./?@#$%^&*_~\"\"\" # remove punctuation https://www.programiz.com/python-programming/examples/remove-punctuation\n no_punct = \"\" # remove punctuation\n for char in line: # remove punctuation\n if char not in punctuations: # remove punctuation\n no_punct = no_punct + char # remove punctuation\n words = line.split(\" \")\n for word in words:\n d[word] = d.get(word, 0) + 1\n return d","def countWords(file_name, start, end):\r\n\r\n with open(file_name, \"r\") as file:\r\n counter_words = 0\r\n\r\n for line in islice(file, start, end):\r\n res = len(line.split())\r\n counter_words += res\r\n\r\n return counter_words","def print_word_freq(file):\n# Opening file to be read\n with open(file, \"r\") as f:\n file_contents = f.read()\n\n\n# # Taking away punctuation and lowercase all words\n word_list = file_contents.lower().replace(',',' ').replace('.',' ').replace('!',' ').split()\n # print(word_list)\n\n nice_list = []\n for word in word_list:\n if word not in STOP_WORDS:\n nice_list.append(word)\n # print(nice_list)\n\n d = {}\n for word in nice_list:\n if word not in d.keys():\n d[word] = 1\n else:\n d[word] += 1 \n # print(sorted(d, key=d.get, reverse=True)\n # sorted(d, key=d.get, reverse=true)\n # print(d)\n\n # for word in sorted(d):\n # print((word, d[word]), end = \" \")\n\n d_filtered = sorted(d, key=d.get, reverse=True)\n for x in d_filtered:\n print(x, d[x])","def countTagsInFile(fname):\n with open(fname, 'r', encoding='utf-8') as f:\n for line in f:\n words = line.split(' ')\n for w in words:\n tag = w.split('_')[1].rstrip()\n cat = tag[0].upper()\n if tag not in dictionaries[cat]:\n dictionaries[cat][tag] = 1\n else:\n dictionaries[cat][tag] += 1","def computeWordsFrequencies(self):\n token_stream = self._tokenize(self.readable)\n token_map = self._countTokens(token_stream)\n # print token_map.items()\n return sorted(token_map.items(), key = lambda x : x[1], reverse = True)","def wordcount(input_file_path):\n\n # Execute word count command on the input file and obtain the output\n result = subprocess.check_output(['wc', input_file_path], stderr=subprocess.STDOUT)\n result = result.decode('utf-8')\n\n # Split the output string into lines, words, and characters\n (lines, words, characters, _) = result.split()\n\n # Create metadata dictionary\n metadata = {\n 'lines': lines,\n 'words': words,\n 'characters': characters\n }\n\n # Store metadata in result dictionary\n result = {\n 'metadata': metadata\n }\n\n # Return the result dictionary\n return result","def count_words(filename):\n\t#store the missing files in a seperate file\n\tnot_found_log = 'text_files\\\\missing_files.txt'\n\t#concatenate the file path\n\tfile_folder = 'text_files\\\\'\n\tfilename = file_folder + filename\n\ttry:\n\t\twith open(filename, encoding='utf-8') as f:\n\t\t\tcontents = f.read()\n\texcept FileNotFoundError:\n\t\twith open(not_found_log, 'a') as file_object:\n\t\t\tfile_object.write(filename + '\\n')\n\telse:\n\t\twords = contents.split()\n\t\twords_count = len(words)\n\t\tprint(f\"The file {filename} has about {words_count} words.\")","def print_word_freq(file):\n with open(file) as text:\n text_string = str(text.readlines())\n text_string = text_string.replace(\",\", \"\")\n text_string = text_string.replace(\".\", \"\")\n text_string = text_string.replace(\"-\", \"\")\n text_string = text_string.replace(\"?\", \"\")\n text_string = text_string.replace(\":\", \"\")\n text_string = text_string.replace(\"'\", \"\")\n text_string = text_string.replace(\"\\\\n\", \"\")\n text_string = text_string.replace(\"[\", \"\")\n text_string = text_string.replace(\"]\", \"\")\n word_list = text_string.split()\n no_stop_words = []\n for word in word_list:\n if word in STOP_WORDS:\n pass\n else: no_stop_words.append(word)\n clean_list = {}\n for word in no_stop_words:\n clean_list[word] = no_stop_words.count(word) \n print(clean_list)","def count_tokens(tokens, filename):\n wordcounts = Counter(tokens)\n #print(wordcounts)\n wordcounts = pd.Series(wordcounts, name=filename)\n #print(wordcounts.head())\n return wordcounts","def count_all_words(file_name):\n\n return len(separate_words(file_name))","def print_word_freq(file):\n \n text_file = open(file, 'r')\n\n contents = text_file.read()\n\n words = contents.split()\n\n def clean_text(text):\n text = text.lower()\n all_letters = \"abcdefghijklmnopqrstuvwxyz\"\n text_to_keep = \"\"\n for char in text:\n if char in all_letters:\n text_to_keep += char\n return text_to_keep\n\n clean_words = []\n\n for word in words:\n clean_words.append(clean_text(word))\n\n go_words = [word for word in clean_words if word not in STOP_WORDS]\n\n word_count = {}\n\n for go_word in go_words:\n word_count.update({go_word: go_words.count(go_word)})\n\n sorted_word_count = sorted(word_count.items(), key=lambda x: x[1], reverse=True)\n\n longest_word_len = len(get_longest_word(words))\n\n for word, value in sorted_word_count[:10]:\n print(word.rjust(longest_word_len), \"|\", str(value).ljust(3), \"*\" * value)","def ReadAndTokenize(filename):\n global CACHE\n global VOCABULARY\n if filename in CACHE:\n return CACHE[filename]\n comment = open(filename).read()\n words = Tokenize(comment)\n\n terms = collections.Counter()\n for w in words:\n VOCABULARY[w] += 1\n terms[w] += 1\n\n CACHE[filename] = terms\n return terms","def readFile(filename):\n listOfWords = []\n currentLine = 1\n f = open(filename, \"r\")\n for line in f:\n line = stripPunctuation(line)\n for word in line.split():\n word = word.lower()\n if len(word) > 1:\n if not word[0].isdigit():\n tempObj = contains(listOfWords, word)\n if tempObj != None:\n tempObj.incOccurrence(currentLine)\n else:\n temp = Word(word, currentLine)\n listOfWords.append(temp)\n currentLine = currentLine + 1\n return listOfWords","def word_tag_counts (count_file):\r\n wordtagcounts = defaultdict(list)\r\n f = open(count_file, 'r')\r\n for line in f:\r\n fields = line.split(\" \")\r\n if fields[1] != 'WORDTAG':\r\n continue\r\n count = int(fields[0].strip())\r\n tag = fields[2].strip()\r\n word = fields[3].strip()\r\n wordtagcounts[word].append((tag, count)) \r\n f.close() \r\n return wordtagcounts","def get_usercounts(self):\n word_counts = defaultdict(int) # {}\n with open(self.filename) as f:\n for line in f:\n if line:\n username, words = self.get_username_words(line) # username1, cat dog\n num_words = len(words.split()) # 1\n word_counts[username] += num_words # {u1: 3, u2: 4, }\n return word_counts","def get_word_freq_output(fname):\n try:\n words = read_words_from_file(fname) # read a list of words from the file\n\n except FileNotFoundError as e:\n return (1, str(e))\n\n else:\n downcased = make_all_lower(words) # transform all of the words to lower case\n punct_filtered = filter_punctuation(downcased) # remove punctuation\n word_filtered = remove_stop_words(punct_filtered) # remove the stop words\n word_counts = count_words(word_filtered) # get a count of all the words in the file\n pretty_word_frequency = get_word_frequency_string(word_counts) # print formatted\n return (0, pretty_word_frequency) # all done!","def build_dict(fname):\n\t\n\twith open(fname) as file:\n\n\t\tword_count_dict = {}\n\n\t\tfor line in file:\n\t\t\tline = line.rstrip()\n\t\t\tline =line.split(' ')\n\t\t\tfor word in line:\n\t\t\t\tword = word.strip('\"!.,?_;():')\n\t\t\t\tword = word.lower()\n\t\t\t\tword_count_dict[word] = word_count_dict.get(word, 0) + 1\n\t\t#return word_count_dict\n\n\t\tfor each in word_count_dict:\n\t\t\tcount = word_count_dict[each]\n\t\t\tprint(each, count)\n\n\t\treturn","def get_frequencies(filename):\n freq_dict = {}\n _,long_name = filename.split(\"\\\\\")\n name,_ = long_name.split(\"_gold_\")\n f = os.path.join(PARSED, name + \".fix.xml\")\n #soup = bs(open(f, 'r'))\n soup = bs(codecs.open(f, 'r', encoding='utf-8'))\n for sent in soup.findAll('sentence'):\n for token in sent.findAll('token'):\n try:\n w = token.word.string\n if w in freq_dict:\n freq_dict[w] += 1\n else:\n freq_dict[w] = 1\n except AttributeError:\n pass\n return freq_dict","def count_words(text):\n\n # Open a file and read the text\n with open(text) as file:\n # Split the file in to a list of words\n words = remove_punctuation(file.read()).split()\n # Create a set of unique words from the list words\n unique_words = {*words}\n\n # For each string in the new list\n for unique_word in unique_words:\n # Count the number of times the word appears\n count = words.count(unique_word)\n # Print the string and the number of times it appears.\n print(f'\"{unique_word.capitalize() }\" appears {count} times.')","def analyzeFile(filename): \n fileData = open(filename, encoding=\"utf-8\") # open the file\n \n counts = {}\n\n for line in fileData:\t\t # iterates over every line of the file\n words = line.split() # turns each line into a list\n for word in words: #iterates over the words in each line list\n word = word.lower().strip(string.whitespace+string.punctuation)\n if len(word) > 0: #make sure word is longer than 0 before adding it to the dictionary\n counts[word] = counts.get(word, 0) + 1 #look up if the dictionary has that word and if not then it'll add that word with the value 0 associated with it and then add one to that, if it has seen it it'll add 1 to the value stored in the counts dictionary\n #when it gets here for the first line it goes back up to the top and repeats for the 2nd line\n mostCommonWord = [word]\n leastCommonWord = [word]\n shortestWord = [word]\n longestWord = [word]\n \n for item in counts:\n if counts[mostCommonWord[0]] < counts[item]:\n mostCommonWord = [item]\n elif counts[mostCommonWord[0]] == counts[item]:\n mostCommonWord.append(item)\n if counts[leastCommonWord[0]] > counts[item]:\n leastCommonWord = [item]\n elif counts[leastCommonWord[0]] == counts[item]:\n leastCommonWord.append(item)\n if len(shortestWord[0]) > len(item):\n shortestWord = [item] \n elif len((shortestWord[0])) == len(item):\n shortestWord.append(item)\n if len(longestWord[0]) < len(item):\n longestWord = [item]\n elif len(longestWord[0]) == len(item):\n longestWord.append(item)\n \n return (mostCommonWord, leastCommonWord, shortestWord, longestWord)","def count_words(self, contents):\n wordCounts = {}\n for i in self.ngramCounts:\n if i == 0: # want the default to be the size of the corpus\n total = 0\n for line in contents:\n words = line.split(\" \")\n words = [ w.strip() for w in words if w] #remove nulls\n for word in words:\n if word:\n total += 1\n wordCounts[i] = defaultdict(lambda: total)\n continue\n else:\n counts = defaultdict(lambda: 0)\n for line in contents:\n words = line.split(\" \")\n words = [ w.strip() for w in words if w] #remove nulls\n for k, word in enumerate(words): \n if k < (i-1) or not word:\n continue\n key = \"\"\n for j in range(k-i+1, k+1):\n key += words[j] + \" \"\n counts[key.strip()] += 1\n wordCounts[i] = counts\n return wordCounts","def count_common_words(filename):\n with open(filename,encoding='utf-8') as f:\n contents = f.read()\n common_words = contents.count('Alice')\n print(common_words)","def load_dictionary(filename):\n\n word_list = []\n freq_sum = 0\n\n # nacitanie zo suboru\n with open(filename) as f:\n for line in f:\n freq, val = line.split()\n word_list.append(Word(int(freq), val))\n freq_sum += int(freq)\n\n # lexikograficke usporiadanie slov\n word_list_sorted = sorted(word_list, key=operator.attrgetter('value'))\n\n return word_list_sorted, freq_sum","def frequency(text):\n # TODO: change function input to a textfile?\n import collections\n freq = collections.Counter(text)\n # print freq\n return freq","def get_frequency_list():\n freqs = {}\n file = get_or_download_wordlist_file()\n for line in file:\n word, freq = line.split()\n freqs[word] = int(freq)\n return freqs","def get_counts(data):\n\n word_count = {}\n syll_count = {}\n\n infile = data.corpus\n try:\n\n open_file = codecs.open(infile, 'r', encoding='utf-16')\n for line in open_file:\n line = line.lower()\n # Remove tablet indexing info and line numbers. Grab only text data\n line = line.split(',')\n text = clean_line(line[7])\n\n # Update the occurrences of the words in the line\n for word in text.split():\n count = word_count.setdefault(word, 0)\n word_count[word] = count + 1\n\n # Track occurrences of syllables\n update_syllable_count(word, syll_count)\n\n open_file.close()\n except IOError:\n print(\"Cannot open: \" + infile)\n\n return (word_count, syll_count)","def mapWordsFrequencies(self):\n token_stream = self._tokenize(self.readable)\n token_map = self._countTokens(token_stream)\n return token_map","def tag_counts (count_file):\r\n tagcounts = defaultdict(int)\r\n f = open(count_file, 'r')\r\n for line in f:\r\n fields = line.split()\r\n if fields[1] != 'WORDTAG':\r\n continue\r\n count = int(fields[0])\r\n tag = fields[2]\r\n tagcounts[tag] += count \r\n f.close() \r\n return tagcounts","def print_word_freq(file):\n with open(file) as text:\n text = text.read().lower()\n text = text.replace(\"\\n\", \" \")\n text = text.replace(\"’\", \"\")\n # text = \" \".join(text.split())\n # print(text)\n for character in string.punctuation:\n text = text.replace(character, \"\")\n word_list = text.split()\n clean_list = []\n for word in word_list:\n if word not in STOP_WORDS:\n clean_list.append(word)\n \n\n # for stop_word in STOP_WORDS:\n # if stop_word in word_list:\n # word_list.remove(stop_word)\n\n\n new_dict = {}\n for word in clean_list:\n new_dict[word] = clean_list.count(word)\n sorted_dict = sorted(new_dict.items())\n print(sorted_dict)\n\n # print(f\"{key} | {value} {'*' * value}\")\n\n \n # for stop_word in STOP_WORDS:\n # text = text.replace(stop_word, \"\")\n\n # for word in word_list:\n # if word in string.punctuation:\n # #do something\n # if word in STOP_WORDS:\n\n \n # for stop_word in STOP_WORDS:\n # text = text.replace(stop_word, \"\")\n # print(text)","def cnt_freq(filename):\n freq = [0] * 256\n try:\n f_in = open(filename,'r')\n except:\n raise FileNotFoundError\n for line in f_in:\n for char in line:\n freq[ord(char)] = freq[ord(char)] + 1\n f_in.close()\n return freq","def print_word_freq(file):\n # with open(file, 'r') as text the r as the second arguement means that my intentions are to read the file\n with open(file, 'r') as text:\n # this reads the entire file and puts this into text string\n text_string = text.read()\n # returns the string respresentation of text string without removing special characters so you can see what you need to remove\n # print(repr(text_string))\n # this removes the specified characters from the text string\n text_string = text_string.replace(\",\", \"\")\n text_string = text_string.replace(\".\", \"\")\n text_string = text_string.replace(\"—\", \" \")\n text_string = text_string.replace(\"-\", \" \")\n text_string = text_string.replace(\"?\", \"\")\n text_string = text_string.replace(\":\", \"\")\n text_string = text_string.replace(\"'\", \"\")\n text_string = text_string.replace(\"\\\\n\", \"\")\n text_string = text_string.replace(\"’\", \"\")\n text_string = text_string.replace(\"]\", \"\")\n text_string = text_string.replace(\"[\", \"\")\n text_string = text_string.replace(\"\\\"\", \"\")\n # takes the text string and makes all the characters lower case\n text_string = text_string.lower()\n # takes the text string and splits all the words into a list this splits from space to space\n words_list = text_string.split()\n # a dictionary is a key and a value\n no_stop_words = {}\n # for loop that will cycle through the words list\n for word in words_list:\n # checking to see if the word is stop words\n if word not in STOP_WORDS:\n # if the word is already in the dictionary no stop words increment the value by 1\n if word in no_stop_words:\n no_stop_words[word] += 1\n # if the word is not in the dictionary no stop words add this to the dictionary and give it a value of 1\n else:\n no_stop_words[word] = 1\n \n sorted_dict = {}\n sorted_keys = sorted(no_stop_words, key=no_stop_words.get, reverse=True)\n \n for w in sorted_keys:\n sorted_dict[w] = no_stop_words[w]\n \n for key in sorted_dict:\n print(f\"{key:>15} | {sorted_dict[key]:2} {'*' * sorted_dict[key]}\")\n \n # good practice to ensure that we are properly closing the file in use at the end of the function\n text.close()","def cnt_freq(filename):\r\n counts = [0] * 256\r\n fp_file = open(filename, \"r\")\r\n lines = fp_file.readlines()\r\n for i in lines:\r\n for j in i: # count every letter in the line\r\n counts[ord(j)] += 1 # counts[ord(j)] + 1\r\n counts[0] = 1\r\n fp_file.close()\r\n return counts","def count_word(filename, word):\r\n try:\r\n with open(filename) as file_object:\r\n contents = file_object.read()\r\n word_count = contents.lower().count(word) \r\n except FileNotFoundError:\r\n print(filename + \" cannot be located.\")\r\n else:\r\n message = filename + \" has the word \" + \"'\" + word + \"' in it \" \r\n message += str(word_count) + \" times.\"\r\n print(message)","def _count_words_in_file(self, words: List[str]) -> Dict[str, int]:\n files_found_by_word = {}\n for word in words:\n found_files_with_word = self._db_ranking.query_by_word(word)\n for filename in found_files_with_word:\n if filename not in files_found_by_word:\n files_found_by_word[filename] = 0\n files_found_by_word[filename] = files_found_by_word[filename] + 1\n\n return files_found_by_word","def print_word_freq(file):\n opened_file = open(file)\n text = opened_file.read()\n #print(text)\n #replace hyphens\n no_hyphen = text.replace(\"-\",\" \")\n #remove punctuation\n no_punctuation = \"\"\n for char in no_hyphen:\n if char not in punctuation:\n no_punctuation = no_punctuation + char\n #make everything lowercase\n lower_case_text = no_punctuation.lower()\n #print(lower_case_text)\n #split into words\n all_words = lower_case_text.split()\n #print(all_words)\n #remove stop words\n no_stop_words = []\n for each_word in all_words:\n if each_word not in STOP_WORDS:\n no_stop_words.append(each_word)\n #print(no_stop_words)\n #find the longest word to use for indention purposes\n word_length = 0\n for word in no_stop_words:\n if len(word) > word_length:\n #print (word, len(word))\n word_length = len(word)\n #print (word_length)\n #count remaining word usage\n word_counts = {}\n for word in no_stop_words:\n if word in word_counts:\n word_counts[word] +=1\n else: word_counts[word] = 1\n #print (word_counts)\n #sort words by frequency\n ordered_by_freq = (sorted(word_counts.items(), key=lambda seq: seq[1], reverse=True))\n #print (ordered_by_freq)\n #print words, freq, graph, indent, and add a space past the pipe for values less than 10\n for key, value in ordered_by_freq:\n indent = (word_length + 1 - len(key))\n space = \" \"\n star = \"*\"\n if value >= 10:\n print (indent * space, key, \" | \", value, value * star)\n else:\n print (indent * space, key, \" | \", value, value * star)\n \n\n \n \n\n \n\n \n\n\n\n #remove the stop words\n #count the frequency of the remaing words (see ex 6 for sort function)\n #output as a cord list, count and graph of *** (ex 7 for justify)","def wc(file_):\r\n with open(file_) as f:\r\n file = f.read().strip()\r\n char_nums = len(file)\r\n lines = file.split('\\n')\r\n line_nums = len(lines)\r\n word_nums = 0\r\n for line in lines:\r\n words = line.split()\r\n word_nums += len(words)\r\n return f'{line_nums} {word_nums} {char_nums} {file_}'","def word_frequencies(word_list: TextIO) -> dict:\n words = word_list.read().split(' ')\n amount_of_words = len(set(words))\n frequencies = {}\n for index, word in enumerate(words):\n clean_word = remove_punctuation(word)\n if clean_word not in frequencies:\n frequencies[clean_word] = (index + 1) / amount_of_words\n del frequencies[\"\"]\n return frequencies","def word_frequencies(corpus):\n return frequencies(corpus, 1, to_lower=True)","def analyze_text(filename):\n with open(filename, mode='r') as f:\n lines = 0\n words = 0 \n chars = 0\n for line in f:\n lines += 1\n words += len(line.split())\n chars += len(line)\n return (lines, words, chars)","def countWords(f, ext):\n\n word_count = 0\n if ext == \".xml\":\n # Parse with lxml\n tree = lxml.etree.parse(f)\n root = tree.getroot()\n # Get the text of all tags.\n if root is not None:\n text = root.xpath(\"//text()\")\n else:\n return word_count\n # Join the text together.\n text = \" \".join(text)\n # Split the text into words.\n words = text.split(\" \")\n # Remove empty strings.\n words = [w for w in words if w != \"\"]\n # Remove words that are just numbers.\n words = [w for w in words if not w.isnumeric()]\n # Remove one-letter words\n words = [w for w in words if len(w) > 1]\n # Count the words\n word_count = len(words)\n # Subtract off the number of child tags from the root.\n word_count = word_count - len(root.getchildren()) - 1\n\n elif ext == \".html\":\n # Parse the file with BeautifulSoup.\n soup = BS(f, \"html.parser\")\n # Get the text of all tags.\n text = soup.get_text()\n # Split the text into words.\n words = text.split(\" \")\n # Remove empty strings.\n words = [w for w in words if w != \"\"]\n # Remove words that are just numbers.\n words = [w for w in words if not w.isnumeric()]\n # Remove one-letter words\n words = [w for w in words if len(w) > 1]\n # Count the words\n word_count = len(words)\n\n elif ext == \".md\" or ext == \".srt\":\n for line in f:\n # Skip blank lines.\n if len(line) == 0 or line == \"\\n\" or line == \"\\r\":\n continue\n # Check for SRT time lines and skip them.\n if re.search(\"\\d\\d --> \\d\\d:\", line):\n continue\n # Skip lines that are just a single number.\n if re.search(\"^\\d+$\", line):\n continue\n # Check for lines that are just times and skip them.\n if re.search(\"^\\d\\d:\\d\\d$\", line):\n continue\n if re.search(\"^\\d\\d:\\d\\d:\\d\\d$\", line):\n continue\n\n raw_words = line.split(\" \")\n reduced_words = []\n for w in raw_words:\n # Don't include 1-character \"words\"\n if len(w) > 1:\n reduced_words.append(w)\n\n # Store filename and count\n word_count += len(reduced_words)\n\n # Sometimes the word count is negative. I don't know why.\n if word_count < 0:\n word_count = 0\n return word_count","def word_frequency(words):\r\n frequency = {}\r\n for w in words:\r\n frequency[w] = frequency.get(w, 0) + 1\r\n return frequency","def parse(filename, case_sensitive=False, sort=False):\n\n text = _read(filename)\n\n # If case_sensitive is true we make the text all lower case.\n if not case_sensitive:\n text = text.lower()\n\n # Note: we here process a word as being anything with\n # A-Z, a-z, 0-9, or any unicode characters in the \n # range 00c00-u02b08 which is a number of weird characters\n # not normally used in English. The range was found by manually\n # looking through the table located at\n # https://unicode-table.com/en/#ipa-extensions\n # for some common vowels that occur in other languages.\n # The motivation for this was in processing moby-dick.txt\n # in the examples where â was being misinterpreted as \n # a word boundary by the re module.\n words = re.findall(r'\\w*[\\'-\\u00c00-u02b08]*\\w', text)\n\n frequency_dict = {word: 0 for word in words}\n # Do it this way rather than using count, because it avoids\n # doing len(words) lookups over the whole text.\n for word in words:\n frequency_dict[word] += 1\n\n if sort:\n # Sort the dictionary by the values. Dictionarys are ordered in Python\n # 3.6 and above but that is not the case for old versions where you\n # must use collections.OrderedDict.\n frequency_dict = sort_dict(frequency_dict)\n\n return frequency_dict","def count_words(path, max_vocab_size=40000, tok=False):\n counts = collections.Counter()\n for words in read_file(path, tok):\n for word in words:\n counts[word] += 1\n\n vocab = [word for (word, _) in counts.most_common(max_vocab_size)]\n return vocab","def frequency(self, path, filemoving, parser):\n root = parser.parsing_xml(path, filemoving)\n root_tag = root.tag[0:(root.tag.find('}') + 1)]\n list_of_words = []\n for i in root.iter(root_tag + 'p'):\n if str(type(i.text)) == \"<class 'str'>\":\n for word in i.text.split():\n alphanumeric_filter = filter(str.isalnum, word)\n alphanumeric_string = \"\".join(alphanumeric_filter)\n list_of_words.append(alphanumeric_string)\n dict_of_frequency = collections.Counter(list_of_words)\n return dict_of_frequency","def get_dict(fname):\n out_set, tot_count = {}, 0\n with open(fname, 'r') as fid:\n word_arr = fid.read().split('\\n')\n for ele in word_arr:\n if len(ele) > 0:\n out_set[(ele.split()[0])] = tot_count\n tot_count += 1\n return out_set","def word_frequency( tokenized, dic ):\n print( 'computing word frequencies' )\n start = time.time()\n for i, text in enumerate( tokenized ):\n for token in text:\n if token not in dic:\n dic[ token ] = 1\n else:\n dic[ token ] += 1\n if i % 10000 == 0:\n sys.stdout.write( '\\rprocessed : {}/{} reviews in {}s'.format( i, NO_REVIEWS, time.time() - start ) )\n sys.stdout.write( '\\rprocessed : {}/{} reviews in {}s\\n'.format( i, NO_REVIEWS, time.time() - start ) )","def word_frequency(words):\n freq = {}\n for w in words:\n cur_word = w.lower().strip(punctuation)\n freq[cur_word] = freq.get(cur_word, 0) + 1\n return freq","def word_frequencies(url):\n\ttexts = get_all_texts(url)\n\tcount = count_words_in_sentence_list(texts)\n\treturn count","def get_vocabulary(text_fname, vocab_fname):\n with codecs.open(text_fname,'r','utf-8') as infile, \\\n codecs.open(vocab_fname,'w','utf-8') as outfile: \n\n count_map={}\n for line in infile:\n sent=line.strip().split(' ')\n for w in sent:\n count_map[w]=count_map.get(w,0.0)+1.0\n\n for w,c in count_map.iteritems(): \n outfile.write(u'{}|{}\\n'.format(w,c))","def main():\n wf = WordFrequencies()\n tokens = wf.tokenize(sys.argv[1])\n occurrences = wf.computeWordFrequencies(tokens)\n wf.print(occurrences)","def _read_leipzig_word_counts_file(self, leipzig_word_counts_path):\n self._background_word_counts = defaultdict(int)\n self._background_lowercased_word_counts = defaultdict(int)\n with open(leipzig_word_counts_path, mode='rt') as word_count_file:\n for line in word_count_file.readlines():\n splits = line.strip().split('\\t')\n assert len(splits) == 4\n WORD_INDEX = 1\n FREQUENCY_INDEX = 3\n frequency = int(splits[3])\n self._background_word_counts[splits[1]] = frequency\n self._background_lowercased_word_counts[splits[1].lower()] += frequency","def get_number_of_words(self):\n filename = f'{self.path}/{self.filename}'\n # word_counter = {}\n # w_cnt = 0\n # x = 0\n file = open(filename, 'r', encoding='utf-8')\n data = file.read()\n head, sep, tail = data.partition('<binary')\n head = re.sub('\\\\s\\\\s*', ' ', (re.sub('\\\\W|\\\\d', ' ', re.sub('<.*?>', '', head))))\n word_list = head.split()\n # for word in word_list:\n # w_cnt += 1\n # if word not in word_counter:\n # word_counter[word] = 1\n # else:\n # word_counter[word] = word_counter[word] + 1\n\n # for word in word_list:\n # x += 1\n # print(word, word.isalpha(), x)\n\n w_cnt = sum([a[0].isalpha() for a in word_list])\n sqlite_for_ht.CreateTable.update_table(f_1, self.filename, 'number_of_words', w_cnt)\n print(datetime.now(), '-', 'number_of_words for', self.filename, 'calculated =', w_cnt)\n return None","def count_words(all_lines):\n words = {}\n for line in all_lines:\n for word in line:\n if word in words:\n words[word] += 1\n else:\n words[word] = 1\n\n new_words = sorted(words.items(), key=operator.itemgetter(1), reverse=True)\n\n return [item[0] for item in new_words]","def find_freq_words(words):\n word_list = [1 for line in f if words in line]\n return reduce(lambda x,y: x+1 if y==1 else x, word_list) # x takes on the type of the elements in the array","def load_input(path):\n counts = defaultdict(int)\n if not os.path.exists(mode+'indices.p'):\n root = '/'.join(path.split('/')[0:-1])\n all_paths = [root+'/'+x for x in os.listdir(root)] #'/'.join(path.split('/')[0:-1]))\n else:\n all_paths = [path]\n \n for path in all_paths:\n print(path)\n with open(path) as f:\n if mode == 'word':\n words = tokenize(f.read())\n else:\n words = f.read()\n\n for word in words:\n counts[word] += 1 \n\n words = [x for x in words if len(x) > 0]\n return words, counts","def count_word_instances_in_file(file_name, target_word):\n\n\tcount = 0\n\twords = get_words_in_file(file_name)\n\tfor word in words:\n\t\tif target_word == word:\n\t\t\tcount += 1\n\treturn count","def read_counts(counts_file):\n try:\n fi = open(counts_file, 'r')\n except IOError:\n sys.stderr.write('ERROR: Cannot open %s.\\n' % counts_file)\n sys.exit(1)\n\n for line in fi:\n fields = line.strip().split(' ')\n yield fields # yields a list of fields","def wc(filename):\n\n\n # holds number of characters, words and lines in the file\n lines = 0\n words = 0\n char = 0\n try: # if the file does not exist\n file = open(filename)\n for line in file: # goes through file\n lines += 1\n wordList = line.split()\n words += len(wordList)\n for el in wordList: # this way I only count characters without \" \"(spaces)\n char += len(el)\n file.close()\n except Exception as e:\n print(e)\n lines, words, char = 404, 404, 404\n\n # prints out only if there was a right file name\n print(f\"{lines} {words} {char} {filename}\")","def count_word(self, most_num):\n with open(self.file_name, 'r') as f:\n data = f.read().lower()\n # characters and single quote not split\n words = re.split(r'[^\\w\\']+', data)\n logging.debug(words)\n most_cnts_words = Counter(words).most_common(most_num)\n print(most_cnts_words)","def load_word_freq(self, file_path):\n\n # initialise frequency dict\n # freq = {i: {} for i in range(1,9)}\n freq = {1: {}}\n\n # read csv file\n with open(file_path, 'r', encoding=co.OUT_ENCODING[self.language]) as f:\n reader = csv.reader(f, delimiter=',')\n\n # skip header\n next(reader)\n\n # iterate through csv and add values to dictionary\n for row in reader:\n try:\n # freq[int(row[3])][row[0]] = int(row[1])\n freq[1][row[0]] = int(row[1])\n except ValueError:\n pass\n\n return freq","def _count_word_frequency(self, data):\n _dict = {}\n for _docs in data:\n for _word in _docs:\n if _word in _dict:\n _dict[_word] += 1\n else:\n _dict[_word] = 1\n return _dict","def freq(word, document):\n return document.split(None).count(word)","def get_frequencies(tokens):\n cnt = {}\n\n for word in tokens:\n if word not in cnt:\n cnt[word] = 0\n\n cnt[word] += 1\n\n return cnt","def main ():\n fio = FileIo(\"../input2.txt\")\n text = fio.getInput()\n p = re.compile(r'#?\\d[\\s\\.]?[\\s]?')\n out = filter(None, p.split(text))\n #print out[2]\n #print len(out)\n wc = 0\n\n for s in out:\n text = nltk.word_tokenize(s)\n wc += wordCount( text )\n print wc","def frequencies(filename):\n\n hashtable = QuadraticProbeTable()\n file = open(filename,'r')\n words = []\n\n for item in file:\n item = item.strip('\\n')\n if item not in hashtable:\n hashtable[item] = 1\n words.append(item)\n else: hashtable[item] = hashtable[item] + 1\n\n file = open('FREQUENCY.txt', 'w')\n words = heap_sort(words)\n for item in words: file.write(item + ' ' + str(hashtable[item]) + '\\n')","def main():\n filename = input('filename?\\n')\n print(report_distribution(count_words(filename)))","def count(self):\n freq = {}\n\n for desc in self.words:\n if desc in freq:\n freq[desc] += 1\n else:\n freq[desc] = 1\n\n return freq"],"string":"[\n \"def count_words(filename):\",\n \"def word_count_2(filename):\\n\\n with open(filename) as file_:\\n # read file and lowercase all words\\n words = file_.read().lower()\\n # use translate to remove punc\\n words = words.translate(None, string.punctuation)\\n # call counter to count on split owrds\\n word_counts = Counter(words.split())\\n\\n # print out items using iteritems (display, doesn't creat list) \\n for word, count in word_counts.iteritems():\\n print \\\"{} {}\\\".format(word, count)\\n\\n return word_counts\",\n \"def countWords(words, filename):\\n\\ttry:\\n\\t\\tfile = codecs.open(filename, \\\"r\\\", \\\"utf8\\\")\\n\\t\\ttokens = [ string.strip(string.lower(i)) for i in file.read().split() ]\\n\\t\\tfor i in tokens:\\n\\t\\t\\twords[i] = words.get(i, 0) + 1\\n\\t\\tfile.close()\\n\\texcept IOError:\\n\\t\\tprint \\\"Cannot read from file:\\\", filename\\n\\treturn words\",\n \"def countWords(filename):\\n with open(filename) as f:\\n filetext = f.read()\\n #words = re.findall(r'\\\\w+', filetext)\\n words = re.findall(r'[a-zA-Z]+', filetext)\\n return Counter(words)\",\n \"def word_frequency_in_file(filename):\\n words = {}\\n fin = open(filename)\\n punctuation = string.punctuation\\n for line in fin:\\n line = line.translate( # Replace punctuation with spaces\\n str.maketrans(punctuation, ' ' * len(punctuation)))\\n line = line.lower()\\n line_words = line.split()\\n for word in line_words: # Process each word in the line.\\n if word in words:\\n words[word] += 1\\n else:\\n words[word] = 1\\n return words\",\n \"def word_count(filename):\\n \\n word_counts = {}\\n\\n with open(filename) as file_:\\n for line in file_:\\n # strip white space\\n words = line.split()\\n # iterate over words and strip excess punctutation then add to dict\\n for word in words:\\n word = word.strip(\\\",.\\\\\\\";:?_!\\\").lower()\\n word_counts[word] = word_counts.get(word, 0) + 1\\n\\n # print list of words and count\\n for word, count in word_counts.iteritems():\\n print \\\"{} {}\\\".format(word, count)\",\n \"def get_word_count(file_name):\\n\\n my_file = open(file_name)\\n word_count = {}\\n\\n for line in my_file:\\n stripped_line = line.rstrip()\\n line_list = stripped_line.split(' ')\\n line_list = [word.lower() for word in line_list]\\n\\n for word in line_list:\\n word_count[word] = word_count.get(word, 0) + 1\\n\\n for word_in_count, count in word_count.iteritems():\\n print \\\"{} {}\\\".format(word_in_count, count)\\n\\n my_file.close()\\n # return word_count\",\n \"def count_words(filename):\\n # create a dictionary\\n my_dict = {}\\n with open(filename, 'r') as f:\\n text = f.read()\\n ''' fine, I have to use his method\\n _words = text.split()\\n # remove not alpha num bs\\n # not gonna use anything fancy \\n words = []\\n for s in _words:\\n w = \\\"\\\"\\n for char in s:\\n if char.isalpha():\\n w += char\\n words.append(w.lower())\\n '''\\n words = extract_words(text)\\n \\n for word in words:\\n if word in my_dict:\\n my_dict[word] += 1\\n else:\\n my_dict[word] = 1\\n\\n # open the file and read the text\\n # extract each word in the file\\n # count the number of times each word occurs.\\n # return the dictionary with the word count.\\n return my_dict\",\n \"def get_word_frequency():\\n counter = Counter()\\n with open('resource/word-count.txt', encoding=\\\"utf8\\\") as f:\\n for line in f.readlines():\\n try:\\n word, count = line.split(':')\\n if (word == \\\"RT\\\"):\\n continue\\n count = int(count)\\n counter[word] += count\\n except Exception as e:\\n continue\\n return counter\",\n \"def word_counts(file):\\n words = defaultdict(int)\\n regex = re.compile('[' + string.punctuation + ']')\\n for line in open(file):\\n for word in [regex.sub('', w) for w in line.lower().split()]:\\n words[word] += 1\\n\\n return words\",\n \"def parse_file(input_file):\\n # Automatically close the file after being used\\n with open(input_file) as text:\\n # Read file and split each word into an element in a list\\n data = text.read().split()\\n\\n # Sort the list\\n # Python sort automatically does lexical sorting\\n data.sort()\\n\\n # For each word, use as Dictionary key and count the occurrences of the word and use as value\\n frequency_table = {word: data.count(word) for word in data}\\n\\n # Return the frequency table\\n return frequency_table\",\n \"def count_words(filename):\\n\\ttry:\\n\\t\\twith open(filename, encoding='utf-8') as f_obj:\\n\\t\\t\\tcontents = f_obj.read()\\n\\texcept FileNotFoundError:\\n\\t\\tmsg = \\\"Sorry, the file \\\" + filename + \\\" does not exist.\\\"\\n\\t\\tprint(msg)\\n\\telse:\\n\\t\\t# Count the approximate number of words in the file.\\n\\t\\twords = contents.split()\\n\\t\\tnum_words = len(words)\\n\\t\\tprint(\\\"The file \\\" + filename + \\\" has about \\\" + str(num_words) + \\\" words.\\\")\",\n \"def count_words(filename):\\n try:\\n with open(filename, encoding='utf-8') as f:\\n contents = f.read()\\n except FileNotFoundError:\\n pass\\n else:\\n words = contents.split()\\n num_words = len(words)\\n print(f\\\"The file {filename} has about {num_words} words.\\\")\\n\\n #10-10\",\n \"def word_count(input_file, word_freq=None):\\n if word_freq is None:\\n word_freq = collections.defaultdict(int)\\n\\n for l in input_file:\\n for w in l.strip().split():\\n word_freq[w] += 1\\n\\n return word_freq\",\n \"def read_words(f, words):\\n with open(f) as file:\\n for line in file:\\n w = tokenizer.tokenize(line.strip())\\n for word in w:\\n try:\\n words[word] += 1\\n except:\\n words[word] = 1\",\n \"def word_count(filename):\\n try:\\n with open(filename) as f_obj:\\n content = f_obj.read()\\n except FileNotFoundError:\\n print('This file ' + filename + ' is not exist.')\\n else:\\n word = content.split()\\n print('word counts: ' + str(len(word)))\",\n \"def collect_frequencies(nameoffile):\\n with open(nameoffile) as text:\\n list_of_words = []\\n for line in text:\\n words = line.split()\\n list_of_words = list_of_words + words\\n list_of_words = [word.lower() for word in list_of_words]\\n\\n dict = Counter(list_of_words)\\n print(dict)\\n return dict\",\n \"def wc(filename):\\n f = open(filename, 'rt')\\n data = f.readlines()\\n f.close()\\n word_count_tot = 0\\n for s in data:\\n words = s.split()\\n word_count = len(words)\\n word_count_tot = word_count_tot+word_count\\n return word_count_tot\",\n \"def count_words_in_file(file_name):\\n\\n\\treturn len(get_words_in_file(file_name))\",\n \"def count_words(filename):\\n try:\\n with open(filename) as file_object:\\n contents = file_object.read()\\n except FileNotFoundError:\\n message = \\\"Sorry, the file \\\" + filename + \\\" does not exist.\\\"\\n print(message)\\n else:\\n # Count approximate number of words in the file.\\n words = contents.split()\\n number_words = len(words)\\n print(\\\"The file \\\" + filename + \\\" has about \\\" +\\n str(number_words) + \\\" words.\\\")\",\n \"def get_word_freq(filein):\\n freq = {}\\n\\n # Open file handles with context manager\\n with open(filein) as f:\\n\\n # Read a single line at a time so as not to crush memory\\n for line in f:\\n\\n # Tokenize and iterate\\n for word in line.split():\\n\\n # Use try/except instead of if/then for performance\\n # Likely after the first 1M tweets that the key will be contained\\n try:\\n freq[word] += 1\\n except KeyError:\\n freq[word] = 1\\n\\n return freq\",\n \"def counting_words(filename):\\n try:\\n with open(filename) as f_object:\\n poll_results = f_object.read()\\n except FileNotFoundError:\\n message = 'Sorry, this file does not exist!'\\n print(message)\\n else:\\n words = poll_results.split()\\n # this sections each of the words in the file and stores it in a list.\\n num_words = len(words)\\n print(\\\"This file has \\\" + str(num_words) + \\\" words.\\\")\",\n \"def count_words(filename):\\n try:\\n with open(filename) as f_obj:\\n contents = f_obj.read()\\n except FileNotFoundError:\\n # msg = \\\"Sorry, the file \\\" + filename + \\\" does not exist.\\\"\\n # print(msg)\\n pass\\n else: \\n words = contents.split()\\n num_words = len(words)\\n print(\\\"The file \\\" + filename + \\\" has about \\\" + str(num_words) + \\\" words.\\\")\",\n \"def word_count():\\n word_counter = Counter()\\n\\n # read files and count words\\n for file_path in Path(INPUTS_PATH).rglob(\\\"*\\\"):\\n if file_path.is_file():\\n print(f\\\"Processing input file: {file_path.as_posix()}\\\")\\n word_counter += Counter(file_path.read_text().split())\\n\\n # write the result to OUTPUTS_PATH\\n output_file = Path(OUTPUTS_PATH) / \\\"output.txt\\\"\\n with output_file.open(\\\"w\\\") as f:\\n for word, count in word_counter.most_common():\\n f.write(f\\\"{word}: {count}\\\\n\\\")\\n print(f\\\"Generated output file: {output_file.as_posix()}\\\")\",\n \"def count_words(filename):\\n\\ttry:\\n\\t\\twith open(filename, encoding = \\\"utf-8\\\") as f_odj:\\n\\t\\t\\tcontents = f_odj.read()\\n\\texcept FileNotFoundError:\\n\\t\\tmsg = \\\"Sorry, the file \\\" + filename + \\\" does not exist.\\\"\\n\\t\\tprint(msg)\\n\\telse:\\n\\t\\twords = contents.split()\\n\\t\\tnum_words = len(words)\\n\\t\\tprint(\\\"The file \\\" + filename + \\\" has about \\\" + str(num_words) + \\n\\t\\t\\t\\\" words.\\\")\",\n \"def calculate_frequencies(file_contents):\\n\\n # list of uninteresting words\\n uninteresting_words = [\\\"the\\\", \\\"a\\\", \\\"to\\\", \\\"if\\\", \\\"is\\\", \\\"it\\\", \\\"of\\\", \\\"and\\\", \\\"or\\\", \\\"an\\\", \\\"as\\\", \\\"i\\\", \\\"me\\\", \\\"my\\\", \\\\\\n \\\"we\\\", \\\"our\\\", \\\"ours\\\", \\\"you\\\", \\\"your\\\", \\\"yours\\\", \\\"he\\\", \\\"she\\\", \\\"him\\\", \\\"his\\\", \\\"her\\\", \\\"hers\\\", \\\"its\\\", \\\"they\\\", \\\"them\\\", \\\\\\n \\\"their\\\", \\\"what\\\", \\\"which\\\", \\\"who\\\", \\\"whom\\\", \\\"this\\\", \\\"that\\\", \\\"am\\\", \\\"are\\\", \\\"was\\\", \\\"were\\\", \\\"be\\\", \\\"been\\\", \\\"being\\\", \\\\\\n \\\"have\\\", \\\"has\\\", \\\"had\\\", \\\"do\\\", \\\"does\\\", \\\"did\\\", \\\"but\\\", \\\"at\\\", \\\"by\\\", \\\"with\\\", \\\"from\\\", \\\"here\\\", \\\"when\\\", \\\"where\\\", \\\"how\\\", \\\\\\n \\\"all\\\", \\\"any\\\", \\\"both\\\", \\\"each\\\", \\\"few\\\", \\\"more\\\", \\\"some\\\", \\\"such\\\", \\\"no\\\", \\\"nor\\\", \\\"too\\\", \\\"very\\\", \\\"can\\\", \\\"will\\\", \\\"just\\\"]\\n \\n # Dictionary to store frequencies\\n frequencies = {}\\n\\n # Split the contents into words\\n file_contents = file_contents.split()\\n\\n # loop through every word\\n for line in file_contents:\\n # Contatenate every word\\n words = ''.join(w for w in line if w.isalpha())\\n # Check if word is not a uninetersting_words\\n if words.lower() not in uninteresting_words:\\n # Get the number of occurences\\n frequencies[words.lower()] = frequencies.get(words, 0) + 1\\n\\n # returns the frequencies from words\\n return frequencies\",\n \"def count_words(filename):\\n\\ttry:\\n\\t\\twith open(filename, encoding = \\\"utf-8\\\") as f_odj:\\n\\t\\t\\tcontents = f_odj.read()\\n\\texcept FileNotFoundError:\\n\\t\\tpass #this command tells python to print nothing when a command fails.\\n\\telse:\\n\\t\\twords = contents.split()\\n\\t\\tnum_words = len(words)\\n\\t\\tprint(\\\"The file \\\" + filename + \\\" has about \\\" + str(num_words) + \\n\\t\\t\\t\\\" words.\\\")\",\n \"def get_file_counts(filename):\\n new_file = open(filename, \\\"r\\\")\\n d = dict()\\n for line in new_file: \\n split_line = line.split()\\n for word in split_line:\\n if word in d:\\n d[word] += 1\\n else:\\n d[word] = 1\\n new_file.close()\\n return d\",\n \"def load_word_counts(filename):\\n raw_rows = csv_rows(filename)\\n word_counts = defaultdict(lambda: 0)\\n\\n for line_number, raw_row in enumerate(raw_rows, 2):\\n count = int(raw_row[\\\"count\\\"])\\n ipa = raw_row[\\\"IPA\\\"]\\n if '*' in ipa:\\n continue\\n\\n # Fixes random badness.. hopefully doesn't hide anything?\\n mod_ipa = ipa.replace('(', '').replace(')', '')\\n\\n # Work around a passage with an error in it:\\n gloss = raw_row[\\\"Gloss\\\"] or raw_row[\\\"Text\\\"]\\n\\n category = raw_row[\\\"Category\\\"]\\n\\n skipword_characters = {'?'}\\n try:\\n for i, g in izip(mod_ipa.split('/'), gloss.split('/')):\\n word = make_word(i, g, category)\\n word_counts[word] += count\\n except WordParseError as e:\\n print (u\\\"Error on line %d: %s [%s || %s]\\\" %\\n (line_number, repr(e), ipa, gloss)).encode('utf-8')\\n except IndexError as e:\\n unknown_index = e.args[0]\\n if unknown_index in skipword_characters:\\n print (u\\\"Bad char on line %d: %s [%s || %s]\\\" %\\n (line_number, repr(e), ipa, gloss)).encode('utf-8')\\n else:\\n print \\\"FATAL ERROR ON LINE %d\\\" % line_number\\n raise\\n except:\\n print \\\"FATAL ERROR ON LINE %d\\\" % line_number\\n raise\\n return word_counts\",\n \"def word_frequency_from_file(cls, filename, monocase = False, pretty_print=False):\\n\\n # variable declarations\\n all_words = [] # holds all the words\\n word_pattern = r'[a-zA-Z]+'\\n\\n # file reading and regex logic\\n with open(file=filename) as f:\\n for line in f: # reading one line at a time\\n match = re.findall(word_pattern, line)\\n if match: # bingo\\n if monocase:\\n all_words += [x.lower() for x in match] # converting all to lowercase and appending to list\\n else:\\n all_words += match\\n\\n # converting all_words list to frequencies\\n result = defaultdict(int)\\n for word in all_words:\\n result[word] += 1\\n\\n # del all_words\\n del all_words\\n\\n if pretty_print:\\n WordAnalysis.__pretty_print_word_frequency(result)\\n return result\",\n \"def count_words(filename):\\n try:\\n with open(filename) as f_obj:\\n contents = f_obj.read()\\n except FileNotFoundError:\\n msg = \\\"sorry, \\\" + filename + \\\" does not exist\\\"\\n print(msg)\\n else:\\n words = contents.split()\\n num_words = len(words)\\n print(\\\"The words'number is \\\" + str(num_words))\",\n \"def print_wordcount(file_to_count):\\n wordcount_dict = {}\\n file_string = open(file_to_count).read()\\n words = file_string.rstrip().split()\\n \\n for word in words:\\n if word in wordcount_dict:\\n value = wordcount_dict.get(word)\\n value += 1\\n wordcount_dict[word] = value\\n else:\\n wordcount_dict[word] = 1\\n \\n for key, value in wordcount_dict.items():\\n print(key, value)\\n \\n return wordcount_dict\",\n \"def print_word_freq(file):\\n with open(file) as one_today:\\n text = one_today.readlines()\\n d = dict()\\n for line in text:\\n line = line.strip()\\n line = line.lower()\\n line = line.translate(line.maketrans(\\\"\\\", \\\"\\\", string.punctuation))\\n words = line.split(\\\" \\\")\\n for word in words:\\n if word in d:\\n d[word] = d[word] + 1\\n elif word in STOP_WORDS:\\n pass\\n else:\\n d[word] = 1\\n for word in sorted(d, key=d.get, reverse=True):\\n print(word, \\\"|\\\", d[word])\",\n \"def word_frequency():\\n\\n song = open(\\\"data/yellow_submarine.txt\\\")\\n d = dict()\\n for line in song:\\n line = line.strip()\\n line = line.lower()\\n punctuations = \\\"\\\"\\\"!()-[]{};:'\\\"\\\\,<>./?@#$%^&*_~\\\"\\\"\\\" # remove punctuation https://www.programiz.com/python-programming/examples/remove-punctuation\\n no_punct = \\\"\\\" # remove punctuation\\n for char in line: # remove punctuation\\n if char not in punctuations: # remove punctuation\\n no_punct = no_punct + char # remove punctuation\\n words = line.split(\\\" \\\")\\n for word in words:\\n d[word] = d.get(word, 0) + 1\\n return d\",\n \"def countWords(file_name, start, end):\\r\\n\\r\\n with open(file_name, \\\"r\\\") as file:\\r\\n counter_words = 0\\r\\n\\r\\n for line in islice(file, start, end):\\r\\n res = len(line.split())\\r\\n counter_words += res\\r\\n\\r\\n return counter_words\",\n \"def print_word_freq(file):\\n# Opening file to be read\\n with open(file, \\\"r\\\") as f:\\n file_contents = f.read()\\n\\n\\n# # Taking away punctuation and lowercase all words\\n word_list = file_contents.lower().replace(',',' ').replace('.',' ').replace('!',' ').split()\\n # print(word_list)\\n\\n nice_list = []\\n for word in word_list:\\n if word not in STOP_WORDS:\\n nice_list.append(word)\\n # print(nice_list)\\n\\n d = {}\\n for word in nice_list:\\n if word not in d.keys():\\n d[word] = 1\\n else:\\n d[word] += 1 \\n # print(sorted(d, key=d.get, reverse=True)\\n # sorted(d, key=d.get, reverse=true)\\n # print(d)\\n\\n # for word in sorted(d):\\n # print((word, d[word]), end = \\\" \\\")\\n\\n d_filtered = sorted(d, key=d.get, reverse=True)\\n for x in d_filtered:\\n print(x, d[x])\",\n \"def countTagsInFile(fname):\\n with open(fname, 'r', encoding='utf-8') as f:\\n for line in f:\\n words = line.split(' ')\\n for w in words:\\n tag = w.split('_')[1].rstrip()\\n cat = tag[0].upper()\\n if tag not in dictionaries[cat]:\\n dictionaries[cat][tag] = 1\\n else:\\n dictionaries[cat][tag] += 1\",\n \"def computeWordsFrequencies(self):\\n token_stream = self._tokenize(self.readable)\\n token_map = self._countTokens(token_stream)\\n # print token_map.items()\\n return sorted(token_map.items(), key = lambda x : x[1], reverse = True)\",\n \"def wordcount(input_file_path):\\n\\n # Execute word count command on the input file and obtain the output\\n result = subprocess.check_output(['wc', input_file_path], stderr=subprocess.STDOUT)\\n result = result.decode('utf-8')\\n\\n # Split the output string into lines, words, and characters\\n (lines, words, characters, _) = result.split()\\n\\n # Create metadata dictionary\\n metadata = {\\n 'lines': lines,\\n 'words': words,\\n 'characters': characters\\n }\\n\\n # Store metadata in result dictionary\\n result = {\\n 'metadata': metadata\\n }\\n\\n # Return the result dictionary\\n return result\",\n \"def count_words(filename):\\n\\t#store the missing files in a seperate file\\n\\tnot_found_log = 'text_files\\\\\\\\missing_files.txt'\\n\\t#concatenate the file path\\n\\tfile_folder = 'text_files\\\\\\\\'\\n\\tfilename = file_folder + filename\\n\\ttry:\\n\\t\\twith open(filename, encoding='utf-8') as f:\\n\\t\\t\\tcontents = f.read()\\n\\texcept FileNotFoundError:\\n\\t\\twith open(not_found_log, 'a') as file_object:\\n\\t\\t\\tfile_object.write(filename + '\\\\n')\\n\\telse:\\n\\t\\twords = contents.split()\\n\\t\\twords_count = len(words)\\n\\t\\tprint(f\\\"The file {filename} has about {words_count} words.\\\")\",\n \"def print_word_freq(file):\\n with open(file) as text:\\n text_string = str(text.readlines())\\n text_string = text_string.replace(\\\",\\\", \\\"\\\")\\n text_string = text_string.replace(\\\".\\\", \\\"\\\")\\n text_string = text_string.replace(\\\"-\\\", \\\"\\\")\\n text_string = text_string.replace(\\\"?\\\", \\\"\\\")\\n text_string = text_string.replace(\\\":\\\", \\\"\\\")\\n text_string = text_string.replace(\\\"'\\\", \\\"\\\")\\n text_string = text_string.replace(\\\"\\\\\\\\n\\\", \\\"\\\")\\n text_string = text_string.replace(\\\"[\\\", \\\"\\\")\\n text_string = text_string.replace(\\\"]\\\", \\\"\\\")\\n word_list = text_string.split()\\n no_stop_words = []\\n for word in word_list:\\n if word in STOP_WORDS:\\n pass\\n else: no_stop_words.append(word)\\n clean_list = {}\\n for word in no_stop_words:\\n clean_list[word] = no_stop_words.count(word) \\n print(clean_list)\",\n \"def count_tokens(tokens, filename):\\n wordcounts = Counter(tokens)\\n #print(wordcounts)\\n wordcounts = pd.Series(wordcounts, name=filename)\\n #print(wordcounts.head())\\n return wordcounts\",\n \"def count_all_words(file_name):\\n\\n return len(separate_words(file_name))\",\n \"def print_word_freq(file):\\n \\n text_file = open(file, 'r')\\n\\n contents = text_file.read()\\n\\n words = contents.split()\\n\\n def clean_text(text):\\n text = text.lower()\\n all_letters = \\\"abcdefghijklmnopqrstuvwxyz\\\"\\n text_to_keep = \\\"\\\"\\n for char in text:\\n if char in all_letters:\\n text_to_keep += char\\n return text_to_keep\\n\\n clean_words = []\\n\\n for word in words:\\n clean_words.append(clean_text(word))\\n\\n go_words = [word for word in clean_words if word not in STOP_WORDS]\\n\\n word_count = {}\\n\\n for go_word in go_words:\\n word_count.update({go_word: go_words.count(go_word)})\\n\\n sorted_word_count = sorted(word_count.items(), key=lambda x: x[1], reverse=True)\\n\\n longest_word_len = len(get_longest_word(words))\\n\\n for word, value in sorted_word_count[:10]:\\n print(word.rjust(longest_word_len), \\\"|\\\", str(value).ljust(3), \\\"*\\\" * value)\",\n \"def ReadAndTokenize(filename):\\n global CACHE\\n global VOCABULARY\\n if filename in CACHE:\\n return CACHE[filename]\\n comment = open(filename).read()\\n words = Tokenize(comment)\\n\\n terms = collections.Counter()\\n for w in words:\\n VOCABULARY[w] += 1\\n terms[w] += 1\\n\\n CACHE[filename] = terms\\n return terms\",\n \"def readFile(filename):\\n listOfWords = []\\n currentLine = 1\\n f = open(filename, \\\"r\\\")\\n for line in f:\\n line = stripPunctuation(line)\\n for word in line.split():\\n word = word.lower()\\n if len(word) > 1:\\n if not word[0].isdigit():\\n tempObj = contains(listOfWords, word)\\n if tempObj != None:\\n tempObj.incOccurrence(currentLine)\\n else:\\n temp = Word(word, currentLine)\\n listOfWords.append(temp)\\n currentLine = currentLine + 1\\n return listOfWords\",\n \"def word_tag_counts (count_file):\\r\\n wordtagcounts = defaultdict(list)\\r\\n f = open(count_file, 'r')\\r\\n for line in f:\\r\\n fields = line.split(\\\" \\\")\\r\\n if fields[1] != 'WORDTAG':\\r\\n continue\\r\\n count = int(fields[0].strip())\\r\\n tag = fields[2].strip()\\r\\n word = fields[3].strip()\\r\\n wordtagcounts[word].append((tag, count)) \\r\\n f.close() \\r\\n return wordtagcounts\",\n \"def get_usercounts(self):\\n word_counts = defaultdict(int) # {}\\n with open(self.filename) as f:\\n for line in f:\\n if line:\\n username, words = self.get_username_words(line) # username1, cat dog\\n num_words = len(words.split()) # 1\\n word_counts[username] += num_words # {u1: 3, u2: 4, }\\n return word_counts\",\n \"def get_word_freq_output(fname):\\n try:\\n words = read_words_from_file(fname) # read a list of words from the file\\n\\n except FileNotFoundError as e:\\n return (1, str(e))\\n\\n else:\\n downcased = make_all_lower(words) # transform all of the words to lower case\\n punct_filtered = filter_punctuation(downcased) # remove punctuation\\n word_filtered = remove_stop_words(punct_filtered) # remove the stop words\\n word_counts = count_words(word_filtered) # get a count of all the words in the file\\n pretty_word_frequency = get_word_frequency_string(word_counts) # print formatted\\n return (0, pretty_word_frequency) # all done!\",\n \"def build_dict(fname):\\n\\t\\n\\twith open(fname) as file:\\n\\n\\t\\tword_count_dict = {}\\n\\n\\t\\tfor line in file:\\n\\t\\t\\tline = line.rstrip()\\n\\t\\t\\tline =line.split(' ')\\n\\t\\t\\tfor word in line:\\n\\t\\t\\t\\tword = word.strip('\\\"!.,?_;():')\\n\\t\\t\\t\\tword = word.lower()\\n\\t\\t\\t\\tword_count_dict[word] = word_count_dict.get(word, 0) + 1\\n\\t\\t#return word_count_dict\\n\\n\\t\\tfor each in word_count_dict:\\n\\t\\t\\tcount = word_count_dict[each]\\n\\t\\t\\tprint(each, count)\\n\\n\\t\\treturn\",\n \"def get_frequencies(filename):\\n freq_dict = {}\\n _,long_name = filename.split(\\\"\\\\\\\\\\\")\\n name,_ = long_name.split(\\\"_gold_\\\")\\n f = os.path.join(PARSED, name + \\\".fix.xml\\\")\\n #soup = bs(open(f, 'r'))\\n soup = bs(codecs.open(f, 'r', encoding='utf-8'))\\n for sent in soup.findAll('sentence'):\\n for token in sent.findAll('token'):\\n try:\\n w = token.word.string\\n if w in freq_dict:\\n freq_dict[w] += 1\\n else:\\n freq_dict[w] = 1\\n except AttributeError:\\n pass\\n return freq_dict\",\n \"def count_words(text):\\n\\n # Open a file and read the text\\n with open(text) as file:\\n # Split the file in to a list of words\\n words = remove_punctuation(file.read()).split()\\n # Create a set of unique words from the list words\\n unique_words = {*words}\\n\\n # For each string in the new list\\n for unique_word in unique_words:\\n # Count the number of times the word appears\\n count = words.count(unique_word)\\n # Print the string and the number of times it appears.\\n print(f'\\\"{unique_word.capitalize() }\\\" appears {count} times.')\",\n \"def analyzeFile(filename): \\n fileData = open(filename, encoding=\\\"utf-8\\\") # open the file\\n \\n counts = {}\\n\\n for line in fileData:\\t\\t # iterates over every line of the file\\n words = line.split() # turns each line into a list\\n for word in words: #iterates over the words in each line list\\n word = word.lower().strip(string.whitespace+string.punctuation)\\n if len(word) > 0: #make sure word is longer than 0 before adding it to the dictionary\\n counts[word] = counts.get(word, 0) + 1 #look up if the dictionary has that word and if not then it'll add that word with the value 0 associated with it and then add one to that, if it has seen it it'll add 1 to the value stored in the counts dictionary\\n #when it gets here for the first line it goes back up to the top and repeats for the 2nd line\\n mostCommonWord = [word]\\n leastCommonWord = [word]\\n shortestWord = [word]\\n longestWord = [word]\\n \\n for item in counts:\\n if counts[mostCommonWord[0]] < counts[item]:\\n mostCommonWord = [item]\\n elif counts[mostCommonWord[0]] == counts[item]:\\n mostCommonWord.append(item)\\n if counts[leastCommonWord[0]] > counts[item]:\\n leastCommonWord = [item]\\n elif counts[leastCommonWord[0]] == counts[item]:\\n leastCommonWord.append(item)\\n if len(shortestWord[0]) > len(item):\\n shortestWord = [item] \\n elif len((shortestWord[0])) == len(item):\\n shortestWord.append(item)\\n if len(longestWord[0]) < len(item):\\n longestWord = [item]\\n elif len(longestWord[0]) == len(item):\\n longestWord.append(item)\\n \\n return (mostCommonWord, leastCommonWord, shortestWord, longestWord)\",\n \"def count_words(self, contents):\\n wordCounts = {}\\n for i in self.ngramCounts:\\n if i == 0: # want the default to be the size of the corpus\\n total = 0\\n for line in contents:\\n words = line.split(\\\" \\\")\\n words = [ w.strip() for w in words if w] #remove nulls\\n for word in words:\\n if word:\\n total += 1\\n wordCounts[i] = defaultdict(lambda: total)\\n continue\\n else:\\n counts = defaultdict(lambda: 0)\\n for line in contents:\\n words = line.split(\\\" \\\")\\n words = [ w.strip() for w in words if w] #remove nulls\\n for k, word in enumerate(words): \\n if k < (i-1) or not word:\\n continue\\n key = \\\"\\\"\\n for j in range(k-i+1, k+1):\\n key += words[j] + \\\" \\\"\\n counts[key.strip()] += 1\\n wordCounts[i] = counts\\n return wordCounts\",\n \"def count_common_words(filename):\\n with open(filename,encoding='utf-8') as f:\\n contents = f.read()\\n common_words = contents.count('Alice')\\n print(common_words)\",\n \"def load_dictionary(filename):\\n\\n word_list = []\\n freq_sum = 0\\n\\n # nacitanie zo suboru\\n with open(filename) as f:\\n for line in f:\\n freq, val = line.split()\\n word_list.append(Word(int(freq), val))\\n freq_sum += int(freq)\\n\\n # lexikograficke usporiadanie slov\\n word_list_sorted = sorted(word_list, key=operator.attrgetter('value'))\\n\\n return word_list_sorted, freq_sum\",\n \"def frequency(text):\\n # TODO: change function input to a textfile?\\n import collections\\n freq = collections.Counter(text)\\n # print freq\\n return freq\",\n \"def get_frequency_list():\\n freqs = {}\\n file = get_or_download_wordlist_file()\\n for line in file:\\n word, freq = line.split()\\n freqs[word] = int(freq)\\n return freqs\",\n \"def get_counts(data):\\n\\n word_count = {}\\n syll_count = {}\\n\\n infile = data.corpus\\n try:\\n\\n open_file = codecs.open(infile, 'r', encoding='utf-16')\\n for line in open_file:\\n line = line.lower()\\n # Remove tablet indexing info and line numbers. Grab only text data\\n line = line.split(',')\\n text = clean_line(line[7])\\n\\n # Update the occurrences of the words in the line\\n for word in text.split():\\n count = word_count.setdefault(word, 0)\\n word_count[word] = count + 1\\n\\n # Track occurrences of syllables\\n update_syllable_count(word, syll_count)\\n\\n open_file.close()\\n except IOError:\\n print(\\\"Cannot open: \\\" + infile)\\n\\n return (word_count, syll_count)\",\n \"def mapWordsFrequencies(self):\\n token_stream = self._tokenize(self.readable)\\n token_map = self._countTokens(token_stream)\\n return token_map\",\n \"def tag_counts (count_file):\\r\\n tagcounts = defaultdict(int)\\r\\n f = open(count_file, 'r')\\r\\n for line in f:\\r\\n fields = line.split()\\r\\n if fields[1] != 'WORDTAG':\\r\\n continue\\r\\n count = int(fields[0])\\r\\n tag = fields[2]\\r\\n tagcounts[tag] += count \\r\\n f.close() \\r\\n return tagcounts\",\n \"def print_word_freq(file):\\n with open(file) as text:\\n text = text.read().lower()\\n text = text.replace(\\\"\\\\n\\\", \\\" \\\")\\n text = text.replace(\\\"’\\\", \\\"\\\")\\n # text = \\\" \\\".join(text.split())\\n # print(text)\\n for character in string.punctuation:\\n text = text.replace(character, \\\"\\\")\\n word_list = text.split()\\n clean_list = []\\n for word in word_list:\\n if word not in STOP_WORDS:\\n clean_list.append(word)\\n \\n\\n # for stop_word in STOP_WORDS:\\n # if stop_word in word_list:\\n # word_list.remove(stop_word)\\n\\n\\n new_dict = {}\\n for word in clean_list:\\n new_dict[word] = clean_list.count(word)\\n sorted_dict = sorted(new_dict.items())\\n print(sorted_dict)\\n\\n # print(f\\\"{key} | {value} {'*' * value}\\\")\\n\\n \\n # for stop_word in STOP_WORDS:\\n # text = text.replace(stop_word, \\\"\\\")\\n\\n # for word in word_list:\\n # if word in string.punctuation:\\n # #do something\\n # if word in STOP_WORDS:\\n\\n \\n # for stop_word in STOP_WORDS:\\n # text = text.replace(stop_word, \\\"\\\")\\n # print(text)\",\n \"def cnt_freq(filename):\\n freq = [0] * 256\\n try:\\n f_in = open(filename,'r')\\n except:\\n raise FileNotFoundError\\n for line in f_in:\\n for char in line:\\n freq[ord(char)] = freq[ord(char)] + 1\\n f_in.close()\\n return freq\",\n \"def print_word_freq(file):\\n # with open(file, 'r') as text the r as the second arguement means that my intentions are to read the file\\n with open(file, 'r') as text:\\n # this reads the entire file and puts this into text string\\n text_string = text.read()\\n # returns the string respresentation of text string without removing special characters so you can see what you need to remove\\n # print(repr(text_string))\\n # this removes the specified characters from the text string\\n text_string = text_string.replace(\\\",\\\", \\\"\\\")\\n text_string = text_string.replace(\\\".\\\", \\\"\\\")\\n text_string = text_string.replace(\\\"—\\\", \\\" \\\")\\n text_string = text_string.replace(\\\"-\\\", \\\" \\\")\\n text_string = text_string.replace(\\\"?\\\", \\\"\\\")\\n text_string = text_string.replace(\\\":\\\", \\\"\\\")\\n text_string = text_string.replace(\\\"'\\\", \\\"\\\")\\n text_string = text_string.replace(\\\"\\\\\\\\n\\\", \\\"\\\")\\n text_string = text_string.replace(\\\"’\\\", \\\"\\\")\\n text_string = text_string.replace(\\\"]\\\", \\\"\\\")\\n text_string = text_string.replace(\\\"[\\\", \\\"\\\")\\n text_string = text_string.replace(\\\"\\\\\\\"\\\", \\\"\\\")\\n # takes the text string and makes all the characters lower case\\n text_string = text_string.lower()\\n # takes the text string and splits all the words into a list this splits from space to space\\n words_list = text_string.split()\\n # a dictionary is a key and a value\\n no_stop_words = {}\\n # for loop that will cycle through the words list\\n for word in words_list:\\n # checking to see if the word is stop words\\n if word not in STOP_WORDS:\\n # if the word is already in the dictionary no stop words increment the value by 1\\n if word in no_stop_words:\\n no_stop_words[word] += 1\\n # if the word is not in the dictionary no stop words add this to the dictionary and give it a value of 1\\n else:\\n no_stop_words[word] = 1\\n \\n sorted_dict = {}\\n sorted_keys = sorted(no_stop_words, key=no_stop_words.get, reverse=True)\\n \\n for w in sorted_keys:\\n sorted_dict[w] = no_stop_words[w]\\n \\n for key in sorted_dict:\\n print(f\\\"{key:>15} | {sorted_dict[key]:2} {'*' * sorted_dict[key]}\\\")\\n \\n # good practice to ensure that we are properly closing the file in use at the end of the function\\n text.close()\",\n \"def cnt_freq(filename):\\r\\n counts = [0] * 256\\r\\n fp_file = open(filename, \\\"r\\\")\\r\\n lines = fp_file.readlines()\\r\\n for i in lines:\\r\\n for j in i: # count every letter in the line\\r\\n counts[ord(j)] += 1 # counts[ord(j)] + 1\\r\\n counts[0] = 1\\r\\n fp_file.close()\\r\\n return counts\",\n \"def count_word(filename, word):\\r\\n try:\\r\\n with open(filename) as file_object:\\r\\n contents = file_object.read()\\r\\n word_count = contents.lower().count(word) \\r\\n except FileNotFoundError:\\r\\n print(filename + \\\" cannot be located.\\\")\\r\\n else:\\r\\n message = filename + \\\" has the word \\\" + \\\"'\\\" + word + \\\"' in it \\\" \\r\\n message += str(word_count) + \\\" times.\\\"\\r\\n print(message)\",\n \"def _count_words_in_file(self, words: List[str]) -> Dict[str, int]:\\n files_found_by_word = {}\\n for word in words:\\n found_files_with_word = self._db_ranking.query_by_word(word)\\n for filename in found_files_with_word:\\n if filename not in files_found_by_word:\\n files_found_by_word[filename] = 0\\n files_found_by_word[filename] = files_found_by_word[filename] + 1\\n\\n return files_found_by_word\",\n \"def print_word_freq(file):\\n opened_file = open(file)\\n text = opened_file.read()\\n #print(text)\\n #replace hyphens\\n no_hyphen = text.replace(\\\"-\\\",\\\" \\\")\\n #remove punctuation\\n no_punctuation = \\\"\\\"\\n for char in no_hyphen:\\n if char not in punctuation:\\n no_punctuation = no_punctuation + char\\n #make everything lowercase\\n lower_case_text = no_punctuation.lower()\\n #print(lower_case_text)\\n #split into words\\n all_words = lower_case_text.split()\\n #print(all_words)\\n #remove stop words\\n no_stop_words = []\\n for each_word in all_words:\\n if each_word not in STOP_WORDS:\\n no_stop_words.append(each_word)\\n #print(no_stop_words)\\n #find the longest word to use for indention purposes\\n word_length = 0\\n for word in no_stop_words:\\n if len(word) > word_length:\\n #print (word, len(word))\\n word_length = len(word)\\n #print (word_length)\\n #count remaining word usage\\n word_counts = {}\\n for word in no_stop_words:\\n if word in word_counts:\\n word_counts[word] +=1\\n else: word_counts[word] = 1\\n #print (word_counts)\\n #sort words by frequency\\n ordered_by_freq = (sorted(word_counts.items(), key=lambda seq: seq[1], reverse=True))\\n #print (ordered_by_freq)\\n #print words, freq, graph, indent, and add a space past the pipe for values less than 10\\n for key, value in ordered_by_freq:\\n indent = (word_length + 1 - len(key))\\n space = \\\" \\\"\\n star = \\\"*\\\"\\n if value >= 10:\\n print (indent * space, key, \\\" | \\\", value, value * star)\\n else:\\n print (indent * space, key, \\\" | \\\", value, value * star)\\n \\n\\n \\n \\n\\n \\n\\n \\n\\n\\n\\n #remove the stop words\\n #count the frequency of the remaing words (see ex 6 for sort function)\\n #output as a cord list, count and graph of *** (ex 7 for justify)\",\n \"def wc(file_):\\r\\n with open(file_) as f:\\r\\n file = f.read().strip()\\r\\n char_nums = len(file)\\r\\n lines = file.split('\\\\n')\\r\\n line_nums = len(lines)\\r\\n word_nums = 0\\r\\n for line in lines:\\r\\n words = line.split()\\r\\n word_nums += len(words)\\r\\n return f'{line_nums} {word_nums} {char_nums} {file_}'\",\n \"def word_frequencies(word_list: TextIO) -> dict:\\n words = word_list.read().split(' ')\\n amount_of_words = len(set(words))\\n frequencies = {}\\n for index, word in enumerate(words):\\n clean_word = remove_punctuation(word)\\n if clean_word not in frequencies:\\n frequencies[clean_word] = (index + 1) / amount_of_words\\n del frequencies[\\\"\\\"]\\n return frequencies\",\n \"def word_frequencies(corpus):\\n return frequencies(corpus, 1, to_lower=True)\",\n \"def analyze_text(filename):\\n with open(filename, mode='r') as f:\\n lines = 0\\n words = 0 \\n chars = 0\\n for line in f:\\n lines += 1\\n words += len(line.split())\\n chars += len(line)\\n return (lines, words, chars)\",\n \"def countWords(f, ext):\\n\\n word_count = 0\\n if ext == \\\".xml\\\":\\n # Parse with lxml\\n tree = lxml.etree.parse(f)\\n root = tree.getroot()\\n # Get the text of all tags.\\n if root is not None:\\n text = root.xpath(\\\"//text()\\\")\\n else:\\n return word_count\\n # Join the text together.\\n text = \\\" \\\".join(text)\\n # Split the text into words.\\n words = text.split(\\\" \\\")\\n # Remove empty strings.\\n words = [w for w in words if w != \\\"\\\"]\\n # Remove words that are just numbers.\\n words = [w for w in words if not w.isnumeric()]\\n # Remove one-letter words\\n words = [w for w in words if len(w) > 1]\\n # Count the words\\n word_count = len(words)\\n # Subtract off the number of child tags from the root.\\n word_count = word_count - len(root.getchildren()) - 1\\n\\n elif ext == \\\".html\\\":\\n # Parse the file with BeautifulSoup.\\n soup = BS(f, \\\"html.parser\\\")\\n # Get the text of all tags.\\n text = soup.get_text()\\n # Split the text into words.\\n words = text.split(\\\" \\\")\\n # Remove empty strings.\\n words = [w for w in words if w != \\\"\\\"]\\n # Remove words that are just numbers.\\n words = [w for w in words if not w.isnumeric()]\\n # Remove one-letter words\\n words = [w for w in words if len(w) > 1]\\n # Count the words\\n word_count = len(words)\\n\\n elif ext == \\\".md\\\" or ext == \\\".srt\\\":\\n for line in f:\\n # Skip blank lines.\\n if len(line) == 0 or line == \\\"\\\\n\\\" or line == \\\"\\\\r\\\":\\n continue\\n # Check for SRT time lines and skip them.\\n if re.search(\\\"\\\\d\\\\d --> \\\\d\\\\d:\\\", line):\\n continue\\n # Skip lines that are just a single number.\\n if re.search(\\\"^\\\\d+$\\\", line):\\n continue\\n # Check for lines that are just times and skip them.\\n if re.search(\\\"^\\\\d\\\\d:\\\\d\\\\d$\\\", line):\\n continue\\n if re.search(\\\"^\\\\d\\\\d:\\\\d\\\\d:\\\\d\\\\d$\\\", line):\\n continue\\n\\n raw_words = line.split(\\\" \\\")\\n reduced_words = []\\n for w in raw_words:\\n # Don't include 1-character \\\"words\\\"\\n if len(w) > 1:\\n reduced_words.append(w)\\n\\n # Store filename and count\\n word_count += len(reduced_words)\\n\\n # Sometimes the word count is negative. I don't know why.\\n if word_count < 0:\\n word_count = 0\\n return word_count\",\n \"def word_frequency(words):\\r\\n frequency = {}\\r\\n for w in words:\\r\\n frequency[w] = frequency.get(w, 0) + 1\\r\\n return frequency\",\n \"def parse(filename, case_sensitive=False, sort=False):\\n\\n text = _read(filename)\\n\\n # If case_sensitive is true we make the text all lower case.\\n if not case_sensitive:\\n text = text.lower()\\n\\n # Note: we here process a word as being anything with\\n # A-Z, a-z, 0-9, or any unicode characters in the \\n # range 00c00-u02b08 which is a number of weird characters\\n # not normally used in English. The range was found by manually\\n # looking through the table located at\\n # https://unicode-table.com/en/#ipa-extensions\\n # for some common vowels that occur in other languages.\\n # The motivation for this was in processing moby-dick.txt\\n # in the examples where â was being misinterpreted as \\n # a word boundary by the re module.\\n words = re.findall(r'\\\\w*[\\\\'-\\\\u00c00-u02b08]*\\\\w', text)\\n\\n frequency_dict = {word: 0 for word in words}\\n # Do it this way rather than using count, because it avoids\\n # doing len(words) lookups over the whole text.\\n for word in words:\\n frequency_dict[word] += 1\\n\\n if sort:\\n # Sort the dictionary by the values. Dictionarys are ordered in Python\\n # 3.6 and above but that is not the case for old versions where you\\n # must use collections.OrderedDict.\\n frequency_dict = sort_dict(frequency_dict)\\n\\n return frequency_dict\",\n \"def count_words(path, max_vocab_size=40000, tok=False):\\n counts = collections.Counter()\\n for words in read_file(path, tok):\\n for word in words:\\n counts[word] += 1\\n\\n vocab = [word for (word, _) in counts.most_common(max_vocab_size)]\\n return vocab\",\n \"def frequency(self, path, filemoving, parser):\\n root = parser.parsing_xml(path, filemoving)\\n root_tag = root.tag[0:(root.tag.find('}') + 1)]\\n list_of_words = []\\n for i in root.iter(root_tag + 'p'):\\n if str(type(i.text)) == \\\"<class 'str'>\\\":\\n for word in i.text.split():\\n alphanumeric_filter = filter(str.isalnum, word)\\n alphanumeric_string = \\\"\\\".join(alphanumeric_filter)\\n list_of_words.append(alphanumeric_string)\\n dict_of_frequency = collections.Counter(list_of_words)\\n return dict_of_frequency\",\n \"def get_dict(fname):\\n out_set, tot_count = {}, 0\\n with open(fname, 'r') as fid:\\n word_arr = fid.read().split('\\\\n')\\n for ele in word_arr:\\n if len(ele) > 0:\\n out_set[(ele.split()[0])] = tot_count\\n tot_count += 1\\n return out_set\",\n \"def word_frequency( tokenized, dic ):\\n print( 'computing word frequencies' )\\n start = time.time()\\n for i, text in enumerate( tokenized ):\\n for token in text:\\n if token not in dic:\\n dic[ token ] = 1\\n else:\\n dic[ token ] += 1\\n if i % 10000 == 0:\\n sys.stdout.write( '\\\\rprocessed : {}/{} reviews in {}s'.format( i, NO_REVIEWS, time.time() - start ) )\\n sys.stdout.write( '\\\\rprocessed : {}/{} reviews in {}s\\\\n'.format( i, NO_REVIEWS, time.time() - start ) )\",\n \"def word_frequency(words):\\n freq = {}\\n for w in words:\\n cur_word = w.lower().strip(punctuation)\\n freq[cur_word] = freq.get(cur_word, 0) + 1\\n return freq\",\n \"def word_frequencies(url):\\n\\ttexts = get_all_texts(url)\\n\\tcount = count_words_in_sentence_list(texts)\\n\\treturn count\",\n \"def get_vocabulary(text_fname, vocab_fname):\\n with codecs.open(text_fname,'r','utf-8') as infile, \\\\\\n codecs.open(vocab_fname,'w','utf-8') as outfile: \\n\\n count_map={}\\n for line in infile:\\n sent=line.strip().split(' ')\\n for w in sent:\\n count_map[w]=count_map.get(w,0.0)+1.0\\n\\n for w,c in count_map.iteritems(): \\n outfile.write(u'{}|{}\\\\n'.format(w,c))\",\n \"def main():\\n wf = WordFrequencies()\\n tokens = wf.tokenize(sys.argv[1])\\n occurrences = wf.computeWordFrequencies(tokens)\\n wf.print(occurrences)\",\n \"def _read_leipzig_word_counts_file(self, leipzig_word_counts_path):\\n self._background_word_counts = defaultdict(int)\\n self._background_lowercased_word_counts = defaultdict(int)\\n with open(leipzig_word_counts_path, mode='rt') as word_count_file:\\n for line in word_count_file.readlines():\\n splits = line.strip().split('\\\\t')\\n assert len(splits) == 4\\n WORD_INDEX = 1\\n FREQUENCY_INDEX = 3\\n frequency = int(splits[3])\\n self._background_word_counts[splits[1]] = frequency\\n self._background_lowercased_word_counts[splits[1].lower()] += frequency\",\n \"def get_number_of_words(self):\\n filename = f'{self.path}/{self.filename}'\\n # word_counter = {}\\n # w_cnt = 0\\n # x = 0\\n file = open(filename, 'r', encoding='utf-8')\\n data = file.read()\\n head, sep, tail = data.partition('<binary')\\n head = re.sub('\\\\\\\\s\\\\\\\\s*', ' ', (re.sub('\\\\\\\\W|\\\\\\\\d', ' ', re.sub('<.*?>', '', head))))\\n word_list = head.split()\\n # for word in word_list:\\n # w_cnt += 1\\n # if word not in word_counter:\\n # word_counter[word] = 1\\n # else:\\n # word_counter[word] = word_counter[word] + 1\\n\\n # for word in word_list:\\n # x += 1\\n # print(word, word.isalpha(), x)\\n\\n w_cnt = sum([a[0].isalpha() for a in word_list])\\n sqlite_for_ht.CreateTable.update_table(f_1, self.filename, 'number_of_words', w_cnt)\\n print(datetime.now(), '-', 'number_of_words for', self.filename, 'calculated =', w_cnt)\\n return None\",\n \"def count_words(all_lines):\\n words = {}\\n for line in all_lines:\\n for word in line:\\n if word in words:\\n words[word] += 1\\n else:\\n words[word] = 1\\n\\n new_words = sorted(words.items(), key=operator.itemgetter(1), reverse=True)\\n\\n return [item[0] for item in new_words]\",\n \"def find_freq_words(words):\\n word_list = [1 for line in f if words in line]\\n return reduce(lambda x,y: x+1 if y==1 else x, word_list) # x takes on the type of the elements in the array\",\n \"def load_input(path):\\n counts = defaultdict(int)\\n if not os.path.exists(mode+'indices.p'):\\n root = '/'.join(path.split('/')[0:-1])\\n all_paths = [root+'/'+x for x in os.listdir(root)] #'/'.join(path.split('/')[0:-1]))\\n else:\\n all_paths = [path]\\n \\n for path in all_paths:\\n print(path)\\n with open(path) as f:\\n if mode == 'word':\\n words = tokenize(f.read())\\n else:\\n words = f.read()\\n\\n for word in words:\\n counts[word] += 1 \\n\\n words = [x for x in words if len(x) > 0]\\n return words, counts\",\n \"def count_word_instances_in_file(file_name, target_word):\\n\\n\\tcount = 0\\n\\twords = get_words_in_file(file_name)\\n\\tfor word in words:\\n\\t\\tif target_word == word:\\n\\t\\t\\tcount += 1\\n\\treturn count\",\n \"def read_counts(counts_file):\\n try:\\n fi = open(counts_file, 'r')\\n except IOError:\\n sys.stderr.write('ERROR: Cannot open %s.\\\\n' % counts_file)\\n sys.exit(1)\\n\\n for line in fi:\\n fields = line.strip().split(' ')\\n yield fields # yields a list of fields\",\n \"def wc(filename):\\n\\n\\n # holds number of characters, words and lines in the file\\n lines = 0\\n words = 0\\n char = 0\\n try: # if the file does not exist\\n file = open(filename)\\n for line in file: # goes through file\\n lines += 1\\n wordList = line.split()\\n words += len(wordList)\\n for el in wordList: # this way I only count characters without \\\" \\\"(spaces)\\n char += len(el)\\n file.close()\\n except Exception as e:\\n print(e)\\n lines, words, char = 404, 404, 404\\n\\n # prints out only if there was a right file name\\n print(f\\\"{lines} {words} {char} {filename}\\\")\",\n \"def count_word(self, most_num):\\n with open(self.file_name, 'r') as f:\\n data = f.read().lower()\\n # characters and single quote not split\\n words = re.split(r'[^\\\\w\\\\']+', data)\\n logging.debug(words)\\n most_cnts_words = Counter(words).most_common(most_num)\\n print(most_cnts_words)\",\n \"def load_word_freq(self, file_path):\\n\\n # initialise frequency dict\\n # freq = {i: {} for i in range(1,9)}\\n freq = {1: {}}\\n\\n # read csv file\\n with open(file_path, 'r', encoding=co.OUT_ENCODING[self.language]) as f:\\n reader = csv.reader(f, delimiter=',')\\n\\n # skip header\\n next(reader)\\n\\n # iterate through csv and add values to dictionary\\n for row in reader:\\n try:\\n # freq[int(row[3])][row[0]] = int(row[1])\\n freq[1][row[0]] = int(row[1])\\n except ValueError:\\n pass\\n\\n return freq\",\n \"def _count_word_frequency(self, data):\\n _dict = {}\\n for _docs in data:\\n for _word in _docs:\\n if _word in _dict:\\n _dict[_word] += 1\\n else:\\n _dict[_word] = 1\\n return _dict\",\n \"def freq(word, document):\\n return document.split(None).count(word)\",\n \"def get_frequencies(tokens):\\n cnt = {}\\n\\n for word in tokens:\\n if word not in cnt:\\n cnt[word] = 0\\n\\n cnt[word] += 1\\n\\n return cnt\",\n \"def main ():\\n fio = FileIo(\\\"../input2.txt\\\")\\n text = fio.getInput()\\n p = re.compile(r'#?\\\\d[\\\\s\\\\.]?[\\\\s]?')\\n out = filter(None, p.split(text))\\n #print out[2]\\n #print len(out)\\n wc = 0\\n\\n for s in out:\\n text = nltk.word_tokenize(s)\\n wc += wordCount( text )\\n print wc\",\n \"def frequencies(filename):\\n\\n hashtable = QuadraticProbeTable()\\n file = open(filename,'r')\\n words = []\\n\\n for item in file:\\n item = item.strip('\\\\n')\\n if item not in hashtable:\\n hashtable[item] = 1\\n words.append(item)\\n else: hashtable[item] = hashtable[item] + 1\\n\\n file = open('FREQUENCY.txt', 'w')\\n words = heap_sort(words)\\n for item in words: file.write(item + ' ' + str(hashtable[item]) + '\\\\n')\",\n \"def main():\\n filename = input('filename?\\\\n')\\n print(report_distribution(count_words(filename)))\",\n \"def count(self):\\n freq = {}\\n\\n for desc in self.words:\\n if desc in freq:\\n freq[desc] += 1\\n else:\\n freq[desc] = 1\\n\\n return freq\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.82008404","0.7888448","0.7832937","0.77919406","0.7706766","0.76518214","0.76488185","0.7634585","0.76182836","0.7587663","0.75641406","0.75639457","0.7504516","0.74861825","0.7480002","0.74630535","0.74255395","0.74054885","0.7391366","0.7357203","0.734464","0.7336504","0.7333173","0.73155886","0.7314652","0.7287313","0.7257152","0.72353333","0.7220229","0.7208063","0.72074187","0.7178428","0.7144671","0.7115632","0.7105753","0.7095055","0.70422965","0.7010078","0.700717","0.7005381","0.7000809","0.69732994","0.6963761","0.6928905","0.6927942","0.68785155","0.68519694","0.68479776","0.6829049","0.681555","0.68148416","0.6806107","0.6732018","0.6729976","0.6706171","0.6705313","0.6700285","0.66986626","0.66956013","0.66934186","0.6691023","0.6667764","0.6663398","0.6634083","0.66185576","0.6608191","0.6583022","0.6567269","0.65580297","0.65468335","0.65430886","0.6526976","0.652562","0.6521116","0.6512615","0.65107936","0.6507363","0.6506873","0.64916515","0.64884734","0.64401495","0.6435122","0.64343876","0.643193","0.6407856","0.63914657","0.63907176","0.6379206","0.6374824","0.6361635","0.6344877","0.63371414","0.6335607","0.6326289","0.63217914","0.6309457","0.6300298","0.6298822","0.62818366","0.6275703"],"string":"[\n \"0.82008404\",\n \"0.7888448\",\n \"0.7832937\",\n \"0.77919406\",\n \"0.7706766\",\n \"0.76518214\",\n \"0.76488185\",\n \"0.7634585\",\n \"0.76182836\",\n \"0.7587663\",\n \"0.75641406\",\n \"0.75639457\",\n \"0.7504516\",\n \"0.74861825\",\n \"0.7480002\",\n \"0.74630535\",\n \"0.74255395\",\n \"0.74054885\",\n \"0.7391366\",\n \"0.7357203\",\n \"0.734464\",\n \"0.7336504\",\n \"0.7333173\",\n \"0.73155886\",\n \"0.7314652\",\n \"0.7287313\",\n \"0.7257152\",\n \"0.72353333\",\n \"0.7220229\",\n \"0.7208063\",\n \"0.72074187\",\n \"0.7178428\",\n \"0.7144671\",\n \"0.7115632\",\n \"0.7105753\",\n \"0.7095055\",\n \"0.70422965\",\n \"0.7010078\",\n \"0.700717\",\n \"0.7005381\",\n \"0.7000809\",\n \"0.69732994\",\n \"0.6963761\",\n \"0.6928905\",\n \"0.6927942\",\n \"0.68785155\",\n \"0.68519694\",\n \"0.68479776\",\n \"0.6829049\",\n \"0.681555\",\n \"0.68148416\",\n \"0.6806107\",\n \"0.6732018\",\n \"0.6729976\",\n \"0.6706171\",\n \"0.6705313\",\n \"0.6700285\",\n \"0.66986626\",\n \"0.66956013\",\n \"0.66934186\",\n \"0.6691023\",\n \"0.6667764\",\n \"0.6663398\",\n \"0.6634083\",\n \"0.66185576\",\n \"0.6608191\",\n \"0.6583022\",\n \"0.6567269\",\n \"0.65580297\",\n \"0.65468335\",\n \"0.65430886\",\n \"0.6526976\",\n \"0.652562\",\n \"0.6521116\",\n \"0.6512615\",\n \"0.65107936\",\n \"0.6507363\",\n \"0.6506873\",\n \"0.64916515\",\n \"0.64884734\",\n \"0.64401495\",\n \"0.6435122\",\n \"0.64343876\",\n \"0.643193\",\n \"0.6407856\",\n \"0.63914657\",\n \"0.63907176\",\n \"0.6379206\",\n \"0.6374824\",\n \"0.6361635\",\n \"0.6344877\",\n \"0.63371414\",\n \"0.6335607\",\n \"0.6326289\",\n \"0.63217914\",\n \"0.6309457\",\n \"0.6300298\",\n \"0.6298822\",\n \"0.62818366\",\n \"0.6275703\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6632512"},"document_rank":{"kind":"string","value":"64"}}},{"rowIdx":91973,"cells":{"query":{"kind":"string","value":"Prints the histogram dictionary"},"document":{"kind":"string","value":"def print_dict(d):\n list1=list()\n for key,value in d.items():\n list1.append((value,key))\n list1.sort(reverse=True)\n for word,value in list1[:20]:\n print(word, value, sep='\\t')"},"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 print_hist(h):\n for k in h:\n print(k, h[k])","def do_hist(self, args):\n print(self._hist)","def show_histo(dict, orient=\"horiz\", label=\"counts\", title=\"title\"):\n plt.clf()\n plt.cla()\n if orient==\"horiz\":\n bar_fun = plt.barh \n bar_ticks = plt.yticks\n bar_label = plt.xlabel\n elif orient==\"vert\":\n bar_fun = plt.bar\n bar_ticks = plt.xticks\n bar_label = plt.ylabel\n else:\n raise Exception(\"show_histo: Unknown orientation: %s \".format % orient)\n n = len(dict)\n bar_fun(range(n), list(dict.values()), align='center', alpha=0.4, color = 'g')\n bar_ticks(range(n), list(dict.keys())) \n bar_label(label)\n plt.title(title)\n plt.show()","def _printHist(self):\n bins = [0] * self.displayBins\n binSize = self.maxValue / self.displayBins\n displaySamps = self.samples[:]\n displaySamps.sort()\n currLimit = binSize\n binIndex = 0\n partIndex = 0\n while partIndex < self.numParticles:\n part = displaySamps[partIndex]\n if binIndex >= self.displayBins:\n # if value beyond max value, add to last bin and go on to next particle\n bins[19] += 1\n partIndex += 1\n elif part < currLimit:\n # count particle in current bin, go on to next particle\n bins[binIndex] += 1\n partIndex += 1\n else:\n # go on to next bin, don't go on to next particle\n binIndex += 1\n currLimit += binSize\n self.printMapPattern(binSize)\n histStr = \"{0:3d} \"\n printStr = \"\"\n for b in bins:\n printStr += histStr.format(b)\n print(printStr)","def ascii_histogram(seq) -> None:\n counted = count_elements(seq)\n for k in sorted(counted):\n print('{0:5d} {1}'.format(k, '+' * counted[k]))","def print_histogram(path):\n with open(path, 'rb') as handle:\n size = os.fstat(handle.fileno()).st_size\n mgz.header.parse_stream(handle)\n operations = defaultdict(int)\n actions = defaultdict(int)\n labels = {}\n fast.meta(handle)\n while handle.tell() < size:\n op_type, payload = fast.operation(handle)\n operations[op_type.name] += 1\n if op_type == fast.Operation.ACTION:\n action_id = payload[1]\n action_id = '{0:#0{1}x}'.format(payload[0].value, 4)\n labels[action_id] = payload[0].name\n actions[action_id] += 1\n print('Operations')\n print(tabulate([\n [operation, operations[operation]]\n for operation in sorted(operations, key=operations.get, reverse=True)\n ], headers=['Name', 'Count'], tablefmt='simple'))\n print()\n print('Actions')\n print(tabulate([\n [action, labels[action], actions[action]]\n for action in sorted(actions, key=actions.get, reverse=True)\n ], headers=['ID', 'Name', 'Count'], tablefmt='simple'))","def _hist_info(ns, hist):\n data = collections.OrderedDict()\n data['sessionid'] = str(hist.sessionid)\n data['filename'] = hist.filename\n data['length'] = len(hist)\n data['buffersize'] = hist.buffersize\n data['bufferlength'] = len(hist.buffer)\n if ns.json:\n s = json.dumps(data)\n print(s)\n else:\n lines = ['{0}: {1}'.format(k, v) for k, v in data.items()]\n print('\\n'.join(lines))","def histogram(histo,nbr_launch,file):\n with open(\"Results/Histogram_{}_{}.txt\".format(nbr_launch,file.strip(\".yaml\")),'w') as f:\n f.write(\"mgm results :\"+\"\\n\")\n for val,occur in histo[\"mgm\"].items():\n f.write(\"value \"+str(val)+\" : \"+str(occur[0])+\" \"+\"Initial costs : \"+str(occur[1]).strip(\"[\"+\"]\")+\"\\n\")\n f.write(\"\\n\")\n f.write(\"mcs_mgm results :\" + \"\\n\")\n for val, occur in histo[\"mcs_mgm\"].items():\n f.write(\"value \" + str(val) + \" : \" + str(occur[0])+\" \"+\"Initial costs : \"+str(occur[1]).strip(\"[\"+\"]\")+\"\\n\")\n f.write(\"\\n\")\n f.write(\"gca_mgm results :\" + \"\\n\")\n for val, occur in histo[\"gca_mgm\"].items():\n f.write(\"value \" + str(val) + \" : \" + str(occur[0])+\" \"+\"Initial costs : \"+str(occur[1]).strip(\"[\"+\"]\")+\"\\n\")","def print_histogram(data, columns=0, key_format=None):\n # TODO(maruel): Add dots for tens.\n if not data:\n # Nothing to print.\n return\n\n columns = columns or get_console_width()\n key_format = key_format or '%s'\n\n max_key_width = max(len(key_format % k) for k in data)\n # 3 == 1 for ' ' prefix, 2 for ': ' suffix.\n width = columns - max_key_width - 3\n assert width > 1\n\n maxvalue = max(data.values())\n if all(isinstance(i, int) for i in data.values()) and maxvalue < width:\n width = maxvalue\n norm = float(maxvalue) / width\n\n form = '%s: %s%s%s'\n for k in sorted(data):\n line = '*' * int(data[k] / norm)\n key = (key_format % k).rjust(max_key_width)\n print(form % (key, colorama.Fore.GREEN, line, colorama.Fore.RESET))","def display(self):\n for value, prob in self.items():\n print(value, prob)","def print_hist(a_column, a_category):\n plt.hist(a_column)\n plt.title(\"Histogram for {} variable\".format(a_category))\n plt.xlabel(a_category)\n plt.ylabel(\"frequency\")\n plt.show()","def bar_grapgh(dictionary, variable):\r\n plt.clf() # Deletes the previous plot \r\n plt.hist(dictionary[variable])\r\n plt.title('Histogram of ' + variable)\r\n plt.xlabel(variable)\r\n plt.ylabel('Frequency')\r\n plt.savefig(variable)","def display(\n self, start=None, stop=None, step=None, format=\"%14.4f\", show_empty=False\n ):\n collection = self.collect(start, stop, step)\n print(\"Histogram\")\n print(\"=========\")\n size = len(format % 0)\n sformat = \"%\" + str(size) + \"s\"\n columns = [\"Range Start\", \"Range End\", \"Count\", \"Bins\"]\n formats = [sformat % s for s in columns]\n print(*formats)\n print(\"-\" * (size * 4 + 3))\n total = 0.0\n for row in collection:\n count = row[\"count\"]\n total += count\n if show_empty or count > 0:\n print(\n format % row[\"value_start\"],\n format % row[\"value_stop\"],\n format % count,\n (\n sformat\n % (\"[%s-%s]\" % (row[\"bin_index_start\"], row[\"bin_index_stop\"]))\n ),\n )\n print(\"-\" * (size * 4 + 3))\n print((\"Total: \" + format) % total)","def histogram_print(lista):\n divisor = ((lista[0])[1])//50\n def slashout(value):\n \"\"\"a function that converts a number into the appropriate\n number of slashes\"\"\"\n intvalue = value//divisor\n slashes = \"#\" * intvalue\n return slashes\n\n for item in lista:\n print(\"{} \\t\\t {}\".format(item[0], slashout(item[1])))","def _dumpHistos ( cmp , *args ) :\n _histos = cmp.Histos()\n for _k in _histos :\n _h = _histos[_k]\n if hasattr ( _h , 'dump' ) :print _h.dump( *args )","def _dumpHistos ( cmp , *args ) :\n _histos = cmp.Histos()\n for _k in _histos :\n _h = _histos[_k]\n if hasattr ( _h , 'dump' ) :print _h.dump( *args )","def plot_histogram(hist, outname, xlabel=\"\", ylabel=\"frequency\"):\n plt.bar(hist[:,0], hist[:,1])\n plt.xlabel(xlabel)\n plt.ylabel(ylabel)\n plt.savefig(outname)\n plt.close()","def main():\n print_hist_new(histogram_new(get_pledge_list()))","def makeHistogram(values, numBins, xLabel, yLabel, title=None):","def plot_hitstogram_graph(data_values, title,\r\n number_of_keys,\r\n max_val,\r\n file_in):\r\n\r\n # bins = max(data_values)\r\n # pylab.hist(data_values, facecolor='blue')\r\n pylab.hist(data_values, facecolor='green', alpha=0.6)\r\n pylab.grid(True)\r\n pylab.title(title + \"_histogram\")\r\n pylab.xlabel('number in cluster')\r\n pylab.ylabel('Count')\r\n pylab.savefig(file_in + \"_\" + title + '_histogram.png')\r\n plt.close()\r\n pylab.close()\r\n os.chdir('..')","def hist(self):\r\n plt.hist(self.data_array, bins='auto', density=False, facecolor='b')\r\n plt.title(self.column_name)\r\n plt.savefig(self.column_name + \".svg\")\r\n plt.close()","def draw_histogram(m, rolls, width):\n # Count the number of rolls of each side and store them in a list\n roll_count = []\n for i in list(range(1, m+1)):\n count = rolls.count(i)\n roll_count.append(count)\n\n # Finding the the maximum count from the list\n max_count = max(roll_count)\n\n print(\"Frequency Histogram: \" + str(m) + \"-sided Die\")\n\n # Counting the number of same outputs and then scaling these outputs\n # to the given width\n for j in list(range(1, m+1)):\n count = rolls.count(j)\n scaled_count = round(count*(width/max_count))\n print(str(j)+'.', end='')\n print('#'*scaled_count, end='')\n print('-'*(width-scaled_count))","def print_histogram(input_data):\n\n input_data.sort()\n largest_class_number = len(str(input_data[-1]))\n current_index = 1 # missä luokassa ollaan menossa\n count = 0 # kuinka monta alkiota tässä luokassa\n\n for number in input_data:\n if len(str(number)) > current_index: # jos luokka vaihtuu\n\n # jos vaihtu enemmän ku yks luokka kerralla\n # nii loopataan sen verran \"tyhjii\" rivei histrogrammiin\n for _ in range(len(str(number)) - current_index):\n print_single_histogram_line(current_index, count,\n largest_class_number)\n current_index += 1\n count = 0\n\n count = 1\n else:\n count += 1\n\n # lopuks viel viimenenki rivi sinne mukaan\n print_single_histogram_line(current_index, count, largest_class_number)","def show_histograms(self, n_samples=1000):\n\n ps = self.gen(n_samples)\n util.plot.plot_hist_marginals(ps, lims=get_disp_lims())\n plt.show()","def test_format_histograms(self):\r\n self.assertEqual(format_histograms(array([0, 1, 0, 2, 2, 3]),\r\n array(\r\n [2, 1, 0, 2, 0, 0]), array(\r\n [0, 0, 0, 2, 0, 1]),\r\n array(\r\n [100, 110, 120, 130, 140, 150, 160])),\r\n \"\"\"# bins raw sequence lengths, length of sequences that pass quality filters before processing, and lengths of sequences that pass quality filters post processing.\\nLength\\tRaw\\tBefore\\tAfter\\n100\\t0\\t2\\t0\\n110\\t1\\t1\\t0\\n120\\t0\\t0\\t0\\n130\\t2\\t2\\t2\\n140\\t2\\t0\\t0\\n150\\t3\\t0\\t1\"\"\")","def create_histogram(data_dict,\r\n x_label=\"X\",\r\n y_label=\"Count\",\r\n title=\"Histogram\",\r\n log_x=False,\r\n bins=\"auto\"):\r\n\r\n # copy the dict so we don't change it\r\n data = copy.copy(data_dict)\r\n\r\n # take the log of the data if appropriate\r\n if log_x:\r\n for key in data.keys():\r\n if not data[key] == 0:\r\n data[key] = np.log(data[key])\r\n\r\n # create the list of X data\r\n X = list(data.values())\r\n\r\n # plot the histogram\r\n plt.style.use('Solarize_Light2')\r\n plt.hist(X, bins=bins)\r\n\r\n # add titles\r\n plt.xlabel(x_label)\r\n plt.ylabel(y_label)\r\n plt.title(title)\r\n\r\n # display the plot\r\n plt.show()","def plot_hist(self):\n labels = [self.get_class_str(action, obj)\n for (action, obj, subj, rec, beg, end) in self.action_clips]\n visualize.plot_hist(labels, proportion=True)","def ascii_hist(x):\n fAbs = frecuencia_abs(x)\n for k in sorted(fAbs):\n print(\"{0:5d} {1}\".format(k, \"+\"*fAbs[k]))","def histogramintegrals(self):\n return {}","def print_dict(data):\n print data","def Pretty_print(summary):\n print('Length of the dictionary: {}'.format(len(summary)))\n print('Word', ' ', 'Count')\n print('-------------------------')\n # Sort the dictionary by value\n for word, count in sorted(summary.items(), key=lambda kv: kv[1], reverse=True):\n print(\"{:17} {:5}\".format(word, count))","def print_metrics(self):\n output = \"\"\n metrics = self.get_all_metrics()\n for k, v in metrics.items():\n # Print the help line\n output += \"\\n# HELP {name} {help}\\n\".format(name=v['name'],\n help=v['help'])\n # and the type line\n output += \"# TYPE {name} {type}\\n\".format(name=v['name'],\n type=v['type'])\n for sample in v['values']:\n labels = json.loads(sample, object_pairs_hook=OrderedDict)\n if v['type'] == 'histogram' and labels.get('le') == '_sum':\n labels.pop('le', None)\n mname = '{name}_sum'.format(name=v['name'])\n elif v['type'] == 'histogram' and labels.get('le') == '+Inf':\n labels.pop('le', None)\n mname = '{name}_count'.format(name=v['name'])\n elif v['type'] == 'histogram':\n mname = '{name}_bucket'.format(name=v['name'])\n else:\n mname = v['name']\n output += \"{name}{labels} {value}\\n\".format(name=mname,\n labels=self.format_labels(labels),\n value=self.format_value(v['values'][sample]))\n return output","def histogram(self):\n return self._hist","def make_histogram(cadena):\r\n hist = dict()\r\n for c in cadena:\r\n hist[c] = hist.get(c, 0) + 1\r\n \r\n if \"\\n\" in hist:\r\n del hist[\"\\n\"] \r\n return hist","def plotHist(self):\n X = []\n Y = []\n for item in self.hist.items():\n X.append(int(item[0]))\n Y.append(int(item[1]))\n plt.bar(X,Y, align='center')\n plt.xticks([1,2,3,4,5,6,7])\n plt.ylim(0,len(self.responses))\n plt.title(self.text)\n plt.xlabel('Number of Responses')\n plt.ylabel('Value of Response')\n for x, y in zip(X, Y):\n plt.text(x, y, str(y), ha='center', va='bottom')\n plt.show()","def histogram(self, number_concentration=True):\n\n\t\tresp = []\n\t\tself.spi.transfer([0x30], [0x00], 1)\n\t\ttime.sleep(10e-3)\n\t\tfor i in range(62):\n\t\t\trb = [0x00]\n\t\t\tself.spi.transfer([0x00], rb, 1)\n\t\t\tif rb[0] < 0:\n\t\t\t\trb[0] += 256\n\t\t\tresp.append(rb[0])\n\t\t\n\t\tself._hist_dict['bin0'] = _16bit_unsigned(resp[0], resp[1])\n\t\tself._hist_dict['bin1'] = _16bit_unsigned(resp[2], resp[3])\n\t\tself._hist_dict['bin2'] = _16bit_unsigned(resp[4], resp[5])\n\t\tself._hist_dict['bin3'] = _16bit_unsigned(resp[6], resp[7])\n\t\tself._hist_dict['bin4'] = _16bit_unsigned(resp[8], resp[9])\n\t\tself._hist_dict['bin5'] = _16bit_unsigned(resp[10], resp[11])\n\t\tself._hist_dict['bin6'] = _16bit_unsigned(resp[12], resp[13])\n\t\tself._hist_dict['bin7'] = _16bit_unsigned(resp[14], resp[15])\n\t\tself._hist_dict['bin8'] = _16bit_unsigned(resp[16], resp[17])\n\t\tself._hist_dict['bin9'] = _16bit_unsigned(resp[18], resp[19])\n\t\tself._hist_dict['bin10'] = _16bit_unsigned(resp[20], resp[21])\n\t\tself._hist_dict['bin11'] = _16bit_unsigned(resp[22], resp[23])\n\t\tself._hist_dict['bin12'] = _16bit_unsigned(resp[24], resp[25])\n\t\tself._hist_dict['bin13'] = _16bit_unsigned(resp[26], resp[27])\n\t\tself._hist_dict['bin14'] = _16bit_unsigned(resp[28], resp[29])\n\t\tself._hist_dict['bin15'] = _16bit_unsigned(resp[30], resp[31])\n\n\t\tself._hist_dict['bin1_MToF'] = _calculate_mtof(resp[32])\n\t\tself._hist_dict['bin3_MToF'] = _calculate_mtof(resp[33])\n\t\tself._hist_dict['bin5_MToF'] = _calculate_mtof(resp[34])\n\t\tself._hist_dict['bin7_MToF'] = _calculate_mtof(resp[35])\n\n\t\tself._hist_dict['sfr'] = _calculate_float(resp[36:40])\t\t## Sample flow rate\n\n\t\t## Alright, we don't know whether it is temp or pressure since it switches...\n\t\ttmp = _calculate_pressure(resp[40:44])\n\t\tif tmp > 98000:\n\t\t\tself._hist_dict['temperature'] = None\n\t\t\tself._hist_dict['pressure'] = tmp\n\t\telse:\n\t\t\ttmp = _calculate_temp(resp[40:44])\n\t\t\tif tmp < 500:\n\t\t\t\tself._hist_dict['temperature'] = tmp\n\t\t\t\tself._hist_dict['pressure'] = None\n\t\t\telse:\n\t\t\t\tself._hist_dict['temperature'] = None\n\t\t\t\tself._hist_dict['pressure'] = None\n\n\t\tself._hist_dict['period'] = _calculate_float(resp[44:48])\t\t## Sampling period\n\n\t\tself._hist_dict['checksum'] = _16bit_unsigned(resp[48], resp[49])\n\n\t\tself._hist_dict['PM1'] = _calculate_float(resp[50:54])\n\t\tself._hist_dict['PM2.5'] = _calculate_float(resp[54:58])\n\t\tself._hist_dict['PM10'] = _calculate_float(resp[58:])\n\n\t\t## Calculate the sum of the histogram bins\n\t\thistogram_sum = self._hist_dict['bin0'] + self._hist_dict['bin1'] + self._hist_dict['bin2'] + \\\n\t\t\t\tself._hist_dict['bin3'] + self._hist_dict['bin4'] + self._hist_dict['bin5'] + self._hist_dict['bin6'] + \\\n\t\t\t\tself._hist_dict['bin7'] + self._hist_dict['bin8'] + self._hist_dict['bin9'] + self._hist_dict['bin10'] + \\\n\t\t\t\tself._hist_dict['bin11'] + self._hist_dict['bin12'] + self._hist_dict['bin13'] + self._hist_dict['bin14'] + \\\n\t\t\t\tself._hist_dict['bin15']\n\n\t\t## Check that checksum and the least significant bits of the sum of histogram bins are equivilant\n\t\tif (histogram_sum & 0x0000FFFF) != self._hist_dict['checksum']:\n\t\t\tprint(f\"[{self.__class__.__name__}::histogram] CHECKSUM ERROR: Data transfer was incomplete\")\n\t\t\treturn None\n\n\t\t## If number_concentration flag is set, convert histogram values to number concentration\n\t\tif number_concentration is True:\n\t\t\t_conv_ = self._hist_dict['sfr'] * self._hist_dict['period'] \t## Divider in units of ml (cc)\n\n\t\t\tself._hist_dict['bin0'] /= _conv_\n\t\t\tself._hist_dict['bin1'] /= _conv_\n\t\t\tself._hist_dict['bin2'] /= _conv_\n\t\t\tself._hist_dict['bin3'] /= _conv_\n\t\t\tself._hist_dict['bin4'] /= _conv_\n\t\t\tself._hist_dict['bin5'] /= _conv_\n\t\t\tself._hist_dict['bin6'] /= _conv_\n\t\t\tself._hist_dict['bin7'] /= _conv_\n\t\t\tself._hist_dict['bin8'] /= _conv_\n\t\t\tself._hist_dict['bin9'] /= _conv_\n\t\t\tself._hist_dict['bin10'] /= _conv_\n\t\t\tself._hist_dict['bin11'] /= _conv_\n\t\t\tself._hist_dict['bin12'] /= _conv_\n\t\t\tself._hist_dict['bin13'] /= _conv_\n\t\t\tself._hist_dict['bin14'] /= _conv_\n\t\t\tself._hist_dict['bin15'] /= _conv_\n\n\t\ttime.sleep(0.1)\n\t\treturn self._hist_dict","def drawHist(data, xLabel, unit, binSize, title):\n mean = np.mean(data)\n median = np.median(data)\n mode = stats.mode(data)[0].astype(float)\n \n q1, q3 = np.percentile(data, [25, 75])\n iqr = q3 - q1\n sigma = np.std(data)\n \n \n bins = np.arange(min(data), max(data) + 1, binSize)\n plt.style.use('dark_background')\n fig, ax = plt.subplots(figsize=(12,7))\n plt.hist(data, bins=bins, histtype='bar') \n plt.title(title)\n plt.xlabel(xLabel + \" \" + unit)\n plt.ylabel('count')\n ymax = ax.get_ylim()[1]\n ax.vlines(mean, 0, ymax, color='red', label='mean')\n ax.vlines(mean-sigma, 0, ymax, color='red', linestyle='--', \n label='mean +/- std')\n ax.vlines(mean+sigma, 0, ymax, color='red', linestyle='--')\n plt.legend()\n plt.show()\n \n print(\"Einheit: \", unit)\n print(\"Minimum: \", round(data.min(),3))\n print(\"Maximum: \", round(data.max(),3))\n print(\"Mittelwert: \", round(mean,3))\n print(\"Median: \", round(median,3))\n print(\"Modus: \", round(mode[0],3))\n print(\"Standardabweichung: \", round(sigma, 3))\n print(\"1. Quartil: \", round(q1,3))\n print(\"3. Quartil: \", round(q3,3))\n print(\"Quartilsdifferenz: \", round(iqr,3))","def showHistogram(x,y,txt,**options):\n plot2d_system = pyformex.cfg['gui/plot2d']\n\n if plot2d_system == 'gnuplot':\n if not utils.hasModule('gnuplot'):\n error(\"You do not have the Python Gnuplot module installed.\\nI can not draw the requested plot.\")\n return\n \n import Gnuplot\n maxlen = min(len(x),len(y))\n data = Gnuplot.Data(x[:maxlen],y[:maxlen],title=txt, with_='histeps') \n g = Gnuplot.Gnuplot(persist=1)\n g.title('pyFormex histogram: %s' % txt)\n g.plot(data)\n \n elif plot2d_system == 'qwt':\n pass\n #from PyQt4.Qwt5.qplt import *","def write_hist(fname='~/.ipyhist.py'):\n import os\n vseparator = '#' + '#'*62 + '#\\n'\n nextcmdfmt = vseparator + '# In[{}]:\\n{}\\n'\n outputfmt = '#' + '-'*62 + '#\\n# Out[{}]:\\n# {}\\n'\n with open(os.path.expanduser(fname), 'w') as outfile:\n for i in range(len(In)):\n outfile.write(nextcmdfmt.format(i, In[i]))\n if Out.has_key(i):\n out = repr(Out[i]).replace('\\n', '\\n# ')\n outfile.write(outputfmt.format(i, out))","def mostrar_histograma(self):\n histograma = self.imagem_core.get_histograma()\n\n graph = Graph(\n xlabel='Tom de Cinza',\n ylabel='Quantidade de tons',\n padding=5,\n xmin=0,\n xmax=max(histograma.keys()),\n ymin=0,\n ymax=max(histograma.values())\n )\n plot = MeshLinePlot()\n plot.points = histograma.items()\n graph.add_plot(plot)\n self.widgets_dinamicos.append(graph)\n self.add_widget(graph)","def hog_histograms(*args, **kwargs): # real signature unknown\n pass","def printResults(self):\n for key in self.mDict.keys():\n print ('for {:d}, entries = {:d} and exits = {:d}'.format (key, self.mDict.get(key).get ('entries'), self.mDict.get(key).get ('exits')))","def format_histogram_one_count(counts, bin_edges):\r\n lines = []\r\n lines.append('Length\\tCount')\r\n for edge, count in zip(bin_edges, counts):\r\n lines.append('\\t'.join(map(str, [edge, count])))\r\n return '\\n'.join(lines)","def printDicts():\n for k in key:\n print k, key[k]\n \n for f in freq:\n print f, freq[f]\n \n for e in english:\n print e, english[e]","def plot_histogram(self) -> None:\n\n if self.data:\n plt.hist(self.data)\n plt.title(\"Histogram of data\")\n plt.xlabel(\"data\")\n plt.ylabel(\"count\")\n else:\n raise ValueError(\"Histogram cannot be generated as no\\\n data has been provided\")","def plot_counter(counter, outname, xlabel=\"\", ylabel=\"frequency\"):\n x = sorted(counter.keys())\n y = [counter[k] for k in x]\n plt.bar(x,y)\n plt.xlabel(xlabel)\n plt.ylabel(ylabel)\n plt.savefig(outname)\n plt.close()","def display(self):\r\n\t\tfor key, value in self.__dict__.items():\r\n\t\t\tprint(key.upper(), value, sep=': ')\r\n\r\n\t\tprint(\"\")","def print_stats(stats: Dict):\n print()\n print(\" Panelist Scores\")\n print(\" Count: {}\".format(stats[\"count\"]))\n print(\" Minimum: {}\".format(stats[\"minimum\"]))\n print(\" Maximum: {}\".format(stats[\"maximum\"]))\n print(\" Median: {}\".format(stats[\"median\"]))\n print(\" Mean: {}\".format(stats[\"mean\"]))\n print(\" Std Dev: {}\".format(stats[\"standard_deviation\"]))\n print(\" Total: {}\".format(stats[\"total\"]))\n print(\"\\n\\n\")\n return","def histogram(list):\n for i in range(0,len(list)):#go over the number in the list\n print('*'*list[i])","def phist():\n history = hist();\n for line in history:\n print(line, \":\", history[line])","def setup_hist(self):\n self.x_min = {}\n self.x_max = {}\n self.x_max_minus_min = {}\n self.dx = {}\n self.n_bins = {}\n\n self.histogram_edges = {}\n self.histogram_values = {}\n self.histogram_cdf = {}","def hist_of_numeric(X):\n figsize(10,3)\n for col in get_numeric(X):\n print(col)\n X[col].hist(bins=50)\n show()","def write_weights_histograms(self):\n for weight_name, weight in self._weights.items():\n self._write_weight_histogram_to_tensorboard(\n name=f\"{self._Sections.WEIGHTS}/{weight_name}\",\n weight=weight,\n step=self._epochs,\n )","def print_most_common(self, hist, n=10):\n t = []\n for word,freq in hist.items():\n t.append((freq, word))\n t.sort(reverse=True)\n\n for word,freq in t[:n]:\n print(word, '\\t', freq)","def pprint(self):\r\n for i in self.items():\r\n print '%s => %r'%i","def hist_save(self, d, bin1, name, no):\n\t\tfor i in range(0,no):\n\t\t\ts = d[:,i]\n\t\t\tplt.hist(s, bin1, normed=True, color='c')\t# Extracting the parameters from the histogram\n\t\t\tplt.title('Probability Distribution Fnction of %s' %name, fontsize=20)\n\t\t\tplt.xlabel(\"Filter tap values\", fontsize=20)\n\t\t\tplt.ylabel(\"Probability Distribution\", fontsize=20)\n#\t\t\tplt.xlim(0,0.10)\n\t\t\tplt.ylim(0,100)\n#\t\t\tplt.legend(fontsize = 'xx-large')\n\t\t\tplt.savefig('/home/abhishek/Results/comparison_all_sets/Curve fitting/test/set_1/hist_%s_index_%d' %(name,i))\n\t\t\tplt.close()","def plotting(self, figsize=(12, 12), types=['freqs']):\n ax = plt.figure(figsize=figsize)\n if 'freqs' in types:\n count_dict = self.count_freq(types=1)\n plt.title(\n f'Total keys in count_dict: {sum(list(count_dict.values()))}')\n barh = plt.barh(list(count_dict.keys()), list(count_dict.values()), color=[\n np.random.rand(3,) for _ in range(self.categories)])\n for rect in barh:\n height = rect.get_height()\n plt.text(rect.get_x() + rect.get_height()/2.0, height,\n '%d' % int(height), ha='center', va='bottom')\n\n plt.legend()\n plt.show()","def display_dict() -> None:\n for key in ascii_dict:\n print(key, ': ')\n for line in ascii_dict[key]:\n print(line)","def output_metrics(self):\n print('')\n for key in sorted(self.metrics):\n print('{}:'.format(key), end='')\n for k, v in self.metrics[key].items():\n if type(v[-1]) is list:\n print('\\t' + k + ': ' + ''.join('{:5.3f} '.format(vs) for vs in v[-1]), end='')\n else:\n print('\\t{}: {:5.3f}'.format(k, v[-1]), end='')\n print('\\n', end='')","def histogram(end_statistics: EndStatistics, n: int, gc_content: float) -> str:\n sio = StringIO()\n\n print(\"length\", \"count\", \"expect\", \"max.err\", \"error counts\", sep=\"\\t\", file=sio)\n for row in histogram_rows(end_statistics, n, gc_content):\n print(\n row.length,\n row.count,\n f\"{row.expect:.1F}\",\n row.max_err,\n \" \".join(str(e) for e in row.error_counts),\n sep=\"\\t\",\n file=sio,\n )\n return sio.getvalue() + \"\\n\"","def printing_summary_gene_report(gene_dict):\n #Creating a summary report for data\n summary_gene_report = open('summary_gene_report.txt', 'w')\n summary_gene_report.write(\"Accesssion ID\\tDescription\\tCounts\\n\")\n for key in gene_dict:\n accession_ID=str(key) \n gene_description=str(gene_dict[key][0])\n gene_counts=str(gene_dict[key][1])\n summary_gene_report.write(accession_ID+\"\\t\"+gene_description+\"\\t\"+gene_counts+\"\\n\")\n summary_gene_report.close()","def cassandra_histograms(mycluster=RING_1_dev__allnodes):\n cassandra_nodetool(mycluster,cmd=\"cfhistograms\")","def show_histograms(n_samples=1000):\n\n true_ps, obs_xs = get_ground_truth()\n\n prior = Prior()\n model = Model()\n stats = Stats()\n\n ps = prior.gen(n_samples)\n data = stats.calc(model.sim(ps))\n cond_data = stats.calc(model.sim(np.tile(true_ps, [n_samples, 1])))\n\n # plot prior parameter histograms\n fig = util.plot.plot_hist_marginals(ps, lims=get_disp_lims(), gt=true_ps)\n fig.suptitle('p(thetas)')\n\n # plot stats histograms\n fig = util.plot.plot_hist_marginals(data, gt=obs_xs)\n fig.suptitle('p(stats)')\n\n # plot stats histograms, conditioned on true params\n fig = util.plot.plot_hist_marginals(cond_data, gt=obs_xs)\n fig.suptitle('p(stats|true thetas)')\n\n plt.show()","def num_54():\n frmt = \"\"\"\n :{}\n :Generate Data that conform to a uniform distribution.\n :\n :Class values: {}\n :Population size: {}\n :Results:\n : values:\n {}\n : table:\n {}\n : histogram: (class, frequency)\n {}\n :Then use NumPyArrayToTable to get your table.\n \"\"\"\n # import numpy as np\n st = 1\n end = 7\n vals = np.arange(st,end)\n reps = 10\n z = np.repeat(vals,reps)\n np.random.shuffle(z)\n ID = np.arange(len(z))\n tbl = np.array(list(zip(ID, z)), \n dtype = [('ID', 'int'), ('Class', 'int')])\n h = np.histogram(z, np.arange(st, end+1))\n h = np.array(list(zip(h[1], h[0])))\n pad = \" \"\n args =[num_54.__doc__, vals, reps*len(vals),\n indent(str(z.reshape(3,20)), pad),\n indent(str(tbl), pad), indent(str(h), pad)]\n print(dedent(frmt).format(*args))","def histogram(self):\r\n channel = self.ui.channel_selection.itemData(self.ui.channel_selection.currentIndex())\r\n\r\n #create a window, the reference must be stored, because the window\r\n #gets destroyed when its reference is garbage collected\r\n #make plotWindow a list and append to that if multiple windows should be possible\r\n title = \"histogram of {:s} channel\".format(self.ui.channel_selection.currentText())\r\n self.plotWindow = pyguitools.SimplePlotWindow(name = title)\r\n self.plotWindow.ax1.hist(self.npImg[self.ui.y0.value():self.ui.y1.value(),\r\n self.ui.x0.value():self.ui.x1.value(), \r\n channel].flatten(),\r\n bins=self.settings[\"histogramm bins\"],\r\n range=(self.settings[\"histogramm min\"],self.settings[\"histogramm max\"]))\r\n self.plotWindow.ax1.set_xlim(self.settings[\"histogramm min\"],self.settings[\"histogramm max\"]) \r\n self.plotWindow.show()","def histogram(l):\n return \"\\n\".join(map(lambda ls: \"#\"*ls, l))","def distribution_magnitude_histogram(cur, var, table, label):\n x = select(cur,var, table)\n print(\"Number of entries: \", len(x))\n print(\"Maximum: \", max(x))\n print(\"Minimum: \", min(x))\n \n fig = plt.figure()\n ax = fig.add_subplot(1,1,1)\n ax.set_xlabel(\"Sentiment Magnitude\")\n ax.set_ylabel(\"Number of Sentences\")\n fig.suptitle(label)\n ax.hist(x, bins = 20)\n plt.show()","def display(self, bin_size):\n xs = np.linspace(self.sample_min, self.sample_max, 2000)\n ys = np.zeros_like(xs)\n for (l, s), w in zip(self.gauss_params, self.dist_weights):\n ys += ss.norm.pdf(xs, loc=l, scale=s) * w\n plt.plot(xs, ys, color=\"blue\")\n plt.hist(self.samples, density=True, bins=bin_size, color=\"palegreen\")\n plt.xlabel(\"duration\")\n plt.ylabel(\"density\")\n _, _, ymin, ymax = plt.axis()\n if self.lower_bound > 0:\n plt.vlines([self.lower_bound], ymin, ymax, color=\"crimson\")\n if self.upper_bound < float(\"inf\"):\n plt.vlines([self.upper_bound], ymin, ymax, color=\"crimson\")\n plt.show()","def create_histograms(PrimaryParticleName, LongVectorSignals, LongVectorSignalsCher,\n\tShortVectorSignals, ShortVectorSignalsCher, LongScinMaxFiber, LongCherMaxFiber, \n\tShortScinMaxFiber, ShortCherMaxFiber, EnergyTotContainer, MaxEnergyTotContainer):\n\n\t#Set ROOT histograms\n\tTH1LongScin = TH1F(\"LongScintillation\", PrimaryParticleName, 100, 0.0, LongScinMaxFiber+200.)\n\tTH1LongCher = TH1F(\"LongCherenkov\", PrimaryParticleName, 100, 0.0, LongCherMaxFiber+200.)\n\tTH1ShortScin = TH1F(\"ShortScintillation\", PrimaryParticleName, 100, 0.0, ShortScinMaxFiber+200.)\n\tTH1ShortCher = TH1F(\"ShortCherenkov\", PrimaryParticleName, 100, 0.0, ShortCherMaxFiber+200.)\n\tTH1EnergyTot = TH1F(\"EnergyTot\", PrimaryParticleName, 100, MaxEnergyTotContainer-10000., MaxEnergyTotContainer+500.) \n\n\t#Fill histograms in for loop\n\tfor index in range(len(LongVectorSignals)):\n\t\tTH1LongScin.Fill(LongVectorSignals[index])\n\t\tTH1LongCher.Fill(LongVectorSignalsCher[index])\n\t\tTH1ShortScin.Fill(ShortVectorSignals[index])\n\t\tTH1ShortCher.Fill(ShortVectorSignalsCher[index])\n\t\tTH1EnergyTot.Fill(EnergyTotContainer[index])\n\n\t#Draw + DrawOptions\n\tStyle = gStyle\n\tStyle.SetOptStat(1) #Show statistics\n\tStyle.SetLineWidth(1)\n\tXAxis = TH1LongScin.GetXaxis() #TH1LongScin\n\tXAxis.SetTitle(\"Energy (MeV)\")\n\tXAxis.SetTitleOffset(1.2)\n\tYAxis = TH1LongScin.GetYaxis()\n\tYAxis.SetTitle(\"Entries\")\n\tTH1LongScin.Draw()\n\tgPad.SaveAs(\"EnergyLongScin.eps\")\n\tXAxis = TH1LongCher.GetXaxis() #TH1LongCher\n\tXAxis.SetTitle(\"# Cher p.e.\")\n\tXAxis.SetTitleOffset(1.2)\n\tYAxis = TH1LongCher.GetYaxis()\n\tYAxis.SetTitle(\"Entries\")\n\tTH1LongCher.Draw()\n\tgPad.SaveAs(\"CherpeLong.eps\")\n\tXAxis = TH1ShortScin.GetXaxis() #TH1ShortScin\n\tXAxis.SetTitle(\"Energy (MeV)\")\n\tXAxis.SetTitleOffset(1.2)\n\tYAxis = TH1ShortScin.GetYaxis()\n\tYAxis.SetTitle(\"Entries\")\n\tTH1ShortScin.Draw()\n\tgPad.SaveAs(\"EnergyShortScin.eps\")\n\tXAxis = TH1ShortCher.GetXaxis() #TH1ShortCher\n\tXAxis.SetTitle(\"# Cher p.e.\")\n\tXAxis.SetTitleOffset(1.2)\n\tYAxis = TH1ShortCher.GetYaxis()\n\tYAxis.SetTitle(\"Entries\")\n\tTH1ShortCher.Draw()\n\tgPad.SaveAs(\"CherpeShort.eps\")\n\tXAxis = TH1EnergyTot.GetXaxis() #TH1EnergyTot\n\tXAxis.SetTitle(\"Energy (MeV)\")\n\tXAxis.SetTitleOffset(1.2)\n\tYAxis = TH1EnergyTot.GetYaxis()\n\tYAxis.SetTitle(\"Entries\")\n\tTH1EnergyTot.Draw()\n\tgPad.SaveAs(\"EnergyTot.eps\")","def printHashtagsDict(self):\n print(\"========Top 10 Hashtags=========\")\n hashtagList = sorted(self.hashDict, key=self.hashDict.get, reverse=True)\n count = 0\n for hashtag in hashtagList:\n print(hashtag, self.hashDict[hashtag])\n count += 1\n if count >= 10:\n return","def printDict(self):\n print str(self)","def print_table(self) -> None:\n if (self.probability_links == None):\n print(\"+--------+\")\n print(f\"| P({self.key:1s}) |\")\n print(\"+--------+\")\n print(f\"| {self.probability_values[0]:0.04f} |\")\n print(\"+--------+\")\n else:\n arg_len = 2 + len(' '.join(self.probability_links.keys()))\n param_len = 2 + \\\n max(6, len(\"P(A|)\" + \",\".join(self.probability_links.keys())))\n print(f\"+{'-'*arg_len}+{'-'*param_len}+\")\n print(\n f\"| {' '.join(self.probability_links.keys())} | P({self.key}|{','.join(self.probability_links.keys())}) |\")\n print(f\"+{'-'*arg_len}+{'-'*param_len}+\")\n for i in range(2**len(self.probability_links.keys())):\n # Gives us a string binary value to make truth table off of\n bool_key = f\"{i:0{len(self.probability_links.keys())}b}\"\n print(\n f\"| {' '.join(['T' if bool_key[j] == '0' else 'F' for j in range(len(self.probability_links.keys()))])} | {f'{self.probability_values[i]:0.04f}':<{param_len-1}s}|\")\n print(f\"+{'-'*arg_len}+{'-'*param_len}+\")","def show_histogram(im):\n\n if im.ndim == 2:\n # Input image is single channel\n plt.hist(im.flatten(), 256, range=(0, 250), fc='k')\n plt.show()\n\n elif im.ndim == 3:\n # Input image is three channels\n fig = plt.figure()\n fig.add_subplot(311)\n plt.hist(im[..., 0].flatten(), 256, range=(0, 250), fc='b')\n fig.add_subplot(312)\n plt.hist(im[..., 1].flatten(), 256, range=(0, 250), fc='g')\n fig.add_subplot(313)\n plt.hist(im[..., 2].flatten(), 256, range=(0, 250), fc='r')\n plt.show()","def print_metric_dict(self, metric_dict):\n print(\"\".join([\" {}: {:4f},\".format(k, v) for k, v in metric_dict.items()]))","def format_histograms(raw_hist, pre_hist, post_hist, bin_edges):\r\n lines = []\r\n lines.append('# bins raw sequence lengths, length of sequences that '\r\n 'pass quality filters before processing, and lengths of sequences that '\r\n 'pass quality filters post processing.')\r\n lines.append('Length\\tRaw\\tBefore\\tAfter')\r\n for edge, raw, pre, post in zip(bin_edges, raw_hist, pre_hist, post_hist):\r\n lines.append('\\t'.join(map(str, [edge, raw, pre, post])))\r\n return '\\n'.join(lines)","def histogram(values, title, fig_size=(4,3), path=None):\n plt.clf()\n f, ax = plt.subplots(1, figsize=fig_size)\n ax.hist(values, bins=60)\n ax.set_title(title)\n f.tight_layout()\n if(path != None):\n f.savefig(path+'/hist_'+title+'.png')","def print_table(album_dict, filename):\n print()\n print(\"Album Catalogue Summary\")\n print(\"-\" * 60)\n print('{:<5}{:<30}{:>10}{:>15}'.format(\"ID\", \"ALBUM NAME\", \"# SOLD\", \"CERTIFICATE\"))\n sorted_albums = sorted(album_dict.values(), key=total_sold, reverse=True)\n for album in sorted_albums:\n print(album)\n print()\n print(\"Sales Bar Graph\")\n print(\"-\" * 30)\n print(\" {:<4}{:>5}\".format(\"ID\", \"Freq Graph\"))\n total_sales = 0\n for album in sorted_albums:\n total_sales += int(album.total_sold)\n print_graph(sorted_albums, total_sales)\n make_barchart(album_dict, sorted_albums, filename, total_sales)","def print(self):\n for fiction in self.fictions:\n print(fiction.__dict__)","def save_hist(data, fname, title=''):\n fig = plt.figure()\n ax = fig.add_subplot(111)\n im = ax.hist(data.flatten(),bins=100,range=[0,1])\n plt.savefig(fname, dpi=100)\n plt.close(fig)","def printt(dictionnary):\n for key, value in dictionnary.iteritems():\n print('{key}, size: {size}, {values}'.format(key=key, \n size=len(value), values=value[0:4]))","def build_histogram(iterator, key):\n buckets = defaultdict(int)\n values = {}\n\n num_objects = 0\n for obj in iterator:\n num_objects += 1\n\n try:\n val = obj[key]\n except (KeyError, TypeError):\n continue\n\n value_hash = hashlib.sha1()\n value_hash.update(syaml.dump_config(sort_yaml_obj(val)).encode())\n value_hash = value_hash.hexdigest()\n\n buckets[value_hash] += 1\n values[value_hash] = val\n\n return [\n (h, buckets[h], float(buckets[h]) / num_objects, values[h])\n for h in sorted(buckets.keys(), key=lambda k: -buckets[k])\n ]","def draw_histo(df, col_name, x_start, bin_width, n_bins, title, output_dir, output_filename, \n log_y = False, describe = False):\n my_plt = df[col_name].plot.hist(\n bins=[bin_width * (x + 0.5) + x_start for x in np.arange(0, n_bins)], \n edgecolor='black', \n color='#88d498',\n log=log_y)\n my_plt.set_title(title)\n pd.set_option('precision', 3)\n plt.tight_layout(pad=5)\n if(describe): print(df[col_name].describe())\n plt.figtext(0.01,0.01, df[col_name].describe().loc[['mean','std','count']].to_string(),fontsize='x-large')\n my_plt.ticklabel_format(style='sci', axis='x', scilimits=(0,3)) \n my_plt.get_figure().savefig(os.path.join(output_dir,output_filename))\n my_plt.get_figure().clf()","def print_statistics(fib_details: dict, nth_value: int):\n line = '\\n' + (\"---------------\" * 5)\n pass # TODO: Replace with implementation!","def basic_statistics():\n print(train_data['revenue'].describe())\n plt.hist(train_data['revenue'], color = 'blue', edgecolor = 'black',\n bins = int(4))\n\n # Add labels\n plt.title('Histogram of Revenues')\n plt.xlabel('revenues')\n plt.ylabel('P(revenues)')\n plt.show()","def distribution_sentimentscore_histogram(cur, var, table, label):\n x = select(cur,var, table)\n print(\"Number of entries: \", len(x))\n print(\"Maximum: \", max(x))\n print(\"Minimum: \", min(x))\n \n fig = plt.figure()\n ax = fig.add_subplot(1,1,1)\n ax.set_xlabel(\"Sentiment Score\")\n ax.set_ylabel(\"Number of Loans\")\n fig.suptitle(label)\n ax.hist(x, bins = 15)\n plt.show()","def histogram_summary(self, tag, values, step, bins=1000):\n self.writer.add_histogram(tag, values, step, bins='auto')","def plotHistogram(self, var, idx = None, translation = None, other = None,\\\n verbose = 1, ab = [], bins = 100, xlim = None,\\\n cmap = \"tab10\", row = 1, col = 1, N = 1, save = False,\\\n dpi = 100, format = \"pdf\", shift = None, **kwargs):\n \n if idx is None: idx = np.arange(self.atoms.shape[0])\n if translation is None: translation = [0]\n if isinstance(translation, (int, np.integer)): translation = [translation]\n if isinstance(var, str): var = [var]\n\n if other is not None:\n if np.shape(other)[0] != np.shape(idx)[0]:\n string = \"Length of other %s inconsistent with the rest of the data %s\"\\\n % (np.shape(other), np.shape(idx))\n ut.infoPrint(string)\n return\n\n x, y, lbl, leg = self.getHistogram(var = var, idx = idx, translation = translation,\\\n verbose = verbose, ab = ab, other = other,\\\n bins = bins, minmax = xlim)\n\n cmap = kwargs.pop(\"colormap\", cmap)\n c = plt.cm.get_cmap(cmap)(range(len(x)))\n c = kwargs.pop(\"color\", c)\n\n s = 0\n hFig = plt.figure()\n hAx = plt.subplot(row, col, N)\n for i in range(len(x)):\n hAx.plot(x[i], y[i] + s, label = leg[i], color = c[i], **kwargs)\n if shift is not None: s += shift\n\n hAx.set_xlabel(lbl[0])\n hAx.set_ylabel(\"Count\")\n hAx.legend()\n if self.filename is None:\n hAx.set_title(\"Histogram\")\n else:\n hAx.set_title(self.filename)\n \n if save:\n if save is True:\n ut.save_fig(filename = \"Histogram.%s\" % format, format = format,\\\n dpi = dpi, verbose = verbose)\n else:\n ut.save_fig(filename = save, format = format, dpi = dpi,\\\n verbose = verbose)\n plt.close()\n else:\n plt.show()","def print_verb_dict(verb):\n for keys in verb:\n print(f'{keys}: {verb[keys]}')","def displaySummary(self, dictionnary, lineCount):\n for key in self.summaryDict.keys():\n dictionnary[key] = (dictionnary[key] / lineCount) * 100\n #print(str(key)+\" => \"+str(dictionnary[key])+\" %\")","def makeHistogram(values, numBins, xLabel, yLabel, title=None):\n pylab.hist(values, bins = numBins)\n pylab.xlabel(xLabel)\n pylab.ylabel(yLabel)\n if not title == None:\n pylab.title(title)\n pylab.show()","def histogram(word_list):\n assert type(word_list) == list\n\n histogram = {}\n total_words = len(word_list)\n word_frac = 1.0/total_words\n\n for word in word_list:\n if word in histogram: histogram[word] += word_frac\n else: histogram[word] = word_frac\n\n return histogram","def run_print_dict_examples():\n print()\n print_dict_keys(NAME_DICT)\n print()\n print_dict_items(NAME_DICT)","def run_print_dict_examples():\n print()\n print_dict_keys(NAME_DICT)\n print()\n print_dict_items(NAME_DICT)","def magic_hist(self, parameter_s = ''):\n\n if not self.do_full_cache:\n print 'This feature is only available if numbered prompts are in use.'\n return\n opts,args = self.parse_options(parameter_s,'n',mode='list')\n \n default_length = 40\n if len(args) == 0:\n final = self.outputcache.prompt_count\n init = max(1,final-default_length)\n elif len(args) == 1:\n final = self.outputcache.prompt_count\n init = max(1,final-int(args[0]))\n elif len(args) == 2:\n init,final = map(int,args)\n else:\n warn('@hist takes 0, 1 or 2 arguments separated by spaces.')\n print self.magic_hist.__doc__\n return\n width = len(str(final))\n line_sep = ['','\\n']\n for in_num in range(init,final):\n #inline = eval('self.user_ns[\"_i'+str(in_num)+'\"]')\n inline = self.user_ns['_ih'][in_num]\n multiline = inline.count('\\n') > 1\n if not opts.has_key('n'):\n print str(in_num).ljust(width)+':'+ line_sep[multiline],\n if inline.startswith('#@') or inline.startswith('#!'):\n print inline[1:],\n else:\n print inline,","def histogram(data, title, path):\n plt.hist(data,\n bins=60)\n plt.xticks(size=22)\n plt.yticks(size=22)\n plt.title(title,\n fontsize=30)\n plt.savefig(path)\n plt.clf()","def plot_feature_histograms(self):\n\n num_features = len(self.feature_names)\n fig, ax = plt.subplots(nrows=1, ncols=num_features, figsize=(50, 2), tight_layout=True)\n fig.suptitle('Histograms of 19 features', fontsize=14)\n\n for i in range(num_features):\n ax[i].hist(self.train_data[self.train_data.columns[i]], bins=50)\n ax[i].set_xlabel(self.train_data.columns[i])\n\n plt.savefig(r'data_analysis\\histograms_' + self.file_name + '.png', \n facecolor=fig.get_facecolor(), bbox_inches='tight')","def get_histogram_strings(data, padding=0, hist_char=\"\\xf0\\x9f\\x8d\\x95\"):\n max_key_width = max([len(key) for key in data])\n max_val_width = max([len(str(val)) for val in data.values()])\n max_value = max(data.values())\n _, width = get_terminal_size()\n # Find the length we have left for the histogram bars.\n # Magic number 6 is the _():_ parts of the string, and the\n # guaranteed value of one that gets added.\n histogram_width = width - padding - max_key_width - max_val_width - 6\n result = []\n for key, val in data.iteritems():\n preamble = \"{:>{max_key}} ({:>{max_val}}): \".format(\n key, val, max_key=max_key_width, max_val=max_val_width)\n #percentage = float(val) / osx_clients\n percentage = float(val) / max_value\n histogram_bar = int(percentage * histogram_width + 1) * hist_char\n result.append((preamble + histogram_bar).decode(\"utf-8\"))\n return result","def print_metrics(self):\n # num times regular barcodes appear in a simulated doublet nearest neighbors, grouped by value\n # TODO: this list is 2 dimensional... need to extract dimensione with counts for the counter\n frequencies = [i[1] for i in self.num_times_knn]\n counter = collections.Counter(frequencies)\n print(\"##\\nNumber time barcoded in sim doub KNN: {}\".format(counter))\n\n # artificial fraction\n print(\"##\\nArtificial fraction: {}\".format(self.artificial_fraction))\n\n # num doublets\n print(\"##\\nNumber of doublets called: {}\".format(self.num_doublets))","def __str__(self):\n return 'HistogramMatcher:\\n' \\\n ' histogram_levels: {self.histogram_levels}\\n' \\\n ' match_points: {self.match_points}\\n' \\\n ' threshold_mean_intensity: {self.threshold_mean_intensity}\\n' \\\n .format(self=self)","def get_hist(self):\n return self.hist","def print_strand_stats(strand_statistics):\n print(' Total\\tFor\\tRev\\tDif')\n for base, count in strand_statistics.items():\n print(f'{base}: {str(count[0])}\\t{str(count[1])}\\t{str(count[2])}\\t{str(count[3])}')"],"string":"[\n \"def print_hist(h):\\n for k in h:\\n print(k, h[k])\",\n \"def do_hist(self, args):\\n print(self._hist)\",\n \"def show_histo(dict, orient=\\\"horiz\\\", label=\\\"counts\\\", title=\\\"title\\\"):\\n plt.clf()\\n plt.cla()\\n if orient==\\\"horiz\\\":\\n bar_fun = plt.barh \\n bar_ticks = plt.yticks\\n bar_label = plt.xlabel\\n elif orient==\\\"vert\\\":\\n bar_fun = plt.bar\\n bar_ticks = plt.xticks\\n bar_label = plt.ylabel\\n else:\\n raise Exception(\\\"show_histo: Unknown orientation: %s \\\".format % orient)\\n n = len(dict)\\n bar_fun(range(n), list(dict.values()), align='center', alpha=0.4, color = 'g')\\n bar_ticks(range(n), list(dict.keys())) \\n bar_label(label)\\n plt.title(title)\\n plt.show()\",\n \"def _printHist(self):\\n bins = [0] * self.displayBins\\n binSize = self.maxValue / self.displayBins\\n displaySamps = self.samples[:]\\n displaySamps.sort()\\n currLimit = binSize\\n binIndex = 0\\n partIndex = 0\\n while partIndex < self.numParticles:\\n part = displaySamps[partIndex]\\n if binIndex >= self.displayBins:\\n # if value beyond max value, add to last bin and go on to next particle\\n bins[19] += 1\\n partIndex += 1\\n elif part < currLimit:\\n # count particle in current bin, go on to next particle\\n bins[binIndex] += 1\\n partIndex += 1\\n else:\\n # go on to next bin, don't go on to next particle\\n binIndex += 1\\n currLimit += binSize\\n self.printMapPattern(binSize)\\n histStr = \\\"{0:3d} \\\"\\n printStr = \\\"\\\"\\n for b in bins:\\n printStr += histStr.format(b)\\n print(printStr)\",\n \"def ascii_histogram(seq) -> None:\\n counted = count_elements(seq)\\n for k in sorted(counted):\\n print('{0:5d} {1}'.format(k, '+' * counted[k]))\",\n \"def print_histogram(path):\\n with open(path, 'rb') as handle:\\n size = os.fstat(handle.fileno()).st_size\\n mgz.header.parse_stream(handle)\\n operations = defaultdict(int)\\n actions = defaultdict(int)\\n labels = {}\\n fast.meta(handle)\\n while handle.tell() < size:\\n op_type, payload = fast.operation(handle)\\n operations[op_type.name] += 1\\n if op_type == fast.Operation.ACTION:\\n action_id = payload[1]\\n action_id = '{0:#0{1}x}'.format(payload[0].value, 4)\\n labels[action_id] = payload[0].name\\n actions[action_id] += 1\\n print('Operations')\\n print(tabulate([\\n [operation, operations[operation]]\\n for operation in sorted(operations, key=operations.get, reverse=True)\\n ], headers=['Name', 'Count'], tablefmt='simple'))\\n print()\\n print('Actions')\\n print(tabulate([\\n [action, labels[action], actions[action]]\\n for action in sorted(actions, key=actions.get, reverse=True)\\n ], headers=['ID', 'Name', 'Count'], tablefmt='simple'))\",\n \"def _hist_info(ns, hist):\\n data = collections.OrderedDict()\\n data['sessionid'] = str(hist.sessionid)\\n data['filename'] = hist.filename\\n data['length'] = len(hist)\\n data['buffersize'] = hist.buffersize\\n data['bufferlength'] = len(hist.buffer)\\n if ns.json:\\n s = json.dumps(data)\\n print(s)\\n else:\\n lines = ['{0}: {1}'.format(k, v) for k, v in data.items()]\\n print('\\\\n'.join(lines))\",\n \"def histogram(histo,nbr_launch,file):\\n with open(\\\"Results/Histogram_{}_{}.txt\\\".format(nbr_launch,file.strip(\\\".yaml\\\")),'w') as f:\\n f.write(\\\"mgm results :\\\"+\\\"\\\\n\\\")\\n for val,occur in histo[\\\"mgm\\\"].items():\\n f.write(\\\"value \\\"+str(val)+\\\" : \\\"+str(occur[0])+\\\" \\\"+\\\"Initial costs : \\\"+str(occur[1]).strip(\\\"[\\\"+\\\"]\\\")+\\\"\\\\n\\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"mcs_mgm results :\\\" + \\\"\\\\n\\\")\\n for val, occur in histo[\\\"mcs_mgm\\\"].items():\\n f.write(\\\"value \\\" + str(val) + \\\" : \\\" + str(occur[0])+\\\" \\\"+\\\"Initial costs : \\\"+str(occur[1]).strip(\\\"[\\\"+\\\"]\\\")+\\\"\\\\n\\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"gca_mgm results :\\\" + \\\"\\\\n\\\")\\n for val, occur in histo[\\\"gca_mgm\\\"].items():\\n f.write(\\\"value \\\" + str(val) + \\\" : \\\" + str(occur[0])+\\\" \\\"+\\\"Initial costs : \\\"+str(occur[1]).strip(\\\"[\\\"+\\\"]\\\")+\\\"\\\\n\\\")\",\n \"def print_histogram(data, columns=0, key_format=None):\\n # TODO(maruel): Add dots for tens.\\n if not data:\\n # Nothing to print.\\n return\\n\\n columns = columns or get_console_width()\\n key_format = key_format or '%s'\\n\\n max_key_width = max(len(key_format % k) for k in data)\\n # 3 == 1 for ' ' prefix, 2 for ': ' suffix.\\n width = columns - max_key_width - 3\\n assert width > 1\\n\\n maxvalue = max(data.values())\\n if all(isinstance(i, int) for i in data.values()) and maxvalue < width:\\n width = maxvalue\\n norm = float(maxvalue) / width\\n\\n form = '%s: %s%s%s'\\n for k in sorted(data):\\n line = '*' * int(data[k] / norm)\\n key = (key_format % k).rjust(max_key_width)\\n print(form % (key, colorama.Fore.GREEN, line, colorama.Fore.RESET))\",\n \"def display(self):\\n for value, prob in self.items():\\n print(value, prob)\",\n \"def print_hist(a_column, a_category):\\n plt.hist(a_column)\\n plt.title(\\\"Histogram for {} variable\\\".format(a_category))\\n plt.xlabel(a_category)\\n plt.ylabel(\\\"frequency\\\")\\n plt.show()\",\n \"def bar_grapgh(dictionary, variable):\\r\\n plt.clf() # Deletes the previous plot \\r\\n plt.hist(dictionary[variable])\\r\\n plt.title('Histogram of ' + variable)\\r\\n plt.xlabel(variable)\\r\\n plt.ylabel('Frequency')\\r\\n plt.savefig(variable)\",\n \"def display(\\n self, start=None, stop=None, step=None, format=\\\"%14.4f\\\", show_empty=False\\n ):\\n collection = self.collect(start, stop, step)\\n print(\\\"Histogram\\\")\\n print(\\\"=========\\\")\\n size = len(format % 0)\\n sformat = \\\"%\\\" + str(size) + \\\"s\\\"\\n columns = [\\\"Range Start\\\", \\\"Range End\\\", \\\"Count\\\", \\\"Bins\\\"]\\n formats = [sformat % s for s in columns]\\n print(*formats)\\n print(\\\"-\\\" * (size * 4 + 3))\\n total = 0.0\\n for row in collection:\\n count = row[\\\"count\\\"]\\n total += count\\n if show_empty or count > 0:\\n print(\\n format % row[\\\"value_start\\\"],\\n format % row[\\\"value_stop\\\"],\\n format % count,\\n (\\n sformat\\n % (\\\"[%s-%s]\\\" % (row[\\\"bin_index_start\\\"], row[\\\"bin_index_stop\\\"]))\\n ),\\n )\\n print(\\\"-\\\" * (size * 4 + 3))\\n print((\\\"Total: \\\" + format) % total)\",\n \"def histogram_print(lista):\\n divisor = ((lista[0])[1])//50\\n def slashout(value):\\n \\\"\\\"\\\"a function that converts a number into the appropriate\\n number of slashes\\\"\\\"\\\"\\n intvalue = value//divisor\\n slashes = \\\"#\\\" * intvalue\\n return slashes\\n\\n for item in lista:\\n print(\\\"{} \\\\t\\\\t {}\\\".format(item[0], slashout(item[1])))\",\n \"def _dumpHistos ( cmp , *args ) :\\n _histos = cmp.Histos()\\n for _k in _histos :\\n _h = _histos[_k]\\n if hasattr ( _h , 'dump' ) :print _h.dump( *args )\",\n \"def _dumpHistos ( cmp , *args ) :\\n _histos = cmp.Histos()\\n for _k in _histos :\\n _h = _histos[_k]\\n if hasattr ( _h , 'dump' ) :print _h.dump( *args )\",\n \"def plot_histogram(hist, outname, xlabel=\\\"\\\", ylabel=\\\"frequency\\\"):\\n plt.bar(hist[:,0], hist[:,1])\\n plt.xlabel(xlabel)\\n plt.ylabel(ylabel)\\n plt.savefig(outname)\\n plt.close()\",\n \"def main():\\n print_hist_new(histogram_new(get_pledge_list()))\",\n \"def makeHistogram(values, numBins, xLabel, yLabel, title=None):\",\n \"def plot_hitstogram_graph(data_values, title,\\r\\n number_of_keys,\\r\\n max_val,\\r\\n file_in):\\r\\n\\r\\n # bins = max(data_values)\\r\\n # pylab.hist(data_values, facecolor='blue')\\r\\n pylab.hist(data_values, facecolor='green', alpha=0.6)\\r\\n pylab.grid(True)\\r\\n pylab.title(title + \\\"_histogram\\\")\\r\\n pylab.xlabel('number in cluster')\\r\\n pylab.ylabel('Count')\\r\\n pylab.savefig(file_in + \\\"_\\\" + title + '_histogram.png')\\r\\n plt.close()\\r\\n pylab.close()\\r\\n os.chdir('..')\",\n \"def hist(self):\\r\\n plt.hist(self.data_array, bins='auto', density=False, facecolor='b')\\r\\n plt.title(self.column_name)\\r\\n plt.savefig(self.column_name + \\\".svg\\\")\\r\\n plt.close()\",\n \"def draw_histogram(m, rolls, width):\\n # Count the number of rolls of each side and store them in a list\\n roll_count = []\\n for i in list(range(1, m+1)):\\n count = rolls.count(i)\\n roll_count.append(count)\\n\\n # Finding the the maximum count from the list\\n max_count = max(roll_count)\\n\\n print(\\\"Frequency Histogram: \\\" + str(m) + \\\"-sided Die\\\")\\n\\n # Counting the number of same outputs and then scaling these outputs\\n # to the given width\\n for j in list(range(1, m+1)):\\n count = rolls.count(j)\\n scaled_count = round(count*(width/max_count))\\n print(str(j)+'.', end='')\\n print('#'*scaled_count, end='')\\n print('-'*(width-scaled_count))\",\n \"def print_histogram(input_data):\\n\\n input_data.sort()\\n largest_class_number = len(str(input_data[-1]))\\n current_index = 1 # missä luokassa ollaan menossa\\n count = 0 # kuinka monta alkiota tässä luokassa\\n\\n for number in input_data:\\n if len(str(number)) > current_index: # jos luokka vaihtuu\\n\\n # jos vaihtu enemmän ku yks luokka kerralla\\n # nii loopataan sen verran \\\"tyhjii\\\" rivei histrogrammiin\\n for _ in range(len(str(number)) - current_index):\\n print_single_histogram_line(current_index, count,\\n largest_class_number)\\n current_index += 1\\n count = 0\\n\\n count = 1\\n else:\\n count += 1\\n\\n # lopuks viel viimenenki rivi sinne mukaan\\n print_single_histogram_line(current_index, count, largest_class_number)\",\n \"def show_histograms(self, n_samples=1000):\\n\\n ps = self.gen(n_samples)\\n util.plot.plot_hist_marginals(ps, lims=get_disp_lims())\\n plt.show()\",\n \"def test_format_histograms(self):\\r\\n self.assertEqual(format_histograms(array([0, 1, 0, 2, 2, 3]),\\r\\n array(\\r\\n [2, 1, 0, 2, 0, 0]), array(\\r\\n [0, 0, 0, 2, 0, 1]),\\r\\n array(\\r\\n [100, 110, 120, 130, 140, 150, 160])),\\r\\n \\\"\\\"\\\"# bins raw sequence lengths, length of sequences that pass quality filters before processing, and lengths of sequences that pass quality filters post processing.\\\\nLength\\\\tRaw\\\\tBefore\\\\tAfter\\\\n100\\\\t0\\\\t2\\\\t0\\\\n110\\\\t1\\\\t1\\\\t0\\\\n120\\\\t0\\\\t0\\\\t0\\\\n130\\\\t2\\\\t2\\\\t2\\\\n140\\\\t2\\\\t0\\\\t0\\\\n150\\\\t3\\\\t0\\\\t1\\\"\\\"\\\")\",\n \"def create_histogram(data_dict,\\r\\n x_label=\\\"X\\\",\\r\\n y_label=\\\"Count\\\",\\r\\n title=\\\"Histogram\\\",\\r\\n log_x=False,\\r\\n bins=\\\"auto\\\"):\\r\\n\\r\\n # copy the dict so we don't change it\\r\\n data = copy.copy(data_dict)\\r\\n\\r\\n # take the log of the data if appropriate\\r\\n if log_x:\\r\\n for key in data.keys():\\r\\n if not data[key] == 0:\\r\\n data[key] = np.log(data[key])\\r\\n\\r\\n # create the list of X data\\r\\n X = list(data.values())\\r\\n\\r\\n # plot the histogram\\r\\n plt.style.use('Solarize_Light2')\\r\\n plt.hist(X, bins=bins)\\r\\n\\r\\n # add titles\\r\\n plt.xlabel(x_label)\\r\\n plt.ylabel(y_label)\\r\\n plt.title(title)\\r\\n\\r\\n # display the plot\\r\\n plt.show()\",\n \"def plot_hist(self):\\n labels = [self.get_class_str(action, obj)\\n for (action, obj, subj, rec, beg, end) in self.action_clips]\\n visualize.plot_hist(labels, proportion=True)\",\n \"def ascii_hist(x):\\n fAbs = frecuencia_abs(x)\\n for k in sorted(fAbs):\\n print(\\\"{0:5d} {1}\\\".format(k, \\\"+\\\"*fAbs[k]))\",\n \"def histogramintegrals(self):\\n return {}\",\n \"def print_dict(data):\\n print data\",\n \"def Pretty_print(summary):\\n print('Length of the dictionary: {}'.format(len(summary)))\\n print('Word', ' ', 'Count')\\n print('-------------------------')\\n # Sort the dictionary by value\\n for word, count in sorted(summary.items(), key=lambda kv: kv[1], reverse=True):\\n print(\\\"{:17} {:5}\\\".format(word, count))\",\n \"def print_metrics(self):\\n output = \\\"\\\"\\n metrics = self.get_all_metrics()\\n for k, v in metrics.items():\\n # Print the help line\\n output += \\\"\\\\n# HELP {name} {help}\\\\n\\\".format(name=v['name'],\\n help=v['help'])\\n # and the type line\\n output += \\\"# TYPE {name} {type}\\\\n\\\".format(name=v['name'],\\n type=v['type'])\\n for sample in v['values']:\\n labels = json.loads(sample, object_pairs_hook=OrderedDict)\\n if v['type'] == 'histogram' and labels.get('le') == '_sum':\\n labels.pop('le', None)\\n mname = '{name}_sum'.format(name=v['name'])\\n elif v['type'] == 'histogram' and labels.get('le') == '+Inf':\\n labels.pop('le', None)\\n mname = '{name}_count'.format(name=v['name'])\\n elif v['type'] == 'histogram':\\n mname = '{name}_bucket'.format(name=v['name'])\\n else:\\n mname = v['name']\\n output += \\\"{name}{labels} {value}\\\\n\\\".format(name=mname,\\n labels=self.format_labels(labels),\\n value=self.format_value(v['values'][sample]))\\n return output\",\n \"def histogram(self):\\n return self._hist\",\n \"def make_histogram(cadena):\\r\\n hist = dict()\\r\\n for c in cadena:\\r\\n hist[c] = hist.get(c, 0) + 1\\r\\n \\r\\n if \\\"\\\\n\\\" in hist:\\r\\n del hist[\\\"\\\\n\\\"] \\r\\n return hist\",\n \"def plotHist(self):\\n X = []\\n Y = []\\n for item in self.hist.items():\\n X.append(int(item[0]))\\n Y.append(int(item[1]))\\n plt.bar(X,Y, align='center')\\n plt.xticks([1,2,3,4,5,6,7])\\n plt.ylim(0,len(self.responses))\\n plt.title(self.text)\\n plt.xlabel('Number of Responses')\\n plt.ylabel('Value of Response')\\n for x, y in zip(X, Y):\\n plt.text(x, y, str(y), ha='center', va='bottom')\\n plt.show()\",\n \"def histogram(self, number_concentration=True):\\n\\n\\t\\tresp = []\\n\\t\\tself.spi.transfer([0x30], [0x00], 1)\\n\\t\\ttime.sleep(10e-3)\\n\\t\\tfor i in range(62):\\n\\t\\t\\trb = [0x00]\\n\\t\\t\\tself.spi.transfer([0x00], rb, 1)\\n\\t\\t\\tif rb[0] < 0:\\n\\t\\t\\t\\trb[0] += 256\\n\\t\\t\\tresp.append(rb[0])\\n\\t\\t\\n\\t\\tself._hist_dict['bin0'] = _16bit_unsigned(resp[0], resp[1])\\n\\t\\tself._hist_dict['bin1'] = _16bit_unsigned(resp[2], resp[3])\\n\\t\\tself._hist_dict['bin2'] = _16bit_unsigned(resp[4], resp[5])\\n\\t\\tself._hist_dict['bin3'] = _16bit_unsigned(resp[6], resp[7])\\n\\t\\tself._hist_dict['bin4'] = _16bit_unsigned(resp[8], resp[9])\\n\\t\\tself._hist_dict['bin5'] = _16bit_unsigned(resp[10], resp[11])\\n\\t\\tself._hist_dict['bin6'] = _16bit_unsigned(resp[12], resp[13])\\n\\t\\tself._hist_dict['bin7'] = _16bit_unsigned(resp[14], resp[15])\\n\\t\\tself._hist_dict['bin8'] = _16bit_unsigned(resp[16], resp[17])\\n\\t\\tself._hist_dict['bin9'] = _16bit_unsigned(resp[18], resp[19])\\n\\t\\tself._hist_dict['bin10'] = _16bit_unsigned(resp[20], resp[21])\\n\\t\\tself._hist_dict['bin11'] = _16bit_unsigned(resp[22], resp[23])\\n\\t\\tself._hist_dict['bin12'] = _16bit_unsigned(resp[24], resp[25])\\n\\t\\tself._hist_dict['bin13'] = _16bit_unsigned(resp[26], resp[27])\\n\\t\\tself._hist_dict['bin14'] = _16bit_unsigned(resp[28], resp[29])\\n\\t\\tself._hist_dict['bin15'] = _16bit_unsigned(resp[30], resp[31])\\n\\n\\t\\tself._hist_dict['bin1_MToF'] = _calculate_mtof(resp[32])\\n\\t\\tself._hist_dict['bin3_MToF'] = _calculate_mtof(resp[33])\\n\\t\\tself._hist_dict['bin5_MToF'] = _calculate_mtof(resp[34])\\n\\t\\tself._hist_dict['bin7_MToF'] = _calculate_mtof(resp[35])\\n\\n\\t\\tself._hist_dict['sfr'] = _calculate_float(resp[36:40])\\t\\t## Sample flow rate\\n\\n\\t\\t## Alright, we don't know whether it is temp or pressure since it switches...\\n\\t\\ttmp = _calculate_pressure(resp[40:44])\\n\\t\\tif tmp > 98000:\\n\\t\\t\\tself._hist_dict['temperature'] = None\\n\\t\\t\\tself._hist_dict['pressure'] = tmp\\n\\t\\telse:\\n\\t\\t\\ttmp = _calculate_temp(resp[40:44])\\n\\t\\t\\tif tmp < 500:\\n\\t\\t\\t\\tself._hist_dict['temperature'] = tmp\\n\\t\\t\\t\\tself._hist_dict['pressure'] = None\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself._hist_dict['temperature'] = None\\n\\t\\t\\t\\tself._hist_dict['pressure'] = None\\n\\n\\t\\tself._hist_dict['period'] = _calculate_float(resp[44:48])\\t\\t## Sampling period\\n\\n\\t\\tself._hist_dict['checksum'] = _16bit_unsigned(resp[48], resp[49])\\n\\n\\t\\tself._hist_dict['PM1'] = _calculate_float(resp[50:54])\\n\\t\\tself._hist_dict['PM2.5'] = _calculate_float(resp[54:58])\\n\\t\\tself._hist_dict['PM10'] = _calculate_float(resp[58:])\\n\\n\\t\\t## Calculate the sum of the histogram bins\\n\\t\\thistogram_sum = self._hist_dict['bin0'] + self._hist_dict['bin1'] + self._hist_dict['bin2'] + \\\\\\n\\t\\t\\t\\tself._hist_dict['bin3'] + self._hist_dict['bin4'] + self._hist_dict['bin5'] + self._hist_dict['bin6'] + \\\\\\n\\t\\t\\t\\tself._hist_dict['bin7'] + self._hist_dict['bin8'] + self._hist_dict['bin9'] + self._hist_dict['bin10'] + \\\\\\n\\t\\t\\t\\tself._hist_dict['bin11'] + self._hist_dict['bin12'] + self._hist_dict['bin13'] + self._hist_dict['bin14'] + \\\\\\n\\t\\t\\t\\tself._hist_dict['bin15']\\n\\n\\t\\t## Check that checksum and the least significant bits of the sum of histogram bins are equivilant\\n\\t\\tif (histogram_sum & 0x0000FFFF) != self._hist_dict['checksum']:\\n\\t\\t\\tprint(f\\\"[{self.__class__.__name__}::histogram] CHECKSUM ERROR: Data transfer was incomplete\\\")\\n\\t\\t\\treturn None\\n\\n\\t\\t## If number_concentration flag is set, convert histogram values to number concentration\\n\\t\\tif number_concentration is True:\\n\\t\\t\\t_conv_ = self._hist_dict['sfr'] * self._hist_dict['period'] \\t## Divider in units of ml (cc)\\n\\n\\t\\t\\tself._hist_dict['bin0'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin1'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin2'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin3'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin4'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin5'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin6'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin7'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin8'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin9'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin10'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin11'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin12'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin13'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin14'] /= _conv_\\n\\t\\t\\tself._hist_dict['bin15'] /= _conv_\\n\\n\\t\\ttime.sleep(0.1)\\n\\t\\treturn self._hist_dict\",\n \"def drawHist(data, xLabel, unit, binSize, title):\\n mean = np.mean(data)\\n median = np.median(data)\\n mode = stats.mode(data)[0].astype(float)\\n \\n q1, q3 = np.percentile(data, [25, 75])\\n iqr = q3 - q1\\n sigma = np.std(data)\\n \\n \\n bins = np.arange(min(data), max(data) + 1, binSize)\\n plt.style.use('dark_background')\\n fig, ax = plt.subplots(figsize=(12,7))\\n plt.hist(data, bins=bins, histtype='bar') \\n plt.title(title)\\n plt.xlabel(xLabel + \\\" \\\" + unit)\\n plt.ylabel('count')\\n ymax = ax.get_ylim()[1]\\n ax.vlines(mean, 0, ymax, color='red', label='mean')\\n ax.vlines(mean-sigma, 0, ymax, color='red', linestyle='--', \\n label='mean +/- std')\\n ax.vlines(mean+sigma, 0, ymax, color='red', linestyle='--')\\n plt.legend()\\n plt.show()\\n \\n print(\\\"Einheit: \\\", unit)\\n print(\\\"Minimum: \\\", round(data.min(),3))\\n print(\\\"Maximum: \\\", round(data.max(),3))\\n print(\\\"Mittelwert: \\\", round(mean,3))\\n print(\\\"Median: \\\", round(median,3))\\n print(\\\"Modus: \\\", round(mode[0],3))\\n print(\\\"Standardabweichung: \\\", round(sigma, 3))\\n print(\\\"1. Quartil: \\\", round(q1,3))\\n print(\\\"3. Quartil: \\\", round(q3,3))\\n print(\\\"Quartilsdifferenz: \\\", round(iqr,3))\",\n \"def showHistogram(x,y,txt,**options):\\n plot2d_system = pyformex.cfg['gui/plot2d']\\n\\n if plot2d_system == 'gnuplot':\\n if not utils.hasModule('gnuplot'):\\n error(\\\"You do not have the Python Gnuplot module installed.\\\\nI can not draw the requested plot.\\\")\\n return\\n \\n import Gnuplot\\n maxlen = min(len(x),len(y))\\n data = Gnuplot.Data(x[:maxlen],y[:maxlen],title=txt, with_='histeps') \\n g = Gnuplot.Gnuplot(persist=1)\\n g.title('pyFormex histogram: %s' % txt)\\n g.plot(data)\\n \\n elif plot2d_system == 'qwt':\\n pass\\n #from PyQt4.Qwt5.qplt import *\",\n \"def write_hist(fname='~/.ipyhist.py'):\\n import os\\n vseparator = '#' + '#'*62 + '#\\\\n'\\n nextcmdfmt = vseparator + '# In[{}]:\\\\n{}\\\\n'\\n outputfmt = '#' + '-'*62 + '#\\\\n# Out[{}]:\\\\n# {}\\\\n'\\n with open(os.path.expanduser(fname), 'w') as outfile:\\n for i in range(len(In)):\\n outfile.write(nextcmdfmt.format(i, In[i]))\\n if Out.has_key(i):\\n out = repr(Out[i]).replace('\\\\n', '\\\\n# ')\\n outfile.write(outputfmt.format(i, out))\",\n \"def mostrar_histograma(self):\\n histograma = self.imagem_core.get_histograma()\\n\\n graph = Graph(\\n xlabel='Tom de Cinza',\\n ylabel='Quantidade de tons',\\n padding=5,\\n xmin=0,\\n xmax=max(histograma.keys()),\\n ymin=0,\\n ymax=max(histograma.values())\\n )\\n plot = MeshLinePlot()\\n plot.points = histograma.items()\\n graph.add_plot(plot)\\n self.widgets_dinamicos.append(graph)\\n self.add_widget(graph)\",\n \"def hog_histograms(*args, **kwargs): # real signature unknown\\n pass\",\n \"def printResults(self):\\n for key in self.mDict.keys():\\n print ('for {:d}, entries = {:d} and exits = {:d}'.format (key, self.mDict.get(key).get ('entries'), self.mDict.get(key).get ('exits')))\",\n \"def format_histogram_one_count(counts, bin_edges):\\r\\n lines = []\\r\\n lines.append('Length\\\\tCount')\\r\\n for edge, count in zip(bin_edges, counts):\\r\\n lines.append('\\\\t'.join(map(str, [edge, count])))\\r\\n return '\\\\n'.join(lines)\",\n \"def printDicts():\\n for k in key:\\n print k, key[k]\\n \\n for f in freq:\\n print f, freq[f]\\n \\n for e in english:\\n print e, english[e]\",\n \"def plot_histogram(self) -> None:\\n\\n if self.data:\\n plt.hist(self.data)\\n plt.title(\\\"Histogram of data\\\")\\n plt.xlabel(\\\"data\\\")\\n plt.ylabel(\\\"count\\\")\\n else:\\n raise ValueError(\\\"Histogram cannot be generated as no\\\\\\n data has been provided\\\")\",\n \"def plot_counter(counter, outname, xlabel=\\\"\\\", ylabel=\\\"frequency\\\"):\\n x = sorted(counter.keys())\\n y = [counter[k] for k in x]\\n plt.bar(x,y)\\n plt.xlabel(xlabel)\\n plt.ylabel(ylabel)\\n plt.savefig(outname)\\n plt.close()\",\n \"def display(self):\\r\\n\\t\\tfor key, value in self.__dict__.items():\\r\\n\\t\\t\\tprint(key.upper(), value, sep=': ')\\r\\n\\r\\n\\t\\tprint(\\\"\\\")\",\n \"def print_stats(stats: Dict):\\n print()\\n print(\\\" Panelist Scores\\\")\\n print(\\\" Count: {}\\\".format(stats[\\\"count\\\"]))\\n print(\\\" Minimum: {}\\\".format(stats[\\\"minimum\\\"]))\\n print(\\\" Maximum: {}\\\".format(stats[\\\"maximum\\\"]))\\n print(\\\" Median: {}\\\".format(stats[\\\"median\\\"]))\\n print(\\\" Mean: {}\\\".format(stats[\\\"mean\\\"]))\\n print(\\\" Std Dev: {}\\\".format(stats[\\\"standard_deviation\\\"]))\\n print(\\\" Total: {}\\\".format(stats[\\\"total\\\"]))\\n print(\\\"\\\\n\\\\n\\\")\\n return\",\n \"def histogram(list):\\n for i in range(0,len(list)):#go over the number in the list\\n print('*'*list[i])\",\n \"def phist():\\n history = hist();\\n for line in history:\\n print(line, \\\":\\\", history[line])\",\n \"def setup_hist(self):\\n self.x_min = {}\\n self.x_max = {}\\n self.x_max_minus_min = {}\\n self.dx = {}\\n self.n_bins = {}\\n\\n self.histogram_edges = {}\\n self.histogram_values = {}\\n self.histogram_cdf = {}\",\n \"def hist_of_numeric(X):\\n figsize(10,3)\\n for col in get_numeric(X):\\n print(col)\\n X[col].hist(bins=50)\\n show()\",\n \"def write_weights_histograms(self):\\n for weight_name, weight in self._weights.items():\\n self._write_weight_histogram_to_tensorboard(\\n name=f\\\"{self._Sections.WEIGHTS}/{weight_name}\\\",\\n weight=weight,\\n step=self._epochs,\\n )\",\n \"def print_most_common(self, hist, n=10):\\n t = []\\n for word,freq in hist.items():\\n t.append((freq, word))\\n t.sort(reverse=True)\\n\\n for word,freq in t[:n]:\\n print(word, '\\\\t', freq)\",\n \"def pprint(self):\\r\\n for i in self.items():\\r\\n print '%s => %r'%i\",\n \"def hist_save(self, d, bin1, name, no):\\n\\t\\tfor i in range(0,no):\\n\\t\\t\\ts = d[:,i]\\n\\t\\t\\tplt.hist(s, bin1, normed=True, color='c')\\t# Extracting the parameters from the histogram\\n\\t\\t\\tplt.title('Probability Distribution Fnction of %s' %name, fontsize=20)\\n\\t\\t\\tplt.xlabel(\\\"Filter tap values\\\", fontsize=20)\\n\\t\\t\\tplt.ylabel(\\\"Probability Distribution\\\", fontsize=20)\\n#\\t\\t\\tplt.xlim(0,0.10)\\n\\t\\t\\tplt.ylim(0,100)\\n#\\t\\t\\tplt.legend(fontsize = 'xx-large')\\n\\t\\t\\tplt.savefig('/home/abhishek/Results/comparison_all_sets/Curve fitting/test/set_1/hist_%s_index_%d' %(name,i))\\n\\t\\t\\tplt.close()\",\n \"def plotting(self, figsize=(12, 12), types=['freqs']):\\n ax = plt.figure(figsize=figsize)\\n if 'freqs' in types:\\n count_dict = self.count_freq(types=1)\\n plt.title(\\n f'Total keys in count_dict: {sum(list(count_dict.values()))}')\\n barh = plt.barh(list(count_dict.keys()), list(count_dict.values()), color=[\\n np.random.rand(3,) for _ in range(self.categories)])\\n for rect in barh:\\n height = rect.get_height()\\n plt.text(rect.get_x() + rect.get_height()/2.0, height,\\n '%d' % int(height), ha='center', va='bottom')\\n\\n plt.legend()\\n plt.show()\",\n \"def display_dict() -> None:\\n for key in ascii_dict:\\n print(key, ': ')\\n for line in ascii_dict[key]:\\n print(line)\",\n \"def output_metrics(self):\\n print('')\\n for key in sorted(self.metrics):\\n print('{}:'.format(key), end='')\\n for k, v in self.metrics[key].items():\\n if type(v[-1]) is list:\\n print('\\\\t' + k + ': ' + ''.join('{:5.3f} '.format(vs) for vs in v[-1]), end='')\\n else:\\n print('\\\\t{}: {:5.3f}'.format(k, v[-1]), end='')\\n print('\\\\n', end='')\",\n \"def histogram(end_statistics: EndStatistics, n: int, gc_content: float) -> str:\\n sio = StringIO()\\n\\n print(\\\"length\\\", \\\"count\\\", \\\"expect\\\", \\\"max.err\\\", \\\"error counts\\\", sep=\\\"\\\\t\\\", file=sio)\\n for row in histogram_rows(end_statistics, n, gc_content):\\n print(\\n row.length,\\n row.count,\\n f\\\"{row.expect:.1F}\\\",\\n row.max_err,\\n \\\" \\\".join(str(e) for e in row.error_counts),\\n sep=\\\"\\\\t\\\",\\n file=sio,\\n )\\n return sio.getvalue() + \\\"\\\\n\\\"\",\n \"def printing_summary_gene_report(gene_dict):\\n #Creating a summary report for data\\n summary_gene_report = open('summary_gene_report.txt', 'w')\\n summary_gene_report.write(\\\"Accesssion ID\\\\tDescription\\\\tCounts\\\\n\\\")\\n for key in gene_dict:\\n accession_ID=str(key) \\n gene_description=str(gene_dict[key][0])\\n gene_counts=str(gene_dict[key][1])\\n summary_gene_report.write(accession_ID+\\\"\\\\t\\\"+gene_description+\\\"\\\\t\\\"+gene_counts+\\\"\\\\n\\\")\\n summary_gene_report.close()\",\n \"def cassandra_histograms(mycluster=RING_1_dev__allnodes):\\n cassandra_nodetool(mycluster,cmd=\\\"cfhistograms\\\")\",\n \"def show_histograms(n_samples=1000):\\n\\n true_ps, obs_xs = get_ground_truth()\\n\\n prior = Prior()\\n model = Model()\\n stats = Stats()\\n\\n ps = prior.gen(n_samples)\\n data = stats.calc(model.sim(ps))\\n cond_data = stats.calc(model.sim(np.tile(true_ps, [n_samples, 1])))\\n\\n # plot prior parameter histograms\\n fig = util.plot.plot_hist_marginals(ps, lims=get_disp_lims(), gt=true_ps)\\n fig.suptitle('p(thetas)')\\n\\n # plot stats histograms\\n fig = util.plot.plot_hist_marginals(data, gt=obs_xs)\\n fig.suptitle('p(stats)')\\n\\n # plot stats histograms, conditioned on true params\\n fig = util.plot.plot_hist_marginals(cond_data, gt=obs_xs)\\n fig.suptitle('p(stats|true thetas)')\\n\\n plt.show()\",\n \"def num_54():\\n frmt = \\\"\\\"\\\"\\n :{}\\n :Generate Data that conform to a uniform distribution.\\n :\\n :Class values: {}\\n :Population size: {}\\n :Results:\\n : values:\\n {}\\n : table:\\n {}\\n : histogram: (class, frequency)\\n {}\\n :Then use NumPyArrayToTable to get your table.\\n \\\"\\\"\\\"\\n # import numpy as np\\n st = 1\\n end = 7\\n vals = np.arange(st,end)\\n reps = 10\\n z = np.repeat(vals,reps)\\n np.random.shuffle(z)\\n ID = np.arange(len(z))\\n tbl = np.array(list(zip(ID, z)), \\n dtype = [('ID', 'int'), ('Class', 'int')])\\n h = np.histogram(z, np.arange(st, end+1))\\n h = np.array(list(zip(h[1], h[0])))\\n pad = \\\" \\\"\\n args =[num_54.__doc__, vals, reps*len(vals),\\n indent(str(z.reshape(3,20)), pad),\\n indent(str(tbl), pad), indent(str(h), pad)]\\n print(dedent(frmt).format(*args))\",\n \"def histogram(self):\\r\\n channel = self.ui.channel_selection.itemData(self.ui.channel_selection.currentIndex())\\r\\n\\r\\n #create a window, the reference must be stored, because the window\\r\\n #gets destroyed when its reference is garbage collected\\r\\n #make plotWindow a list and append to that if multiple windows should be possible\\r\\n title = \\\"histogram of {:s} channel\\\".format(self.ui.channel_selection.currentText())\\r\\n self.plotWindow = pyguitools.SimplePlotWindow(name = title)\\r\\n self.plotWindow.ax1.hist(self.npImg[self.ui.y0.value():self.ui.y1.value(),\\r\\n self.ui.x0.value():self.ui.x1.value(), \\r\\n channel].flatten(),\\r\\n bins=self.settings[\\\"histogramm bins\\\"],\\r\\n range=(self.settings[\\\"histogramm min\\\"],self.settings[\\\"histogramm max\\\"]))\\r\\n self.plotWindow.ax1.set_xlim(self.settings[\\\"histogramm min\\\"],self.settings[\\\"histogramm max\\\"]) \\r\\n self.plotWindow.show()\",\n \"def histogram(l):\\n return \\\"\\\\n\\\".join(map(lambda ls: \\\"#\\\"*ls, l))\",\n \"def distribution_magnitude_histogram(cur, var, table, label):\\n x = select(cur,var, table)\\n print(\\\"Number of entries: \\\", len(x))\\n print(\\\"Maximum: \\\", max(x))\\n print(\\\"Minimum: \\\", min(x))\\n \\n fig = plt.figure()\\n ax = fig.add_subplot(1,1,1)\\n ax.set_xlabel(\\\"Sentiment Magnitude\\\")\\n ax.set_ylabel(\\\"Number of Sentences\\\")\\n fig.suptitle(label)\\n ax.hist(x, bins = 20)\\n plt.show()\",\n \"def display(self, bin_size):\\n xs = np.linspace(self.sample_min, self.sample_max, 2000)\\n ys = np.zeros_like(xs)\\n for (l, s), w in zip(self.gauss_params, self.dist_weights):\\n ys += ss.norm.pdf(xs, loc=l, scale=s) * w\\n plt.plot(xs, ys, color=\\\"blue\\\")\\n plt.hist(self.samples, density=True, bins=bin_size, color=\\\"palegreen\\\")\\n plt.xlabel(\\\"duration\\\")\\n plt.ylabel(\\\"density\\\")\\n _, _, ymin, ymax = plt.axis()\\n if self.lower_bound > 0:\\n plt.vlines([self.lower_bound], ymin, ymax, color=\\\"crimson\\\")\\n if self.upper_bound < float(\\\"inf\\\"):\\n plt.vlines([self.upper_bound], ymin, ymax, color=\\\"crimson\\\")\\n plt.show()\",\n \"def create_histograms(PrimaryParticleName, LongVectorSignals, LongVectorSignalsCher,\\n\\tShortVectorSignals, ShortVectorSignalsCher, LongScinMaxFiber, LongCherMaxFiber, \\n\\tShortScinMaxFiber, ShortCherMaxFiber, EnergyTotContainer, MaxEnergyTotContainer):\\n\\n\\t#Set ROOT histograms\\n\\tTH1LongScin = TH1F(\\\"LongScintillation\\\", PrimaryParticleName, 100, 0.0, LongScinMaxFiber+200.)\\n\\tTH1LongCher = TH1F(\\\"LongCherenkov\\\", PrimaryParticleName, 100, 0.0, LongCherMaxFiber+200.)\\n\\tTH1ShortScin = TH1F(\\\"ShortScintillation\\\", PrimaryParticleName, 100, 0.0, ShortScinMaxFiber+200.)\\n\\tTH1ShortCher = TH1F(\\\"ShortCherenkov\\\", PrimaryParticleName, 100, 0.0, ShortCherMaxFiber+200.)\\n\\tTH1EnergyTot = TH1F(\\\"EnergyTot\\\", PrimaryParticleName, 100, MaxEnergyTotContainer-10000., MaxEnergyTotContainer+500.) \\n\\n\\t#Fill histograms in for loop\\n\\tfor index in range(len(LongVectorSignals)):\\n\\t\\tTH1LongScin.Fill(LongVectorSignals[index])\\n\\t\\tTH1LongCher.Fill(LongVectorSignalsCher[index])\\n\\t\\tTH1ShortScin.Fill(ShortVectorSignals[index])\\n\\t\\tTH1ShortCher.Fill(ShortVectorSignalsCher[index])\\n\\t\\tTH1EnergyTot.Fill(EnergyTotContainer[index])\\n\\n\\t#Draw + DrawOptions\\n\\tStyle = gStyle\\n\\tStyle.SetOptStat(1) #Show statistics\\n\\tStyle.SetLineWidth(1)\\n\\tXAxis = TH1LongScin.GetXaxis() #TH1LongScin\\n\\tXAxis.SetTitle(\\\"Energy (MeV)\\\")\\n\\tXAxis.SetTitleOffset(1.2)\\n\\tYAxis = TH1LongScin.GetYaxis()\\n\\tYAxis.SetTitle(\\\"Entries\\\")\\n\\tTH1LongScin.Draw()\\n\\tgPad.SaveAs(\\\"EnergyLongScin.eps\\\")\\n\\tXAxis = TH1LongCher.GetXaxis() #TH1LongCher\\n\\tXAxis.SetTitle(\\\"# Cher p.e.\\\")\\n\\tXAxis.SetTitleOffset(1.2)\\n\\tYAxis = TH1LongCher.GetYaxis()\\n\\tYAxis.SetTitle(\\\"Entries\\\")\\n\\tTH1LongCher.Draw()\\n\\tgPad.SaveAs(\\\"CherpeLong.eps\\\")\\n\\tXAxis = TH1ShortScin.GetXaxis() #TH1ShortScin\\n\\tXAxis.SetTitle(\\\"Energy (MeV)\\\")\\n\\tXAxis.SetTitleOffset(1.2)\\n\\tYAxis = TH1ShortScin.GetYaxis()\\n\\tYAxis.SetTitle(\\\"Entries\\\")\\n\\tTH1ShortScin.Draw()\\n\\tgPad.SaveAs(\\\"EnergyShortScin.eps\\\")\\n\\tXAxis = TH1ShortCher.GetXaxis() #TH1ShortCher\\n\\tXAxis.SetTitle(\\\"# Cher p.e.\\\")\\n\\tXAxis.SetTitleOffset(1.2)\\n\\tYAxis = TH1ShortCher.GetYaxis()\\n\\tYAxis.SetTitle(\\\"Entries\\\")\\n\\tTH1ShortCher.Draw()\\n\\tgPad.SaveAs(\\\"CherpeShort.eps\\\")\\n\\tXAxis = TH1EnergyTot.GetXaxis() #TH1EnergyTot\\n\\tXAxis.SetTitle(\\\"Energy (MeV)\\\")\\n\\tXAxis.SetTitleOffset(1.2)\\n\\tYAxis = TH1EnergyTot.GetYaxis()\\n\\tYAxis.SetTitle(\\\"Entries\\\")\\n\\tTH1EnergyTot.Draw()\\n\\tgPad.SaveAs(\\\"EnergyTot.eps\\\")\",\n \"def printHashtagsDict(self):\\n print(\\\"========Top 10 Hashtags=========\\\")\\n hashtagList = sorted(self.hashDict, key=self.hashDict.get, reverse=True)\\n count = 0\\n for hashtag in hashtagList:\\n print(hashtag, self.hashDict[hashtag])\\n count += 1\\n if count >= 10:\\n return\",\n \"def printDict(self):\\n print str(self)\",\n \"def print_table(self) -> None:\\n if (self.probability_links == None):\\n print(\\\"+--------+\\\")\\n print(f\\\"| P({self.key:1s}) |\\\")\\n print(\\\"+--------+\\\")\\n print(f\\\"| {self.probability_values[0]:0.04f} |\\\")\\n print(\\\"+--------+\\\")\\n else:\\n arg_len = 2 + len(' '.join(self.probability_links.keys()))\\n param_len = 2 + \\\\\\n max(6, len(\\\"P(A|)\\\" + \\\",\\\".join(self.probability_links.keys())))\\n print(f\\\"+{'-'*arg_len}+{'-'*param_len}+\\\")\\n print(\\n f\\\"| {' '.join(self.probability_links.keys())} | P({self.key}|{','.join(self.probability_links.keys())}) |\\\")\\n print(f\\\"+{'-'*arg_len}+{'-'*param_len}+\\\")\\n for i in range(2**len(self.probability_links.keys())):\\n # Gives us a string binary value to make truth table off of\\n bool_key = f\\\"{i:0{len(self.probability_links.keys())}b}\\\"\\n print(\\n f\\\"| {' '.join(['T' if bool_key[j] == '0' else 'F' for j in range(len(self.probability_links.keys()))])} | {f'{self.probability_values[i]:0.04f}':<{param_len-1}s}|\\\")\\n print(f\\\"+{'-'*arg_len}+{'-'*param_len}+\\\")\",\n \"def show_histogram(im):\\n\\n if im.ndim == 2:\\n # Input image is single channel\\n plt.hist(im.flatten(), 256, range=(0, 250), fc='k')\\n plt.show()\\n\\n elif im.ndim == 3:\\n # Input image is three channels\\n fig = plt.figure()\\n fig.add_subplot(311)\\n plt.hist(im[..., 0].flatten(), 256, range=(0, 250), fc='b')\\n fig.add_subplot(312)\\n plt.hist(im[..., 1].flatten(), 256, range=(0, 250), fc='g')\\n fig.add_subplot(313)\\n plt.hist(im[..., 2].flatten(), 256, range=(0, 250), fc='r')\\n plt.show()\",\n \"def print_metric_dict(self, metric_dict):\\n print(\\\"\\\".join([\\\" {}: {:4f},\\\".format(k, v) for k, v in metric_dict.items()]))\",\n \"def format_histograms(raw_hist, pre_hist, post_hist, bin_edges):\\r\\n lines = []\\r\\n lines.append('# bins raw sequence lengths, length of sequences that '\\r\\n 'pass quality filters before processing, and lengths of sequences that '\\r\\n 'pass quality filters post processing.')\\r\\n lines.append('Length\\\\tRaw\\\\tBefore\\\\tAfter')\\r\\n for edge, raw, pre, post in zip(bin_edges, raw_hist, pre_hist, post_hist):\\r\\n lines.append('\\\\t'.join(map(str, [edge, raw, pre, post])))\\r\\n return '\\\\n'.join(lines)\",\n \"def histogram(values, title, fig_size=(4,3), path=None):\\n plt.clf()\\n f, ax = plt.subplots(1, figsize=fig_size)\\n ax.hist(values, bins=60)\\n ax.set_title(title)\\n f.tight_layout()\\n if(path != None):\\n f.savefig(path+'/hist_'+title+'.png')\",\n \"def print_table(album_dict, filename):\\n print()\\n print(\\\"Album Catalogue Summary\\\")\\n print(\\\"-\\\" * 60)\\n print('{:<5}{:<30}{:>10}{:>15}'.format(\\\"ID\\\", \\\"ALBUM NAME\\\", \\\"# SOLD\\\", \\\"CERTIFICATE\\\"))\\n sorted_albums = sorted(album_dict.values(), key=total_sold, reverse=True)\\n for album in sorted_albums:\\n print(album)\\n print()\\n print(\\\"Sales Bar Graph\\\")\\n print(\\\"-\\\" * 30)\\n print(\\\" {:<4}{:>5}\\\".format(\\\"ID\\\", \\\"Freq Graph\\\"))\\n total_sales = 0\\n for album in sorted_albums:\\n total_sales += int(album.total_sold)\\n print_graph(sorted_albums, total_sales)\\n make_barchart(album_dict, sorted_albums, filename, total_sales)\",\n \"def print(self):\\n for fiction in self.fictions:\\n print(fiction.__dict__)\",\n \"def save_hist(data, fname, title=''):\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n im = ax.hist(data.flatten(),bins=100,range=[0,1])\\n plt.savefig(fname, dpi=100)\\n plt.close(fig)\",\n \"def printt(dictionnary):\\n for key, value in dictionnary.iteritems():\\n print('{key}, size: {size}, {values}'.format(key=key, \\n size=len(value), values=value[0:4]))\",\n \"def build_histogram(iterator, key):\\n buckets = defaultdict(int)\\n values = {}\\n\\n num_objects = 0\\n for obj in iterator:\\n num_objects += 1\\n\\n try:\\n val = obj[key]\\n except (KeyError, TypeError):\\n continue\\n\\n value_hash = hashlib.sha1()\\n value_hash.update(syaml.dump_config(sort_yaml_obj(val)).encode())\\n value_hash = value_hash.hexdigest()\\n\\n buckets[value_hash] += 1\\n values[value_hash] = val\\n\\n return [\\n (h, buckets[h], float(buckets[h]) / num_objects, values[h])\\n for h in sorted(buckets.keys(), key=lambda k: -buckets[k])\\n ]\",\n \"def draw_histo(df, col_name, x_start, bin_width, n_bins, title, output_dir, output_filename, \\n log_y = False, describe = False):\\n my_plt = df[col_name].plot.hist(\\n bins=[bin_width * (x + 0.5) + x_start for x in np.arange(0, n_bins)], \\n edgecolor='black', \\n color='#88d498',\\n log=log_y)\\n my_plt.set_title(title)\\n pd.set_option('precision', 3)\\n plt.tight_layout(pad=5)\\n if(describe): print(df[col_name].describe())\\n plt.figtext(0.01,0.01, df[col_name].describe().loc[['mean','std','count']].to_string(),fontsize='x-large')\\n my_plt.ticklabel_format(style='sci', axis='x', scilimits=(0,3)) \\n my_plt.get_figure().savefig(os.path.join(output_dir,output_filename))\\n my_plt.get_figure().clf()\",\n \"def print_statistics(fib_details: dict, nth_value: int):\\n line = '\\\\n' + (\\\"---------------\\\" * 5)\\n pass # TODO: Replace with implementation!\",\n \"def basic_statistics():\\n print(train_data['revenue'].describe())\\n plt.hist(train_data['revenue'], color = 'blue', edgecolor = 'black',\\n bins = int(4))\\n\\n # Add labels\\n plt.title('Histogram of Revenues')\\n plt.xlabel('revenues')\\n plt.ylabel('P(revenues)')\\n plt.show()\",\n \"def distribution_sentimentscore_histogram(cur, var, table, label):\\n x = select(cur,var, table)\\n print(\\\"Number of entries: \\\", len(x))\\n print(\\\"Maximum: \\\", max(x))\\n print(\\\"Minimum: \\\", min(x))\\n \\n fig = plt.figure()\\n ax = fig.add_subplot(1,1,1)\\n ax.set_xlabel(\\\"Sentiment Score\\\")\\n ax.set_ylabel(\\\"Number of Loans\\\")\\n fig.suptitle(label)\\n ax.hist(x, bins = 15)\\n plt.show()\",\n \"def histogram_summary(self, tag, values, step, bins=1000):\\n self.writer.add_histogram(tag, values, step, bins='auto')\",\n \"def plotHistogram(self, var, idx = None, translation = None, other = None,\\\\\\n verbose = 1, ab = [], bins = 100, xlim = None,\\\\\\n cmap = \\\"tab10\\\", row = 1, col = 1, N = 1, save = False,\\\\\\n dpi = 100, format = \\\"pdf\\\", shift = None, **kwargs):\\n \\n if idx is None: idx = np.arange(self.atoms.shape[0])\\n if translation is None: translation = [0]\\n if isinstance(translation, (int, np.integer)): translation = [translation]\\n if isinstance(var, str): var = [var]\\n\\n if other is not None:\\n if np.shape(other)[0] != np.shape(idx)[0]:\\n string = \\\"Length of other %s inconsistent with the rest of the data %s\\\"\\\\\\n % (np.shape(other), np.shape(idx))\\n ut.infoPrint(string)\\n return\\n\\n x, y, lbl, leg = self.getHistogram(var = var, idx = idx, translation = translation,\\\\\\n verbose = verbose, ab = ab, other = other,\\\\\\n bins = bins, minmax = xlim)\\n\\n cmap = kwargs.pop(\\\"colormap\\\", cmap)\\n c = plt.cm.get_cmap(cmap)(range(len(x)))\\n c = kwargs.pop(\\\"color\\\", c)\\n\\n s = 0\\n hFig = plt.figure()\\n hAx = plt.subplot(row, col, N)\\n for i in range(len(x)):\\n hAx.plot(x[i], y[i] + s, label = leg[i], color = c[i], **kwargs)\\n if shift is not None: s += shift\\n\\n hAx.set_xlabel(lbl[0])\\n hAx.set_ylabel(\\\"Count\\\")\\n hAx.legend()\\n if self.filename is None:\\n hAx.set_title(\\\"Histogram\\\")\\n else:\\n hAx.set_title(self.filename)\\n \\n if save:\\n if save is True:\\n ut.save_fig(filename = \\\"Histogram.%s\\\" % format, format = format,\\\\\\n dpi = dpi, verbose = verbose)\\n else:\\n ut.save_fig(filename = save, format = format, dpi = dpi,\\\\\\n verbose = verbose)\\n plt.close()\\n else:\\n plt.show()\",\n \"def print_verb_dict(verb):\\n for keys in verb:\\n print(f'{keys}: {verb[keys]}')\",\n \"def displaySummary(self, dictionnary, lineCount):\\n for key in self.summaryDict.keys():\\n dictionnary[key] = (dictionnary[key] / lineCount) * 100\\n #print(str(key)+\\\" => \\\"+str(dictionnary[key])+\\\" %\\\")\",\n \"def makeHistogram(values, numBins, xLabel, yLabel, title=None):\\n pylab.hist(values, bins = numBins)\\n pylab.xlabel(xLabel)\\n pylab.ylabel(yLabel)\\n if not title == None:\\n pylab.title(title)\\n pylab.show()\",\n \"def histogram(word_list):\\n assert type(word_list) == list\\n\\n histogram = {}\\n total_words = len(word_list)\\n word_frac = 1.0/total_words\\n\\n for word in word_list:\\n if word in histogram: histogram[word] += word_frac\\n else: histogram[word] = word_frac\\n\\n return histogram\",\n \"def run_print_dict_examples():\\n print()\\n print_dict_keys(NAME_DICT)\\n print()\\n print_dict_items(NAME_DICT)\",\n \"def run_print_dict_examples():\\n print()\\n print_dict_keys(NAME_DICT)\\n print()\\n print_dict_items(NAME_DICT)\",\n \"def magic_hist(self, parameter_s = ''):\\n\\n if not self.do_full_cache:\\n print 'This feature is only available if numbered prompts are in use.'\\n return\\n opts,args = self.parse_options(parameter_s,'n',mode='list')\\n \\n default_length = 40\\n if len(args) == 0:\\n final = self.outputcache.prompt_count\\n init = max(1,final-default_length)\\n elif len(args) == 1:\\n final = self.outputcache.prompt_count\\n init = max(1,final-int(args[0]))\\n elif len(args) == 2:\\n init,final = map(int,args)\\n else:\\n warn('@hist takes 0, 1 or 2 arguments separated by spaces.')\\n print self.magic_hist.__doc__\\n return\\n width = len(str(final))\\n line_sep = ['','\\\\n']\\n for in_num in range(init,final):\\n #inline = eval('self.user_ns[\\\"_i'+str(in_num)+'\\\"]')\\n inline = self.user_ns['_ih'][in_num]\\n multiline = inline.count('\\\\n') > 1\\n if not opts.has_key('n'):\\n print str(in_num).ljust(width)+':'+ line_sep[multiline],\\n if inline.startswith('#@') or inline.startswith('#!'):\\n print inline[1:],\\n else:\\n print inline,\",\n \"def histogram(data, title, path):\\n plt.hist(data,\\n bins=60)\\n plt.xticks(size=22)\\n plt.yticks(size=22)\\n plt.title(title,\\n fontsize=30)\\n plt.savefig(path)\\n plt.clf()\",\n \"def plot_feature_histograms(self):\\n\\n num_features = len(self.feature_names)\\n fig, ax = plt.subplots(nrows=1, ncols=num_features, figsize=(50, 2), tight_layout=True)\\n fig.suptitle('Histograms of 19 features', fontsize=14)\\n\\n for i in range(num_features):\\n ax[i].hist(self.train_data[self.train_data.columns[i]], bins=50)\\n ax[i].set_xlabel(self.train_data.columns[i])\\n\\n plt.savefig(r'data_analysis\\\\histograms_' + self.file_name + '.png', \\n facecolor=fig.get_facecolor(), bbox_inches='tight')\",\n \"def get_histogram_strings(data, padding=0, hist_char=\\\"\\\\xf0\\\\x9f\\\\x8d\\\\x95\\\"):\\n max_key_width = max([len(key) for key in data])\\n max_val_width = max([len(str(val)) for val in data.values()])\\n max_value = max(data.values())\\n _, width = get_terminal_size()\\n # Find the length we have left for the histogram bars.\\n # Magic number 6 is the _():_ parts of the string, and the\\n # guaranteed value of one that gets added.\\n histogram_width = width - padding - max_key_width - max_val_width - 6\\n result = []\\n for key, val in data.iteritems():\\n preamble = \\\"{:>{max_key}} ({:>{max_val}}): \\\".format(\\n key, val, max_key=max_key_width, max_val=max_val_width)\\n #percentage = float(val) / osx_clients\\n percentage = float(val) / max_value\\n histogram_bar = int(percentage * histogram_width + 1) * hist_char\\n result.append((preamble + histogram_bar).decode(\\\"utf-8\\\"))\\n return result\",\n \"def print_metrics(self):\\n # num times regular barcodes appear in a simulated doublet nearest neighbors, grouped by value\\n # TODO: this list is 2 dimensional... need to extract dimensione with counts for the counter\\n frequencies = [i[1] for i in self.num_times_knn]\\n counter = collections.Counter(frequencies)\\n print(\\\"##\\\\nNumber time barcoded in sim doub KNN: {}\\\".format(counter))\\n\\n # artificial fraction\\n print(\\\"##\\\\nArtificial fraction: {}\\\".format(self.artificial_fraction))\\n\\n # num doublets\\n print(\\\"##\\\\nNumber of doublets called: {}\\\".format(self.num_doublets))\",\n \"def __str__(self):\\n return 'HistogramMatcher:\\\\n' \\\\\\n ' histogram_levels: {self.histogram_levels}\\\\n' \\\\\\n ' match_points: {self.match_points}\\\\n' \\\\\\n ' threshold_mean_intensity: {self.threshold_mean_intensity}\\\\n' \\\\\\n .format(self=self)\",\n \"def get_hist(self):\\n return self.hist\",\n \"def print_strand_stats(strand_statistics):\\n print(' Total\\\\tFor\\\\tRev\\\\tDif')\\n for base, count in strand_statistics.items():\\n print(f'{base}: {str(count[0])}\\\\t{str(count[1])}\\\\t{str(count[2])}\\\\t{str(count[3])}')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79336995","0.7364849","0.7264949","0.7221877","0.6844306","0.67762184","0.67736197","0.670204","0.6640156","0.658255","0.6464321","0.6459065","0.6452475","0.6445913","0.6416502","0.6416502","0.6401292","0.6320839","0.6299228","0.62942815","0.6251127","0.6237026","0.62188905","0.6208991","0.61801606","0.6155645","0.6153177","0.6148632","0.6112122","0.6099607","0.60992855","0.6098508","0.60830873","0.6075174","0.607446","0.6067176","0.60586697","0.6015352","0.60131556","0.60070425","0.59975374","0.5994555","0.59905964","0.5964571","0.59544384","0.59394246","0.59390557","0.5934746","0.5922923","0.5910248","0.59040827","0.5902546","0.59005624","0.5896909","0.58758473","0.5874878","0.5873554","0.58584386","0.5847614","0.58452713","0.5844658","0.5842546","0.58404106","0.5836493","0.5835941","0.5830933","0.5828038","0.58179694","0.58100194","0.5807727","0.58059484","0.5797285","0.5793919","0.579374","0.57924503","0.57888114","0.5787431","0.57862324","0.57631725","0.57555395","0.5745532","0.5739792","0.57387406","0.57314336","0.57305473","0.5726862","0.57267076","0.5724864","0.5722521","0.5718452","0.5717103","0.57079345","0.57079345","0.57063603","0.5703615","0.5703008","0.5699659","0.5699071","0.5698443","0.5696151","0.5695594"],"string":"[\n \"0.79336995\",\n \"0.7364849\",\n \"0.7264949\",\n \"0.7221877\",\n \"0.6844306\",\n \"0.67762184\",\n \"0.67736197\",\n \"0.670204\",\n \"0.6640156\",\n \"0.658255\",\n \"0.6464321\",\n \"0.6459065\",\n \"0.6452475\",\n \"0.6445913\",\n \"0.6416502\",\n \"0.6416502\",\n \"0.6401292\",\n \"0.6320839\",\n \"0.6299228\",\n \"0.62942815\",\n \"0.6251127\",\n \"0.6237026\",\n \"0.62188905\",\n \"0.6208991\",\n \"0.61801606\",\n \"0.6155645\",\n \"0.6153177\",\n \"0.6148632\",\n \"0.6112122\",\n \"0.6099607\",\n \"0.60992855\",\n \"0.6098508\",\n \"0.60830873\",\n \"0.6075174\",\n \"0.607446\",\n \"0.6067176\",\n \"0.60586697\",\n \"0.6015352\",\n \"0.60131556\",\n \"0.60070425\",\n \"0.59975374\",\n \"0.5994555\",\n \"0.59905964\",\n \"0.5964571\",\n \"0.59544384\",\n \"0.59394246\",\n \"0.59390557\",\n \"0.5934746\",\n \"0.5922923\",\n \"0.5910248\",\n \"0.59040827\",\n \"0.5902546\",\n \"0.59005624\",\n \"0.5896909\",\n \"0.58758473\",\n \"0.5874878\",\n \"0.5873554\",\n \"0.58584386\",\n \"0.5847614\",\n \"0.58452713\",\n \"0.5844658\",\n \"0.5842546\",\n \"0.58404106\",\n \"0.5836493\",\n \"0.5835941\",\n \"0.5830933\",\n \"0.5828038\",\n \"0.58179694\",\n \"0.58100194\",\n \"0.5807727\",\n \"0.58059484\",\n \"0.5797285\",\n \"0.5793919\",\n \"0.579374\",\n \"0.57924503\",\n \"0.57888114\",\n \"0.5787431\",\n \"0.57862324\",\n \"0.57631725\",\n \"0.57555395\",\n \"0.5745532\",\n \"0.5739792\",\n \"0.57387406\",\n \"0.57314336\",\n \"0.57305473\",\n \"0.5726862\",\n \"0.57267076\",\n \"0.5724864\",\n \"0.5722521\",\n \"0.5718452\",\n \"0.5717103\",\n \"0.57079345\",\n \"0.57079345\",\n \"0.57063603\",\n \"0.5703615\",\n \"0.5703008\",\n \"0.5699659\",\n \"0.5699071\",\n \"0.5698443\",\n \"0.5696151\",\n \"0.5695594\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":91974,"cells":{"query":{"kind":"string","value":"Calculate the closest cruising altitude to the given altitude."},"document":{"kind":"string","value":"def closest_cruising_altitude(altitude):\n return 1000 * ((altitude + 500) // 1000)"},"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 altitude(self):\n if self.__altitude:\n return sum(self.__altitude) / len(self.__altitude)\n else:\n return -9999","def altitude(self):\r\n pressure = self.pressure # in Si units for hPascal\r\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))","def set_altitude(self):\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\n print('altitude set to', self.altitude)\n if self.altitude < 0:\n self.altitude = self.altitude + 360.0\n return self.altitude \n else: \n pass\n return self.altitude","def altitude(self) -> int:\n return self._point.altitude","def topographic_altitude(self, lat_d, lon_d):\n return self.altitude(lat_d, lon_d)","def topographic_altitude(self, lat_d, lon_d):\n return self.altitude(lat_d, lon_d)","def topographic_altitude(lat, lon):\n global __model\n type_output = type(lat)\n lat = prepare_input_array(lat)\n lon = prepare_input_array(lon)\n lon = np.mod(lon, 360)\n val = __model.topographic_altitude(lat, lon)\n val = np.maximum(val, 1e-7)\n return prepare_output_array(val, type_output) * u.km","def test_triangle_get_shortest_altitude(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)","def get_air_density(self, altitude):\n\n altitude /= 1000 # convert to kilometers\n\n return self.get_air_density_from_model(altitude)","def get_altitude(self):\n self.degrees = self.altitude_encoder.get_degrees()\n self.tele_altitude = self.Calculations.convert_degrees( self.degrees)\n return self.tele_altitude","def getAltitudeAngle(self):\n return self._altitude","def temperature(altitude):\n if altitude <= 36152:\n t = 59-0.00356*altitude # deg F\n else:\n t = -70 # deg F\n t = t + 459.7 # R\n return t","def altitude(press, altimeter=29.92126):\n AS = altimeter*inHg2PA\n print(AS, press**(L*R/g/M))\n h = -(press**(L*R/g/M) - AS**(L*R/g/M))*T0/L/(P0**(L*R/g/M))\n return h/ft2m","def setTargetAltitude(altitude):\n return RoboCaller().call(\"setTargetAltitude\", \"void\", altitude)","def get_altitude(self):\n return self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_GET_ALTITUDE, (), '', 'i')","def ecef2LatLonAlt(x, y, z):\n\n # Calculate the polar eccentricity\n ep = np.sqrt((EARTH.EQUATORIAL_RADIUS**2 - EARTH.POLAR_RADIUS**2)/(EARTH.POLAR_RADIUS**2))\n\n # Calculate the longitude\n lon = np.arctan2(y, x)\n\n p = np.sqrt(x**2 + y**2)\n\n theta = np.arctan2( z*EARTH.EQUATORIAL_RADIUS, p*EARTH.POLAR_RADIUS)\n\n # Calculate the latitude\n lat = np.arctan2(z + (ep**2)*EARTH.POLAR_RADIUS*np.sin(theta)**3, \\\n p - (EARTH.E**2)*EARTH.EQUATORIAL_RADIUS*np.cos(theta)**3)\n\n # Get distance from Earth centre to the position given by geographical coordinates, in WGS84\n N = EARTH.EQUATORIAL_RADIUS/math.sqrt(1.0 - (EARTH.E**2)*math.sin(lat)**2)\n\n \n # Calculate the height in meters\n\n # Correct for numerical instability in altitude near exact poles (and make sure cos(lat) is not 0!)\n if((np.abs(x) < 1000) and (np.abs(y) < 1000)):\n alt = np.abs(z) - EARTH.POLAR_RADIUS\n\n else:\n # Calculate altitude anywhere else\n alt = p/np.cos(lat) - N\n\n\n return lat, lon, alt","def test_triangle_get_longest_altitude(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_longest_altitude(), 9.428090415820634)","def altitude_speed(self, degrees = True):\n return self.angularSpeed(self.future_location.al, self.old_location.al)","def get_altitude(self, degrees=True):\n if degrees:\n return math.degrees(self.current_location.al)\n else:\n return self.current_location.al","def InverseRefractionAngle(refraction, bent_altitude):\n if bent_altitude < -90.0 or bent_altitude > +90.0:\n return 0.0 # No attempt to correct an invalid altitude\n # Find the pre-adjusted altitude whose refraction correction leads to 'altitude'.\n altitude = bent_altitude - RefractionAngle(refraction, bent_altitude)\n while True:\n # See how close we got. Keep iterating until the solution converges.\n diff = (altitude + RefractionAngle(refraction, altitude)) - bent_altitude\n if abs(diff) < 1.0e-14:\n return altitude - bent_altitude\n altitude -= diff","def elevation(self):\n return self.altitude - self.heightAboveGround","def altitude_to_pressure(alt):\n for i in range(len(_heights)-1,0,-1):\n h0 = _heights[i]\n T0 = _basetemps[i]\n if alt > h0:\n if _isotherm[i]:\n rP = math.exp(-_g / _R / T0 * (alt - h0))\n else:\n l0 = _lapsert[i]\n rP = math.pow(1 + (alt - h0) * l0 / T0, -_g / _R / l0)\n return _basepress[i] * rP\n l0 = _lapsert[0]\n return _stdpres * math.pow(1 + alt * l0 / _stdtemp, -_g / _R / l0)","def calibrateElevation(self,elevation):\n if len(self.values) == self.values.maxlen:\n self.elevcomp = self.value / ((1.0 - ((elevation + self.heightAboveGround) * 0.3048 / 44330.0)) ** 5.255)\n self.calibrated = True\n else:\n self.calibratedElevation = elevation","def solarelevation_function_overcast(latitude_deg, longitude_deg, utc_datetime,\n elevation = elevation_default, temperature_celsius = 25,\n pressure_millibars = 1013.25):\n altitude = solar.GetAltitude(latitude_deg, longitude_deg,utc_datetime, elevation, temperature_celsius,pressure_millibars)\n return ((-0.0067133) + (0.78600 * (math.sin(altitude)))) + (0.22401 * (0.5 * (1 - math.cos(2 * altitude))))","def pressure_to_altitude(pres):\n for i in range(len(_heights)-1,0,-1):\n P0 = _basepress[i]\n T0 = _basetemps[i]\n if pres < P0:\n if _isotherm[i]:\n dh = _R * T0 / _g * math.log(P0 / pres)\n else:\n l0 = _lapsert[i]\n dh = T0 / l0 * (math.pow(pres / P0, -l0 * _R / _g) - 1)\n return _heights[i] + dh\n l0 = _lapsert[0]\n return _stdtemp / l0 * (math.pow(pres / _stdpres, -l0 * _R / _g) - 1)","def RefractionAngle(refraction, altitude):\n if altitude < -90.0 or altitude > +90.0:\n return 0.0 # No attempt to correct an invalid altitude\n\n if refraction == Refraction.Normal or refraction == Refraction.JplHorizons:\n # http://extras.springer.com/1999/978-1-4471-0555-8/chap4/horizons/horizons.pdf\n # JPL Horizons says it uses refraction algorithm from\n # Meeus \"Astronomical Algorithms\", 1991, p. 101-102.\n # I found the following Go implementation:\n # https://github.com/soniakeys/meeus/blob/master/v3/refraction/refract.go\n # This is a translation from the function \"Saemundsson\" there.\n # I found experimentally that JPL Horizons clamps the angle to 1 degree below the horizon.\n # This is important because the 'refr' formula below goes crazy near hd = -5.11.\n hd = max(altitude, -1.0)\n refr = (1.02 / math.tan(math.radians((hd+10.3/(hd+5.11))))) / 60.0\n\n if refraction == Refraction.Normal and altitude < -1.0:\n # In \"normal\" mode we gradually reduce refraction toward the nadir\n # so that we never get an altitude angle less than -90 degrees.\n # When horizon angle is -1 degrees, the factor is exactly 1.\n # As altitude approaches -90 (the nadir), the fraction approaches 0 linearly.\n refr *= (altitude + 90.0) / 89.0\n else:\n # No refraction, or the refraction option is invalid.\n refr = 0.0\n return refr","def AEH2LatLonAlt(azim, elev, h, lat, lon, alt):\n\n # Compute the range to the point\n r = AEH2Range(azim, elev, h, lat, lon, alt)\n\n\n # Compute lat/lon/alt of the point on the line of sight\n x, y, z = AER2ECEF(azim, elev, r, lat, lon, alt)\n lat2, lon2, alt2 = ecef2LatLonAlt(x, y, z)\n lat2, lon2 = np.degrees(lat2), np.degrees(lon2)\n\n\n return lat2, lon2, alt2","def altitude_profile(self, alt):\n # checking if the units entered are km\n if alt.unit == u.km:\n if 150 <= alt.value < 500:\n alt_properties = self._altitude_profile(500)\n else:\n alt_properties = self._altitude_profile(alt.value)\n\n return [last[int(alt.value)] for last in alt_properties]","def offset_to_altaz(xoff, yoff, azimuth, altitude):\n #Deal with situations where offset = 0?\n\n d = sqrt(xoff*xoff+yoff*yoff)\n pos = np.where(d==0)\n d=1e-12 * u.deg # add a very small offset to prevent math errors\n\n q = arctan(d.to(u.rad).value)\n\n sq = sin(q)\n xp1 = xoff * (sq/d)\n yp1 = yoff * (sq/d)\n zp1 = cos(q)\n\n cx = sin(altitude)\n sx = cos(altitude)\n\n xp0 = cx*xp1 - sx*zp1\n yp0 = yp1\n zp0 = sx*xp1 + cx*zp1\n\n obj_altitude = arcsin(zp0)\n obj_altitude[pos]=altitude\n obj_azimuth = arctan2(yp0,-xp0) + azimuth\n obj_azimuth[pos] = azimuth\n\n #if obj_azimuth.value < 0.:\n # obj_azimuth += 2.*pi\n #elif obj_azimuth.value >= (2.*pi ):\n # obj_azimuth -= 2.*pi\n\n return obj_altitude,obj_azimuth","def get_altitude(points):\n altitudes = np.zeros((len(points),), dtype=\"float64\")\n for i, point in tqdm(enumerate(points), desc=\"GETTING ALTITUDE\"):\n p = Point(point[0], point[1])\n altitudes[i] = alt.NM_COTA.iloc[\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\n ]\n return altitudes","def getSlantRangeElevationHeight(self, groundRange, z):\r\n \r\n lat = self.ctrLat * pi / 180.0\r\n \r\n #figure out earth's radius at radar's lat ... non-spherical earth model\r\n e2 = self.eccen # First eccentricity squared - WGS-84 value = 0.00669437999013\r\n a = self.Requator # Equatorial radius - WGS-84 value = 6378137.0\r\n Rearth = a/sqrt(1-e2*(sin(lat))**2) # radius of curvature\r\n \r\n Rprime = self.effectiveRadiusMultiplier * self.Requator\r\n \r\n h = array(z - self.ctrAlt, dtype='float64')\r\n s = array(groundRange, dtype='float64')\r\n \r\n # Use law of cosines (Side-Angle-Side triangle theorem) with \r\n # R', R'+h as sides and s/R' as the angle to get slant range\r\n r = sqrt(Rprime**2.0 + (Rprime+h)**2.0 - 2*(Rprime+h)*Rprime*cos(s/Rprime))\r\n # Inverse of eq. 2.28c in Doviak and Zrnic 1993\r\n # Will return NaN for r=0\r\n el = arccos((Rprime+h) * sin(s/Rprime) / r) \r\n el *= 180.0 / pi\r\n \r\n return r, el","def altaz_to_offset(obj_azimuth,obj_altitude,azimuth,altitude):\n\n daz = obj_azimuth - azimuth\n coa = cos(obj_altitude)\n\n xp0 = -cos(daz) * coa\n yp0 = sin(daz) * coa\n zp0 = sin(obj_altitude)\n\n cx = sin(altitude)\n sx = cos(altitude)\n\n xp1 = cx*xp0 + sx*zp0\n yp1 = yp0\n zp1 = -sx*xp0 + cx*zp0\n\n q = arccos(zp1)\n d = tan(q)\n alpha = arctan2(yp1,xp1)\n\n xoff = d * cos(alpha)\n yoff = d * sin(alpha)\n\n return xoff,yoff","def altitude_control(self, altitude_cmd,\n vertical_velocity_cmd,\n altitude,\n vertical_velocity,\n attitude,\n acceleration_ff=0.0):\n \n hdot_cmd = self.Kp_alt * (altitude_cmd - altitude) + vertical_velocity_cmd\n \n # Limit the ascent/descent rate\n hdot_cmd = np.clip(hdot_cmd, -self.max_descent_rate, self.max_ascent_rate)\n\n acceleration_cmd = acceleration_ff + self.Kp_hdot*(hdot_cmd - vertical_velocity)\n \n R33 = np.cos(attitude[0]) * np.cos(attitude[1])\n thrust = DRONE_MASS_KG * acceleration_cmd / R33\n \n if thrust > MAX_THRUST:\n thrust = MAX_THRUST\n elif thrust < 0.0:\n thrust = 0.0\n return thrust","def getAltitudeFromLatLon(self, lat, lon):\r\n # print \"-----\\nFromLatLon\", lon, lat\r\n lat -= self.lat\r\n lon -= self.lon\r\n # print \"lon, lat\", lon, lat\r\n if lat < 0.0 or lat >= 1.0 or lon < 0.0 or lon >= 1.0:\r\n raise WrongTileError(self.lat, self.lon, self.lat+lat, self.lon+lon)\r\n x = lon * (self.size - 1)\r\n y = lat * (self.size - 1)\r\n # print \"x,y\", x, y\r\n x_int = int(x)\r\n x_frac = x - int(x)\r\n y_int = int(y)\r\n y_frac = y - int(y)\r\n # print \"frac\", x_int, x_frac, y_int, y_frac\r\n value00 = self.getPixelValue(x_int, y_int)\r\n value10 = self.getPixelValue(x_int+1, y_int)\r\n value01 = self.getPixelValue(x_int, y_int+1)\r\n value11 = self.getPixelValue(x_int+1, y_int+1)\r\n value1 = self._avg(value00, value10, x_frac)\r\n value2 = self._avg(value01, value11, x_frac)\r\n value = self._avg(value1, value2, y_frac)\r\n # print \"%4d %4d | %4d\\n%4d %4d | %4d\\n-------------\\n%4d\" % (\r\n # value00, value10, value1, value01, value11, value2, value)\r\n return value","def track_closest_aircraft(latitude, longitude, elevation, host, port, q):\n try:\n d = Dump1090(host, port)\n q.put(True)\n except IOError as exc:\n q.put(exc)\n return\n\n target = None\n target_distance = None\n aad = AzimuthAltitudeDistance(latitude, longitude, elevation)\n\n try:\n for aircraft in d.updates():\n lat, lng = aircraft.position\n azimuth, altitude, distance = aad.calculate(\n lat,\n lng,\n aircraft.altitude\n )\n\n # if we don't have a target we do now\n # or target is old, then use this new aircraft\n # or new aircraft isn't the target, but it is closer, so we switch!\n if (target is None or target.age > 60 or\n (target.icao != aircraft.icao and distance < target_distance)):\n target = aircraft\n\n # if we aren't the target at this point then bail\n if target.icao != aircraft.icao:\n continue\n\n target = aircraft\n target_distance = distance\n q.put((target, azimuth, altitude, distance))\n except KeyboardInterrupt:\n pass","def diff_of_errors(self):\n self.e_of_e = self.azimuth_error - self.altitude_error\n return self.e_of_e","def altitude(self, value: int):\n self._point.altitude = value","def optimal_tilt(lat):\n lat = abs(lat)\n if lat <= 25:\n return lat * 0.87\n elif lat <= 50:\n return (lat * 0.76) + 3.1\n else: # lat > 50\n # raise NotImplementedError('Not implemented for latitudes beyond 50.')\n return 40 # Simply use 40 degrees above lat 50","def optimal_tilt(lat):\n lat = abs(lat)\n if lat <= 25:\n return lat * 0.87\n elif lat <= 50:\n return (lat * 0.76) + 3.1\n else: # lat > 50\n # raise NotImplementedError('Not implemented for latitudes beyond 50.')\n return 40 # Simply use 40 degrees above lat 50","def temperature(self, alt):\n T = self.altitude_profile(alt)[1]\n return T","def lidar_relative(self):\n return self.distance","def getSlantRangeElevation(self, groundRange, el):\r\n \r\n lat = self.ctrLat * pi / 180.0\r\n theta = el * pi / 180.0\r\n \r\n #figure out earth's radius at radar's lat ... non-spherical earth model\r\n e2 = self.eccen # First eccentricity squared - WGS-84 value = 0.00669437999013\r\n a = self.Requator # Equatorial radius - WGS-84 value = 6378137.0\r\n Rearth = a/sqrt(1-e2*(sin(lat))**2) # radius of curvature\r\n \r\n # Inverse of eq. 2.28b in Doviak and Zrnic 1993\r\n # Inverse of eq. 2.28c in Doviak and Zrnic 1993\r\n\r\n Rprime = self.effectiveRadiusMultiplier * self.Requator\r\n\r\n s = array(groundRange, dtype='float64')\r\n\r\n h = Rprime * ( math.cos(theta) / math.cos( theta + s / Rprime) - 1)\r\n\r\n r = (Rprime + h) * math.sin(s / Rprime) / math.cos(theta);\r\n\r\n # Use law of cosines (Side-Angle-Side triangle theorem) with \r\n # R', R'+h as sides and s/R' as the angle to get slant range\r\n #r = sqrt(Rprime**2.0 + (Rprime+h)**2.0 - 2*(Rprime+h)*Rprime*cos(s/Rprime))\r\n # Will return NaN for r=0\r\n #el = arccos((Rprime+h) * sin(s/Rprime) / r) \r\n #el *= 180.0 / pi\r\n \r\n return r,h","def is_cruising(altitude, cruise_altitude=None):\n if cruise_altitude is None:\n cruise_altitude = closest_cruising_altitude(altitude)\n return abs(altitude - cruise_altitude) <= 200","def _get_lip_best(self) -> float:\n pass","def air_density(altitude):\n p = pressure(altitude) # psf\n t = temperature(altitude) # R\n rho = p/(gas_constant*t) # lb/ft3\n return rho","def top_of_descent_index(self):\n tod = self.altitudes.argmax()\n # if the altitude profile is not just a climb\n # and there is a cruising section\n if (tod < len(self.altitudes) - 1) and \\\n (self.altitudes[tod] == self.altitudes[tod + 1]):\n tod += 1\n\n return tod","def haversine_distance_ignore_altitude(loc1_lat, loc1_lon, loc2_lat, loc2_lon):\n R = 6372797.560856 # radius of the earth in meters\n\n lat_arc = math.radians(loc1_lat - loc2_lat)\n lon_arc = math.radians(loc1_lon - loc2_lon)\n\n lat_h = math.sin(lat_arc * 0.5)\n lat_h = lat_h * lat_h\n\n lon_h = math.sin(lon_arc * 0.5)\n lon_h = lon_h * lon_h\n\n tmp = math.cos(math.radians(loc1_lat)) * math.cos(math.radians(loc2_lat))\n rad = 2.0 * math.asin(math.sqrt(lat_h + tmp * lon_h))\n\n return rad * R","def top_of_climb_index(self):\n return self.altitudes.argmax()","def sim_altitude(a):\n a.takeoff()\n for i in range(20):\n b = a.refresh()\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() + 3)\n print a.altitude.get_altitudes(), b\n a.land()\n a.motor.set_speed(2000.0)\n for i in range(20):\n b = a.refresh()\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() - 3)\n print a.altitude.get_altitudes(), b","def calculate_longitude(prior_lat, source_long, distance, heading):\n\n return ((source_long - \\\n math.asin(math.sin(heading)*math.sin(distance)/math.cos(prior_lat))\n + math.pi) % (2*math.pi)) - math.pi","def diversion(self) -> Optional[\"Flight\"]:\n from ..data import airports\n\n # The following cast secures the typing\n self = cast(\"Flight\", self)\n\n f_above: Optional[\"Flight\"] = self.query(\"altitude > 15000\")\n if (\n self.destination != self.destination\n or airports[self.destination] is None # type: ignore\n or f_above is None\n ):\n return None\n\n return (\n f_above.distance(airports[self.destination]) # type: ignore\n .diff(\"distance\")\n .agg_time(\"10T\", distance_diff=\"mean\")\n .query(\"distance_diff > 0\")\n )","def haDecFromAzAlt (azAlt, lat):\n # convert spherical az/alt (deg) to direction cosines\n azAltDC = dcFromSC (azAlt)\n\n # convert az/alt direction cosines to -ha/dec direction cosines\n negHADecDC = Cnv.haDecFromAzAlt (azAltDC, lat)\n\n # convert -ha/dec direction cosines to spherical -ha/dec (deg)\n ((negHA, dec), atPole) = scFromDC (negHADecDC)\n\n return ((RO.MathUtil.wrapCtr(-negHA), dec), atPole)","def _plunge_distance(self, volume):\n percent = self._volume_percentage(volume)\n top = self._get_plunger_position('top')\n bottom = self._get_plunger_position('bottom')\n travel = bottom - top\n if travel <= 0:\n self.robot.add_warning('Plunger calibrated incorrectly')\n return travel * percent","def get_elementary_airspace_altitude_range(db_id):\n connection = get_geo_db_connection()\n sector = find_sector(db_id, connection)\n if (sector):\n return (sector['min_altitude'], sector['max_altitude'])\n else:\n raise NotFoundException(db_id, \"Elementary sector not found.\")","def get_evaporation_latent_heat() -> float:\n theta = 28.0\n return 2500.8 - 2.3668 * theta","def elevation(source):\n srcAzEl = subarrayControl.s.azel(source, 0.0);\n return srcAzEl[1];","def _FindNearestAnat(self, acqtime):\n tdiff_min = 1e6\n for anat in self.entry_map['anat']:\n if self.info[anat]['type'] == 'T1High' and \\\n self.info[anat]['InversionTime'] > 0.:\n tdiff = abs(acqtime - self.info[anat]['acqtime'])\n if tdiff < tdiff_min:\n tdiff_min = tdiff\n anat_min = anat\n return anat_min","def read_altitude(self, meanSeaLevelPressureInBar):\n phPa = self.read_pressure() / 100.0\n\n return float(44330.0 * (1.0 - math.pow((phPa / meanSeaLevelPressureInBar), 0.1903)))","def read_altitude(self, meanSeaLevelPressureInBar):\n phPa = self.read_pressure() / 100.0\n\n return float(44330.0 * (1.0 - math.pow((phPa / meanSeaLevelPressureInBar), 0.1903)))","def AEH2Range(azim, elev, h, lat, lon, alt):\n\n\n def _heightCostFunction(params, azim, elev, h, lat, lon, alt):\n\n # Get the guessed range\n r = params\n\n # Compute the ECEF coordinates with the given range\n x, y, z = AER2ECEF(azim, elev, r, lat, lon, alt)\n\n # Compute the height\n _, _, h_computed = ecef2LatLonAlt(x, y, z)\n\n # Return residual between the heights\n return (h_computed - h)**2\n\n\n # Use a flat-Earth range as a first guess of range if the elevation is higher than 10 degrees\n if elev > np.radians(10):\n r0 = (h - alt)/np.sin(np.radians(elev))\n else:\n # Otherwise, use a distance of 1000 km\n r0 = 1e6\n\n # Numerically find the range which corresponds to the given height above the ground\n res = scipy.optimize.minimize(_heightCostFunction, r0, \\\n args=(azim, elev, h, lat, lon, alt))\n\n # Return the minimized solution\n return res.x[0]","def classify_altitude_profile(altitudes):\n max_alt = altitudes.max()\n has_climb = (max_alt > altitudes[0])\n has_descent = (max_alt > altitudes[-1])\n\n if has_climb or has_descent:\n if has_climb != has_descent:\n return AltitudeProfileType.CLIMBING if has_climb \\\n else AltitudeProfileType.DESCENDING\n else:\n return AltitudeProfileType.CLIMBING_AND_DESCENDING\n else:\n return AltitudeProfileType.CRUISING","def get_resistance(self):\n adc = ADC(self.pin)\n value = adc.read()\n if value == 0:\n return -1\n\n return (4095./value - 1.) * self.RLOAD","def GetAbsBeer(epsilon, conc, pathLength):\n return epsilon * conc * pathLength","def pair_from_elev(elevation):\n # version converted from vb.net\n\n # return 101.3 * ((293. - 0.0065 * elevm) / 293.) ** (9.8 / (0.0065 * 286.9)) # kPa ' standardized by ASCE 2005\n\n # version from from DRI\n\n # return 101.3 * np.power((293.0 - 0.0065 * elevation) / 293.0, 5.26)\n\n # version extended to better match vb.net version\n # 5.255114352 = 9.8 / (0.0065 * 286.9\n\n return 101.3 * np.power((293.0 - 0.0065 * elevation) / 293.0, 5.255114352)","def process_driver_altitude(coordinate: Coordinate) -> ProcessDescription:\n city = get_city_by_coordinates(\n latitude=coordinate.latitude,\n longitude=coordinate.longitude,\n )\n city_coordinates = CITIES_COORDINATES_MAP.get(city)\n if not city_coordinates:\n return ProcessDescription(\n detect=False,\n description='Invalid city coordinates.'\n )\n\n altitude_min = city_coordinates['altitude_min']\n altitude_max = city_coordinates['altitude_max']\n\n if altitude_min <= coordinate.altitude <= altitude_max:\n return ProcessDescription(\n detect=False,\n description=(\n f'Driver altitude {coordinate.altitude} '\n f'is normal for city {city.capitalize()}.'\n )\n )\n\n return ProcessDescription(\n detect=True,\n description=(\n f'Driver has incorrect altitude {coordinate.altitude} '\n f'for city {city.capitalize()}.'\n )\n )","def get_surface_elevation(wind_lat, wind_lon):\n # Load the NetCDF file containing the geopotential of Europe.\n nc = Dataset(path_join(era5_data_dir, geopotential_file_name))\n \n # Read the variables from the netCDF file.\n geopot_lat = nc.variables['latitude'][:]\n geopot_lon = nc.variables['longitude'][:]\n \n \n # Check if wind and geopotential data use same grid.\n assert np.array_equal(geopot_lat, wind_lat) and np.array_equal(geopot_lon, wind_lon), \\\n \"Requested latitudes and/or longitudes do not correspond to those in the NetCDF file.\"\n\n geopot_z = nc.variables['z'][0, :, :]\n nc.close()\n\n surface_elevation = geopot_z/9.81\n print(\"Minimum and maximum elevation found are respectively {:.1f}m and {:.1f}m, removing those below zero.\"\n .format(np.amin(surface_elevation), np.amax(surface_elevation)))\n\n # Get rid of negative elevation values.\n for i, row in enumerate(surface_elevation):\n for j, val in enumerate(row):\n if val < 0.:\n surface_elevation[i, j] = 0.\n\n return surface_elevation","def getGroundRangeHeight(self, r, elevationAngle):\r\n \r\n #Double precison arithmetic is crucial to proper operation.\r\n lat = self.ctrLat * pi / 180.0\r\n elev = array(elevationAngle * pi / 180.0, dtype='float64')\r\n slantr = array(r, dtype='float64')\r\n \r\n #figure out earth's radius at radar's lat ... non-spherical earth model\r\n e2 = self.eccen # First eccentricity squared - WGS-84 value = 0.00669437999013\r\n a = self.Requator # Equatorial radius - WGS-84 value = 6378137.0\r\n Rearth = a/sqrt(1-e2*(sin(lat))**2) # radius of curvature\r\n \r\n Rprime = self.effectiveRadiusMultiplier * self.Requator\r\n \r\n # Eqns 2.28b,c in Doviak and Zrnic 1993\r\n # Radar altitude is tacked on at the end, which isn't part of their derivation. At 100 km, it's \r\n # worth < 10 m range error total for a radar at 500 m MSL. For 250 m gate spacing (typical at S-band), \r\n # this is not too important.\r\n h = sqrt(slantr**2.0 + Rprime**2.0 + 2*slantr*Rprime*sin(elev)) - Rprime\r\n s = Rprime * arcsin( (slantr*cos(elev)) / (Rprime + h) )\r\n \r\n h += self.ctrAlt\r\n \r\n return s, h","def guess_anchor(self):\n return self.nearest(\"VP\")","def get_temperature(elevation, sea_level):\n if elevation <= sea_level:\n return 0.8\n else:\n return (-1.0 / (1.0 - sea_level)) * (elevation - sea_level) + 1.0","def get_alt(self, dec, i_alt):\n return self.decisions[dec].value[i_alt]","def intersection_distances(self, altitude, start_distance, finish_distance):\n distances = []\n alt_index, alt_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, alt_index, alt_ratio)\n\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n while alt_index < finish_index:\n next_index = alt_index + 1\n next_ratio = 0.0\n next_alt = calculate_value(self.altitudes, next_index, next_ratio)\n\n # Does this section span the given altitude?\n if (next_alt != start_alt) and \\\n (min(start_alt, next_alt) < altitude < max(start_alt, next_alt)):\n delta = altitude - start_alt\n denom = next_alt - start_alt\n ratio = delta / denom\n distance = calculate_value(self.distances, alt_index, ratio)\n distances.append(distance)\n\n alt_index = next_index\n alt_ratio = next_ratio\n start_alt = next_alt\n\n if finish_ratio:\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n # Does the last section span the given altitude?\n if (start_alt != finish_alt) and \\\n (min(start_alt, finish_alt) < altitude < max(start_alt, finish_alt)):\n # Calculate the altitude at the end of the section to maximimse accuracy\n next_alt = calculate_value(self.altitudes, finish_index, 1.0)\n delta = altitude - start_alt\n denom = next_alt - start_alt\n ratio = delta / denom\n distance = calculate_value(self.distances, alt_index, ratio)\n distances.append(distance)\n\n return distances","def get_alt_loc(self, alt_loc):\n try:\n return self[alt_loc]\n except KeyError:\n return None","def alt_index(self) -> Optional[int]:\n if not self.is_hom_alt():\n return None\n return max(self.allele1, self.allele2) - 1","def get_resistance(self):\n adc = ADC(self.pin)\n value = adc.read()\n if value == 0:\n return -1\n\n return (4095./value - 1.) * self.RLOAD # ESP32 maksimi, ESP8266:lle arvo on 1023","def fit_elevation(self, elevation):\n if self.p_opt is None:\n result = elevation * np.nan\n else:\n result = self.value_at(elevation, *self.p_opt)\n if isinstance(result, units.Quantity):\n result = result.value\n return result","def pressure(altitude):\n t = temperature(altitude) # R\n if altitude <= 36152:\n p = 2116*(t/518.6)**5.256 # psf\n else:\n p = 473.1*exp(1.73-0.000048*altitude) # psf\n return p","def altitude_range(self, start_distance, finish_distance):\n start_index, start_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n\n min_alt = min(start_alt, finish_alt)\n max_alt = max(start_alt, finish_alt)\n\n if start_index < finish_index:\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\n min_alt = min(min_alt, altitudes.min())\n max_alt = max(max_alt, altitudes.max())\n\n return min_alt, max_alt","def get_best_move_toward(self, target_ground):\n options_by_parent, cost_to_reach = self.a_star_search(start=self.ground, goal=target_ground)\n ground = target_ground\n\n # Can't reach it?\n if ground not in options_by_parent:\n return None\n\n while options_by_parent[ground] is not self.ground:\n ground = options_by_parent[ground]\n\n return ground.x - self.ground.x, ground.y - self.ground.y","def altitude(p):\r\n \r\n R = 290 #specific gas constant \r\n T = 93.65 #surface temperature K from A.Coustenis book\r\n g = 1.354 #surface gravity from A.Coustenis book\r\n p0 = 1467 #surface pressure in hPa 6.1 for mars\r\n \r\n z = np.empty_like(p)\r\n \r\n for i in range(p.shape[0]):\r\n z[i] = (-1)*(R*T/g)*np.log((p[i])/p0)/(10**3)\r\n \r\n # Make into an xarray DataArray\r\n z_xr = xr.DataArray(z, coords=[z], dims=['pfull'])\r\n z_xr.attrs['units'] = 'km'\r\n \r\n #below is the inverse of the calculation\r\n #p[i] = p0*np.exp((-1)*z[i]*(10**3)/((R*T/g)))\r\n \r\n return z_xr","def diffuse_underclear(latitude_deg, longitude_deg, utc_datetime, elevation = elevation_default, \n temperature_celsius = 25, pressure_millibars = 1013.25, TL=TL_default): \n DT = ((-21.657) + (41.752 * (TL)) + (0.51905 * (TL) * (TL)))\n altitude = solar.GetAltitude(latitude_deg, longitude_deg,utc_datetime, elevation, temperature_celsius,pressure_millibars)\n\n return mean_earth_sun_distance(utc_datetime) * DT * altitude","def altaz_to_radec(alt_az, pos=local_latlong,\n minute=minute, hour=hour, day=day,\n month=month, year=year, tz_offset=5):\n # Retrieve the coordinates and convert them to rads for some trig.\n lat, long = pos[0] * (np.pi/180), pos[1] * (np.pi/180)\n alt, az = alt_az[0] * (np.pi/180), alt_az[1] * (np.pi/180)\n\n gmst = localtime_to_gmst(minute=minute, hour=hour,\n day=day, month=month, year=year, tz_offset=5)\n\n sin_dec = np.sin(alt) * np.sin(lat) + np.cos(alt) * np.cos(lat) * np.cos(az)\n dec = np.arcsin(sin_dec)\n\n cosHA = (np.sin(alt) - np.sin(lat) * np.sin(dec))/(np.cos(lat) * np.cos(dec))\n HA = np.arccos(cosHA) * (180/np.pi)\n\n dec *= (180/np.pi)\n ra = gmst + HA + (long * 180/np.pi) if az < np.pi else gmst - HA + (long * 180/np.pi)\n\n ra_dec = (round(ra, 4), round(dec, 4))\n return ra_dec","def getAltitudeProfile(pass_length,terrain,uav_altitude,u,start_v,wind_angle):\n altitude_profile = []\n v = start_v\n for k in range(0,round(pass_length)):\n coord = convertCoords([[u,v]],wind_angle,'xy')\n x = coord[0][0]\n y = coord[0][1]\n x_points = [int(x),int(x),int(x)+1,int(x)+1]\n y_points = [int(y),int(y)+1,int(y)+1,int(y)]\n z_points = [terrain[int(y)][int(x)],terrain[int(y)+1][int(x)],\n terrain[int(y)+1][int(x)+1],terrain[int(y)][int(x)+1]]\n\n # For created terrain ONLY\n z = griddata((x_points,y_points),z_points,(x,y)) # Interpolate \n altitude = z + uav_altitude\n\n altitude_profile.append(altitude)\n v +=1\n return altitude_profile","def get_min_distance(self):\n return round(min(self.combined_euclidian_distance))","def road_multiplier(highway, bicycle_pref, motorway_pref, highway_pref, residential_pref):\n if highway == 'motorway':\n result = -motorway_pref*0.5\n elif highway == 'primary':\n result = -highway_pref*0.5\n elif highway == 'residential' or highway == 'service':\n result = -residential_pref*0.5\n elif highway == 'cycleway':\n result = -bicycle_pref * 0.8\n else:\n result = 0\n return result","def arm_and_takeoff_nogps(aTargetAltitude):\n\n print(\"Taking of to an altitude of \", str(aTargetAltitude))\n\n print(\"Basic pre-arm checks\")\n\n while not vehicle.is_armable:\n print(\" Waiting for vehicle to initialise...\")\n time.sleep(1)\n\n print(\"Arming motors\")\n # Copter should arm in GUIDED_NOGPS mode\n vehicle.mode = VehicleMode(\"GUIDED_NOGPS\")\n vehicle.armed = True\n\n while not vehicle.armed:\n print(\" Waiting for arming...\")\n vehicle.armed = True\n time.sleep(1)\n\n print(\"Taking off!\")\n\n thrust = DEFAULT_TAKEOFF_THRUST\n while True:\n current_altitude = vehicle.location.global_relative_frame.alt\n print(\" Altitude: %f Desired: %f\" %\n (current_altitude, aTargetAltitude))\n if current_altitude >= aTargetAltitude*0.95: # Trigger just below target alt.\n print(\"Reached target altitude\")\n break\n elif current_altitude >= aTargetAltitude*0.6:\n thrust = SMOOTH_TAKEOFF_THRUST\n set_attitude(thrust = thrust)\n time.sleep(0.2)","def get_salinity(self) -> float:\n try:\n datalist = self.get_data()\n data = datalist[2]\n if data.endswith('\\x00'):\n data = data.rstrip('\\x00')\n return float(data)\n else:\n return float(data)\n except Exception as err:\n print(f'get_salinity error: {err}')\n return -1","def get_closest_station_by_zipcode(zipcode):\n\n station_lookup_method_by_zipcode = lookup_usaf_station_by_zipcode(zipcode)\n try:\n station, warnings, lat, lon = _get_closest_station_by_zcta_ranked(zipcode)\n\n isd_metadata = get_isd_file_metadata(str(station))\n if len(isd_metadata) == 0:\n logging.warning(\"Zipcode %s mapped to station %s, but no ISD metadata was found.\" % (zipcode, station))\n return station_lookup_method_by_zipcode\n\n except UnrecognizedUSAFIDError as e:\n logging.warning(\"Closest station %s is not a recognized station. Using backup-method station %s for zipcode %s instead.\" % (\n str(station),\n station_lookup_method_by_zipcode,\n zipcode))\n return station_lookup_method_by_zipcode\n\n except UnrecognizedZCTAError as e:\n logging.warning(\"Unrecognized ZCTA %s\" % e)\n return None\n\n if str(station) != station_lookup_method_by_zipcode:\n logging.debug(\"Previously would have selected station %s instead of %s for zip code %s\" % (\n station_lookup_method_by_zipcode,\n str(station),\n zipcode))\n\n if warnings:\n logging.warning(\"Station %s is %d meters over maximum %d meters (%d meters) (zip code %s is at lat/lon %f, %f)\" % (\n str(station),\n int(warnings[0].data['distance_meters'] - warnings[0].data['max_distance_meters']),\n int(warnings[0].data['max_distance_meters']),\n int(warnings[0].data['distance_meters']),\n zipcode,\n lat,\n lon,\n ))\n logging.warning(\"Closest station %s is too far. Using backup-method station %s instead.\" % (\n str(station),\n station_lookup_method_by_zipcode))\n return station_lookup_method_by_zipcode\n\n return str(station)","def get_overland(p1, p2, tolerance = 0.1, min_slope = 0.00001):\n\n L = get_distance(p1, p2)\n\n if L > tolerance: return L / 2., (p1[2] - p2[2]) / L / 100000\n else: return tolerance, min_slope","def impact_prediction(\n radius: float,\n target_altitude: float,\n vertical_speed: float,\n horizontal_speed: float,\n surface_gravity: float,\n ut: float,\n):\n fall_speed = -vertical_speed\n downward_acceleration = (\n surface_gravity - horizontal_speed * horizontal_speed / radius\n )\n\n # do we already landed?\n if target_altitude < 0:\n return None, None\n\n # do we land?\n if downward_acceleration < 0:\n max_fall_distance = -(fall_speed * fall_speed) / (\n 2.0 * downward_acceleration\n )\n if max_fall_distance < (target_altitude + 1.0):\n return None, None\n\n sec_until_impact = (\n -fall_speed\n + math.sqrt(\n fall_speed * fall_speed\n + 2.0 * downward_acceleration * target_altitude\n )\n ) / downward_acceleration\n\n vertical_speed_at_impact = (\n fall_speed + sec_until_impact * downward_acceleration\n )\n impact_speed = math.sqrt(\n vertical_speed_at_impact * vertical_speed_at_impact\n + horizontal_speed * horizontal_speed\n )\n impact_ut = sec_until_impact + ut\n return impact_ut, impact_speed","def altAz2RADec(azim, elev, jd, lat, lon):\n\n azim = np.radians(azim)\n elev = np.radians(elev)\n lat = np.radians(lat)\n lon = np.radians(lon)\n \n # Calculate hour angle\n ha = np.arctan2(-np.sin(azim), np.tan(elev)*np.cos(lat) - np.cos(azim)*np.sin(lat))\n\n # Calculate Local Sidereal Time\n lst = np.radians(JD2LST(jd, np.degrees(lon))[0])\n \n # Calculate right ascension\n ra = (lst - ha)%(2*np.pi)\n\n # Calculate declination\n dec = np.arcsin(np.sin(lat)*np.sin(elev) + np.cos(lat)*np.cos(elev)*np.cos(azim))\n\n return np.degrees(ra), np.degrees(dec)","def _get_elevation_percentage(height: float, distance: float) -> float:\n return height / (distance * 1000)","def get_user_sector_altitude_range(db_id):\n found, sector = user_sector_finder(\"id\", int(db_id))\n if found:\n return (sector[0]['min_altitude'], sector[0]['max_altitude'])\n else:\n raise NotFoundException(db_id, \"User sector not found.\")","async def get_altaz(self, **kwargs: Any) -> Tuple[float, float]:\n if self.observer is not None:\n alt_az = self.observer.altaz(Time.now(), self._telescope.position)\n return float(alt_az.alt.degree), float(alt_az.az.degree)\n else:\n raise ValueError(\"No observer given.\")","def lidar_absolute(self):\n return np.roll(self.distance, self.heading_idx)","def get_tolerance(self):\n return self.tolerance","def get_abs_tolerance(self):\n\n if Test.global_abs_tolerance is None:\n return self._abs_tolerance\n return Test.global_abs_tolerance","def speed_of_sound(altitude):\n t = temperature(altitude) # R\n a = sqrt(gamma*gas_constant*t) # [ft/s]\n return a","def slewEstimate(source1,source2=None,ant=1,returnUnit='time') :\n azel1 = azel(source1)\n azel1[0] = _wrapFix(azel1[0], ant)\n if source2 == None: \n azel2 = currentAzel(ant)\n else:\n azel2 = azel(source2)\n azel2[0] = _wrapFix(azel2[0], ant)\n az1 = [azel1[0], _wrapChoice(azel1[0], ant)]\n az2 = [azel2[0], _wrapChoice(azel2[0], ant)]\n print az1, az2\n deltaAz = 360\n deltaAz = min(deltaAz, abs(az1[0]-az2[0]))\n deltaAz = min(deltaAz, abs(az1[0]-az2[1]))\n deltaAz = min(deltaAz, abs(az1[1]-az2[0]))\n deltaAz = min(deltaAz, abs(az1[1]-az2[1]))\n delta = [deltaAz, abs(azel1[1]-azel2[1])]\n print delta\n if ant < 7:\n azRate = 60.0\n elRate = 30.0\n settleTime = 5.0\n elif ant < 16: \n azRate = 120.0\n elRate = 60.0\n settleTime = 10.0\n else: \n azRate = 60.0\n elRate = 30.0\n settleTime = 8.0\n if returnUnit == 'time': \n return max(delta[0]/azRate,delta[1]/elRate) + settleTime/60.0\n return delta","def le_calibration_func(etr, kc, ts):\n return etr * kc * (2.501 - 2.361E-3 * (ts - 273)) * 2500 / 9","def _generate_equilateral_triangle_around_point(\n center_point: Coordinate, altitude: Decimal = TRIANGLE_ALTITUDE\n) -> Tuple[Coordinate, Coordinate, Coordinate]:\n # This is how you math I guess?\n side_length = 2 * altitude / Decimal(sqrt(3))\n\n ay = center_point.y + altitude / 2\n ax = center_point.x\n a = Coordinate(ay, ax)\n\n by = center_point.y - altitude / 2\n bx = center_point.x + side_length / 2\n b = Coordinate(by, bx)\n\n cy = center_point.y - altitude / 2\n cx = center_point.x - side_length / 2\n c = Coordinate(cy, cx)\n\n return (a, b, c)"],"string":"[\n \"def altitude(self):\\n if self.__altitude:\\n return sum(self.__altitude) / len(self.__altitude)\\n else:\\n return -9999\",\n \"def altitude(self):\\r\\n pressure = self.pressure # in Si units for hPascal\\r\\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))\",\n \"def set_altitude(self):\\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\\n print('altitude set to', self.altitude)\\n if self.altitude < 0:\\n self.altitude = self.altitude + 360.0\\n return self.altitude \\n else: \\n pass\\n return self.altitude\",\n \"def altitude(self) -> int:\\n return self._point.altitude\",\n \"def topographic_altitude(self, lat_d, lon_d):\\n return self.altitude(lat_d, lon_d)\",\n \"def topographic_altitude(self, lat_d, lon_d):\\n return self.altitude(lat_d, lon_d)\",\n \"def topographic_altitude(lat, lon):\\n global __model\\n type_output = type(lat)\\n lat = prepare_input_array(lat)\\n lon = prepare_input_array(lon)\\n lon = np.mod(lon, 360)\\n val = __model.topographic_altitude(lat, lon)\\n val = np.maximum(val, 1e-7)\\n return prepare_output_array(val, type_output) * u.km\",\n \"def test_triangle_get_shortest_altitude(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)\",\n \"def get_air_density(self, altitude):\\n\\n altitude /= 1000 # convert to kilometers\\n\\n return self.get_air_density_from_model(altitude)\",\n \"def get_altitude(self):\\n self.degrees = self.altitude_encoder.get_degrees()\\n self.tele_altitude = self.Calculations.convert_degrees( self.degrees)\\n return self.tele_altitude\",\n \"def getAltitudeAngle(self):\\n return self._altitude\",\n \"def temperature(altitude):\\n if altitude <= 36152:\\n t = 59-0.00356*altitude # deg F\\n else:\\n t = -70 # deg F\\n t = t + 459.7 # R\\n return t\",\n \"def altitude(press, altimeter=29.92126):\\n AS = altimeter*inHg2PA\\n print(AS, press**(L*R/g/M))\\n h = -(press**(L*R/g/M) - AS**(L*R/g/M))*T0/L/(P0**(L*R/g/M))\\n return h/ft2m\",\n \"def setTargetAltitude(altitude):\\n return RoboCaller().call(\\\"setTargetAltitude\\\", \\\"void\\\", altitude)\",\n \"def get_altitude(self):\\n return self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_GET_ALTITUDE, (), '', 'i')\",\n \"def ecef2LatLonAlt(x, y, z):\\n\\n # Calculate the polar eccentricity\\n ep = np.sqrt((EARTH.EQUATORIAL_RADIUS**2 - EARTH.POLAR_RADIUS**2)/(EARTH.POLAR_RADIUS**2))\\n\\n # Calculate the longitude\\n lon = np.arctan2(y, x)\\n\\n p = np.sqrt(x**2 + y**2)\\n\\n theta = np.arctan2( z*EARTH.EQUATORIAL_RADIUS, p*EARTH.POLAR_RADIUS)\\n\\n # Calculate the latitude\\n lat = np.arctan2(z + (ep**2)*EARTH.POLAR_RADIUS*np.sin(theta)**3, \\\\\\n p - (EARTH.E**2)*EARTH.EQUATORIAL_RADIUS*np.cos(theta)**3)\\n\\n # Get distance from Earth centre to the position given by geographical coordinates, in WGS84\\n N = EARTH.EQUATORIAL_RADIUS/math.sqrt(1.0 - (EARTH.E**2)*math.sin(lat)**2)\\n\\n \\n # Calculate the height in meters\\n\\n # Correct for numerical instability in altitude near exact poles (and make sure cos(lat) is not 0!)\\n if((np.abs(x) < 1000) and (np.abs(y) < 1000)):\\n alt = np.abs(z) - EARTH.POLAR_RADIUS\\n\\n else:\\n # Calculate altitude anywhere else\\n alt = p/np.cos(lat) - N\\n\\n\\n return lat, lon, alt\",\n \"def test_triangle_get_longest_altitude(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_longest_altitude(), 9.428090415820634)\",\n \"def altitude_speed(self, degrees = True):\\n return self.angularSpeed(self.future_location.al, self.old_location.al)\",\n \"def get_altitude(self, degrees=True):\\n if degrees:\\n return math.degrees(self.current_location.al)\\n else:\\n return self.current_location.al\",\n \"def InverseRefractionAngle(refraction, bent_altitude):\\n if bent_altitude < -90.0 or bent_altitude > +90.0:\\n return 0.0 # No attempt to correct an invalid altitude\\n # Find the pre-adjusted altitude whose refraction correction leads to 'altitude'.\\n altitude = bent_altitude - RefractionAngle(refraction, bent_altitude)\\n while True:\\n # See how close we got. Keep iterating until the solution converges.\\n diff = (altitude + RefractionAngle(refraction, altitude)) - bent_altitude\\n if abs(diff) < 1.0e-14:\\n return altitude - bent_altitude\\n altitude -= diff\",\n \"def elevation(self):\\n return self.altitude - self.heightAboveGround\",\n \"def altitude_to_pressure(alt):\\n for i in range(len(_heights)-1,0,-1):\\n h0 = _heights[i]\\n T0 = _basetemps[i]\\n if alt > h0:\\n if _isotherm[i]:\\n rP = math.exp(-_g / _R / T0 * (alt - h0))\\n else:\\n l0 = _lapsert[i]\\n rP = math.pow(1 + (alt - h0) * l0 / T0, -_g / _R / l0)\\n return _basepress[i] * rP\\n l0 = _lapsert[0]\\n return _stdpres * math.pow(1 + alt * l0 / _stdtemp, -_g / _R / l0)\",\n \"def calibrateElevation(self,elevation):\\n if len(self.values) == self.values.maxlen:\\n self.elevcomp = self.value / ((1.0 - ((elevation + self.heightAboveGround) * 0.3048 / 44330.0)) ** 5.255)\\n self.calibrated = True\\n else:\\n self.calibratedElevation = elevation\",\n \"def solarelevation_function_overcast(latitude_deg, longitude_deg, utc_datetime,\\n elevation = elevation_default, temperature_celsius = 25,\\n pressure_millibars = 1013.25):\\n altitude = solar.GetAltitude(latitude_deg, longitude_deg,utc_datetime, elevation, temperature_celsius,pressure_millibars)\\n return ((-0.0067133) + (0.78600 * (math.sin(altitude)))) + (0.22401 * (0.5 * (1 - math.cos(2 * altitude))))\",\n \"def pressure_to_altitude(pres):\\n for i in range(len(_heights)-1,0,-1):\\n P0 = _basepress[i]\\n T0 = _basetemps[i]\\n if pres < P0:\\n if _isotherm[i]:\\n dh = _R * T0 / _g * math.log(P0 / pres)\\n else:\\n l0 = _lapsert[i]\\n dh = T0 / l0 * (math.pow(pres / P0, -l0 * _R / _g) - 1)\\n return _heights[i] + dh\\n l0 = _lapsert[0]\\n return _stdtemp / l0 * (math.pow(pres / _stdpres, -l0 * _R / _g) - 1)\",\n \"def RefractionAngle(refraction, altitude):\\n if altitude < -90.0 or altitude > +90.0:\\n return 0.0 # No attempt to correct an invalid altitude\\n\\n if refraction == Refraction.Normal or refraction == Refraction.JplHorizons:\\n # http://extras.springer.com/1999/978-1-4471-0555-8/chap4/horizons/horizons.pdf\\n # JPL Horizons says it uses refraction algorithm from\\n # Meeus \\\"Astronomical Algorithms\\\", 1991, p. 101-102.\\n # I found the following Go implementation:\\n # https://github.com/soniakeys/meeus/blob/master/v3/refraction/refract.go\\n # This is a translation from the function \\\"Saemundsson\\\" there.\\n # I found experimentally that JPL Horizons clamps the angle to 1 degree below the horizon.\\n # This is important because the 'refr' formula below goes crazy near hd = -5.11.\\n hd = max(altitude, -1.0)\\n refr = (1.02 / math.tan(math.radians((hd+10.3/(hd+5.11))))) / 60.0\\n\\n if refraction == Refraction.Normal and altitude < -1.0:\\n # In \\\"normal\\\" mode we gradually reduce refraction toward the nadir\\n # so that we never get an altitude angle less than -90 degrees.\\n # When horizon angle is -1 degrees, the factor is exactly 1.\\n # As altitude approaches -90 (the nadir), the fraction approaches 0 linearly.\\n refr *= (altitude + 90.0) / 89.0\\n else:\\n # No refraction, or the refraction option is invalid.\\n refr = 0.0\\n return refr\",\n \"def AEH2LatLonAlt(azim, elev, h, lat, lon, alt):\\n\\n # Compute the range to the point\\n r = AEH2Range(azim, elev, h, lat, lon, alt)\\n\\n\\n # Compute lat/lon/alt of the point on the line of sight\\n x, y, z = AER2ECEF(azim, elev, r, lat, lon, alt)\\n lat2, lon2, alt2 = ecef2LatLonAlt(x, y, z)\\n lat2, lon2 = np.degrees(lat2), np.degrees(lon2)\\n\\n\\n return lat2, lon2, alt2\",\n \"def altitude_profile(self, alt):\\n # checking if the units entered are km\\n if alt.unit == u.km:\\n if 150 <= alt.value < 500:\\n alt_properties = self._altitude_profile(500)\\n else:\\n alt_properties = self._altitude_profile(alt.value)\\n\\n return [last[int(alt.value)] for last in alt_properties]\",\n \"def offset_to_altaz(xoff, yoff, azimuth, altitude):\\n #Deal with situations where offset = 0?\\n\\n d = sqrt(xoff*xoff+yoff*yoff)\\n pos = np.where(d==0)\\n d=1e-12 * u.deg # add a very small offset to prevent math errors\\n\\n q = arctan(d.to(u.rad).value)\\n\\n sq = sin(q)\\n xp1 = xoff * (sq/d)\\n yp1 = yoff * (sq/d)\\n zp1 = cos(q)\\n\\n cx = sin(altitude)\\n sx = cos(altitude)\\n\\n xp0 = cx*xp1 - sx*zp1\\n yp0 = yp1\\n zp0 = sx*xp1 + cx*zp1\\n\\n obj_altitude = arcsin(zp0)\\n obj_altitude[pos]=altitude\\n obj_azimuth = arctan2(yp0,-xp0) + azimuth\\n obj_azimuth[pos] = azimuth\\n\\n #if obj_azimuth.value < 0.:\\n # obj_azimuth += 2.*pi\\n #elif obj_azimuth.value >= (2.*pi ):\\n # obj_azimuth -= 2.*pi\\n\\n return obj_altitude,obj_azimuth\",\n \"def get_altitude(points):\\n altitudes = np.zeros((len(points),), dtype=\\\"float64\\\")\\n for i, point in tqdm(enumerate(points), desc=\\\"GETTING ALTITUDE\\\"):\\n p = Point(point[0], point[1])\\n altitudes[i] = alt.NM_COTA.iloc[\\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\\n ]\\n return altitudes\",\n \"def getSlantRangeElevationHeight(self, groundRange, z):\\r\\n \\r\\n lat = self.ctrLat * pi / 180.0\\r\\n \\r\\n #figure out earth's radius at radar's lat ... non-spherical earth model\\r\\n e2 = self.eccen # First eccentricity squared - WGS-84 value = 0.00669437999013\\r\\n a = self.Requator # Equatorial radius - WGS-84 value = 6378137.0\\r\\n Rearth = a/sqrt(1-e2*(sin(lat))**2) # radius of curvature\\r\\n \\r\\n Rprime = self.effectiveRadiusMultiplier * self.Requator\\r\\n \\r\\n h = array(z - self.ctrAlt, dtype='float64')\\r\\n s = array(groundRange, dtype='float64')\\r\\n \\r\\n # Use law of cosines (Side-Angle-Side triangle theorem) with \\r\\n # R', R'+h as sides and s/R' as the angle to get slant range\\r\\n r = sqrt(Rprime**2.0 + (Rprime+h)**2.0 - 2*(Rprime+h)*Rprime*cos(s/Rprime))\\r\\n # Inverse of eq. 2.28c in Doviak and Zrnic 1993\\r\\n # Will return NaN for r=0\\r\\n el = arccos((Rprime+h) * sin(s/Rprime) / r) \\r\\n el *= 180.0 / pi\\r\\n \\r\\n return r, el\",\n \"def altaz_to_offset(obj_azimuth,obj_altitude,azimuth,altitude):\\n\\n daz = obj_azimuth - azimuth\\n coa = cos(obj_altitude)\\n\\n xp0 = -cos(daz) * coa\\n yp0 = sin(daz) * coa\\n zp0 = sin(obj_altitude)\\n\\n cx = sin(altitude)\\n sx = cos(altitude)\\n\\n xp1 = cx*xp0 + sx*zp0\\n yp1 = yp0\\n zp1 = -sx*xp0 + cx*zp0\\n\\n q = arccos(zp1)\\n d = tan(q)\\n alpha = arctan2(yp1,xp1)\\n\\n xoff = d * cos(alpha)\\n yoff = d * sin(alpha)\\n\\n return xoff,yoff\",\n \"def altitude_control(self, altitude_cmd,\\n vertical_velocity_cmd,\\n altitude,\\n vertical_velocity,\\n attitude,\\n acceleration_ff=0.0):\\n \\n hdot_cmd = self.Kp_alt * (altitude_cmd - altitude) + vertical_velocity_cmd\\n \\n # Limit the ascent/descent rate\\n hdot_cmd = np.clip(hdot_cmd, -self.max_descent_rate, self.max_ascent_rate)\\n\\n acceleration_cmd = acceleration_ff + self.Kp_hdot*(hdot_cmd - vertical_velocity)\\n \\n R33 = np.cos(attitude[0]) * np.cos(attitude[1])\\n thrust = DRONE_MASS_KG * acceleration_cmd / R33\\n \\n if thrust > MAX_THRUST:\\n thrust = MAX_THRUST\\n elif thrust < 0.0:\\n thrust = 0.0\\n return thrust\",\n \"def getAltitudeFromLatLon(self, lat, lon):\\r\\n # print \\\"-----\\\\nFromLatLon\\\", lon, lat\\r\\n lat -= self.lat\\r\\n lon -= self.lon\\r\\n # print \\\"lon, lat\\\", lon, lat\\r\\n if lat < 0.0 or lat >= 1.0 or lon < 0.0 or lon >= 1.0:\\r\\n raise WrongTileError(self.lat, self.lon, self.lat+lat, self.lon+lon)\\r\\n x = lon * (self.size - 1)\\r\\n y = lat * (self.size - 1)\\r\\n # print \\\"x,y\\\", x, y\\r\\n x_int = int(x)\\r\\n x_frac = x - int(x)\\r\\n y_int = int(y)\\r\\n y_frac = y - int(y)\\r\\n # print \\\"frac\\\", x_int, x_frac, y_int, y_frac\\r\\n value00 = self.getPixelValue(x_int, y_int)\\r\\n value10 = self.getPixelValue(x_int+1, y_int)\\r\\n value01 = self.getPixelValue(x_int, y_int+1)\\r\\n value11 = self.getPixelValue(x_int+1, y_int+1)\\r\\n value1 = self._avg(value00, value10, x_frac)\\r\\n value2 = self._avg(value01, value11, x_frac)\\r\\n value = self._avg(value1, value2, y_frac)\\r\\n # print \\\"%4d %4d | %4d\\\\n%4d %4d | %4d\\\\n-------------\\\\n%4d\\\" % (\\r\\n # value00, value10, value1, value01, value11, value2, value)\\r\\n return value\",\n \"def track_closest_aircraft(latitude, longitude, elevation, host, port, q):\\n try:\\n d = Dump1090(host, port)\\n q.put(True)\\n except IOError as exc:\\n q.put(exc)\\n return\\n\\n target = None\\n target_distance = None\\n aad = AzimuthAltitudeDistance(latitude, longitude, elevation)\\n\\n try:\\n for aircraft in d.updates():\\n lat, lng = aircraft.position\\n azimuth, altitude, distance = aad.calculate(\\n lat,\\n lng,\\n aircraft.altitude\\n )\\n\\n # if we don't have a target we do now\\n # or target is old, then use this new aircraft\\n # or new aircraft isn't the target, but it is closer, so we switch!\\n if (target is None or target.age > 60 or\\n (target.icao != aircraft.icao and distance < target_distance)):\\n target = aircraft\\n\\n # if we aren't the target at this point then bail\\n if target.icao != aircraft.icao:\\n continue\\n\\n target = aircraft\\n target_distance = distance\\n q.put((target, azimuth, altitude, distance))\\n except KeyboardInterrupt:\\n pass\",\n \"def diff_of_errors(self):\\n self.e_of_e = self.azimuth_error - self.altitude_error\\n return self.e_of_e\",\n \"def altitude(self, value: int):\\n self._point.altitude = value\",\n \"def optimal_tilt(lat):\\n lat = abs(lat)\\n if lat <= 25:\\n return lat * 0.87\\n elif lat <= 50:\\n return (lat * 0.76) + 3.1\\n else: # lat > 50\\n # raise NotImplementedError('Not implemented for latitudes beyond 50.')\\n return 40 # Simply use 40 degrees above lat 50\",\n \"def optimal_tilt(lat):\\n lat = abs(lat)\\n if lat <= 25:\\n return lat * 0.87\\n elif lat <= 50:\\n return (lat * 0.76) + 3.1\\n else: # lat > 50\\n # raise NotImplementedError('Not implemented for latitudes beyond 50.')\\n return 40 # Simply use 40 degrees above lat 50\",\n \"def temperature(self, alt):\\n T = self.altitude_profile(alt)[1]\\n return T\",\n \"def lidar_relative(self):\\n return self.distance\",\n \"def getSlantRangeElevation(self, groundRange, el):\\r\\n \\r\\n lat = self.ctrLat * pi / 180.0\\r\\n theta = el * pi / 180.0\\r\\n \\r\\n #figure out earth's radius at radar's lat ... non-spherical earth model\\r\\n e2 = self.eccen # First eccentricity squared - WGS-84 value = 0.00669437999013\\r\\n a = self.Requator # Equatorial radius - WGS-84 value = 6378137.0\\r\\n Rearth = a/sqrt(1-e2*(sin(lat))**2) # radius of curvature\\r\\n \\r\\n # Inverse of eq. 2.28b in Doviak and Zrnic 1993\\r\\n # Inverse of eq. 2.28c in Doviak and Zrnic 1993\\r\\n\\r\\n Rprime = self.effectiveRadiusMultiplier * self.Requator\\r\\n\\r\\n s = array(groundRange, dtype='float64')\\r\\n\\r\\n h = Rprime * ( math.cos(theta) / math.cos( theta + s / Rprime) - 1)\\r\\n\\r\\n r = (Rprime + h) * math.sin(s / Rprime) / math.cos(theta);\\r\\n\\r\\n # Use law of cosines (Side-Angle-Side triangle theorem) with \\r\\n # R', R'+h as sides and s/R' as the angle to get slant range\\r\\n #r = sqrt(Rprime**2.0 + (Rprime+h)**2.0 - 2*(Rprime+h)*Rprime*cos(s/Rprime))\\r\\n # Will return NaN for r=0\\r\\n #el = arccos((Rprime+h) * sin(s/Rprime) / r) \\r\\n #el *= 180.0 / pi\\r\\n \\r\\n return r,h\",\n \"def is_cruising(altitude, cruise_altitude=None):\\n if cruise_altitude is None:\\n cruise_altitude = closest_cruising_altitude(altitude)\\n return abs(altitude - cruise_altitude) <= 200\",\n \"def _get_lip_best(self) -> float:\\n pass\",\n \"def air_density(altitude):\\n p = pressure(altitude) # psf\\n t = temperature(altitude) # R\\n rho = p/(gas_constant*t) # lb/ft3\\n return rho\",\n \"def top_of_descent_index(self):\\n tod = self.altitudes.argmax()\\n # if the altitude profile is not just a climb\\n # and there is a cruising section\\n if (tod < len(self.altitudes) - 1) and \\\\\\n (self.altitudes[tod] == self.altitudes[tod + 1]):\\n tod += 1\\n\\n return tod\",\n \"def haversine_distance_ignore_altitude(loc1_lat, loc1_lon, loc2_lat, loc2_lon):\\n R = 6372797.560856 # radius of the earth in meters\\n\\n lat_arc = math.radians(loc1_lat - loc2_lat)\\n lon_arc = math.radians(loc1_lon - loc2_lon)\\n\\n lat_h = math.sin(lat_arc * 0.5)\\n lat_h = lat_h * lat_h\\n\\n lon_h = math.sin(lon_arc * 0.5)\\n lon_h = lon_h * lon_h\\n\\n tmp = math.cos(math.radians(loc1_lat)) * math.cos(math.radians(loc2_lat))\\n rad = 2.0 * math.asin(math.sqrt(lat_h + tmp * lon_h))\\n\\n return rad * R\",\n \"def top_of_climb_index(self):\\n return self.altitudes.argmax()\",\n \"def sim_altitude(a):\\n a.takeoff()\\n for i in range(20):\\n b = a.refresh()\\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() + 3)\\n print a.altitude.get_altitudes(), b\\n a.land()\\n a.motor.set_speed(2000.0)\\n for i in range(20):\\n b = a.refresh()\\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() - 3)\\n print a.altitude.get_altitudes(), b\",\n \"def calculate_longitude(prior_lat, source_long, distance, heading):\\n\\n return ((source_long - \\\\\\n math.asin(math.sin(heading)*math.sin(distance)/math.cos(prior_lat))\\n + math.pi) % (2*math.pi)) - math.pi\",\n \"def diversion(self) -> Optional[\\\"Flight\\\"]:\\n from ..data import airports\\n\\n # The following cast secures the typing\\n self = cast(\\\"Flight\\\", self)\\n\\n f_above: Optional[\\\"Flight\\\"] = self.query(\\\"altitude > 15000\\\")\\n if (\\n self.destination != self.destination\\n or airports[self.destination] is None # type: ignore\\n or f_above is None\\n ):\\n return None\\n\\n return (\\n f_above.distance(airports[self.destination]) # type: ignore\\n .diff(\\\"distance\\\")\\n .agg_time(\\\"10T\\\", distance_diff=\\\"mean\\\")\\n .query(\\\"distance_diff > 0\\\")\\n )\",\n \"def haDecFromAzAlt (azAlt, lat):\\n # convert spherical az/alt (deg) to direction cosines\\n azAltDC = dcFromSC (azAlt)\\n\\n # convert az/alt direction cosines to -ha/dec direction cosines\\n negHADecDC = Cnv.haDecFromAzAlt (azAltDC, lat)\\n\\n # convert -ha/dec direction cosines to spherical -ha/dec (deg)\\n ((negHA, dec), atPole) = scFromDC (negHADecDC)\\n\\n return ((RO.MathUtil.wrapCtr(-negHA), dec), atPole)\",\n \"def _plunge_distance(self, volume):\\n percent = self._volume_percentage(volume)\\n top = self._get_plunger_position('top')\\n bottom = self._get_plunger_position('bottom')\\n travel = bottom - top\\n if travel <= 0:\\n self.robot.add_warning('Plunger calibrated incorrectly')\\n return travel * percent\",\n \"def get_elementary_airspace_altitude_range(db_id):\\n connection = get_geo_db_connection()\\n sector = find_sector(db_id, connection)\\n if (sector):\\n return (sector['min_altitude'], sector['max_altitude'])\\n else:\\n raise NotFoundException(db_id, \\\"Elementary sector not found.\\\")\",\n \"def get_evaporation_latent_heat() -> float:\\n theta = 28.0\\n return 2500.8 - 2.3668 * theta\",\n \"def elevation(source):\\n srcAzEl = subarrayControl.s.azel(source, 0.0);\\n return srcAzEl[1];\",\n \"def _FindNearestAnat(self, acqtime):\\n tdiff_min = 1e6\\n for anat in self.entry_map['anat']:\\n if self.info[anat]['type'] == 'T1High' and \\\\\\n self.info[anat]['InversionTime'] > 0.:\\n tdiff = abs(acqtime - self.info[anat]['acqtime'])\\n if tdiff < tdiff_min:\\n tdiff_min = tdiff\\n anat_min = anat\\n return anat_min\",\n \"def read_altitude(self, meanSeaLevelPressureInBar):\\n phPa = self.read_pressure() / 100.0\\n\\n return float(44330.0 * (1.0 - math.pow((phPa / meanSeaLevelPressureInBar), 0.1903)))\",\n \"def read_altitude(self, meanSeaLevelPressureInBar):\\n phPa = self.read_pressure() / 100.0\\n\\n return float(44330.0 * (1.0 - math.pow((phPa / meanSeaLevelPressureInBar), 0.1903)))\",\n \"def AEH2Range(azim, elev, h, lat, lon, alt):\\n\\n\\n def _heightCostFunction(params, azim, elev, h, lat, lon, alt):\\n\\n # Get the guessed range\\n r = params\\n\\n # Compute the ECEF coordinates with the given range\\n x, y, z = AER2ECEF(azim, elev, r, lat, lon, alt)\\n\\n # Compute the height\\n _, _, h_computed = ecef2LatLonAlt(x, y, z)\\n\\n # Return residual between the heights\\n return (h_computed - h)**2\\n\\n\\n # Use a flat-Earth range as a first guess of range if the elevation is higher than 10 degrees\\n if elev > np.radians(10):\\n r0 = (h - alt)/np.sin(np.radians(elev))\\n else:\\n # Otherwise, use a distance of 1000 km\\n r0 = 1e6\\n\\n # Numerically find the range which corresponds to the given height above the ground\\n res = scipy.optimize.minimize(_heightCostFunction, r0, \\\\\\n args=(azim, elev, h, lat, lon, alt))\\n\\n # Return the minimized solution\\n return res.x[0]\",\n \"def classify_altitude_profile(altitudes):\\n max_alt = altitudes.max()\\n has_climb = (max_alt > altitudes[0])\\n has_descent = (max_alt > altitudes[-1])\\n\\n if has_climb or has_descent:\\n if has_climb != has_descent:\\n return AltitudeProfileType.CLIMBING if has_climb \\\\\\n else AltitudeProfileType.DESCENDING\\n else:\\n return AltitudeProfileType.CLIMBING_AND_DESCENDING\\n else:\\n return AltitudeProfileType.CRUISING\",\n \"def get_resistance(self):\\n adc = ADC(self.pin)\\n value = adc.read()\\n if value == 0:\\n return -1\\n\\n return (4095./value - 1.) * self.RLOAD\",\n \"def GetAbsBeer(epsilon, conc, pathLength):\\n return epsilon * conc * pathLength\",\n \"def pair_from_elev(elevation):\\n # version converted from vb.net\\n\\n # return 101.3 * ((293. - 0.0065 * elevm) / 293.) ** (9.8 / (0.0065 * 286.9)) # kPa ' standardized by ASCE 2005\\n\\n # version from from DRI\\n\\n # return 101.3 * np.power((293.0 - 0.0065 * elevation) / 293.0, 5.26)\\n\\n # version extended to better match vb.net version\\n # 5.255114352 = 9.8 / (0.0065 * 286.9\\n\\n return 101.3 * np.power((293.0 - 0.0065 * elevation) / 293.0, 5.255114352)\",\n \"def process_driver_altitude(coordinate: Coordinate) -> ProcessDescription:\\n city = get_city_by_coordinates(\\n latitude=coordinate.latitude,\\n longitude=coordinate.longitude,\\n )\\n city_coordinates = CITIES_COORDINATES_MAP.get(city)\\n if not city_coordinates:\\n return ProcessDescription(\\n detect=False,\\n description='Invalid city coordinates.'\\n )\\n\\n altitude_min = city_coordinates['altitude_min']\\n altitude_max = city_coordinates['altitude_max']\\n\\n if altitude_min <= coordinate.altitude <= altitude_max:\\n return ProcessDescription(\\n detect=False,\\n description=(\\n f'Driver altitude {coordinate.altitude} '\\n f'is normal for city {city.capitalize()}.'\\n )\\n )\\n\\n return ProcessDescription(\\n detect=True,\\n description=(\\n f'Driver has incorrect altitude {coordinate.altitude} '\\n f'for city {city.capitalize()}.'\\n )\\n )\",\n \"def get_surface_elevation(wind_lat, wind_lon):\\n # Load the NetCDF file containing the geopotential of Europe.\\n nc = Dataset(path_join(era5_data_dir, geopotential_file_name))\\n \\n # Read the variables from the netCDF file.\\n geopot_lat = nc.variables['latitude'][:]\\n geopot_lon = nc.variables['longitude'][:]\\n \\n \\n # Check if wind and geopotential data use same grid.\\n assert np.array_equal(geopot_lat, wind_lat) and np.array_equal(geopot_lon, wind_lon), \\\\\\n \\\"Requested latitudes and/or longitudes do not correspond to those in the NetCDF file.\\\"\\n\\n geopot_z = nc.variables['z'][0, :, :]\\n nc.close()\\n\\n surface_elevation = geopot_z/9.81\\n print(\\\"Minimum and maximum elevation found are respectively {:.1f}m and {:.1f}m, removing those below zero.\\\"\\n .format(np.amin(surface_elevation), np.amax(surface_elevation)))\\n\\n # Get rid of negative elevation values.\\n for i, row in enumerate(surface_elevation):\\n for j, val in enumerate(row):\\n if val < 0.:\\n surface_elevation[i, j] = 0.\\n\\n return surface_elevation\",\n \"def getGroundRangeHeight(self, r, elevationAngle):\\r\\n \\r\\n #Double precison arithmetic is crucial to proper operation.\\r\\n lat = self.ctrLat * pi / 180.0\\r\\n elev = array(elevationAngle * pi / 180.0, dtype='float64')\\r\\n slantr = array(r, dtype='float64')\\r\\n \\r\\n #figure out earth's radius at radar's lat ... non-spherical earth model\\r\\n e2 = self.eccen # First eccentricity squared - WGS-84 value = 0.00669437999013\\r\\n a = self.Requator # Equatorial radius - WGS-84 value = 6378137.0\\r\\n Rearth = a/sqrt(1-e2*(sin(lat))**2) # radius of curvature\\r\\n \\r\\n Rprime = self.effectiveRadiusMultiplier * self.Requator\\r\\n \\r\\n # Eqns 2.28b,c in Doviak and Zrnic 1993\\r\\n # Radar altitude is tacked on at the end, which isn't part of their derivation. At 100 km, it's \\r\\n # worth < 10 m range error total for a radar at 500 m MSL. For 250 m gate spacing (typical at S-band), \\r\\n # this is not too important.\\r\\n h = sqrt(slantr**2.0 + Rprime**2.0 + 2*slantr*Rprime*sin(elev)) - Rprime\\r\\n s = Rprime * arcsin( (slantr*cos(elev)) / (Rprime + h) )\\r\\n \\r\\n h += self.ctrAlt\\r\\n \\r\\n return s, h\",\n \"def guess_anchor(self):\\n return self.nearest(\\\"VP\\\")\",\n \"def get_temperature(elevation, sea_level):\\n if elevation <= sea_level:\\n return 0.8\\n else:\\n return (-1.0 / (1.0 - sea_level)) * (elevation - sea_level) + 1.0\",\n \"def get_alt(self, dec, i_alt):\\n return self.decisions[dec].value[i_alt]\",\n \"def intersection_distances(self, altitude, start_distance, finish_distance):\\n distances = []\\n alt_index, alt_ratio = calculate_value_reference(self.distances,\\n start_distance)\\n start_alt = calculate_value(self.altitudes, alt_index, alt_ratio)\\n\\n finish_index, finish_ratio = calculate_value_reference(self.distances,\\n finish_distance)\\n while alt_index < finish_index:\\n next_index = alt_index + 1\\n next_ratio = 0.0\\n next_alt = calculate_value(self.altitudes, next_index, next_ratio)\\n\\n # Does this section span the given altitude?\\n if (next_alt != start_alt) and \\\\\\n (min(start_alt, next_alt) < altitude < max(start_alt, next_alt)):\\n delta = altitude - start_alt\\n denom = next_alt - start_alt\\n ratio = delta / denom\\n distance = calculate_value(self.distances, alt_index, ratio)\\n distances.append(distance)\\n\\n alt_index = next_index\\n alt_ratio = next_ratio\\n start_alt = next_alt\\n\\n if finish_ratio:\\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\\n # Does the last section span the given altitude?\\n if (start_alt != finish_alt) and \\\\\\n (min(start_alt, finish_alt) < altitude < max(start_alt, finish_alt)):\\n # Calculate the altitude at the end of the section to maximimse accuracy\\n next_alt = calculate_value(self.altitudes, finish_index, 1.0)\\n delta = altitude - start_alt\\n denom = next_alt - start_alt\\n ratio = delta / denom\\n distance = calculate_value(self.distances, alt_index, ratio)\\n distances.append(distance)\\n\\n return distances\",\n \"def get_alt_loc(self, alt_loc):\\n try:\\n return self[alt_loc]\\n except KeyError:\\n return None\",\n \"def alt_index(self) -> Optional[int]:\\n if not self.is_hom_alt():\\n return None\\n return max(self.allele1, self.allele2) - 1\",\n \"def get_resistance(self):\\n adc = ADC(self.pin)\\n value = adc.read()\\n if value == 0:\\n return -1\\n\\n return (4095./value - 1.) * self.RLOAD # ESP32 maksimi, ESP8266:lle arvo on 1023\",\n \"def fit_elevation(self, elevation):\\n if self.p_opt is None:\\n result = elevation * np.nan\\n else:\\n result = self.value_at(elevation, *self.p_opt)\\n if isinstance(result, units.Quantity):\\n result = result.value\\n return result\",\n \"def pressure(altitude):\\n t = temperature(altitude) # R\\n if altitude <= 36152:\\n p = 2116*(t/518.6)**5.256 # psf\\n else:\\n p = 473.1*exp(1.73-0.000048*altitude) # psf\\n return p\",\n \"def altitude_range(self, start_distance, finish_distance):\\n start_index, start_ratio = calculate_value_reference(self.distances,\\n start_distance)\\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\\n finish_index, finish_ratio = calculate_value_reference(self.distances,\\n finish_distance)\\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\\n\\n min_alt = min(start_alt, finish_alt)\\n max_alt = max(start_alt, finish_alt)\\n\\n if start_index < finish_index:\\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\\n min_alt = min(min_alt, altitudes.min())\\n max_alt = max(max_alt, altitudes.max())\\n\\n return min_alt, max_alt\",\n \"def get_best_move_toward(self, target_ground):\\n options_by_parent, cost_to_reach = self.a_star_search(start=self.ground, goal=target_ground)\\n ground = target_ground\\n\\n # Can't reach it?\\n if ground not in options_by_parent:\\n return None\\n\\n while options_by_parent[ground] is not self.ground:\\n ground = options_by_parent[ground]\\n\\n return ground.x - self.ground.x, ground.y - self.ground.y\",\n \"def altitude(p):\\r\\n \\r\\n R = 290 #specific gas constant \\r\\n T = 93.65 #surface temperature K from A.Coustenis book\\r\\n g = 1.354 #surface gravity from A.Coustenis book\\r\\n p0 = 1467 #surface pressure in hPa 6.1 for mars\\r\\n \\r\\n z = np.empty_like(p)\\r\\n \\r\\n for i in range(p.shape[0]):\\r\\n z[i] = (-1)*(R*T/g)*np.log((p[i])/p0)/(10**3)\\r\\n \\r\\n # Make into an xarray DataArray\\r\\n z_xr = xr.DataArray(z, coords=[z], dims=['pfull'])\\r\\n z_xr.attrs['units'] = 'km'\\r\\n \\r\\n #below is the inverse of the calculation\\r\\n #p[i] = p0*np.exp((-1)*z[i]*(10**3)/((R*T/g)))\\r\\n \\r\\n return z_xr\",\n \"def diffuse_underclear(latitude_deg, longitude_deg, utc_datetime, elevation = elevation_default, \\n temperature_celsius = 25, pressure_millibars = 1013.25, TL=TL_default): \\n DT = ((-21.657) + (41.752 * (TL)) + (0.51905 * (TL) * (TL)))\\n altitude = solar.GetAltitude(latitude_deg, longitude_deg,utc_datetime, elevation, temperature_celsius,pressure_millibars)\\n\\n return mean_earth_sun_distance(utc_datetime) * DT * altitude\",\n \"def altaz_to_radec(alt_az, pos=local_latlong,\\n minute=minute, hour=hour, day=day,\\n month=month, year=year, tz_offset=5):\\n # Retrieve the coordinates and convert them to rads for some trig.\\n lat, long = pos[0] * (np.pi/180), pos[1] * (np.pi/180)\\n alt, az = alt_az[0] * (np.pi/180), alt_az[1] * (np.pi/180)\\n\\n gmst = localtime_to_gmst(minute=minute, hour=hour,\\n day=day, month=month, year=year, tz_offset=5)\\n\\n sin_dec = np.sin(alt) * np.sin(lat) + np.cos(alt) * np.cos(lat) * np.cos(az)\\n dec = np.arcsin(sin_dec)\\n\\n cosHA = (np.sin(alt) - np.sin(lat) * np.sin(dec))/(np.cos(lat) * np.cos(dec))\\n HA = np.arccos(cosHA) * (180/np.pi)\\n\\n dec *= (180/np.pi)\\n ra = gmst + HA + (long * 180/np.pi) if az < np.pi else gmst - HA + (long * 180/np.pi)\\n\\n ra_dec = (round(ra, 4), round(dec, 4))\\n return ra_dec\",\n \"def getAltitudeProfile(pass_length,terrain,uav_altitude,u,start_v,wind_angle):\\n altitude_profile = []\\n v = start_v\\n for k in range(0,round(pass_length)):\\n coord = convertCoords([[u,v]],wind_angle,'xy')\\n x = coord[0][0]\\n y = coord[0][1]\\n x_points = [int(x),int(x),int(x)+1,int(x)+1]\\n y_points = [int(y),int(y)+1,int(y)+1,int(y)]\\n z_points = [terrain[int(y)][int(x)],terrain[int(y)+1][int(x)],\\n terrain[int(y)+1][int(x)+1],terrain[int(y)][int(x)+1]]\\n\\n # For created terrain ONLY\\n z = griddata((x_points,y_points),z_points,(x,y)) # Interpolate \\n altitude = z + uav_altitude\\n\\n altitude_profile.append(altitude)\\n v +=1\\n return altitude_profile\",\n \"def get_min_distance(self):\\n return round(min(self.combined_euclidian_distance))\",\n \"def road_multiplier(highway, bicycle_pref, motorway_pref, highway_pref, residential_pref):\\n if highway == 'motorway':\\n result = -motorway_pref*0.5\\n elif highway == 'primary':\\n result = -highway_pref*0.5\\n elif highway == 'residential' or highway == 'service':\\n result = -residential_pref*0.5\\n elif highway == 'cycleway':\\n result = -bicycle_pref * 0.8\\n else:\\n result = 0\\n return result\",\n \"def arm_and_takeoff_nogps(aTargetAltitude):\\n\\n print(\\\"Taking of to an altitude of \\\", str(aTargetAltitude))\\n\\n print(\\\"Basic pre-arm checks\\\")\\n\\n while not vehicle.is_armable:\\n print(\\\" Waiting for vehicle to initialise...\\\")\\n time.sleep(1)\\n\\n print(\\\"Arming motors\\\")\\n # Copter should arm in GUIDED_NOGPS mode\\n vehicle.mode = VehicleMode(\\\"GUIDED_NOGPS\\\")\\n vehicle.armed = True\\n\\n while not vehicle.armed:\\n print(\\\" Waiting for arming...\\\")\\n vehicle.armed = True\\n time.sleep(1)\\n\\n print(\\\"Taking off!\\\")\\n\\n thrust = DEFAULT_TAKEOFF_THRUST\\n while True:\\n current_altitude = vehicle.location.global_relative_frame.alt\\n print(\\\" Altitude: %f Desired: %f\\\" %\\n (current_altitude, aTargetAltitude))\\n if current_altitude >= aTargetAltitude*0.95: # Trigger just below target alt.\\n print(\\\"Reached target altitude\\\")\\n break\\n elif current_altitude >= aTargetAltitude*0.6:\\n thrust = SMOOTH_TAKEOFF_THRUST\\n set_attitude(thrust = thrust)\\n time.sleep(0.2)\",\n \"def get_salinity(self) -> float:\\n try:\\n datalist = self.get_data()\\n data = datalist[2]\\n if data.endswith('\\\\x00'):\\n data = data.rstrip('\\\\x00')\\n return float(data)\\n else:\\n return float(data)\\n except Exception as err:\\n print(f'get_salinity error: {err}')\\n return -1\",\n \"def get_closest_station_by_zipcode(zipcode):\\n\\n station_lookup_method_by_zipcode = lookup_usaf_station_by_zipcode(zipcode)\\n try:\\n station, warnings, lat, lon = _get_closest_station_by_zcta_ranked(zipcode)\\n\\n isd_metadata = get_isd_file_metadata(str(station))\\n if len(isd_metadata) == 0:\\n logging.warning(\\\"Zipcode %s mapped to station %s, but no ISD metadata was found.\\\" % (zipcode, station))\\n return station_lookup_method_by_zipcode\\n\\n except UnrecognizedUSAFIDError as e:\\n logging.warning(\\\"Closest station %s is not a recognized station. Using backup-method station %s for zipcode %s instead.\\\" % (\\n str(station),\\n station_lookup_method_by_zipcode,\\n zipcode))\\n return station_lookup_method_by_zipcode\\n\\n except UnrecognizedZCTAError as e:\\n logging.warning(\\\"Unrecognized ZCTA %s\\\" % e)\\n return None\\n\\n if str(station) != station_lookup_method_by_zipcode:\\n logging.debug(\\\"Previously would have selected station %s instead of %s for zip code %s\\\" % (\\n station_lookup_method_by_zipcode,\\n str(station),\\n zipcode))\\n\\n if warnings:\\n logging.warning(\\\"Station %s is %d meters over maximum %d meters (%d meters) (zip code %s is at lat/lon %f, %f)\\\" % (\\n str(station),\\n int(warnings[0].data['distance_meters'] - warnings[0].data['max_distance_meters']),\\n int(warnings[0].data['max_distance_meters']),\\n int(warnings[0].data['distance_meters']),\\n zipcode,\\n lat,\\n lon,\\n ))\\n logging.warning(\\\"Closest station %s is too far. Using backup-method station %s instead.\\\" % (\\n str(station),\\n station_lookup_method_by_zipcode))\\n return station_lookup_method_by_zipcode\\n\\n return str(station)\",\n \"def get_overland(p1, p2, tolerance = 0.1, min_slope = 0.00001):\\n\\n L = get_distance(p1, p2)\\n\\n if L > tolerance: return L / 2., (p1[2] - p2[2]) / L / 100000\\n else: return tolerance, min_slope\",\n \"def impact_prediction(\\n radius: float,\\n target_altitude: float,\\n vertical_speed: float,\\n horizontal_speed: float,\\n surface_gravity: float,\\n ut: float,\\n):\\n fall_speed = -vertical_speed\\n downward_acceleration = (\\n surface_gravity - horizontal_speed * horizontal_speed / radius\\n )\\n\\n # do we already landed?\\n if target_altitude < 0:\\n return None, None\\n\\n # do we land?\\n if downward_acceleration < 0:\\n max_fall_distance = -(fall_speed * fall_speed) / (\\n 2.0 * downward_acceleration\\n )\\n if max_fall_distance < (target_altitude + 1.0):\\n return None, None\\n\\n sec_until_impact = (\\n -fall_speed\\n + math.sqrt(\\n fall_speed * fall_speed\\n + 2.0 * downward_acceleration * target_altitude\\n )\\n ) / downward_acceleration\\n\\n vertical_speed_at_impact = (\\n fall_speed + sec_until_impact * downward_acceleration\\n )\\n impact_speed = math.sqrt(\\n vertical_speed_at_impact * vertical_speed_at_impact\\n + horizontal_speed * horizontal_speed\\n )\\n impact_ut = sec_until_impact + ut\\n return impact_ut, impact_speed\",\n \"def altAz2RADec(azim, elev, jd, lat, lon):\\n\\n azim = np.radians(azim)\\n elev = np.radians(elev)\\n lat = np.radians(lat)\\n lon = np.radians(lon)\\n \\n # Calculate hour angle\\n ha = np.arctan2(-np.sin(azim), np.tan(elev)*np.cos(lat) - np.cos(azim)*np.sin(lat))\\n\\n # Calculate Local Sidereal Time\\n lst = np.radians(JD2LST(jd, np.degrees(lon))[0])\\n \\n # Calculate right ascension\\n ra = (lst - ha)%(2*np.pi)\\n\\n # Calculate declination\\n dec = np.arcsin(np.sin(lat)*np.sin(elev) + np.cos(lat)*np.cos(elev)*np.cos(azim))\\n\\n return np.degrees(ra), np.degrees(dec)\",\n \"def _get_elevation_percentage(height: float, distance: float) -> float:\\n return height / (distance * 1000)\",\n \"def get_user_sector_altitude_range(db_id):\\n found, sector = user_sector_finder(\\\"id\\\", int(db_id))\\n if found:\\n return (sector[0]['min_altitude'], sector[0]['max_altitude'])\\n else:\\n raise NotFoundException(db_id, \\\"User sector not found.\\\")\",\n \"async def get_altaz(self, **kwargs: Any) -> Tuple[float, float]:\\n if self.observer is not None:\\n alt_az = self.observer.altaz(Time.now(), self._telescope.position)\\n return float(alt_az.alt.degree), float(alt_az.az.degree)\\n else:\\n raise ValueError(\\\"No observer given.\\\")\",\n \"def lidar_absolute(self):\\n return np.roll(self.distance, self.heading_idx)\",\n \"def get_tolerance(self):\\n return self.tolerance\",\n \"def get_abs_tolerance(self):\\n\\n if Test.global_abs_tolerance is None:\\n return self._abs_tolerance\\n return Test.global_abs_tolerance\",\n \"def speed_of_sound(altitude):\\n t = temperature(altitude) # R\\n a = sqrt(gamma*gas_constant*t) # [ft/s]\\n return a\",\n \"def slewEstimate(source1,source2=None,ant=1,returnUnit='time') :\\n azel1 = azel(source1)\\n azel1[0] = _wrapFix(azel1[0], ant)\\n if source2 == None: \\n azel2 = currentAzel(ant)\\n else:\\n azel2 = azel(source2)\\n azel2[0] = _wrapFix(azel2[0], ant)\\n az1 = [azel1[0], _wrapChoice(azel1[0], ant)]\\n az2 = [azel2[0], _wrapChoice(azel2[0], ant)]\\n print az1, az2\\n deltaAz = 360\\n deltaAz = min(deltaAz, abs(az1[0]-az2[0]))\\n deltaAz = min(deltaAz, abs(az1[0]-az2[1]))\\n deltaAz = min(deltaAz, abs(az1[1]-az2[0]))\\n deltaAz = min(deltaAz, abs(az1[1]-az2[1]))\\n delta = [deltaAz, abs(azel1[1]-azel2[1])]\\n print delta\\n if ant < 7:\\n azRate = 60.0\\n elRate = 30.0\\n settleTime = 5.0\\n elif ant < 16: \\n azRate = 120.0\\n elRate = 60.0\\n settleTime = 10.0\\n else: \\n azRate = 60.0\\n elRate = 30.0\\n settleTime = 8.0\\n if returnUnit == 'time': \\n return max(delta[0]/azRate,delta[1]/elRate) + settleTime/60.0\\n return delta\",\n \"def le_calibration_func(etr, kc, ts):\\n return etr * kc * (2.501 - 2.361E-3 * (ts - 273)) * 2500 / 9\",\n \"def _generate_equilateral_triangle_around_point(\\n center_point: Coordinate, altitude: Decimal = TRIANGLE_ALTITUDE\\n) -> Tuple[Coordinate, Coordinate, Coordinate]:\\n # This is how you math I guess?\\n side_length = 2 * altitude / Decimal(sqrt(3))\\n\\n ay = center_point.y + altitude / 2\\n ax = center_point.x\\n a = Coordinate(ay, ax)\\n\\n by = center_point.y - altitude / 2\\n bx = center_point.x + side_length / 2\\n b = Coordinate(by, bx)\\n\\n cy = center_point.y - altitude / 2\\n cx = center_point.x - side_length / 2\\n c = Coordinate(cy, cx)\\n\\n return (a, b, c)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68563944","0.6599064","0.6381891","0.6333543","0.6299421","0.6299421","0.62524825","0.61202556","0.609955","0.60223883","0.5997195","0.595264","0.5929024","0.59270704","0.58204633","0.5791743","0.5770483","0.5733085","0.5660749","0.5638563","0.5614531","0.5604844","0.5557647","0.5538122","0.55280626","0.5464547","0.5438516","0.5424265","0.5421513","0.53894055","0.5362957","0.5354338","0.530233","0.5275784","0.52704674","0.5265621","0.5253078","0.5242834","0.5242834","0.51796675","0.5170521","0.5155098","0.51538724","0.51465595","0.5132277","0.5125648","0.5098557","0.50616145","0.50566226","0.50509167","0.50412464","0.5040867","0.5040792","0.50403416","0.5036522","0.50335467","0.5016724","0.50092787","0.50092787","0.50003856","0.49898085","0.4983441","0.49716377","0.49588937","0.49580652","0.4955452","0.4954799","0.4948079","0.49427286","0.49400023","0.49366626","0.49331158","0.49308392","0.49280927","0.49167022","0.49063396","0.49030948","0.48943743","0.48917127","0.48914224","0.48531598","0.48526278","0.48476157","0.4839217","0.48351645","0.4831798","0.48127052","0.48094893","0.48093963","0.4802492","0.47997567","0.47968885","0.4786043","0.47769767","0.4752075","0.47505078","0.4742017","0.47405773","0.47279406","0.47192168"],"string":"[\n \"0.68563944\",\n \"0.6599064\",\n \"0.6381891\",\n \"0.6333543\",\n \"0.6299421\",\n \"0.6299421\",\n \"0.62524825\",\n \"0.61202556\",\n \"0.609955\",\n \"0.60223883\",\n \"0.5997195\",\n \"0.595264\",\n \"0.5929024\",\n \"0.59270704\",\n \"0.58204633\",\n \"0.5791743\",\n \"0.5770483\",\n \"0.5733085\",\n \"0.5660749\",\n \"0.5638563\",\n \"0.5614531\",\n \"0.5604844\",\n \"0.5557647\",\n \"0.5538122\",\n \"0.55280626\",\n \"0.5464547\",\n \"0.5438516\",\n \"0.5424265\",\n \"0.5421513\",\n \"0.53894055\",\n \"0.5362957\",\n \"0.5354338\",\n \"0.530233\",\n \"0.5275784\",\n \"0.52704674\",\n \"0.5265621\",\n \"0.5253078\",\n \"0.5242834\",\n \"0.5242834\",\n \"0.51796675\",\n \"0.5170521\",\n \"0.5155098\",\n \"0.51538724\",\n \"0.51465595\",\n \"0.5132277\",\n \"0.5125648\",\n \"0.5098557\",\n \"0.50616145\",\n \"0.50566226\",\n \"0.50509167\",\n \"0.50412464\",\n \"0.5040867\",\n \"0.5040792\",\n \"0.50403416\",\n \"0.5036522\",\n \"0.50335467\",\n \"0.5016724\",\n \"0.50092787\",\n \"0.50092787\",\n \"0.50003856\",\n \"0.49898085\",\n \"0.4983441\",\n \"0.49716377\",\n \"0.49588937\",\n \"0.49580652\",\n \"0.4955452\",\n \"0.4954799\",\n \"0.4948079\",\n \"0.49427286\",\n \"0.49400023\",\n \"0.49366626\",\n \"0.49331158\",\n \"0.49308392\",\n \"0.49280927\",\n \"0.49167022\",\n \"0.49063396\",\n \"0.49030948\",\n \"0.48943743\",\n \"0.48917127\",\n \"0.48914224\",\n \"0.48531598\",\n \"0.48526278\",\n \"0.48476157\",\n \"0.4839217\",\n \"0.48351645\",\n \"0.4831798\",\n \"0.48127052\",\n \"0.48094893\",\n \"0.48093963\",\n \"0.4802492\",\n \"0.47997567\",\n \"0.47968885\",\n \"0.4786043\",\n \"0.47769767\",\n \"0.4752075\",\n \"0.47505078\",\n \"0.4742017\",\n \"0.47405773\",\n \"0.47279406\",\n \"0.47192168\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8231129"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":91975,"cells":{"query":{"kind":"string","value":"Determine whether an altitude may be a cruising altitude."},"document":{"kind":"string","value":"def is_cruising(altitude, cruise_altitude=None):\n if cruise_altitude is None:\n cruise_altitude = closest_cruising_altitude(altitude)\n return abs(altitude - cruise_altitude) <= 200"},"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 is_elevation(self):\n return not self._is_depth","def altitude(self):\n if self.__altitude:\n return sum(self.__altitude) / len(self.__altitude)\n else:\n return -9999","def is_slope(self):\n\t\tif self.high_elevation != self.low_elevation:\n\t\t\treturn True\n\t\treturn False","def sanity_check(self):\n res = True\n res = res and self.detected\n res = res and np.sum(self.diffs) < 30000 # experimental value\n return res","def is_aux_heat_on(self):\n return self._device.mode == self._device.MODE_HEAT_EMERGENCY","def has_undercoordinated_metal(self):\n return self._has_low_metal_coordination()","def classify_altitude_profile(altitudes):\n max_alt = altitudes.max()\n has_climb = (max_alt > altitudes[0])\n has_descent = (max_alt > altitudes[-1])\n\n if has_climb or has_descent:\n if has_climb != has_descent:\n return AltitudeProfileType.CLIMBING if has_climb \\\n else AltitudeProfileType.DESCENDING\n else:\n return AltitudeProfileType.CLIMBING_AND_DESCENDING\n else:\n return AltitudeProfileType.CRUISING","def is_equidistant(self) -> bool:\n if len(self.time) < 3:\n return True\n return len(self.time.to_series().diff().dropna().unique()) == 1","def isstationary(self):\n if np.all(np.abs(self.arroots) > 1.0):\n return True\n else:\n return False","def is_inequality(self):\n return True","def is_inequality(self):\n return True","def altitude(self):\r\n pressure = self.pressure # in Si units for hPascal\r\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))","def test_triangle_get_shortest_altitude(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)","def check_rpt_status(self) -> bool:\n return self.allele == self.fasta_alt","def is_cis(self):\n prev_res = self.get_offset_residue(-1)\n if prev_res is None:\n return None\n\n prev_omega = prev_res.calc_torsion_omega()\n if prev_omega is None:\n return None\n\n if abs(prev_omega) <= (math.pi/2.0):\n return True\n\n return False","def base_failure(self, uncertainty):\n return False\n rpos = self.sim.getAgentPosition(self.robot_num)\n gpos = self.overall_robot_goal\n if ((rpos[0]-gpos[0])**2 + (rpos[1]-gpos[1])**2)**0.5 <= \\\n self.sim.getAgentRadius(self.robot_num):\n return True\n elif (rpos[0] > gpos[0]):\n return True\n else:\n return False\n self.uncertainties[self.uncertainty_ind] = uncertainty\n self.uncertainty_ind = (self.uncertainty_ind + 1 )%len(\n self.uncertainties)\n # 0.004 is a hard-coded threshold for now that was determined by\n # analyzing multiple barge-in runs.\n return utils.avg(self.uncertainties) > 0.004","def is_artificial(self):\n\t\treturn 0","def is_inequality(self):\n return False","def is_upper(self):\n return self.z < 0","def is_aux_heat(self) -> bool | None:\n return self._aux","def looks_azimuth(self) -> Optional[int]:\n return self._get_property(LOOKS_AZIMUTH_PROP, int)","def altitude_callback(self, data):\n self.altitude = data\n self.altitude_bottom_clearance = np.float64(data.bottom_clearance)\n if np.isnan(self.altitude_bottom_clearance):\n # message is often enough that it should alert the user but shouldn't swamp the console\n rospy.logwarn_throttle(0.5, 'bottom clearance is invalid type: {}'.format(self.altitude_bottom_clearance))","def sun_is_down(check_time, observatory):\n sun = get_sun(check_time).transform_to(AltAz(obstime=check_time, location=observatory))\n return sun.alt.value < -14","def check_altitude_at(self, altim, coords, altitude_bounds):\n altitude = altim.mesh.point_altitude(coords)\n self.assertWithin(altitude, *altitude_bounds)","def determine_azel_are_safe(_az, _el):\n if _az and _el:\n return True","def check_convergency(self):\n if self.vars['ema_trace'][self.vars['step']] <= self.settings[\"emaSpeedTol\"]:\n return True\n else:\n return False","def deceived(self, a):\n try:\n n = self.control[a.name][0]\n if hardrule:\n return self.nsucc(a) > self.succ(a) + epsilonD and \\\n (n > 5) and ((self.world.round - n) > 5) \n else:\n return (n > 5) and ( (a.successRate > self.succ(a) + epsilonD) or \\\n (a.successRate < epsilonD))\n except KeyError:\n raise AssertionError, str(a) + \" is not a non-MI!\"","def closest_cruising_altitude(altitude):\n return 1000 * ((altitude + 500) // 1000)","def is_leech(self, meta: \"CardMeta\") -> bool:\n if len(meta.past_quality) < LEECH_MIN_QUALITY:\n return False\n return (\n meta.past_quality[-1] < BAD_QUALITY_THRESHOLD\n and meta.past_quality[-2] < BAD_QUALITY_THRESHOLD\n and meta.past_quality[-3] < BAD_QUALITY_THRESHOLD\n )","def is_tachycardic(self, hr):\n lower_bound = self.tachycardic_range()\n return hr > lower_bound","def is_stationary(self) -> bool:\n ad_fuller_result = adfuller(self.y.dropna(), autolag='AIC')\n p_value = ad_fuller_result[1]\n return p_value <= 0.5","def is_inequality(self): \n return False","def altitude(self) -> int:\n return self._point.altitude","def isGeostationary(sat):\n minAlt = minAz = float('inf')\n maxAlt = maxAz = -float('inf')\n\n epochDt = sat.epoch.utc_datetime()\n startDt = epochDt - timedelta(hours=24)\n endDt = epochDt + timedelta(hours=24)\n\n dt = startDt\n while dt <= endDt:\n t = ts.from_datetime(dt)\n alt, az, _ = (sat - sofia).at(t).altaz()\n alt = alt.degrees\n az = az.degrees\n if alt < minAlt:\n minAlt = alt\n if alt > maxAlt:\n maxAlt = alt\n if az < minAz:\n minAz = az\n if az > maxAz:\n maxAz = az\n dt += timedelta(hours=1)\n return maxAlt - minAlt < 1 and maxAz - minAz < 1","def check_masked(self):\n if self._alternate == 'N': # If our alternate allele is masked, or an 'N'\n return True # Return True\n else: # Otherwise\n return False # Return False","def isgood(self):\n\t\tanswer = True\n\t\t\n\t\tif self.mes_flux <= 0.0:\n\t\t\tanswer = False\n\n\t\treturn answer","def isCalibrationExpired(self):\n return (getI1ProTimeUntilCalibrationExpire() < 200)","def lux_above_threshold(self) -> bool:\n if self.lux_sensor:\n value = self.hass.get_state(self.lux_sensor)\n if value not in [\"unavailable\", \"unknown\"]:\n return float(value) > self.lux_threshold\n\n return False","def set_altitude(self):\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\n print('altitude set to', self.altitude)\n if self.altitude < 0:\n self.altitude = self.altitude + 360.0\n return self.altitude \n else: \n pass\n return self.altitude","def exit_indicator(self, feats):\n pos = self.portfolio.portfolio_handler.filled_positions[\"ARNC\"]\n d = pos.direction\n return (\n (feats[\"z-score\"] > -0.5 and d == Directions.long_dir) or\n (feats[\"z-score\"] < 0.5 and d == Directions.short_dir)\n )","def is_achromatic(self) -> bool:\n\n value = self._space.is_achromatic(self.coords(nans=False))\n if value is None:\n xyz = self.convert('xyz-d65')\n return bool(xyz._space.is_achromatic(xyz[:-1]))\n return value","def is_hom_alt(self) -> bool:\n return self.is_hom() and (self.allele1 > 0 or self.allele2 > 0)","def isLow(self):\n\t\treturn self.resolution == 'LOW'","def test_triangle_get_longest_altitude(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_longest_altitude(), 9.428090415820634)","def degenerate(self):\n return self.radius == 0.0","def is_heavily_armed(self):\n # type: () -> bool\n return False","def sensed(self):\n return not self.pin.read() if self.pinishigh else self.pin.read()","def is_northern(latitude):\n if (latitude < 0.0):\n return 0\n else:\n return 1","def check_notch(self):\n\n return self.pins[0] == self.notch","def isInvertible(self):\n return bool(self.isSquare() and self.determinant())","def is_from_inertial(self, freq_threshold: float = 0.05) -> bool:\n self = cast(\"Flight\", self)\n\n if \"compute_track\" not in self.data.columns:\n self = self.cumulative_distance(compute_gs=False)\n\n freq = (\n self.diff(\"compute_track\")\n .compute_track_diff.round()\n .value_counts(normalize=True)\n )\n if 90 not in freq.index or -90 not in freq.index:\n return False\n return ( # type: ignore\n freq[90] > freq_threshold and freq[-90] > freq_threshold\n )","def process_driver_altitude(coordinate: Coordinate) -> ProcessDescription:\n city = get_city_by_coordinates(\n latitude=coordinate.latitude,\n longitude=coordinate.longitude,\n )\n city_coordinates = CITIES_COORDINATES_MAP.get(city)\n if not city_coordinates:\n return ProcessDescription(\n detect=False,\n description='Invalid city coordinates.'\n )\n\n altitude_min = city_coordinates['altitude_min']\n altitude_max = city_coordinates['altitude_max']\n\n if altitude_min <= coordinate.altitude <= altitude_max:\n return ProcessDescription(\n detect=False,\n description=(\n f'Driver altitude {coordinate.altitude} '\n f'is normal for city {city.capitalize()}.'\n )\n )\n\n return ProcessDescription(\n detect=True,\n description=(\n f'Driver has incorrect altitude {coordinate.altitude} '\n f'for city {city.capitalize()}.'\n )\n )","def checkAltAz ( rawAltAz ):\n #-- 1 --\n # [ if rawAltAz contains either a '+' or a '-' ->\n # m := a re.match instance describing the first matching\n # character\n # else ->\n # sys.stderr +:= error message\n # stop execution ]\n m = SIGN_PAT.search ( rawAltAz )\n if m is None:\n usage ( \"Equatorial coordinates must be separated by \"\n \"'+' or '-'.\" )\n #-- 2 --\n # [ rawAz := rawAltAz up to the match described by m\n # sign := characters matched by m\n # rawAlt := rawAltAz past the match described by m ]\n rawAz = rawAltAz[:m.start()]\n sign = m.group()\n rawAlt = rawAltAz[m.end():]\n\n #-- 3 --\n # [ if rawAz is a valid angle ->\n # az := that angle as radians\n # else ->\n # sys.stderr +:= error message\n # stop execution ]\n try:\n az = sidereal.parseAngle ( rawAz )\n except SyntaxError, detail:\n usage ( \"Azimuth '%s' should have the form \"\n \"'NNNd[NNm[NN.NNNs]]'.\" % rawAz )\n\n #-- 4 --\n # [ if rawAlt is a valid angle ->\n # alt := that angle as radians\n # else ->\n # sys.stderr +:= error message\n # stop execution ]\n try:\n absAlt = sidereal.parseAngle ( rawAlt )\n except SyntaxError, detail:\n usage ( \"Altitude '%s' should have the form \"\n \"'NNd[NNm[NN.NNNs]]'.\" % rawAlt )\n\n #-- 5 --\n if sign == '-': alt = - absAlt\n else: alt = absAlt\n\n #-- 6 --\n return sidereal.AltAz ( alt, az )","def has_warning(self):\n \n if self['n_madloop_calls'] > 0:\n fraction = self['exceptional_points']/float(self['n_madloop_calls'])\n else:\n fraction = 0.0\n \n if self['skipped_subchannel'] > 0:\n return True\n elif fraction > 1.0e-4:\n return True\n else:\n return False","def check_heated_up(error):\n error = np.array(error)\n error = np.abs(error)\n if len(error) < 30 or sum(error[-30:-1]) > 15:\n return False\n else:\n return True","def is_heating(self) -> bool:\r\n self._logger.debug(log_message_formatter(\r\n \"get\", f\"{self}\", \"is_heating\"))\r\n return (self._ambient_temperature < self._target_temperature) \\\r\n and self.can_heat \\\r\n and (self._hvac_mode == \"heat\" or self._hvac_mode == \"heat-cool\")","def is_water(self):\n return False","def is_water(self):\n return False","def is_hermitian(self, eps = 0):\n return (self - self.hc()).absmax() <= eps","def is_Heegner_disc(self, D):\n Dr = D % self.multiplier().level()\n if self.multiplier().is_dual():\n Dr = -Dr\n if Dr in self.multiplier().weil_module().Qv_times_level:\n return True\n else:\n return False","def is_eht_off(self):\n raise NotImplementedError","def utm_isNorthern(latitude):\n\n return (latitude > 0.0)","def is_almost_active(self,\n env\n ):\n if not hasattr(self, \"tolerance\") or self.tolerance is None:\n return False\n c_value = self.get_value(env)\n flag = np.any(np.greater(c_value + self.tolerance, 0.))\n return bool(flag)","def is_antipodal(self):\n return self._.r if self._.antipodal else False","def has_uav_reached_current_waypoint(self):\n return self.drone.has_reached_waypoint()","def _has_noise(self) -> bool:\n min = self.array.min()\n max = self.array.max()\n near_min, near_max = np.percentile(self.array, [0.5, 99.5])\n max_is_extreme = max > near_max * 1.25\n min_is_extreme = (min < near_min * 0.75) and (\n abs(min - near_min) > 0.1 * (near_max - near_min)\n )\n return max_is_extreme or min_is_extreme","def is_sealed(self):\n return self.walls == Direction.All","def is_approximated_solution(p):\n tr = float(p[\"optThreshold\"])\n # TODO: finish\n k = \"result.best.verificationDecision\"\n return p[\"result.best.isOptimal\"] == \"true\" and p[k] == \"unsat\"","def is_calibrated(self):\n\n return self.bin_edges_kev is not None","def uniform_dz(self):\n return self.dz is not None","def is_elliptic(self):\n if self.is_irreducible():\n return self._info['elliptic']\n else:\n return False","def _is_ue4(self):\n\n return False","def is_pure_electric(self):\n klist = [key for key in self.components if not self.component_is_zero(key)]\n return all([key.startswith('electric') for key in klist])","def is_tr(self, y, t):\n return t != 0 and y != 0","def _check_large_tilt(self):\n large_tilt = []\n xy, xz, yz = self.tilt_factors\n x,y,_ = self.cell_lengths\n\n large_tilt.append(-x/2<xy<x/2)\n large_tilt.append(-x/2<xz<y/2)\n large_tilt.append(-x/2<yz<y/2)\n return not all(large_tilt)","def hasEnergyExpended(self, flags):\r\n return (flags & 0x08) != 0","def is_distal(self):\n return bool(set(self.locations) and set(self.locations) <= set(StandardTerminology.DISTAL_LOCATIONS)) \\\n or bool(self.depth and 16 < self.depth < 82)","def is_high_temp(self):\n status = self.get_status_response()\n return ((status[1] & 0x20) == 0x20)\n #end is_power_limited()","def __isFarFromLevel(self, l):\n\n s = np.mean(self.df['high'] - self.df['low'])\n return np.sum([abs(l-x) < s for x in self.levels]) == 0","def valid_trip(self):\n if self.pickupcoords is None or self.dropoffcoords is None:\n return False\n valid = lambda x, y: 41 < x < 43.5 and -72.5 < y < - 70.5\n return valid(self.pickupcoords[0], self.pickupcoords[1]) and valid(self.dropoffcoords[0], self.dropoffcoords[1])","def is_passing(hi_sens, hi_prec, purity, min_sensitivity, min_precision, min_supported_purity):\n # type: (float, float, float, float, float, float) -> bool\n if purity < min_supported_purity:\n return True\n if hi_sens < min_sensitivity:\n return False\n if hi_prec < min_precision:\n return False\n return True","def is_correctly_identified(self, identity = None):\n if identity is None:\n identity = self.identity()\n\n return len(self.inaccuracies[identity]) == 0","def can_throw(self):\n if self.round_points == 0:\n return False\n return True","def is_affine(self):\n if self.is_irreducible():\n return self._info['affine']\n else:\n return False","def elevation(self):\n return self.altitude - self.heightAboveGround","def isUnConditional(self) -> bool:\n ...","def steadyYet(newg, oldg, newe, olde, newh, oldh, newf, oldf, tolerance):\n steady_yet = True\n if oldg == 0 or (abs(newg-oldg)/oldg > tolerance or\n abs(newe-olde)/olde > tolerance or\n abs(newh-oldh)/oldh > tolerance or\n abs(newf-oldf)/oldf > tolerance):\n steady_yet = False\n return steady_yet","def isHittingLow(self):\n return not self.limLow.get()","def has_compatible_ligands(self, identity):\n return ((len(self.bad_coords[identity]) == 0) and\n (not self.BAD_COORD_RESIDUE in self.inaccuracies[identity]))","def stop_on_low_ais_ess(trial_id, result):\n return result[\"ais_effective_sample_size\"] < 0.1","def is_lmtp_over(self):\n\t\tif self._c >= self._C:\n\t\t\treturn True\n\t\treturn False","def _is_valid_leg(self, leg):\n if not leg:\n return False\n\n if (leg.LegType() == 'Float' and\n leg.FloatRateReference() and\n leg.Currency().Name() == self.currency.Name()):\n return True\n elif leg.LegType() == 'Fixed':\n return True\n\n return False","def _is_ue3(self):\n\n return False","def water_detected(self):\n summary = \" \".join(self.get_summary().split())\n pattern = '\\$.... .. .*? .*? .*? .*? .*? (.) .*? .*? . . . .*?'\n water = int(re.findall(pattern,summary).pop())\n if water == 0:\n return False\n elif water == 1:\n return True","def rotated(self):\n return self.pol_lat != 90.","def is_worthless(self):\n self.normalize()\n return self.all_details['normalized'] in WORTHLESS_UA_TYPES","def is_proximal(self):\n return bool(set(self.locations) and set(self.locations) <= set(StandardTerminology.PROXIMAL_LOCATIONS)) \\\n or bool(self.depth and self.depth > 82)","def stable(self):\n return(self.zeta > 0)","def isKelvin(self):\n return _libsbml.Unit_isKelvin(self)","def zero_failures(self) -> bool:\n return abs(self.failurerate) < 1e-7"],"string":"[\n \"def is_elevation(self):\\n return not self._is_depth\",\n \"def altitude(self):\\n if self.__altitude:\\n return sum(self.__altitude) / len(self.__altitude)\\n else:\\n return -9999\",\n \"def is_slope(self):\\n\\t\\tif self.high_elevation != self.low_elevation:\\n\\t\\t\\treturn True\\n\\t\\treturn False\",\n \"def sanity_check(self):\\n res = True\\n res = res and self.detected\\n res = res and np.sum(self.diffs) < 30000 # experimental value\\n return res\",\n \"def is_aux_heat_on(self):\\n return self._device.mode == self._device.MODE_HEAT_EMERGENCY\",\n \"def has_undercoordinated_metal(self):\\n return self._has_low_metal_coordination()\",\n \"def classify_altitude_profile(altitudes):\\n max_alt = altitudes.max()\\n has_climb = (max_alt > altitudes[0])\\n has_descent = (max_alt > altitudes[-1])\\n\\n if has_climb or has_descent:\\n if has_climb != has_descent:\\n return AltitudeProfileType.CLIMBING if has_climb \\\\\\n else AltitudeProfileType.DESCENDING\\n else:\\n return AltitudeProfileType.CLIMBING_AND_DESCENDING\\n else:\\n return AltitudeProfileType.CRUISING\",\n \"def is_equidistant(self) -> bool:\\n if len(self.time) < 3:\\n return True\\n return len(self.time.to_series().diff().dropna().unique()) == 1\",\n \"def isstationary(self):\\n if np.all(np.abs(self.arroots) > 1.0):\\n return True\\n else:\\n return False\",\n \"def is_inequality(self):\\n return True\",\n \"def is_inequality(self):\\n return True\",\n \"def altitude(self):\\r\\n pressure = self.pressure # in Si units for hPascal\\r\\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))\",\n \"def test_triangle_get_shortest_altitude(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)\",\n \"def check_rpt_status(self) -> bool:\\n return self.allele == self.fasta_alt\",\n \"def is_cis(self):\\n prev_res = self.get_offset_residue(-1)\\n if prev_res is None:\\n return None\\n\\n prev_omega = prev_res.calc_torsion_omega()\\n if prev_omega is None:\\n return None\\n\\n if abs(prev_omega) <= (math.pi/2.0):\\n return True\\n\\n return False\",\n \"def base_failure(self, uncertainty):\\n return False\\n rpos = self.sim.getAgentPosition(self.robot_num)\\n gpos = self.overall_robot_goal\\n if ((rpos[0]-gpos[0])**2 + (rpos[1]-gpos[1])**2)**0.5 <= \\\\\\n self.sim.getAgentRadius(self.robot_num):\\n return True\\n elif (rpos[0] > gpos[0]):\\n return True\\n else:\\n return False\\n self.uncertainties[self.uncertainty_ind] = uncertainty\\n self.uncertainty_ind = (self.uncertainty_ind + 1 )%len(\\n self.uncertainties)\\n # 0.004 is a hard-coded threshold for now that was determined by\\n # analyzing multiple barge-in runs.\\n return utils.avg(self.uncertainties) > 0.004\",\n \"def is_artificial(self):\\n\\t\\treturn 0\",\n \"def is_inequality(self):\\n return False\",\n \"def is_upper(self):\\n return self.z < 0\",\n \"def is_aux_heat(self) -> bool | None:\\n return self._aux\",\n \"def looks_azimuth(self) -> Optional[int]:\\n return self._get_property(LOOKS_AZIMUTH_PROP, int)\",\n \"def altitude_callback(self, data):\\n self.altitude = data\\n self.altitude_bottom_clearance = np.float64(data.bottom_clearance)\\n if np.isnan(self.altitude_bottom_clearance):\\n # message is often enough that it should alert the user but shouldn't swamp the console\\n rospy.logwarn_throttle(0.5, 'bottom clearance is invalid type: {}'.format(self.altitude_bottom_clearance))\",\n \"def sun_is_down(check_time, observatory):\\n sun = get_sun(check_time).transform_to(AltAz(obstime=check_time, location=observatory))\\n return sun.alt.value < -14\",\n \"def check_altitude_at(self, altim, coords, altitude_bounds):\\n altitude = altim.mesh.point_altitude(coords)\\n self.assertWithin(altitude, *altitude_bounds)\",\n \"def determine_azel_are_safe(_az, _el):\\n if _az and _el:\\n return True\",\n \"def check_convergency(self):\\n if self.vars['ema_trace'][self.vars['step']] <= self.settings[\\\"emaSpeedTol\\\"]:\\n return True\\n else:\\n return False\",\n \"def deceived(self, a):\\n try:\\n n = self.control[a.name][0]\\n if hardrule:\\n return self.nsucc(a) > self.succ(a) + epsilonD and \\\\\\n (n > 5) and ((self.world.round - n) > 5) \\n else:\\n return (n > 5) and ( (a.successRate > self.succ(a) + epsilonD) or \\\\\\n (a.successRate < epsilonD))\\n except KeyError:\\n raise AssertionError, str(a) + \\\" is not a non-MI!\\\"\",\n \"def closest_cruising_altitude(altitude):\\n return 1000 * ((altitude + 500) // 1000)\",\n \"def is_leech(self, meta: \\\"CardMeta\\\") -> bool:\\n if len(meta.past_quality) < LEECH_MIN_QUALITY:\\n return False\\n return (\\n meta.past_quality[-1] < BAD_QUALITY_THRESHOLD\\n and meta.past_quality[-2] < BAD_QUALITY_THRESHOLD\\n and meta.past_quality[-3] < BAD_QUALITY_THRESHOLD\\n )\",\n \"def is_tachycardic(self, hr):\\n lower_bound = self.tachycardic_range()\\n return hr > lower_bound\",\n \"def is_stationary(self) -> bool:\\n ad_fuller_result = adfuller(self.y.dropna(), autolag='AIC')\\n p_value = ad_fuller_result[1]\\n return p_value <= 0.5\",\n \"def is_inequality(self): \\n return False\",\n \"def altitude(self) -> int:\\n return self._point.altitude\",\n \"def isGeostationary(sat):\\n minAlt = minAz = float('inf')\\n maxAlt = maxAz = -float('inf')\\n\\n epochDt = sat.epoch.utc_datetime()\\n startDt = epochDt - timedelta(hours=24)\\n endDt = epochDt + timedelta(hours=24)\\n\\n dt = startDt\\n while dt <= endDt:\\n t = ts.from_datetime(dt)\\n alt, az, _ = (sat - sofia).at(t).altaz()\\n alt = alt.degrees\\n az = az.degrees\\n if alt < minAlt:\\n minAlt = alt\\n if alt > maxAlt:\\n maxAlt = alt\\n if az < minAz:\\n minAz = az\\n if az > maxAz:\\n maxAz = az\\n dt += timedelta(hours=1)\\n return maxAlt - minAlt < 1 and maxAz - minAz < 1\",\n \"def check_masked(self):\\n if self._alternate == 'N': # If our alternate allele is masked, or an 'N'\\n return True # Return True\\n else: # Otherwise\\n return False # Return False\",\n \"def isgood(self):\\n\\t\\tanswer = True\\n\\t\\t\\n\\t\\tif self.mes_flux <= 0.0:\\n\\t\\t\\tanswer = False\\n\\n\\t\\treturn answer\",\n \"def isCalibrationExpired(self):\\n return (getI1ProTimeUntilCalibrationExpire() < 200)\",\n \"def lux_above_threshold(self) -> bool:\\n if self.lux_sensor:\\n value = self.hass.get_state(self.lux_sensor)\\n if value not in [\\\"unavailable\\\", \\\"unknown\\\"]:\\n return float(value) > self.lux_threshold\\n\\n return False\",\n \"def set_altitude(self):\\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\\n print('altitude set to', self.altitude)\\n if self.altitude < 0:\\n self.altitude = self.altitude + 360.0\\n return self.altitude \\n else: \\n pass\\n return self.altitude\",\n \"def exit_indicator(self, feats):\\n pos = self.portfolio.portfolio_handler.filled_positions[\\\"ARNC\\\"]\\n d = pos.direction\\n return (\\n (feats[\\\"z-score\\\"] > -0.5 and d == Directions.long_dir) or\\n (feats[\\\"z-score\\\"] < 0.5 and d == Directions.short_dir)\\n )\",\n \"def is_achromatic(self) -> bool:\\n\\n value = self._space.is_achromatic(self.coords(nans=False))\\n if value is None:\\n xyz = self.convert('xyz-d65')\\n return bool(xyz._space.is_achromatic(xyz[:-1]))\\n return value\",\n \"def is_hom_alt(self) -> bool:\\n return self.is_hom() and (self.allele1 > 0 or self.allele2 > 0)\",\n \"def isLow(self):\\n\\t\\treturn self.resolution == 'LOW'\",\n \"def test_triangle_get_longest_altitude(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_longest_altitude(), 9.428090415820634)\",\n \"def degenerate(self):\\n return self.radius == 0.0\",\n \"def is_heavily_armed(self):\\n # type: () -> bool\\n return False\",\n \"def sensed(self):\\n return not self.pin.read() if self.pinishigh else self.pin.read()\",\n \"def is_northern(latitude):\\n if (latitude < 0.0):\\n return 0\\n else:\\n return 1\",\n \"def check_notch(self):\\n\\n return self.pins[0] == self.notch\",\n \"def isInvertible(self):\\n return bool(self.isSquare() and self.determinant())\",\n \"def is_from_inertial(self, freq_threshold: float = 0.05) -> bool:\\n self = cast(\\\"Flight\\\", self)\\n\\n if \\\"compute_track\\\" not in self.data.columns:\\n self = self.cumulative_distance(compute_gs=False)\\n\\n freq = (\\n self.diff(\\\"compute_track\\\")\\n .compute_track_diff.round()\\n .value_counts(normalize=True)\\n )\\n if 90 not in freq.index or -90 not in freq.index:\\n return False\\n return ( # type: ignore\\n freq[90] > freq_threshold and freq[-90] > freq_threshold\\n )\",\n \"def process_driver_altitude(coordinate: Coordinate) -> ProcessDescription:\\n city = get_city_by_coordinates(\\n latitude=coordinate.latitude,\\n longitude=coordinate.longitude,\\n )\\n city_coordinates = CITIES_COORDINATES_MAP.get(city)\\n if not city_coordinates:\\n return ProcessDescription(\\n detect=False,\\n description='Invalid city coordinates.'\\n )\\n\\n altitude_min = city_coordinates['altitude_min']\\n altitude_max = city_coordinates['altitude_max']\\n\\n if altitude_min <= coordinate.altitude <= altitude_max:\\n return ProcessDescription(\\n detect=False,\\n description=(\\n f'Driver altitude {coordinate.altitude} '\\n f'is normal for city {city.capitalize()}.'\\n )\\n )\\n\\n return ProcessDescription(\\n detect=True,\\n description=(\\n f'Driver has incorrect altitude {coordinate.altitude} '\\n f'for city {city.capitalize()}.'\\n )\\n )\",\n \"def checkAltAz ( rawAltAz ):\\n #-- 1 --\\n # [ if rawAltAz contains either a '+' or a '-' ->\\n # m := a re.match instance describing the first matching\\n # character\\n # else ->\\n # sys.stderr +:= error message\\n # stop execution ]\\n m = SIGN_PAT.search ( rawAltAz )\\n if m is None:\\n usage ( \\\"Equatorial coordinates must be separated by \\\"\\n \\\"'+' or '-'.\\\" )\\n #-- 2 --\\n # [ rawAz := rawAltAz up to the match described by m\\n # sign := characters matched by m\\n # rawAlt := rawAltAz past the match described by m ]\\n rawAz = rawAltAz[:m.start()]\\n sign = m.group()\\n rawAlt = rawAltAz[m.end():]\\n\\n #-- 3 --\\n # [ if rawAz is a valid angle ->\\n # az := that angle as radians\\n # else ->\\n # sys.stderr +:= error message\\n # stop execution ]\\n try:\\n az = sidereal.parseAngle ( rawAz )\\n except SyntaxError, detail:\\n usage ( \\\"Azimuth '%s' should have the form \\\"\\n \\\"'NNNd[NNm[NN.NNNs]]'.\\\" % rawAz )\\n\\n #-- 4 --\\n # [ if rawAlt is a valid angle ->\\n # alt := that angle as radians\\n # else ->\\n # sys.stderr +:= error message\\n # stop execution ]\\n try:\\n absAlt = sidereal.parseAngle ( rawAlt )\\n except SyntaxError, detail:\\n usage ( \\\"Altitude '%s' should have the form \\\"\\n \\\"'NNd[NNm[NN.NNNs]]'.\\\" % rawAlt )\\n\\n #-- 5 --\\n if sign == '-': alt = - absAlt\\n else: alt = absAlt\\n\\n #-- 6 --\\n return sidereal.AltAz ( alt, az )\",\n \"def has_warning(self):\\n \\n if self['n_madloop_calls'] > 0:\\n fraction = self['exceptional_points']/float(self['n_madloop_calls'])\\n else:\\n fraction = 0.0\\n \\n if self['skipped_subchannel'] > 0:\\n return True\\n elif fraction > 1.0e-4:\\n return True\\n else:\\n return False\",\n \"def check_heated_up(error):\\n error = np.array(error)\\n error = np.abs(error)\\n if len(error) < 30 or sum(error[-30:-1]) > 15:\\n return False\\n else:\\n return True\",\n \"def is_heating(self) -> bool:\\r\\n self._logger.debug(log_message_formatter(\\r\\n \\\"get\\\", f\\\"{self}\\\", \\\"is_heating\\\"))\\r\\n return (self._ambient_temperature < self._target_temperature) \\\\\\r\\n and self.can_heat \\\\\\r\\n and (self._hvac_mode == \\\"heat\\\" or self._hvac_mode == \\\"heat-cool\\\")\",\n \"def is_water(self):\\n return False\",\n \"def is_water(self):\\n return False\",\n \"def is_hermitian(self, eps = 0):\\n return (self - self.hc()).absmax() <= eps\",\n \"def is_Heegner_disc(self, D):\\n Dr = D % self.multiplier().level()\\n if self.multiplier().is_dual():\\n Dr = -Dr\\n if Dr in self.multiplier().weil_module().Qv_times_level:\\n return True\\n else:\\n return False\",\n \"def is_eht_off(self):\\n raise NotImplementedError\",\n \"def utm_isNorthern(latitude):\\n\\n return (latitude > 0.0)\",\n \"def is_almost_active(self,\\n env\\n ):\\n if not hasattr(self, \\\"tolerance\\\") or self.tolerance is None:\\n return False\\n c_value = self.get_value(env)\\n flag = np.any(np.greater(c_value + self.tolerance, 0.))\\n return bool(flag)\",\n \"def is_antipodal(self):\\n return self._.r if self._.antipodal else False\",\n \"def has_uav_reached_current_waypoint(self):\\n return self.drone.has_reached_waypoint()\",\n \"def _has_noise(self) -> bool:\\n min = self.array.min()\\n max = self.array.max()\\n near_min, near_max = np.percentile(self.array, [0.5, 99.5])\\n max_is_extreme = max > near_max * 1.25\\n min_is_extreme = (min < near_min * 0.75) and (\\n abs(min - near_min) > 0.1 * (near_max - near_min)\\n )\\n return max_is_extreme or min_is_extreme\",\n \"def is_sealed(self):\\n return self.walls == Direction.All\",\n \"def is_approximated_solution(p):\\n tr = float(p[\\\"optThreshold\\\"])\\n # TODO: finish\\n k = \\\"result.best.verificationDecision\\\"\\n return p[\\\"result.best.isOptimal\\\"] == \\\"true\\\" and p[k] == \\\"unsat\\\"\",\n \"def is_calibrated(self):\\n\\n return self.bin_edges_kev is not None\",\n \"def uniform_dz(self):\\n return self.dz is not None\",\n \"def is_elliptic(self):\\n if self.is_irreducible():\\n return self._info['elliptic']\\n else:\\n return False\",\n \"def _is_ue4(self):\\n\\n return False\",\n \"def is_pure_electric(self):\\n klist = [key for key in self.components if not self.component_is_zero(key)]\\n return all([key.startswith('electric') for key in klist])\",\n \"def is_tr(self, y, t):\\n return t != 0 and y != 0\",\n \"def _check_large_tilt(self):\\n large_tilt = []\\n xy, xz, yz = self.tilt_factors\\n x,y,_ = self.cell_lengths\\n\\n large_tilt.append(-x/2<xy<x/2)\\n large_tilt.append(-x/2<xz<y/2)\\n large_tilt.append(-x/2<yz<y/2)\\n return not all(large_tilt)\",\n \"def hasEnergyExpended(self, flags):\\r\\n return (flags & 0x08) != 0\",\n \"def is_distal(self):\\n return bool(set(self.locations) and set(self.locations) <= set(StandardTerminology.DISTAL_LOCATIONS)) \\\\\\n or bool(self.depth and 16 < self.depth < 82)\",\n \"def is_high_temp(self):\\n status = self.get_status_response()\\n return ((status[1] & 0x20) == 0x20)\\n #end is_power_limited()\",\n \"def __isFarFromLevel(self, l):\\n\\n s = np.mean(self.df['high'] - self.df['low'])\\n return np.sum([abs(l-x) < s for x in self.levels]) == 0\",\n \"def valid_trip(self):\\n if self.pickupcoords is None or self.dropoffcoords is None:\\n return False\\n valid = lambda x, y: 41 < x < 43.5 and -72.5 < y < - 70.5\\n return valid(self.pickupcoords[0], self.pickupcoords[1]) and valid(self.dropoffcoords[0], self.dropoffcoords[1])\",\n \"def is_passing(hi_sens, hi_prec, purity, min_sensitivity, min_precision, min_supported_purity):\\n # type: (float, float, float, float, float, float) -> bool\\n if purity < min_supported_purity:\\n return True\\n if hi_sens < min_sensitivity:\\n return False\\n if hi_prec < min_precision:\\n return False\\n return True\",\n \"def is_correctly_identified(self, identity = None):\\n if identity is None:\\n identity = self.identity()\\n\\n return len(self.inaccuracies[identity]) == 0\",\n \"def can_throw(self):\\n if self.round_points == 0:\\n return False\\n return True\",\n \"def is_affine(self):\\n if self.is_irreducible():\\n return self._info['affine']\\n else:\\n return False\",\n \"def elevation(self):\\n return self.altitude - self.heightAboveGround\",\n \"def isUnConditional(self) -> bool:\\n ...\",\n \"def steadyYet(newg, oldg, newe, olde, newh, oldh, newf, oldf, tolerance):\\n steady_yet = True\\n if oldg == 0 or (abs(newg-oldg)/oldg > tolerance or\\n abs(newe-olde)/olde > tolerance or\\n abs(newh-oldh)/oldh > tolerance or\\n abs(newf-oldf)/oldf > tolerance):\\n steady_yet = False\\n return steady_yet\",\n \"def isHittingLow(self):\\n return not self.limLow.get()\",\n \"def has_compatible_ligands(self, identity):\\n return ((len(self.bad_coords[identity]) == 0) and\\n (not self.BAD_COORD_RESIDUE in self.inaccuracies[identity]))\",\n \"def stop_on_low_ais_ess(trial_id, result):\\n return result[\\\"ais_effective_sample_size\\\"] < 0.1\",\n \"def is_lmtp_over(self):\\n\\t\\tif self._c >= self._C:\\n\\t\\t\\treturn True\\n\\t\\treturn False\",\n \"def _is_valid_leg(self, leg):\\n if not leg:\\n return False\\n\\n if (leg.LegType() == 'Float' and\\n leg.FloatRateReference() and\\n leg.Currency().Name() == self.currency.Name()):\\n return True\\n elif leg.LegType() == 'Fixed':\\n return True\\n\\n return False\",\n \"def _is_ue3(self):\\n\\n return False\",\n \"def water_detected(self):\\n summary = \\\" \\\".join(self.get_summary().split())\\n pattern = '\\\\$.... .. .*? .*? .*? .*? .*? (.) .*? .*? . . . .*?'\\n water = int(re.findall(pattern,summary).pop())\\n if water == 0:\\n return False\\n elif water == 1:\\n return True\",\n \"def rotated(self):\\n return self.pol_lat != 90.\",\n \"def is_worthless(self):\\n self.normalize()\\n return self.all_details['normalized'] in WORTHLESS_UA_TYPES\",\n \"def is_proximal(self):\\n return bool(set(self.locations) and set(self.locations) <= set(StandardTerminology.PROXIMAL_LOCATIONS)) \\\\\\n or bool(self.depth and self.depth > 82)\",\n \"def stable(self):\\n return(self.zeta > 0)\",\n \"def isKelvin(self):\\n return _libsbml.Unit_isKelvin(self)\",\n \"def zero_failures(self) -> bool:\\n return abs(self.failurerate) < 1e-7\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62690014","0.60328066","0.58956814","0.58533365","0.57905114","0.5768535","0.57448244","0.5742459","0.56997365","0.56776786","0.56776786","0.5669931","0.566654","0.56537473","0.5641513","0.56306905","0.5626469","0.56141675","0.55750054","0.5573237","0.55560845","0.55502564","0.5544272","0.5523991","0.5523315","0.5464514","0.54558325","0.5455095","0.5442505","0.5440647","0.5439925","0.5431997","0.5428201","0.5400523","0.5396545","0.5346218","0.53136265","0.5305906","0.53050715","0.52956206","0.5286881","0.5282724","0.5265228","0.5264659","0.52566254","0.5250289","0.5249451","0.5247324","0.5240706","0.5236454","0.52357036","0.5224445","0.52233833","0.5221653","0.5221511","0.52207166","0.5210437","0.5210437","0.52050674","0.5194604","0.51862454","0.51728547","0.5148761","0.5142023","0.51412654","0.5136401","0.5134133","0.5119625","0.5119612","0.51152587","0.51091","0.51086146","0.5102726","0.51019186","0.5096265","0.5084955","0.5083359","0.5080318","0.50699824","0.5067768","0.5062297","0.5060839","0.5058946","0.5058228","0.5044675","0.5043841","0.5040105","0.5039119","0.503614","0.5034527","0.50342256","0.5030521","0.50283074","0.5025201","0.50213695","0.50153327","0.5012061","0.50082725","0.50082177","0.50027007"],"string":"[\n \"0.62690014\",\n \"0.60328066\",\n \"0.58956814\",\n \"0.58533365\",\n \"0.57905114\",\n \"0.5768535\",\n \"0.57448244\",\n \"0.5742459\",\n \"0.56997365\",\n \"0.56776786\",\n \"0.56776786\",\n \"0.5669931\",\n \"0.566654\",\n \"0.56537473\",\n \"0.5641513\",\n \"0.56306905\",\n \"0.5626469\",\n \"0.56141675\",\n \"0.55750054\",\n \"0.5573237\",\n \"0.55560845\",\n \"0.55502564\",\n \"0.5544272\",\n \"0.5523991\",\n \"0.5523315\",\n \"0.5464514\",\n \"0.54558325\",\n \"0.5455095\",\n \"0.5442505\",\n \"0.5440647\",\n \"0.5439925\",\n \"0.5431997\",\n \"0.5428201\",\n \"0.5400523\",\n \"0.5396545\",\n \"0.5346218\",\n \"0.53136265\",\n \"0.5305906\",\n \"0.53050715\",\n \"0.52956206\",\n \"0.5286881\",\n \"0.5282724\",\n \"0.5265228\",\n \"0.5264659\",\n \"0.52566254\",\n \"0.5250289\",\n \"0.5249451\",\n \"0.5247324\",\n \"0.5240706\",\n \"0.5236454\",\n \"0.52357036\",\n \"0.5224445\",\n \"0.52233833\",\n \"0.5221653\",\n \"0.5221511\",\n \"0.52207166\",\n \"0.5210437\",\n \"0.5210437\",\n \"0.52050674\",\n \"0.5194604\",\n \"0.51862454\",\n \"0.51728547\",\n \"0.5148761\",\n \"0.5142023\",\n \"0.51412654\",\n \"0.5136401\",\n \"0.5134133\",\n \"0.5119625\",\n \"0.5119612\",\n \"0.51152587\",\n \"0.51091\",\n \"0.51086146\",\n \"0.5102726\",\n \"0.51019186\",\n \"0.5096265\",\n \"0.5084955\",\n \"0.5083359\",\n \"0.5080318\",\n \"0.50699824\",\n \"0.5067768\",\n \"0.5062297\",\n \"0.5060839\",\n \"0.5058946\",\n \"0.5058228\",\n \"0.5044675\",\n \"0.5043841\",\n \"0.5040105\",\n \"0.5039119\",\n \"0.503614\",\n \"0.5034527\",\n \"0.50342256\",\n \"0.5030521\",\n \"0.50283074\",\n \"0.5025201\",\n \"0.50213695\",\n \"0.50153327\",\n \"0.5012061\",\n \"0.50082725\",\n \"0.50082177\",\n \"0.50027007\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.713465"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":91976,"cells":{"query":{"kind":"string","value":"Determine whether an altitude range may be at a cruising altitude."},"document":{"kind":"string","value":"def in_cruise_level_range(altitudes, cruise_altitude):\n return is_cruising(altitudes, cruise_altitude).all()"},"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 is_cruising(altitude, cruise_altitude=None):\n if cruise_altitude is None:\n cruise_altitude = closest_cruising_altitude(altitude)\n return abs(altitude - cruise_altitude) <= 200","def check_altitude_at(self, altim, coords, altitude_bounds):\n altitude = altim.mesh.point_altitude(coords)\n self.assertWithin(altitude, *altitude_bounds)","def is_elevation(self):\n return not self._is_depth","def is_upper(self):\n return self.z < 0","def is_slope(self):\n\t\tif self.high_elevation != self.low_elevation:\n\t\t\treturn True\n\t\treturn False","def test_is_mountain_in_range(self):\n self.assertTrue(self.user_location.is_mountain_in_range(self.mountain_one))\n self.assertFalse(self.user_location.is_mountain_in_range(self.mountain_two))","def base_failure(self, uncertainty):\n return False\n rpos = self.sim.getAgentPosition(self.robot_num)\n gpos = self.overall_robot_goal\n if ((rpos[0]-gpos[0])**2 + (rpos[1]-gpos[1])**2)**0.5 <= \\\n self.sim.getAgentRadius(self.robot_num):\n return True\n elif (rpos[0] > gpos[0]):\n return True\n else:\n return False\n self.uncertainties[self.uncertainty_ind] = uncertainty\n self.uncertainty_ind = (self.uncertainty_ind + 1 )%len(\n self.uncertainties)\n # 0.004 is a hard-coded threshold for now that was determined by\n # analyzing multiple barge-in runs.\n return utils.avg(self.uncertainties) > 0.004","def sanity_check(self):\n res = True\n res = res and self.detected\n res = res and np.sum(self.diffs) < 30000 # experimental value\n return res","def __isFarFromLevel(self, l):\n\n s = np.mean(self.df['high'] - self.df['low'])\n return np.sum([abs(l-x) < s for x in self.levels]) == 0","def is_equidistant(self) -> bool:\n if len(self.time) < 3:\n return True\n return len(self.time.to_series().diff().dropna().unique()) == 1","def air_range(self) -> Union[int, float]:\n return self.air_weapon and self.air_weapon.range","def f_has_range(self):\n return len(self._explored_range) > 0","def is_tachycardic(self, hr):\n lower_bound = self.tachycardic_range()\n return hr > lower_bound","def classify_altitude_profile(altitudes):\n max_alt = altitudes.max()\n has_climb = (max_alt > altitudes[0])\n has_descent = (max_alt > altitudes[-1])\n\n if has_climb or has_descent:\n if has_climb != has_descent:\n return AltitudeProfileType.CLIMBING if has_climb \\\n else AltitudeProfileType.DESCENDING\n else:\n return AltitudeProfileType.CLIMBING_AND_DESCENDING\n else:\n return AltitudeProfileType.CRUISING","def altitude(self):\n if self.__altitude:\n return sum(self.__altitude) / len(self.__altitude)\n else:\n return -9999","def check(self):\n self.lower_bound(5e-4)\n self.upper_bound(5e2)","def isGeostationary(sat):\n minAlt = minAz = float('inf')\n maxAlt = maxAz = -float('inf')\n\n epochDt = sat.epoch.utc_datetime()\n startDt = epochDt - timedelta(hours=24)\n endDt = epochDt + timedelta(hours=24)\n\n dt = startDt\n while dt <= endDt:\n t = ts.from_datetime(dt)\n alt, az, _ = (sat - sofia).at(t).altaz()\n alt = alt.degrees\n az = az.degrees\n if alt < minAlt:\n minAlt = alt\n if alt > maxAlt:\n maxAlt = alt\n if az < minAz:\n minAz = az\n if az > maxAz:\n maxAz = az\n dt += timedelta(hours=1)\n return maxAlt - minAlt < 1 and maxAz - minAz < 1","def lux_above_threshold(self) -> bool:\n if self.lux_sensor:\n value = self.hass.get_state(self.lux_sensor)\n if value not in [\"unavailable\", \"unknown\"]:\n return float(value) > self.lux_threshold\n\n return False","def _isInAllowedRange( self, testval, refval, reltol=1.e-2 ):\n denom = refval\n if refval == 0:\n if testval == 0:\n return True\n else:\n denom = testval\n rdiff = (testval-refval)/denom\n del denom,testval,refval\n return (abs(rdiff) <= reltol)","def check_heated_up(error):\n error = np.array(error)\n error = np.abs(error)\n if len(error) < 30 or sum(error[-30:-1]) > 15:\n return False\n else:\n return True","def isHittingLow(self):\n return not self.limLow.get()","def altitude_range(self, start_distance, finish_distance):\n start_index, start_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n\n min_alt = min(start_alt, finish_alt)\n max_alt = max(start_alt, finish_alt)\n\n if start_index < finish_index:\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\n min_alt = min(min_alt, altitudes.min())\n max_alt = max(max_alt, altitudes.max())\n\n return min_alt, max_alt","def _has_noise(self) -> bool:\n min = self.array.min()\n max = self.array.max()\n near_min, near_max = np.percentile(self.array, [0.5, 99.5])\n max_is_extreme = max > near_max * 1.25\n min_is_extreme = (min < near_min * 0.75) and (\n abs(min - near_min) > 0.1 * (near_max - near_min)\n )\n return max_is_extreme or min_is_extreme","def is_inequality(self):\n return True","def is_inequality(self):\n return True","def determine_azel_are_safe(_az, _el):\n if _az and _el:\n return True","def check_rpt_status(self) -> bool:\n return self.allele == self.fasta_alt","def check_convergency(self):\n if self.vars['ema_trace'][self.vars['step']] <= self.settings[\"emaSpeedTol\"]:\n return True\n else:\n return False","def is_inequality(self):\n return False","def is_aux_heat_on(self):\n return self._device.mode == self._device.MODE_HEAT_EMERGENCY","def feasible(self):\n return self.lowBound <= self._value <= self.upBound","def valid_trip(self):\n if self.pickupcoords is None or self.dropoffcoords is None:\n return False\n valid = lambda x, y: 41 < x < 43.5 and -72.5 < y < - 70.5\n return valid(self.pickupcoords[0], self.pickupcoords[1]) and valid(self.dropoffcoords[0], self.dropoffcoords[1])","def has_compatible_ligands(self, identity):\n return ((len(self.bad_coords[identity]) == 0) and\n (not self.BAD_COORD_RESIDUE in self.inaccuracies[identity]))","def is_interior(r0, r1, abs_tol=ABS_TOL):\n if isinstance(r0, Polytope):\n r0 = Region([r0])\n if isinstance(r1, Polytope):\n r1 = Region([r1])\n for p in r1:\n A = p.A.copy()\n b = p.b.copy() + abs_tol\n dummy = Polytope(A, b)\n if not dummy <= r0:\n return True\n return False","def ground_range(self) -> Union[int, float]:\n return self.ground_weapon and self.ground_weapon.range","def isRangeValid(self) -> bool:\n ...","def is_almost_active(self,\n env\n ):\n if not hasattr(self, \"tolerance\") or self.tolerance is None:\n return False\n c_value = self.get_value(env)\n flag = np.any(np.greater(c_value + self.tolerance, 0.))\n return bool(flag)","def has_undercoordinated_metal(self):\n return self._has_low_metal_coordination()","def in_valid_range(self, string):\n fret_number = self.cursor.get_frets()[string]\n return (\n (self.min_x <= fret_number <= self.max_x) or\n (self.allow_open and fret_number == self.guitar.min_fret)\n )","def altitude_callback(self, data):\n self.altitude = data\n self.altitude_bottom_clearance = np.float64(data.bottom_clearance)\n if np.isnan(self.altitude_bottom_clearance):\n # message is often enough that it should alert the user but shouldn't swamp the console\n rospy.logwarn_throttle(0.5, 'bottom clearance is invalid type: {}'.format(self.altitude_bottom_clearance))","def isstationary(self):\n if np.all(np.abs(self.arroots) > 1.0):\n return True\n else:\n return False","def validRange(line):\n line_col = str.split(line)\n chrom = line_col[0]\n pos = line_col[1]\n# any(lower <= postcode <= upper for (lower, upper) in [(1000, 2249), (2555, 2574), ...])\n if any(float(low) <= float(pos) <= float(high) for (low,high) in TE_ranges[chrom]):\n return False\n return True","def is_leech(self, meta: \"CardMeta\") -> bool:\n if len(meta.past_quality) < LEECH_MIN_QUALITY:\n return False\n return (\n meta.past_quality[-1] < BAD_QUALITY_THRESHOLD\n and meta.past_quality[-2] < BAD_QUALITY_THRESHOLD\n and meta.past_quality[-3] < BAD_QUALITY_THRESHOLD\n )","def is_inequality(self): \n return False","def is_cis(self):\n prev_res = self.get_offset_residue(-1)\n if prev_res is None:\n return None\n\n prev_omega = prev_res.calc_torsion_omega()\n if prev_omega is None:\n return None\n\n if abs(prev_omega) <= (math.pi/2.0):\n return True\n\n return False","def is_lower_limit(self):\n is_lower = self.get_raw_status() & self.STATUS_LLIM\n return bool(is_lower)","def is_valid(self):\n posit1 = (self.mean_v > 0) & (self.kappa_y > 0) & (self.eta_y > 0)\n posit2 = (self.kappa_s > 0) & (self.eta_s > 0)\n return posit1 & posit2 & self.feller()","def set_altitude(self):\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\n print('altitude set to', self.altitude)\n if self.altitude < 0:\n self.altitude = self.altitude + 360.0\n return self.altitude \n else: \n pass\n return self.altitude","def is_exceptional(self):\n G = self.poset().hasse_diagram()\n for x in G:\n nx = list(G.neighbors_out(x))\n nx.append(x)\n if min(nx) < x and max(nx) > x:\n return False\n return True","def exit_indicator(self, feats):\n pos = self.portfolio.portfolio_handler.filled_positions[\"ARNC\"]\n d = pos.direction\n return (\n (feats[\"z-score\"] > -0.5 and d == Directions.long_dir) or\n (feats[\"z-score\"] < 0.5 and d == Directions.short_dir)\n )","def closest_cruising_altitude(altitude):\n return 1000 * ((altitude + 500) // 1000)","def isLow(self):\n\t\treturn self.resolution == 'LOW'","def is_valid(self):\n if len(self.exterior) < 3:\n return False\n return self.to_shapely_polygon().is_valid","def _exceeds_critical_angle(angle: float, s0: float, s1: float) -> bool:\n if s1 > s0: # if the second speed is faster, there is a critical angle\n critical_angle = get_critical_angle(s0, s1)\n if abs(angle) >= critical_angle:\n return True\n return False","def steadyYet(newg, oldg, newe, olde, newh, oldh, newf, oldf, tolerance):\n steady_yet = True\n if oldg == 0 or (abs(newg-oldg)/oldg > tolerance or\n abs(newe-olde)/olde > tolerance or\n abs(newh-oldh)/oldh > tolerance or\n abs(newf-oldf)/oldf > tolerance):\n steady_yet = False\n return steady_yet","def is_hermitian(self, eps = 0):\n return (self - self.hc()).absmax() <= eps","def is_upper_limit(self):\n is_upper = self.get_raw_status() & self.STATUS_ULIM\n return bool(is_upper)","def is_achromatic(self) -> bool:\n\n value = self._space.is_achromatic(self.coords(nans=False))\n if value is None:\n xyz = self.convert('xyz-d65')\n return bool(xyz._space.is_achromatic(xyz[:-1]))\n return value","def is_rectal(self):\n return bool(self.locations and set(self.locations) <= set(StandardTerminology.RECTAL_LOCATIONS)) \\\n or bool(self.depth and 4 <= self.depth <= 16)","def is_distal(self):\n return bool(set(self.locations) and set(self.locations) <= set(StandardTerminology.DISTAL_LOCATIONS)) \\\n or bool(self.depth and 16 < self.depth < 82)","def is_east(longitudes):\n return np.asarray(longitudes, dtype=\"d\") <= 0.","def ValidClusterRanges(self):\n for cluster_range in self.cluster_ranges:\n the_range = cluster_range.split(\"-\")\n print(f\"Checking that range {the_range} falls within our data area\")\n try:\n if int(the_range[0]) < self.low_data_cluster or int(the_range[1]) > self.high_data_cluster:\n print(f\"False. {the_range[0]} or {the_range[1]} is outside of our data area\")\n return False\n except TypeError as t_err:\n print(f\"Error. Range does not appear to be an int\")\n return False\n return True","def is_from_inertial(self, freq_threshold: float = 0.05) -> bool:\n self = cast(\"Flight\", self)\n\n if \"compute_track\" not in self.data.columns:\n self = self.cumulative_distance(compute_gs=False)\n\n freq = (\n self.diff(\"compute_track\")\n .compute_track_diff.round()\n .value_counts(normalize=True)\n )\n if 90 not in freq.index or -90 not in freq.index:\n return False\n return ( # type: ignore\n freq[90] > freq_threshold and freq[-90] > freq_threshold\n )","def hasLow(self):\n\t\treturn self.toLow().exists","def altitude(self):\r\n pressure = self.pressure # in Si units for hPascal\r\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))","def _check_large_tilt(self):\n large_tilt = []\n xy, xz, yz = self.tilt_factors\n x,y,_ = self.cell_lengths\n\n large_tilt.append(-x/2<xy<x/2)\n large_tilt.append(-x/2<xz<y/2)\n large_tilt.append(-x/2<yz<y/2)\n return not all(large_tilt)","def calibrateElevation(self,elevation):\n if len(self.values) == self.values.maxlen:\n self.elevcomp = self.value / ((1.0 - ((elevation + self.heightAboveGround) * 0.3048 / 44330.0)) ** 5.255)\n self.calibrated = True\n else:\n self.calibratedElevation = elevation","def looks_azimuth(self) -> Optional[int]:\n return self._get_property(LOOKS_AZIMUTH_PROP, int)","def isGE(self, a : float, b : float) -> bool:\n return (a >= b - self.tol * max(abs(a), abs(b), 1.0)) #and (a >= b - 0.1)","def inRegion(self, pulsar):\n # check if l, b are outside region first of all\n if pulsar.gl>180.:\n pulsar.gl -= 360.\n if pulsar.gl > self.GLmax or pulsar.gl < self.GLmin:\n return False\n if math.fabs(pulsar.gb) > self.GBmax or math.fabs(pulsar.gb) < self.GBmin:\n return False\n\n # need to compute ra/dec of pulsar from the l and b (galtfeq)\n ra, dec = go.lb_to_radec(pulsar.gl, pulsar.gb)\n\n # are ra, dec outside region?\n if ra > self.RAmax or ra < self.RAmin:\n return False\n if dec > self.DECmax or dec < self.DECmin:\n return False\n \n # randomly decide if pulsar is in completed area of survey\n if random.random() > self.coverage:\n return False\n \n return True","def sun_is_down(check_time, observatory):\n sun = get_sun(check_time).transform_to(AltAz(obstime=check_time, location=observatory))\n return sun.alt.value < -14","def _in_interval(value, low, up):\n if low <= value <= up:\n return True\n else:\n return False","def test_triangle_get_shortest_altitude(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)","def maybe_rectal(self):\n return bool(set(self.locations) & set(StandardTerminology.RECTAL_LOCATIONS))","def refinement_func_area(tri_points, area):\r\n max_area = 0.005\r\n return bool(area > max_area)","def filter_altitude(self, gps_data, setting=None, threshold=None):\n\n # New filter settings if provided\n if setting is not None:\n self.gps_altitude_filter = setting\n if setting == 'Manual':\n self.gps_altitude_filter_change = threshold\n\n # Set threshold for Auto\n if self.gps_altitude_filter == 'Auto':\n self.gps_altitude_filter_change = 3\n\n # Set all data to valid\n self.valid_data[3, :] = True\n # self.valid_data[5, :] = True\n\n # Manual or Auto is selected, apply filter\n if not self.gps_altitude_filter == 'Off':\n # Initialize variables\n num_valid_old = np.sum(self.valid_data[3, :])\n k = 0\n change = 1\n # Loop until no change in the number of valid ensembles\n while k < 100 and change > 0.1:\n # Compute mean using valid ensembles\n alt_mean = np.nanmean(gps_data.altitude_ens_m[self.valid_data[1, :]])\n\n # Compute difference for each ensemble\n diff = np.abs(gps_data.altitude_ens_m - alt_mean)\n\n # Mark invalid those ensembles with differences greater than the change threshold\n self.valid_data[3, diff > self.gps_altitude_filter_change] = False\n k += 1\n num_valid = np.sum(self.valid_data[3, :])\n change = num_valid_old - num_valid\n\n # Combine all filter data to composite valid data\n self.valid_data[0, :] = np.all(self.valid_data[1:, :], 0)\n self.num_invalid = np.sum(self.valid_data[0, :] == False)","def check_for_residue_existance(self):\n if not self.pose.total_residue():\n print \"No pose Loaded.\"\n return False\n\n if not self.current_chain.get() or not self.current_residue.get():\n print \"Chain or residue not set\"\n return False\n\n current_region = self.current_residue.get().split(\":\")\n if len(current_region)>1:\n ResStart = int(current_region[0]); ResEnd = int(self.current_region[1])\n\n\n if self.pose.pdb_info().pdb2pose(self.current_chain.get(), ResStart)==0 or self.pose.pdb_info().pdb2pose(self.current_chain.get(), ResEnd)==0:\n print \"Region not found in pose\"\n return False\n else:\n if self.pose.pdb_info().pdb2pose(self.current_chain.get(), int(self.current_residue.get())) ==0:\n\n print \"Residue not found in pose\"\n return False\n\n #If everythig is good then:\n return True","def bad_ceiling(ceiling,minimum):\n # Implement this function\n\n result = False\n \n if ceiling == 'clear':\n result = False\n \n elif ceiling == 'unavailable':\n result = True\n \n elif len(ceiling) == 1:\n\n if ceiling[0]['units'] == 'FT': \n if ceiling[0]['height'] < minimum and (ceiling[0]['type'] == 'broken' or ceiling[0]['type'] == 'overcast' or ceiling[0]['type'] == 'indefinite ceiling'):\n result = True\n \n elif len(ceiling) > 1:\n\n if ceiling[0]['units'] == 'FT': \n for x in range(len(ceiling)):\n if ceiling[x]['height'] < minimum and (ceiling[x]['type'] == 'broken' or ceiling[x]['type'] == 'overcast' or ceiling[x]['type'] == 'indefinite ceiling'):\n result = True\n else:\n result = False\n \n return result","def shrink(self,altRange=None,aziRange=None):\n\n if altRange is None and aziRange is None: raise LookupError('At least one of altRange and aziRange should be defined!')\n\n if altRange is not None: indAlt = np.logical_and(self.data['altitude']>=altRange[0],self.data['altitude']<=altRange[1])\n else: indAlt = np.ones(len(self.data),dtype=np.bool)\n if aziRange is not None: indAzi = np.logical_and(self.data['azimuth']>=aziRange[0],self.data['azimuth']<=aziRange[1])\n else: indAzi = np.ones(len(self.data),dtype=np.bool)\n ind = np.logical_and(indAlt,indAzi)\n self.data = self.data[ind]","def isUndefinedRange(program: ghidra.program.model.listing.Program, startAddress: ghidra.program.model.address.Address, endAddress: ghidra.program.model.address.Address) -> bool:\n ...","def check_masked(self):\n if self._alternate == 'N': # If our alternate allele is masked, or an 'N'\n return True # Return True\n else: # Otherwise\n return False # Return False","def _reached_temperature_end_point(self, T, Tend):\n if Tend is None:\n # End point not give\n return False\n\n if self._integration_direction == \"increasing\":\n if T > Tend:\n return True\n elif self._integration_direction == \"decreasing\":\n if T < Tend:\n return True\n return False","def has_uav_reached_current_waypoint(self):\n return self.drone.has_reached_waypoint()","def deceived(self, a):\n try:\n n = self.control[a.name][0]\n if hardrule:\n return self.nsucc(a) > self.succ(a) + epsilonD and \\\n (n > 5) and ((self.world.round - n) > 5) \n else:\n return (n > 5) and ( (a.successRate > self.succ(a) + epsilonD) or \\\n (a.successRate < epsilonD))\n except KeyError:\n raise AssertionError, str(a) + \" is not a non-MI!\"","def is_aux_heat(self) -> bool | None:\n return self._aux","def __check_total_duration(self, duration: int) -> bool:\n available_duration = N_EIGHTHS_PER_MEASURE * (self.n_measures - 1)\n return self.current_time_in_eighths + duration <= available_duration","def yaw_stop(self):\n return self.yaw > config.YAW_MAX or self.yaw < -config.YAW_MAX","def is_grasping(self, threshold=80):\n gripper_value = self.vacuum_sensor.state()\n if rospy.get_param('verbose'):\n rospy.loginfo('Current vacuum value: {}'.format(gripper_value))\n if gripper_value > self.GRIP_MAX_VALUE:\n raise ValueError('Detected unsafe vacuum value of {}.'.format(gripper_value))\n return gripper_value > threshold","def anamoly_detec(self,data):\r\n\t\tp = (1/(((2*math.pi)**0.5)* self.sig)) * np.prod(np.exp(-((data - self.mu)**2)/( 2 * self.sig**2)))\r\n\t\tif p >= self.epsilon:\r\n\t\t\treturn False\r\n\t\telse:\r\n\t\t\treturn True","def testLowerBound(self,time,accel):\n\t\tif (time - self.timestamp) > ParserSettings.TIME_DELTA:#tests lockout threshold of a flick event\n\t\t\tif accel > self.lower:#tests to see if the flick maximum is met yet, relative to the previous magnitude\n\t\t\t\tself.timestamp \t= time#set appropriate values when flick triggered\n\t\t\t\ttoReturn \t\t= self.lower\n\t\t\t\tself.lower\t \t= 0#reset flick for next magnitude test\n\t\t\t\treturn toReturn\n\t\t\telse:\n\t\t\t\tself.lower = accel#if no flick yet, update most recent flick to test\n\t\t\t\treturn 0\n\t\telse:\n\t\t\treturn 0","def isInAera(self):\n opp = self.get_opponent\n for players in opp:\n if (players.distance(self.playerPos)<10):\n return True\n return False","def testUpperBound(self,time,accel):\n\t\tif (time - self.timestamp) > ParserSettings.TIME_DELTA:#tests lockout threshold of a flick event\n\t\t\tif accel < self.upper:#tests if flick maximum is found, relative to previous magnitude\n\t\t\t\tself.timestamp\t= time#once peak found, set appropriate data and return a flick\n\t\t\t\ttoReturn\t\t= self.upper\n\t\t\t\tself.upper\t\t= 0\n\t\t\t\treturn toReturn\n\t\t\telse:\n\t\t\t\tself.upper = accel#if no flick yet, update most recent flick to test\n\t\t\t\treturn 0\n\t\telse:\n\t\t\treturn 0","def is_stationary(self) -> bool:\n ad_fuller_result = adfuller(self.y.dropna(), autolag='AIC')\n p_value = ad_fuller_result[1]\n return p_value <= 0.5","def is_proximal(self):\n return bool(set(self.locations) and set(self.locations) <= set(StandardTerminology.PROXIMAL_LOCATIONS)) \\\n or bool(self.depth and self.depth > 82)","def check_availibity(self, starts_at: datetime.datetime, ends_at: datetime.datetime):\n for unavailable in self.unavailable:\n if unavailable[0] <= starts_at <= unavailable[1]:\n return False\n if unavailable[0] <= ends_at <= unavailable[1]:\n return False\n return True","def signal_hammer(icu, icu_slope, hammer_icu, hammer_slope):\n\n return (icu > hammer_icu and icu_slope > 0) or (icu_slope > hammer_slope)","def degenerate(self):\n return self.radius == 0.0","def is_final_interval(self):\n return self.increasing_cover_relations() == []","def is_legal(self, start, end) -> bool:\n return self.board(end) == 0 \\\n and self.board(start) > 0 \\\n and self._check_zone_locks(start, end) \\\n and self.exists_path(start, end)","def has_warning(self):\n \n if self['n_madloop_calls'] > 0:\n fraction = self['exceptional_points']/float(self['n_madloop_calls'])\n else:\n fraction = 0.0\n \n if self['skipped_subchannel'] > 0:\n return True\n elif fraction > 1.0e-4:\n return True\n else:\n return False"],"string":"[\n \"def is_cruising(altitude, cruise_altitude=None):\\n if cruise_altitude is None:\\n cruise_altitude = closest_cruising_altitude(altitude)\\n return abs(altitude - cruise_altitude) <= 200\",\n \"def check_altitude_at(self, altim, coords, altitude_bounds):\\n altitude = altim.mesh.point_altitude(coords)\\n self.assertWithin(altitude, *altitude_bounds)\",\n \"def is_elevation(self):\\n return not self._is_depth\",\n \"def is_upper(self):\\n return self.z < 0\",\n \"def is_slope(self):\\n\\t\\tif self.high_elevation != self.low_elevation:\\n\\t\\t\\treturn True\\n\\t\\treturn False\",\n \"def test_is_mountain_in_range(self):\\n self.assertTrue(self.user_location.is_mountain_in_range(self.mountain_one))\\n self.assertFalse(self.user_location.is_mountain_in_range(self.mountain_two))\",\n \"def base_failure(self, uncertainty):\\n return False\\n rpos = self.sim.getAgentPosition(self.robot_num)\\n gpos = self.overall_robot_goal\\n if ((rpos[0]-gpos[0])**2 + (rpos[1]-gpos[1])**2)**0.5 <= \\\\\\n self.sim.getAgentRadius(self.robot_num):\\n return True\\n elif (rpos[0] > gpos[0]):\\n return True\\n else:\\n return False\\n self.uncertainties[self.uncertainty_ind] = uncertainty\\n self.uncertainty_ind = (self.uncertainty_ind + 1 )%len(\\n self.uncertainties)\\n # 0.004 is a hard-coded threshold for now that was determined by\\n # analyzing multiple barge-in runs.\\n return utils.avg(self.uncertainties) > 0.004\",\n \"def sanity_check(self):\\n res = True\\n res = res and self.detected\\n res = res and np.sum(self.diffs) < 30000 # experimental value\\n return res\",\n \"def __isFarFromLevel(self, l):\\n\\n s = np.mean(self.df['high'] - self.df['low'])\\n return np.sum([abs(l-x) < s for x in self.levels]) == 0\",\n \"def is_equidistant(self) -> bool:\\n if len(self.time) < 3:\\n return True\\n return len(self.time.to_series().diff().dropna().unique()) == 1\",\n \"def air_range(self) -> Union[int, float]:\\n return self.air_weapon and self.air_weapon.range\",\n \"def f_has_range(self):\\n return len(self._explored_range) > 0\",\n \"def is_tachycardic(self, hr):\\n lower_bound = self.tachycardic_range()\\n return hr > lower_bound\",\n \"def classify_altitude_profile(altitudes):\\n max_alt = altitudes.max()\\n has_climb = (max_alt > altitudes[0])\\n has_descent = (max_alt > altitudes[-1])\\n\\n if has_climb or has_descent:\\n if has_climb != has_descent:\\n return AltitudeProfileType.CLIMBING if has_climb \\\\\\n else AltitudeProfileType.DESCENDING\\n else:\\n return AltitudeProfileType.CLIMBING_AND_DESCENDING\\n else:\\n return AltitudeProfileType.CRUISING\",\n \"def altitude(self):\\n if self.__altitude:\\n return sum(self.__altitude) / len(self.__altitude)\\n else:\\n return -9999\",\n \"def check(self):\\n self.lower_bound(5e-4)\\n self.upper_bound(5e2)\",\n \"def isGeostationary(sat):\\n minAlt = minAz = float('inf')\\n maxAlt = maxAz = -float('inf')\\n\\n epochDt = sat.epoch.utc_datetime()\\n startDt = epochDt - timedelta(hours=24)\\n endDt = epochDt + timedelta(hours=24)\\n\\n dt = startDt\\n while dt <= endDt:\\n t = ts.from_datetime(dt)\\n alt, az, _ = (sat - sofia).at(t).altaz()\\n alt = alt.degrees\\n az = az.degrees\\n if alt < minAlt:\\n minAlt = alt\\n if alt > maxAlt:\\n maxAlt = alt\\n if az < minAz:\\n minAz = az\\n if az > maxAz:\\n maxAz = az\\n dt += timedelta(hours=1)\\n return maxAlt - minAlt < 1 and maxAz - minAz < 1\",\n \"def lux_above_threshold(self) -> bool:\\n if self.lux_sensor:\\n value = self.hass.get_state(self.lux_sensor)\\n if value not in [\\\"unavailable\\\", \\\"unknown\\\"]:\\n return float(value) > self.lux_threshold\\n\\n return False\",\n \"def _isInAllowedRange( self, testval, refval, reltol=1.e-2 ):\\n denom = refval\\n if refval == 0:\\n if testval == 0:\\n return True\\n else:\\n denom = testval\\n rdiff = (testval-refval)/denom\\n del denom,testval,refval\\n return (abs(rdiff) <= reltol)\",\n \"def check_heated_up(error):\\n error = np.array(error)\\n error = np.abs(error)\\n if len(error) < 30 or sum(error[-30:-1]) > 15:\\n return False\\n else:\\n return True\",\n \"def isHittingLow(self):\\n return not self.limLow.get()\",\n \"def altitude_range(self, start_distance, finish_distance):\\n start_index, start_ratio = calculate_value_reference(self.distances,\\n start_distance)\\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\\n finish_index, finish_ratio = calculate_value_reference(self.distances,\\n finish_distance)\\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\\n\\n min_alt = min(start_alt, finish_alt)\\n max_alt = max(start_alt, finish_alt)\\n\\n if start_index < finish_index:\\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\\n min_alt = min(min_alt, altitudes.min())\\n max_alt = max(max_alt, altitudes.max())\\n\\n return min_alt, max_alt\",\n \"def _has_noise(self) -> bool:\\n min = self.array.min()\\n max = self.array.max()\\n near_min, near_max = np.percentile(self.array, [0.5, 99.5])\\n max_is_extreme = max > near_max * 1.25\\n min_is_extreme = (min < near_min * 0.75) and (\\n abs(min - near_min) > 0.1 * (near_max - near_min)\\n )\\n return max_is_extreme or min_is_extreme\",\n \"def is_inequality(self):\\n return True\",\n \"def is_inequality(self):\\n return True\",\n \"def determine_azel_are_safe(_az, _el):\\n if _az and _el:\\n return True\",\n \"def check_rpt_status(self) -> bool:\\n return self.allele == self.fasta_alt\",\n \"def check_convergency(self):\\n if self.vars['ema_trace'][self.vars['step']] <= self.settings[\\\"emaSpeedTol\\\"]:\\n return True\\n else:\\n return False\",\n \"def is_inequality(self):\\n return False\",\n \"def is_aux_heat_on(self):\\n return self._device.mode == self._device.MODE_HEAT_EMERGENCY\",\n \"def feasible(self):\\n return self.lowBound <= self._value <= self.upBound\",\n \"def valid_trip(self):\\n if self.pickupcoords is None or self.dropoffcoords is None:\\n return False\\n valid = lambda x, y: 41 < x < 43.5 and -72.5 < y < - 70.5\\n return valid(self.pickupcoords[0], self.pickupcoords[1]) and valid(self.dropoffcoords[0], self.dropoffcoords[1])\",\n \"def has_compatible_ligands(self, identity):\\n return ((len(self.bad_coords[identity]) == 0) and\\n (not self.BAD_COORD_RESIDUE in self.inaccuracies[identity]))\",\n \"def is_interior(r0, r1, abs_tol=ABS_TOL):\\n if isinstance(r0, Polytope):\\n r0 = Region([r0])\\n if isinstance(r1, Polytope):\\n r1 = Region([r1])\\n for p in r1:\\n A = p.A.copy()\\n b = p.b.copy() + abs_tol\\n dummy = Polytope(A, b)\\n if not dummy <= r0:\\n return True\\n return False\",\n \"def ground_range(self) -> Union[int, float]:\\n return self.ground_weapon and self.ground_weapon.range\",\n \"def isRangeValid(self) -> bool:\\n ...\",\n \"def is_almost_active(self,\\n env\\n ):\\n if not hasattr(self, \\\"tolerance\\\") or self.tolerance is None:\\n return False\\n c_value = self.get_value(env)\\n flag = np.any(np.greater(c_value + self.tolerance, 0.))\\n return bool(flag)\",\n \"def has_undercoordinated_metal(self):\\n return self._has_low_metal_coordination()\",\n \"def in_valid_range(self, string):\\n fret_number = self.cursor.get_frets()[string]\\n return (\\n (self.min_x <= fret_number <= self.max_x) or\\n (self.allow_open and fret_number == self.guitar.min_fret)\\n )\",\n \"def altitude_callback(self, data):\\n self.altitude = data\\n self.altitude_bottom_clearance = np.float64(data.bottom_clearance)\\n if np.isnan(self.altitude_bottom_clearance):\\n # message is often enough that it should alert the user but shouldn't swamp the console\\n rospy.logwarn_throttle(0.5, 'bottom clearance is invalid type: {}'.format(self.altitude_bottom_clearance))\",\n \"def isstationary(self):\\n if np.all(np.abs(self.arroots) > 1.0):\\n return True\\n else:\\n return False\",\n \"def validRange(line):\\n line_col = str.split(line)\\n chrom = line_col[0]\\n pos = line_col[1]\\n# any(lower <= postcode <= upper for (lower, upper) in [(1000, 2249), (2555, 2574), ...])\\n if any(float(low) <= float(pos) <= float(high) for (low,high) in TE_ranges[chrom]):\\n return False\\n return True\",\n \"def is_leech(self, meta: \\\"CardMeta\\\") -> bool:\\n if len(meta.past_quality) < LEECH_MIN_QUALITY:\\n return False\\n return (\\n meta.past_quality[-1] < BAD_QUALITY_THRESHOLD\\n and meta.past_quality[-2] < BAD_QUALITY_THRESHOLD\\n and meta.past_quality[-3] < BAD_QUALITY_THRESHOLD\\n )\",\n \"def is_inequality(self): \\n return False\",\n \"def is_cis(self):\\n prev_res = self.get_offset_residue(-1)\\n if prev_res is None:\\n return None\\n\\n prev_omega = prev_res.calc_torsion_omega()\\n if prev_omega is None:\\n return None\\n\\n if abs(prev_omega) <= (math.pi/2.0):\\n return True\\n\\n return False\",\n \"def is_lower_limit(self):\\n is_lower = self.get_raw_status() & self.STATUS_LLIM\\n return bool(is_lower)\",\n \"def is_valid(self):\\n posit1 = (self.mean_v > 0) & (self.kappa_y > 0) & (self.eta_y > 0)\\n posit2 = (self.kappa_s > 0) & (self.eta_s > 0)\\n return posit1 & posit2 & self.feller()\",\n \"def set_altitude(self):\\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\\n print('altitude set to', self.altitude)\\n if self.altitude < 0:\\n self.altitude = self.altitude + 360.0\\n return self.altitude \\n else: \\n pass\\n return self.altitude\",\n \"def is_exceptional(self):\\n G = self.poset().hasse_diagram()\\n for x in G:\\n nx = list(G.neighbors_out(x))\\n nx.append(x)\\n if min(nx) < x and max(nx) > x:\\n return False\\n return True\",\n \"def exit_indicator(self, feats):\\n pos = self.portfolio.portfolio_handler.filled_positions[\\\"ARNC\\\"]\\n d = pos.direction\\n return (\\n (feats[\\\"z-score\\\"] > -0.5 and d == Directions.long_dir) or\\n (feats[\\\"z-score\\\"] < 0.5 and d == Directions.short_dir)\\n )\",\n \"def closest_cruising_altitude(altitude):\\n return 1000 * ((altitude + 500) // 1000)\",\n \"def isLow(self):\\n\\t\\treturn self.resolution == 'LOW'\",\n \"def is_valid(self):\\n if len(self.exterior) < 3:\\n return False\\n return self.to_shapely_polygon().is_valid\",\n \"def _exceeds_critical_angle(angle: float, s0: float, s1: float) -> bool:\\n if s1 > s0: # if the second speed is faster, there is a critical angle\\n critical_angle = get_critical_angle(s0, s1)\\n if abs(angle) >= critical_angle:\\n return True\\n return False\",\n \"def steadyYet(newg, oldg, newe, olde, newh, oldh, newf, oldf, tolerance):\\n steady_yet = True\\n if oldg == 0 or (abs(newg-oldg)/oldg > tolerance or\\n abs(newe-olde)/olde > tolerance or\\n abs(newh-oldh)/oldh > tolerance or\\n abs(newf-oldf)/oldf > tolerance):\\n steady_yet = False\\n return steady_yet\",\n \"def is_hermitian(self, eps = 0):\\n return (self - self.hc()).absmax() <= eps\",\n \"def is_upper_limit(self):\\n is_upper = self.get_raw_status() & self.STATUS_ULIM\\n return bool(is_upper)\",\n \"def is_achromatic(self) -> bool:\\n\\n value = self._space.is_achromatic(self.coords(nans=False))\\n if value is None:\\n xyz = self.convert('xyz-d65')\\n return bool(xyz._space.is_achromatic(xyz[:-1]))\\n return value\",\n \"def is_rectal(self):\\n return bool(self.locations and set(self.locations) <= set(StandardTerminology.RECTAL_LOCATIONS)) \\\\\\n or bool(self.depth and 4 <= self.depth <= 16)\",\n \"def is_distal(self):\\n return bool(set(self.locations) and set(self.locations) <= set(StandardTerminology.DISTAL_LOCATIONS)) \\\\\\n or bool(self.depth and 16 < self.depth < 82)\",\n \"def is_east(longitudes):\\n return np.asarray(longitudes, dtype=\\\"d\\\") <= 0.\",\n \"def ValidClusterRanges(self):\\n for cluster_range in self.cluster_ranges:\\n the_range = cluster_range.split(\\\"-\\\")\\n print(f\\\"Checking that range {the_range} falls within our data area\\\")\\n try:\\n if int(the_range[0]) < self.low_data_cluster or int(the_range[1]) > self.high_data_cluster:\\n print(f\\\"False. {the_range[0]} or {the_range[1]} is outside of our data area\\\")\\n return False\\n except TypeError as t_err:\\n print(f\\\"Error. Range does not appear to be an int\\\")\\n return False\\n return True\",\n \"def is_from_inertial(self, freq_threshold: float = 0.05) -> bool:\\n self = cast(\\\"Flight\\\", self)\\n\\n if \\\"compute_track\\\" not in self.data.columns:\\n self = self.cumulative_distance(compute_gs=False)\\n\\n freq = (\\n self.diff(\\\"compute_track\\\")\\n .compute_track_diff.round()\\n .value_counts(normalize=True)\\n )\\n if 90 not in freq.index or -90 not in freq.index:\\n return False\\n return ( # type: ignore\\n freq[90] > freq_threshold and freq[-90] > freq_threshold\\n )\",\n \"def hasLow(self):\\n\\t\\treturn self.toLow().exists\",\n \"def altitude(self):\\r\\n pressure = self.pressure # in Si units for hPascal\\r\\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))\",\n \"def _check_large_tilt(self):\\n large_tilt = []\\n xy, xz, yz = self.tilt_factors\\n x,y,_ = self.cell_lengths\\n\\n large_tilt.append(-x/2<xy<x/2)\\n large_tilt.append(-x/2<xz<y/2)\\n large_tilt.append(-x/2<yz<y/2)\\n return not all(large_tilt)\",\n \"def calibrateElevation(self,elevation):\\n if len(self.values) == self.values.maxlen:\\n self.elevcomp = self.value / ((1.0 - ((elevation + self.heightAboveGround) * 0.3048 / 44330.0)) ** 5.255)\\n self.calibrated = True\\n else:\\n self.calibratedElevation = elevation\",\n \"def looks_azimuth(self) -> Optional[int]:\\n return self._get_property(LOOKS_AZIMUTH_PROP, int)\",\n \"def isGE(self, a : float, b : float) -> bool:\\n return (a >= b - self.tol * max(abs(a), abs(b), 1.0)) #and (a >= b - 0.1)\",\n \"def inRegion(self, pulsar):\\n # check if l, b are outside region first of all\\n if pulsar.gl>180.:\\n pulsar.gl -= 360.\\n if pulsar.gl > self.GLmax or pulsar.gl < self.GLmin:\\n return False\\n if math.fabs(pulsar.gb) > self.GBmax or math.fabs(pulsar.gb) < self.GBmin:\\n return False\\n\\n # need to compute ra/dec of pulsar from the l and b (galtfeq)\\n ra, dec = go.lb_to_radec(pulsar.gl, pulsar.gb)\\n\\n # are ra, dec outside region?\\n if ra > self.RAmax or ra < self.RAmin:\\n return False\\n if dec > self.DECmax or dec < self.DECmin:\\n return False\\n \\n # randomly decide if pulsar is in completed area of survey\\n if random.random() > self.coverage:\\n return False\\n \\n return True\",\n \"def sun_is_down(check_time, observatory):\\n sun = get_sun(check_time).transform_to(AltAz(obstime=check_time, location=observatory))\\n return sun.alt.value < -14\",\n \"def _in_interval(value, low, up):\\n if low <= value <= up:\\n return True\\n else:\\n return False\",\n \"def test_triangle_get_shortest_altitude(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)\",\n \"def maybe_rectal(self):\\n return bool(set(self.locations) & set(StandardTerminology.RECTAL_LOCATIONS))\",\n \"def refinement_func_area(tri_points, area):\\r\\n max_area = 0.005\\r\\n return bool(area > max_area)\",\n \"def filter_altitude(self, gps_data, setting=None, threshold=None):\\n\\n # New filter settings if provided\\n if setting is not None:\\n self.gps_altitude_filter = setting\\n if setting == 'Manual':\\n self.gps_altitude_filter_change = threshold\\n\\n # Set threshold for Auto\\n if self.gps_altitude_filter == 'Auto':\\n self.gps_altitude_filter_change = 3\\n\\n # Set all data to valid\\n self.valid_data[3, :] = True\\n # self.valid_data[5, :] = True\\n\\n # Manual or Auto is selected, apply filter\\n if not self.gps_altitude_filter == 'Off':\\n # Initialize variables\\n num_valid_old = np.sum(self.valid_data[3, :])\\n k = 0\\n change = 1\\n # Loop until no change in the number of valid ensembles\\n while k < 100 and change > 0.1:\\n # Compute mean using valid ensembles\\n alt_mean = np.nanmean(gps_data.altitude_ens_m[self.valid_data[1, :]])\\n\\n # Compute difference for each ensemble\\n diff = np.abs(gps_data.altitude_ens_m - alt_mean)\\n\\n # Mark invalid those ensembles with differences greater than the change threshold\\n self.valid_data[3, diff > self.gps_altitude_filter_change] = False\\n k += 1\\n num_valid = np.sum(self.valid_data[3, :])\\n change = num_valid_old - num_valid\\n\\n # Combine all filter data to composite valid data\\n self.valid_data[0, :] = np.all(self.valid_data[1:, :], 0)\\n self.num_invalid = np.sum(self.valid_data[0, :] == False)\",\n \"def check_for_residue_existance(self):\\n if not self.pose.total_residue():\\n print \\\"No pose Loaded.\\\"\\n return False\\n\\n if not self.current_chain.get() or not self.current_residue.get():\\n print \\\"Chain or residue not set\\\"\\n return False\\n\\n current_region = self.current_residue.get().split(\\\":\\\")\\n if len(current_region)>1:\\n ResStart = int(current_region[0]); ResEnd = int(self.current_region[1])\\n\\n\\n if self.pose.pdb_info().pdb2pose(self.current_chain.get(), ResStart)==0 or self.pose.pdb_info().pdb2pose(self.current_chain.get(), ResEnd)==0:\\n print \\\"Region not found in pose\\\"\\n return False\\n else:\\n if self.pose.pdb_info().pdb2pose(self.current_chain.get(), int(self.current_residue.get())) ==0:\\n\\n print \\\"Residue not found in pose\\\"\\n return False\\n\\n #If everythig is good then:\\n return True\",\n \"def bad_ceiling(ceiling,minimum):\\n # Implement this function\\n\\n result = False\\n \\n if ceiling == 'clear':\\n result = False\\n \\n elif ceiling == 'unavailable':\\n result = True\\n \\n elif len(ceiling) == 1:\\n\\n if ceiling[0]['units'] == 'FT': \\n if ceiling[0]['height'] < minimum and (ceiling[0]['type'] == 'broken' or ceiling[0]['type'] == 'overcast' or ceiling[0]['type'] == 'indefinite ceiling'):\\n result = True\\n \\n elif len(ceiling) > 1:\\n\\n if ceiling[0]['units'] == 'FT': \\n for x in range(len(ceiling)):\\n if ceiling[x]['height'] < minimum and (ceiling[x]['type'] == 'broken' or ceiling[x]['type'] == 'overcast' or ceiling[x]['type'] == 'indefinite ceiling'):\\n result = True\\n else:\\n result = False\\n \\n return result\",\n \"def shrink(self,altRange=None,aziRange=None):\\n\\n if altRange is None and aziRange is None: raise LookupError('At least one of altRange and aziRange should be defined!')\\n\\n if altRange is not None: indAlt = np.logical_and(self.data['altitude']>=altRange[0],self.data['altitude']<=altRange[1])\\n else: indAlt = np.ones(len(self.data),dtype=np.bool)\\n if aziRange is not None: indAzi = np.logical_and(self.data['azimuth']>=aziRange[0],self.data['azimuth']<=aziRange[1])\\n else: indAzi = np.ones(len(self.data),dtype=np.bool)\\n ind = np.logical_and(indAlt,indAzi)\\n self.data = self.data[ind]\",\n \"def isUndefinedRange(program: ghidra.program.model.listing.Program, startAddress: ghidra.program.model.address.Address, endAddress: ghidra.program.model.address.Address) -> bool:\\n ...\",\n \"def check_masked(self):\\n if self._alternate == 'N': # If our alternate allele is masked, or an 'N'\\n return True # Return True\\n else: # Otherwise\\n return False # Return False\",\n \"def _reached_temperature_end_point(self, T, Tend):\\n if Tend is None:\\n # End point not give\\n return False\\n\\n if self._integration_direction == \\\"increasing\\\":\\n if T > Tend:\\n return True\\n elif self._integration_direction == \\\"decreasing\\\":\\n if T < Tend:\\n return True\\n return False\",\n \"def has_uav_reached_current_waypoint(self):\\n return self.drone.has_reached_waypoint()\",\n \"def deceived(self, a):\\n try:\\n n = self.control[a.name][0]\\n if hardrule:\\n return self.nsucc(a) > self.succ(a) + epsilonD and \\\\\\n (n > 5) and ((self.world.round - n) > 5) \\n else:\\n return (n > 5) and ( (a.successRate > self.succ(a) + epsilonD) or \\\\\\n (a.successRate < epsilonD))\\n except KeyError:\\n raise AssertionError, str(a) + \\\" is not a non-MI!\\\"\",\n \"def is_aux_heat(self) -> bool | None:\\n return self._aux\",\n \"def __check_total_duration(self, duration: int) -> bool:\\n available_duration = N_EIGHTHS_PER_MEASURE * (self.n_measures - 1)\\n return self.current_time_in_eighths + duration <= available_duration\",\n \"def yaw_stop(self):\\n return self.yaw > config.YAW_MAX or self.yaw < -config.YAW_MAX\",\n \"def is_grasping(self, threshold=80):\\n gripper_value = self.vacuum_sensor.state()\\n if rospy.get_param('verbose'):\\n rospy.loginfo('Current vacuum value: {}'.format(gripper_value))\\n if gripper_value > self.GRIP_MAX_VALUE:\\n raise ValueError('Detected unsafe vacuum value of {}.'.format(gripper_value))\\n return gripper_value > threshold\",\n \"def anamoly_detec(self,data):\\r\\n\\t\\tp = (1/(((2*math.pi)**0.5)* self.sig)) * np.prod(np.exp(-((data - self.mu)**2)/( 2 * self.sig**2)))\\r\\n\\t\\tif p >= self.epsilon:\\r\\n\\t\\t\\treturn False\\r\\n\\t\\telse:\\r\\n\\t\\t\\treturn True\",\n \"def testLowerBound(self,time,accel):\\n\\t\\tif (time - self.timestamp) > ParserSettings.TIME_DELTA:#tests lockout threshold of a flick event\\n\\t\\t\\tif accel > self.lower:#tests to see if the flick maximum is met yet, relative to the previous magnitude\\n\\t\\t\\t\\tself.timestamp \\t= time#set appropriate values when flick triggered\\n\\t\\t\\t\\ttoReturn \\t\\t= self.lower\\n\\t\\t\\t\\tself.lower\\t \\t= 0#reset flick for next magnitude test\\n\\t\\t\\t\\treturn toReturn\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.lower = accel#if no flick yet, update most recent flick to test\\n\\t\\t\\t\\treturn 0\\n\\t\\telse:\\n\\t\\t\\treturn 0\",\n \"def isInAera(self):\\n opp = self.get_opponent\\n for players in opp:\\n if (players.distance(self.playerPos)<10):\\n return True\\n return False\",\n \"def testUpperBound(self,time,accel):\\n\\t\\tif (time - self.timestamp) > ParserSettings.TIME_DELTA:#tests lockout threshold of a flick event\\n\\t\\t\\tif accel < self.upper:#tests if flick maximum is found, relative to previous magnitude\\n\\t\\t\\t\\tself.timestamp\\t= time#once peak found, set appropriate data and return a flick\\n\\t\\t\\t\\ttoReturn\\t\\t= self.upper\\n\\t\\t\\t\\tself.upper\\t\\t= 0\\n\\t\\t\\t\\treturn toReturn\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.upper = accel#if no flick yet, update most recent flick to test\\n\\t\\t\\t\\treturn 0\\n\\t\\telse:\\n\\t\\t\\treturn 0\",\n \"def is_stationary(self) -> bool:\\n ad_fuller_result = adfuller(self.y.dropna(), autolag='AIC')\\n p_value = ad_fuller_result[1]\\n return p_value <= 0.5\",\n \"def is_proximal(self):\\n return bool(set(self.locations) and set(self.locations) <= set(StandardTerminology.PROXIMAL_LOCATIONS)) \\\\\\n or bool(self.depth and self.depth > 82)\",\n \"def check_availibity(self, starts_at: datetime.datetime, ends_at: datetime.datetime):\\n for unavailable in self.unavailable:\\n if unavailable[0] <= starts_at <= unavailable[1]:\\n return False\\n if unavailable[0] <= ends_at <= unavailable[1]:\\n return False\\n return True\",\n \"def signal_hammer(icu, icu_slope, hammer_icu, hammer_slope):\\n\\n return (icu > hammer_icu and icu_slope > 0) or (icu_slope > hammer_slope)\",\n \"def degenerate(self):\\n return self.radius == 0.0\",\n \"def is_final_interval(self):\\n return self.increasing_cover_relations() == []\",\n \"def is_legal(self, start, end) -> bool:\\n return self.board(end) == 0 \\\\\\n and self.board(start) > 0 \\\\\\n and self._check_zone_locks(start, end) \\\\\\n and self.exists_path(start, end)\",\n \"def has_warning(self):\\n \\n if self['n_madloop_calls'] > 0:\\n fraction = self['exceptional_points']/float(self['n_madloop_calls'])\\n else:\\n fraction = 0.0\\n \\n if self['skipped_subchannel'] > 0:\\n return True\\n elif fraction > 1.0e-4:\\n return True\\n else:\\n return False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71779066","0.61347663","0.6049398","0.59661514","0.59199977","0.58426267","0.5821014","0.57130736","0.5702021","0.5696651","0.56564146","0.56514233","0.564707","0.56175345","0.560205","0.5593734","0.5585223","0.5575167","0.5550343","0.5514078","0.54926586","0.5490992","0.5487547","0.54849964","0.54849964","0.5461481","0.5446876","0.54234415","0.5415299","0.5408245","0.5408228","0.53996134","0.5386868","0.5385375","0.5384885","0.53650874","0.5365009","0.534702","0.5331876","0.5325387","0.5321634","0.5281765","0.527403","0.52698946","0.5266419","0.5264169","0.52602077","0.52579415","0.52553385","0.52490264","0.52484196","0.5246474","0.5237411","0.52300894","0.5220554","0.5215765","0.52091837","0.52081823","0.5206209","0.5205127","0.5187332","0.5186684","0.5185012","0.5181829","0.5178522","0.51710397","0.5159023","0.51581234","0.5155172","0.51460415","0.51424444","0.5138042","0.5127604","0.51272625","0.5116088","0.51127166","0.510738","0.51057774","0.51051074","0.509956","0.5097982","0.50949854","0.50873667","0.5085239","0.5081191","0.5062832","0.5050432","0.50496304","0.50482476","0.5045511","0.50444466","0.50367194","0.50364774","0.50338405","0.50310016","0.50304854","0.5027627","0.50271666","0.5023024","0.5013348"],"string":"[\n \"0.71779066\",\n \"0.61347663\",\n \"0.6049398\",\n \"0.59661514\",\n \"0.59199977\",\n \"0.58426267\",\n \"0.5821014\",\n \"0.57130736\",\n \"0.5702021\",\n \"0.5696651\",\n \"0.56564146\",\n \"0.56514233\",\n \"0.564707\",\n \"0.56175345\",\n \"0.560205\",\n \"0.5593734\",\n \"0.5585223\",\n \"0.5575167\",\n \"0.5550343\",\n \"0.5514078\",\n \"0.54926586\",\n \"0.5490992\",\n \"0.5487547\",\n \"0.54849964\",\n \"0.54849964\",\n \"0.5461481\",\n \"0.5446876\",\n \"0.54234415\",\n \"0.5415299\",\n \"0.5408245\",\n \"0.5408228\",\n \"0.53996134\",\n \"0.5386868\",\n \"0.5385375\",\n \"0.5384885\",\n \"0.53650874\",\n \"0.5365009\",\n \"0.534702\",\n \"0.5331876\",\n \"0.5325387\",\n \"0.5321634\",\n \"0.5281765\",\n \"0.527403\",\n \"0.52698946\",\n \"0.5266419\",\n \"0.5264169\",\n \"0.52602077\",\n \"0.52579415\",\n \"0.52553385\",\n \"0.52490264\",\n \"0.52484196\",\n \"0.5246474\",\n \"0.5237411\",\n \"0.52300894\",\n \"0.5220554\",\n \"0.5215765\",\n \"0.52091837\",\n \"0.52081823\",\n \"0.5206209\",\n \"0.5205127\",\n \"0.5187332\",\n \"0.5186684\",\n \"0.5185012\",\n \"0.5181829\",\n \"0.5178522\",\n \"0.51710397\",\n \"0.5159023\",\n \"0.51581234\",\n \"0.5155172\",\n \"0.51460415\",\n \"0.51424444\",\n \"0.5138042\",\n \"0.5127604\",\n \"0.51272625\",\n \"0.5116088\",\n \"0.51127166\",\n \"0.510738\",\n \"0.51057774\",\n \"0.51051074\",\n \"0.509956\",\n \"0.5097982\",\n \"0.50949854\",\n \"0.50873667\",\n \"0.5085239\",\n \"0.5081191\",\n \"0.5062832\",\n \"0.5050432\",\n \"0.50496304\",\n \"0.50482476\",\n \"0.5045511\",\n \"0.50444466\",\n \"0.50367194\",\n \"0.50364774\",\n \"0.50338405\",\n \"0.50310016\",\n \"0.50304854\",\n \"0.5027627\",\n \"0.50271666\",\n \"0.5023024\",\n \"0.5013348\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58846647"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":91977,"cells":{"query":{"kind":"string","value":"Find pairs of start/finish indicies of consecutive altitudes with the same value. I.e. where an aircraft was in level flight."},"document":{"kind":"string","value":"def find_level_sections(alts):\n # Get the indicies of positions at the starts and end of levels\n level_indicies = []\n\n if len(alts) > 2:\n prev_alt = alts[0]\n alt = alts[1]\n\n # If the first two altitudea are the same, mark as is_level\n is_level = (prev_alt == alt)\n if is_level:\n level_indicies.append(0)\n\n for index in range(1, len(alts) - 1):\n next_alt = alts[index + 1]\n if is_level:\n # ignore single values at a different altitude\n is_level = (alt == next_alt)\n if not is_level: # no longer is_level\n # note the end cruise index\n level_indicies.append(index)\n else: # was not is_level\n is_level = (alt == next_alt)\n if is_level:\n # note the start cruise index\n level_indicies.append(index)\n\n # advance altitudes\n alt = next_alt\n prev_alt = alt\n\n # Ensure end is recorded if is_level\n if is_level:\n level_indicies.append(len(alts) - 1)\n\n return level_indicies"},"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 intersection_distances(self, altitude, start_distance, finish_distance):\n distances = []\n alt_index, alt_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, alt_index, alt_ratio)\n\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n while alt_index < finish_index:\n next_index = alt_index + 1\n next_ratio = 0.0\n next_alt = calculate_value(self.altitudes, next_index, next_ratio)\n\n # Does this section span the given altitude?\n if (next_alt != start_alt) and \\\n (min(start_alt, next_alt) < altitude < max(start_alt, next_alt)):\n delta = altitude - start_alt\n denom = next_alt - start_alt\n ratio = delta / denom\n distance = calculate_value(self.distances, alt_index, ratio)\n distances.append(distance)\n\n alt_index = next_index\n alt_ratio = next_ratio\n start_alt = next_alt\n\n if finish_ratio:\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n # Does the last section span the given altitude?\n if (start_alt != finish_alt) and \\\n (min(start_alt, finish_alt) < altitude < max(start_alt, finish_alt)):\n # Calculate the altitude at the end of the section to maximimse accuracy\n next_alt = calculate_value(self.altitudes, finish_index, 1.0)\n delta = altitude - start_alt\n denom = next_alt - start_alt\n ratio = delta / denom\n distance = calculate_value(self.distances, alt_index, ratio)\n distances.append(distance)\n\n return distances","def altitude_range(self, start_distance, finish_distance):\n start_index, start_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n\n min_alt = min(start_alt, finish_alt)\n max_alt = max(start_alt, finish_alt)\n\n if start_index < finish_index:\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\n min_alt = min(min_alt, altitudes.min())\n max_alt = max(max_alt, altitudes.max())\n\n return min_alt, max_alt","def startEndPoints(mazz):\n for i in range (len(mazz)):\n for j in range (len(mazz[i])):\n if mazz[i][j] == 6:\n startx = i\n starty = j\n elif mazz[i][j] == 7:\n endx = i\n endy = j\n return startx, starty, endx, endy","def find_isolated_endpoints(lines):\n \n isolated_endpoints = []\n count = len(lines)\n print(\"Finding isolated end points 2/3\")\n pb = pbar.ProgressBar(count)\n for i, line in enumerate(lines):\n pb += 1\n other_lines = lines[:i] + lines[i+1:]\n for q in [0,-1]:\n endpoint = Point(line.coords[q])\n if any(endpoint.touches(another_line) \n for another_line in other_lines):\n continue\n else:\n isolated_endpoints.append(endpoint)\n del pb\n return isolated_endpoints","def get_lat_offsets(self):\n\n startlat = self.parameters['startlatitude']\n stoplat = self.parameters['stoplatitude']\n\n #Given the start and stops,\n startidx, startvalue = utils.getnearest(self.latitudes, startlat)\n stopidx, stopvalue = utils.getnearest(self.latitudes, stoplat)\n startidx -= 2\n stopidx += 2\n latslice = np.arange(startidx, stopidx + 1)\n if utils.checkmonotonic(latslice):\n latslice = latslice\n else:\n #TODO: Support pole crossing images\n logger.error('Image is pole crossing, not currently supported.')\n '''\n print \"NOT MONOTONIC\"\n #Handle wraps around the poles\n latslice = np.arange(start_idx, stop_idx + 1)\n nlats = self.startlookup.shape[1]\n greatermask = np.where(latslice >= nlats)\n latslice[greatermask] -= nlats\n lessmask = np.where(latslice < 0)\n latslice[lessmask] += self.startlookup.shape[1]\n\n self.latsort = np.argsort(latslice)\n self.latslice = latslice[self.latsort]\n self.latsort = np.argsort(self.latsort)\n '''\n latslice = None\n logger.debug('Start latitude node is {}. Nearest lookup node is {}.'.format(startlat, startidx))\n logger.debug('Stop latitude node is {}. Nearest lookup node is {}.'.format(stoplat, stopidx))\n return latslice","def create_adjacent_stop_pairs(trips):\n\n stop_pairs = []\n\n sorted_trips = trips.sort_values(\n ['TRIPID', 'PROGRNUMBER']).reset_index(drop=True)\n\n # For each trip match up pairs of adjacent stops and calculate how long it\n # took to travel between them\n for trip_id in sorted_trips['TRIPID'].unique():\n\n # Filter down to just this trip\n trip = sorted_trips[sorted_trips['TRIPID'] ==\n trip_id].sort_values(['TRIPID', 'PROGRNUMBER'])\n\n stop_pairs_trip = trip.copy()\n stop_pairs_trip = stop_pairs_trip.rename(columns={\n 'ACTUALTIME_DEP': 'time_departure',\n 'STOPPOINTID': 'departure_stop'\n })\n\n # arrival stop and time are from the next row\n stop_pairs_trip.loc[:,\n 'arrival_stop'] = stop_pairs_trip.shift(-1).loc[:, 'departure_stop']\n stop_pairs_trip.loc[:,\n 'time_arrival'] = stop_pairs_trip.shift(-1).loc[:, 'ACTUALTIME_DEP']\n stop_pairs_trip['travel_time'] = stop_pairs_trip[\"time_arrival\"] - \\\n stop_pairs_trip[\"time_departure\"]\n\n # Only keep pairs with consecutive PROGRNUMBER\n stop_pairs_trip = stop_pairs_trip[stop_pairs_trip['PROGRNUMBER'] == (\n stop_pairs_trip.shift(-1)['PROGRNUMBER'] - 1)]\n\n # Add it to the DF of all stop pairs\n stop_pairs.append(stop_pairs_trip)\n\n return pd.concat(stop_pairs)","def determine_next_stop(current_location, stops):\n possible_stop = {}\n for stop in stops:\n # calculates the distance between the current location and the next possible stop\n calculated_distance = csv_reader.distance_lookup(current_location, stop)\n\n # adds a key value pair of possible trip (a tuple) and the distance of that trip\n possible_stop[(current_location, stop)] = float(calculated_distance)\n return possible_stop","def find_rpt_coords(self) -> (int, int):\n start_size = self.size\n end_size = self.size + len(self.allele)\n coord = self.coord\n fasta_alt = self.fasta_alt\n while self.allele == fasta_alt:\n coord += len(self.allele)\n start_size += len(self.allele)\n end_size += len(self.allele)\n fasta_alt = self.seq[start_size:end_size]\n new_start = coord - len(self.allele)\n new_end = new_start + len(self.allele) - 1\n return new_start, new_end","def find_cruise_sections(altitudes):\n indicies = find_level_sections(altitudes)\n\n if indicies:\n prev_altitude = altitudes[indicies[0]]\n cruise_altitude = closest_cruising_altitude(prev_altitude)\n was_cruising = is_cruising(prev_altitude, cruise_altitude)\n prev_altitude = cruise_altitude if was_cruising else prev_altitude\n\n merge_indicies = []\n for index in range(2, len(indicies), 2):\n altitude = altitudes[indicies[index]]\n cruise_altitude = closest_cruising_altitude(altitude)\n if is_cruising(altitude, cruise_altitude):\n # If the aircraft cruised between the level ranges,\n if was_cruising and (prev_altitude == cruise_altitude) and \\\n in_cruise_level_range(altitudes[indicies[index - 1] + 1: indicies[index]],\n cruise_altitude):\n # merge the level indicies\n merge_indicies.append(index - 1)\n merge_indicies.append(index)\n\n prev_altitude = cruise_altitude\n was_cruising = True\n else: # level but not at a cruising level\n merge_indicies.append(index)\n merge_indicies.append(index + 1)\n prev_altitude = altitude\n was_cruising = False\n\n # merge the level indicies\n while merge_indicies:\n index = merge_indicies.pop()\n del indicies[index]\n\n return indicies","def _get_marker_indices(marker, line):\n indices = [i for i, ltr in enumerate(line) if ltr == marker]\n start = indices[0:-1:2]\n end = [i + 1 for i in indices[1::2]]\n assert len(start) == len(end)\n return start, end","def consecutive_sections(): # noqa: D416","def get_head_and_tail(street):\r\n def is_end(location):\r\n num_adj = 0\r\n adj = get_orthogonal(location)\r\n for merchant in street:\r\n if merchant != location and merchant in adj:\r\n num_adj += 1\r\n return num_adj <= 1\r\n return [loc for loc in street if is_end(loc)]","def longest_flight(self):\r\n distance = 0\r\n for code, _list in self.edges.items():\r\n for edge in _list:\r\n if edge.distance > distance:\r\n distance = edge.distance\r\n start = edge.start\r\n destination = edge.destination\r\n return start, destination, distance","def flightLegs(Alist,start,dest):\n Alen = len(Alist) #length of Alist\n index = list(range(Alen)) #list of airport indexes\n Adict = dict(zip(index,Alist)) #zip into dictionary\n #Adict = dict.fromkeys(range(Alen),large value) possibly qiucker?\n \n Flights = [] #output\n\n checked = [] #empty list\n tocheck = deque() #empty deque for a queue of paths to be checked\n tocheck.append([start])\n \n if start == dest: #trivial case\n return \"trivial case explored\"\n \n while tocheck: #while there are elements in tocheck\n path = tocheck.popleft() #pop out a path to be checked\n node = path[-1] #extract last element of path, this node represents an airport\n if node not in checked: #check if this path terminates in a new node/airport\n adjacents = Adict[node] #look up in dictionary airport index and return list of adjacent airports\n for n in adjacents: #extracts nodes inside list of adjacents\n if n not in checked:\n new_path = path +[n] #add neighbour to this current path\n tocheck.append(new_path) #put this new path into the queue to be checked\n if n == dest: #if this neighbour is the final destination, then the new path is the full path\n if len(Flights)==0:\n Flights.append(new_path)\n elif len(new_path)==len(Flights[-1]):\n Flights.append(new_path)\n else:\n return (len(Flights[0]),len(Flights))\n \n checked.append(node)\n\n return Flights #finds all paths need to modify to stop after a path of non shortest length is found","def _findTangentSplitExisting(self, frames, start, end, step):\n splits = []\n inTangentType = \"step\"\n outTangentType = \"stepnext\"\n\n inAngles = cmds.keyTangent(self.path, query=True, time=(start, end), inAngle=True)\n outAngles = cmds.keyTangent(self.path, query=True, time=(start, end), outAngle=True)\n inTangentTypes = cmds.keyTangent(self.path, query=True, time=(start, end), inTangentType=True)\n outTangentTypes = cmds.keyTangent(self.path, query=True, time=(start, end), outTangentType=True)\n\n iterator = zip(frames, inAngles, outAngles, inTangentTypes, outTangentTypes)\n for frame, inAngle, outAngle, inType, outType in iterator:\n # get closest index\n index = int((frame - start) / step)\n\n # validate split\n if abs(inAngle - outAngle) > THRESHOLD:\n splits.append(index)\n elif inType == inTangentType:\n splits.append(index)\n elif outType == outTangentType:\n splits.append(index)\n\n return splits","def _all_dist_to_end(args):\n idx = args[0]\n spiketrains = args[1]\n start = args[2]\n end = args[3]\n N = args[4]\n num_spiketrains = len(spiketrains)\n distances = []\n for jdx in range(idx+1, num_spiketrains):\n dist = distance(spiketrains[idx], spiketrains[jdx], start, end, N)\n times = dist[0] # should be the same for all\n distances.append(dist[1])\n return times, distances","def identifyPutativeFields(tuning_curve):\r\n\r\n tuning_curve = np.copy(tuning_curve)\r\n tuning_curve = np.around(tuning_curve, decimals=3)\r\n elevated_indices = np.nonzero(tuning_curve)[0]\r\n if len(elevated_indices) == 0:\r\n return [[], []]\r\n\r\n putative_starts = []\r\n putative_ends = []\r\n\r\n putative_start = elevated_indices[0]\r\n\r\n while putative_start is not None:\r\n putative_starts.append(putative_start)\r\n # when does it return to zero?\r\n try:\r\n putative_end = putative_start + np.amin(\r\n np.where(tuning_curve[putative_start:] == 0)) - 1\r\n except ValueError:\r\n # does not return to 0\r\n putative_end = len(tuning_curve) - 1\r\n\r\n putative_ends.append(putative_end)\r\n\r\n try:\r\n putative_start = np.amin(\r\n elevated_indices[elevated_indices > putative_end])\r\n except ValueError:\r\n # no more intervals > 0\r\n putative_start = None\r\n\r\n # correct the wrap-around case\r\n if 0 in putative_starts and len(tuning_curve) - 1 in putative_ends and \\\r\n len(putative_starts) > 1:\r\n putative_starts.pop(0)\r\n putative_ends[-1] = putative_ends.pop(0)\r\n\r\n return putative_starts, putative_ends","def ends_with_lt_tonic(a_list):\n key = a_list.track.bars[0].key\n a, b = a_list.notes[-2:]\n lt, tonic = Note(key).transpose('7', True).name, key.name\n\n if (a.name, b.name) == (lt, tonic) and int(b) - int(a) == 1:\n return []\n else:\n return [a.start, b.start]","def compute_start_end_points(linestrings):\n starts = []\n stops = []\n for ls in linestrings:\n pt = Point(ls.coords[0])\n starts.append(round(CONUS[\"poly\"].exterior.project(pt), 2))\n pt = Point(ls.coords[-1])\n stops.append(round(CONUS[\"poly\"].exterior.project(pt), 2))\n return starts, stops","def count_ranges(a):\n ranges = []\n count = 0\n for i, v in enumerate(a):\n if v == 1: # same as previous value\n count += 1\n else:\n if count > 1:\n ranges.append([i, count]) # [end, length]\n count = 0\n return ranges","def find_ranges(iterable):\n for group in mit.consecutive_groups(iterable):\n group = list(group)\n if len(group) == 1:\n yield [group[0], group[0]]\n else:\n yield [group[0], group[-1]]\n return group","def adjacentPairs(patches, borderWidth=2):\r\n\r\n keyList = patches.keys()\r\n pairKeyList = []\r\n\r\n for pair in combinations(keyList, 2):\r\n patch1 = patches[pair[0]]\r\n patch2 = patches[pair[1]]\r\n\r\n if (ia.is_adjacent(patch1.array, patch2.array, borderWidth=borderWidth)) and (patch1.sign == patch2.sign):\r\n pairKeyList.append(pair)\r\n\r\n return pairKeyList","def scan( gaps, center, dist ):\n return _scan_reverse( gaps, center, dist ), _scan_forward( gaps, center, dist )","def get_steps_between_peaks(self):\n max_x, max_y = self.get_local_maxes()\n full_steps = np.ediff1d(max_x)\n # _full_mean, _full_std = np.mean(full_steps), np.std(full_steps)\n _full_count = len(full_steps)\n\n unique_steps_between_peaks, unique_steps_counts = np.unique(full_steps, return_counts=True)\n\n _filter = np.logical_and(full_steps < unique_steps_between_peaks[np.argmax(unique_steps_counts)] * 1.7,\n full_steps > unique_steps_between_peaks[np.argmax(unique_steps_counts)] * 0.3)\n # 1.7 chosen as filter, as there seems to be another peak ~2* (probably due to single missed peaks)\n # 1.7 avoids the start of the gaussian at 2*\n\n if not _filter.all():\n steps = full_steps[_filter]\n # print(unique_steps_between_peaks[np.argmax(unique_steps_counts)])\n _filtered_count = len(steps)\n _counts = (_full_count, _filtered_count, _full_count - _filtered_count)\n # print('Original Count: %s, Filtered Count: %s, Excluded Count: %s' % _counts)\n # print('Filtered:', full_steps[np.invert(_filter)])\n unique_steps_between_peaks, unique_steps_counts = np.unique(steps, return_counts=True)\n else:\n steps = full_steps\n\n return steps, unique_steps_between_peaks, unique_steps_counts","def get_3away_pairs(kmers):\n k = len(kmers[0])\n if k == 1 or k==2:\n return []\n if k == 3:\n return [pair for pair in combinations(kmers, 2) if pair[0][0] != pair[1][0] and pair[0][1] != pair[1][1] and pair[0][2] != pair[1][2]]\n k_L = k//2\n k_R = k-k_L\n kmer_L_hashes = defaultdict(list)\n kmer_R_hashes = defaultdict(list)\n pairs = []\n kmers_L = []\n kmers_R = []\n for i, kmer in enumerate(kmers):\n kmer_L = kmer[:k_L]\n kmer_R = kmer[k_L:]\n #print(kmer_L)\n #print(kmer_R)\n kmers_L.append(kmer_L)\n kmers_R.append(kmer_R)\n kmer_L_hashes[kmer_to_int(kmer_L)] += [i]\n kmer_R_hashes[kmer_to_int(kmer_R)] += [i]\n for kmer_L_hash in kmer_L_hashes.values(): #same in first half\n if len(kmer_L_hash) > 1:\n kmer_L = kmers[kmer_L_hash[0]][:k_L] #first half\n pairs += [tuple(kmer_L + kmer for kmer in pair) for pair in get_3away_pairs([kmers[i][k_L:] for i in kmer_L_hash])] #differ by 3 in second half\n for kmer_R_hash in kmer_R_hashes.values(): #same in second half\n if len(kmer_R_hash) > 1:\n kmer_R = kmers[kmer_R_hash[0]][k_L:] #second half\n #print(kmer_R)\n pairs += [tuple(kmer + kmer_R for kmer in pair) for pair in get_3away_pairs([kmers[i][:k_L] for i in kmer_R_hash])] #differ by 3 in first half\n possible_pairs = []\n possible_pairs_L = get_1away_pairs(kmers_L)\n possible_pairs_R = get_2away_pairs(kmers_R)\n #print(kmers_L)\n #print(kmers_R)\n #print(possible_pairs_L)\n #print(possible_pairs_R)\n for possible_pair_L in possible_pairs_L:\n for possible_pair_R in possible_pairs_R:\n possible_kmer1 = possible_pair_L[0]+possible_pair_R[0]\n possible_kmer2 = possible_pair_L[1]+possible_pair_R[1]\n if possible_kmer1 in kmers and possible_kmer2 in kmers:\n pairs += [(possible_kmer1, possible_kmer2)]\n possible_pairs = []\n possible_pairs_L = get_2away_pairs(kmers_L)\n possible_pairs_R = get_1away_pairs(kmers_R)\n for possible_pair_L in possible_pairs_L:\n for possible_pair_R in possible_pairs_R:\n possible_kmer1 = possible_pair_L[0]+possible_pair_R[0]\n possible_kmer2 = possible_pair_L[1]+possible_pair_R[1]\n if possible_kmer1 in kmers and possible_kmer2 in kmers:\n pairs += [(possible_kmer1, possible_kmer2)]\n return(pairs)","def find_start_and_end(arr):\n start = None\n end = None\n for i, line in enumerate(arr):\n for j, node in enumerate(line):\n if node.symbol is 'A':\n start = node\n if node.symbol is 'B':\n end = node\n return start, end","def get_hour_offsets(self):\n starttime = self.parameters['startlocaltime']\n stoptime = self.parameters['stoplocaltime']\n timediff = (stoptime - starttime)\n logger.debug(\"Start time: {} | Stop time: {}\".format(starttime, stoptime))\n if timediff > config.TIME_THRESHOLD:\n logger.debug(\"Time delta is {}. This is significantly larger than anticipated\".format(timediff))\n else:\n logger.debug(\"Time delta is {}. Using start time as the global time\".format(timediff))\n\n \"\"\"\n timediff = (stoptime - starttime).total_seconds()\n logger.debug(\"Start time: {} | Stop time: {}\".format(starttime, stoptime))\n #TODO: How do we want to handle large images with huge time differences?\n if timediff > config.TIME_THRESHOLD:\n logger.debug(\"Time delta is {}. This is significantly larger than anticipated\".format(timediff))\n starttime = starttime\n else:\n logger.debug(\"Time delta is {}. Using start time as the global time\".format(timediff))\n \"\"\"\n #Given the image start time, find the nearest index and set to the middle,\n # then find the adjacent two nodes in both directions to get allow a\n # cubic interpolation.\n #image_time = starttime.hour + starttime.minute / 60.0\n # This grabs the hour that is nearest, but hour is circular\n image_time = starttime\n if abs(image_time - 24) < abs(image_time - 23.5):\n image_time -= 24\n mididx, midhour = utils.getnearest(self.times, image_time)\n logger.debug(\"Time is {}. The nearest lookup node is {}\".format(image_time, mididx))\n minidx = mididx - 2\n maxidx = mididx + 2\n\n hourslice = np.arange(minidx, maxidx + 1, dtype=np.int8)\n\n hourslice[hourslice < 0] += 18\n\n if hourslice[-1] >= len(self.times):\n #The hour slice needs to be shifted over the time break\n hourslice[hourslice >= len(self.times)] -= len(self.times)\n logger.debug(\"Using indices {} and start time of {}.\".format(hourslice, image_time))\n return hourslice, image_time","def adjacencies(self, tile, tile_set):\n r, c = tile\n ns = []\n for d, (dr, dc) in self._offsets.items():\n other = (r + dr, c + dc)\n if other in tile_set:\n ns.append((d, other))\n return ns","def find_edges(starting_point, max_dist, hi, lo, bgArray):\n try:\n b = fetch_val(bgArray, starting_point)\n except IndexError:\n return None\n offsets = [(0,1), (1,0), (0,-1), (-1,0)]\n edgePoints = []\n for offset in offsets:\n first_result = find_edge(starting_point, offset, max_dist, hi, lo, bgArray)\n if first_result is not None:\n edgePoints.append(first_result[0])\n if b < lo or b > hi:\n # Try to find second point, since starting click was outside threshold\n second_result = find_edge(first_result[0], offset, max_dist - first_result[1], hi, lo, bgArray)\n if second_result is not None:\n edgePoints.append(second_result[0])\n return edgePoints","def _pair_indices(self):\n indices_src = []\n indices_dst = []\n for i in range(self.walk_len):\n for j in range(max(i - self.l, 0), i):\n indices_src.append(i)\n indices_dst.append(j)\n for j in range(i + 1, min(i + self.r + 1, self.walk_len)):\n indices_src.append(i)\n indices_dst.append(j)\n return indices_src, indices_dst","def entryPair(self):\n exitPair = {}\n deadEnd = self.searchDeadEnd()\n deadPoints = []\n deadRoads = deadEnd.copy()\n for (x,y) in deadEnd:\n # if (x,y) not in deadPoints:\n adjacent = self.scanmap.adjacentValidPoints(x, y)\n BFS = util.Queue()\n visited = []\n BFS.push((x,y))\n while not BFS.isEmpty():\n (i,j) = BFS.pop()\n visited.append((i, j))\n adjacents = self.scanmap.adjacentValidPoints(i,j)\n for position in adjacents:\n if not position in deadRoads:\n exitPoint = position\n if position in deadRoads and not position in visited:\n BFS.push(position)\n if exitPoint in exitPair.keys():\n exitPair[exitPoint] = list(set(visited).union(set(exitPair[exitPoint])))\n else:\n exitPair[exitPoint] = visited\n deadPoints = list(set(deadEnd).difference(set(visited)))\n\n return exitPair","def calculateTrackBetweenFlights(lat1,lon1,lat2,lon2):\n\treturn Geodesic.WGS84.Inverse(lat1,lon1, lat2, lon2)['azi1']","def puzzle2(offsets):\n return find_jumps_to_exit(offsets, lambda o: o + 1 if o < 3 else o - 1)","def get_continous_time_periods(binary_array):\n binary_array = np.copy(binary_array).astype(\"int8\")\n n_times = len(binary_array)\n d_times = np.diff(binary_array)\n # show the +1 and -1 edges\n pos = np.where(d_times == 1)[0] + 1\n neg = np.where(d_times == -1)[0] + 1\n\n if (pos.size == 0) and (neg.size == 0):\n if len(np.nonzero(binary_array)[0]) > 0:\n return [(0, n_times-1)]\n else:\n return []\n elif pos.size == 0:\n # i.e., starts on an spike, then stops\n return [(0, neg[0])]\n elif neg.size == 0:\n # starts, then ends on a spike.\n return [(pos[0], n_times-1)]\n else:\n if pos[0] > neg[0]:\n # we start with a spike\n pos = np.insert(pos, 0, 0)\n if neg[-1] < pos[-1]:\n # we end with aspike\n neg = np.append(neg, n_times - 1)\n # NOTE: by this time, length(pos)==length(neg), necessarily\n h = np.matrix([pos, neg])\n # print(f\"len(h[1][0]) {len(h[1][0])} h[1][0] {h[1][0]} h.size {h.size}\")\n if np.any(h):\n result = []\n for i in np.arange(h.shape[1]):\n if h[1, i] == n_times-1:\n result.append((h[0, i], h[1, i]))\n else:\n result.append((h[0, i], h[1, i]-1))\n return result\n return []","def find_offsets(self):\r\n\r\n #### Begin functionality here\r\n\r\n return()","def calc_distances(marker_list, rf_pairs):\n final_distance = [[marker_list[0], 0]]\n\n for i in range(1, len(marker_list)):\n cur_markers = [marker_list[i-1], marker_list[i]]\n for rf_pair in rf_pairs:\n if rf_pair[0] in cur_markers and rf_pair[1] in cur_markers:\n final_distance.append([cur_markers[1], rf_pairs[rf_pair]])\n break\n return final_distance","def puzzle1(offsets):\n return find_jumps_to_exit(offsets, lambda o: o + 1)","def find_cruise_positions(num_altitudes, cruise_indicies):\n cruise_positions = np.zeros(num_altitudes, dtype=bool)\n\n if cruise_indicies:\n for index in range(0, len(cruise_indicies), 2):\n start = cruise_indicies[index] + 1\n stop = cruise_indicies[index + 1]\n if start < stop:\n cruise_positions[start: stop] = True\n\n return cruise_positions","def get_slopes(timestep):\n pathing_grid = timestep.game_info.start_raw.pathing_grid\n placement_grid = timestep.game_info.start_raw.placement_grid\n terrain_height = timestep.game_info.start_raw.terrain_height\n pathing = bitmap2array(pathing_grid)\n placement = bitmap2array(placement_grid)\n height = bitmap2array(terrain_height)\n\n slopes = []\n for i in range(pathing_grid.size.x):\n for j in range(pathing_grid.size.y):\n if pathing[i, j] == 0 and placement[i, j] == 0:\n slope_item = extract_slope(i, j, pathing, placement, height)\n if slope_item.min_h != slope_item.max_h:\n slopes.append(slope_item)\n return slopes","def get_loop_borders(pdb_hierarchy, center_resnum_list, ss_annot):\n f_start_res_num =-9999\n f_end_res_num = 9999999\n if ss_annot is not None:\n for elem in ss_annot.simple_elements():\n if f_start_res_num < elem.get_end_resseq_as_int() <= hy36decode(4, center_resnum_list[0]):\n # print \" cutting...\"\n f_start_res_num = elem.get_end_resseq_as_int()\n if hy36decode(4, center_resnum_list[-1]) <= elem.get_start_resseq_as_int() < f_end_res_num:\n # print \" cutting...\"\n f_end_res_num = elem.get_start_resseq_as_int()\n loop_length = f_end_res_num - f_start_res_num\n return f_start_res_num, f_end_res_num","def _get_minimal_lanes(self):\n return np.argwhere(self.end_of_lanes == np.min(self.end_of_lanes)).flatten()","def matching_time_indices(stamps_1, stamps_2, max_diff=0.01, offset_2=0.0):\n matching_indices = []\n stamps_2 = copy.deepcopy(stamps_2)\n stamps_2 += offset_2\n for stamp in stamps_1:\n diffs = np.abs(stamps_2 - stamp)\n argmin = np.argmin(diffs)\n if diffs[argmin] <= max_diff:\n matching_indices.append(argmin)\n return matching_indices","def find_pair(line):\n if len(line) >1:\n for dummy_i in range(0,len(line) - 1):\n if line[dummy_i] !=0 and line[dummy_i] == line[dummy_i+1]:\n return True\n return False","def compute_previous_intervals(I):\n # extract start and finish times\n start = [i.left for i in I]\n finish = [i.right for i in I]\n\n p = []\n for j in range(len(I)):\n # rightmost interval f_i <= s_j\n i = bisect.bisect_right(finish, start[j]) - 1\n p.append(i)\n\n return p","def getEnds(self) -> List[int]:\n ...","def calculateOverlap(mfaPairs, exons1, exons2):\n exonSize = 0\n noMatchToExons = 0\n noMatchToNonExons = 0\n noMatchToGapsInExons = 0\n noMatchToGapsNotInExons = 0\n \n p = -100000\n for i in exons1:\n exonSize += i[1] - i[0]\n for j in xrange(i[0], i[1]):\n k = mfaPairs[j]\n l = k\n if k == GAP:\n l = p \n for m in exons2:\n if(l >= m[0] and l < m[1]):\n if k == GAP:\n noMatchToGapsInExons += 1\n else:\n noMatchToExons += 1\n break\n else:\n if k == GAP:\n noMatchToGapsNotInExons += 1\n else:\n noMatchToNonExons += 1\n if k != GAP:\n p = k\n return (exonSize, noMatchToExons, noMatchToNonExons,\\\n noMatchToGapsInExons, noMatchToGapsNotInExons)","def pairs_from_list(lights):\n length = len(lights)\n half = int(length / 2)\n offset = 0\n\n centre = None\n if length % 2 == 1:\n centre = lights[half]\n offset = 1\n\n left = lights[:half]\n\n rh_start = half + offset\n right = reversed(lights[rh_start:])\n\n pairs = list(map(list, zip(left, right)))\n\n if centre:\n pairs.append([centre])\n\n return pairs","def sum_light(\n els: List[Union[datetime, Tuple[datetime, int]]],\n start_watching: Optional[datetime] = None,\n end_watching: Optional[datetime] = None,\n) -> int:\n # replace elements with no bulb index\n els, switch = [(e, 0) if type(e) is datetime else e for e in els], [False] * 10\n sw, ew, on = start_watching or els[0][0], end_watching or els[-1][0], []\n # determine what intervals any lamp is on\n for idx, e in enumerate(els):\n switch[e[1]], els[idx] = not switch[e[1]], min(ew, max(e[0], sw))\n on.append(any(switch))\n # then summ all intervals where any lamp is on\n els += [ew]\n return sum(on[i] * (els[i + 1] - els[i]).total_seconds() for i in range(len(on)))","def get_altitude(points):\n altitudes = np.zeros((len(points),), dtype=\"float64\")\n for i, point in tqdm(enumerate(points), desc=\"GETTING ALTITUDE\"):\n p = Point(point[0], point[1])\n altitudes[i] = alt.NM_COTA.iloc[\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\n ]\n return altitudes","def identify_outliers_consecutive(self, max_vel):\r\n if 'Dry' in self.outlier_methods:\r\n flagged = self.rec_track['Dry'].copy()\r\n niterations = 1\r\n for nit in range(0,niterations):\r\n not_flagged = np.where(flagged==0)[0]\r\n valid_tr = self.rec_track[not_flagged]\r\n # compute segments associated with valid detects\r\n nvalid = len(valid_tr)\r\n if nvalid < 3:\r\n self.valid = False\r\n return flagged\r\n valid_seg = self.make_segments(input_rec_track = valid_tr)\r\n for ndv in range(1,nvalid-1):\r\n sp1 = valid_seg.speed[ndv-1]\r\n sp2 = valid_seg.speed[ndv]\r\n if (sp1 > max_vel) and (sp2 > max_vel):\r\n nd_orig = valid_tr[ndv].nd\r\n flagged[nd_orig] = 1\r\n\r\n ncol = len(self.df_track.columns)\r\n self.df_track.insert(ncol, 'Consecutive', flagged)\r\n ncol = len(self.df_track.columns)\r\n\r\n return flagged","def part1(problem_input: Iterable[str], row_y: int) -> int:\n sensor_beacons: dict[Point, tuple[Point, int]] = {\n Point(int(sx), int(sy)): (\n Point(int(bx), int(by)),\n distance(Point(int(sx), int(sy)), Point(int(bx), int(by))),\n )\n for sx, sy, bx, by in [\n re.match(\n r\"Sensor at x=([0-9-]+), y=([0-9-]+): closest beacon is at x=([0-9-]+), y=([0-9-]+)\",\n line,\n ).groups() # type: ignore\n for line in problem_input\n ]\n }\n\n min_x = min(s.x - d for s, (_, d) in sensor_beacons.items())\n max_x = max(s.x + d for s, (_, d) in sensor_beacons.items())\n\n ruled_out: set[Point] = set()\n for x in range(min_x, max_x + 1):\n p = Point(x, row_y)\n for s, (b, d) in sensor_beacons.items():\n if distance(s, p) <= d and p != b:\n ruled_out.add(p)\n break\n return len(ruled_out)","def expander(i_start, j_end, length):\n\n # create list of paired i indices\n i_s = list(np.arange(i_start, i_start + length))\n\n # create list of corresponding j indices:\n j_s = list(np.arange(j_end, j_end + length))\n\n # form list of tuple pairs\n pairs = list(zip(i_s, j_s))\n\n return pairs","def find_endpoints(batch_trajectories):\n # empty lists to fill\n site_lats = []\n site_lons = []\n last_lats = []\n last_lons = []\n lats_150 = []\n lons_150 = [] \n last_times = []\n times_150 = []\n last_sst = []\n sst_150 = []\n \n # temporary lists as placeholders\n temp_site_lats = []\n temp_site_lons = []\n temp_lats = []\n temp_lons = []\n temp_lats150 = []\n temp_lons150 = []\n temp_times = []\n temp_times150 = []\n temp_sst = []\n temp_sst150 = []\n\n for speed in range(len(batch_trajectories)):\n # working with one speed at a time means working with one nc file at\n # a time\n \n # reset temporary lists\n temp_site_lats = []\n temp_site_lons = []\n temp_lats = []\n temp_lons = []\n temp_lats150 = []\n temp_lons150 = []\n temp_times = []\n temp_times150 = []\n temp_sst = []\n temp_sst150 = []\n\n # extract variables into lists\n lats = batch_trajectories[speed].variables['lat'][:]\n lons = batch_trajectories[speed].variables['lon'][:]\n lats150 = batch_trajectories[speed].variables['lat150'][:]\n lons150 = batch_trajectories[speed].variables['lon150'][:]\n times = batch_trajectories[speed].variables['time'][:]\n ssts = batch_trajectories[speed].variables['temp'][:]\n ssts_150 = batch_trajectories[speed].variables['temp150'][:]\n\n # if a particle is deleted before time is up, values are masked. \n # We'd like to get the last valid number.\n for trajectory in range(len(lats)):\n i = -1 # index for the last value\n while np.ma.is_masked(lats[trajectory][i]) is True:\n i -= 1 # if the value is masked, go to one value sooner\n \n j = i # use j for the 150m values\n while lats150[trajectory][j] > 0:\n # we want the first index where the latitude is recorded.\n # j is actually the last one where it's not recorded, so we\n # extract the information at index j+1\n j -= 1\n\n # once i and j are determined for a trajectory, we can extract the\n # variables and append them to temporary lists.\n temp_site_lats.append(lats[trajectory][0])\n temp_site_lons.append(lons[trajectory][0])\n temp_lats.append(lats[trajectory][i])\n temp_lons.append(lons[trajectory][i])\n temp_lats150.append(lats150[trajectory][j+1])\n temp_lons150.append(lons150[trajectory][j+1])\n temp_times.append(times[trajectory][i])\n temp_sst.append(ssts[trajectory][i])\n temp_sst150.append(ssts_150[trajectory][j+1])\n temp_times150.append(times[trajectory][j+1])\n \n # after the temporary lists are appended by sinking speed, they\n # are appended to the big lists that are returned by the function.\n # this keeps the structure of being separated by sinking speed.\n site_lats.append(temp_site_lats)\n site_lons.append(temp_site_lons)\n last_lats.append(temp_lats)\n last_lons.append(temp_lons)\n lats_150.append(temp_lats150)\n lons_150.append(temp_lons150)\n last_times.append(temp_times)\n times_150.append(temp_times150)\n last_sst.append(temp_sst)\n sst_150.append(temp_sst150)\n \n return site_lats, site_lons, last_lats, last_lons, lats_150, lons_150,\\\n last_times, times_150, last_sst, sst_150","def _sort_index(self):\n\n allAltPos = np.array(sorted(list(set(list(self.data['altitude'])))))[::-1]\n allAziPos = np.array(sorted(list(set(list(self.data['azimuth'])))))\n\n indON = [[None for azi in allAziPos] for alt in allAltPos]; indOFF = [[None for azi in allAziPos] for alt in allAltPos]\n\n for i, traceItem in enumerate(self.data):\n alt = traceItem['altitude'];azi = traceItem['azimuth'];sign = traceItem['sign']\n for j, altPos in enumerate(allAltPos):\n for k, aziPos in enumerate(allAziPos):\n if alt==altPos and azi==aziPos:\n if sign==1:\n if indON[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign: 1!')\n else: indON[j][k]=i\n\n if sign==-1:\n if indOFF[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign:-1!')\n else: indOFF[j][k]=i\n\n indON = np.array([np.array(x) for x in indON]); indOFF = np.array([np.array(x) for x in indOFF])\n\n return indON,indOFF,allAltPos,allAziPos","def get_list_after_paired(line):\n if find_pair(line):\n index = get_index(line)\n return line[index + 2: ]\n return []","def find_start_end(grid):\n #------------------------------------\n #\n # Fill and submit this code\n #\n start = 0\n end = 0\n for i in range(len(grid)):\n if grid[i] == \"emerald_block\":\n start = i\n elif grid[i] == \"redstone_block\":\n end = i\n return (start, end)\n #-------------------------------------","def racetrack_filter(reversals, h):\n\n y = reversals\n yprev = None\n ix = []\n for n, yn in enumerate(y):\n if (n == 0) or (n == y.size-1):\n yprev = yn\n ix.append(n)\n continue\n dy = yn - yprev\n if fabs(dy) > h / 2.:\n yprev = yn - dy/fabs(dy) * h/2.\n ix.append(n)\n ix = np.array(ix, dtype=int)\n return y[ix], ix","def find_pairs(candidate_array, TARGET_VALUE=10):\r\n \r\n from collections import defaultdict\r\n positions = defaultdict(list)\r\n \r\n #Read everything into a dictionary, storing the original array position \r\n for i in range(len(candidate_array)):\r\n positions[candidate_array[i]].append(i)\r\n\r\n #Read list comparing value to TARGET_VALUE \r\n for i in range(len(candidate_array)):\r\n pair_value = TARGET_VALUE - candidate_array[i]\r\n if positions[pair_value]:\r\n for p in positions[pair_value]:\r\n if p > i:\r\n #print \"%d,%d\" % (candidate_array[i], pair_value)\r\n None","def next_coordinate1(cur_position, data, steps):\n # cur_position and next ride-> [x1, x2, y1, y2, earlieststart, latestfinish)\n if abs(data[0] - cur_position[0]) + abs(data[1] - cur_position[1]) <= data[4] - steps:\n return 1\n else:\n return 0","def searchDeadEnd(self):\n boundaries = []\n if not self.red:\n i = self.midWidth - 1\n else:\n i = self.midWidth + 1\n boudaries = [(i, j) for j in range(self.height)]\n validPositions = []\n for i in boudaries:\n if not (i[0], i[1]) in self.walls:\n validPositions.append(i)\n\n dangerPos = []\n\n toExpand = self.scanmap.twoEntryPoints()\n for (x,y) in toExpand:\n adjacent = self.scanmap.adjacentValidPoints(x, y)\n if not (x,y) in dangerPos:\n for (u, w) in adjacent:\n visited = []\n visited.append((x, y))\n safe = False\n danger = False\n DFS = util.Stack()\n DFS.push((u,w))\n while not safe and not danger:\n (i,j) = DFS.pop()\n visited.append((i,j))\n adjacents = self.scanmap.adjacentValidPoints(i,j)\n for position in adjacents:\n if not position in visited:\n DFS.push(position)\n if DFS.isEmpty():\n danger = True\n dangerPos = list(set(dangerPos) | set(visited))\n\n if (i,j) in validPositions:\n safe = True\n oneEntry = self.scanmap.oneEntryPoints()\n dangerPos = list(set(oneEntry).union(set(dangerPos)))\n dangerPos.sort()\n return dangerPos","def introns_from_bed(bed):\n introns = set()\n with open(bed) as bed_stream:\n for line in bed_stream:\n tokens = line.rstrip().split('\\t')\n if len(tokens) < 12:\n continue\n chrom = tokens[0]\n chrom_start = int(tokens[1])\n chrom_end = int(tokens[2])\n block_sizes = tokens[10].split(',')\n block_starts = tokens[11].split(',')\n # Handle trailing commas\n try:\n int(block_sizes[-1])\n except ValueError:\n block_sizes = block_sizes[:-1]\n try:\n int(block_starts[-1])\n except ValueError:\n block_starts = block_starts[:-1]\n block_count = len(block_sizes)\n if block_count < 2:\n # No introns\n continue\n assert block_count == len(block_starts)\n junctions = []\n # First block characterizes junction on left side of intron\n junctions.append(chrom_start + int(block_starts[0]) \n + int(block_sizes[0]))\n for i in xrange(1, block_count - 1):\n # Any intervening blocks characterize two junctions\n intron_start = chrom_start + int(block_starts[i])\n junctions.append(intron_start)\n junctions.append(intron_start + int(block_sizes[i]))\n # Final block characterizes junction on right side of intron\n junctions.append(chrom_start + int(block_starts[-1]))\n for i in xrange(len(junctions)/2):\n introns.add((chrom, junctions[2*i]+1, junctions[2*i+1]+1))\n return introns","def _findKeyframeSegments(self,array, classifications):\n keyframes=[]\n while True:\n max_idx = np.argmax(array)\n max_value = array[max_idx]\n if max_value < PEAK_THRESHOLD:\n return keyframes\n\n area_sum = peak_sum(array, max_idx, MIN_SPACING)\n low_idx = max(max_idx-MIN_SPACING,0)\n limit = min(max_idx+MIN_SPACING+1,len(array))\n if area_sum > AREA_THRESHOLD:\n max_clear = 0.0\n clear_idx = None\n for area_idx in range(low_idx,limit):\n # The actual frame is KEYFRAME_OFFSET away from the\n # result vector due to padding\n class_idx = area_idx - KEYFRAME_OFFSET\n\n # If there are no detections don't attemt to extract\n # then don't attempt to extract cover info\n if len(classifications[class_idx]) == 0:\n continue\n element_cover = classifications[class_idx][0].cover[2]\n if element_cover > max_clear:\n max_clear = element_cover\n clear_idx = area_idx\n\n if clear_idx is not None:\n keyframes.append(clear_idx)\n keyframes.sort()\n\n # Zero out the area identified\n for clear_idx in range(low_idx, limit):\n array[clear_idx] = 0.0","def _euclidian_distances(stop_list):\n e_dists2 = [transitfeed.approximate_distance_between_stops(stop, tail) for\n (stop, tail) in zip(stop_list, stop_list[1:])]\n\n return e_dists2","def _pasrse_data_start_end(self, data):\n first = data['obs_time'].iloc[0]\n last = data['obs_time'].iloc[-1]\n\n return (first, last)","def break_points(graph = None):\n\tstart = 0\n\tstop = nx.number_of_nodes(graph) -1\n\tbreak_points = []\n\tbasepair_list = basepairs(graph = graph)\n\tfor basepair in basepair_list:\n\t\tif (successor_pair(basepair, start, stop) == (-1,-1)) or \\\n\t\t(predecessor_pair(basepair, start, stop) == (-1,-1)) or \\\n\t\tnot (successor_pair(basepair, start, stop) in basepair_list) or \\\n\t\tnot (predecessor_pair(basepair, start, stop) in basepair_list):\n\t\t\tbreak_points.append(basepair)\n\treturn break_points","def find_pairs_simple(candidate_array, TARGET_VALUE=10):\r\n for i in range(len(candidate_array)):\r\n for j in range(i + 1, len(candidate_array)):\r\n if (TARGET_VALUE == candidate_array[i] + candidate_array[j]):\r\n #print \"%d,%d\" % (candidate_array[i], candidate_array[j])\r\n None","def corresponding_frame(traj1, len1, traj2, len2):\n p1, p2 = 0, 0\n loc = -1 * np.ones((len1,), dtype=int)\n while p1 < len1 and p2 < len2:\n if traj1[p1] < traj2[p2]:\n loc[p1] = -1\n p1 += 1\n elif traj1[p1] == traj2[p2]:\n loc[p1] = p2\n p1 += 1\n p2 += 1\n else:\n p2 += 1\n return loc","def all_consecutive(s):\n for (x, y) in pairwise(sorted(s)):\n if y - x != 1:\n return False\n return True","def group_consecutive(data):\n from itertools import groupby\n from operator import itemgetter\n results = []\n for k, g in groupby(enumerate(data), lambda i_x: i_x[0] - i_x[1]):\n results.append(list(map(itemgetter(1), g)))\n\n return results","def get_start_end_points(path, transect): \n transect_array = np.genfromtxt(path + 'tran_sim_pts.csv', delimiter=\",\")\n start_point = transect_array[2 * transect, :]\n end_point = transect_array[2 * transect + 1, :]\n \n # force start points to be west of end points\n if start_point[0] > end_point[0]:\n previous_start_point = start_point\n start_point = end_point\n end_point = previous_start_point\n return start_point, end_point","def find_uniques_consecutive(array):\n val = array[0]\n indices = []\n for idx, element in enumerate(array):\n if element != val:\n indices.append(idx)\n val = element\n return indices","def _get_lines(self) -> tuple[VGroup, VGroup]:\n center = self.get_origin()\n ratio_faded_lines = self.faded_line_ratio\n offset = self.azimuth_offset\n\n if ratio_faded_lines == 0: # don't show faded lines\n ratio_faded_lines = 1 # i.e. set ratio to 1\n rstep = (1 / ratio_faded_lines) * self.x_axis.x_range[2]\n astep = (1 / ratio_faded_lines) * (TAU * (1 / self.azimuth_step))\n rlines1 = VGroup()\n rlines2 = VGroup()\n alines1 = VGroup()\n alines2 = VGroup()\n\n rinput = np.arange(0, self.x_axis.x_range[1] + rstep, rstep)\n ainput = np.arange(0, TAU, astep)\n\n unit_vector = self.x_axis.get_unit_vector()[0]\n\n for k, x in enumerate(rinput):\n new_line = Circle(radius=x * unit_vector)\n if k % ratio_faded_lines == 0:\n alines1.add(new_line)\n else:\n alines2.add(new_line)\n\n line = Line(center, self.get_x_axis().get_end())\n\n for k, x in enumerate(ainput):\n new_line = line.copy()\n new_line.rotate(x + offset, about_point=center)\n if k % ratio_faded_lines == 0:\n rlines1.add(new_line)\n else:\n rlines2.add(new_line)\n\n lines1 = VGroup(*rlines1, *alines1)\n lines2 = VGroup(*rlines2, *alines2)\n return lines1, lines2","def _scan_reverse(gaps, center, dist):\n\n for i in range( 0, center ):\n idx_gap = center - 1 - i\n gap = gaps[idx_gap]\n if gap >= dist: return idx_gap+1\n return 0","def find_steps(walk):\n cols = ['id', 'acc_x', 'acc_y', 'acc_z', 'gy_x', 'gy_y', 'gy_z', 'mag_x', 'mag_y', 'mag_z'] \n df = DataFrame(walk)\n df.columns = cols\n acc_mag, mag_mag, mag_gy = get_mags(df)\n reduced_gy = reduce_signal(mag_gy)\n gy = [make_auto(mag_gy), make_auto(reduced_gy)]\n maxtab, mintab = peakdet(gy[1], .02)\n ind = maxtab[:, 0]\n ind = ind.astype(int)\n len_btw_steps = [j-i for i, j in zip(ind[:-1], ind[1:])]\n loc_and_len = zip(ind, len_btw_steps)\n steps = []\n for location, length in loc_and_len:\n start = location\n stop = location + length\n step = longest[start:stop]\n steps.append(step)\n return steps","def is_consecutive(a_list):\n current_value = a_list[0]-1\n for number in a_list:\n current_value +=1\n if current_value != number:\n return False\n return True","def verify_cutoff_pair(cutoff, pair, voltages):\n flag = -1\n for i in range(len(cutoff)):\n pairs = cutoff[i]\n if pair in pairs or list(reversed(pair)) in pairs:\n if voltages[i] is 'S':\n flag = i\n return flag\n return flag","def find_starts(config, data):\n\n trigger = butter_bandpass_filter(\n data, config.bandpass_lower, config.bandpass_upper,\n config.sampling_rate, 6)\n trigger = np.absolute(trigger)\n trigger = butter_lowpass_filter(\n trigger, config.lowpass_freq, config.sampling_rate, 6)\n\n # transient = 0.0005\n # start_idx = int(transient * config.sampling_rate)\n start_idx = 0\n average = np.average(trigger[start_idx:])\n maximum = np.max(trigger[start_idx:])\n minimum = np.min(trigger[start_idx:])\n middle = (np.max(trigger[start_idx:]) - min(trigger[start_idx:])) / 2\n if average < 1.1 * middle:\n print()\n print(\"Adjusting average to avg + (max - avg) / 2\")\n average = average + (maximum - average) / 2\n offset = -int(config.trigger_offset * config.sampling_rate)\n\n if config.trigger_rising:\n trigger_fn = lambda x, y: x > y\n else:\n trigger_fn = lambda x, y: x < y\n\n # The cryptic numpy code below is equivalent to looping over the signal and\n # recording the indices where the trigger crosses the average value in the\n # direction specified by config.trigger_rising. It is faster than a Python\n # loop by a factor of ~1000, so we trade readability for speed.\n trigger_signal = trigger_fn(trigger, average)[start_idx:]\n starts = np.where((trigger_signal[1:] != trigger_signal[:-1])\n * trigger_signal[1:])[0] + start_idx + offset + 1\n if trigger_signal[0]:\n starts = np.insert(starts, 0, start_idx + offset)\n\n # plt.plot(data)\n # plt.plot(trigger*100)\n # plt.axhline(y=average*100)\n # plt.show()\n\n return starts, trigger, average","def get_stopped_pts(gpx_track, speed_threshold=2.5):\n\n n = 0\n stopped_bool = [False]*gpx_track.get_points_no() # pre-allocate\n for segment in gpx_track.segments:\n for ida, point in enumerate(segment.points):\n stopped_bool[n] = segment.get_speed[ida] < speed_threshold\n n = n + 1\n\n _, stopped_time = gpx_track.get_moving_data(speed_threshold)\n\n return stopped_bool, stopped_time","def _consecutive(self, n):\n grouped = zip(*[iter(self._history())]*n)\n results = [0]*len(grouped)\n for i, group in enumerate(grouped):\n if list(group) == [1]*n:\n results[i] = 1\n if list(group) == [0]*n:\n results[i] = -1\n return results","def listOfOverlappingTTPairs():\n listOfHalfModules = listOfTTHalfModules()\n ttmap = TTModulesMap_instance\n pairs = []\n regions = {'A':1, 'B':2, 'C':3}\n print \"Overlapping TT half modules:\"\n for hm1 in listOfHalfModules:\n for hm2 in listOfHalfModules:\n # they must be different\n if hm1 == hm2: continue\n # they must be both on top or both on bottom\n if locateTTHalfModule(hm1)[3] != locateTTHalfModule(hm2)[3]: continue\n # they must be on the same layer\n if locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0]: continue\n # avoid duplicates\n if (hm1, hm2) in pairs: continue\n if (hm2, hm1) in pairs: continue\n # they must be contiguous:\n if (locateTTHalfModule(hm1)[1] == locateTTHalfModule(hm2)[1]):\n if (abs(locateTTHalfModule(hm1)[2] - locateTTHalfModule(hm2)[2]) == 1):\n pairs.append( (hm1, hm2) )\n else:\n num1 = locateTTHalfModule(hm1)[2]\n num2 = locateTTHalfModule(hm2)[2]\n max1 = ttmap.numberOfModules[locateTTHalfModule(hm1)[0]]['Region'+locateTTHalfModule(hm1)[1]] - 1\n max2 = ttmap.numberOfModules[locateTTHalfModule(hm2)[0]]['Region'+locateTTHalfModule(hm2)[1]] - 1\n nreg1 = regions[locateTTHalfModule(hm1)[1]]\n nreg2 = regions[locateTTHalfModule(hm2)[1]]\n if ( (num1==max1 and num2==0 and nreg2-nreg1==1) or (num2==max2 and num1==0 and nreg1-nreg2==1) ):\n pairs.append( (hm1, hm2) )\n print '\\t', hm1, hm2\n ## - same region\n #if ((abs(locateTTHalfModule(hm1)[2] - locateTTHalfModule(hm2)[2]) != 1)\n # and (locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0])): continue\n ## - or neighbouring region\n #elif not ((locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0])\n # and ( ( (ttmap.numberOfModules[locateTTHalfModule(hm1)[0]] == locateTTHalfModule(hm1)[2]+1 )\n # and (locateTTHalfModule(hm2)[2] == 0) )\n # or ( (ttmap.numberOfModules[locateTTHalfModule(hm2)[0]] == locateTTHalfModule(hm2)[2]+1 )\n # and (locateTTHalfModule(hm1)[2] == 0) ) ) ): continue\n ## append to list of pairs\n #pairs.append( (hm1, hm2) )\n print\n return pairs","def get_elementary_airspace_altitude_range(db_id):\n connection = get_geo_db_connection()\n sector = find_sector(db_id, connection)\n if (sector):\n return (sector['min_altitude'], sector['max_altitude'])\n else:\n raise NotFoundException(db_id, \"Elementary sector not found.\")","def _scan_forward( gaps, center, dist ):\n\n n = len(gaps)\n for i in range( center, n ):\n idx_gap = i\n gap = gaps[idx_gap]\n if gap >= dist: return idx_gap+1\n return n+1","def get_list_before_paired(line):\n if find_pair(line):\n index = get_index(line)\n return line[ :index + 2]\n return []","def max_overlap_pair(skylines):\n max_pair = None\n max_overlap_area = 0.0\n\n for i in range(len(skylines) - 1):\n curr_s = skylines[i]\n next_s, i_area = curr_s.find_max_overlap(skylines[i + 1:])\n\n if i_area > max_overlap_area:\n max_overlap_area = i_area\n max_pair = (curr_s, next_s)\n\n return max_pair","def GetScanPositions(self,d):\n\n # make it so that you have a gap, only use data where the telescope is moving\n\n elcurrent = np.abs(d['level1/hk/antenna0/driveNode/elDacOutput'][:])\n elutc = d['level1/hk/antenna0/driveNode/utc'][:]\n mjd = d['level1/spectrometer/MJD'][:]\n select = np.where((elcurrent > np.max(elcurrent)*0.8))[0] # these are when the telescope is changing position\n #if len(select) == 0:\n\n\n dselect = select[1:]-select[:-1]\n ends = np.concatenate((np.where((dselect > 10))[0], np.array([len(dselect)-1])))\n\n indices = []\n for e in select[ends]:\n end_idx = np.argmin((elutc[e]-mjd)**2)\n indices += [end_idx]\n\n mean_scan_time = np.mean(elutc[ends[1:]] - elutc[ends[:-1]])*24*3600\n step = mean_scan_time*0.1\n mask = np.zeros(len(mjd)).astype(bool)\n samples = np.arange(len(mjd))\n\n buffer_size = 50\n buffer_multiply = 5\n for iend, end in enumerate(indices):\n if (iend ==0):\n mask[samples < (end+step*buffer_size)] = True\n elif (iend == (len(indices)-1)):\n mask[samples > (end-step*buffer_size)] = True\n else:\n mask[(samples > (end - buffer_multiply*buffer_size)) & (samples < (end + buffer_multiply*buffer_size))] = True\n\n\n # Map indices\n oldindex = np.arange(len(mjd))[~mask] # old positions\n newindex = np.arange(len(oldindex)) # new positions\n mapOld2New = {o:n for (o,n) in zip(oldindex,newindex)}\n mapNew2Old = {n:o for (o,n) in zip(oldindex,newindex)}\n\n diff_mask = mask[1:].astype(int) - mask[:-1].astype(int)\n mask_select = np.where((diff_mask > 0))[0] # old positions\n end_indices = np.unique([0] + [mapOld2New[i] for i in mask_select] )\n\n if end_indices[-1] > newindex.size:\n end_indices[-1] = newindex.size-1\n \n\n starts, ends = end_indices[:-1],end_indices[1:] \n\n start_final = []\n end_final = []\n for start,end in zip(starts,ends):\n i0,i1 = mapNew2Old[start], mapNew2Old[end]\n if (end-start) < self.minimum_scanlength:\n mask[i0:i1] = True\n else:\n start_final += [start]\n end_final += [end]\n\n return (mask == False), np.array(start_final).astype(int), np.array(end_final).astype(int)","def find_matching_segments(self):\n hyp_matched_segs = [TIntervalGroup() for i in range(len(self.hyp))]\n for gid_ref, match_ref in enumerate(self.ref):\n bg_ref = match_ref.bbox_group\n max_gid, max_area = -1, 0\n for gid_hyp, bg_hyp in enumerate(self.hyp.get_bbox_groups()):\n rx, ry = bg_ref.page_range(), bg_hyp.page_range()\n if ry[0] > rx[1]:\n break\n area = (bg_ref & bg_hyp)\n if area > max_area:\n max_gid, max_area = gid_hyp, area\n if max_gid != -1:\n hyp_matched_segs[max_gid].extend(match_ref.tinterval_group.copy())\n print('%d -> %d' % (gid_ref, max_gid))\n for seg in hyp_matched_segs:\n seg.reduce()\n return hyp_matched_segs","def set_cruise_altitudes(altitudes, cruise_indicies):\n if cruise_indicies:\n for index in range(0, len(cruise_indicies), 2):\n start = cruise_indicies[index]\n stop = cruise_indicies[index + 1]\n if start < stop:\n cruise_altitude = closest_cruising_altitude(altitudes[start])\n altitudes[start] = cruise_altitude\n altitudes[stop] = cruise_altitude\n\n return altitudes","def find_x_wing_pairs(pair_array):\n pair_array_return = []\n i = 0\n while i < len(pair_array):\n j = i+1\n while j < len(pair_array):\n if pair_array[i][1] == pair_array[j][1] and pair_array[i][2] == pair_array[j][2] \\\n and pair_array[i][3] == pair_array[j][3]:\n pair_array_return.append([pair_array[i][1],pair_array[i][0],pair_array[j][0], \\\n pair_array[j][2],pair_array[j][3]])\n j += 1\n i += 1\n return pair_array_return","def consecutive(data):\n data_group = [(v, sum(1 for _ in g)) for v, g in groupby(data)]\n vals, cons = zip(*data_group)\n\n start_inds = np.cumsum((0,) + cons[:-1])\n end_inds = start_inds + cons - 1\n\n return list(zip(vals, start_inds, end_inds))","def arc_tangents(amount, start, stop, truncated, sequence):\n ratio = (start + stop) / 2\n for x in range(start, amount):\n y = abs(round(ratio * math.atan(x)))\n if truncated and y >= stop:\n sequence.append(stop)\n elif y < start:\n sequence.append(start)\n else:\n sequence.append(y)\n return sequence","def list_duplicates(seq):\n tally = defaultdict(list)\n for i, item in enumerate(seq):\n try:\n if item.mask == True:\n continue\n except:\n tally[item].append(i)\n return ((key, locs) for key, locs in tally.items() if len(locs) > 1)","def _getscanind(self):\n \n zamin = self.za.min()\n first = np.where(self.za==zamin)[0]\n self.scan = np.zeros(self.spec.shape[0])\n if zamin < 0:\n cs = first[np.where((first - np.roll(first, 1)) != 1)[0]]\n ss = first[np.where((np.roll(first,-1) - first) != 1)[0]] + 1\n ce = ss \n se = np.roll((cs - 1) % self.za.size, -1) + 1\n for k, val in enumerate(cs):\n self.scan[val:se[k] + 1] = k\n else:\n moves = np.diff(self.za)\n max_ind = np.where(moves==moves.max())[0]\n turnover = self.za.size\n diffs = np.diff(max_ind)\n if np.unique(diffs).size > 1:\n raise ValueError, 'Can\\'t deal with non-uniform cal data yet.'\n if max_ind.size > 1:\n turnover = diffs[0]\n cs = ce = np.array([])\n ss = np.arange(self.za.size)[::turnover]\n se = np.roll((ss - 1) % self.za.size, -1)\n for k, val in enumerate(ss):\n self.scan[val:se[k] + 1] = k\n \n self.ind = {'cs': cs, 'ce': ce, 'ss': ss, 'se': se}\n self.nscan = np.unique(self.scan).size","def find_answer(offsets, begin_offset, end_offset):\n start = [i for i, tok in enumerate(offsets) if tok[0] == begin_offset]\n end = [i for i, tok in enumerate(offsets) if tok[1] == end_offset]\n assert(len(start) <= 1)\n assert(len(end) <= 1)\n if len(start) == 1 and len(end) == 1:\n return start[0], end[0]","def GetTimeIntervalsForEachLine(PathInfo):\r\n\tTimeIntervalOnLine = {}\r\n\r\n\tif PathInfo == None: return TimeIntervalOnLine\r\n\tif len(PathInfo) < 2: return TimeIntervalOnLine\r\n\r\n\tLastLine = None\r\n\tCurrDeparture = None\r\n\r\n\tfor i in range(1, len(PathInfo)):\r\n\t\tConnectionInfo = PathInfo[i]\r\n\t\tCurLine = ConnectionInfo[ConnInfoInd['line_id']]\r\n\t\tCurTripID = ConnectionInfo[ConnInfoInd['travel_id']]\r\n\r\n\t\tif i == 1:\r\n\t\t\tCurrDeparture = ConnectionInfo[ConnInfoInd['departure_hour']]*60 + ConnectionInfo[ConnInfoInd['departure_min']]\r\n\t\t\tLastLine = CurLine\r\n\t\t\tLastTripID = CurTripID\r\n\r\n\t\t# if CurLine != LastLine:\r\n\t\tif CurTripID != LastTripID:\r\n\t\t\tLastArrival = PathInfo[i-1][ConnInfoInd['arrival_hour']]*60 + PathInfo[i-1][ConnInfoInd['arrival_min']]\r\n\t\t\tif TimeIntervalOnLine.has_key(LastLine):\r\n\t\t\t\tTimeIntervalOnLine[LastLine].append((CurrDeparture, LastArrival))\r\n\t\t\telse:\r\n\t\t\t\tTimeIntervalOnLine[LastLine] = [(CurrDeparture, LastArrival)]\r\n\t\t\tCurrDeparture = ConnectionInfo[ConnInfoInd['departure_hour']]*60 + ConnectionInfo[ConnInfoInd['departure_min']]\r\n\t\t\tLastLine = CurLine\r\n\t\t\tLastTripID = CurTripID\r\n\t\t\r\n\t\tif i == (len(PathInfo) - 1):\r\n\t\t\tLastArrival = ConnectionInfo[ConnInfoInd['arrival_hour']]*60 + ConnectionInfo[ConnInfoInd['arrival_min']]\r\n\t\t\tif TimeIntervalOnLine.has_key(CurLine):\r\n\t\t\t\tTimeIntervalOnLine[CurLine].append((CurrDeparture, LastArrival))\r\n\t\t\telse:\r\n\t\t\t\tTimeIntervalOnLine[CurLine] = [(CurrDeparture, LastArrival)]\r\n\r\n\treturn TimeIntervalOnLine","def get_regions_above_threshold(self, threshold, values):\n\n xlocs = arange(0, len(values))\n\n # finds all turns, between above and below threshold\n # and generate areas to call peaks in, also\n # makes sure starting and stopping above maxima is caught\n # threshold is at or equal to values, need to correct this\n starts = xlocs[r_[True, diff(values >= threshold)] & (values >= threshold)]\n stops = xlocs[r_[diff(values >= threshold), True] & (values >= threshold)]\n # add to fix off by one bug\n stops += + 1\n\n # error correction incase my logic is wrong here, assuming that starts\n # and stops are always paired, and the only two cases of not being\n # pared are if the spline starts above the cutoff or the spline starts\n # below the cutoff\n assert len(starts) == len(stops)\n\n ### important note: for getting values x->y [inclusive]\n # you must index an array as ar[x:(y+1)]|\n # or else you end up with one-too-few values, the second\n # index is non-inclusive\n\n # gets all local minima, function taken from:\n # http://stackoverflow.com/questions/4624970/finding-local-maxima-minima-with-numpy-in-a-1d-numpy-array\n # Can't have local minima at start or end, that would get caught by\n # previous check, really need to think about that more\n\n local_minima = self.find_local_minima(values)\n\n # append to list any local minima above threshold\n for i, minima in enumerate(local_minima):\n if minima and values[i] >= threshold:\n starts = append(starts, i)\n stops = append(stops, i)\n\n starts = array(sorted(set(starts)))\n stops = array(sorted(set(stops)))\n starts_and_stops = []\n\n # making sure we aren't in some strange state\n assert len(starts) == len(stops)\n\n # get all contigous start and stops pairs\n while len(starts) > 0:\n stop_list = stops[stops > starts[0]]\n\n # if there are no more stops left exit the loop and return the\n # currently found starts and stops\n if len(stop_list) == 0:\n break\n stop = stop_list[0]\n starts_and_stops.append((starts[0], stop))\n starts = starts[starts >= stop]\n\n starts = array([x[0] for x in starts_and_stops])\n stops = array([x[1] for x in starts_and_stops])\n return starts_and_stops, starts, stops","def resolve(self):\n for annotation_1 in self._data:\n for annotation_2 in self._data:\n if annotation_1 == annotation_2:\n continue\n elif ((annotation_2.start < annotation_1.end) or\n (annotation_1.start < annotation_2.end)):\n self._resolve_pair(annotation_1, annotation_2)","def iter_neighbors(x: int, y: int) -> t.Generator[COORDINATE, None, None]:\n yield x - 1, y\n yield x + 1, y\n yield x, y - 1\n yield x, y + 1","def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\n watershed, allValsByFrame\n):\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\n watershed, allValsByFrame\n )\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\n return cVLSByFrame, orderOfSCsByValueByFrame\n\n ## NOT NEEDED! KEEPING FOR REFERENCE!\n # for i in range(len(cVLS)-1,0,-1):\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\n # break\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\n # if cVLS[j][1]>cVLS[i][1]:\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\n #\n # cVLS[j][1] = shortest\n # del(cVLS[i])\n # break","def get_emissivity_offsets(self):\n emissivity = self.ancillarydata['emissivity']\n min_emissivity = np.amin(emissivity)\n max_emissivity = np.amax(emissivity)\n\n logger.debug('Minimum emissivity value is {}'.format(min_emissivity))\n logger.debug('Maximum emissivity value is {}'.format(max_emissivity))\n\n if min_emissivity in self.emissivities.keys() and max_emissivity in self.emissivities.keys():\n startemiss = self.emissivities[min_emissivity]\n stopemiss = self.emissivities[max_emissivity]\n else:\n #Case where emissivities are not in the dict keys, need to find the closest\n #TODO: Emissivity is considered constant at the moment\n startemiss = None\n stopemiss = None\n return startemiss, stopemiss","def find_overlap_range_list(points_list):\n highest_start_point = points_list[0][0]\n lowest_end_point = points_list[0][0] + points_list[0][1]\n\n for point in points_list[1:]:\n highest_start_point = max(highest_start_point, point[0])\n lowest_end_point = min(lowest_end_point, point[1]+point[0])\n\n if lowest_end_point <= highest_start_point:\n return None\n\n return [highest_start_point, lowest_end_point - highest_start_point]"],"string":"[\n \"def intersection_distances(self, altitude, start_distance, finish_distance):\\n distances = []\\n alt_index, alt_ratio = calculate_value_reference(self.distances,\\n start_distance)\\n start_alt = calculate_value(self.altitudes, alt_index, alt_ratio)\\n\\n finish_index, finish_ratio = calculate_value_reference(self.distances,\\n finish_distance)\\n while alt_index < finish_index:\\n next_index = alt_index + 1\\n next_ratio = 0.0\\n next_alt = calculate_value(self.altitudes, next_index, next_ratio)\\n\\n # Does this section span the given altitude?\\n if (next_alt != start_alt) and \\\\\\n (min(start_alt, next_alt) < altitude < max(start_alt, next_alt)):\\n delta = altitude - start_alt\\n denom = next_alt - start_alt\\n ratio = delta / denom\\n distance = calculate_value(self.distances, alt_index, ratio)\\n distances.append(distance)\\n\\n alt_index = next_index\\n alt_ratio = next_ratio\\n start_alt = next_alt\\n\\n if finish_ratio:\\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\\n # Does the last section span the given altitude?\\n if (start_alt != finish_alt) and \\\\\\n (min(start_alt, finish_alt) < altitude < max(start_alt, finish_alt)):\\n # Calculate the altitude at the end of the section to maximimse accuracy\\n next_alt = calculate_value(self.altitudes, finish_index, 1.0)\\n delta = altitude - start_alt\\n denom = next_alt - start_alt\\n ratio = delta / denom\\n distance = calculate_value(self.distances, alt_index, ratio)\\n distances.append(distance)\\n\\n return distances\",\n \"def altitude_range(self, start_distance, finish_distance):\\n start_index, start_ratio = calculate_value_reference(self.distances,\\n start_distance)\\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\\n finish_index, finish_ratio = calculate_value_reference(self.distances,\\n finish_distance)\\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\\n\\n min_alt = min(start_alt, finish_alt)\\n max_alt = max(start_alt, finish_alt)\\n\\n if start_index < finish_index:\\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\\n min_alt = min(min_alt, altitudes.min())\\n max_alt = max(max_alt, altitudes.max())\\n\\n return min_alt, max_alt\",\n \"def startEndPoints(mazz):\\n for i in range (len(mazz)):\\n for j in range (len(mazz[i])):\\n if mazz[i][j] == 6:\\n startx = i\\n starty = j\\n elif mazz[i][j] == 7:\\n endx = i\\n endy = j\\n return startx, starty, endx, endy\",\n \"def find_isolated_endpoints(lines):\\n \\n isolated_endpoints = []\\n count = len(lines)\\n print(\\\"Finding isolated end points 2/3\\\")\\n pb = pbar.ProgressBar(count)\\n for i, line in enumerate(lines):\\n pb += 1\\n other_lines = lines[:i] + lines[i+1:]\\n for q in [0,-1]:\\n endpoint = Point(line.coords[q])\\n if any(endpoint.touches(another_line) \\n for another_line in other_lines):\\n continue\\n else:\\n isolated_endpoints.append(endpoint)\\n del pb\\n return isolated_endpoints\",\n \"def get_lat_offsets(self):\\n\\n startlat = self.parameters['startlatitude']\\n stoplat = self.parameters['stoplatitude']\\n\\n #Given the start and stops,\\n startidx, startvalue = utils.getnearest(self.latitudes, startlat)\\n stopidx, stopvalue = utils.getnearest(self.latitudes, stoplat)\\n startidx -= 2\\n stopidx += 2\\n latslice = np.arange(startidx, stopidx + 1)\\n if utils.checkmonotonic(latslice):\\n latslice = latslice\\n else:\\n #TODO: Support pole crossing images\\n logger.error('Image is pole crossing, not currently supported.')\\n '''\\n print \\\"NOT MONOTONIC\\\"\\n #Handle wraps around the poles\\n latslice = np.arange(start_idx, stop_idx + 1)\\n nlats = self.startlookup.shape[1]\\n greatermask = np.where(latslice >= nlats)\\n latslice[greatermask] -= nlats\\n lessmask = np.where(latslice < 0)\\n latslice[lessmask] += self.startlookup.shape[1]\\n\\n self.latsort = np.argsort(latslice)\\n self.latslice = latslice[self.latsort]\\n self.latsort = np.argsort(self.latsort)\\n '''\\n latslice = None\\n logger.debug('Start latitude node is {}. Nearest lookup node is {}.'.format(startlat, startidx))\\n logger.debug('Stop latitude node is {}. Nearest lookup node is {}.'.format(stoplat, stopidx))\\n return latslice\",\n \"def create_adjacent_stop_pairs(trips):\\n\\n stop_pairs = []\\n\\n sorted_trips = trips.sort_values(\\n ['TRIPID', 'PROGRNUMBER']).reset_index(drop=True)\\n\\n # For each trip match up pairs of adjacent stops and calculate how long it\\n # took to travel between them\\n for trip_id in sorted_trips['TRIPID'].unique():\\n\\n # Filter down to just this trip\\n trip = sorted_trips[sorted_trips['TRIPID'] ==\\n trip_id].sort_values(['TRIPID', 'PROGRNUMBER'])\\n\\n stop_pairs_trip = trip.copy()\\n stop_pairs_trip = stop_pairs_trip.rename(columns={\\n 'ACTUALTIME_DEP': 'time_departure',\\n 'STOPPOINTID': 'departure_stop'\\n })\\n\\n # arrival stop and time are from the next row\\n stop_pairs_trip.loc[:,\\n 'arrival_stop'] = stop_pairs_trip.shift(-1).loc[:, 'departure_stop']\\n stop_pairs_trip.loc[:,\\n 'time_arrival'] = stop_pairs_trip.shift(-1).loc[:, 'ACTUALTIME_DEP']\\n stop_pairs_trip['travel_time'] = stop_pairs_trip[\\\"time_arrival\\\"] - \\\\\\n stop_pairs_trip[\\\"time_departure\\\"]\\n\\n # Only keep pairs with consecutive PROGRNUMBER\\n stop_pairs_trip = stop_pairs_trip[stop_pairs_trip['PROGRNUMBER'] == (\\n stop_pairs_trip.shift(-1)['PROGRNUMBER'] - 1)]\\n\\n # Add it to the DF of all stop pairs\\n stop_pairs.append(stop_pairs_trip)\\n\\n return pd.concat(stop_pairs)\",\n \"def determine_next_stop(current_location, stops):\\n possible_stop = {}\\n for stop in stops:\\n # calculates the distance between the current location and the next possible stop\\n calculated_distance = csv_reader.distance_lookup(current_location, stop)\\n\\n # adds a key value pair of possible trip (a tuple) and the distance of that trip\\n possible_stop[(current_location, stop)] = float(calculated_distance)\\n return possible_stop\",\n \"def find_rpt_coords(self) -> (int, int):\\n start_size = self.size\\n end_size = self.size + len(self.allele)\\n coord = self.coord\\n fasta_alt = self.fasta_alt\\n while self.allele == fasta_alt:\\n coord += len(self.allele)\\n start_size += len(self.allele)\\n end_size += len(self.allele)\\n fasta_alt = self.seq[start_size:end_size]\\n new_start = coord - len(self.allele)\\n new_end = new_start + len(self.allele) - 1\\n return new_start, new_end\",\n \"def find_cruise_sections(altitudes):\\n indicies = find_level_sections(altitudes)\\n\\n if indicies:\\n prev_altitude = altitudes[indicies[0]]\\n cruise_altitude = closest_cruising_altitude(prev_altitude)\\n was_cruising = is_cruising(prev_altitude, cruise_altitude)\\n prev_altitude = cruise_altitude if was_cruising else prev_altitude\\n\\n merge_indicies = []\\n for index in range(2, len(indicies), 2):\\n altitude = altitudes[indicies[index]]\\n cruise_altitude = closest_cruising_altitude(altitude)\\n if is_cruising(altitude, cruise_altitude):\\n # If the aircraft cruised between the level ranges,\\n if was_cruising and (prev_altitude == cruise_altitude) and \\\\\\n in_cruise_level_range(altitudes[indicies[index - 1] + 1: indicies[index]],\\n cruise_altitude):\\n # merge the level indicies\\n merge_indicies.append(index - 1)\\n merge_indicies.append(index)\\n\\n prev_altitude = cruise_altitude\\n was_cruising = True\\n else: # level but not at a cruising level\\n merge_indicies.append(index)\\n merge_indicies.append(index + 1)\\n prev_altitude = altitude\\n was_cruising = False\\n\\n # merge the level indicies\\n while merge_indicies:\\n index = merge_indicies.pop()\\n del indicies[index]\\n\\n return indicies\",\n \"def _get_marker_indices(marker, line):\\n indices = [i for i, ltr in enumerate(line) if ltr == marker]\\n start = indices[0:-1:2]\\n end = [i + 1 for i in indices[1::2]]\\n assert len(start) == len(end)\\n return start, end\",\n \"def consecutive_sections(): # noqa: D416\",\n \"def get_head_and_tail(street):\\r\\n def is_end(location):\\r\\n num_adj = 0\\r\\n adj = get_orthogonal(location)\\r\\n for merchant in street:\\r\\n if merchant != location and merchant in adj:\\r\\n num_adj += 1\\r\\n return num_adj <= 1\\r\\n return [loc for loc in street if is_end(loc)]\",\n \"def longest_flight(self):\\r\\n distance = 0\\r\\n for code, _list in self.edges.items():\\r\\n for edge in _list:\\r\\n if edge.distance > distance:\\r\\n distance = edge.distance\\r\\n start = edge.start\\r\\n destination = edge.destination\\r\\n return start, destination, distance\",\n \"def flightLegs(Alist,start,dest):\\n Alen = len(Alist) #length of Alist\\n index = list(range(Alen)) #list of airport indexes\\n Adict = dict(zip(index,Alist)) #zip into dictionary\\n #Adict = dict.fromkeys(range(Alen),large value) possibly qiucker?\\n \\n Flights = [] #output\\n\\n checked = [] #empty list\\n tocheck = deque() #empty deque for a queue of paths to be checked\\n tocheck.append([start])\\n \\n if start == dest: #trivial case\\n return \\\"trivial case explored\\\"\\n \\n while tocheck: #while there are elements in tocheck\\n path = tocheck.popleft() #pop out a path to be checked\\n node = path[-1] #extract last element of path, this node represents an airport\\n if node not in checked: #check if this path terminates in a new node/airport\\n adjacents = Adict[node] #look up in dictionary airport index and return list of adjacent airports\\n for n in adjacents: #extracts nodes inside list of adjacents\\n if n not in checked:\\n new_path = path +[n] #add neighbour to this current path\\n tocheck.append(new_path) #put this new path into the queue to be checked\\n if n == dest: #if this neighbour is the final destination, then the new path is the full path\\n if len(Flights)==0:\\n Flights.append(new_path)\\n elif len(new_path)==len(Flights[-1]):\\n Flights.append(new_path)\\n else:\\n return (len(Flights[0]),len(Flights))\\n \\n checked.append(node)\\n\\n return Flights #finds all paths need to modify to stop after a path of non shortest length is found\",\n \"def _findTangentSplitExisting(self, frames, start, end, step):\\n splits = []\\n inTangentType = \\\"step\\\"\\n outTangentType = \\\"stepnext\\\"\\n\\n inAngles = cmds.keyTangent(self.path, query=True, time=(start, end), inAngle=True)\\n outAngles = cmds.keyTangent(self.path, query=True, time=(start, end), outAngle=True)\\n inTangentTypes = cmds.keyTangent(self.path, query=True, time=(start, end), inTangentType=True)\\n outTangentTypes = cmds.keyTangent(self.path, query=True, time=(start, end), outTangentType=True)\\n\\n iterator = zip(frames, inAngles, outAngles, inTangentTypes, outTangentTypes)\\n for frame, inAngle, outAngle, inType, outType in iterator:\\n # get closest index\\n index = int((frame - start) / step)\\n\\n # validate split\\n if abs(inAngle - outAngle) > THRESHOLD:\\n splits.append(index)\\n elif inType == inTangentType:\\n splits.append(index)\\n elif outType == outTangentType:\\n splits.append(index)\\n\\n return splits\",\n \"def _all_dist_to_end(args):\\n idx = args[0]\\n spiketrains = args[1]\\n start = args[2]\\n end = args[3]\\n N = args[4]\\n num_spiketrains = len(spiketrains)\\n distances = []\\n for jdx in range(idx+1, num_spiketrains):\\n dist = distance(spiketrains[idx], spiketrains[jdx], start, end, N)\\n times = dist[0] # should be the same for all\\n distances.append(dist[1])\\n return times, distances\",\n \"def identifyPutativeFields(tuning_curve):\\r\\n\\r\\n tuning_curve = np.copy(tuning_curve)\\r\\n tuning_curve = np.around(tuning_curve, decimals=3)\\r\\n elevated_indices = np.nonzero(tuning_curve)[0]\\r\\n if len(elevated_indices) == 0:\\r\\n return [[], []]\\r\\n\\r\\n putative_starts = []\\r\\n putative_ends = []\\r\\n\\r\\n putative_start = elevated_indices[0]\\r\\n\\r\\n while putative_start is not None:\\r\\n putative_starts.append(putative_start)\\r\\n # when does it return to zero?\\r\\n try:\\r\\n putative_end = putative_start + np.amin(\\r\\n np.where(tuning_curve[putative_start:] == 0)) - 1\\r\\n except ValueError:\\r\\n # does not return to 0\\r\\n putative_end = len(tuning_curve) - 1\\r\\n\\r\\n putative_ends.append(putative_end)\\r\\n\\r\\n try:\\r\\n putative_start = np.amin(\\r\\n elevated_indices[elevated_indices > putative_end])\\r\\n except ValueError:\\r\\n # no more intervals > 0\\r\\n putative_start = None\\r\\n\\r\\n # correct the wrap-around case\\r\\n if 0 in putative_starts and len(tuning_curve) - 1 in putative_ends and \\\\\\r\\n len(putative_starts) > 1:\\r\\n putative_starts.pop(0)\\r\\n putative_ends[-1] = putative_ends.pop(0)\\r\\n\\r\\n return putative_starts, putative_ends\",\n \"def ends_with_lt_tonic(a_list):\\n key = a_list.track.bars[0].key\\n a, b = a_list.notes[-2:]\\n lt, tonic = Note(key).transpose('7', True).name, key.name\\n\\n if (a.name, b.name) == (lt, tonic) and int(b) - int(a) == 1:\\n return []\\n else:\\n return [a.start, b.start]\",\n \"def compute_start_end_points(linestrings):\\n starts = []\\n stops = []\\n for ls in linestrings:\\n pt = Point(ls.coords[0])\\n starts.append(round(CONUS[\\\"poly\\\"].exterior.project(pt), 2))\\n pt = Point(ls.coords[-1])\\n stops.append(round(CONUS[\\\"poly\\\"].exterior.project(pt), 2))\\n return starts, stops\",\n \"def count_ranges(a):\\n ranges = []\\n count = 0\\n for i, v in enumerate(a):\\n if v == 1: # same as previous value\\n count += 1\\n else:\\n if count > 1:\\n ranges.append([i, count]) # [end, length]\\n count = 0\\n return ranges\",\n \"def find_ranges(iterable):\\n for group in mit.consecutive_groups(iterable):\\n group = list(group)\\n if len(group) == 1:\\n yield [group[0], group[0]]\\n else:\\n yield [group[0], group[-1]]\\n return group\",\n \"def adjacentPairs(patches, borderWidth=2):\\r\\n\\r\\n keyList = patches.keys()\\r\\n pairKeyList = []\\r\\n\\r\\n for pair in combinations(keyList, 2):\\r\\n patch1 = patches[pair[0]]\\r\\n patch2 = patches[pair[1]]\\r\\n\\r\\n if (ia.is_adjacent(patch1.array, patch2.array, borderWidth=borderWidth)) and (patch1.sign == patch2.sign):\\r\\n pairKeyList.append(pair)\\r\\n\\r\\n return pairKeyList\",\n \"def scan( gaps, center, dist ):\\n return _scan_reverse( gaps, center, dist ), _scan_forward( gaps, center, dist )\",\n \"def get_steps_between_peaks(self):\\n max_x, max_y = self.get_local_maxes()\\n full_steps = np.ediff1d(max_x)\\n # _full_mean, _full_std = np.mean(full_steps), np.std(full_steps)\\n _full_count = len(full_steps)\\n\\n unique_steps_between_peaks, unique_steps_counts = np.unique(full_steps, return_counts=True)\\n\\n _filter = np.logical_and(full_steps < unique_steps_between_peaks[np.argmax(unique_steps_counts)] * 1.7,\\n full_steps > unique_steps_between_peaks[np.argmax(unique_steps_counts)] * 0.3)\\n # 1.7 chosen as filter, as there seems to be another peak ~2* (probably due to single missed peaks)\\n # 1.7 avoids the start of the gaussian at 2*\\n\\n if not _filter.all():\\n steps = full_steps[_filter]\\n # print(unique_steps_between_peaks[np.argmax(unique_steps_counts)])\\n _filtered_count = len(steps)\\n _counts = (_full_count, _filtered_count, _full_count - _filtered_count)\\n # print('Original Count: %s, Filtered Count: %s, Excluded Count: %s' % _counts)\\n # print('Filtered:', full_steps[np.invert(_filter)])\\n unique_steps_between_peaks, unique_steps_counts = np.unique(steps, return_counts=True)\\n else:\\n steps = full_steps\\n\\n return steps, unique_steps_between_peaks, unique_steps_counts\",\n \"def get_3away_pairs(kmers):\\n k = len(kmers[0])\\n if k == 1 or k==2:\\n return []\\n if k == 3:\\n return [pair for pair in combinations(kmers, 2) if pair[0][0] != pair[1][0] and pair[0][1] != pair[1][1] and pair[0][2] != pair[1][2]]\\n k_L = k//2\\n k_R = k-k_L\\n kmer_L_hashes = defaultdict(list)\\n kmer_R_hashes = defaultdict(list)\\n pairs = []\\n kmers_L = []\\n kmers_R = []\\n for i, kmer in enumerate(kmers):\\n kmer_L = kmer[:k_L]\\n kmer_R = kmer[k_L:]\\n #print(kmer_L)\\n #print(kmer_R)\\n kmers_L.append(kmer_L)\\n kmers_R.append(kmer_R)\\n kmer_L_hashes[kmer_to_int(kmer_L)] += [i]\\n kmer_R_hashes[kmer_to_int(kmer_R)] += [i]\\n for kmer_L_hash in kmer_L_hashes.values(): #same in first half\\n if len(kmer_L_hash) > 1:\\n kmer_L = kmers[kmer_L_hash[0]][:k_L] #first half\\n pairs += [tuple(kmer_L + kmer for kmer in pair) for pair in get_3away_pairs([kmers[i][k_L:] for i in kmer_L_hash])] #differ by 3 in second half\\n for kmer_R_hash in kmer_R_hashes.values(): #same in second half\\n if len(kmer_R_hash) > 1:\\n kmer_R = kmers[kmer_R_hash[0]][k_L:] #second half\\n #print(kmer_R)\\n pairs += [tuple(kmer + kmer_R for kmer in pair) for pair in get_3away_pairs([kmers[i][:k_L] for i in kmer_R_hash])] #differ by 3 in first half\\n possible_pairs = []\\n possible_pairs_L = get_1away_pairs(kmers_L)\\n possible_pairs_R = get_2away_pairs(kmers_R)\\n #print(kmers_L)\\n #print(kmers_R)\\n #print(possible_pairs_L)\\n #print(possible_pairs_R)\\n for possible_pair_L in possible_pairs_L:\\n for possible_pair_R in possible_pairs_R:\\n possible_kmer1 = possible_pair_L[0]+possible_pair_R[0]\\n possible_kmer2 = possible_pair_L[1]+possible_pair_R[1]\\n if possible_kmer1 in kmers and possible_kmer2 in kmers:\\n pairs += [(possible_kmer1, possible_kmer2)]\\n possible_pairs = []\\n possible_pairs_L = get_2away_pairs(kmers_L)\\n possible_pairs_R = get_1away_pairs(kmers_R)\\n for possible_pair_L in possible_pairs_L:\\n for possible_pair_R in possible_pairs_R:\\n possible_kmer1 = possible_pair_L[0]+possible_pair_R[0]\\n possible_kmer2 = possible_pair_L[1]+possible_pair_R[1]\\n if possible_kmer1 in kmers and possible_kmer2 in kmers:\\n pairs += [(possible_kmer1, possible_kmer2)]\\n return(pairs)\",\n \"def find_start_and_end(arr):\\n start = None\\n end = None\\n for i, line in enumerate(arr):\\n for j, node in enumerate(line):\\n if node.symbol is 'A':\\n start = node\\n if node.symbol is 'B':\\n end = node\\n return start, end\",\n \"def get_hour_offsets(self):\\n starttime = self.parameters['startlocaltime']\\n stoptime = self.parameters['stoplocaltime']\\n timediff = (stoptime - starttime)\\n logger.debug(\\\"Start time: {} | Stop time: {}\\\".format(starttime, stoptime))\\n if timediff > config.TIME_THRESHOLD:\\n logger.debug(\\\"Time delta is {}. This is significantly larger than anticipated\\\".format(timediff))\\n else:\\n logger.debug(\\\"Time delta is {}. Using start time as the global time\\\".format(timediff))\\n\\n \\\"\\\"\\\"\\n timediff = (stoptime - starttime).total_seconds()\\n logger.debug(\\\"Start time: {} | Stop time: {}\\\".format(starttime, stoptime))\\n #TODO: How do we want to handle large images with huge time differences?\\n if timediff > config.TIME_THRESHOLD:\\n logger.debug(\\\"Time delta is {}. This is significantly larger than anticipated\\\".format(timediff))\\n starttime = starttime\\n else:\\n logger.debug(\\\"Time delta is {}. Using start time as the global time\\\".format(timediff))\\n \\\"\\\"\\\"\\n #Given the image start time, find the nearest index and set to the middle,\\n # then find the adjacent two nodes in both directions to get allow a\\n # cubic interpolation.\\n #image_time = starttime.hour + starttime.minute / 60.0\\n # This grabs the hour that is nearest, but hour is circular\\n image_time = starttime\\n if abs(image_time - 24) < abs(image_time - 23.5):\\n image_time -= 24\\n mididx, midhour = utils.getnearest(self.times, image_time)\\n logger.debug(\\\"Time is {}. The nearest lookup node is {}\\\".format(image_time, mididx))\\n minidx = mididx - 2\\n maxidx = mididx + 2\\n\\n hourslice = np.arange(minidx, maxidx + 1, dtype=np.int8)\\n\\n hourslice[hourslice < 0] += 18\\n\\n if hourslice[-1] >= len(self.times):\\n #The hour slice needs to be shifted over the time break\\n hourslice[hourslice >= len(self.times)] -= len(self.times)\\n logger.debug(\\\"Using indices {} and start time of {}.\\\".format(hourslice, image_time))\\n return hourslice, image_time\",\n \"def adjacencies(self, tile, tile_set):\\n r, c = tile\\n ns = []\\n for d, (dr, dc) in self._offsets.items():\\n other = (r + dr, c + dc)\\n if other in tile_set:\\n ns.append((d, other))\\n return ns\",\n \"def find_edges(starting_point, max_dist, hi, lo, bgArray):\\n try:\\n b = fetch_val(bgArray, starting_point)\\n except IndexError:\\n return None\\n offsets = [(0,1), (1,0), (0,-1), (-1,0)]\\n edgePoints = []\\n for offset in offsets:\\n first_result = find_edge(starting_point, offset, max_dist, hi, lo, bgArray)\\n if first_result is not None:\\n edgePoints.append(first_result[0])\\n if b < lo or b > hi:\\n # Try to find second point, since starting click was outside threshold\\n second_result = find_edge(first_result[0], offset, max_dist - first_result[1], hi, lo, bgArray)\\n if second_result is not None:\\n edgePoints.append(second_result[0])\\n return edgePoints\",\n \"def _pair_indices(self):\\n indices_src = []\\n indices_dst = []\\n for i in range(self.walk_len):\\n for j in range(max(i - self.l, 0), i):\\n indices_src.append(i)\\n indices_dst.append(j)\\n for j in range(i + 1, min(i + self.r + 1, self.walk_len)):\\n indices_src.append(i)\\n indices_dst.append(j)\\n return indices_src, indices_dst\",\n \"def entryPair(self):\\n exitPair = {}\\n deadEnd = self.searchDeadEnd()\\n deadPoints = []\\n deadRoads = deadEnd.copy()\\n for (x,y) in deadEnd:\\n # if (x,y) not in deadPoints:\\n adjacent = self.scanmap.adjacentValidPoints(x, y)\\n BFS = util.Queue()\\n visited = []\\n BFS.push((x,y))\\n while not BFS.isEmpty():\\n (i,j) = BFS.pop()\\n visited.append((i, j))\\n adjacents = self.scanmap.adjacentValidPoints(i,j)\\n for position in adjacents:\\n if not position in deadRoads:\\n exitPoint = position\\n if position in deadRoads and not position in visited:\\n BFS.push(position)\\n if exitPoint in exitPair.keys():\\n exitPair[exitPoint] = list(set(visited).union(set(exitPair[exitPoint])))\\n else:\\n exitPair[exitPoint] = visited\\n deadPoints = list(set(deadEnd).difference(set(visited)))\\n\\n return exitPair\",\n \"def calculateTrackBetweenFlights(lat1,lon1,lat2,lon2):\\n\\treturn Geodesic.WGS84.Inverse(lat1,lon1, lat2, lon2)['azi1']\",\n \"def puzzle2(offsets):\\n return find_jumps_to_exit(offsets, lambda o: o + 1 if o < 3 else o - 1)\",\n \"def get_continous_time_periods(binary_array):\\n binary_array = np.copy(binary_array).astype(\\\"int8\\\")\\n n_times = len(binary_array)\\n d_times = np.diff(binary_array)\\n # show the +1 and -1 edges\\n pos = np.where(d_times == 1)[0] + 1\\n neg = np.where(d_times == -1)[0] + 1\\n\\n if (pos.size == 0) and (neg.size == 0):\\n if len(np.nonzero(binary_array)[0]) > 0:\\n return [(0, n_times-1)]\\n else:\\n return []\\n elif pos.size == 0:\\n # i.e., starts on an spike, then stops\\n return [(0, neg[0])]\\n elif neg.size == 0:\\n # starts, then ends on a spike.\\n return [(pos[0], n_times-1)]\\n else:\\n if pos[0] > neg[0]:\\n # we start with a spike\\n pos = np.insert(pos, 0, 0)\\n if neg[-1] < pos[-1]:\\n # we end with aspike\\n neg = np.append(neg, n_times - 1)\\n # NOTE: by this time, length(pos)==length(neg), necessarily\\n h = np.matrix([pos, neg])\\n # print(f\\\"len(h[1][0]) {len(h[1][0])} h[1][0] {h[1][0]} h.size {h.size}\\\")\\n if np.any(h):\\n result = []\\n for i in np.arange(h.shape[1]):\\n if h[1, i] == n_times-1:\\n result.append((h[0, i], h[1, i]))\\n else:\\n result.append((h[0, i], h[1, i]-1))\\n return result\\n return []\",\n \"def find_offsets(self):\\r\\n\\r\\n #### Begin functionality here\\r\\n\\r\\n return()\",\n \"def calc_distances(marker_list, rf_pairs):\\n final_distance = [[marker_list[0], 0]]\\n\\n for i in range(1, len(marker_list)):\\n cur_markers = [marker_list[i-1], marker_list[i]]\\n for rf_pair in rf_pairs:\\n if rf_pair[0] in cur_markers and rf_pair[1] in cur_markers:\\n final_distance.append([cur_markers[1], rf_pairs[rf_pair]])\\n break\\n return final_distance\",\n \"def puzzle1(offsets):\\n return find_jumps_to_exit(offsets, lambda o: o + 1)\",\n \"def find_cruise_positions(num_altitudes, cruise_indicies):\\n cruise_positions = np.zeros(num_altitudes, dtype=bool)\\n\\n if cruise_indicies:\\n for index in range(0, len(cruise_indicies), 2):\\n start = cruise_indicies[index] + 1\\n stop = cruise_indicies[index + 1]\\n if start < stop:\\n cruise_positions[start: stop] = True\\n\\n return cruise_positions\",\n \"def get_slopes(timestep):\\n pathing_grid = timestep.game_info.start_raw.pathing_grid\\n placement_grid = timestep.game_info.start_raw.placement_grid\\n terrain_height = timestep.game_info.start_raw.terrain_height\\n pathing = bitmap2array(pathing_grid)\\n placement = bitmap2array(placement_grid)\\n height = bitmap2array(terrain_height)\\n\\n slopes = []\\n for i in range(pathing_grid.size.x):\\n for j in range(pathing_grid.size.y):\\n if pathing[i, j] == 0 and placement[i, j] == 0:\\n slope_item = extract_slope(i, j, pathing, placement, height)\\n if slope_item.min_h != slope_item.max_h:\\n slopes.append(slope_item)\\n return slopes\",\n \"def get_loop_borders(pdb_hierarchy, center_resnum_list, ss_annot):\\n f_start_res_num =-9999\\n f_end_res_num = 9999999\\n if ss_annot is not None:\\n for elem in ss_annot.simple_elements():\\n if f_start_res_num < elem.get_end_resseq_as_int() <= hy36decode(4, center_resnum_list[0]):\\n # print \\\" cutting...\\\"\\n f_start_res_num = elem.get_end_resseq_as_int()\\n if hy36decode(4, center_resnum_list[-1]) <= elem.get_start_resseq_as_int() < f_end_res_num:\\n # print \\\" cutting...\\\"\\n f_end_res_num = elem.get_start_resseq_as_int()\\n loop_length = f_end_res_num - f_start_res_num\\n return f_start_res_num, f_end_res_num\",\n \"def _get_minimal_lanes(self):\\n return np.argwhere(self.end_of_lanes == np.min(self.end_of_lanes)).flatten()\",\n \"def matching_time_indices(stamps_1, stamps_2, max_diff=0.01, offset_2=0.0):\\n matching_indices = []\\n stamps_2 = copy.deepcopy(stamps_2)\\n stamps_2 += offset_2\\n for stamp in stamps_1:\\n diffs = np.abs(stamps_2 - stamp)\\n argmin = np.argmin(diffs)\\n if diffs[argmin] <= max_diff:\\n matching_indices.append(argmin)\\n return matching_indices\",\n \"def find_pair(line):\\n if len(line) >1:\\n for dummy_i in range(0,len(line) - 1):\\n if line[dummy_i] !=0 and line[dummy_i] == line[dummy_i+1]:\\n return True\\n return False\",\n \"def compute_previous_intervals(I):\\n # extract start and finish times\\n start = [i.left for i in I]\\n finish = [i.right for i in I]\\n\\n p = []\\n for j in range(len(I)):\\n # rightmost interval f_i <= s_j\\n i = bisect.bisect_right(finish, start[j]) - 1\\n p.append(i)\\n\\n return p\",\n \"def getEnds(self) -> List[int]:\\n ...\",\n \"def calculateOverlap(mfaPairs, exons1, exons2):\\n exonSize = 0\\n noMatchToExons = 0\\n noMatchToNonExons = 0\\n noMatchToGapsInExons = 0\\n noMatchToGapsNotInExons = 0\\n \\n p = -100000\\n for i in exons1:\\n exonSize += i[1] - i[0]\\n for j in xrange(i[0], i[1]):\\n k = mfaPairs[j]\\n l = k\\n if k == GAP:\\n l = p \\n for m in exons2:\\n if(l >= m[0] and l < m[1]):\\n if k == GAP:\\n noMatchToGapsInExons += 1\\n else:\\n noMatchToExons += 1\\n break\\n else:\\n if k == GAP:\\n noMatchToGapsNotInExons += 1\\n else:\\n noMatchToNonExons += 1\\n if k != GAP:\\n p = k\\n return (exonSize, noMatchToExons, noMatchToNonExons,\\\\\\n noMatchToGapsInExons, noMatchToGapsNotInExons)\",\n \"def pairs_from_list(lights):\\n length = len(lights)\\n half = int(length / 2)\\n offset = 0\\n\\n centre = None\\n if length % 2 == 1:\\n centre = lights[half]\\n offset = 1\\n\\n left = lights[:half]\\n\\n rh_start = half + offset\\n right = reversed(lights[rh_start:])\\n\\n pairs = list(map(list, zip(left, right)))\\n\\n if centre:\\n pairs.append([centre])\\n\\n return pairs\",\n \"def sum_light(\\n els: List[Union[datetime, Tuple[datetime, int]]],\\n start_watching: Optional[datetime] = None,\\n end_watching: Optional[datetime] = None,\\n) -> int:\\n # replace elements with no bulb index\\n els, switch = [(e, 0) if type(e) is datetime else e for e in els], [False] * 10\\n sw, ew, on = start_watching or els[0][0], end_watching or els[-1][0], []\\n # determine what intervals any lamp is on\\n for idx, e in enumerate(els):\\n switch[e[1]], els[idx] = not switch[e[1]], min(ew, max(e[0], sw))\\n on.append(any(switch))\\n # then summ all intervals where any lamp is on\\n els += [ew]\\n return sum(on[i] * (els[i + 1] - els[i]).total_seconds() for i in range(len(on)))\",\n \"def get_altitude(points):\\n altitudes = np.zeros((len(points),), dtype=\\\"float64\\\")\\n for i, point in tqdm(enumerate(points), desc=\\\"GETTING ALTITUDE\\\"):\\n p = Point(point[0], point[1])\\n altitudes[i] = alt.NM_COTA.iloc[\\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\\n ]\\n return altitudes\",\n \"def identify_outliers_consecutive(self, max_vel):\\r\\n if 'Dry' in self.outlier_methods:\\r\\n flagged = self.rec_track['Dry'].copy()\\r\\n niterations = 1\\r\\n for nit in range(0,niterations):\\r\\n not_flagged = np.where(flagged==0)[0]\\r\\n valid_tr = self.rec_track[not_flagged]\\r\\n # compute segments associated with valid detects\\r\\n nvalid = len(valid_tr)\\r\\n if nvalid < 3:\\r\\n self.valid = False\\r\\n return flagged\\r\\n valid_seg = self.make_segments(input_rec_track = valid_tr)\\r\\n for ndv in range(1,nvalid-1):\\r\\n sp1 = valid_seg.speed[ndv-1]\\r\\n sp2 = valid_seg.speed[ndv]\\r\\n if (sp1 > max_vel) and (sp2 > max_vel):\\r\\n nd_orig = valid_tr[ndv].nd\\r\\n flagged[nd_orig] = 1\\r\\n\\r\\n ncol = len(self.df_track.columns)\\r\\n self.df_track.insert(ncol, 'Consecutive', flagged)\\r\\n ncol = len(self.df_track.columns)\\r\\n\\r\\n return flagged\",\n \"def part1(problem_input: Iterable[str], row_y: int) -> int:\\n sensor_beacons: dict[Point, tuple[Point, int]] = {\\n Point(int(sx), int(sy)): (\\n Point(int(bx), int(by)),\\n distance(Point(int(sx), int(sy)), Point(int(bx), int(by))),\\n )\\n for sx, sy, bx, by in [\\n re.match(\\n r\\\"Sensor at x=([0-9-]+), y=([0-9-]+): closest beacon is at x=([0-9-]+), y=([0-9-]+)\\\",\\n line,\\n ).groups() # type: ignore\\n for line in problem_input\\n ]\\n }\\n\\n min_x = min(s.x - d for s, (_, d) in sensor_beacons.items())\\n max_x = max(s.x + d for s, (_, d) in sensor_beacons.items())\\n\\n ruled_out: set[Point] = set()\\n for x in range(min_x, max_x + 1):\\n p = Point(x, row_y)\\n for s, (b, d) in sensor_beacons.items():\\n if distance(s, p) <= d and p != b:\\n ruled_out.add(p)\\n break\\n return len(ruled_out)\",\n \"def expander(i_start, j_end, length):\\n\\n # create list of paired i indices\\n i_s = list(np.arange(i_start, i_start + length))\\n\\n # create list of corresponding j indices:\\n j_s = list(np.arange(j_end, j_end + length))\\n\\n # form list of tuple pairs\\n pairs = list(zip(i_s, j_s))\\n\\n return pairs\",\n \"def find_endpoints(batch_trajectories):\\n # empty lists to fill\\n site_lats = []\\n site_lons = []\\n last_lats = []\\n last_lons = []\\n lats_150 = []\\n lons_150 = [] \\n last_times = []\\n times_150 = []\\n last_sst = []\\n sst_150 = []\\n \\n # temporary lists as placeholders\\n temp_site_lats = []\\n temp_site_lons = []\\n temp_lats = []\\n temp_lons = []\\n temp_lats150 = []\\n temp_lons150 = []\\n temp_times = []\\n temp_times150 = []\\n temp_sst = []\\n temp_sst150 = []\\n\\n for speed in range(len(batch_trajectories)):\\n # working with one speed at a time means working with one nc file at\\n # a time\\n \\n # reset temporary lists\\n temp_site_lats = []\\n temp_site_lons = []\\n temp_lats = []\\n temp_lons = []\\n temp_lats150 = []\\n temp_lons150 = []\\n temp_times = []\\n temp_times150 = []\\n temp_sst = []\\n temp_sst150 = []\\n\\n # extract variables into lists\\n lats = batch_trajectories[speed].variables['lat'][:]\\n lons = batch_trajectories[speed].variables['lon'][:]\\n lats150 = batch_trajectories[speed].variables['lat150'][:]\\n lons150 = batch_trajectories[speed].variables['lon150'][:]\\n times = batch_trajectories[speed].variables['time'][:]\\n ssts = batch_trajectories[speed].variables['temp'][:]\\n ssts_150 = batch_trajectories[speed].variables['temp150'][:]\\n\\n # if a particle is deleted before time is up, values are masked. \\n # We'd like to get the last valid number.\\n for trajectory in range(len(lats)):\\n i = -1 # index for the last value\\n while np.ma.is_masked(lats[trajectory][i]) is True:\\n i -= 1 # if the value is masked, go to one value sooner\\n \\n j = i # use j for the 150m values\\n while lats150[trajectory][j] > 0:\\n # we want the first index where the latitude is recorded.\\n # j is actually the last one where it's not recorded, so we\\n # extract the information at index j+1\\n j -= 1\\n\\n # once i and j are determined for a trajectory, we can extract the\\n # variables and append them to temporary lists.\\n temp_site_lats.append(lats[trajectory][0])\\n temp_site_lons.append(lons[trajectory][0])\\n temp_lats.append(lats[trajectory][i])\\n temp_lons.append(lons[trajectory][i])\\n temp_lats150.append(lats150[trajectory][j+1])\\n temp_lons150.append(lons150[trajectory][j+1])\\n temp_times.append(times[trajectory][i])\\n temp_sst.append(ssts[trajectory][i])\\n temp_sst150.append(ssts_150[trajectory][j+1])\\n temp_times150.append(times[trajectory][j+1])\\n \\n # after the temporary lists are appended by sinking speed, they\\n # are appended to the big lists that are returned by the function.\\n # this keeps the structure of being separated by sinking speed.\\n site_lats.append(temp_site_lats)\\n site_lons.append(temp_site_lons)\\n last_lats.append(temp_lats)\\n last_lons.append(temp_lons)\\n lats_150.append(temp_lats150)\\n lons_150.append(temp_lons150)\\n last_times.append(temp_times)\\n times_150.append(temp_times150)\\n last_sst.append(temp_sst)\\n sst_150.append(temp_sst150)\\n \\n return site_lats, site_lons, last_lats, last_lons, lats_150, lons_150,\\\\\\n last_times, times_150, last_sst, sst_150\",\n \"def _sort_index(self):\\n\\n allAltPos = np.array(sorted(list(set(list(self.data['altitude'])))))[::-1]\\n allAziPos = np.array(sorted(list(set(list(self.data['azimuth'])))))\\n\\n indON = [[None for azi in allAziPos] for alt in allAltPos]; indOFF = [[None for azi in allAziPos] for alt in allAltPos]\\n\\n for i, traceItem in enumerate(self.data):\\n alt = traceItem['altitude'];azi = traceItem['azimuth'];sign = traceItem['sign']\\n for j, altPos in enumerate(allAltPos):\\n for k, aziPos in enumerate(allAziPos):\\n if alt==altPos and azi==aziPos:\\n if sign==1:\\n if indON[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign: 1!')\\n else: indON[j][k]=i\\n\\n if sign==-1:\\n if indOFF[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign:-1!')\\n else: indOFF[j][k]=i\\n\\n indON = np.array([np.array(x) for x in indON]); indOFF = np.array([np.array(x) for x in indOFF])\\n\\n return indON,indOFF,allAltPos,allAziPos\",\n \"def get_list_after_paired(line):\\n if find_pair(line):\\n index = get_index(line)\\n return line[index + 2: ]\\n return []\",\n \"def find_start_end(grid):\\n #------------------------------------\\n #\\n # Fill and submit this code\\n #\\n start = 0\\n end = 0\\n for i in range(len(grid)):\\n if grid[i] == \\\"emerald_block\\\":\\n start = i\\n elif grid[i] == \\\"redstone_block\\\":\\n end = i\\n return (start, end)\\n #-------------------------------------\",\n \"def racetrack_filter(reversals, h):\\n\\n y = reversals\\n yprev = None\\n ix = []\\n for n, yn in enumerate(y):\\n if (n == 0) or (n == y.size-1):\\n yprev = yn\\n ix.append(n)\\n continue\\n dy = yn - yprev\\n if fabs(dy) > h / 2.:\\n yprev = yn - dy/fabs(dy) * h/2.\\n ix.append(n)\\n ix = np.array(ix, dtype=int)\\n return y[ix], ix\",\n \"def find_pairs(candidate_array, TARGET_VALUE=10):\\r\\n \\r\\n from collections import defaultdict\\r\\n positions = defaultdict(list)\\r\\n \\r\\n #Read everything into a dictionary, storing the original array position \\r\\n for i in range(len(candidate_array)):\\r\\n positions[candidate_array[i]].append(i)\\r\\n\\r\\n #Read list comparing value to TARGET_VALUE \\r\\n for i in range(len(candidate_array)):\\r\\n pair_value = TARGET_VALUE - candidate_array[i]\\r\\n if positions[pair_value]:\\r\\n for p in positions[pair_value]:\\r\\n if p > i:\\r\\n #print \\\"%d,%d\\\" % (candidate_array[i], pair_value)\\r\\n None\",\n \"def next_coordinate1(cur_position, data, steps):\\n # cur_position and next ride-> [x1, x2, y1, y2, earlieststart, latestfinish)\\n if abs(data[0] - cur_position[0]) + abs(data[1] - cur_position[1]) <= data[4] - steps:\\n return 1\\n else:\\n return 0\",\n \"def searchDeadEnd(self):\\n boundaries = []\\n if not self.red:\\n i = self.midWidth - 1\\n else:\\n i = self.midWidth + 1\\n boudaries = [(i, j) for j in range(self.height)]\\n validPositions = []\\n for i in boudaries:\\n if not (i[0], i[1]) in self.walls:\\n validPositions.append(i)\\n\\n dangerPos = []\\n\\n toExpand = self.scanmap.twoEntryPoints()\\n for (x,y) in toExpand:\\n adjacent = self.scanmap.adjacentValidPoints(x, y)\\n if not (x,y) in dangerPos:\\n for (u, w) in adjacent:\\n visited = []\\n visited.append((x, y))\\n safe = False\\n danger = False\\n DFS = util.Stack()\\n DFS.push((u,w))\\n while not safe and not danger:\\n (i,j) = DFS.pop()\\n visited.append((i,j))\\n adjacents = self.scanmap.adjacentValidPoints(i,j)\\n for position in adjacents:\\n if not position in visited:\\n DFS.push(position)\\n if DFS.isEmpty():\\n danger = True\\n dangerPos = list(set(dangerPos) | set(visited))\\n\\n if (i,j) in validPositions:\\n safe = True\\n oneEntry = self.scanmap.oneEntryPoints()\\n dangerPos = list(set(oneEntry).union(set(dangerPos)))\\n dangerPos.sort()\\n return dangerPos\",\n \"def introns_from_bed(bed):\\n introns = set()\\n with open(bed) as bed_stream:\\n for line in bed_stream:\\n tokens = line.rstrip().split('\\\\t')\\n if len(tokens) < 12:\\n continue\\n chrom = tokens[0]\\n chrom_start = int(tokens[1])\\n chrom_end = int(tokens[2])\\n block_sizes = tokens[10].split(',')\\n block_starts = tokens[11].split(',')\\n # Handle trailing commas\\n try:\\n int(block_sizes[-1])\\n except ValueError:\\n block_sizes = block_sizes[:-1]\\n try:\\n int(block_starts[-1])\\n except ValueError:\\n block_starts = block_starts[:-1]\\n block_count = len(block_sizes)\\n if block_count < 2:\\n # No introns\\n continue\\n assert block_count == len(block_starts)\\n junctions = []\\n # First block characterizes junction on left side of intron\\n junctions.append(chrom_start + int(block_starts[0]) \\n + int(block_sizes[0]))\\n for i in xrange(1, block_count - 1):\\n # Any intervening blocks characterize two junctions\\n intron_start = chrom_start + int(block_starts[i])\\n junctions.append(intron_start)\\n junctions.append(intron_start + int(block_sizes[i]))\\n # Final block characterizes junction on right side of intron\\n junctions.append(chrom_start + int(block_starts[-1]))\\n for i in xrange(len(junctions)/2):\\n introns.add((chrom, junctions[2*i]+1, junctions[2*i+1]+1))\\n return introns\",\n \"def _findKeyframeSegments(self,array, classifications):\\n keyframes=[]\\n while True:\\n max_idx = np.argmax(array)\\n max_value = array[max_idx]\\n if max_value < PEAK_THRESHOLD:\\n return keyframes\\n\\n area_sum = peak_sum(array, max_idx, MIN_SPACING)\\n low_idx = max(max_idx-MIN_SPACING,0)\\n limit = min(max_idx+MIN_SPACING+1,len(array))\\n if area_sum > AREA_THRESHOLD:\\n max_clear = 0.0\\n clear_idx = None\\n for area_idx in range(low_idx,limit):\\n # The actual frame is KEYFRAME_OFFSET away from the\\n # result vector due to padding\\n class_idx = area_idx - KEYFRAME_OFFSET\\n\\n # If there are no detections don't attemt to extract\\n # then don't attempt to extract cover info\\n if len(classifications[class_idx]) == 0:\\n continue\\n element_cover = classifications[class_idx][0].cover[2]\\n if element_cover > max_clear:\\n max_clear = element_cover\\n clear_idx = area_idx\\n\\n if clear_idx is not None:\\n keyframes.append(clear_idx)\\n keyframes.sort()\\n\\n # Zero out the area identified\\n for clear_idx in range(low_idx, limit):\\n array[clear_idx] = 0.0\",\n \"def _euclidian_distances(stop_list):\\n e_dists2 = [transitfeed.approximate_distance_between_stops(stop, tail) for\\n (stop, tail) in zip(stop_list, stop_list[1:])]\\n\\n return e_dists2\",\n \"def _pasrse_data_start_end(self, data):\\n first = data['obs_time'].iloc[0]\\n last = data['obs_time'].iloc[-1]\\n\\n return (first, last)\",\n \"def break_points(graph = None):\\n\\tstart = 0\\n\\tstop = nx.number_of_nodes(graph) -1\\n\\tbreak_points = []\\n\\tbasepair_list = basepairs(graph = graph)\\n\\tfor basepair in basepair_list:\\n\\t\\tif (successor_pair(basepair, start, stop) == (-1,-1)) or \\\\\\n\\t\\t(predecessor_pair(basepair, start, stop) == (-1,-1)) or \\\\\\n\\t\\tnot (successor_pair(basepair, start, stop) in basepair_list) or \\\\\\n\\t\\tnot (predecessor_pair(basepair, start, stop) in basepair_list):\\n\\t\\t\\tbreak_points.append(basepair)\\n\\treturn break_points\",\n \"def find_pairs_simple(candidate_array, TARGET_VALUE=10):\\r\\n for i in range(len(candidate_array)):\\r\\n for j in range(i + 1, len(candidate_array)):\\r\\n if (TARGET_VALUE == candidate_array[i] + candidate_array[j]):\\r\\n #print \\\"%d,%d\\\" % (candidate_array[i], candidate_array[j])\\r\\n None\",\n \"def corresponding_frame(traj1, len1, traj2, len2):\\n p1, p2 = 0, 0\\n loc = -1 * np.ones((len1,), dtype=int)\\n while p1 < len1 and p2 < len2:\\n if traj1[p1] < traj2[p2]:\\n loc[p1] = -1\\n p1 += 1\\n elif traj1[p1] == traj2[p2]:\\n loc[p1] = p2\\n p1 += 1\\n p2 += 1\\n else:\\n p2 += 1\\n return loc\",\n \"def all_consecutive(s):\\n for (x, y) in pairwise(sorted(s)):\\n if y - x != 1:\\n return False\\n return True\",\n \"def group_consecutive(data):\\n from itertools import groupby\\n from operator import itemgetter\\n results = []\\n for k, g in groupby(enumerate(data), lambda i_x: i_x[0] - i_x[1]):\\n results.append(list(map(itemgetter(1), g)))\\n\\n return results\",\n \"def get_start_end_points(path, transect): \\n transect_array = np.genfromtxt(path + 'tran_sim_pts.csv', delimiter=\\\",\\\")\\n start_point = transect_array[2 * transect, :]\\n end_point = transect_array[2 * transect + 1, :]\\n \\n # force start points to be west of end points\\n if start_point[0] > end_point[0]:\\n previous_start_point = start_point\\n start_point = end_point\\n end_point = previous_start_point\\n return start_point, end_point\",\n \"def find_uniques_consecutive(array):\\n val = array[0]\\n indices = []\\n for idx, element in enumerate(array):\\n if element != val:\\n indices.append(idx)\\n val = element\\n return indices\",\n \"def _get_lines(self) -> tuple[VGroup, VGroup]:\\n center = self.get_origin()\\n ratio_faded_lines = self.faded_line_ratio\\n offset = self.azimuth_offset\\n\\n if ratio_faded_lines == 0: # don't show faded lines\\n ratio_faded_lines = 1 # i.e. set ratio to 1\\n rstep = (1 / ratio_faded_lines) * self.x_axis.x_range[2]\\n astep = (1 / ratio_faded_lines) * (TAU * (1 / self.azimuth_step))\\n rlines1 = VGroup()\\n rlines2 = VGroup()\\n alines1 = VGroup()\\n alines2 = VGroup()\\n\\n rinput = np.arange(0, self.x_axis.x_range[1] + rstep, rstep)\\n ainput = np.arange(0, TAU, astep)\\n\\n unit_vector = self.x_axis.get_unit_vector()[0]\\n\\n for k, x in enumerate(rinput):\\n new_line = Circle(radius=x * unit_vector)\\n if k % ratio_faded_lines == 0:\\n alines1.add(new_line)\\n else:\\n alines2.add(new_line)\\n\\n line = Line(center, self.get_x_axis().get_end())\\n\\n for k, x in enumerate(ainput):\\n new_line = line.copy()\\n new_line.rotate(x + offset, about_point=center)\\n if k % ratio_faded_lines == 0:\\n rlines1.add(new_line)\\n else:\\n rlines2.add(new_line)\\n\\n lines1 = VGroup(*rlines1, *alines1)\\n lines2 = VGroup(*rlines2, *alines2)\\n return lines1, lines2\",\n \"def _scan_reverse(gaps, center, dist):\\n\\n for i in range( 0, center ):\\n idx_gap = center - 1 - i\\n gap = gaps[idx_gap]\\n if gap >= dist: return idx_gap+1\\n return 0\",\n \"def find_steps(walk):\\n cols = ['id', 'acc_x', 'acc_y', 'acc_z', 'gy_x', 'gy_y', 'gy_z', 'mag_x', 'mag_y', 'mag_z'] \\n df = DataFrame(walk)\\n df.columns = cols\\n acc_mag, mag_mag, mag_gy = get_mags(df)\\n reduced_gy = reduce_signal(mag_gy)\\n gy = [make_auto(mag_gy), make_auto(reduced_gy)]\\n maxtab, mintab = peakdet(gy[1], .02)\\n ind = maxtab[:, 0]\\n ind = ind.astype(int)\\n len_btw_steps = [j-i for i, j in zip(ind[:-1], ind[1:])]\\n loc_and_len = zip(ind, len_btw_steps)\\n steps = []\\n for location, length in loc_and_len:\\n start = location\\n stop = location + length\\n step = longest[start:stop]\\n steps.append(step)\\n return steps\",\n \"def is_consecutive(a_list):\\n current_value = a_list[0]-1\\n for number in a_list:\\n current_value +=1\\n if current_value != number:\\n return False\\n return True\",\n \"def verify_cutoff_pair(cutoff, pair, voltages):\\n flag = -1\\n for i in range(len(cutoff)):\\n pairs = cutoff[i]\\n if pair in pairs or list(reversed(pair)) in pairs:\\n if voltages[i] is 'S':\\n flag = i\\n return flag\\n return flag\",\n \"def find_starts(config, data):\\n\\n trigger = butter_bandpass_filter(\\n data, config.bandpass_lower, config.bandpass_upper,\\n config.sampling_rate, 6)\\n trigger = np.absolute(trigger)\\n trigger = butter_lowpass_filter(\\n trigger, config.lowpass_freq, config.sampling_rate, 6)\\n\\n # transient = 0.0005\\n # start_idx = int(transient * config.sampling_rate)\\n start_idx = 0\\n average = np.average(trigger[start_idx:])\\n maximum = np.max(trigger[start_idx:])\\n minimum = np.min(trigger[start_idx:])\\n middle = (np.max(trigger[start_idx:]) - min(trigger[start_idx:])) / 2\\n if average < 1.1 * middle:\\n print()\\n print(\\\"Adjusting average to avg + (max - avg) / 2\\\")\\n average = average + (maximum - average) / 2\\n offset = -int(config.trigger_offset * config.sampling_rate)\\n\\n if config.trigger_rising:\\n trigger_fn = lambda x, y: x > y\\n else:\\n trigger_fn = lambda x, y: x < y\\n\\n # The cryptic numpy code below is equivalent to looping over the signal and\\n # recording the indices where the trigger crosses the average value in the\\n # direction specified by config.trigger_rising. It is faster than a Python\\n # loop by a factor of ~1000, so we trade readability for speed.\\n trigger_signal = trigger_fn(trigger, average)[start_idx:]\\n starts = np.where((trigger_signal[1:] != trigger_signal[:-1])\\n * trigger_signal[1:])[0] + start_idx + offset + 1\\n if trigger_signal[0]:\\n starts = np.insert(starts, 0, start_idx + offset)\\n\\n # plt.plot(data)\\n # plt.plot(trigger*100)\\n # plt.axhline(y=average*100)\\n # plt.show()\\n\\n return starts, trigger, average\",\n \"def get_stopped_pts(gpx_track, speed_threshold=2.5):\\n\\n n = 0\\n stopped_bool = [False]*gpx_track.get_points_no() # pre-allocate\\n for segment in gpx_track.segments:\\n for ida, point in enumerate(segment.points):\\n stopped_bool[n] = segment.get_speed[ida] < speed_threshold\\n n = n + 1\\n\\n _, stopped_time = gpx_track.get_moving_data(speed_threshold)\\n\\n return stopped_bool, stopped_time\",\n \"def _consecutive(self, n):\\n grouped = zip(*[iter(self._history())]*n)\\n results = [0]*len(grouped)\\n for i, group in enumerate(grouped):\\n if list(group) == [1]*n:\\n results[i] = 1\\n if list(group) == [0]*n:\\n results[i] = -1\\n return results\",\n \"def listOfOverlappingTTPairs():\\n listOfHalfModules = listOfTTHalfModules()\\n ttmap = TTModulesMap_instance\\n pairs = []\\n regions = {'A':1, 'B':2, 'C':3}\\n print \\\"Overlapping TT half modules:\\\"\\n for hm1 in listOfHalfModules:\\n for hm2 in listOfHalfModules:\\n # they must be different\\n if hm1 == hm2: continue\\n # they must be both on top or both on bottom\\n if locateTTHalfModule(hm1)[3] != locateTTHalfModule(hm2)[3]: continue\\n # they must be on the same layer\\n if locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0]: continue\\n # avoid duplicates\\n if (hm1, hm2) in pairs: continue\\n if (hm2, hm1) in pairs: continue\\n # they must be contiguous:\\n if (locateTTHalfModule(hm1)[1] == locateTTHalfModule(hm2)[1]):\\n if (abs(locateTTHalfModule(hm1)[2] - locateTTHalfModule(hm2)[2]) == 1):\\n pairs.append( (hm1, hm2) )\\n else:\\n num1 = locateTTHalfModule(hm1)[2]\\n num2 = locateTTHalfModule(hm2)[2]\\n max1 = ttmap.numberOfModules[locateTTHalfModule(hm1)[0]]['Region'+locateTTHalfModule(hm1)[1]] - 1\\n max2 = ttmap.numberOfModules[locateTTHalfModule(hm2)[0]]['Region'+locateTTHalfModule(hm2)[1]] - 1\\n nreg1 = regions[locateTTHalfModule(hm1)[1]]\\n nreg2 = regions[locateTTHalfModule(hm2)[1]]\\n if ( (num1==max1 and num2==0 and nreg2-nreg1==1) or (num2==max2 and num1==0 and nreg1-nreg2==1) ):\\n pairs.append( (hm1, hm2) )\\n print '\\\\t', hm1, hm2\\n ## - same region\\n #if ((abs(locateTTHalfModule(hm1)[2] - locateTTHalfModule(hm2)[2]) != 1)\\n # and (locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0])): continue\\n ## - or neighbouring region\\n #elif not ((locateTTHalfModule(hm1)[0] != locateTTHalfModule(hm2)[0])\\n # and ( ( (ttmap.numberOfModules[locateTTHalfModule(hm1)[0]] == locateTTHalfModule(hm1)[2]+1 )\\n # and (locateTTHalfModule(hm2)[2] == 0) )\\n # or ( (ttmap.numberOfModules[locateTTHalfModule(hm2)[0]] == locateTTHalfModule(hm2)[2]+1 )\\n # and (locateTTHalfModule(hm1)[2] == 0) ) ) ): continue\\n ## append to list of pairs\\n #pairs.append( (hm1, hm2) )\\n print\\n return pairs\",\n \"def get_elementary_airspace_altitude_range(db_id):\\n connection = get_geo_db_connection()\\n sector = find_sector(db_id, connection)\\n if (sector):\\n return (sector['min_altitude'], sector['max_altitude'])\\n else:\\n raise NotFoundException(db_id, \\\"Elementary sector not found.\\\")\",\n \"def _scan_forward( gaps, center, dist ):\\n\\n n = len(gaps)\\n for i in range( center, n ):\\n idx_gap = i\\n gap = gaps[idx_gap]\\n if gap >= dist: return idx_gap+1\\n return n+1\",\n \"def get_list_before_paired(line):\\n if find_pair(line):\\n index = get_index(line)\\n return line[ :index + 2]\\n return []\",\n \"def max_overlap_pair(skylines):\\n max_pair = None\\n max_overlap_area = 0.0\\n\\n for i in range(len(skylines) - 1):\\n curr_s = skylines[i]\\n next_s, i_area = curr_s.find_max_overlap(skylines[i + 1:])\\n\\n if i_area > max_overlap_area:\\n max_overlap_area = i_area\\n max_pair = (curr_s, next_s)\\n\\n return max_pair\",\n \"def GetScanPositions(self,d):\\n\\n # make it so that you have a gap, only use data where the telescope is moving\\n\\n elcurrent = np.abs(d['level1/hk/antenna0/driveNode/elDacOutput'][:])\\n elutc = d['level1/hk/antenna0/driveNode/utc'][:]\\n mjd = d['level1/spectrometer/MJD'][:]\\n select = np.where((elcurrent > np.max(elcurrent)*0.8))[0] # these are when the telescope is changing position\\n #if len(select) == 0:\\n\\n\\n dselect = select[1:]-select[:-1]\\n ends = np.concatenate((np.where((dselect > 10))[0], np.array([len(dselect)-1])))\\n\\n indices = []\\n for e in select[ends]:\\n end_idx = np.argmin((elutc[e]-mjd)**2)\\n indices += [end_idx]\\n\\n mean_scan_time = np.mean(elutc[ends[1:]] - elutc[ends[:-1]])*24*3600\\n step = mean_scan_time*0.1\\n mask = np.zeros(len(mjd)).astype(bool)\\n samples = np.arange(len(mjd))\\n\\n buffer_size = 50\\n buffer_multiply = 5\\n for iend, end in enumerate(indices):\\n if (iend ==0):\\n mask[samples < (end+step*buffer_size)] = True\\n elif (iend == (len(indices)-1)):\\n mask[samples > (end-step*buffer_size)] = True\\n else:\\n mask[(samples > (end - buffer_multiply*buffer_size)) & (samples < (end + buffer_multiply*buffer_size))] = True\\n\\n\\n # Map indices\\n oldindex = np.arange(len(mjd))[~mask] # old positions\\n newindex = np.arange(len(oldindex)) # new positions\\n mapOld2New = {o:n for (o,n) in zip(oldindex,newindex)}\\n mapNew2Old = {n:o for (o,n) in zip(oldindex,newindex)}\\n\\n diff_mask = mask[1:].astype(int) - mask[:-1].astype(int)\\n mask_select = np.where((diff_mask > 0))[0] # old positions\\n end_indices = np.unique([0] + [mapOld2New[i] for i in mask_select] )\\n\\n if end_indices[-1] > newindex.size:\\n end_indices[-1] = newindex.size-1\\n \\n\\n starts, ends = end_indices[:-1],end_indices[1:] \\n\\n start_final = []\\n end_final = []\\n for start,end in zip(starts,ends):\\n i0,i1 = mapNew2Old[start], mapNew2Old[end]\\n if (end-start) < self.minimum_scanlength:\\n mask[i0:i1] = True\\n else:\\n start_final += [start]\\n end_final += [end]\\n\\n return (mask == False), np.array(start_final).astype(int), np.array(end_final).astype(int)\",\n \"def find_matching_segments(self):\\n hyp_matched_segs = [TIntervalGroup() for i in range(len(self.hyp))]\\n for gid_ref, match_ref in enumerate(self.ref):\\n bg_ref = match_ref.bbox_group\\n max_gid, max_area = -1, 0\\n for gid_hyp, bg_hyp in enumerate(self.hyp.get_bbox_groups()):\\n rx, ry = bg_ref.page_range(), bg_hyp.page_range()\\n if ry[0] > rx[1]:\\n break\\n area = (bg_ref & bg_hyp)\\n if area > max_area:\\n max_gid, max_area = gid_hyp, area\\n if max_gid != -1:\\n hyp_matched_segs[max_gid].extend(match_ref.tinterval_group.copy())\\n print('%d -> %d' % (gid_ref, max_gid))\\n for seg in hyp_matched_segs:\\n seg.reduce()\\n return hyp_matched_segs\",\n \"def set_cruise_altitudes(altitudes, cruise_indicies):\\n if cruise_indicies:\\n for index in range(0, len(cruise_indicies), 2):\\n start = cruise_indicies[index]\\n stop = cruise_indicies[index + 1]\\n if start < stop:\\n cruise_altitude = closest_cruising_altitude(altitudes[start])\\n altitudes[start] = cruise_altitude\\n altitudes[stop] = cruise_altitude\\n\\n return altitudes\",\n \"def find_x_wing_pairs(pair_array):\\n pair_array_return = []\\n i = 0\\n while i < len(pair_array):\\n j = i+1\\n while j < len(pair_array):\\n if pair_array[i][1] == pair_array[j][1] and pair_array[i][2] == pair_array[j][2] \\\\\\n and pair_array[i][3] == pair_array[j][3]:\\n pair_array_return.append([pair_array[i][1],pair_array[i][0],pair_array[j][0], \\\\\\n pair_array[j][2],pair_array[j][3]])\\n j += 1\\n i += 1\\n return pair_array_return\",\n \"def consecutive(data):\\n data_group = [(v, sum(1 for _ in g)) for v, g in groupby(data)]\\n vals, cons = zip(*data_group)\\n\\n start_inds = np.cumsum((0,) + cons[:-1])\\n end_inds = start_inds + cons - 1\\n\\n return list(zip(vals, start_inds, end_inds))\",\n \"def arc_tangents(amount, start, stop, truncated, sequence):\\n ratio = (start + stop) / 2\\n for x in range(start, amount):\\n y = abs(round(ratio * math.atan(x)))\\n if truncated and y >= stop:\\n sequence.append(stop)\\n elif y < start:\\n sequence.append(start)\\n else:\\n sequence.append(y)\\n return sequence\",\n \"def list_duplicates(seq):\\n tally = defaultdict(list)\\n for i, item in enumerate(seq):\\n try:\\n if item.mask == True:\\n continue\\n except:\\n tally[item].append(i)\\n return ((key, locs) for key, locs in tally.items() if len(locs) > 1)\",\n \"def _getscanind(self):\\n \\n zamin = self.za.min()\\n first = np.where(self.za==zamin)[0]\\n self.scan = np.zeros(self.spec.shape[0])\\n if zamin < 0:\\n cs = first[np.where((first - np.roll(first, 1)) != 1)[0]]\\n ss = first[np.where((np.roll(first,-1) - first) != 1)[0]] + 1\\n ce = ss \\n se = np.roll((cs - 1) % self.za.size, -1) + 1\\n for k, val in enumerate(cs):\\n self.scan[val:se[k] + 1] = k\\n else:\\n moves = np.diff(self.za)\\n max_ind = np.where(moves==moves.max())[0]\\n turnover = self.za.size\\n diffs = np.diff(max_ind)\\n if np.unique(diffs).size > 1:\\n raise ValueError, 'Can\\\\'t deal with non-uniform cal data yet.'\\n if max_ind.size > 1:\\n turnover = diffs[0]\\n cs = ce = np.array([])\\n ss = np.arange(self.za.size)[::turnover]\\n se = np.roll((ss - 1) % self.za.size, -1)\\n for k, val in enumerate(ss):\\n self.scan[val:se[k] + 1] = k\\n \\n self.ind = {'cs': cs, 'ce': ce, 'ss': ss, 'se': se}\\n self.nscan = np.unique(self.scan).size\",\n \"def find_answer(offsets, begin_offset, end_offset):\\n start = [i for i, tok in enumerate(offsets) if tok[0] == begin_offset]\\n end = [i for i, tok in enumerate(offsets) if tok[1] == end_offset]\\n assert(len(start) <= 1)\\n assert(len(end) <= 1)\\n if len(start) == 1 and len(end) == 1:\\n return start[0], end[0]\",\n \"def GetTimeIntervalsForEachLine(PathInfo):\\r\\n\\tTimeIntervalOnLine = {}\\r\\n\\r\\n\\tif PathInfo == None: return TimeIntervalOnLine\\r\\n\\tif len(PathInfo) < 2: return TimeIntervalOnLine\\r\\n\\r\\n\\tLastLine = None\\r\\n\\tCurrDeparture = None\\r\\n\\r\\n\\tfor i in range(1, len(PathInfo)):\\r\\n\\t\\tConnectionInfo = PathInfo[i]\\r\\n\\t\\tCurLine = ConnectionInfo[ConnInfoInd['line_id']]\\r\\n\\t\\tCurTripID = ConnectionInfo[ConnInfoInd['travel_id']]\\r\\n\\r\\n\\t\\tif i == 1:\\r\\n\\t\\t\\tCurrDeparture = ConnectionInfo[ConnInfoInd['departure_hour']]*60 + ConnectionInfo[ConnInfoInd['departure_min']]\\r\\n\\t\\t\\tLastLine = CurLine\\r\\n\\t\\t\\tLastTripID = CurTripID\\r\\n\\r\\n\\t\\t# if CurLine != LastLine:\\r\\n\\t\\tif CurTripID != LastTripID:\\r\\n\\t\\t\\tLastArrival = PathInfo[i-1][ConnInfoInd['arrival_hour']]*60 + PathInfo[i-1][ConnInfoInd['arrival_min']]\\r\\n\\t\\t\\tif TimeIntervalOnLine.has_key(LastLine):\\r\\n\\t\\t\\t\\tTimeIntervalOnLine[LastLine].append((CurrDeparture, LastArrival))\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tTimeIntervalOnLine[LastLine] = [(CurrDeparture, LastArrival)]\\r\\n\\t\\t\\tCurrDeparture = ConnectionInfo[ConnInfoInd['departure_hour']]*60 + ConnectionInfo[ConnInfoInd['departure_min']]\\r\\n\\t\\t\\tLastLine = CurLine\\r\\n\\t\\t\\tLastTripID = CurTripID\\r\\n\\t\\t\\r\\n\\t\\tif i == (len(PathInfo) - 1):\\r\\n\\t\\t\\tLastArrival = ConnectionInfo[ConnInfoInd['arrival_hour']]*60 + ConnectionInfo[ConnInfoInd['arrival_min']]\\r\\n\\t\\t\\tif TimeIntervalOnLine.has_key(CurLine):\\r\\n\\t\\t\\t\\tTimeIntervalOnLine[CurLine].append((CurrDeparture, LastArrival))\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tTimeIntervalOnLine[CurLine] = [(CurrDeparture, LastArrival)]\\r\\n\\r\\n\\treturn TimeIntervalOnLine\",\n \"def get_regions_above_threshold(self, threshold, values):\\n\\n xlocs = arange(0, len(values))\\n\\n # finds all turns, between above and below threshold\\n # and generate areas to call peaks in, also\\n # makes sure starting and stopping above maxima is caught\\n # threshold is at or equal to values, need to correct this\\n starts = xlocs[r_[True, diff(values >= threshold)] & (values >= threshold)]\\n stops = xlocs[r_[diff(values >= threshold), True] & (values >= threshold)]\\n # add to fix off by one bug\\n stops += + 1\\n\\n # error correction incase my logic is wrong here, assuming that starts\\n # and stops are always paired, and the only two cases of not being\\n # pared are if the spline starts above the cutoff or the spline starts\\n # below the cutoff\\n assert len(starts) == len(stops)\\n\\n ### important note: for getting values x->y [inclusive]\\n # you must index an array as ar[x:(y+1)]|\\n # or else you end up with one-too-few values, the second\\n # index is non-inclusive\\n\\n # gets all local minima, function taken from:\\n # http://stackoverflow.com/questions/4624970/finding-local-maxima-minima-with-numpy-in-a-1d-numpy-array\\n # Can't have local minima at start or end, that would get caught by\\n # previous check, really need to think about that more\\n\\n local_minima = self.find_local_minima(values)\\n\\n # append to list any local minima above threshold\\n for i, minima in enumerate(local_minima):\\n if minima and values[i] >= threshold:\\n starts = append(starts, i)\\n stops = append(stops, i)\\n\\n starts = array(sorted(set(starts)))\\n stops = array(sorted(set(stops)))\\n starts_and_stops = []\\n\\n # making sure we aren't in some strange state\\n assert len(starts) == len(stops)\\n\\n # get all contigous start and stops pairs\\n while len(starts) > 0:\\n stop_list = stops[stops > starts[0]]\\n\\n # if there are no more stops left exit the loop and return the\\n # currently found starts and stops\\n if len(stop_list) == 0:\\n break\\n stop = stop_list[0]\\n starts_and_stops.append((starts[0], stop))\\n starts = starts[starts >= stop]\\n\\n starts = array([x[0] for x in starts_and_stops])\\n stops = array([x[1] for x in starts_and_stops])\\n return starts_and_stops, starts, stops\",\n \"def resolve(self):\\n for annotation_1 in self._data:\\n for annotation_2 in self._data:\\n if annotation_1 == annotation_2:\\n continue\\n elif ((annotation_2.start < annotation_1.end) or\\n (annotation_1.start < annotation_2.end)):\\n self._resolve_pair(annotation_1, annotation_2)\",\n \"def iter_neighbors(x: int, y: int) -> t.Generator[COORDINATE, None, None]:\\n yield x - 1, y\\n yield x + 1, y\\n yield x, y - 1\\n yield x, y + 1\",\n \"def GetContourValuesLengthsAndSubContoursAndOrderOfSubContoursByFrame(\\n watershed, allValsByFrame\\n):\\n scListByFrame, orderOfSCsByValueByFrame = GetSubContoursAndOrderingByFrame(\\n watershed, allValsByFrame\\n )\\n cVLSByFrame = [[sc.cVLS() for sc in scList] for scList in scListByFrame]\\n return cVLSByFrame, orderOfSCsByValueByFrame\\n\\n ## NOT NEEDED! KEEPING FOR REFERENCE!\\n # for i in range(len(cVLS)-1,0,-1):\\n # for j in range(i-1,-1,-1): # Loop backwards through the sorted list of cvls's... if the value pair matches, check the endpoints (they will always be reversed for adjacent regions (always go ccw...))\\n # if cVLS[i][0]!=cVLS[j][0]: # once we no longer match the value pair, we know there are no more matches in the list...\\n # break\\n # ######## VERIFY THIS ACTUALLY WORKS THE SAME WAY!!!\\n # elif (cVLS[i][2][-1],cVLS[i][2][0]]) == (cVLS[j][2][0],cVLS[j][2][-1]): # if 2 subcoutours are the same,\\n # if cVLS[j][1]>cVLS[i][1]:\\n # cVLS[j],cVLS[i] = cVLS[i],cVLS[j] #swap!\\n # shortest = min(cVLS[j][1],cVLS[i][1]) # keep only the one with the minimum length computation\\n #\\n # cVLS[j][1] = shortest\\n # del(cVLS[i])\\n # break\",\n \"def get_emissivity_offsets(self):\\n emissivity = self.ancillarydata['emissivity']\\n min_emissivity = np.amin(emissivity)\\n max_emissivity = np.amax(emissivity)\\n\\n logger.debug('Minimum emissivity value is {}'.format(min_emissivity))\\n logger.debug('Maximum emissivity value is {}'.format(max_emissivity))\\n\\n if min_emissivity in self.emissivities.keys() and max_emissivity in self.emissivities.keys():\\n startemiss = self.emissivities[min_emissivity]\\n stopemiss = self.emissivities[max_emissivity]\\n else:\\n #Case where emissivities are not in the dict keys, need to find the closest\\n #TODO: Emissivity is considered constant at the moment\\n startemiss = None\\n stopemiss = None\\n return startemiss, stopemiss\",\n \"def find_overlap_range_list(points_list):\\n highest_start_point = points_list[0][0]\\n lowest_end_point = points_list[0][0] + points_list[0][1]\\n\\n for point in points_list[1:]:\\n highest_start_point = max(highest_start_point, point[0])\\n lowest_end_point = min(lowest_end_point, point[1]+point[0])\\n\\n if lowest_end_point <= highest_start_point:\\n return None\\n\\n return [highest_start_point, lowest_end_point - highest_start_point]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61895657","0.57591677","0.5693731","0.55963063","0.5349171","0.5304589","0.52295","0.51885813","0.51586705","0.51529676","0.5115243","0.51014274","0.5073773","0.5066128","0.5040757","0.50405693","0.5022069","0.5019296","0.50123805","0.50085217","0.49733093","0.49727276","0.49456376","0.49437687","0.49399823","0.49241242","0.49240503","0.49125642","0.4904133","0.48998192","0.4888821","0.48766613","0.48620418","0.4856093","0.48403934","0.48289156","0.482533","0.48135012","0.48133397","0.48027363","0.47894606","0.47863603","0.47763756","0.47671473","0.4761002","0.47542956","0.47471836","0.47412795","0.47391865","0.47388443","0.4728173","0.4726523","0.47253254","0.47252527","0.47227073","0.4714284","0.47132388","0.47099423","0.46926996","0.46809205","0.46781272","0.46766636","0.46720406","0.46668404","0.4665248","0.46635276","0.46567044","0.46497038","0.46372467","0.4633749","0.46326607","0.4632189","0.4621461","0.46181223","0.4617907","0.461762","0.46117252","0.46090996","0.46083352","0.4603554","0.46015295","0.45945066","0.4589367","0.45852798","0.45715275","0.45700106","0.4566975","0.4566652","0.45561686","0.45561448","0.4555081","0.45542184","0.45529738","0.45522392","0.45519","0.45517847","0.4549437","0.4546317","0.4544053","0.45435318"],"string":"[\n \"0.61895657\",\n \"0.57591677\",\n \"0.5693731\",\n \"0.55963063\",\n \"0.5349171\",\n \"0.5304589\",\n \"0.52295\",\n \"0.51885813\",\n \"0.51586705\",\n \"0.51529676\",\n \"0.5115243\",\n \"0.51014274\",\n \"0.5073773\",\n \"0.5066128\",\n \"0.5040757\",\n \"0.50405693\",\n \"0.5022069\",\n \"0.5019296\",\n \"0.50123805\",\n \"0.50085217\",\n \"0.49733093\",\n \"0.49727276\",\n \"0.49456376\",\n \"0.49437687\",\n \"0.49399823\",\n \"0.49241242\",\n \"0.49240503\",\n \"0.49125642\",\n \"0.4904133\",\n \"0.48998192\",\n \"0.4888821\",\n \"0.48766613\",\n \"0.48620418\",\n \"0.4856093\",\n \"0.48403934\",\n \"0.48289156\",\n \"0.482533\",\n \"0.48135012\",\n \"0.48133397\",\n \"0.48027363\",\n \"0.47894606\",\n \"0.47863603\",\n \"0.47763756\",\n \"0.47671473\",\n \"0.4761002\",\n \"0.47542956\",\n \"0.47471836\",\n \"0.47412795\",\n \"0.47391865\",\n \"0.47388443\",\n \"0.4728173\",\n \"0.4726523\",\n \"0.47253254\",\n \"0.47252527\",\n \"0.47227073\",\n \"0.4714284\",\n \"0.47132388\",\n \"0.47099423\",\n \"0.46926996\",\n \"0.46809205\",\n \"0.46781272\",\n \"0.46766636\",\n \"0.46720406\",\n \"0.46668404\",\n \"0.4665248\",\n \"0.46635276\",\n \"0.46567044\",\n \"0.46497038\",\n \"0.46372467\",\n \"0.4633749\",\n \"0.46326607\",\n \"0.4632189\",\n \"0.4621461\",\n \"0.46181223\",\n \"0.4617907\",\n \"0.461762\",\n \"0.46117252\",\n \"0.46090996\",\n \"0.46083352\",\n \"0.4603554\",\n \"0.46015295\",\n \"0.45945066\",\n \"0.4589367\",\n \"0.45852798\",\n \"0.45715275\",\n \"0.45700106\",\n \"0.4566975\",\n \"0.4566652\",\n \"0.45561686\",\n \"0.45561448\",\n \"0.4555081\",\n \"0.45542184\",\n \"0.45529738\",\n \"0.45522392\",\n \"0.45519\",\n \"0.45517847\",\n \"0.4549437\",\n \"0.4546317\",\n \"0.4544053\",\n \"0.45435318\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61840254"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":91978,"cells":{"query":{"kind":"string","value":"Find pairs of start/finish indicies of altitudes where an aircraft was cruising."},"document":{"kind":"string","value":"def find_cruise_sections(altitudes):\n indicies = find_level_sections(altitudes)\n\n if indicies:\n prev_altitude = altitudes[indicies[0]]\n cruise_altitude = closest_cruising_altitude(prev_altitude)\n was_cruising = is_cruising(prev_altitude, cruise_altitude)\n prev_altitude = cruise_altitude if was_cruising else prev_altitude\n\n merge_indicies = []\n for index in range(2, len(indicies), 2):\n altitude = altitudes[indicies[index]]\n cruise_altitude = closest_cruising_altitude(altitude)\n if is_cruising(altitude, cruise_altitude):\n # If the aircraft cruised between the level ranges,\n if was_cruising and (prev_altitude == cruise_altitude) and \\\n in_cruise_level_range(altitudes[indicies[index - 1] + 1: indicies[index]],\n cruise_altitude):\n # merge the level indicies\n merge_indicies.append(index - 1)\n merge_indicies.append(index)\n\n prev_altitude = cruise_altitude\n was_cruising = True\n else: # level but not at a cruising level\n merge_indicies.append(index)\n merge_indicies.append(index + 1)\n prev_altitude = altitude\n was_cruising = False\n\n # merge the level indicies\n while merge_indicies:\n index = merge_indicies.pop()\n del indicies[index]\n\n return indicies"},"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 intersection_distances(self, altitude, start_distance, finish_distance):\n distances = []\n alt_index, alt_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, alt_index, alt_ratio)\n\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n while alt_index < finish_index:\n next_index = alt_index + 1\n next_ratio = 0.0\n next_alt = calculate_value(self.altitudes, next_index, next_ratio)\n\n # Does this section span the given altitude?\n if (next_alt != start_alt) and \\\n (min(start_alt, next_alt) < altitude < max(start_alt, next_alt)):\n delta = altitude - start_alt\n denom = next_alt - start_alt\n ratio = delta / denom\n distance = calculate_value(self.distances, alt_index, ratio)\n distances.append(distance)\n\n alt_index = next_index\n alt_ratio = next_ratio\n start_alt = next_alt\n\n if finish_ratio:\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n # Does the last section span the given altitude?\n if (start_alt != finish_alt) and \\\n (min(start_alt, finish_alt) < altitude < max(start_alt, finish_alt)):\n # Calculate the altitude at the end of the section to maximimse accuracy\n next_alt = calculate_value(self.altitudes, finish_index, 1.0)\n delta = altitude - start_alt\n denom = next_alt - start_alt\n ratio = delta / denom\n distance = calculate_value(self.distances, alt_index, ratio)\n distances.append(distance)\n\n return distances","def altitude_range(self, start_distance, finish_distance):\n start_index, start_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n\n min_alt = min(start_alt, finish_alt)\n max_alt = max(start_alt, finish_alt)\n\n if start_index < finish_index:\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\n min_alt = min(min_alt, altitudes.min())\n max_alt = max(max_alt, altitudes.max())\n\n return min_alt, max_alt","def startEndPoints(mazz):\n for i in range (len(mazz)):\n for j in range (len(mazz[i])):\n if mazz[i][j] == 6:\n startx = i\n starty = j\n elif mazz[i][j] == 7:\n endx = i\n endy = j\n return startx, starty, endx, endy","def find_level_sections(alts):\n # Get the indicies of positions at the starts and end of levels\n level_indicies = []\n\n if len(alts) > 2:\n prev_alt = alts[0]\n alt = alts[1]\n\n # If the first two altitudea are the same, mark as is_level\n is_level = (prev_alt == alt)\n if is_level:\n level_indicies.append(0)\n\n for index in range(1, len(alts) - 1):\n next_alt = alts[index + 1]\n if is_level:\n # ignore single values at a different altitude\n is_level = (alt == next_alt)\n if not is_level: # no longer is_level\n # note the end cruise index\n level_indicies.append(index)\n else: # was not is_level\n is_level = (alt == next_alt)\n if is_level:\n # note the start cruise index\n level_indicies.append(index)\n\n # advance altitudes\n alt = next_alt\n prev_alt = alt\n\n # Ensure end is recorded if is_level\n if is_level:\n level_indicies.append(len(alts) - 1)\n\n return level_indicies","def find_rpt_coords(self) -> (int, int):\n start_size = self.size\n end_size = self.size + len(self.allele)\n coord = self.coord\n fasta_alt = self.fasta_alt\n while self.allele == fasta_alt:\n coord += len(self.allele)\n start_size += len(self.allele)\n end_size += len(self.allele)\n fasta_alt = self.seq[start_size:end_size]\n new_start = coord - len(self.allele)\n new_end = new_start + len(self.allele) - 1\n return new_start, new_end","def get_lat_offsets(self):\n\n startlat = self.parameters['startlatitude']\n stoplat = self.parameters['stoplatitude']\n\n #Given the start and stops,\n startidx, startvalue = utils.getnearest(self.latitudes, startlat)\n stopidx, stopvalue = utils.getnearest(self.latitudes, stoplat)\n startidx -= 2\n stopidx += 2\n latslice = np.arange(startidx, stopidx + 1)\n if utils.checkmonotonic(latslice):\n latslice = latslice\n else:\n #TODO: Support pole crossing images\n logger.error('Image is pole crossing, not currently supported.')\n '''\n print \"NOT MONOTONIC\"\n #Handle wraps around the poles\n latslice = np.arange(start_idx, stop_idx + 1)\n nlats = self.startlookup.shape[1]\n greatermask = np.where(latslice >= nlats)\n latslice[greatermask] -= nlats\n lessmask = np.where(latslice < 0)\n latslice[lessmask] += self.startlookup.shape[1]\n\n self.latsort = np.argsort(latslice)\n self.latslice = latslice[self.latsort]\n self.latsort = np.argsort(self.latsort)\n '''\n latslice = None\n logger.debug('Start latitude node is {}. Nearest lookup node is {}.'.format(startlat, startidx))\n logger.debug('Stop latitude node is {}. Nearest lookup node is {}.'.format(stoplat, stopidx))\n return latslice","def find_isolated_endpoints(lines):\n \n isolated_endpoints = []\n count = len(lines)\n print(\"Finding isolated end points 2/3\")\n pb = pbar.ProgressBar(count)\n for i, line in enumerate(lines):\n pb += 1\n other_lines = lines[:i] + lines[i+1:]\n for q in [0,-1]:\n endpoint = Point(line.coords[q])\n if any(endpoint.touches(another_line) \n for another_line in other_lines):\n continue\n else:\n isolated_endpoints.append(endpoint)\n del pb\n return isolated_endpoints","def identifyPutativeFields(tuning_curve):\r\n\r\n tuning_curve = np.copy(tuning_curve)\r\n tuning_curve = np.around(tuning_curve, decimals=3)\r\n elevated_indices = np.nonzero(tuning_curve)[0]\r\n if len(elevated_indices) == 0:\r\n return [[], []]\r\n\r\n putative_starts = []\r\n putative_ends = []\r\n\r\n putative_start = elevated_indices[0]\r\n\r\n while putative_start is not None:\r\n putative_starts.append(putative_start)\r\n # when does it return to zero?\r\n try:\r\n putative_end = putative_start + np.amin(\r\n np.where(tuning_curve[putative_start:] == 0)) - 1\r\n except ValueError:\r\n # does not return to 0\r\n putative_end = len(tuning_curve) - 1\r\n\r\n putative_ends.append(putative_end)\r\n\r\n try:\r\n putative_start = np.amin(\r\n elevated_indices[elevated_indices > putative_end])\r\n except ValueError:\r\n # no more intervals > 0\r\n putative_start = None\r\n\r\n # correct the wrap-around case\r\n if 0 in putative_starts and len(tuning_curve) - 1 in putative_ends and \\\r\n len(putative_starts) > 1:\r\n putative_starts.pop(0)\r\n putative_ends[-1] = putative_ends.pop(0)\r\n\r\n return putative_starts, putative_ends","def find_cruise_positions(num_altitudes, cruise_indicies):\n cruise_positions = np.zeros(num_altitudes, dtype=bool)\n\n if cruise_indicies:\n for index in range(0, len(cruise_indicies), 2):\n start = cruise_indicies[index] + 1\n stop = cruise_indicies[index + 1]\n if start < stop:\n cruise_positions[start: stop] = True\n\n return cruise_positions","def set_cruise_altitudes(altitudes, cruise_indicies):\n if cruise_indicies:\n for index in range(0, len(cruise_indicies), 2):\n start = cruise_indicies[index]\n stop = cruise_indicies[index + 1]\n if start < stop:\n cruise_altitude = closest_cruising_altitude(altitudes[start])\n altitudes[start] = cruise_altitude\n altitudes[stop] = cruise_altitude\n\n return altitudes","def RisetimeFinder(X, Y,startIndex,peakIndex,baseline):\n # Channel1Data is from first TOF\n # Channel2Data is from second TOF\n hitAmplitude = Y[peakIndex]\n UpperThreshold = baseline - (.7 * (baseline - hitAmplitude))\n LowerThreshold = baseline - (.3 * (baseline - hitAmplitude))\n riseTimestart = 0\n riseTimeend = 0\n riseIndex = 0\n fallIndex = 0\n diffs = Y[startIndex:peakIndex]-UpperThreshold\n value = np.min(abs(diffs))\n noiserms = np.std(Y[:50])*5\n YStart = Y[startIndex]\n YSign =np.sign(Y[startIndex])\n #print(value,diffs)\n #print(np.where(value == abs(diffs))[0][0])\n riseIndex = int(np.where(value == abs(diffs))[0][0]) + startIndex\n diffs = Y[startIndex:peakIndex]-LowerThreshold\n value = np.min(abs(diffs))\n fallIndex = int(np.where(value == abs(diffs))[0][0]) + startIndex\n riseTimestart = Interpolator(X, Y, riseIndex-1,riseIndex+1,UpperThreshold)\n riseTimeend = Interpolator(X, Y, fallIndex-1,fallIndex+1,LowerThreshold)\n #print(UpperThreshold,LowerThreshold)\n result = dict()\n result['risetime'] = riseTimestart-riseTimeend\n result['starttime'] = riseTimeend\n if riseTimestart < X[startIndex] or riseTimestart > X[EndIndex] or riseTimeend < X[startIndex] or riseTimeend > X[EndIndex]:\n result['risetime']= False\n if riseTimestart - riseTimeend > (X[EndIndex] - X[startIndex]):\n result['risetime']= False\n if riseTimestart - riseTimeend <= 0:\n result['risetime']= False\n if riseIndex == 0 or fallIndex ==0:\n result['risetime']= False\n if YSign > 0:\n if(YStart > baseline + noiserms):\n result['risetime']= False\n if YSign < 0:\n if(YStart < baseline - noiserms):\n result['risetime']= False\n if len(np.unique(np.sign(np.diff(Y[fallIndex:startIndex])))) > 1:\n result['risetime']= False\n\n return result","def get_emissivity_offsets(self):\n emissivity = self.ancillarydata['emissivity']\n min_emissivity = np.amin(emissivity)\n max_emissivity = np.amax(emissivity)\n\n logger.debug('Minimum emissivity value is {}'.format(min_emissivity))\n logger.debug('Maximum emissivity value is {}'.format(max_emissivity))\n\n if min_emissivity in self.emissivities.keys() and max_emissivity in self.emissivities.keys():\n startemiss = self.emissivities[min_emissivity]\n stopemiss = self.emissivities[max_emissivity]\n else:\n #Case where emissivities are not in the dict keys, need to find the closest\n #TODO: Emissivity is considered constant at the moment\n startemiss = None\n stopemiss = None\n return startemiss, stopemiss","def compute_start_end_points(linestrings):\n starts = []\n stops = []\n for ls in linestrings:\n pt = Point(ls.coords[0])\n starts.append(round(CONUS[\"poly\"].exterior.project(pt), 2))\n pt = Point(ls.coords[-1])\n stops.append(round(CONUS[\"poly\"].exterior.project(pt), 2))\n return starts, stops","def get_altitude(points):\n altitudes = np.zeros((len(points),), dtype=\"float64\")\n for i, point in tqdm(enumerate(points), desc=\"GETTING ALTITUDE\"):\n p = Point(point[0], point[1])\n altitudes[i] = alt.NM_COTA.iloc[\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\n ]\n return altitudes","def adjacencies(self, tile, tile_set):\n r, c = tile\n ns = []\n for d, (dr, dc) in self._offsets.items():\n other = (r + dr, c + dc)\n if other in tile_set:\n ns.append((d, other))\n return ns","def flightLegs(Alist,start,dest):\n Alen = len(Alist) #length of Alist\n index = list(range(Alen)) #list of airport indexes\n Adict = dict(zip(index,Alist)) #zip into dictionary\n #Adict = dict.fromkeys(range(Alen),large value) possibly qiucker?\n \n Flights = [] #output\n\n checked = [] #empty list\n tocheck = deque() #empty deque for a queue of paths to be checked\n tocheck.append([start])\n \n if start == dest: #trivial case\n return \"trivial case explored\"\n \n while tocheck: #while there are elements in tocheck\n path = tocheck.popleft() #pop out a path to be checked\n node = path[-1] #extract last element of path, this node represents an airport\n if node not in checked: #check if this path terminates in a new node/airport\n adjacents = Adict[node] #look up in dictionary airport index and return list of adjacent airports\n for n in adjacents: #extracts nodes inside list of adjacents\n if n not in checked:\n new_path = path +[n] #add neighbour to this current path\n tocheck.append(new_path) #put this new path into the queue to be checked\n if n == dest: #if this neighbour is the final destination, then the new path is the full path\n if len(Flights)==0:\n Flights.append(new_path)\n elif len(new_path)==len(Flights[-1]):\n Flights.append(new_path)\n else:\n return (len(Flights[0]),len(Flights))\n \n checked.append(node)\n\n return Flights #finds all paths need to modify to stop after a path of non shortest length is found","def scan( gaps, center, dist ):\n return _scan_reverse( gaps, center, dist ), _scan_forward( gaps, center, dist )","def racetrack_filter(reversals, h):\n\n y = reversals\n yprev = None\n ix = []\n for n, yn in enumerate(y):\n if (n == 0) or (n == y.size-1):\n yprev = yn\n ix.append(n)\n continue\n dy = yn - yprev\n if fabs(dy) > h / 2.:\n yprev = yn - dy/fabs(dy) * h/2.\n ix.append(n)\n ix = np.array(ix, dtype=int)\n return y[ix], ix","def __airfoilSplit(self):\n FoilGrad = [(self.__RawPoints[i][0]-self.__RawPoints[i+1][0]) for i in range(len(self.__RawPoints)-1)]\n\n for i in range(len(FoilGrad)-1):\n if FoilGrad[i]>=0.>=FoilGrad[i+1]:\n if FoilGrad[i+1]<=0.<=FoilGrad[i+2]:\n splitloc = i+1\n else:\n splitloc = i\n break\n elif FoilGrad[i]<=0.<=FoilGrad[i+1]:\n if FoilGrad[i+1]>=0.>=FoilGrad[i+2]:\n splitloc = i+1\n else:\n splitloc = i\n break\n \n print(FoilGrad)\n \n # Split the airfoil along chord\n self.__upper = self.__RawPoints[:splitloc+1]\n self.__lower = self.__RawPoints[splitloc+1:]\n\n # Ensure each section starts at (0,0)->(1,0)\n # NOTE: we do NOT SORT the points because we want to insure that the order is preserved\n if self.__upper[1][0] > self.__upper[-2][0]:\n self.__upper.reverse()\n if self.__lower[1][0] > self.__lower[-2][0]:\n self.__lower.reverse()","def get_hour_offsets(self):\n starttime = self.parameters['startlocaltime']\n stoptime = self.parameters['stoplocaltime']\n timediff = (stoptime - starttime)\n logger.debug(\"Start time: {} | Stop time: {}\".format(starttime, stoptime))\n if timediff > config.TIME_THRESHOLD:\n logger.debug(\"Time delta is {}. This is significantly larger than anticipated\".format(timediff))\n else:\n logger.debug(\"Time delta is {}. Using start time as the global time\".format(timediff))\n\n \"\"\"\n timediff = (stoptime - starttime).total_seconds()\n logger.debug(\"Start time: {} | Stop time: {}\".format(starttime, stoptime))\n #TODO: How do we want to handle large images with huge time differences?\n if timediff > config.TIME_THRESHOLD:\n logger.debug(\"Time delta is {}. This is significantly larger than anticipated\".format(timediff))\n starttime = starttime\n else:\n logger.debug(\"Time delta is {}. Using start time as the global time\".format(timediff))\n \"\"\"\n #Given the image start time, find the nearest index and set to the middle,\n # then find the adjacent two nodes in both directions to get allow a\n # cubic interpolation.\n #image_time = starttime.hour + starttime.minute / 60.0\n # This grabs the hour that is nearest, but hour is circular\n image_time = starttime\n if abs(image_time - 24) < abs(image_time - 23.5):\n image_time -= 24\n mididx, midhour = utils.getnearest(self.times, image_time)\n logger.debug(\"Time is {}. The nearest lookup node is {}\".format(image_time, mididx))\n minidx = mididx - 2\n maxidx = mididx + 2\n\n hourslice = np.arange(minidx, maxidx + 1, dtype=np.int8)\n\n hourslice[hourslice < 0] += 18\n\n if hourslice[-1] >= len(self.times):\n #The hour slice needs to be shifted over the time break\n hourslice[hourslice >= len(self.times)] -= len(self.times)\n logger.debug(\"Using indices {} and start time of {}.\".format(hourslice, image_time))\n return hourslice, image_time","def part1(problem_input: Iterable[str], row_y: int) -> int:\n sensor_beacons: dict[Point, tuple[Point, int]] = {\n Point(int(sx), int(sy)): (\n Point(int(bx), int(by)),\n distance(Point(int(sx), int(sy)), Point(int(bx), int(by))),\n )\n for sx, sy, bx, by in [\n re.match(\n r\"Sensor at x=([0-9-]+), y=([0-9-]+): closest beacon is at x=([0-9-]+), y=([0-9-]+)\",\n line,\n ).groups() # type: ignore\n for line in problem_input\n ]\n }\n\n min_x = min(s.x - d for s, (_, d) in sensor_beacons.items())\n max_x = max(s.x + d for s, (_, d) in sensor_beacons.items())\n\n ruled_out: set[Point] = set()\n for x in range(min_x, max_x + 1):\n p = Point(x, row_y)\n for s, (b, d) in sensor_beacons.items():\n if distance(s, p) <= d and p != b:\n ruled_out.add(p)\n break\n return len(ruled_out)","def triangulate_analytic_sun_at_center(self,r1,x2,y2,r2,x3,y3,r3):\n gamma=(r1**2+x2**2+y2**2-r2**2)/(2.0*x2)\n\ta=(y2**2)/(float(x2**2))\n\tb=-2.0*gamma*y2/x2\n\tc=gamma**2-r1**2\n\ty_plus=(-b+np.sqrt((b**2)-4*a*c))/(2.0*a)\n\ty_minus=(-b-np.sqrt((b**2)-4*a*c))/(2.0*a)\n x_plus=gamma-y_plus*y2/float(x2)\n x_minus=gamma-y_minus*y2/float(x2)\n difference_plus=(x_plus-x3)**2+(y_plus-y3)**2-r3**2\n difference_minus=(x_minus-x3)**2+(y_minus-y3)**2-r3**2\n if abs(difference_minus) < abs(difference_plus):\n print \"Difference minus\", difference_minus\n print x_minus, y_minus\n return x_minus, x_plus, difference_minus\n else:\n print \"Difference plus\", difference_plus\n print x_plus, y_plus\n return x_plus, y_plus, difference_plus","def set_start_stop_time(self):\n start_acq, stop_acq = [], []\n \n for fit_id in self.raw_results:\n print(fit_id)\n ts, _ = self.get_spec_times(fit_id)\n if len(ts) > 0:\n start_acq.append(ts.min())\n stop_acq.append(ts.max())\n \n self.setup.start = min(start_acq)\n self.setup.stop = max(stop_acq)\n return self.start, self.stop","def get_start_end_points(path, transect): \n transect_array = np.genfromtxt(path + 'tran_sim_pts.csv', delimiter=\",\")\n start_point = transect_array[2 * transect, :]\n end_point = transect_array[2 * transect + 1, :]\n \n # force start points to be west of end points\n if start_point[0] > end_point[0]:\n previous_start_point = start_point\n start_point = end_point\n end_point = previous_start_point\n return start_point, end_point","def CalcAnglesAndSlantRanges(numRxScanAngles, altitude, angles, minLookAngle):\n IA_Arr = []\n SR_Arr = []\n for i in range(numRxScanAngles):\n ia_arr = SEM.IncidenceAngle(altitude, angles[i] + minLookAngle)\n sr_arr = SEM.SlantRange(altitude, ia_arr, angles[i] + minLookAngle)\n IA_Arr.append(ia_arr)\n SR_Arr.append(sr_arr)\n return IA_Arr, SR_Arr","def searchDeadEnd(self):\n boundaries = []\n if not self.red:\n i = self.midWidth - 1\n else:\n i = self.midWidth + 1\n boudaries = [(i, j) for j in range(self.height)]\n validPositions = []\n for i in boudaries:\n if not (i[0], i[1]) in self.walls:\n validPositions.append(i)\n\n dangerPos = []\n\n toExpand = self.scanmap.twoEntryPoints()\n for (x,y) in toExpand:\n adjacent = self.scanmap.adjacentValidPoints(x, y)\n if not (x,y) in dangerPos:\n for (u, w) in adjacent:\n visited = []\n visited.append((x, y))\n safe = False\n danger = False\n DFS = util.Stack()\n DFS.push((u,w))\n while not safe and not danger:\n (i,j) = DFS.pop()\n visited.append((i,j))\n adjacents = self.scanmap.adjacentValidPoints(i,j)\n for position in adjacents:\n if not position in visited:\n DFS.push(position)\n if DFS.isEmpty():\n danger = True\n dangerPos = list(set(dangerPos) | set(visited))\n\n if (i,j) in validPositions:\n safe = True\n oneEntry = self.scanmap.oneEntryPoints()\n dangerPos = list(set(oneEntry).union(set(dangerPos)))\n dangerPos.sort()\n return dangerPos","def entryPair(self):\n exitPair = {}\n deadEnd = self.searchDeadEnd()\n deadPoints = []\n deadRoads = deadEnd.copy()\n for (x,y) in deadEnd:\n # if (x,y) not in deadPoints:\n adjacent = self.scanmap.adjacentValidPoints(x, y)\n BFS = util.Queue()\n visited = []\n BFS.push((x,y))\n while not BFS.isEmpty():\n (i,j) = BFS.pop()\n visited.append((i, j))\n adjacents = self.scanmap.adjacentValidPoints(i,j)\n for position in adjacents:\n if not position in deadRoads:\n exitPoint = position\n if position in deadRoads and not position in visited:\n BFS.push(position)\n if exitPoint in exitPair.keys():\n exitPair[exitPoint] = list(set(visited).union(set(exitPair[exitPoint])))\n else:\n exitPair[exitPoint] = visited\n deadPoints = list(set(deadEnd).difference(set(visited)))\n\n return exitPair","def find_SP_calendar_mismatch(self, asset_tuple, start_time, end_time):\n asset_id = asset_tuple[0]\n component_id = asset_tuple[1]\n latitude = asset_tuple[2]\n longitude = asset_tuple[3]\n installation_date = asset_tuple[4]\n commissioning_date = asset_tuple[5]\n street_name = asset_tuple[6]\n cabinet_id = asset_tuple[7]\n nominal_wattage = asset_tuple[8]\n\n # get calendars for this asset from XML\n calendar_xml_str = self.get_xml_with_asset_id(asset_id)\n # calendars is a list of 7 dictionaries (shapes), each of which correponds to one day in a week, starting from Sunday\n calendars = self.parse_calendar_xml(calendar_xml_str)\n\n try:\n self.cur.execute(\"select timestamp_utc, log_value, is_log_value_off \\\n from switching_points \\\n where component_id = %s \\\n and timestamp_utc >= %s and timestamp_utc < %s \\\n order by timestamp_utc\", (component_id, start_time, end_time))\n except:\n print(\"I am unable to get data\") \n\n rows = self.cur.fetchall()\n\n results = []\n for row in rows:\n # convert the time from UTC to local time\n currentTime = row[0] + self.local_time_hours_from_utc\n # log value may be -2, 0, or positive values (positive values represent dimming percent of the light)\n currentLogValue = int(row[1])\n # it is true or false\n currentIsLogValueOff = row[2]\n\n currentDate = currentTime.date()\n timePart = currentTime.time()\n\n noontime = datetime.time(12, 0, 0)\n if timePart < noontime:\n calendar_date = currentDate - self.oneDayDelta\n else: \n calendar_date = currentDate \n\n # get this day's sunrise and sunset time in local time\n sunrise_time = self.sunriseTimeDict[currentDate] + self.local_time_hours_from_utc\n sunset_time = self.sunsetTimeDict[currentDate] + self.local_time_hours_from_utc \n\n calendar_index = self.check_weekday_of_date(calendar_date)\n calendar_shape_dict = calendars[calendar_index] \n\n shape_sunrise_offset = int(calendar_shape_dict['shape_sunrise_offset'])\n shape_sunrise_offset_time = datetime.timedelta(minutes=shape_sunrise_offset)\n shape_sunset_offset = int(calendar_shape_dict['shape_sunset_offset'])\n shape_sunset_offset_time = datetime.timedelta(minutes=shape_sunset_offset)\n # shape_items is a list of dictionary (each dict is an item ordered by time)\n shape_items = calendar_shape_dict['items']\n\n calendar_date_start_time = datetime.datetime.combine(calendar_date, datetime.time())\n minutes_from_calendar_date_start = (currentTime - calendar_date_start_time).total_seconds() / 60\n\n calendar_item = self.get_calendar_item(shape_items, minutes_from_calendar_date_start)\n\n # check if the log value is valid, according to calendars and sun time\n recordInvalid = False\n sunrise_time_with_buffer = sunrise_time + shape_sunrise_offset_time + self.sunriseTimeDelta\n sunrise_time_lower_boundary = sunrise_time + shape_sunrise_offset_time - self.sunriseTimeDelta\n # always add the offset, for Jakarta_utara, the sunset_offset for calendar 2 is -6, so we add this value to sunset time\n sunset_time_with_buffer = sunset_time + shape_sunset_offset_time - self.sunsetTimeDelta\n calendar_percentage = int(calendar_item['item_percent'])\n if currentLogValue > 0:\n # it is light on record\n # need to match both sun time and calendar percent \n if currentTime >= sunrise_time_with_buffer and currentTime <= sunset_time_with_buffer:\n recordInvalid = True\n elif currentLogValue != calendar_percentage:\n #print(currentLogValue, calendar_percentage)\n recordInvalid = True\n else:\n recordInvalid = False \n elif currentLogValue == 0:\n # it is light off record \n # need to match either within sunrise buffer, or calendar_percentage value \n if currentTime >= sunrise_time_lower_boundary and currentTime <= sunrise_time_with_buffer:\n recordInvalid = False\n elif currentLogValue == calendar_percentage:\n recordInvalid = False \n else:\n recordInvalid = True\n else:\n # the currentLogValue is -2\n # need to be within sunrise buffer\n if currentTime >= sunrise_time_lower_boundary and currentTime <= sunrise_time_with_buffer:\n recordInvalid = False\n else:\n recordInvalid = True\n #print(\"-2 cases\")\n\n if recordInvalid:\n # it is invalid record\n #print(asset_id, component_id, latitude, longitude, currentTime, currentLogValue, currentIsLogValueOff) \n results.append((asset_id, component_id, latitude, longitude, installation_date, commissioning_date, street_name, cabinet_id, nominal_wattage, currentTime, currentLogValue, currentIsLogValueOff)) \n\n return results","def find_start_end(grid):\n #------------------------------------\n #\n # Fill and submit this code\n #\n start = 0\n end = 0\n for i in range(len(grid)):\n if grid[i] == \"emerald_block\":\n start = i\n elif grid[i] == \"redstone_block\":\n end = i\n return (start, end)\n #-------------------------------------","def _get_minimal_lanes(self):\n return np.argwhere(self.end_of_lanes == np.min(self.end_of_lanes)).flatten()","def _detect_takeoff(phase):\n imp_range, imp_len = get_ranges(phase, 2, True)\n takeoff = []\n\n # takeoffs from impact\n air = np.array([i == 1 for i in phase]).astype(int)\n air[np.where(phase == 2)[0]] = 3\n impact_to_air = np.where(np.ediff1d(air, to_begin=0) == -2)[0]\n for i in impact_to_air:\n # find when this impact started\n try:\n impact_start = imp_range[np.where(imp_range[:, 1] == i)[0], 0]\n takeoff_len = int((i - impact_start[0]) / 2)\n takeoff.append(np.arange(i - takeoff_len, i))\n except IndexError:\n print('error')\n pass\n if len(takeoff) > 0:\n takeoff_all = np.concatenate(takeoff).ravel()\n phase[takeoff_all] = 3","def _sort_index(self):\n\n allAltPos = np.array(sorted(list(set(list(self.data['altitude'])))))[::-1]\n allAziPos = np.array(sorted(list(set(list(self.data['azimuth'])))))\n\n indON = [[None for azi in allAziPos] for alt in allAltPos]; indOFF = [[None for azi in allAziPos] for alt in allAltPos]\n\n for i, traceItem in enumerate(self.data):\n alt = traceItem['altitude'];azi = traceItem['azimuth'];sign = traceItem['sign']\n for j, altPos in enumerate(allAltPos):\n for k, aziPos in enumerate(allAziPos):\n if alt==altPos and azi==aziPos:\n if sign==1:\n if indON[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign: 1!')\n else: indON[j][k]=i\n\n if sign==-1:\n if indOFF[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign:-1!')\n else: indOFF[j][k]=i\n\n indON = np.array([np.array(x) for x in indON]); indOFF = np.array([np.array(x) for x in indOFF])\n\n return indON,indOFF,allAltPos,allAziPos","def progress(spectra: Iterable[ConvSpectrum], energy_points: tuple[float, float]) -> tuple[np.ndarray, int | None]:\n areas = np.array([integrate(s.energies, s.intensities, energy_points) for s in spectra])\n half_life_index = None\n for i, a in enumerate(areas):\n if a < areas[0] / 2:\n half_life_index = i\n break\n\n return areas, half_life_index","def find_crime_areas(segmented_points):\n\n # once all of the interpolated points are loaded into segmented_points\n # loop through them again to find out which places are high crime.\n bad_neighborhood_crime_index = 0.2\n\n for j in range(1, len(segmented_points)):\n print \"segmented_points[j]\", segmented_points[j]\n # ====================================================================\n # waypoint algorithm fleshing out\n # ====================================================================\n if segmented_points[j]['crime_index'] > bad_neighborhood_crime_index:\n # get the center of the geohash\n print \"This is a bad neighborhood\"\n\n # this is probably temporary, for display purposes\n segmented_points[j]['is_high_crime'] = True\n\n # do a conditional that if the bad neighborhood is at\n # len(segmented_points) we need to go get the end dict\n\n # now that we know what the bad neighborhood point is, let's get\n # the latitude, longitude from the point before and the point after\n if 'lat' not in segmented_points[j-1] or 'lng' not in segmented_points[j-1]:\n point_before = (segmented_points[j-1]['data']['start']['lat'],\n segmented_points[j-1]['data']['start']['lng'])\n else:\n point_before = (segmented_points[j-1]['lat'],\n segmented_points[j-1]['lng'])\n\n if 'lat' not in segmented_points[j+1] or 'lng' not in segmented_points[j+1]:\n point_after = (segmented_points[j+1]['data']['end']['lat'],\n segmented_points[j+1]['data']['end']['lng'])\n else:\n point_after = (segmented_points[j+1]['lat'],\n segmented_points[j+1]['lng'])\n\n current_point = (segmented_points[j]['lat'],\n segmented_points[j]['lng'])\n\n # before calling inspect_waypoints, check the deltas for the\n # step before and the step after to determine whether the function\n # needs to be called twice, or four times, and what direction to go\n # get the change in latitude and longitude between the before\n # and current point location\n delta_lat_before_current = current_point[0] - point_before[0]\n delta_lng_before_current = current_point[1] - point_before[1]\n\n # get the change in latitude and longitude between the before\n # and current point location\n delta_lat_after_current = point_after[0] - current_point[0]\n delta_lng_after_current = point_after[1] - current_point[1]\n\n delta_before_after = [delta_lat_before_current, delta_lng_before_current,\n delta_lat_after_current, delta_lng_after_current]\n\n segmented_points = check_directions_find_waypoint(current_point,\n segmented_points[j],\n delta_before_after,\n segmented_points)\n print \"this is segmented_points[0] returned\", segmented_points[0]\n return segmented_points[0]","def detour(src, dst, pitstop):\n options = on_path([src, dst],query='shell gas station', size=10,urgency=0)\n ret = []\n for place in options:\n title = place['title']\n x = place['latlon']\n addr = place['address']\n A_X = dist(src, x); X_B = dist(x, dst)\n consumer_dist = A_X['distance'] + X_B['distance']\n tour_time = A_X['trafficTime']+X_B['trafficTime']\n last_mile_dist = 2*dist(pitstop, x)['distance']\n total_trip_dist = consumer_dist + last_mile_dist\n carbon_print = total_trip_dist/(1e3 * .621 * .70548)\n ret.append({\"distance\" : consumer_dist,\n \"latlon\" : x,\n \"title\" : title,\n \"time\" : tour_time,\n \"address\" : addr,\n \"carbon\" : carbon_print})\n ret = sorted(ret, key=lambda loc: loc.get('distance'))\n #print(total_trip_dist, consumer_dist, last_mile_dist)\n\n # worst carbon\n consumer_dist = dist(src, dst)['distance']\n last_mile_dist = 2*dist(pitstop, dst)['distance']\n total_trip_dist = consumer_dist + last_mile_dist\n carbon_print = total_trip_dist/(1e3 * .621 * .70548)\n #print(total_trip_dist, consumer_dist, last_mile_dist)\n\n # worst case time A - C - B\n A_C = dist(src, pitstop)\n C_B = dist(pitstop, dst)\n total_time = A_C['trafficTime'] + C_B['trafficTime']\n return {\"meetpoints\" : ret, 'worst_time' : total_time, \"worst_carbon\" : carbon_print}","def calculateTrackBetweenFlights(lat1,lon1,lat2,lon2):\n\treturn Geodesic.WGS84.Inverse(lat1,lon1, lat2, lon2)['azi1']","def denoise(self, offset_arr):\n\n measure_t, otts = zip(*offset_arr)\n all_otts = []\n all_times = []\n otts_per_h = []\n times_per_h = []\n min_arr = []\n hold_x = 0\n hold_y = 0\n ctr = 0\n n = 1\n begin = 0\n end = 120 # N refering to the amount of seconds indicating the first interval\n const = 120 # the coefficient indicating the break interval: every const seconds: must be set the same as end value\n for timel in measure_t: # divide the points every 60 seconds (probe)\n ctr += 1\n if begin <= timel < end:\n times_per_h.append(timel)\n otts_per_h.append(otts[ctr - 1])\n else:\n hold_x = timel\n hold_y = otts[ctr - 1]\n all_times.append(times_per_h)\n all_otts.append(otts_per_h)\n times_per_h = []\n otts_per_h = []\n times_per_h.append(hold_x)\n otts_per_h.append(hold_y) # for the next round\n begin = end\n n += 1\n end = n * const\n if ctr == len(measure_t) and otts_per_h: # belonging to the last hour/min only going through the if statement\n all_times.append(times_per_h)\n all_otts.append(otts_per_h)\n\n for i in range(len(all_otts)):\n try:\n idx = np.array(all_otts[i]).argmin()\n except ValueError as e:\n logging.error(\"{}/{}/{}: denoise: ValueError at argmin -- returning empty array! offset_arr: {}, error e {}\".format(self.domain, self.ip4, self.ip6, offset_arr, e))\n return []\n min_per_probe = all_otts[i][idx]\n assoc_x_per_probe = all_times[i][idx]\n min_arr.append((assoc_x_per_probe, min_per_probe))\n\n return min_arr","def find_offsets(self):\r\n\r\n #### Begin functionality here\r\n\r\n return()","def in_cruise_level_range(altitudes, cruise_altitude):\n return is_cruising(altitudes, cruise_altitude).all()","def get_head_and_tail(street):\r\n def is_end(location):\r\n num_adj = 0\r\n adj = get_orthogonal(location)\r\n for merchant in street:\r\n if merchant != location and merchant in adj:\r\n num_adj += 1\r\n return num_adj <= 1\r\n return [loc for loc in street if is_end(loc)]","def sum_light(\n els: List[Union[datetime, Tuple[datetime, int]]],\n start_watching: Optional[datetime] = None,\n end_watching: Optional[datetime] = None,\n) -> int:\n # replace elements with no bulb index\n els, switch = [(e, 0) if type(e) is datetime else e for e in els], [False] * 10\n sw, ew, on = start_watching or els[0][0], end_watching or els[-1][0], []\n # determine what intervals any lamp is on\n for idx, e in enumerate(els):\n switch[e[1]], els[idx] = not switch[e[1]], min(ew, max(e[0], sw))\n on.append(any(switch))\n # then summ all intervals where any lamp is on\n els += [ew]\n return sum(on[i] * (els[i + 1] - els[i]).total_seconds() for i in range(len(on)))","def spiketraintimerejection(spiketrain, t_start, t_stop):\n t_start, t_stop = np.array(t_start), np.array(t_stop)\n if not t_start.size == 1:\n if t_start.size != t_stop.size:\n print('Argments t_start and t_stop must have the same size')\n return [], []\n else:\n spikerejected_ind = np.zeros(len(spiketrain), dtype=bool)\n for i in range(len(t_start)):\n _, _, spikerejected_ind_i = spiketraintimerejection(spiketrain, t_start[i], t_stop[i])\n spikerejected_ind = spikerejected_ind | spikerejected_ind_i\n spiketimesel = np.array(spiketrain).ravel()[~spikerejected_ind]\n spiketrainsel = neo.core.SpikeTrain(times=spiketimesel, units=spiketrain.units, t_start=spiketrain.t_start,\n t_stop=spiketrain.t_stop, sampling_rate=spiketrain.sampling_rate,\n file_origin=spiketrain.file_origin, name=spiketrain.name)\n return spiketrainsel, spiketimesel, spikerejected_ind\n else:\n spiketimes = np.array(spiketrain).ravel()\n spikerejected_ind = np.logical_and(spiketimes >= t_start, spiketimes <= t_stop)\n spiketimesel = spiketimes[np.logical_or(spiketimes < t_start, spiketimes > t_stop)]\n spiketrainsel = neo.core.SpikeTrain(times=spiketimesel, units=spiketrain.units, t_start=spiketrain.t_start,\n t_stop=spiketrain.t_stop, sampling_rate=spiketrain.sampling_rate,\n file_origin=spiketrain.file_origin, name=spiketrain.name)\n return spiketrainsel, spiketimesel, spikerejected_ind","def longest_flight(self):\r\n distance = 0\r\n for code, _list in self.edges.items():\r\n for edge in _list:\r\n if edge.distance > distance:\r\n distance = edge.distance\r\n start = edge.start\r\n destination = edge.destination\r\n return start, destination, distance","def get_heuristic_corrections(self, tile_key):\n\n if (len(self.foc_est[tile_key]) > 1\n and len(self.astgx_est[tile_key]) > 1\n and len(self.astgy_est[tile_key]) > 1):\n\n wd_corr = (self.heuristic_calibration[0]\n * (self.foc_est[tile_key][0] - self.foc_est[tile_key][1]))\n a1 = (self.heuristic_calibration[1]\n * (self.astgx_est[tile_key][0] - self.astgx_est[tile_key][1]))\n a2 = (self.heuristic_calibration[2]\n * (self.astgy_est[tile_key][0] - self.astgy_est[tile_key][1]))\n\n ax_corr = a1 * cos(self.rot_angle) - a2 * sin(self.rot_angle)\n ay_corr = a1 * sin(self.rot_angle) + a2 * cos(self.rot_angle)\n ax_corr *= self.scale_factor\n ay_corr *= self.scale_factor\n # Are results within permissible range?\n within_range = (abs(wd_corr/1000) <= self.max_wd_diff\n and abs(ax_corr) <= self.max_sx_diff\n and abs(ay_corr) <= self.max_sy_diff)\n if within_range:\n # Store corrections for this tile:\n self.wd_stig_corr[tile_key] = [wd_corr/1000, ax_corr, ay_corr]\n else:\n self.wd_stig_corr[tile_key] = [0, 0, 0]\n\n return wd_corr, ax_corr, ay_corr, within_range\n else:\n return None, None, None, False","def _all_dist_to_end(args):\n idx = args[0]\n spiketrains = args[1]\n start = args[2]\n end = args[3]\n N = args[4]\n num_spiketrains = len(spiketrains)\n distances = []\n for jdx in range(idx+1, num_spiketrains):\n dist = distance(spiketrains[idx], spiketrains[jdx], start, end, N)\n times = dist[0] # should be the same for all\n distances.append(dist[1])\n return times, distances","def test_trips_starting_at_a_and_ending_at_c_by_4_stops(self):\n railroad = trains.Railroad()\n self.assertEqual(sorted(railroad.find_routes('A', 'C', 4, 4)), sorted(['ABCDC', 'ADCDC', 'ADEBC']))","def _get_clip_indices(utt_start, utt_end, batch_start, batch_end):\n if utt_end <= batch_start:\n return None\n if utt_start >= batch_end:\n return None\n start = 0\n end = utt_end - utt_start\n if utt_start < batch_start:\n start = batch_start - utt_start\n if utt_end > batch_end:\n end = batch_end - utt_start\n if utt_end <= batch_end:\n ends = True\n else:\n ends = False\n return (start, end), ends","def unique_radec(ra, dec, tol):\n matches = match(ra, dec, ra, dec, tol, allmatches=True)\n imatchflat = []\n for m in matches:\n imatchflat.extend(m.ind)\n\n inomatch = np.setdiff1d(np.arange(len(ra)), list(set(imatchflat)))\n\n assert len(inomatch) == 0\n # Indices giving unique ra, decs\n iunique = []\n # Will be same length as iunique. Gives all indices in original\n # coords that are matched to each unique coord.\n iextras = []\n assigned = set()\n for j,m in enumerate(matches):\n if not (j % 1000):\n print(j)\n # get the lowest index in this group\n isort = sorted(m.ind)\n ilow = isort[0]\n if ilow not in assigned:\n iunique.append(ilow)\n assigned.add(ilow)\n iextras.append([ilow])\n # assign any extra indices to this unique coord.\n for i in isort[1:]:\n # check not already been assigned to another coord\n if i not in assigned:\n iextras[-1].append(i)\n assigned.add(i)\n\n return np.array(iunique), iextras","def get_airport_start_end(result, geo_airport_cities):\n crs={'init': 'epsg:4326'}\n geometry_st = [Point(xy) for xy in zip(result.start_lon, result.start_lat)]\n geometry_end = [Point(xy) for xy in zip(result.end_lon, result.end_lat)]\n geo_st = gpd.GeoDataFrame(geometry_st, crs=crs, geometry=geometry_st)[['geometry']]\n geo_end = gpd.GeoDataFrame(geometry_end, crs=crs, geometry=geometry_end)[['geometry']]\n geo_st.crs = crs\n geo_end.crs = crs\n st_airport = pd.DataFrame(geo_st.within(geo_airport_cities['geometry'].unary_union.buffer(0.1)))\n st_airport.index=result.index\n result['geometry_st'] = st_airport\n end_airport = pd.DataFrame(geo_end.within(geo_airport_cities['geometry'].unary_union.buffer(0.1)))\n end_airport.index=result.index\n result['geometry_end'] = end_airport\n st_florence = pd.DataFrame(geo_st.within(geo_airport_cities['geometry'].loc[1].buffer(0.1)))\n st_florence.index=result.index\n result['geometry_st_fl'] = st_florence\n end_florence = pd.DataFrame(geo_end.within(geo_airport_cities['geometry'].loc[1].buffer(0.1)))\n end_florence.index=result.index\n result['geometry_end_fl'] = end_florence\n st_pisa = pd.DataFrame(geo_st.within(geo_airport_cities['geometry'].loc[0].buffer(0.1)))\n st_pisa.index=result.index\n result['geometry_st_pisa'] = st_pisa\n end_pisa = pd.DataFrame(geo_end.within(geo_airport_cities['geometry'].loc[0].buffer(0.1)))\n end_pisa.index=result.index\n result['geometry_end_pisa'] = end_pisa\n return result","def get_index_of_surface_gate(data, setup={}):\n alts = data['alt']\n return np.argmin(np.abs(alts), 1)","def compute_previous_intervals(I):\n # extract start and finish times\n start = [i.left for i in I]\n finish = [i.right for i in I]\n\n p = []\n for j in range(len(I)):\n # rightmost interval f_i <= s_j\n i = bisect.bisect_right(finish, start[j]) - 1\n p.append(i)\n\n return p","def _solve_puzzle_parts(self):\n reindeer = self._parse_input()\n race_points = {name: 0 for name in reindeer}\n max_distance = 0\n for time_elapsed in range(1, self.time_limit + 1):\n distances = {\n name: Solver._get_distance(reindeer[name], time_elapsed)\n for name in reindeer\n }\n max_distance = max(distances.values())\n race_points.update({\n name: race_points[name] + 1\n for name in race_points if distances[name] == max_distance\n })\n return max_distance, max(race_points.values())","def calc_rise_diff(self):\n ch1_rise = self.read_channel(0)\n \n ch2_rise = self.read_channel(1)\n \n if (len(ch1_rise)==0) or (len(ch2_rise))==0:\n print(\"TDC readout error\")\n return 0\n\n try:\n ch1_i=0\n ch2_i=0\n rise_diff_list=[]\n while True:\n rise_diff = ch1_rise[ch1_i] - ch2_rise[ch2_i]\n if abs(rise_diff)<50000000000: # 50ms\n rise_diff_list.append(rise_diff)\n ch1_i = ch1_i + 1\n ch2_i = ch2_i + 1\n elif rise_diff>0:\n if rise_diff>500000000000: # 0.5s\n ch1_i = ch1_i + 1\n else:\n ch2_i = ch2_i + 1\n else:\n if rise_diff<-500000000000:\n ch2_i = ch2_i + 1\n else:\n ch1_i = ch1_i + 1\n except Exception as e:\n pass\n return rise_diff_list","def _get_target_azimuths(radar_in):\n sweep_start = radar_in.sweep_start_ray_index['data'][0]\n sweep_end = radar_in.sweep_end_ray_index['data'][0]\n target_azimuths = np.sort(\n radar_in.azimuth['data'][sweep_start:sweep_end+1])\n az_tol = np.median(target_azimuths[1:]-target_azimuths[:-1])\n\n return target_azimuths, az_tol","def getAltitudeReadings():\n return RoboCaller().call(\"getAltitudeReadings\", \"int\")","def _get_death_zone_changes(self) -> Tuple[List[Square], List[Square]]:\r\n\r\n eliminated_squares: List[Square] = []\r\n new_corners: List[Square] = []\r\n\r\n original_corners: Dict[str, Square] = self._get_corner_squares()\r\n eliminated_squares.extend(\r\n self._select_squares(original_corners[Board._TOP_LEFT].pos,\r\n original_corners[Board._TOP_RIGHT].pos,\r\n offset = Pos2D(0, 1)))\r\n eliminated_squares.extend(\r\n self._select_squares(original_corners[Board._TOP_RIGHT].pos,\r\n original_corners[Board._BOTTOM_RIGHT].pos,\r\n offset = Pos2D(1, 1)))\r\n eliminated_squares.extend(\r\n self._select_squares(original_corners[Board._BOTTOM_LEFT].pos,\r\n original_corners[Board._BOTTOM_RIGHT].pos,\r\n offset = Pos2D(0, 1)))\r\n # TODO Consider that this means that top left will be in eliminated_squares TWICE due to the first argument\r\n # to _select_squares always being inclusive.\r\n eliminated_squares.extend(\r\n self._select_squares(original_corners[Board._TOP_LEFT].pos,\r\n original_corners[Board._BOTTOM_LEFT].pos,\r\n offset=Pos2D(1, 0)))\r\n\r\n new_corners.append(\r\n self.squares[original_corners[Board._TOP_LEFT].pos\r\n + Pos2D(1, 1)])\r\n new_corners.append(\r\n self.squares[original_corners[Board._BOTTOM_LEFT].pos\r\n + Pos2D(1, -1)])\r\n new_corners.append(\r\n self.squares[original_corners[Board._BOTTOM_RIGHT].pos\r\n + Pos2D(-1, -1)])\r\n new_corners.append(\r\n self.squares[original_corners[Board._TOP_RIGHT].pos\r\n + Pos2D(-1, 1)])\r\n\r\n\r\n\r\n return (eliminated_squares, new_corners)","def getIntrons(self):\n rtrn = []\n for i in range(0,len(self.exonStarts)-1):\n rtrn.append(Interval(self.chr,self.exonEnds[i]+1,self.exonStarts[i+1]-1))\n return rtrn","def find_endpoints(batch_trajectories):\n # empty lists to fill\n site_lats = []\n site_lons = []\n last_lats = []\n last_lons = []\n lats_150 = []\n lons_150 = [] \n last_times = []\n times_150 = []\n last_sst = []\n sst_150 = []\n \n # temporary lists as placeholders\n temp_site_lats = []\n temp_site_lons = []\n temp_lats = []\n temp_lons = []\n temp_lats150 = []\n temp_lons150 = []\n temp_times = []\n temp_times150 = []\n temp_sst = []\n temp_sst150 = []\n\n for speed in range(len(batch_trajectories)):\n # working with one speed at a time means working with one nc file at\n # a time\n \n # reset temporary lists\n temp_site_lats = []\n temp_site_lons = []\n temp_lats = []\n temp_lons = []\n temp_lats150 = []\n temp_lons150 = []\n temp_times = []\n temp_times150 = []\n temp_sst = []\n temp_sst150 = []\n\n # extract variables into lists\n lats = batch_trajectories[speed].variables['lat'][:]\n lons = batch_trajectories[speed].variables['lon'][:]\n lats150 = batch_trajectories[speed].variables['lat150'][:]\n lons150 = batch_trajectories[speed].variables['lon150'][:]\n times = batch_trajectories[speed].variables['time'][:]\n ssts = batch_trajectories[speed].variables['temp'][:]\n ssts_150 = batch_trajectories[speed].variables['temp150'][:]\n\n # if a particle is deleted before time is up, values are masked. \n # We'd like to get the last valid number.\n for trajectory in range(len(lats)):\n i = -1 # index for the last value\n while np.ma.is_masked(lats[trajectory][i]) is True:\n i -= 1 # if the value is masked, go to one value sooner\n \n j = i # use j for the 150m values\n while lats150[trajectory][j] > 0:\n # we want the first index where the latitude is recorded.\n # j is actually the last one where it's not recorded, so we\n # extract the information at index j+1\n j -= 1\n\n # once i and j are determined for a trajectory, we can extract the\n # variables and append them to temporary lists.\n temp_site_lats.append(lats[trajectory][0])\n temp_site_lons.append(lons[trajectory][0])\n temp_lats.append(lats[trajectory][i])\n temp_lons.append(lons[trajectory][i])\n temp_lats150.append(lats150[trajectory][j+1])\n temp_lons150.append(lons150[trajectory][j+1])\n temp_times.append(times[trajectory][i])\n temp_sst.append(ssts[trajectory][i])\n temp_sst150.append(ssts_150[trajectory][j+1])\n temp_times150.append(times[trajectory][j+1])\n \n # after the temporary lists are appended by sinking speed, they\n # are appended to the big lists that are returned by the function.\n # this keeps the structure of being separated by sinking speed.\n site_lats.append(temp_site_lats)\n site_lons.append(temp_site_lons)\n last_lats.append(temp_lats)\n last_lons.append(temp_lons)\n lats_150.append(temp_lats150)\n lons_150.append(temp_lons150)\n last_times.append(temp_times)\n times_150.append(temp_times150)\n last_sst.append(temp_sst)\n sst_150.append(temp_sst150)\n \n return site_lats, site_lons, last_lats, last_lons, lats_150, lons_150,\\\n last_times, times_150, last_sst, sst_150","def test_trips_starting_and_ending_with_c_by_3_stops(self):\n railroad = trains.Railroad()\n self.assertEqual(sorted(railroad.find_routes('C', 'C', 3)), sorted(['CDC', 'CEBC']))","def _findExonEnd(self, exonRecs, iBlkStart):\n iBlkEnd = iBlkStart + 1\n while (iBlkEnd < len(exonRecs)) and (self._tGapSize(exonRecs, iBlkEnd) < minIntronSize):\n iBlkEnd += 1\n return iBlkEnd, exonRecs[iBlkEnd - 1].end - exonRecs[iBlkStart].start","def solve_part2(start):\n inputs = load_inputs(False)\n all_matches = []\n tiles = inputs.keys()\n for elem in tiles:\n matches = defaultdict(list)\n for elem2 in tiles:\n if elem != elem2 and compare_tile(inputs[elem], inputs[elem2]):\n l = matches[elem]\n l.append(elem2)\n if matches[elem]:\n all_matches.append(matches[elem])\n\n # start frmo an aribtrary corner\n # find a match, rotate me so that the match is along the right side\n # fill in properly oriented match\n # repeat, for row = 1+, consider top-match and left-match\n\n # for eery rotations / orientation, look fot the pattern","async def test_get_alt_ac_start_and_end(test_db, tpm3_1_8_start_genomic,\n tpm3_1_8_end_genomic):\n resp = await test_db.get_alt_ac_start_and_end(\n \"NM_152263.3\", [\"117\", \"234\"], [\"822\", \"892\"], \"TPM3\")\n assert resp[0] == (tpm3_1_8_start_genomic, tpm3_1_8_end_genomic)\n assert resp[1] is None\n\n resp = await test_db.get_alt_ac_start_and_end(\"NM_152263.3\", gene=\"TPM3\")\n assert resp[0] is None\n assert resp[1] == \"Unable to find `alt_ac_start` or `alt_ac_end`\"","def _find_pickup_locations(self):\n if self._pickup_locations is None:\n maze_str = self._env.observations()['DEBUG.MAZE.LAYOUT'].strip()\n lines = maze_str.split('\\n')\n\n self._pickup_locations = []\n for j, line in enumerate(lines):\n for i, cell in enumerate(line):\n if cell == _PICKUP_SYMBOL:\n self._pickup_locations.append((i, j))\n return self._pickup_locations","def find_loners(radec, radec_all, radius):\n \n loners = np.ones(len(radec))\n for i,(ra,dec) in enumerate(radec):\n dra = abs(radec_all[:,0] - ra)\n ddec = abs(radec_all[:,1] - dec)\n keep = np.logical_and(dra < radius, ddec < radius)\n r = np.sqrt((dra[keep]**2 + ddec[keep]**2))\n r = r[r != 0]\n if any(r < radius):\n loners[i] = False\n \n return loners","def check_end(self) -> Optional[List[Point]]:\n\t\tfor x in range(self.size):\n\t\t\tfor y in range(self.size):\n\t\t\t\tif not self.tiles[x][y] == 0:\n\t\t\t\t\tresult = self.check_around(x, y)\n\t\t\t\t\tif result is not None:\n\t\t\t\t\t\treturn result\n\t\tif len(self.get_empty_tiles()) == 0:\n\t\t\treturn []\n\t\treturn None","def detect_fixations(x, y, time, missing=0.0, maxdist=25, mindur=50):\n\n # empty list to contain data\n Sfix = []\n Efix = []\n\n # loop through all coordinates\n si = 0\n fixstart = False\n for i in range(1, len(x)):\n # calculate Euclidean distance from the current fixation coordinate\n # to the next coordinate\n dist = ((x[si]-x[i])**2 + (y[si]-y[i])**2)**0.5\n # check if the next coordinate is below maximal distance\n if dist <= maxdist and not fixstart:\n # start a new fixation\n si = 0 + i\n fixstart = True\n Sfix.append([time[i]])\n elif dist > maxdist and fixstart:\n # end the current fixation\n fixstart = False\n # only store the fixation if the duration is ok\n if time[i-1]-Sfix[-1][0] >= mindur:\n Efix.append([Sfix[-1][0], time[i-1], time[i-1] -\n Sfix[-1][0], x[si], y[si]])\n # delete the last fixation start if it was too short\n else:\n Sfix.pop(-1)\n si = 0 + i\n elif not fixstart:\n si += 1\n\n return Sfix, Efix","def detect_saccades(x, y, time, missing=0.0, minlen=5, maxvel=40, maxacc=340):\n\n # CONTAINERS\n Ssac = []\n Esac = []\n\n # INTER-SAMPLE MEASURES\n # the distance between samples is the square root of the sum\n # of the squared horizontal and vertical interdistances\n intdist = (numpy.diff(x)**2 + numpy.diff(y)**2)**0.5\n # get inter-sample times\n inttime = numpy.diff(time)\n # recalculate inter-sample times to seconds\n inttime = inttime / 1000.0\n\n # VELOCITY AND ACCELERATION\n # the velocity between samples is the inter-sample distance\n # divided by the inter-sample time\n vel = intdist / inttime\n # the acceleration is the sample-to-sample difference in\n # eye movement velocity\n acc = numpy.diff(vel)\n\n # SACCADE START AND END\n t0i = 0\n stop = False\n while not stop:\n # saccade start (t1) is when the velocity or acceleration\n # surpass threshold, saccade end (t2) is when both return\n # under threshold\n\n # detect saccade starts\n sacstarts = numpy.where(\n (vel[1+t0i:] > maxvel).astype(int) + (acc[t0i:] > maxacc).astype(int) >= 1)[0]\n if len(sacstarts) > 0:\n # timestamp for starting position\n t1i = t0i + sacstarts[0] + 1\n if t1i >= len(time)-1:\n t1i = len(time)-2\n t1 = time[t1i]\n\n # add to saccade starts\n Ssac.append([t1])\n\n # detect saccade endings\n sacends = numpy.where(\n (vel[1+t1i:] < maxvel).astype(int) + (acc[t1i:] < maxacc).astype(int) == 2)[0]\n if len(sacends) > 0:\n # timestamp for ending position\n t2i = sacends[0] + 1 + t1i + 2\n if t2i >= len(time):\n t2i = len(time)-1\n t2 = time[t2i]\n dur = t2 - t1\n\n # ignore saccades that did not last long enough\n if dur >= minlen:\n # add to saccade ends\n Esac.append([t1, t2, dur, x[t1i], y[t1i], x[t2i], y[t2i]])\n else:\n # remove last saccade start on too low duration\n Ssac.pop(-1)\n\n # update t0i\n t0i = 0 + t2i\n else:\n stop = True\n else:\n stop = True\n\n return Ssac, Esac","def find_tfl_lights(image: np.ndarray):\n kernel = np.array(\n [[0, 0, 0],\n [0, 0, 0],\n [0, 1, 0],\n [1, 3, 1],\n [0, 1, 0]])\n\n kernel = kernel - kernel.mean()\n\n red_image = image.copy()\n red_image = red_image[:, :, 0]\n _, red_image = cv2.threshold(red_image, 200, 255, cv2.THRESH_BINARY)\n output = cv2.filter2D(red_image, -1, kernel)\n output_copy = output.copy()\n output = ndimage.maximum_filter(output, size=30)\n output = output - output_copy\n mask = ((output == 0) & (output_copy > 0))\n red_points = np.where(mask)\n positions = []\n final_red_points = []\n for point1 in range(len(red_points[0])):\n point = (red_points[0][point1], red_points[1][point1])\n pixel = image[point[0], point[1]]\n if (pixel[1] < 170 or pixel[2] < 120) and pixel[0] >= 200:\n final_red_points.append(point)\n final_red_points = filter_points(final_red_points)\n positions += final_red_points\n auxilary = ['r'] * len(positions)\n red_x = [val[1] for val in final_red_points]\n red_y = [val[0] for val in final_red_points]\n green_image = image.copy()\n green_image = green_image[:, :, 1]\n _, green_image = cv2.threshold(green_image, 190, 255, cv2.THRESH_BINARY)\n output = cv2.filter2D(green_image, -1, kernel)\n output_copy = output.copy()\n output = ndimage.maximum_filter(output, size=30)\n output = output - output_copy\n mask = ((output == 0) & (output_copy > 0))\n green_points = np.where(mask)\n final_green_points = []\n for point1 in range(len(green_points[0])):\n point = (green_points[0][point1], green_points[1][point1])\n pixel = image[point[0], point[1]]\n if pixel[0] <= 180 and pixel[1] >= 220 and pixel[2] >= 160:\n final_green_points.append(point)\n\n final_green_points = filter_points(final_green_points)\n positions += final_green_points\n auxilary += ['g'] * len(final_green_points)\n green_x = [val[1] for val in final_green_points]\n green_y = [val[0] for val in final_green_points]\n print(f\"There are {len(green_x) + len(red_x)} points\")\n return positions, auxilary","def relevant_indexes(data, min_threshold):\n\n start_index = 1\n end_index = len(data) - 1\n\n for i in range(len(data)):\n if data[i] > min_threshold:\n start_index = i\n break\n\n for i in range(len(data)):\n if data[::-1][i] > min_threshold:\n end_index = i\n break\n\n return start_index, end_index","def calibration(self) -> tuple[int, int, int, int, int]:","def get_elementary_airspace_altitude_range(db_id):\n connection = get_geo_db_connection()\n sector = find_sector(db_id, connection)\n if (sector):\n return (sector['min_altitude'], sector['max_altitude'])\n else:\n raise NotFoundException(db_id, \"Elementary sector not found.\")","def get_3away_pairs(kmers):\n k = len(kmers[0])\n if k == 1 or k==2:\n return []\n if k == 3:\n return [pair for pair in combinations(kmers, 2) if pair[0][0] != pair[1][0] and pair[0][1] != pair[1][1] and pair[0][2] != pair[1][2]]\n k_L = k//2\n k_R = k-k_L\n kmer_L_hashes = defaultdict(list)\n kmer_R_hashes = defaultdict(list)\n pairs = []\n kmers_L = []\n kmers_R = []\n for i, kmer in enumerate(kmers):\n kmer_L = kmer[:k_L]\n kmer_R = kmer[k_L:]\n #print(kmer_L)\n #print(kmer_R)\n kmers_L.append(kmer_L)\n kmers_R.append(kmer_R)\n kmer_L_hashes[kmer_to_int(kmer_L)] += [i]\n kmer_R_hashes[kmer_to_int(kmer_R)] += [i]\n for kmer_L_hash in kmer_L_hashes.values(): #same in first half\n if len(kmer_L_hash) > 1:\n kmer_L = kmers[kmer_L_hash[0]][:k_L] #first half\n pairs += [tuple(kmer_L + kmer for kmer in pair) for pair in get_3away_pairs([kmers[i][k_L:] for i in kmer_L_hash])] #differ by 3 in second half\n for kmer_R_hash in kmer_R_hashes.values(): #same in second half\n if len(kmer_R_hash) > 1:\n kmer_R = kmers[kmer_R_hash[0]][k_L:] #second half\n #print(kmer_R)\n pairs += [tuple(kmer + kmer_R for kmer in pair) for pair in get_3away_pairs([kmers[i][:k_L] for i in kmer_R_hash])] #differ by 3 in first half\n possible_pairs = []\n possible_pairs_L = get_1away_pairs(kmers_L)\n possible_pairs_R = get_2away_pairs(kmers_R)\n #print(kmers_L)\n #print(kmers_R)\n #print(possible_pairs_L)\n #print(possible_pairs_R)\n for possible_pair_L in possible_pairs_L:\n for possible_pair_R in possible_pairs_R:\n possible_kmer1 = possible_pair_L[0]+possible_pair_R[0]\n possible_kmer2 = possible_pair_L[1]+possible_pair_R[1]\n if possible_kmer1 in kmers and possible_kmer2 in kmers:\n pairs += [(possible_kmer1, possible_kmer2)]\n possible_pairs = []\n possible_pairs_L = get_2away_pairs(kmers_L)\n possible_pairs_R = get_1away_pairs(kmers_R)\n for possible_pair_L in possible_pairs_L:\n for possible_pair_R in possible_pairs_R:\n possible_kmer1 = possible_pair_L[0]+possible_pair_R[0]\n possible_kmer2 = possible_pair_L[1]+possible_pair_R[1]\n if possible_kmer1 in kmers and possible_kmer2 in kmers:\n pairs += [(possible_kmer1, possible_kmer2)]\n return(pairs)","def shortest_flight(self):\r\n distance = sys.maxsize\r\n for code, _list in self.edges.items():\r\n for edge in _list:\r\n if edge.distance < distance:\r\n distance = edge.distance\r\n start = edge.start\r\n destination = edge.destination\r\n return start, destination, distance","def find_intersections(wire_data):\n # Build a set of course points for each wire\n tracks = [build_track(wire) for wire in wire_data]\n\n # Find the intersection of the two lists\n intersections = list(set(tracks[0]) & set(tracks[1]))\n return intersections","def _pasrse_data_start_end(self, data):\n first = data['obs_time'].iloc[0]\n last = data['obs_time'].iloc[-1]\n\n return (first, last)","def get_slopes(timestep):\n pathing_grid = timestep.game_info.start_raw.pathing_grid\n placement_grid = timestep.game_info.start_raw.placement_grid\n terrain_height = timestep.game_info.start_raw.terrain_height\n pathing = bitmap2array(pathing_grid)\n placement = bitmap2array(placement_grid)\n height = bitmap2array(terrain_height)\n\n slopes = []\n for i in range(pathing_grid.size.x):\n for j in range(pathing_grid.size.y):\n if pathing[i, j] == 0 and placement[i, j] == 0:\n slope_item = extract_slope(i, j, pathing, placement, height)\n if slope_item.min_h != slope_item.max_h:\n slopes.append(slope_item)\n return slopes","def find_excited_locations(self):\n return np.asarray(np.where(self._grid == 8)).T","def get_loop_borders(pdb_hierarchy, center_resnum_list, ss_annot):\n f_start_res_num =-9999\n f_end_res_num = 9999999\n if ss_annot is not None:\n for elem in ss_annot.simple_elements():\n if f_start_res_num < elem.get_end_resseq_as_int() <= hy36decode(4, center_resnum_list[0]):\n # print \" cutting...\"\n f_start_res_num = elem.get_end_resseq_as_int()\n if hy36decode(4, center_resnum_list[-1]) <= elem.get_start_resseq_as_int() < f_end_res_num:\n # print \" cutting...\"\n f_end_res_num = elem.get_start_resseq_as_int()\n loop_length = f_end_res_num - f_start_res_num\n return f_start_res_num, f_end_res_num","def find_start_and_end(arr):\n start = None\n end = None\n for i, line in enumerate(arr):\n for j, node in enumerate(line):\n if node.symbol is 'A':\n start = node\n if node.symbol is 'B':\n end = node\n return start, end","async def test_get_alt_ac_start_or_end(test_db, tpm3_1_8_start_genomic,\n tpm3_1_8_end_genomic):\n resp = await test_db.get_alt_ac_start_or_end(\"NM_152263.3\", 117, 234, None)\n assert resp[0] == tpm3_1_8_start_genomic\n assert resp[1] is None\n\n resp = await test_db.get_alt_ac_start_or_end(\"NM_152263.3\", 822, 892, None)\n assert resp[0] == tpm3_1_8_end_genomic\n assert resp[1] is None\n\n resp = await test_db.get_alt_ac_start_or_end(\n \"NM_152263.63\", 822, 892, None)\n assert resp[0] is None\n assert resp[1] == \"Unable to find a result where NM_152263.63 has \" \\\n \"transcript coordinates 822 and 892 between an exon's \" \\\n \"start and end coordinates\"","def find_source(alt_az, lat_lon=local_latlong,\n minute=minute, hour=hour,\n day=day, month=month, year=year, tz_offset=5,\n return_all_sources=True):\n ra_dec = altaz_to_radec(alt_az, pos=lat_lon,\n minute=minute, hour=hour, day=day,\n month=month, year=year, tz_offset=5)\n\n coords = coordinates.SkyCoord(ra=ra_dec[0], dec=ra_dec[1],\n unit=(u.deg, u.deg), frame='icrs')\n # Get the actual results\n # For some reason, if this goes too big it stops seeing the actual source.\n r = 500 * u.arcminute\n results = Vizier.query_region(coords, radius=r, catalog='V/50')[0]\n df = results.to_pandas()\n\n candidate_sources = filter(None, [n for n in df['HD']])\n sources = []\n dmax, vmax = 0, 0\n for s in candidate_sources:\n source_info = df.loc[df['HD'] == s]\n name = source_info['Name']\n mag = round(float(source_info['Vmag']), 2)\n\n temp_ra = source_info['RAJ2000'].tolist()[0]\n temp_dec = source_info['DEJ2000'].tolist()[0]\n source_ra_hms = tuple(map(float, temp_ra.split()))\n source_dec_dms = tuple(map(float, temp_dec.split()))\n source_ra = Angle(source_ra_hms, unit='hourangle').degree\n source_dec = Angle(source_dec_dms, unit=u.deg).degree\n\n dist_from_center = np.sqrt((source_ra - ra_dec[0])**2 +\n (source_dec - ra_dec[1])**2)\n\n score = float(c1 * mag + c2 * dist_from_center)\n source_dict = {'HD': source_info['HD'].values[0],\n 'Name': source_info['Name'].values[0],\n 'RA': source_ra,\n 'DEC': source_dec,\n 'Distance': dist_from_center,\n 'Vmag': source_info['Vmag'],\n 'Score': score}\n\n sources.append(source_dict)\n\n dmax = dist_from_center if dist_from_center > dmax else dmax\n vmax = mag if mag > vmax else mag\n\n for s in range(len(sources)):\n d = sources[s]['Distance']/dmax\n mag = sources[s]['Vmag'].values[0]/vmax\n score = c1 * mag + c2 * d\n sources[s]['Score'] = score\n sources[s]['Scaled-Distance'] = d\n sources[s]['Scaled-Mag'] = mag\n\n sources_df = pd.DataFrame(sources)\n\n\n # Note that this loop is supremely janky, but df.loc'ing wasn't working.\n # best_source = sources_df.loc[sources_df['Score'] == sources_df['Score'].min]\n best_source_idx = 0\n # best_score = np.array([])\n best_score = 10000\n for i in range(len(sources)):\n score = sources[i]['Score']\n if score < best_score:\n best_source_idx = i\n best_score = score\n\n name = sources_df['Name'].values[0]\n out = {'Coords': ra_dec,\n 'HD-Name': 'HD' + str(int(sources[best_source_idx]['HD'])),\n 'Name': sources[best_source_idx]['Name'],\n 'Score': sources[best_source_idx]['Score'],\n 'Scaled-Distance': sources[best_source_idx]['Scaled-Distance'],\n 'Scaled-Mag': sources[best_source_idx]['Scaled-Mag']\n }\n return out","def takeoff_from_runway(\n self,\n airport: Union[str, \"Airport\"],\n threshold_alt: int = 2000,\n zone_length: int = 6000,\n little_base: int = 50,\n opening: float = 5,\n ) -> Iterator[\"Flight\"]:\n\n from ..data import airports\n\n # Access completion on Flight objects\n self = cast(\"Flight\", self).phases()\n\n _airport = airports[airport] if isinstance(airport, str) else airport\n if (\n _airport is None\n or _airport.runways is None\n or _airport.runways.shape.is_empty\n ):\n return None\n\n nb_run = len(_airport.runways.data)\n alt = _airport.altitude + threshold_alt\n base = zone_length * np.tan(opening * np.pi / 180) + little_base\n\n # Create shapes around each runway\n list_p0 = geo.destination(\n list(_airport.runways.data.latitude),\n list(_airport.runways.data.longitude),\n list(_airport.runways.data.bearing),\n [zone_length for i in range(nb_run)],\n )\n list_p1 = geo.destination(\n list(_airport.runways.data.latitude),\n list(_airport.runways.data.longitude),\n [x + 90 for x in list(_airport.runways.data.bearing)],\n [little_base for i in range(nb_run)],\n )\n list_p2 = geo.destination(\n list(_airport.runways.data.latitude),\n list(_airport.runways.data.longitude),\n [x - 90 for x in list(_airport.runways.data.bearing)],\n [little_base for i in range(nb_run)],\n )\n list_p3 = geo.destination(\n list_p0[0],\n list_p0[1],\n [x - 90 for x in list(_airport.runways.data.bearing)],\n [base for i in range(nb_run)],\n )\n list_p4 = geo.destination(\n list_p0[0],\n list_p0[1],\n [x + 90 for x in list(_airport.runways.data.bearing)],\n [base for i in range(nb_run)],\n )\n\n runway_polygons = {}\n\n for i, name in enumerate(_airport.runways.data.name):\n lat = [list_p1[0][i], list_p2[0][i], list_p3[0][i], list_p4[0][i]]\n lon = [list_p1[1][i], list_p2[1][i], list_p3[1][i], list_p4[1][i]]\n\n poly = Polygon(zip(lon, lat))\n runway_polygons[name] = poly\n\n low_traj = self.query(\n f\"(phase == 'CLIMB' or phase == 'LEVEL') and altitude < {alt}\"\n )\n\n if low_traj is None:\n return\n\n for segment in low_traj.split(\"2T\"):\n candidates_set = []\n for name, polygon in runway_polygons.items():\n if segment.intersects(polygon):\n candidate = (\n segment.cumulative_distance()\n .clip_iterate(polygon)\n .max(key=\"compute_gs_max\")\n )\n if candidate is None or candidate.shape is None:\n continue\n start_runway = candidate.aligned_on_runway(airport).max()\n\n if start_runway is not None:\n candidate = candidate.after(start_runway.start)\n if candidate is None or candidate.shape is None:\n continue\n if candidate.max(\"compute_gs\") < 140:\n continue\n\n candidates_set.append(candidate.assign(runway=name))\n\n result = max(\n candidates_set, key=attrgetter(\"duration\"), default=None\n )\n if result is not None:\n yield result","def introns_from_bed(bed):\n introns = set()\n with open(bed) as bed_stream:\n for line in bed_stream:\n tokens = line.rstrip().split('\\t')\n if len(tokens) < 12:\n continue\n chrom = tokens[0]\n chrom_start = int(tokens[1])\n chrom_end = int(tokens[2])\n block_sizes = tokens[10].split(',')\n block_starts = tokens[11].split(',')\n # Handle trailing commas\n try:\n int(block_sizes[-1])\n except ValueError:\n block_sizes = block_sizes[:-1]\n try:\n int(block_starts[-1])\n except ValueError:\n block_starts = block_starts[:-1]\n block_count = len(block_sizes)\n if block_count < 2:\n # No introns\n continue\n assert block_count == len(block_starts)\n junctions = []\n # First block characterizes junction on left side of intron\n junctions.append(chrom_start + int(block_starts[0]) \n + int(block_sizes[0]))\n for i in xrange(1, block_count - 1):\n # Any intervening blocks characterize two junctions\n intron_start = chrom_start + int(block_starts[i])\n junctions.append(intron_start)\n junctions.append(intron_start + int(block_sizes[i]))\n # Final block characterizes junction on right side of intron\n junctions.append(chrom_start + int(block_starts[-1]))\n for i in xrange(len(junctions)/2):\n introns.add((chrom, junctions[2*i]+1, junctions[2*i+1]+1))\n return introns","def _getscanind(self):\n \n zamin = self.za.min()\n first = np.where(self.za==zamin)[0]\n self.scan = np.zeros(self.spec.shape[0])\n if zamin < 0:\n cs = first[np.where((first - np.roll(first, 1)) != 1)[0]]\n ss = first[np.where((np.roll(first,-1) - first) != 1)[0]] + 1\n ce = ss \n se = np.roll((cs - 1) % self.za.size, -1) + 1\n for k, val in enumerate(cs):\n self.scan[val:se[k] + 1] = k\n else:\n moves = np.diff(self.za)\n max_ind = np.where(moves==moves.max())[0]\n turnover = self.za.size\n diffs = np.diff(max_ind)\n if np.unique(diffs).size > 1:\n raise ValueError, 'Can\\'t deal with non-uniform cal data yet.'\n if max_ind.size > 1:\n turnover = diffs[0]\n cs = ce = np.array([])\n ss = np.arange(self.za.size)[::turnover]\n se = np.roll((ss - 1) % self.za.size, -1)\n for k, val in enumerate(ss):\n self.scan[val:se[k] + 1] = k\n \n self.ind = {'cs': cs, 'ce': ce, 'ss': ss, 'se': se}\n self.nscan = np.unique(self.scan).size","def puzzle2(offsets):\n return find_jumps_to_exit(offsets, lambda o: o + 1 if o < 3 else o - 1)","def getAltitudeProfile(pass_length,terrain,uav_altitude,u,start_v,wind_angle):\n altitude_profile = []\n v = start_v\n for k in range(0,round(pass_length)):\n coord = convertCoords([[u,v]],wind_angle,'xy')\n x = coord[0][0]\n y = coord[0][1]\n x_points = [int(x),int(x),int(x)+1,int(x)+1]\n y_points = [int(y),int(y)+1,int(y)+1,int(y)]\n z_points = [terrain[int(y)][int(x)],terrain[int(y)+1][int(x)],\n terrain[int(y)+1][int(x)+1],terrain[int(y)][int(x)+1]]\n\n # For created terrain ONLY\n z = griddata((x_points,y_points),z_points,(x,y)) # Interpolate \n altitude = z + uav_altitude\n\n altitude_profile.append(altitude)\n v +=1\n return altitude_profile","def optimize(start, stop, step):\n #Go through every angle\n rot_angle_list = np.arange(start, stop, step)\n fitness_list = []\n best_angles_list = []\n for (i, rot_angle) in enumerate(rot_angle_list):\n (fitness, best_angles) = self._angle_fitness(rot_angle, initial_R, ending_vec, starting_vec)\n fitness_list.append(fitness)\n best_angles_list.append(best_angles)\n #Find the best result\n best_index = np.argmin(fitness_list)\n best_rot_angle = rot_angle_list[best_index]\n best_angles = best_angles_list[best_index]\n return (best_rot_angle, best_angles)","def top_of_descent_index(self):\n tod = self.altitudes.argmax()\n # if the altitude profile is not just a climb\n # and there is a cruising section\n if (tod < len(self.altitudes) - 1) and \\\n (self.altitudes[tod] == self.altitudes[tod + 1]):\n tod += 1\n\n return tod","def get_planet_next_transit(jd_start, jd_end, planet, ayanamsha_id=swe.SIDM_LAHIRI):\n swe.set_sid_mode(ayanamsha_id)\n\n transits = []\n MIN_JUMP = 15 # Random check for a transit every 15 days!\n # Could be tweaked based on planet using a dict?\n\n curr_L_bracket = jd_start\n curr_R_bracket = jd_start + MIN_JUMP\n\n while curr_R_bracket <= jd_end:\n L_rashi = floor(get_planet_lon(curr_L_bracket, planet, offset=0,\n ayanamsha_id=ayanamsha_id) / 30) + 1\n R_rashi = floor(get_planet_lon(curr_R_bracket, planet, offset=0,\n ayanamsha_id=ayanamsha_id) / 30) + 1\n\n if L_rashi == R_rashi:\n curr_R_bracket += MIN_JUMP\n continue\n else:\n # We have bracketed a transit!\n if L_rashi < R_rashi:\n target = R_rashi\n else:\n # retrograde transit\n target = L_rashi\n try:\n jd_transit = brentq(get_planet_lon, curr_L_bracket, curr_R_bracket,\n args=(planet, (-target + 1) * 30, ayanamsha_id))\n transits += [(jd_transit, L_rashi, R_rashi)]\n curr_R_bracket += MIN_JUMP\n curr_L_bracket = jd_transit + MIN_JUMP\n except ValueError:\n sys.stderr.write('Unable to compute transit of planet;\\\n possibly could not bracket correctly!\\n')\n return (None, None, None)\n\n return transits","def GetObstaclePos(self):\n # read all points from laser scan\n ranges = self.Lidar.ranges\n # transfer to np.array\n ranges = np.array(ranges)\n # get all the outlier points to a very large value\n ranges = np.where(ranges < self.Lidar.range_min, self.Lidar.range_max + 10, ranges)\n ranges = np.where(ranges > self.Lidar.range_max, self.Lidar.range_max + 10, ranges)\n if len(ranges) != 0:\n # get all default angles\n angles = self.Lidar.angle_max - self.Lidar.angle_increment * np.arange(len(ranges))\n else:\n # if nothing detected, set the default value to zero\n ranges = None\n angles = None\n return ranges, angles","def get_stopped_pts(gpx_track, speed_threshold=2.5):\n\n n = 0\n stopped_bool = [False]*gpx_track.get_points_no() # pre-allocate\n for segment in gpx_track.segments:\n for ida, point in enumerate(segment.points):\n stopped_bool[n] = segment.get_speed[ida] < speed_threshold\n n = n + 1\n\n _, stopped_time = gpx_track.get_moving_data(speed_threshold)\n\n return stopped_bool, stopped_time","def determine_middle_in_triangle(\n segments: List[LineString],\n snap_threshold: float,\n snap_threshold_error_multiplier: float,\n) -> List[LineString]:\n candidates = []\n for idx, linestring in enumerate(segments):\n others = segments.copy()\n others.pop(idx)\n if (\n sum(\n linestring.distance(other)\n < snap_threshold * snap_threshold_error_multiplier\n for other in others\n )\n >= 2\n ):\n candidates.append(segments[idx])\n return candidates","def get_corner(self, time):\n if self.start_time <= time <= self.end_time:\n diff = time - self.start_time\n return self.i[diff][0, 0], self.j[diff][0, 0]\n else:\n return -1, -1","def get_electrode_positions(self):\n return self.electrodes[:, 1:3]","def _get_goes_sat_num(start, end):\n goes_operational = {\n 2: TimeRange('1980-01-04', '1983-05-01'),\n 5: TimeRange('1983-05-02', '1984-08-01'),\n 6: TimeRange('1983-06-01', '1994-08-19'),\n 7: TimeRange('1994-01-01', '1996-08-14'),\n 8: TimeRange('1996-03-21', '2003-06-19'),\n 9: TimeRange('1997-01-01', '1998-09-09'),\n 10: TimeRange('1998-07-10', '2009-12-02'),\n 11: TimeRange('2006-06-20', '2008-02-16'),\n 12: TimeRange('2002-12-13', '2007-05-09'),\n 13: TimeRange('2006-08-01', '2006-08-01'),\n 14: TimeRange('2009-12-02', '2010-11-05'),\n 15: TimeRange('2010-09-01', Time.now()),\n }\n\n sat_list = []\n for sat_num in goes_operational:\n if (goes_operational[sat_num].start <= start <= goes_operational[sat_num].end and\n goes_operational[sat_num].start <= end <= goes_operational[sat_num].end):\n # if true then the satellite with sat_num is available\n sat_list.append(sat_num)\n\n if not sat_list:\n # if no satellites were found then raise an exception\n raise Exception('No operational GOES satellites within time range')\n else:\n return sat_list","def interiors(self):\n return self.substrates.interiors","def _pair_indices(self):\n indices_src = []\n indices_dst = []\n for i in range(self.walk_len):\n for j in range(max(i - self.l, 0), i):\n indices_src.append(i)\n indices_dst.append(j)\n for j in range(i + 1, min(i + self.r + 1, self.walk_len)):\n indices_src.append(i)\n indices_dst.append(j)\n return indices_src, indices_dst","def alt_loc_list(self):\n al_list = []\n for atm in self.iter_all_atoms():\n if atm.alt_loc != \"\" and atm.alt_loc not in al_list:\n al_list.append(atm.alt_loc)\n return al_list","def _cons_traj(self,lon,lat,period):\n\t\tgroup = self['%g_sec'%( period )]\n\t\tlonArr = group['lonArr'].value\n\t\tlatArr = group['latArr'].value\n\t\tageArr = group['age_Arr'].value\n\t\tage_drv_lon = group['age_deriv_lon_Arr']\n\t\tage_drv_lat = group['age_deriv_lat_Arr']\n\t\tage_drv_msk = group['age_deriv_msk_Arr']\n\t\ttomo_data_msk = group['tomo_data_msk'].value\n\t\tmask_init = np.logical_or(tomo_data_msk, age_drv_msk)\n\t\tmask = np.array(np.ones(lonArr.shape),dtype=bool)\n\t\ti_s, j_s = self._find_nearest_grid(lon,lat,period) # find the 1st and 2nd index of the start point on grid\n\t\tif mask_init[i_s,j_s]:\n\t\t\traise ValueError(\"The starting point is out bounds of the resulting map\")\n\t\tmask[i_s,j_s] = False\n\t\t# go along increasing age direction\n\t\ti,j = _walk(age_drv_lon,age_drv_lat,i_s,j_s,1)\n\t\twhile (0<i<lonArr.shape[0] and 0<j<lonArr.shape[1]):\n\t\t\tif mask_init[i,j]:\n\t\t\t\tbreak\n\t\t\telse:\n\t\t\t\tmask[i,j] = False\n\t\t\ti,j = _walk(age_drv_lon,age_drv_lat,i,j,1)\n\t\t\t\n\t\t# go along descending age direction\n\t\ti_2,j_2 = _walk(age_drv_lon,age_drv_lat,i_s,j_s,-1)\n\t\tmask[i_2,j_2] = False\n\t\twhile (0<i_2<lonArr.shape[0] and 0<j_2<lonArr.shape[1]):\n\t\t\tif mask_init[i_2,j_2]:\n\t\t\t\tbreak\n\t\t\telse:\n\t\t\t\tmask[i_2,j_2] = False\n\t\t\tage_b = ageArr[i_2,j_2]\n\t\t\ti_b,j_b = i_2,j_2\n\t\t\ti_2,j_2 = _walk(age_drv_lon,age_drv_lat,i_2,j_2,-1)\n\t\t\tif ageArr[i_2,j_2] > age_b: # find the youngest age\n\t\t\t\ti_3,j_3 = i_b,j_b\n\t\t\t\tbreak\n\t\ttry:\n\t\t\ti_3\n\t\texcept NameError:\n\t\t\treturn mask\n\t\t\n\t\t# go along increasing age from the found youngest age\n\t\twhile (0<i_3<lonArr.shape[0] and 0<j_3<lonArr.shape[1]):\n\t\t\tif mask_init[i_3,j_3]:\n\t\t\t\tbreak\n\t\t\telse:\n\t\t\t\tmask[i_3,j_3] = False\n\t\t\ti_3,j_3 = _walk(age_drv_lon,age_drv_lat,i_3,j_3,1)\n\t\treturn mask","def find_gains_for_baseline(self, t, bl):\n\n ant1, ant2 = baselines_2_ants([bl])\n\n # Find indx of gains entries containing ``t`` with ant1 & ant2\n indx1 = np.where((t <= self._data['stop']) & (t >= self._data['start'])\n & (self._data['antenna'] == ant1))[0]\n indx2 = np.where((t <= self._data['stop']) & (t >= self._data['start'])\n & (self._data['antenna'] == ant2))[0]\n\n # Now each gains# has shape (#if, #pol)\n gains1 = np.squeeze(self._data[indx1]['gains'])\n gains2 = np.squeeze(self._data[indx2]['gains'])\n\n # ``gains12`` has shape (#stokes, #nif)\n gains12 = np.asarray([gains1[:, 0] * np.conjugate(gains2[:, 0]),\n gains1[:, 1] * np.conjugate(gains2[:, 1]),\n gains1[:, 0] * np.conjugate(gains2[:, 1]),\n gains1[:, 1] * np.conjugate(gains2[:, 0])])\n\n return gains12"],"string":"[\n \"def intersection_distances(self, altitude, start_distance, finish_distance):\\n distances = []\\n alt_index, alt_ratio = calculate_value_reference(self.distances,\\n start_distance)\\n start_alt = calculate_value(self.altitudes, alt_index, alt_ratio)\\n\\n finish_index, finish_ratio = calculate_value_reference(self.distances,\\n finish_distance)\\n while alt_index < finish_index:\\n next_index = alt_index + 1\\n next_ratio = 0.0\\n next_alt = calculate_value(self.altitudes, next_index, next_ratio)\\n\\n # Does this section span the given altitude?\\n if (next_alt != start_alt) and \\\\\\n (min(start_alt, next_alt) < altitude < max(start_alt, next_alt)):\\n delta = altitude - start_alt\\n denom = next_alt - start_alt\\n ratio = delta / denom\\n distance = calculate_value(self.distances, alt_index, ratio)\\n distances.append(distance)\\n\\n alt_index = next_index\\n alt_ratio = next_ratio\\n start_alt = next_alt\\n\\n if finish_ratio:\\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\\n # Does the last section span the given altitude?\\n if (start_alt != finish_alt) and \\\\\\n (min(start_alt, finish_alt) < altitude < max(start_alt, finish_alt)):\\n # Calculate the altitude at the end of the section to maximimse accuracy\\n next_alt = calculate_value(self.altitudes, finish_index, 1.0)\\n delta = altitude - start_alt\\n denom = next_alt - start_alt\\n ratio = delta / denom\\n distance = calculate_value(self.distances, alt_index, ratio)\\n distances.append(distance)\\n\\n return distances\",\n \"def altitude_range(self, start_distance, finish_distance):\\n start_index, start_ratio = calculate_value_reference(self.distances,\\n start_distance)\\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\\n finish_index, finish_ratio = calculate_value_reference(self.distances,\\n finish_distance)\\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\\n\\n min_alt = min(start_alt, finish_alt)\\n max_alt = max(start_alt, finish_alt)\\n\\n if start_index < finish_index:\\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\\n min_alt = min(min_alt, altitudes.min())\\n max_alt = max(max_alt, altitudes.max())\\n\\n return min_alt, max_alt\",\n \"def startEndPoints(mazz):\\n for i in range (len(mazz)):\\n for j in range (len(mazz[i])):\\n if mazz[i][j] == 6:\\n startx = i\\n starty = j\\n elif mazz[i][j] == 7:\\n endx = i\\n endy = j\\n return startx, starty, endx, endy\",\n \"def find_level_sections(alts):\\n # Get the indicies of positions at the starts and end of levels\\n level_indicies = []\\n\\n if len(alts) > 2:\\n prev_alt = alts[0]\\n alt = alts[1]\\n\\n # If the first two altitudea are the same, mark as is_level\\n is_level = (prev_alt == alt)\\n if is_level:\\n level_indicies.append(0)\\n\\n for index in range(1, len(alts) - 1):\\n next_alt = alts[index + 1]\\n if is_level:\\n # ignore single values at a different altitude\\n is_level = (alt == next_alt)\\n if not is_level: # no longer is_level\\n # note the end cruise index\\n level_indicies.append(index)\\n else: # was not is_level\\n is_level = (alt == next_alt)\\n if is_level:\\n # note the start cruise index\\n level_indicies.append(index)\\n\\n # advance altitudes\\n alt = next_alt\\n prev_alt = alt\\n\\n # Ensure end is recorded if is_level\\n if is_level:\\n level_indicies.append(len(alts) - 1)\\n\\n return level_indicies\",\n \"def find_rpt_coords(self) -> (int, int):\\n start_size = self.size\\n end_size = self.size + len(self.allele)\\n coord = self.coord\\n fasta_alt = self.fasta_alt\\n while self.allele == fasta_alt:\\n coord += len(self.allele)\\n start_size += len(self.allele)\\n end_size += len(self.allele)\\n fasta_alt = self.seq[start_size:end_size]\\n new_start = coord - len(self.allele)\\n new_end = new_start + len(self.allele) - 1\\n return new_start, new_end\",\n \"def get_lat_offsets(self):\\n\\n startlat = self.parameters['startlatitude']\\n stoplat = self.parameters['stoplatitude']\\n\\n #Given the start and stops,\\n startidx, startvalue = utils.getnearest(self.latitudes, startlat)\\n stopidx, stopvalue = utils.getnearest(self.latitudes, stoplat)\\n startidx -= 2\\n stopidx += 2\\n latslice = np.arange(startidx, stopidx + 1)\\n if utils.checkmonotonic(latslice):\\n latslice = latslice\\n else:\\n #TODO: Support pole crossing images\\n logger.error('Image is pole crossing, not currently supported.')\\n '''\\n print \\\"NOT MONOTONIC\\\"\\n #Handle wraps around the poles\\n latslice = np.arange(start_idx, stop_idx + 1)\\n nlats = self.startlookup.shape[1]\\n greatermask = np.where(latslice >= nlats)\\n latslice[greatermask] -= nlats\\n lessmask = np.where(latslice < 0)\\n latslice[lessmask] += self.startlookup.shape[1]\\n\\n self.latsort = np.argsort(latslice)\\n self.latslice = latslice[self.latsort]\\n self.latsort = np.argsort(self.latsort)\\n '''\\n latslice = None\\n logger.debug('Start latitude node is {}. Nearest lookup node is {}.'.format(startlat, startidx))\\n logger.debug('Stop latitude node is {}. Nearest lookup node is {}.'.format(stoplat, stopidx))\\n return latslice\",\n \"def find_isolated_endpoints(lines):\\n \\n isolated_endpoints = []\\n count = len(lines)\\n print(\\\"Finding isolated end points 2/3\\\")\\n pb = pbar.ProgressBar(count)\\n for i, line in enumerate(lines):\\n pb += 1\\n other_lines = lines[:i] + lines[i+1:]\\n for q in [0,-1]:\\n endpoint = Point(line.coords[q])\\n if any(endpoint.touches(another_line) \\n for another_line in other_lines):\\n continue\\n else:\\n isolated_endpoints.append(endpoint)\\n del pb\\n return isolated_endpoints\",\n \"def identifyPutativeFields(tuning_curve):\\r\\n\\r\\n tuning_curve = np.copy(tuning_curve)\\r\\n tuning_curve = np.around(tuning_curve, decimals=3)\\r\\n elevated_indices = np.nonzero(tuning_curve)[0]\\r\\n if len(elevated_indices) == 0:\\r\\n return [[], []]\\r\\n\\r\\n putative_starts = []\\r\\n putative_ends = []\\r\\n\\r\\n putative_start = elevated_indices[0]\\r\\n\\r\\n while putative_start is not None:\\r\\n putative_starts.append(putative_start)\\r\\n # when does it return to zero?\\r\\n try:\\r\\n putative_end = putative_start + np.amin(\\r\\n np.where(tuning_curve[putative_start:] == 0)) - 1\\r\\n except ValueError:\\r\\n # does not return to 0\\r\\n putative_end = len(tuning_curve) - 1\\r\\n\\r\\n putative_ends.append(putative_end)\\r\\n\\r\\n try:\\r\\n putative_start = np.amin(\\r\\n elevated_indices[elevated_indices > putative_end])\\r\\n except ValueError:\\r\\n # no more intervals > 0\\r\\n putative_start = None\\r\\n\\r\\n # correct the wrap-around case\\r\\n if 0 in putative_starts and len(tuning_curve) - 1 in putative_ends and \\\\\\r\\n len(putative_starts) > 1:\\r\\n putative_starts.pop(0)\\r\\n putative_ends[-1] = putative_ends.pop(0)\\r\\n\\r\\n return putative_starts, putative_ends\",\n \"def find_cruise_positions(num_altitudes, cruise_indicies):\\n cruise_positions = np.zeros(num_altitudes, dtype=bool)\\n\\n if cruise_indicies:\\n for index in range(0, len(cruise_indicies), 2):\\n start = cruise_indicies[index] + 1\\n stop = cruise_indicies[index + 1]\\n if start < stop:\\n cruise_positions[start: stop] = True\\n\\n return cruise_positions\",\n \"def set_cruise_altitudes(altitudes, cruise_indicies):\\n if cruise_indicies:\\n for index in range(0, len(cruise_indicies), 2):\\n start = cruise_indicies[index]\\n stop = cruise_indicies[index + 1]\\n if start < stop:\\n cruise_altitude = closest_cruising_altitude(altitudes[start])\\n altitudes[start] = cruise_altitude\\n altitudes[stop] = cruise_altitude\\n\\n return altitudes\",\n \"def RisetimeFinder(X, Y,startIndex,peakIndex,baseline):\\n # Channel1Data is from first TOF\\n # Channel2Data is from second TOF\\n hitAmplitude = Y[peakIndex]\\n UpperThreshold = baseline - (.7 * (baseline - hitAmplitude))\\n LowerThreshold = baseline - (.3 * (baseline - hitAmplitude))\\n riseTimestart = 0\\n riseTimeend = 0\\n riseIndex = 0\\n fallIndex = 0\\n diffs = Y[startIndex:peakIndex]-UpperThreshold\\n value = np.min(abs(diffs))\\n noiserms = np.std(Y[:50])*5\\n YStart = Y[startIndex]\\n YSign =np.sign(Y[startIndex])\\n #print(value,diffs)\\n #print(np.where(value == abs(diffs))[0][0])\\n riseIndex = int(np.where(value == abs(diffs))[0][0]) + startIndex\\n diffs = Y[startIndex:peakIndex]-LowerThreshold\\n value = np.min(abs(diffs))\\n fallIndex = int(np.where(value == abs(diffs))[0][0]) + startIndex\\n riseTimestart = Interpolator(X, Y, riseIndex-1,riseIndex+1,UpperThreshold)\\n riseTimeend = Interpolator(X, Y, fallIndex-1,fallIndex+1,LowerThreshold)\\n #print(UpperThreshold,LowerThreshold)\\n result = dict()\\n result['risetime'] = riseTimestart-riseTimeend\\n result['starttime'] = riseTimeend\\n if riseTimestart < X[startIndex] or riseTimestart > X[EndIndex] or riseTimeend < X[startIndex] or riseTimeend > X[EndIndex]:\\n result['risetime']= False\\n if riseTimestart - riseTimeend > (X[EndIndex] - X[startIndex]):\\n result['risetime']= False\\n if riseTimestart - riseTimeend <= 0:\\n result['risetime']= False\\n if riseIndex == 0 or fallIndex ==0:\\n result['risetime']= False\\n if YSign > 0:\\n if(YStart > baseline + noiserms):\\n result['risetime']= False\\n if YSign < 0:\\n if(YStart < baseline - noiserms):\\n result['risetime']= False\\n if len(np.unique(np.sign(np.diff(Y[fallIndex:startIndex])))) > 1:\\n result['risetime']= False\\n\\n return result\",\n \"def get_emissivity_offsets(self):\\n emissivity = self.ancillarydata['emissivity']\\n min_emissivity = np.amin(emissivity)\\n max_emissivity = np.amax(emissivity)\\n\\n logger.debug('Minimum emissivity value is {}'.format(min_emissivity))\\n logger.debug('Maximum emissivity value is {}'.format(max_emissivity))\\n\\n if min_emissivity in self.emissivities.keys() and max_emissivity in self.emissivities.keys():\\n startemiss = self.emissivities[min_emissivity]\\n stopemiss = self.emissivities[max_emissivity]\\n else:\\n #Case where emissivities are not in the dict keys, need to find the closest\\n #TODO: Emissivity is considered constant at the moment\\n startemiss = None\\n stopemiss = None\\n return startemiss, stopemiss\",\n \"def compute_start_end_points(linestrings):\\n starts = []\\n stops = []\\n for ls in linestrings:\\n pt = Point(ls.coords[0])\\n starts.append(round(CONUS[\\\"poly\\\"].exterior.project(pt), 2))\\n pt = Point(ls.coords[-1])\\n stops.append(round(CONUS[\\\"poly\\\"].exterior.project(pt), 2))\\n return starts, stops\",\n \"def get_altitude(points):\\n altitudes = np.zeros((len(points),), dtype=\\\"float64\\\")\\n for i, point in tqdm(enumerate(points), desc=\\\"GETTING ALTITUDE\\\"):\\n p = Point(point[0], point[1])\\n altitudes[i] = alt.NM_COTA.iloc[\\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\\n ]\\n return altitudes\",\n \"def adjacencies(self, tile, tile_set):\\n r, c = tile\\n ns = []\\n for d, (dr, dc) in self._offsets.items():\\n other = (r + dr, c + dc)\\n if other in tile_set:\\n ns.append((d, other))\\n return ns\",\n \"def flightLegs(Alist,start,dest):\\n Alen = len(Alist) #length of Alist\\n index = list(range(Alen)) #list of airport indexes\\n Adict = dict(zip(index,Alist)) #zip into dictionary\\n #Adict = dict.fromkeys(range(Alen),large value) possibly qiucker?\\n \\n Flights = [] #output\\n\\n checked = [] #empty list\\n tocheck = deque() #empty deque for a queue of paths to be checked\\n tocheck.append([start])\\n \\n if start == dest: #trivial case\\n return \\\"trivial case explored\\\"\\n \\n while tocheck: #while there are elements in tocheck\\n path = tocheck.popleft() #pop out a path to be checked\\n node = path[-1] #extract last element of path, this node represents an airport\\n if node not in checked: #check if this path terminates in a new node/airport\\n adjacents = Adict[node] #look up in dictionary airport index and return list of adjacent airports\\n for n in adjacents: #extracts nodes inside list of adjacents\\n if n not in checked:\\n new_path = path +[n] #add neighbour to this current path\\n tocheck.append(new_path) #put this new path into the queue to be checked\\n if n == dest: #if this neighbour is the final destination, then the new path is the full path\\n if len(Flights)==0:\\n Flights.append(new_path)\\n elif len(new_path)==len(Flights[-1]):\\n Flights.append(new_path)\\n else:\\n return (len(Flights[0]),len(Flights))\\n \\n checked.append(node)\\n\\n return Flights #finds all paths need to modify to stop after a path of non shortest length is found\",\n \"def scan( gaps, center, dist ):\\n return _scan_reverse( gaps, center, dist ), _scan_forward( gaps, center, dist )\",\n \"def racetrack_filter(reversals, h):\\n\\n y = reversals\\n yprev = None\\n ix = []\\n for n, yn in enumerate(y):\\n if (n == 0) or (n == y.size-1):\\n yprev = yn\\n ix.append(n)\\n continue\\n dy = yn - yprev\\n if fabs(dy) > h / 2.:\\n yprev = yn - dy/fabs(dy) * h/2.\\n ix.append(n)\\n ix = np.array(ix, dtype=int)\\n return y[ix], ix\",\n \"def __airfoilSplit(self):\\n FoilGrad = [(self.__RawPoints[i][0]-self.__RawPoints[i+1][0]) for i in range(len(self.__RawPoints)-1)]\\n\\n for i in range(len(FoilGrad)-1):\\n if FoilGrad[i]>=0.>=FoilGrad[i+1]:\\n if FoilGrad[i+1]<=0.<=FoilGrad[i+2]:\\n splitloc = i+1\\n else:\\n splitloc = i\\n break\\n elif FoilGrad[i]<=0.<=FoilGrad[i+1]:\\n if FoilGrad[i+1]>=0.>=FoilGrad[i+2]:\\n splitloc = i+1\\n else:\\n splitloc = i\\n break\\n \\n print(FoilGrad)\\n \\n # Split the airfoil along chord\\n self.__upper = self.__RawPoints[:splitloc+1]\\n self.__lower = self.__RawPoints[splitloc+1:]\\n\\n # Ensure each section starts at (0,0)->(1,0)\\n # NOTE: we do NOT SORT the points because we want to insure that the order is preserved\\n if self.__upper[1][0] > self.__upper[-2][0]:\\n self.__upper.reverse()\\n if self.__lower[1][0] > self.__lower[-2][0]:\\n self.__lower.reverse()\",\n \"def get_hour_offsets(self):\\n starttime = self.parameters['startlocaltime']\\n stoptime = self.parameters['stoplocaltime']\\n timediff = (stoptime - starttime)\\n logger.debug(\\\"Start time: {} | Stop time: {}\\\".format(starttime, stoptime))\\n if timediff > config.TIME_THRESHOLD:\\n logger.debug(\\\"Time delta is {}. This is significantly larger than anticipated\\\".format(timediff))\\n else:\\n logger.debug(\\\"Time delta is {}. Using start time as the global time\\\".format(timediff))\\n\\n \\\"\\\"\\\"\\n timediff = (stoptime - starttime).total_seconds()\\n logger.debug(\\\"Start time: {} | Stop time: {}\\\".format(starttime, stoptime))\\n #TODO: How do we want to handle large images with huge time differences?\\n if timediff > config.TIME_THRESHOLD:\\n logger.debug(\\\"Time delta is {}. This is significantly larger than anticipated\\\".format(timediff))\\n starttime = starttime\\n else:\\n logger.debug(\\\"Time delta is {}. Using start time as the global time\\\".format(timediff))\\n \\\"\\\"\\\"\\n #Given the image start time, find the nearest index and set to the middle,\\n # then find the adjacent two nodes in both directions to get allow a\\n # cubic interpolation.\\n #image_time = starttime.hour + starttime.minute / 60.0\\n # This grabs the hour that is nearest, but hour is circular\\n image_time = starttime\\n if abs(image_time - 24) < abs(image_time - 23.5):\\n image_time -= 24\\n mididx, midhour = utils.getnearest(self.times, image_time)\\n logger.debug(\\\"Time is {}. The nearest lookup node is {}\\\".format(image_time, mididx))\\n minidx = mididx - 2\\n maxidx = mididx + 2\\n\\n hourslice = np.arange(minidx, maxidx + 1, dtype=np.int8)\\n\\n hourslice[hourslice < 0] += 18\\n\\n if hourslice[-1] >= len(self.times):\\n #The hour slice needs to be shifted over the time break\\n hourslice[hourslice >= len(self.times)] -= len(self.times)\\n logger.debug(\\\"Using indices {} and start time of {}.\\\".format(hourslice, image_time))\\n return hourslice, image_time\",\n \"def part1(problem_input: Iterable[str], row_y: int) -> int:\\n sensor_beacons: dict[Point, tuple[Point, int]] = {\\n Point(int(sx), int(sy)): (\\n Point(int(bx), int(by)),\\n distance(Point(int(sx), int(sy)), Point(int(bx), int(by))),\\n )\\n for sx, sy, bx, by in [\\n re.match(\\n r\\\"Sensor at x=([0-9-]+), y=([0-9-]+): closest beacon is at x=([0-9-]+), y=([0-9-]+)\\\",\\n line,\\n ).groups() # type: ignore\\n for line in problem_input\\n ]\\n }\\n\\n min_x = min(s.x - d for s, (_, d) in sensor_beacons.items())\\n max_x = max(s.x + d for s, (_, d) in sensor_beacons.items())\\n\\n ruled_out: set[Point] = set()\\n for x in range(min_x, max_x + 1):\\n p = Point(x, row_y)\\n for s, (b, d) in sensor_beacons.items():\\n if distance(s, p) <= d and p != b:\\n ruled_out.add(p)\\n break\\n return len(ruled_out)\",\n \"def triangulate_analytic_sun_at_center(self,r1,x2,y2,r2,x3,y3,r3):\\n gamma=(r1**2+x2**2+y2**2-r2**2)/(2.0*x2)\\n\\ta=(y2**2)/(float(x2**2))\\n\\tb=-2.0*gamma*y2/x2\\n\\tc=gamma**2-r1**2\\n\\ty_plus=(-b+np.sqrt((b**2)-4*a*c))/(2.0*a)\\n\\ty_minus=(-b-np.sqrt((b**2)-4*a*c))/(2.0*a)\\n x_plus=gamma-y_plus*y2/float(x2)\\n x_minus=gamma-y_minus*y2/float(x2)\\n difference_plus=(x_plus-x3)**2+(y_plus-y3)**2-r3**2\\n difference_minus=(x_minus-x3)**2+(y_minus-y3)**2-r3**2\\n if abs(difference_minus) < abs(difference_plus):\\n print \\\"Difference minus\\\", difference_minus\\n print x_minus, y_minus\\n return x_minus, x_plus, difference_minus\\n else:\\n print \\\"Difference plus\\\", difference_plus\\n print x_plus, y_plus\\n return x_plus, y_plus, difference_plus\",\n \"def set_start_stop_time(self):\\n start_acq, stop_acq = [], []\\n \\n for fit_id in self.raw_results:\\n print(fit_id)\\n ts, _ = self.get_spec_times(fit_id)\\n if len(ts) > 0:\\n start_acq.append(ts.min())\\n stop_acq.append(ts.max())\\n \\n self.setup.start = min(start_acq)\\n self.setup.stop = max(stop_acq)\\n return self.start, self.stop\",\n \"def get_start_end_points(path, transect): \\n transect_array = np.genfromtxt(path + 'tran_sim_pts.csv', delimiter=\\\",\\\")\\n start_point = transect_array[2 * transect, :]\\n end_point = transect_array[2 * transect + 1, :]\\n \\n # force start points to be west of end points\\n if start_point[0] > end_point[0]:\\n previous_start_point = start_point\\n start_point = end_point\\n end_point = previous_start_point\\n return start_point, end_point\",\n \"def CalcAnglesAndSlantRanges(numRxScanAngles, altitude, angles, minLookAngle):\\n IA_Arr = []\\n SR_Arr = []\\n for i in range(numRxScanAngles):\\n ia_arr = SEM.IncidenceAngle(altitude, angles[i] + minLookAngle)\\n sr_arr = SEM.SlantRange(altitude, ia_arr, angles[i] + minLookAngle)\\n IA_Arr.append(ia_arr)\\n SR_Arr.append(sr_arr)\\n return IA_Arr, SR_Arr\",\n \"def searchDeadEnd(self):\\n boundaries = []\\n if not self.red:\\n i = self.midWidth - 1\\n else:\\n i = self.midWidth + 1\\n boudaries = [(i, j) for j in range(self.height)]\\n validPositions = []\\n for i in boudaries:\\n if not (i[0], i[1]) in self.walls:\\n validPositions.append(i)\\n\\n dangerPos = []\\n\\n toExpand = self.scanmap.twoEntryPoints()\\n for (x,y) in toExpand:\\n adjacent = self.scanmap.adjacentValidPoints(x, y)\\n if not (x,y) in dangerPos:\\n for (u, w) in adjacent:\\n visited = []\\n visited.append((x, y))\\n safe = False\\n danger = False\\n DFS = util.Stack()\\n DFS.push((u,w))\\n while not safe and not danger:\\n (i,j) = DFS.pop()\\n visited.append((i,j))\\n adjacents = self.scanmap.adjacentValidPoints(i,j)\\n for position in adjacents:\\n if not position in visited:\\n DFS.push(position)\\n if DFS.isEmpty():\\n danger = True\\n dangerPos = list(set(dangerPos) | set(visited))\\n\\n if (i,j) in validPositions:\\n safe = True\\n oneEntry = self.scanmap.oneEntryPoints()\\n dangerPos = list(set(oneEntry).union(set(dangerPos)))\\n dangerPos.sort()\\n return dangerPos\",\n \"def entryPair(self):\\n exitPair = {}\\n deadEnd = self.searchDeadEnd()\\n deadPoints = []\\n deadRoads = deadEnd.copy()\\n for (x,y) in deadEnd:\\n # if (x,y) not in deadPoints:\\n adjacent = self.scanmap.adjacentValidPoints(x, y)\\n BFS = util.Queue()\\n visited = []\\n BFS.push((x,y))\\n while not BFS.isEmpty():\\n (i,j) = BFS.pop()\\n visited.append((i, j))\\n adjacents = self.scanmap.adjacentValidPoints(i,j)\\n for position in adjacents:\\n if not position in deadRoads:\\n exitPoint = position\\n if position in deadRoads and not position in visited:\\n BFS.push(position)\\n if exitPoint in exitPair.keys():\\n exitPair[exitPoint] = list(set(visited).union(set(exitPair[exitPoint])))\\n else:\\n exitPair[exitPoint] = visited\\n deadPoints = list(set(deadEnd).difference(set(visited)))\\n\\n return exitPair\",\n \"def find_SP_calendar_mismatch(self, asset_tuple, start_time, end_time):\\n asset_id = asset_tuple[0]\\n component_id = asset_tuple[1]\\n latitude = asset_tuple[2]\\n longitude = asset_tuple[3]\\n installation_date = asset_tuple[4]\\n commissioning_date = asset_tuple[5]\\n street_name = asset_tuple[6]\\n cabinet_id = asset_tuple[7]\\n nominal_wattage = asset_tuple[8]\\n\\n # get calendars for this asset from XML\\n calendar_xml_str = self.get_xml_with_asset_id(asset_id)\\n # calendars is a list of 7 dictionaries (shapes), each of which correponds to one day in a week, starting from Sunday\\n calendars = self.parse_calendar_xml(calendar_xml_str)\\n\\n try:\\n self.cur.execute(\\\"select timestamp_utc, log_value, is_log_value_off \\\\\\n from switching_points \\\\\\n where component_id = %s \\\\\\n and timestamp_utc >= %s and timestamp_utc < %s \\\\\\n order by timestamp_utc\\\", (component_id, start_time, end_time))\\n except:\\n print(\\\"I am unable to get data\\\") \\n\\n rows = self.cur.fetchall()\\n\\n results = []\\n for row in rows:\\n # convert the time from UTC to local time\\n currentTime = row[0] + self.local_time_hours_from_utc\\n # log value may be -2, 0, or positive values (positive values represent dimming percent of the light)\\n currentLogValue = int(row[1])\\n # it is true or false\\n currentIsLogValueOff = row[2]\\n\\n currentDate = currentTime.date()\\n timePart = currentTime.time()\\n\\n noontime = datetime.time(12, 0, 0)\\n if timePart < noontime:\\n calendar_date = currentDate - self.oneDayDelta\\n else: \\n calendar_date = currentDate \\n\\n # get this day's sunrise and sunset time in local time\\n sunrise_time = self.sunriseTimeDict[currentDate] + self.local_time_hours_from_utc\\n sunset_time = self.sunsetTimeDict[currentDate] + self.local_time_hours_from_utc \\n\\n calendar_index = self.check_weekday_of_date(calendar_date)\\n calendar_shape_dict = calendars[calendar_index] \\n\\n shape_sunrise_offset = int(calendar_shape_dict['shape_sunrise_offset'])\\n shape_sunrise_offset_time = datetime.timedelta(minutes=shape_sunrise_offset)\\n shape_sunset_offset = int(calendar_shape_dict['shape_sunset_offset'])\\n shape_sunset_offset_time = datetime.timedelta(minutes=shape_sunset_offset)\\n # shape_items is a list of dictionary (each dict is an item ordered by time)\\n shape_items = calendar_shape_dict['items']\\n\\n calendar_date_start_time = datetime.datetime.combine(calendar_date, datetime.time())\\n minutes_from_calendar_date_start = (currentTime - calendar_date_start_time).total_seconds() / 60\\n\\n calendar_item = self.get_calendar_item(shape_items, minutes_from_calendar_date_start)\\n\\n # check if the log value is valid, according to calendars and sun time\\n recordInvalid = False\\n sunrise_time_with_buffer = sunrise_time + shape_sunrise_offset_time + self.sunriseTimeDelta\\n sunrise_time_lower_boundary = sunrise_time + shape_sunrise_offset_time - self.sunriseTimeDelta\\n # always add the offset, for Jakarta_utara, the sunset_offset for calendar 2 is -6, so we add this value to sunset time\\n sunset_time_with_buffer = sunset_time + shape_sunset_offset_time - self.sunsetTimeDelta\\n calendar_percentage = int(calendar_item['item_percent'])\\n if currentLogValue > 0:\\n # it is light on record\\n # need to match both sun time and calendar percent \\n if currentTime >= sunrise_time_with_buffer and currentTime <= sunset_time_with_buffer:\\n recordInvalid = True\\n elif currentLogValue != calendar_percentage:\\n #print(currentLogValue, calendar_percentage)\\n recordInvalid = True\\n else:\\n recordInvalid = False \\n elif currentLogValue == 0:\\n # it is light off record \\n # need to match either within sunrise buffer, or calendar_percentage value \\n if currentTime >= sunrise_time_lower_boundary and currentTime <= sunrise_time_with_buffer:\\n recordInvalid = False\\n elif currentLogValue == calendar_percentage:\\n recordInvalid = False \\n else:\\n recordInvalid = True\\n else:\\n # the currentLogValue is -2\\n # need to be within sunrise buffer\\n if currentTime >= sunrise_time_lower_boundary and currentTime <= sunrise_time_with_buffer:\\n recordInvalid = False\\n else:\\n recordInvalid = True\\n #print(\\\"-2 cases\\\")\\n\\n if recordInvalid:\\n # it is invalid record\\n #print(asset_id, component_id, latitude, longitude, currentTime, currentLogValue, currentIsLogValueOff) \\n results.append((asset_id, component_id, latitude, longitude, installation_date, commissioning_date, street_name, cabinet_id, nominal_wattage, currentTime, currentLogValue, currentIsLogValueOff)) \\n\\n return results\",\n \"def find_start_end(grid):\\n #------------------------------------\\n #\\n # Fill and submit this code\\n #\\n start = 0\\n end = 0\\n for i in range(len(grid)):\\n if grid[i] == \\\"emerald_block\\\":\\n start = i\\n elif grid[i] == \\\"redstone_block\\\":\\n end = i\\n return (start, end)\\n #-------------------------------------\",\n \"def _get_minimal_lanes(self):\\n return np.argwhere(self.end_of_lanes == np.min(self.end_of_lanes)).flatten()\",\n \"def _detect_takeoff(phase):\\n imp_range, imp_len = get_ranges(phase, 2, True)\\n takeoff = []\\n\\n # takeoffs from impact\\n air = np.array([i == 1 for i in phase]).astype(int)\\n air[np.where(phase == 2)[0]] = 3\\n impact_to_air = np.where(np.ediff1d(air, to_begin=0) == -2)[0]\\n for i in impact_to_air:\\n # find when this impact started\\n try:\\n impact_start = imp_range[np.where(imp_range[:, 1] == i)[0], 0]\\n takeoff_len = int((i - impact_start[0]) / 2)\\n takeoff.append(np.arange(i - takeoff_len, i))\\n except IndexError:\\n print('error')\\n pass\\n if len(takeoff) > 0:\\n takeoff_all = np.concatenate(takeoff).ravel()\\n phase[takeoff_all] = 3\",\n \"def _sort_index(self):\\n\\n allAltPos = np.array(sorted(list(set(list(self.data['altitude'])))))[::-1]\\n allAziPos = np.array(sorted(list(set(list(self.data['azimuth'])))))\\n\\n indON = [[None for azi in allAziPos] for alt in allAltPos]; indOFF = [[None for azi in allAziPos] for alt in allAltPos]\\n\\n for i, traceItem in enumerate(self.data):\\n alt = traceItem['altitude'];azi = traceItem['azimuth'];sign = traceItem['sign']\\n for j, altPos in enumerate(allAltPos):\\n for k, aziPos in enumerate(allAziPos):\\n if alt==altPos and azi==aziPos:\\n if sign==1:\\n if indON[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign: 1!')\\n else: indON[j][k]=i\\n\\n if sign==-1:\\n if indOFF[j][k] is not None: raise LookupError('Duplication of trace items found at location:'+str([alt, azi])+'; sign:-1!')\\n else: indOFF[j][k]=i\\n\\n indON = np.array([np.array(x) for x in indON]); indOFF = np.array([np.array(x) for x in indOFF])\\n\\n return indON,indOFF,allAltPos,allAziPos\",\n \"def progress(spectra: Iterable[ConvSpectrum], energy_points: tuple[float, float]) -> tuple[np.ndarray, int | None]:\\n areas = np.array([integrate(s.energies, s.intensities, energy_points) for s in spectra])\\n half_life_index = None\\n for i, a in enumerate(areas):\\n if a < areas[0] / 2:\\n half_life_index = i\\n break\\n\\n return areas, half_life_index\",\n \"def find_crime_areas(segmented_points):\\n\\n # once all of the interpolated points are loaded into segmented_points\\n # loop through them again to find out which places are high crime.\\n bad_neighborhood_crime_index = 0.2\\n\\n for j in range(1, len(segmented_points)):\\n print \\\"segmented_points[j]\\\", segmented_points[j]\\n # ====================================================================\\n # waypoint algorithm fleshing out\\n # ====================================================================\\n if segmented_points[j]['crime_index'] > bad_neighborhood_crime_index:\\n # get the center of the geohash\\n print \\\"This is a bad neighborhood\\\"\\n\\n # this is probably temporary, for display purposes\\n segmented_points[j]['is_high_crime'] = True\\n\\n # do a conditional that if the bad neighborhood is at\\n # len(segmented_points) we need to go get the end dict\\n\\n # now that we know what the bad neighborhood point is, let's get\\n # the latitude, longitude from the point before and the point after\\n if 'lat' not in segmented_points[j-1] or 'lng' not in segmented_points[j-1]:\\n point_before = (segmented_points[j-1]['data']['start']['lat'],\\n segmented_points[j-1]['data']['start']['lng'])\\n else:\\n point_before = (segmented_points[j-1]['lat'],\\n segmented_points[j-1]['lng'])\\n\\n if 'lat' not in segmented_points[j+1] or 'lng' not in segmented_points[j+1]:\\n point_after = (segmented_points[j+1]['data']['end']['lat'],\\n segmented_points[j+1]['data']['end']['lng'])\\n else:\\n point_after = (segmented_points[j+1]['lat'],\\n segmented_points[j+1]['lng'])\\n\\n current_point = (segmented_points[j]['lat'],\\n segmented_points[j]['lng'])\\n\\n # before calling inspect_waypoints, check the deltas for the\\n # step before and the step after to determine whether the function\\n # needs to be called twice, or four times, and what direction to go\\n # get the change in latitude and longitude between the before\\n # and current point location\\n delta_lat_before_current = current_point[0] - point_before[0]\\n delta_lng_before_current = current_point[1] - point_before[1]\\n\\n # get the change in latitude and longitude between the before\\n # and current point location\\n delta_lat_after_current = point_after[0] - current_point[0]\\n delta_lng_after_current = point_after[1] - current_point[1]\\n\\n delta_before_after = [delta_lat_before_current, delta_lng_before_current,\\n delta_lat_after_current, delta_lng_after_current]\\n\\n segmented_points = check_directions_find_waypoint(current_point,\\n segmented_points[j],\\n delta_before_after,\\n segmented_points)\\n print \\\"this is segmented_points[0] returned\\\", segmented_points[0]\\n return segmented_points[0]\",\n \"def detour(src, dst, pitstop):\\n options = on_path([src, dst],query='shell gas station', size=10,urgency=0)\\n ret = []\\n for place in options:\\n title = place['title']\\n x = place['latlon']\\n addr = place['address']\\n A_X = dist(src, x); X_B = dist(x, dst)\\n consumer_dist = A_X['distance'] + X_B['distance']\\n tour_time = A_X['trafficTime']+X_B['trafficTime']\\n last_mile_dist = 2*dist(pitstop, x)['distance']\\n total_trip_dist = consumer_dist + last_mile_dist\\n carbon_print = total_trip_dist/(1e3 * .621 * .70548)\\n ret.append({\\\"distance\\\" : consumer_dist,\\n \\\"latlon\\\" : x,\\n \\\"title\\\" : title,\\n \\\"time\\\" : tour_time,\\n \\\"address\\\" : addr,\\n \\\"carbon\\\" : carbon_print})\\n ret = sorted(ret, key=lambda loc: loc.get('distance'))\\n #print(total_trip_dist, consumer_dist, last_mile_dist)\\n\\n # worst carbon\\n consumer_dist = dist(src, dst)['distance']\\n last_mile_dist = 2*dist(pitstop, dst)['distance']\\n total_trip_dist = consumer_dist + last_mile_dist\\n carbon_print = total_trip_dist/(1e3 * .621 * .70548)\\n #print(total_trip_dist, consumer_dist, last_mile_dist)\\n\\n # worst case time A - C - B\\n A_C = dist(src, pitstop)\\n C_B = dist(pitstop, dst)\\n total_time = A_C['trafficTime'] + C_B['trafficTime']\\n return {\\\"meetpoints\\\" : ret, 'worst_time' : total_time, \\\"worst_carbon\\\" : carbon_print}\",\n \"def calculateTrackBetweenFlights(lat1,lon1,lat2,lon2):\\n\\treturn Geodesic.WGS84.Inverse(lat1,lon1, lat2, lon2)['azi1']\",\n \"def denoise(self, offset_arr):\\n\\n measure_t, otts = zip(*offset_arr)\\n all_otts = []\\n all_times = []\\n otts_per_h = []\\n times_per_h = []\\n min_arr = []\\n hold_x = 0\\n hold_y = 0\\n ctr = 0\\n n = 1\\n begin = 0\\n end = 120 # N refering to the amount of seconds indicating the first interval\\n const = 120 # the coefficient indicating the break interval: every const seconds: must be set the same as end value\\n for timel in measure_t: # divide the points every 60 seconds (probe)\\n ctr += 1\\n if begin <= timel < end:\\n times_per_h.append(timel)\\n otts_per_h.append(otts[ctr - 1])\\n else:\\n hold_x = timel\\n hold_y = otts[ctr - 1]\\n all_times.append(times_per_h)\\n all_otts.append(otts_per_h)\\n times_per_h = []\\n otts_per_h = []\\n times_per_h.append(hold_x)\\n otts_per_h.append(hold_y) # for the next round\\n begin = end\\n n += 1\\n end = n * const\\n if ctr == len(measure_t) and otts_per_h: # belonging to the last hour/min only going through the if statement\\n all_times.append(times_per_h)\\n all_otts.append(otts_per_h)\\n\\n for i in range(len(all_otts)):\\n try:\\n idx = np.array(all_otts[i]).argmin()\\n except ValueError as e:\\n logging.error(\\\"{}/{}/{}: denoise: ValueError at argmin -- returning empty array! offset_arr: {}, error e {}\\\".format(self.domain, self.ip4, self.ip6, offset_arr, e))\\n return []\\n min_per_probe = all_otts[i][idx]\\n assoc_x_per_probe = all_times[i][idx]\\n min_arr.append((assoc_x_per_probe, min_per_probe))\\n\\n return min_arr\",\n \"def find_offsets(self):\\r\\n\\r\\n #### Begin functionality here\\r\\n\\r\\n return()\",\n \"def in_cruise_level_range(altitudes, cruise_altitude):\\n return is_cruising(altitudes, cruise_altitude).all()\",\n \"def get_head_and_tail(street):\\r\\n def is_end(location):\\r\\n num_adj = 0\\r\\n adj = get_orthogonal(location)\\r\\n for merchant in street:\\r\\n if merchant != location and merchant in adj:\\r\\n num_adj += 1\\r\\n return num_adj <= 1\\r\\n return [loc for loc in street if is_end(loc)]\",\n \"def sum_light(\\n els: List[Union[datetime, Tuple[datetime, int]]],\\n start_watching: Optional[datetime] = None,\\n end_watching: Optional[datetime] = None,\\n) -> int:\\n # replace elements with no bulb index\\n els, switch = [(e, 0) if type(e) is datetime else e for e in els], [False] * 10\\n sw, ew, on = start_watching or els[0][0], end_watching or els[-1][0], []\\n # determine what intervals any lamp is on\\n for idx, e in enumerate(els):\\n switch[e[1]], els[idx] = not switch[e[1]], min(ew, max(e[0], sw))\\n on.append(any(switch))\\n # then summ all intervals where any lamp is on\\n els += [ew]\\n return sum(on[i] * (els[i + 1] - els[i]).total_seconds() for i in range(len(on)))\",\n \"def spiketraintimerejection(spiketrain, t_start, t_stop):\\n t_start, t_stop = np.array(t_start), np.array(t_stop)\\n if not t_start.size == 1:\\n if t_start.size != t_stop.size:\\n print('Argments t_start and t_stop must have the same size')\\n return [], []\\n else:\\n spikerejected_ind = np.zeros(len(spiketrain), dtype=bool)\\n for i in range(len(t_start)):\\n _, _, spikerejected_ind_i = spiketraintimerejection(spiketrain, t_start[i], t_stop[i])\\n spikerejected_ind = spikerejected_ind | spikerejected_ind_i\\n spiketimesel = np.array(spiketrain).ravel()[~spikerejected_ind]\\n spiketrainsel = neo.core.SpikeTrain(times=spiketimesel, units=spiketrain.units, t_start=spiketrain.t_start,\\n t_stop=spiketrain.t_stop, sampling_rate=spiketrain.sampling_rate,\\n file_origin=spiketrain.file_origin, name=spiketrain.name)\\n return spiketrainsel, spiketimesel, spikerejected_ind\\n else:\\n spiketimes = np.array(spiketrain).ravel()\\n spikerejected_ind = np.logical_and(spiketimes >= t_start, spiketimes <= t_stop)\\n spiketimesel = spiketimes[np.logical_or(spiketimes < t_start, spiketimes > t_stop)]\\n spiketrainsel = neo.core.SpikeTrain(times=spiketimesel, units=spiketrain.units, t_start=spiketrain.t_start,\\n t_stop=spiketrain.t_stop, sampling_rate=spiketrain.sampling_rate,\\n file_origin=spiketrain.file_origin, name=spiketrain.name)\\n return spiketrainsel, spiketimesel, spikerejected_ind\",\n \"def longest_flight(self):\\r\\n distance = 0\\r\\n for code, _list in self.edges.items():\\r\\n for edge in _list:\\r\\n if edge.distance > distance:\\r\\n distance = edge.distance\\r\\n start = edge.start\\r\\n destination = edge.destination\\r\\n return start, destination, distance\",\n \"def get_heuristic_corrections(self, tile_key):\\n\\n if (len(self.foc_est[tile_key]) > 1\\n and len(self.astgx_est[tile_key]) > 1\\n and len(self.astgy_est[tile_key]) > 1):\\n\\n wd_corr = (self.heuristic_calibration[0]\\n * (self.foc_est[tile_key][0] - self.foc_est[tile_key][1]))\\n a1 = (self.heuristic_calibration[1]\\n * (self.astgx_est[tile_key][0] - self.astgx_est[tile_key][1]))\\n a2 = (self.heuristic_calibration[2]\\n * (self.astgy_est[tile_key][0] - self.astgy_est[tile_key][1]))\\n\\n ax_corr = a1 * cos(self.rot_angle) - a2 * sin(self.rot_angle)\\n ay_corr = a1 * sin(self.rot_angle) + a2 * cos(self.rot_angle)\\n ax_corr *= self.scale_factor\\n ay_corr *= self.scale_factor\\n # Are results within permissible range?\\n within_range = (abs(wd_corr/1000) <= self.max_wd_diff\\n and abs(ax_corr) <= self.max_sx_diff\\n and abs(ay_corr) <= self.max_sy_diff)\\n if within_range:\\n # Store corrections for this tile:\\n self.wd_stig_corr[tile_key] = [wd_corr/1000, ax_corr, ay_corr]\\n else:\\n self.wd_stig_corr[tile_key] = [0, 0, 0]\\n\\n return wd_corr, ax_corr, ay_corr, within_range\\n else:\\n return None, None, None, False\",\n \"def _all_dist_to_end(args):\\n idx = args[0]\\n spiketrains = args[1]\\n start = args[2]\\n end = args[3]\\n N = args[4]\\n num_spiketrains = len(spiketrains)\\n distances = []\\n for jdx in range(idx+1, num_spiketrains):\\n dist = distance(spiketrains[idx], spiketrains[jdx], start, end, N)\\n times = dist[0] # should be the same for all\\n distances.append(dist[1])\\n return times, distances\",\n \"def test_trips_starting_at_a_and_ending_at_c_by_4_stops(self):\\n railroad = trains.Railroad()\\n self.assertEqual(sorted(railroad.find_routes('A', 'C', 4, 4)), sorted(['ABCDC', 'ADCDC', 'ADEBC']))\",\n \"def _get_clip_indices(utt_start, utt_end, batch_start, batch_end):\\n if utt_end <= batch_start:\\n return None\\n if utt_start >= batch_end:\\n return None\\n start = 0\\n end = utt_end - utt_start\\n if utt_start < batch_start:\\n start = batch_start - utt_start\\n if utt_end > batch_end:\\n end = batch_end - utt_start\\n if utt_end <= batch_end:\\n ends = True\\n else:\\n ends = False\\n return (start, end), ends\",\n \"def unique_radec(ra, dec, tol):\\n matches = match(ra, dec, ra, dec, tol, allmatches=True)\\n imatchflat = []\\n for m in matches:\\n imatchflat.extend(m.ind)\\n\\n inomatch = np.setdiff1d(np.arange(len(ra)), list(set(imatchflat)))\\n\\n assert len(inomatch) == 0\\n # Indices giving unique ra, decs\\n iunique = []\\n # Will be same length as iunique. Gives all indices in original\\n # coords that are matched to each unique coord.\\n iextras = []\\n assigned = set()\\n for j,m in enumerate(matches):\\n if not (j % 1000):\\n print(j)\\n # get the lowest index in this group\\n isort = sorted(m.ind)\\n ilow = isort[0]\\n if ilow not in assigned:\\n iunique.append(ilow)\\n assigned.add(ilow)\\n iextras.append([ilow])\\n # assign any extra indices to this unique coord.\\n for i in isort[1:]:\\n # check not already been assigned to another coord\\n if i not in assigned:\\n iextras[-1].append(i)\\n assigned.add(i)\\n\\n return np.array(iunique), iextras\",\n \"def get_airport_start_end(result, geo_airport_cities):\\n crs={'init': 'epsg:4326'}\\n geometry_st = [Point(xy) for xy in zip(result.start_lon, result.start_lat)]\\n geometry_end = [Point(xy) for xy in zip(result.end_lon, result.end_lat)]\\n geo_st = gpd.GeoDataFrame(geometry_st, crs=crs, geometry=geometry_st)[['geometry']]\\n geo_end = gpd.GeoDataFrame(geometry_end, crs=crs, geometry=geometry_end)[['geometry']]\\n geo_st.crs = crs\\n geo_end.crs = crs\\n st_airport = pd.DataFrame(geo_st.within(geo_airport_cities['geometry'].unary_union.buffer(0.1)))\\n st_airport.index=result.index\\n result['geometry_st'] = st_airport\\n end_airport = pd.DataFrame(geo_end.within(geo_airport_cities['geometry'].unary_union.buffer(0.1)))\\n end_airport.index=result.index\\n result['geometry_end'] = end_airport\\n st_florence = pd.DataFrame(geo_st.within(geo_airport_cities['geometry'].loc[1].buffer(0.1)))\\n st_florence.index=result.index\\n result['geometry_st_fl'] = st_florence\\n end_florence = pd.DataFrame(geo_end.within(geo_airport_cities['geometry'].loc[1].buffer(0.1)))\\n end_florence.index=result.index\\n result['geometry_end_fl'] = end_florence\\n st_pisa = pd.DataFrame(geo_st.within(geo_airport_cities['geometry'].loc[0].buffer(0.1)))\\n st_pisa.index=result.index\\n result['geometry_st_pisa'] = st_pisa\\n end_pisa = pd.DataFrame(geo_end.within(geo_airport_cities['geometry'].loc[0].buffer(0.1)))\\n end_pisa.index=result.index\\n result['geometry_end_pisa'] = end_pisa\\n return result\",\n \"def get_index_of_surface_gate(data, setup={}):\\n alts = data['alt']\\n return np.argmin(np.abs(alts), 1)\",\n \"def compute_previous_intervals(I):\\n # extract start and finish times\\n start = [i.left for i in I]\\n finish = [i.right for i in I]\\n\\n p = []\\n for j in range(len(I)):\\n # rightmost interval f_i <= s_j\\n i = bisect.bisect_right(finish, start[j]) - 1\\n p.append(i)\\n\\n return p\",\n \"def _solve_puzzle_parts(self):\\n reindeer = self._parse_input()\\n race_points = {name: 0 for name in reindeer}\\n max_distance = 0\\n for time_elapsed in range(1, self.time_limit + 1):\\n distances = {\\n name: Solver._get_distance(reindeer[name], time_elapsed)\\n for name in reindeer\\n }\\n max_distance = max(distances.values())\\n race_points.update({\\n name: race_points[name] + 1\\n for name in race_points if distances[name] == max_distance\\n })\\n return max_distance, max(race_points.values())\",\n \"def calc_rise_diff(self):\\n ch1_rise = self.read_channel(0)\\n \\n ch2_rise = self.read_channel(1)\\n \\n if (len(ch1_rise)==0) or (len(ch2_rise))==0:\\n print(\\\"TDC readout error\\\")\\n return 0\\n\\n try:\\n ch1_i=0\\n ch2_i=0\\n rise_diff_list=[]\\n while True:\\n rise_diff = ch1_rise[ch1_i] - ch2_rise[ch2_i]\\n if abs(rise_diff)<50000000000: # 50ms\\n rise_diff_list.append(rise_diff)\\n ch1_i = ch1_i + 1\\n ch2_i = ch2_i + 1\\n elif rise_diff>0:\\n if rise_diff>500000000000: # 0.5s\\n ch1_i = ch1_i + 1\\n else:\\n ch2_i = ch2_i + 1\\n else:\\n if rise_diff<-500000000000:\\n ch2_i = ch2_i + 1\\n else:\\n ch1_i = ch1_i + 1\\n except Exception as e:\\n pass\\n return rise_diff_list\",\n \"def _get_target_azimuths(radar_in):\\n sweep_start = radar_in.sweep_start_ray_index['data'][0]\\n sweep_end = radar_in.sweep_end_ray_index['data'][0]\\n target_azimuths = np.sort(\\n radar_in.azimuth['data'][sweep_start:sweep_end+1])\\n az_tol = np.median(target_azimuths[1:]-target_azimuths[:-1])\\n\\n return target_azimuths, az_tol\",\n \"def getAltitudeReadings():\\n return RoboCaller().call(\\\"getAltitudeReadings\\\", \\\"int\\\")\",\n \"def _get_death_zone_changes(self) -> Tuple[List[Square], List[Square]]:\\r\\n\\r\\n eliminated_squares: List[Square] = []\\r\\n new_corners: List[Square] = []\\r\\n\\r\\n original_corners: Dict[str, Square] = self._get_corner_squares()\\r\\n eliminated_squares.extend(\\r\\n self._select_squares(original_corners[Board._TOP_LEFT].pos,\\r\\n original_corners[Board._TOP_RIGHT].pos,\\r\\n offset = Pos2D(0, 1)))\\r\\n eliminated_squares.extend(\\r\\n self._select_squares(original_corners[Board._TOP_RIGHT].pos,\\r\\n original_corners[Board._BOTTOM_RIGHT].pos,\\r\\n offset = Pos2D(1, 1)))\\r\\n eliminated_squares.extend(\\r\\n self._select_squares(original_corners[Board._BOTTOM_LEFT].pos,\\r\\n original_corners[Board._BOTTOM_RIGHT].pos,\\r\\n offset = Pos2D(0, 1)))\\r\\n # TODO Consider that this means that top left will be in eliminated_squares TWICE due to the first argument\\r\\n # to _select_squares always being inclusive.\\r\\n eliminated_squares.extend(\\r\\n self._select_squares(original_corners[Board._TOP_LEFT].pos,\\r\\n original_corners[Board._BOTTOM_LEFT].pos,\\r\\n offset=Pos2D(1, 0)))\\r\\n\\r\\n new_corners.append(\\r\\n self.squares[original_corners[Board._TOP_LEFT].pos\\r\\n + Pos2D(1, 1)])\\r\\n new_corners.append(\\r\\n self.squares[original_corners[Board._BOTTOM_LEFT].pos\\r\\n + Pos2D(1, -1)])\\r\\n new_corners.append(\\r\\n self.squares[original_corners[Board._BOTTOM_RIGHT].pos\\r\\n + Pos2D(-1, -1)])\\r\\n new_corners.append(\\r\\n self.squares[original_corners[Board._TOP_RIGHT].pos\\r\\n + Pos2D(-1, 1)])\\r\\n\\r\\n\\r\\n\\r\\n return (eliminated_squares, new_corners)\",\n \"def getIntrons(self):\\n rtrn = []\\n for i in range(0,len(self.exonStarts)-1):\\n rtrn.append(Interval(self.chr,self.exonEnds[i]+1,self.exonStarts[i+1]-1))\\n return rtrn\",\n \"def find_endpoints(batch_trajectories):\\n # empty lists to fill\\n site_lats = []\\n site_lons = []\\n last_lats = []\\n last_lons = []\\n lats_150 = []\\n lons_150 = [] \\n last_times = []\\n times_150 = []\\n last_sst = []\\n sst_150 = []\\n \\n # temporary lists as placeholders\\n temp_site_lats = []\\n temp_site_lons = []\\n temp_lats = []\\n temp_lons = []\\n temp_lats150 = []\\n temp_lons150 = []\\n temp_times = []\\n temp_times150 = []\\n temp_sst = []\\n temp_sst150 = []\\n\\n for speed in range(len(batch_trajectories)):\\n # working with one speed at a time means working with one nc file at\\n # a time\\n \\n # reset temporary lists\\n temp_site_lats = []\\n temp_site_lons = []\\n temp_lats = []\\n temp_lons = []\\n temp_lats150 = []\\n temp_lons150 = []\\n temp_times = []\\n temp_times150 = []\\n temp_sst = []\\n temp_sst150 = []\\n\\n # extract variables into lists\\n lats = batch_trajectories[speed].variables['lat'][:]\\n lons = batch_trajectories[speed].variables['lon'][:]\\n lats150 = batch_trajectories[speed].variables['lat150'][:]\\n lons150 = batch_trajectories[speed].variables['lon150'][:]\\n times = batch_trajectories[speed].variables['time'][:]\\n ssts = batch_trajectories[speed].variables['temp'][:]\\n ssts_150 = batch_trajectories[speed].variables['temp150'][:]\\n\\n # if a particle is deleted before time is up, values are masked. \\n # We'd like to get the last valid number.\\n for trajectory in range(len(lats)):\\n i = -1 # index for the last value\\n while np.ma.is_masked(lats[trajectory][i]) is True:\\n i -= 1 # if the value is masked, go to one value sooner\\n \\n j = i # use j for the 150m values\\n while lats150[trajectory][j] > 0:\\n # we want the first index where the latitude is recorded.\\n # j is actually the last one where it's not recorded, so we\\n # extract the information at index j+1\\n j -= 1\\n\\n # once i and j are determined for a trajectory, we can extract the\\n # variables and append them to temporary lists.\\n temp_site_lats.append(lats[trajectory][0])\\n temp_site_lons.append(lons[trajectory][0])\\n temp_lats.append(lats[trajectory][i])\\n temp_lons.append(lons[trajectory][i])\\n temp_lats150.append(lats150[trajectory][j+1])\\n temp_lons150.append(lons150[trajectory][j+1])\\n temp_times.append(times[trajectory][i])\\n temp_sst.append(ssts[trajectory][i])\\n temp_sst150.append(ssts_150[trajectory][j+1])\\n temp_times150.append(times[trajectory][j+1])\\n \\n # after the temporary lists are appended by sinking speed, they\\n # are appended to the big lists that are returned by the function.\\n # this keeps the structure of being separated by sinking speed.\\n site_lats.append(temp_site_lats)\\n site_lons.append(temp_site_lons)\\n last_lats.append(temp_lats)\\n last_lons.append(temp_lons)\\n lats_150.append(temp_lats150)\\n lons_150.append(temp_lons150)\\n last_times.append(temp_times)\\n times_150.append(temp_times150)\\n last_sst.append(temp_sst)\\n sst_150.append(temp_sst150)\\n \\n return site_lats, site_lons, last_lats, last_lons, lats_150, lons_150,\\\\\\n last_times, times_150, last_sst, sst_150\",\n \"def test_trips_starting_and_ending_with_c_by_3_stops(self):\\n railroad = trains.Railroad()\\n self.assertEqual(sorted(railroad.find_routes('C', 'C', 3)), sorted(['CDC', 'CEBC']))\",\n \"def _findExonEnd(self, exonRecs, iBlkStart):\\n iBlkEnd = iBlkStart + 1\\n while (iBlkEnd < len(exonRecs)) and (self._tGapSize(exonRecs, iBlkEnd) < minIntronSize):\\n iBlkEnd += 1\\n return iBlkEnd, exonRecs[iBlkEnd - 1].end - exonRecs[iBlkStart].start\",\n \"def solve_part2(start):\\n inputs = load_inputs(False)\\n all_matches = []\\n tiles = inputs.keys()\\n for elem in tiles:\\n matches = defaultdict(list)\\n for elem2 in tiles:\\n if elem != elem2 and compare_tile(inputs[elem], inputs[elem2]):\\n l = matches[elem]\\n l.append(elem2)\\n if matches[elem]:\\n all_matches.append(matches[elem])\\n\\n # start frmo an aribtrary corner\\n # find a match, rotate me so that the match is along the right side\\n # fill in properly oriented match\\n # repeat, for row = 1+, consider top-match and left-match\\n\\n # for eery rotations / orientation, look fot the pattern\",\n \"async def test_get_alt_ac_start_and_end(test_db, tpm3_1_8_start_genomic,\\n tpm3_1_8_end_genomic):\\n resp = await test_db.get_alt_ac_start_and_end(\\n \\\"NM_152263.3\\\", [\\\"117\\\", \\\"234\\\"], [\\\"822\\\", \\\"892\\\"], \\\"TPM3\\\")\\n assert resp[0] == (tpm3_1_8_start_genomic, tpm3_1_8_end_genomic)\\n assert resp[1] is None\\n\\n resp = await test_db.get_alt_ac_start_and_end(\\\"NM_152263.3\\\", gene=\\\"TPM3\\\")\\n assert resp[0] is None\\n assert resp[1] == \\\"Unable to find `alt_ac_start` or `alt_ac_end`\\\"\",\n \"def _find_pickup_locations(self):\\n if self._pickup_locations is None:\\n maze_str = self._env.observations()['DEBUG.MAZE.LAYOUT'].strip()\\n lines = maze_str.split('\\\\n')\\n\\n self._pickup_locations = []\\n for j, line in enumerate(lines):\\n for i, cell in enumerate(line):\\n if cell == _PICKUP_SYMBOL:\\n self._pickup_locations.append((i, j))\\n return self._pickup_locations\",\n \"def find_loners(radec, radec_all, radius):\\n \\n loners = np.ones(len(radec))\\n for i,(ra,dec) in enumerate(radec):\\n dra = abs(radec_all[:,0] - ra)\\n ddec = abs(radec_all[:,1] - dec)\\n keep = np.logical_and(dra < radius, ddec < radius)\\n r = np.sqrt((dra[keep]**2 + ddec[keep]**2))\\n r = r[r != 0]\\n if any(r < radius):\\n loners[i] = False\\n \\n return loners\",\n \"def check_end(self) -> Optional[List[Point]]:\\n\\t\\tfor x in range(self.size):\\n\\t\\t\\tfor y in range(self.size):\\n\\t\\t\\t\\tif not self.tiles[x][y] == 0:\\n\\t\\t\\t\\t\\tresult = self.check_around(x, y)\\n\\t\\t\\t\\t\\tif result is not None:\\n\\t\\t\\t\\t\\t\\treturn result\\n\\t\\tif len(self.get_empty_tiles()) == 0:\\n\\t\\t\\treturn []\\n\\t\\treturn None\",\n \"def detect_fixations(x, y, time, missing=0.0, maxdist=25, mindur=50):\\n\\n # empty list to contain data\\n Sfix = []\\n Efix = []\\n\\n # loop through all coordinates\\n si = 0\\n fixstart = False\\n for i in range(1, len(x)):\\n # calculate Euclidean distance from the current fixation coordinate\\n # to the next coordinate\\n dist = ((x[si]-x[i])**2 + (y[si]-y[i])**2)**0.5\\n # check if the next coordinate is below maximal distance\\n if dist <= maxdist and not fixstart:\\n # start a new fixation\\n si = 0 + i\\n fixstart = True\\n Sfix.append([time[i]])\\n elif dist > maxdist and fixstart:\\n # end the current fixation\\n fixstart = False\\n # only store the fixation if the duration is ok\\n if time[i-1]-Sfix[-1][0] >= mindur:\\n Efix.append([Sfix[-1][0], time[i-1], time[i-1] -\\n Sfix[-1][0], x[si], y[si]])\\n # delete the last fixation start if it was too short\\n else:\\n Sfix.pop(-1)\\n si = 0 + i\\n elif not fixstart:\\n si += 1\\n\\n return Sfix, Efix\",\n \"def detect_saccades(x, y, time, missing=0.0, minlen=5, maxvel=40, maxacc=340):\\n\\n # CONTAINERS\\n Ssac = []\\n Esac = []\\n\\n # INTER-SAMPLE MEASURES\\n # the distance between samples is the square root of the sum\\n # of the squared horizontal and vertical interdistances\\n intdist = (numpy.diff(x)**2 + numpy.diff(y)**2)**0.5\\n # get inter-sample times\\n inttime = numpy.diff(time)\\n # recalculate inter-sample times to seconds\\n inttime = inttime / 1000.0\\n\\n # VELOCITY AND ACCELERATION\\n # the velocity between samples is the inter-sample distance\\n # divided by the inter-sample time\\n vel = intdist / inttime\\n # the acceleration is the sample-to-sample difference in\\n # eye movement velocity\\n acc = numpy.diff(vel)\\n\\n # SACCADE START AND END\\n t0i = 0\\n stop = False\\n while not stop:\\n # saccade start (t1) is when the velocity or acceleration\\n # surpass threshold, saccade end (t2) is when both return\\n # under threshold\\n\\n # detect saccade starts\\n sacstarts = numpy.where(\\n (vel[1+t0i:] > maxvel).astype(int) + (acc[t0i:] > maxacc).astype(int) >= 1)[0]\\n if len(sacstarts) > 0:\\n # timestamp for starting position\\n t1i = t0i + sacstarts[0] + 1\\n if t1i >= len(time)-1:\\n t1i = len(time)-2\\n t1 = time[t1i]\\n\\n # add to saccade starts\\n Ssac.append([t1])\\n\\n # detect saccade endings\\n sacends = numpy.where(\\n (vel[1+t1i:] < maxvel).astype(int) + (acc[t1i:] < maxacc).astype(int) == 2)[0]\\n if len(sacends) > 0:\\n # timestamp for ending position\\n t2i = sacends[0] + 1 + t1i + 2\\n if t2i >= len(time):\\n t2i = len(time)-1\\n t2 = time[t2i]\\n dur = t2 - t1\\n\\n # ignore saccades that did not last long enough\\n if dur >= minlen:\\n # add to saccade ends\\n Esac.append([t1, t2, dur, x[t1i], y[t1i], x[t2i], y[t2i]])\\n else:\\n # remove last saccade start on too low duration\\n Ssac.pop(-1)\\n\\n # update t0i\\n t0i = 0 + t2i\\n else:\\n stop = True\\n else:\\n stop = True\\n\\n return Ssac, Esac\",\n \"def find_tfl_lights(image: np.ndarray):\\n kernel = np.array(\\n [[0, 0, 0],\\n [0, 0, 0],\\n [0, 1, 0],\\n [1, 3, 1],\\n [0, 1, 0]])\\n\\n kernel = kernel - kernel.mean()\\n\\n red_image = image.copy()\\n red_image = red_image[:, :, 0]\\n _, red_image = cv2.threshold(red_image, 200, 255, cv2.THRESH_BINARY)\\n output = cv2.filter2D(red_image, -1, kernel)\\n output_copy = output.copy()\\n output = ndimage.maximum_filter(output, size=30)\\n output = output - output_copy\\n mask = ((output == 0) & (output_copy > 0))\\n red_points = np.where(mask)\\n positions = []\\n final_red_points = []\\n for point1 in range(len(red_points[0])):\\n point = (red_points[0][point1], red_points[1][point1])\\n pixel = image[point[0], point[1]]\\n if (pixel[1] < 170 or pixel[2] < 120) and pixel[0] >= 200:\\n final_red_points.append(point)\\n final_red_points = filter_points(final_red_points)\\n positions += final_red_points\\n auxilary = ['r'] * len(positions)\\n red_x = [val[1] for val in final_red_points]\\n red_y = [val[0] for val in final_red_points]\\n green_image = image.copy()\\n green_image = green_image[:, :, 1]\\n _, green_image = cv2.threshold(green_image, 190, 255, cv2.THRESH_BINARY)\\n output = cv2.filter2D(green_image, -1, kernel)\\n output_copy = output.copy()\\n output = ndimage.maximum_filter(output, size=30)\\n output = output - output_copy\\n mask = ((output == 0) & (output_copy > 0))\\n green_points = np.where(mask)\\n final_green_points = []\\n for point1 in range(len(green_points[0])):\\n point = (green_points[0][point1], green_points[1][point1])\\n pixel = image[point[0], point[1]]\\n if pixel[0] <= 180 and pixel[1] >= 220 and pixel[2] >= 160:\\n final_green_points.append(point)\\n\\n final_green_points = filter_points(final_green_points)\\n positions += final_green_points\\n auxilary += ['g'] * len(final_green_points)\\n green_x = [val[1] for val in final_green_points]\\n green_y = [val[0] for val in final_green_points]\\n print(f\\\"There are {len(green_x) + len(red_x)} points\\\")\\n return positions, auxilary\",\n \"def relevant_indexes(data, min_threshold):\\n\\n start_index = 1\\n end_index = len(data) - 1\\n\\n for i in range(len(data)):\\n if data[i] > min_threshold:\\n start_index = i\\n break\\n\\n for i in range(len(data)):\\n if data[::-1][i] > min_threshold:\\n end_index = i\\n break\\n\\n return start_index, end_index\",\n \"def calibration(self) -> tuple[int, int, int, int, int]:\",\n \"def get_elementary_airspace_altitude_range(db_id):\\n connection = get_geo_db_connection()\\n sector = find_sector(db_id, connection)\\n if (sector):\\n return (sector['min_altitude'], sector['max_altitude'])\\n else:\\n raise NotFoundException(db_id, \\\"Elementary sector not found.\\\")\",\n \"def get_3away_pairs(kmers):\\n k = len(kmers[0])\\n if k == 1 or k==2:\\n return []\\n if k == 3:\\n return [pair for pair in combinations(kmers, 2) if pair[0][0] != pair[1][0] and pair[0][1] != pair[1][1] and pair[0][2] != pair[1][2]]\\n k_L = k//2\\n k_R = k-k_L\\n kmer_L_hashes = defaultdict(list)\\n kmer_R_hashes = defaultdict(list)\\n pairs = []\\n kmers_L = []\\n kmers_R = []\\n for i, kmer in enumerate(kmers):\\n kmer_L = kmer[:k_L]\\n kmer_R = kmer[k_L:]\\n #print(kmer_L)\\n #print(kmer_R)\\n kmers_L.append(kmer_L)\\n kmers_R.append(kmer_R)\\n kmer_L_hashes[kmer_to_int(kmer_L)] += [i]\\n kmer_R_hashes[kmer_to_int(kmer_R)] += [i]\\n for kmer_L_hash in kmer_L_hashes.values(): #same in first half\\n if len(kmer_L_hash) > 1:\\n kmer_L = kmers[kmer_L_hash[0]][:k_L] #first half\\n pairs += [tuple(kmer_L + kmer for kmer in pair) for pair in get_3away_pairs([kmers[i][k_L:] for i in kmer_L_hash])] #differ by 3 in second half\\n for kmer_R_hash in kmer_R_hashes.values(): #same in second half\\n if len(kmer_R_hash) > 1:\\n kmer_R = kmers[kmer_R_hash[0]][k_L:] #second half\\n #print(kmer_R)\\n pairs += [tuple(kmer + kmer_R for kmer in pair) for pair in get_3away_pairs([kmers[i][:k_L] for i in kmer_R_hash])] #differ by 3 in first half\\n possible_pairs = []\\n possible_pairs_L = get_1away_pairs(kmers_L)\\n possible_pairs_R = get_2away_pairs(kmers_R)\\n #print(kmers_L)\\n #print(kmers_R)\\n #print(possible_pairs_L)\\n #print(possible_pairs_R)\\n for possible_pair_L in possible_pairs_L:\\n for possible_pair_R in possible_pairs_R:\\n possible_kmer1 = possible_pair_L[0]+possible_pair_R[0]\\n possible_kmer2 = possible_pair_L[1]+possible_pair_R[1]\\n if possible_kmer1 in kmers and possible_kmer2 in kmers:\\n pairs += [(possible_kmer1, possible_kmer2)]\\n possible_pairs = []\\n possible_pairs_L = get_2away_pairs(kmers_L)\\n possible_pairs_R = get_1away_pairs(kmers_R)\\n for possible_pair_L in possible_pairs_L:\\n for possible_pair_R in possible_pairs_R:\\n possible_kmer1 = possible_pair_L[0]+possible_pair_R[0]\\n possible_kmer2 = possible_pair_L[1]+possible_pair_R[1]\\n if possible_kmer1 in kmers and possible_kmer2 in kmers:\\n pairs += [(possible_kmer1, possible_kmer2)]\\n return(pairs)\",\n \"def shortest_flight(self):\\r\\n distance = sys.maxsize\\r\\n for code, _list in self.edges.items():\\r\\n for edge in _list:\\r\\n if edge.distance < distance:\\r\\n distance = edge.distance\\r\\n start = edge.start\\r\\n destination = edge.destination\\r\\n return start, destination, distance\",\n \"def find_intersections(wire_data):\\n # Build a set of course points for each wire\\n tracks = [build_track(wire) for wire in wire_data]\\n\\n # Find the intersection of the two lists\\n intersections = list(set(tracks[0]) & set(tracks[1]))\\n return intersections\",\n \"def _pasrse_data_start_end(self, data):\\n first = data['obs_time'].iloc[0]\\n last = data['obs_time'].iloc[-1]\\n\\n return (first, last)\",\n \"def get_slopes(timestep):\\n pathing_grid = timestep.game_info.start_raw.pathing_grid\\n placement_grid = timestep.game_info.start_raw.placement_grid\\n terrain_height = timestep.game_info.start_raw.terrain_height\\n pathing = bitmap2array(pathing_grid)\\n placement = bitmap2array(placement_grid)\\n height = bitmap2array(terrain_height)\\n\\n slopes = []\\n for i in range(pathing_grid.size.x):\\n for j in range(pathing_grid.size.y):\\n if pathing[i, j] == 0 and placement[i, j] == 0:\\n slope_item = extract_slope(i, j, pathing, placement, height)\\n if slope_item.min_h != slope_item.max_h:\\n slopes.append(slope_item)\\n return slopes\",\n \"def find_excited_locations(self):\\n return np.asarray(np.where(self._grid == 8)).T\",\n \"def get_loop_borders(pdb_hierarchy, center_resnum_list, ss_annot):\\n f_start_res_num =-9999\\n f_end_res_num = 9999999\\n if ss_annot is not None:\\n for elem in ss_annot.simple_elements():\\n if f_start_res_num < elem.get_end_resseq_as_int() <= hy36decode(4, center_resnum_list[0]):\\n # print \\\" cutting...\\\"\\n f_start_res_num = elem.get_end_resseq_as_int()\\n if hy36decode(4, center_resnum_list[-1]) <= elem.get_start_resseq_as_int() < f_end_res_num:\\n # print \\\" cutting...\\\"\\n f_end_res_num = elem.get_start_resseq_as_int()\\n loop_length = f_end_res_num - f_start_res_num\\n return f_start_res_num, f_end_res_num\",\n \"def find_start_and_end(arr):\\n start = None\\n end = None\\n for i, line in enumerate(arr):\\n for j, node in enumerate(line):\\n if node.symbol is 'A':\\n start = node\\n if node.symbol is 'B':\\n end = node\\n return start, end\",\n \"async def test_get_alt_ac_start_or_end(test_db, tpm3_1_8_start_genomic,\\n tpm3_1_8_end_genomic):\\n resp = await test_db.get_alt_ac_start_or_end(\\\"NM_152263.3\\\", 117, 234, None)\\n assert resp[0] == tpm3_1_8_start_genomic\\n assert resp[1] is None\\n\\n resp = await test_db.get_alt_ac_start_or_end(\\\"NM_152263.3\\\", 822, 892, None)\\n assert resp[0] == tpm3_1_8_end_genomic\\n assert resp[1] is None\\n\\n resp = await test_db.get_alt_ac_start_or_end(\\n \\\"NM_152263.63\\\", 822, 892, None)\\n assert resp[0] is None\\n assert resp[1] == \\\"Unable to find a result where NM_152263.63 has \\\" \\\\\\n \\\"transcript coordinates 822 and 892 between an exon's \\\" \\\\\\n \\\"start and end coordinates\\\"\",\n \"def find_source(alt_az, lat_lon=local_latlong,\\n minute=minute, hour=hour,\\n day=day, month=month, year=year, tz_offset=5,\\n return_all_sources=True):\\n ra_dec = altaz_to_radec(alt_az, pos=lat_lon,\\n minute=minute, hour=hour, day=day,\\n month=month, year=year, tz_offset=5)\\n\\n coords = coordinates.SkyCoord(ra=ra_dec[0], dec=ra_dec[1],\\n unit=(u.deg, u.deg), frame='icrs')\\n # Get the actual results\\n # For some reason, if this goes too big it stops seeing the actual source.\\n r = 500 * u.arcminute\\n results = Vizier.query_region(coords, radius=r, catalog='V/50')[0]\\n df = results.to_pandas()\\n\\n candidate_sources = filter(None, [n for n in df['HD']])\\n sources = []\\n dmax, vmax = 0, 0\\n for s in candidate_sources:\\n source_info = df.loc[df['HD'] == s]\\n name = source_info['Name']\\n mag = round(float(source_info['Vmag']), 2)\\n\\n temp_ra = source_info['RAJ2000'].tolist()[0]\\n temp_dec = source_info['DEJ2000'].tolist()[0]\\n source_ra_hms = tuple(map(float, temp_ra.split()))\\n source_dec_dms = tuple(map(float, temp_dec.split()))\\n source_ra = Angle(source_ra_hms, unit='hourangle').degree\\n source_dec = Angle(source_dec_dms, unit=u.deg).degree\\n\\n dist_from_center = np.sqrt((source_ra - ra_dec[0])**2 +\\n (source_dec - ra_dec[1])**2)\\n\\n score = float(c1 * mag + c2 * dist_from_center)\\n source_dict = {'HD': source_info['HD'].values[0],\\n 'Name': source_info['Name'].values[0],\\n 'RA': source_ra,\\n 'DEC': source_dec,\\n 'Distance': dist_from_center,\\n 'Vmag': source_info['Vmag'],\\n 'Score': score}\\n\\n sources.append(source_dict)\\n\\n dmax = dist_from_center if dist_from_center > dmax else dmax\\n vmax = mag if mag > vmax else mag\\n\\n for s in range(len(sources)):\\n d = sources[s]['Distance']/dmax\\n mag = sources[s]['Vmag'].values[0]/vmax\\n score = c1 * mag + c2 * d\\n sources[s]['Score'] = score\\n sources[s]['Scaled-Distance'] = d\\n sources[s]['Scaled-Mag'] = mag\\n\\n sources_df = pd.DataFrame(sources)\\n\\n\\n # Note that this loop is supremely janky, but df.loc'ing wasn't working.\\n # best_source = sources_df.loc[sources_df['Score'] == sources_df['Score'].min]\\n best_source_idx = 0\\n # best_score = np.array([])\\n best_score = 10000\\n for i in range(len(sources)):\\n score = sources[i]['Score']\\n if score < best_score:\\n best_source_idx = i\\n best_score = score\\n\\n name = sources_df['Name'].values[0]\\n out = {'Coords': ra_dec,\\n 'HD-Name': 'HD' + str(int(sources[best_source_idx]['HD'])),\\n 'Name': sources[best_source_idx]['Name'],\\n 'Score': sources[best_source_idx]['Score'],\\n 'Scaled-Distance': sources[best_source_idx]['Scaled-Distance'],\\n 'Scaled-Mag': sources[best_source_idx]['Scaled-Mag']\\n }\\n return out\",\n \"def takeoff_from_runway(\\n self,\\n airport: Union[str, \\\"Airport\\\"],\\n threshold_alt: int = 2000,\\n zone_length: int = 6000,\\n little_base: int = 50,\\n opening: float = 5,\\n ) -> Iterator[\\\"Flight\\\"]:\\n\\n from ..data import airports\\n\\n # Access completion on Flight objects\\n self = cast(\\\"Flight\\\", self).phases()\\n\\n _airport = airports[airport] if isinstance(airport, str) else airport\\n if (\\n _airport is None\\n or _airport.runways is None\\n or _airport.runways.shape.is_empty\\n ):\\n return None\\n\\n nb_run = len(_airport.runways.data)\\n alt = _airport.altitude + threshold_alt\\n base = zone_length * np.tan(opening * np.pi / 180) + little_base\\n\\n # Create shapes around each runway\\n list_p0 = geo.destination(\\n list(_airport.runways.data.latitude),\\n list(_airport.runways.data.longitude),\\n list(_airport.runways.data.bearing),\\n [zone_length for i in range(nb_run)],\\n )\\n list_p1 = geo.destination(\\n list(_airport.runways.data.latitude),\\n list(_airport.runways.data.longitude),\\n [x + 90 for x in list(_airport.runways.data.bearing)],\\n [little_base for i in range(nb_run)],\\n )\\n list_p2 = geo.destination(\\n list(_airport.runways.data.latitude),\\n list(_airport.runways.data.longitude),\\n [x - 90 for x in list(_airport.runways.data.bearing)],\\n [little_base for i in range(nb_run)],\\n )\\n list_p3 = geo.destination(\\n list_p0[0],\\n list_p0[1],\\n [x - 90 for x in list(_airport.runways.data.bearing)],\\n [base for i in range(nb_run)],\\n )\\n list_p4 = geo.destination(\\n list_p0[0],\\n list_p0[1],\\n [x + 90 for x in list(_airport.runways.data.bearing)],\\n [base for i in range(nb_run)],\\n )\\n\\n runway_polygons = {}\\n\\n for i, name in enumerate(_airport.runways.data.name):\\n lat = [list_p1[0][i], list_p2[0][i], list_p3[0][i], list_p4[0][i]]\\n lon = [list_p1[1][i], list_p2[1][i], list_p3[1][i], list_p4[1][i]]\\n\\n poly = Polygon(zip(lon, lat))\\n runway_polygons[name] = poly\\n\\n low_traj = self.query(\\n f\\\"(phase == 'CLIMB' or phase == 'LEVEL') and altitude < {alt}\\\"\\n )\\n\\n if low_traj is None:\\n return\\n\\n for segment in low_traj.split(\\\"2T\\\"):\\n candidates_set = []\\n for name, polygon in runway_polygons.items():\\n if segment.intersects(polygon):\\n candidate = (\\n segment.cumulative_distance()\\n .clip_iterate(polygon)\\n .max(key=\\\"compute_gs_max\\\")\\n )\\n if candidate is None or candidate.shape is None:\\n continue\\n start_runway = candidate.aligned_on_runway(airport).max()\\n\\n if start_runway is not None:\\n candidate = candidate.after(start_runway.start)\\n if candidate is None or candidate.shape is None:\\n continue\\n if candidate.max(\\\"compute_gs\\\") < 140:\\n continue\\n\\n candidates_set.append(candidate.assign(runway=name))\\n\\n result = max(\\n candidates_set, key=attrgetter(\\\"duration\\\"), default=None\\n )\\n if result is not None:\\n yield result\",\n \"def introns_from_bed(bed):\\n introns = set()\\n with open(bed) as bed_stream:\\n for line in bed_stream:\\n tokens = line.rstrip().split('\\\\t')\\n if len(tokens) < 12:\\n continue\\n chrom = tokens[0]\\n chrom_start = int(tokens[1])\\n chrom_end = int(tokens[2])\\n block_sizes = tokens[10].split(',')\\n block_starts = tokens[11].split(',')\\n # Handle trailing commas\\n try:\\n int(block_sizes[-1])\\n except ValueError:\\n block_sizes = block_sizes[:-1]\\n try:\\n int(block_starts[-1])\\n except ValueError:\\n block_starts = block_starts[:-1]\\n block_count = len(block_sizes)\\n if block_count < 2:\\n # No introns\\n continue\\n assert block_count == len(block_starts)\\n junctions = []\\n # First block characterizes junction on left side of intron\\n junctions.append(chrom_start + int(block_starts[0]) \\n + int(block_sizes[0]))\\n for i in xrange(1, block_count - 1):\\n # Any intervening blocks characterize two junctions\\n intron_start = chrom_start + int(block_starts[i])\\n junctions.append(intron_start)\\n junctions.append(intron_start + int(block_sizes[i]))\\n # Final block characterizes junction on right side of intron\\n junctions.append(chrom_start + int(block_starts[-1]))\\n for i in xrange(len(junctions)/2):\\n introns.add((chrom, junctions[2*i]+1, junctions[2*i+1]+1))\\n return introns\",\n \"def _getscanind(self):\\n \\n zamin = self.za.min()\\n first = np.where(self.za==zamin)[0]\\n self.scan = np.zeros(self.spec.shape[0])\\n if zamin < 0:\\n cs = first[np.where((first - np.roll(first, 1)) != 1)[0]]\\n ss = first[np.where((np.roll(first,-1) - first) != 1)[0]] + 1\\n ce = ss \\n se = np.roll((cs - 1) % self.za.size, -1) + 1\\n for k, val in enumerate(cs):\\n self.scan[val:se[k] + 1] = k\\n else:\\n moves = np.diff(self.za)\\n max_ind = np.where(moves==moves.max())[0]\\n turnover = self.za.size\\n diffs = np.diff(max_ind)\\n if np.unique(diffs).size > 1:\\n raise ValueError, 'Can\\\\'t deal with non-uniform cal data yet.'\\n if max_ind.size > 1:\\n turnover = diffs[0]\\n cs = ce = np.array([])\\n ss = np.arange(self.za.size)[::turnover]\\n se = np.roll((ss - 1) % self.za.size, -1)\\n for k, val in enumerate(ss):\\n self.scan[val:se[k] + 1] = k\\n \\n self.ind = {'cs': cs, 'ce': ce, 'ss': ss, 'se': se}\\n self.nscan = np.unique(self.scan).size\",\n \"def puzzle2(offsets):\\n return find_jumps_to_exit(offsets, lambda o: o + 1 if o < 3 else o - 1)\",\n \"def getAltitudeProfile(pass_length,terrain,uav_altitude,u,start_v,wind_angle):\\n altitude_profile = []\\n v = start_v\\n for k in range(0,round(pass_length)):\\n coord = convertCoords([[u,v]],wind_angle,'xy')\\n x = coord[0][0]\\n y = coord[0][1]\\n x_points = [int(x),int(x),int(x)+1,int(x)+1]\\n y_points = [int(y),int(y)+1,int(y)+1,int(y)]\\n z_points = [terrain[int(y)][int(x)],terrain[int(y)+1][int(x)],\\n terrain[int(y)+1][int(x)+1],terrain[int(y)][int(x)+1]]\\n\\n # For created terrain ONLY\\n z = griddata((x_points,y_points),z_points,(x,y)) # Interpolate \\n altitude = z + uav_altitude\\n\\n altitude_profile.append(altitude)\\n v +=1\\n return altitude_profile\",\n \"def optimize(start, stop, step):\\n #Go through every angle\\n rot_angle_list = np.arange(start, stop, step)\\n fitness_list = []\\n best_angles_list = []\\n for (i, rot_angle) in enumerate(rot_angle_list):\\n (fitness, best_angles) = self._angle_fitness(rot_angle, initial_R, ending_vec, starting_vec)\\n fitness_list.append(fitness)\\n best_angles_list.append(best_angles)\\n #Find the best result\\n best_index = np.argmin(fitness_list)\\n best_rot_angle = rot_angle_list[best_index]\\n best_angles = best_angles_list[best_index]\\n return (best_rot_angle, best_angles)\",\n \"def top_of_descent_index(self):\\n tod = self.altitudes.argmax()\\n # if the altitude profile is not just a climb\\n # and there is a cruising section\\n if (tod < len(self.altitudes) - 1) and \\\\\\n (self.altitudes[tod] == self.altitudes[tod + 1]):\\n tod += 1\\n\\n return tod\",\n \"def get_planet_next_transit(jd_start, jd_end, planet, ayanamsha_id=swe.SIDM_LAHIRI):\\n swe.set_sid_mode(ayanamsha_id)\\n\\n transits = []\\n MIN_JUMP = 15 # Random check for a transit every 15 days!\\n # Could be tweaked based on planet using a dict?\\n\\n curr_L_bracket = jd_start\\n curr_R_bracket = jd_start + MIN_JUMP\\n\\n while curr_R_bracket <= jd_end:\\n L_rashi = floor(get_planet_lon(curr_L_bracket, planet, offset=0,\\n ayanamsha_id=ayanamsha_id) / 30) + 1\\n R_rashi = floor(get_planet_lon(curr_R_bracket, planet, offset=0,\\n ayanamsha_id=ayanamsha_id) / 30) + 1\\n\\n if L_rashi == R_rashi:\\n curr_R_bracket += MIN_JUMP\\n continue\\n else:\\n # We have bracketed a transit!\\n if L_rashi < R_rashi:\\n target = R_rashi\\n else:\\n # retrograde transit\\n target = L_rashi\\n try:\\n jd_transit = brentq(get_planet_lon, curr_L_bracket, curr_R_bracket,\\n args=(planet, (-target + 1) * 30, ayanamsha_id))\\n transits += [(jd_transit, L_rashi, R_rashi)]\\n curr_R_bracket += MIN_JUMP\\n curr_L_bracket = jd_transit + MIN_JUMP\\n except ValueError:\\n sys.stderr.write('Unable to compute transit of planet;\\\\\\n possibly could not bracket correctly!\\\\n')\\n return (None, None, None)\\n\\n return transits\",\n \"def GetObstaclePos(self):\\n # read all points from laser scan\\n ranges = self.Lidar.ranges\\n # transfer to np.array\\n ranges = np.array(ranges)\\n # get all the outlier points to a very large value\\n ranges = np.where(ranges < self.Lidar.range_min, self.Lidar.range_max + 10, ranges)\\n ranges = np.where(ranges > self.Lidar.range_max, self.Lidar.range_max + 10, ranges)\\n if len(ranges) != 0:\\n # get all default angles\\n angles = self.Lidar.angle_max - self.Lidar.angle_increment * np.arange(len(ranges))\\n else:\\n # if nothing detected, set the default value to zero\\n ranges = None\\n angles = None\\n return ranges, angles\",\n \"def get_stopped_pts(gpx_track, speed_threshold=2.5):\\n\\n n = 0\\n stopped_bool = [False]*gpx_track.get_points_no() # pre-allocate\\n for segment in gpx_track.segments:\\n for ida, point in enumerate(segment.points):\\n stopped_bool[n] = segment.get_speed[ida] < speed_threshold\\n n = n + 1\\n\\n _, stopped_time = gpx_track.get_moving_data(speed_threshold)\\n\\n return stopped_bool, stopped_time\",\n \"def determine_middle_in_triangle(\\n segments: List[LineString],\\n snap_threshold: float,\\n snap_threshold_error_multiplier: float,\\n) -> List[LineString]:\\n candidates = []\\n for idx, linestring in enumerate(segments):\\n others = segments.copy()\\n others.pop(idx)\\n if (\\n sum(\\n linestring.distance(other)\\n < snap_threshold * snap_threshold_error_multiplier\\n for other in others\\n )\\n >= 2\\n ):\\n candidates.append(segments[idx])\\n return candidates\",\n \"def get_corner(self, time):\\n if self.start_time <= time <= self.end_time:\\n diff = time - self.start_time\\n return self.i[diff][0, 0], self.j[diff][0, 0]\\n else:\\n return -1, -1\",\n \"def get_electrode_positions(self):\\n return self.electrodes[:, 1:3]\",\n \"def _get_goes_sat_num(start, end):\\n goes_operational = {\\n 2: TimeRange('1980-01-04', '1983-05-01'),\\n 5: TimeRange('1983-05-02', '1984-08-01'),\\n 6: TimeRange('1983-06-01', '1994-08-19'),\\n 7: TimeRange('1994-01-01', '1996-08-14'),\\n 8: TimeRange('1996-03-21', '2003-06-19'),\\n 9: TimeRange('1997-01-01', '1998-09-09'),\\n 10: TimeRange('1998-07-10', '2009-12-02'),\\n 11: TimeRange('2006-06-20', '2008-02-16'),\\n 12: TimeRange('2002-12-13', '2007-05-09'),\\n 13: TimeRange('2006-08-01', '2006-08-01'),\\n 14: TimeRange('2009-12-02', '2010-11-05'),\\n 15: TimeRange('2010-09-01', Time.now()),\\n }\\n\\n sat_list = []\\n for sat_num in goes_operational:\\n if (goes_operational[sat_num].start <= start <= goes_operational[sat_num].end and\\n goes_operational[sat_num].start <= end <= goes_operational[sat_num].end):\\n # if true then the satellite with sat_num is available\\n sat_list.append(sat_num)\\n\\n if not sat_list:\\n # if no satellites were found then raise an exception\\n raise Exception('No operational GOES satellites within time range')\\n else:\\n return sat_list\",\n \"def interiors(self):\\n return self.substrates.interiors\",\n \"def _pair_indices(self):\\n indices_src = []\\n indices_dst = []\\n for i in range(self.walk_len):\\n for j in range(max(i - self.l, 0), i):\\n indices_src.append(i)\\n indices_dst.append(j)\\n for j in range(i + 1, min(i + self.r + 1, self.walk_len)):\\n indices_src.append(i)\\n indices_dst.append(j)\\n return indices_src, indices_dst\",\n \"def alt_loc_list(self):\\n al_list = []\\n for atm in self.iter_all_atoms():\\n if atm.alt_loc != \\\"\\\" and atm.alt_loc not in al_list:\\n al_list.append(atm.alt_loc)\\n return al_list\",\n \"def _cons_traj(self,lon,lat,period):\\n\\t\\tgroup = self['%g_sec'%( period )]\\n\\t\\tlonArr = group['lonArr'].value\\n\\t\\tlatArr = group['latArr'].value\\n\\t\\tageArr = group['age_Arr'].value\\n\\t\\tage_drv_lon = group['age_deriv_lon_Arr']\\n\\t\\tage_drv_lat = group['age_deriv_lat_Arr']\\n\\t\\tage_drv_msk = group['age_deriv_msk_Arr']\\n\\t\\ttomo_data_msk = group['tomo_data_msk'].value\\n\\t\\tmask_init = np.logical_or(tomo_data_msk, age_drv_msk)\\n\\t\\tmask = np.array(np.ones(lonArr.shape),dtype=bool)\\n\\t\\ti_s, j_s = self._find_nearest_grid(lon,lat,period) # find the 1st and 2nd index of the start point on grid\\n\\t\\tif mask_init[i_s,j_s]:\\n\\t\\t\\traise ValueError(\\\"The starting point is out bounds of the resulting map\\\")\\n\\t\\tmask[i_s,j_s] = False\\n\\t\\t# go along increasing age direction\\n\\t\\ti,j = _walk(age_drv_lon,age_drv_lat,i_s,j_s,1)\\n\\t\\twhile (0<i<lonArr.shape[0] and 0<j<lonArr.shape[1]):\\n\\t\\t\\tif mask_init[i,j]:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmask[i,j] = False\\n\\t\\t\\ti,j = _walk(age_drv_lon,age_drv_lat,i,j,1)\\n\\t\\t\\t\\n\\t\\t# go along descending age direction\\n\\t\\ti_2,j_2 = _walk(age_drv_lon,age_drv_lat,i_s,j_s,-1)\\n\\t\\tmask[i_2,j_2] = False\\n\\t\\twhile (0<i_2<lonArr.shape[0] and 0<j_2<lonArr.shape[1]):\\n\\t\\t\\tif mask_init[i_2,j_2]:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmask[i_2,j_2] = False\\n\\t\\t\\tage_b = ageArr[i_2,j_2]\\n\\t\\t\\ti_b,j_b = i_2,j_2\\n\\t\\t\\ti_2,j_2 = _walk(age_drv_lon,age_drv_lat,i_2,j_2,-1)\\n\\t\\t\\tif ageArr[i_2,j_2] > age_b: # find the youngest age\\n\\t\\t\\t\\ti_3,j_3 = i_b,j_b\\n\\t\\t\\t\\tbreak\\n\\t\\ttry:\\n\\t\\t\\ti_3\\n\\t\\texcept NameError:\\n\\t\\t\\treturn mask\\n\\t\\t\\n\\t\\t# go along increasing age from the found youngest age\\n\\t\\twhile (0<i_3<lonArr.shape[0] and 0<j_3<lonArr.shape[1]):\\n\\t\\t\\tif mask_init[i_3,j_3]:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmask[i_3,j_3] = False\\n\\t\\t\\ti_3,j_3 = _walk(age_drv_lon,age_drv_lat,i_3,j_3,1)\\n\\t\\treturn mask\",\n \"def find_gains_for_baseline(self, t, bl):\\n\\n ant1, ant2 = baselines_2_ants([bl])\\n\\n # Find indx of gains entries containing ``t`` with ant1 & ant2\\n indx1 = np.where((t <= self._data['stop']) & (t >= self._data['start'])\\n & (self._data['antenna'] == ant1))[0]\\n indx2 = np.where((t <= self._data['stop']) & (t >= self._data['start'])\\n & (self._data['antenna'] == ant2))[0]\\n\\n # Now each gains# has shape (#if, #pol)\\n gains1 = np.squeeze(self._data[indx1]['gains'])\\n gains2 = np.squeeze(self._data[indx2]['gains'])\\n\\n # ``gains12`` has shape (#stokes, #nif)\\n gains12 = np.asarray([gains1[:, 0] * np.conjugate(gains2[:, 0]),\\n gains1[:, 1] * np.conjugate(gains2[:, 1]),\\n gains1[:, 0] * np.conjugate(gains2[:, 1]),\\n gains1[:, 1] * np.conjugate(gains2[:, 0])])\\n\\n return gains12\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6280308","0.59270215","0.58374995","0.5785568","0.5549861","0.54942876","0.5423105","0.539191","0.5391667","0.5305186","0.5304457","0.5252072","0.5251932","0.5228445","0.5205544","0.51648146","0.5155315","0.51186764","0.5109229","0.5094685","0.5079075","0.50782794","0.5065722","0.5064653","0.5051183","0.5041579","0.5040786","0.50367564","0.5029109","0.50229716","0.5008939","0.5005103","0.50045544","0.49981844","0.49947017","0.49908325","0.49861282","0.49860215","0.49772704","0.49722117","0.4971271","0.4956284","0.49550396","0.4950958","0.4943743","0.49420452","0.4939333","0.4933216","0.49017107","0.4901509","0.48795763","0.4870948","0.48567086","0.4846844","0.4832101","0.48281106","0.48077494","0.48050737","0.48039067","0.48001873","0.47942957","0.4794036","0.47921646","0.47841126","0.47810602","0.47808146","0.47784793","0.47755706","0.4764138","0.47517332","0.4744976","0.4742125","0.47405845","0.47390234","0.47387132","0.47383046","0.4731564","0.47302583","0.47283322","0.47255614","0.47232175","0.4722963","0.47145516","0.4712822","0.4711489","0.4707088","0.47059628","0.47017232","0.46975648","0.469493","0.4694242","0.46818274","0.4673888","0.46729156","0.46728542","0.4663078","0.46614137","0.46518004","0.46479627","0.46470648"],"string":"[\n \"0.6280308\",\n \"0.59270215\",\n \"0.58374995\",\n \"0.5785568\",\n \"0.5549861\",\n \"0.54942876\",\n \"0.5423105\",\n \"0.539191\",\n \"0.5391667\",\n \"0.5305186\",\n \"0.5304457\",\n \"0.5252072\",\n \"0.5251932\",\n \"0.5228445\",\n \"0.5205544\",\n \"0.51648146\",\n \"0.5155315\",\n \"0.51186764\",\n \"0.5109229\",\n \"0.5094685\",\n \"0.5079075\",\n \"0.50782794\",\n \"0.5065722\",\n \"0.5064653\",\n \"0.5051183\",\n \"0.5041579\",\n \"0.5040786\",\n \"0.50367564\",\n \"0.5029109\",\n \"0.50229716\",\n \"0.5008939\",\n \"0.5005103\",\n \"0.50045544\",\n \"0.49981844\",\n \"0.49947017\",\n \"0.49908325\",\n \"0.49861282\",\n \"0.49860215\",\n \"0.49772704\",\n \"0.49722117\",\n \"0.4971271\",\n \"0.4956284\",\n \"0.49550396\",\n \"0.4950958\",\n \"0.4943743\",\n \"0.49420452\",\n \"0.4939333\",\n \"0.4933216\",\n \"0.49017107\",\n \"0.4901509\",\n \"0.48795763\",\n \"0.4870948\",\n \"0.48567086\",\n \"0.4846844\",\n \"0.4832101\",\n \"0.48281106\",\n \"0.48077494\",\n \"0.48050737\",\n \"0.48039067\",\n \"0.48001873\",\n \"0.47942957\",\n \"0.4794036\",\n \"0.47921646\",\n \"0.47841126\",\n \"0.47810602\",\n \"0.47808146\",\n \"0.47784793\",\n \"0.47755706\",\n \"0.4764138\",\n \"0.47517332\",\n \"0.4744976\",\n \"0.4742125\",\n \"0.47405845\",\n \"0.47390234\",\n \"0.47387132\",\n \"0.47383046\",\n \"0.4731564\",\n \"0.47302583\",\n \"0.47283322\",\n \"0.47255614\",\n \"0.47232175\",\n \"0.4722963\",\n \"0.47145516\",\n \"0.4712822\",\n \"0.4711489\",\n \"0.4707088\",\n \"0.47059628\",\n \"0.47017232\",\n \"0.46975648\",\n \"0.469493\",\n \"0.4694242\",\n \"0.46818274\",\n \"0.4673888\",\n \"0.46729156\",\n \"0.46728542\",\n \"0.4663078\",\n \"0.46614137\",\n \"0.46518004\",\n \"0.46479627\",\n \"0.46470648\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59695065"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":91979,"cells":{"query":{"kind":"string","value":"Create a numpy boolean array with all positions inbetween the starts and finishes of cruising sections marked as True."},"document":{"kind":"string","value":"def find_cruise_positions(num_altitudes, cruise_indicies):\n cruise_positions = np.zeros(num_altitudes, dtype=bool)\n\n if cruise_indicies:\n for index in range(0, len(cruise_indicies), 2):\n start = cruise_indicies[index] + 1\n stop = cruise_indicies[index + 1]\n if start < stop:\n cruise_positions[start: stop] = True\n\n return cruise_positions"},"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 enumerate_bool(bool_array, nstart=0):\n ind = bool_2_indices(bool_array)\n ns = np.full(bool_array.size, nstart, dtype=int)\n for n, lims in enumerate(ind):\n ns[lims[0]:lims[-1]] = nstart + n + 1\n return ns","def masktoregions(in_mask):\n regions = []\n for i in [0,1]: # do the thing for the first and second strands\n current_strand = in_mask[i].copy().astype(float)\n current_strand[-1] = np.nan # set final position to np.nan to avoid overlap issues\n transitions = current_strand - np.roll(current_strand,1)\n true_start = np.where(transitions == 1)[0]\n true_end = np.where(transitions == -1)[0] - 1\n if current_strand[0] == 1: # if starts on True, add True start to front end\n true_start = np.r_[0,true_start]\n if in_mask[i][-1] == True: # if ends on True, add True end to back end\n true_end = np.r_[true_end, len(current_strand)-1]\n if in_mask[i][-2] == False: # if the one before is False, it's a single point True\n true_start = np.r_[true_start,len(current_strand)-1]\n if np.all(in_mask[i][-2:] == [True, False]):\n true_end = np.r_[true_end, len(current_strand)-2]\n regions.append(np.asarray([np.zeros(len(true_start))+i,true_start,true_end]).T)\n out_regions = np.concatenate(regions,axis=0).astype(int)\n return out_regions","def regionstomask(in_regions, genome_len):\n out_mask = np.zeros((2,genome_len)).astype(bool)\n for region in in_regions:\n out_mask[region[0],region[1]:region[2]+1] = True\n return out_mask","def get_mask(total, begin, end):\n mask = np.zeros([total]).astype(np.float32)\n mask[begin:end] = 1\n return np.array(mask, dtype=np.bool)","def contiguous_regions(condition):\n\n # Find the indicies of changes in \"condition\"\n d = np.diff(condition)\n idx, = d.nonzero()\n\n # We need to start things after the change in \"condition\". Therefore,\n # we'll shift the index by 1 to the right.\n idx += 1\n\n if condition[0]:\n # If the start of condition is True prepend a 0\n idx = np.r_[0, idx]\n\n if condition[-1]:\n # If the end of condition is True, append the length of the array\n idx = np.r_[idx, condition.size] # Edit\n\n # Reshape the result into two columns\n idx.shape = (-1,2)\n return idx","def contiguous_regions(condition):\n\n # Find the indicies of changes in \"condition\"\n d = np.diff(condition)\n idx, = d.nonzero() \n\n # We need to start things after the change in \"condition\". Therefore, \n # we'll shift the index by 1 to the right.\n idx += 1\n\n if condition[0]:\n idx_copy = np.zeros((idx.shape[0] + 1), dtype = np.int64)\n idx_copy[1:] = idx\n idx = idx_copy\n # If the start of condition is True prepend a 0\n ## idx = np.r_[0, idx]\n if condition[-1]:\n idx_copy = np.zeros((idx.shape[0] + 1), dtype = np.int64)\n idx_copy[:-1] = idx\n idx_copy[-1] = condition.size\n idx = idx_copy\n\n # Reshape the result into two columns\n idx= np.reshape(idx,(-1,2))\n return idx","def contiguousInds(args):\n condition = (np.array(args) > 0.0)\n\n # Find the indicies of changes in ``condition``\n dd = np.diff(condition)\n idx, = dd.nonzero()\n\n # Start things after change in ``condition``, thus shift indices 1 rightward\n idx += 1\n\n # If the start is True prepend a 0\n if condition[0]: idx = np.r_[0, idx]\n\n # If the end is True, append the length of the array\n if condition[-1]: idx = np.r_[idx, condition.size]\n\n # Reshape the result into two columns\n idx.shape = (-1, 2)\n\n # Find lengths of each contiguous segment\n sizes = np.diff(idx, axis=1)\n # Find the location of maximum segment length\n maxPos = np.argmax(sizes)\n # Make indices spanning longest segment\n inds = np.arange(*idx[maxPos])\n\n return inds","def is_contiguous(arr):\n mn, mx = min(arr), max(arr)\n s = sum(arr)\n sn = (mn*(mn-1))/2 if mn!=0 else 0\n sx = (mx*(mx+1))/2\n if s == sx-sn:\n return True\n else:\n return False","def as_boolean_mask(self):\n bbox = self.bbox()\n zs = np.unique([c.image_z_position for c in self.contours])\n z_to_index = dict(zip(zs,range(len(zs))))\n\n # Get dimensions, initialize mask.\n nx,ny = np.diff(bbox[:2], axis=1).astype(int) + 1\n nx = int(nx); ny = int(ny)\n nz = int(zs.shape[0])\n mask = np.zeros((nx,ny,nz), dtype=np.bool)\n\n # We check if these points are enclosed within each contour \n # for a given slice. `test_points` is a list of image coordinate \n # points, offset by the bounding box.\n test_points = bbox[:2,0] + np.c_[ np.where(~mask[:,:,0]) ]\n\n # First we \"turn on\" pixels enclosed by inclusion contours.\n for contour in self.contours:\n if contour.inclusion:\n zi = z_to_index[contour.image_z_position]\n contour_matrix = contour.to_matrix()[:,:2]\n\n # Turn the contour closed if it's not.\n if (contour_matrix[0] != contour_matrix[-1]).all():\n contour_matrix = np.append(contour_matrix,\n contour_matrix[0].reshape(1,2),\n axis=0)\n\n # Create path object and test all pixels\n # within the contour's bounding box.\n path = mplpath.Path(contour_matrix, closed=True)\n contains_pts = path.contains_points(test_points)\n mask[:,:,zi] = contains_pts.reshape(mask.shape[:2])\n\n # Second, we \"turn off\" pixels enclosed by exclusion contours.\n for contour in self.contours:\n if not contour.inclusion:\n zi = z_to_index[contour.image_z_position]\n contour_matrix = contour.to_matrix()[:,:2]\n\n # Turn the contour closed if it's not.\n if (contour_matrix[0] != contour_matrix[-1]).all():\n contour_matrix = np.append(contour_matrix,\n contour_matrix[0].reshape(1,2),\n axis=0)\n\n path = mplpath.Path(contour_matrix, closed=True)\n not_contains_pts = ~path.contains_points(test_points)\n not_contains_pts = not_contains_pts.reshape(mask.shape[:2])\n mask[:,:,zi] = np.logical_and(mask[:,:,zi], not_contains_pts)\n\n # The first and second axes have to \n # be swapped because of the reshape.\n return mask.swapaxes(0,1), bbox[[1,0,2]]","def test08(self):\n a = np.arange(10000) > 5000\n b = bcolz.carray(a, chunklen=100)\n u = b.wheretrue(skip=1020, limit=1020)\n w = b.wheretrue(skip=1030, limit=1030)\n self.assertEqual(a.nonzero()[0].tolist()[1020:2040], list(u))\n self.assertEqual(a.nonzero()[0].tolist()[1030:2060], list(w))","def _is_contiguous(positions):\n previous = positions[0]\n for current in positions[1:]:\n if current != previous + 1:\n return False\n previous = current\n return True","def subArray(self,left,rightplus):\n lst=self.boolVals[:]\n \n sm=\"\"\n for i in range(len(lst)):\n if lst[i]:\n sm+=\"1\"\n else:\n sm+=\"0\"\n newlst=sm[left:rightplus]\n newlst=newlst[::-1]\n final=hex(int(newlst,2))\n final=final[2:]\n\n return BoolArray(final,rightplus-left)","def transform_preds_to_boolean(img_size, preds):\n out = np.zeros(img_size, dtype=bool)\n\n adder = np.array([0., 1., 0., 1.])\n\n for i in preds:\n bbox = (i[0:4] + adder).astype(int)\n out[bbox[1]:bbox[3], bbox[0]:bbox[2]] = True\n\n return out","def test07(self):\n a = np.arange(10000) > 5000\n b = bcolz.carray(a, chunklen=100)\n wt = a.nonzero()[0].tolist()[1020:2040]\n cwt = [i for i in b.wheretrue(skip=1020, limit=1020)]\n # print \"numpy ->\", a.nonzero()[0].tolist()[1020:2040]\n # print \"where ->\", [i for i in b.wheretrue(limit=1020,skip=1020)]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def test09(self):\n a = np.arange(10000) > 5000\n b = bcolz.carray(a, chunklen=100)\n b1 = b.wheretrue(skip=1020, limit=1020)\n b2 = b.wheretrue(skip=1030, limit=1020)\n a1 = a.nonzero()[0].tolist()[1020:2040]\n a2 = a.nonzero()[0].tolist()[1030:2050]\n # print \"result:\", [i for i in zip(b1, b2)]\n self.assertEqual([i for i in zip(a1, a2)], [i for i in zip(b1, b2)])","def bool_2_indices(bool_array):\n if ~isinstance(bool_array, np.ndarray):\n bool_array = np.array(bool_array)\n if bool_array[-1]:\n bool_array[-1] = False\n lims = np.arange(bool_array.size)[bool_array ^ np.roll(bool_array, 1)]\n if len(lims) > 0:\n if lims[-1] == bool_array.size - 1:\n lims[-1] = bool_array.size\n return np.reshape(lims, (len(lims) // 2, 2))\n else:\n return [[np.nan, np.nan]]","def _get_support_mask(self):\n mask = np.zeros(self.scores_.shape, dtype=bool)\n mask[self.scores_ >= self.min_count] = True\n return mask","def test06(self):\n a = np.arange(1, 11) > 5\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()[2:4]\n cwt = [i for i in b.wheretrue(skip=2, limit=2)]\n # print \"numpy ->\", a.nonzero()[0].tolist()[2:4]\n # print \"where ->\", [i for i in b.wheretrue(limit=2,skip=2)]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def consecutive_sections(): # noqa: D416","def test04(self):\n a = np.arange(1, 11) > 5\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()[:3]\n cwt = [i for i in b.wheretrue(limit=3)]\n # print \"numpy ->\", a.nonzero()[0].tolist()[:3]\n # print \"where ->\", [i for i in b.wheretrue(limit=3)]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def test05(self):\n a = np.arange(1, 11) > 5\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()[2:]\n cwt = [i for i in b.wheretrue(skip=2)]\n # print \"numpy ->\", a.nonzero()[0].tolist()[2:]\n # print \"where ->\", [i for i in b.wheretrue(skip=2)]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def segment_array_by_locs(shape, locs):\n mask_out = np.zeros(np.prod(shape), dtype=int)\n for i in range(len(locs) - 1):\n l = [locs[i],\n locs[i + 1]]\n mask_out[l[0]:l[1]] = i + 1\n return mask_out.reshape(shape)","def test01(self):\n a = np.arange(1, 11) < 0\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()\n cwt = [i for i in b.wheretrue()]\n # print \"numpy ->\", a.nonzero()[0].tolist()\n # print \"where ->\", [i for i in b.wheretrue()]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def trajectory_splitter(trajectory, split_start, split_length):\r\n mask_array = np.zeros(np.shape(trajectory), dtype=bool)\r\n # print(np.shape(mask_array))\r\n mask_array[:, split_start:split_start+split_length] = 1\r\n # print(np.ma.masked_array(trajectory, mask=mask_array))\r\n return trajectory[:, :split_start],trajectory[:, split_start+split_length:], np.ma.masked_array(trajectory, mask=mask_array)","def find_exceedences(temp, clim):\n exceed_bool = temp - clim[\"thresh\"]\n exceed_bool[exceed_bool <= 0] = False\n exceed_bool[exceed_bool > 0] = True\n\n # Find contiguous regions of exceed_bool = True\n events, n_events = ndimage.label(exceed_bool)\n return events, n_events","def continuity_test(districts):\r\n for tag in range(1,6):\r\n if tag in districts:\r\n X = np.where((districts==tag)|(districts==0))\r\n contig = set([(X[0][0],X[1][0])])\r\n prev_len = 0\r\n while len(contig) > prev_len and prev_len<5:\r\n prev_len = len(contig)\r\n for r,c in contig.copy():\r\n if r>0 and districts[r-1,c] in [tag,0]:\r\n contig.add((r-1,c))\r\n if r<4 and districts[r+1,c] in [tag,0]:\r\n contig.add((r+1,c))\r\n if c>0 and districts[r,c-1] in [tag,0]:\r\n contig.add((r,c-1))\r\n if c<4 and districts[r,c+1] in [tag,0]:\r\n contig.add((r,c+1))\r\n if prev_len < 5:\r\n return False\r\n return True","def test02(self):\n a = np.arange(1, 1e5) < 0\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()\n cwt = [i for i in b.wheretrue()]\n # print \"numpy ->\", a.nonzero()[0].tolist()\n # print \"where ->\", [i for i in b.wheretrue()]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def segment_data(x):\n return (x.shift(1) != x).astype(int).cumsum()","def test00(self):\n a = np.arange(1, 11) > 0\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()\n cwt = [i for i in b.wheretrue()]\n # print \"numpy ->\", a.nonzero()[0].tolist()\n # print \"where ->\", [i for i in b.wheretrue()]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def data_category_inside_boundary(self: Union[pd.DataFrame, pd.Series],\n boundary: dict, *,\n inclusive: bool = True) -> ndarray:\n pass\n boolean_array = np.full(self.__getattribute__('shape')[0], fill_value=True)\n for this_dim, this_dim_limit in boundary.items():\n boolean_array = np.bitwise_and(boolean_array,\n self[this_dim].between(*this_dim_limit, inclusive=inclusive).values)\n return boolean_array","def test03(self):\n a = np.arange(1, 11) > 5\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()\n cwt = [i for i in b.wheretrue()]\n # print \"numpy ->\", a.nonzero()[0].tolist()\n # print \"where ->\", [i for i in b.wheretrue()]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def trimtimes(time, elmbeg, elmend, preft = 0.0, suft = 0.0):\n valididx = np.zeros(len(time),dtype='bool')\n \n elmbeg = elmbeg - preft\n elmend = elmend + suft\n for i in range(len(time)):\n t = time[i]\n boolbeg = t>=elmbeg\n boolend = t<=elmend\n boolelm = boolbeg & boolend\n valididx[i] = np.sum(boolelm)\n \n #To use only data outside of ELMs\n valididx = np.invert(valididx)\n return time[valididx], valididx","def isect_flags(arr, other):\n flags = iter_reduce_ufunc(np.logical_or, (arr == item for item in other))\n if flags is None:\n flags = np.zeros(arr.shape, dtype=bool)\n return flags","def get_bools_array(self, bools, limit):\n bit_array = bytearray()\n bits_array_length = (limit) // 8\n\n for x in range(bits_array_length):\n bit_array.append(0)\n\n\n for x in range(limit): \n # set the bits\n if bools[x]['value'] == True:\n index = x//8\n bit = x % 8 \n bit_array[index] |= 1 << bit \n\n return bit_array","def region_growing(im: np.ndarray, seed_points: list, T: int) -> np.ndarray:\n ### START YOUR CODE HERE ### (You can change anything inside this block)\n # You can also define other helper functions\n segmented = np.zeros_like(im).astype(bool)\n\n (H, W) = im.shape\n\n for seed_row, seed_col in seed_points:\n region = []\n region.append([seed_row, seed_col])\n for row, col in region:\n for rows in range((row-1),(row+2)): # Check neighbouring pixels\n for cols in range((col-1),(col+2)):\n if rows < H and rows >= 0 and cols < W and cols >= 0: # Is pixel inside image?\n if (np.abs(im[seed_row, seed_col] - im[rows, cols]) <= T) and not segmented[row, col]:\n region.append([rows, cols])\n segmented[row, col] = True\n return segmented\n ### END YOUR CODE HERE ### ","def life(arr):\n\tres_arr = arr\n\tmax_x = len(arr[0]) - 1\n\tmax_y = len(arr) - 1\n\n\tfor y, y_value in enumerate(arr):\n\t\tfor x, x_value in enumerate(y_value):\n\t\t\tneighb_count = get_count_life_neighbor(arr, x, y, max_x, max_y)\n\t\t\tif x_value:\n\t\t\t\tif neighb_count < 2 or neighb_count > 3:\n\t\t\t\t\tres_arr[y][x] = False\n\t\t\telse:\n\t\t\t\tif neighb_count == 3:\n\t\t\t\t\tres_arr[y][x] = True\n\treturn res_arr","def is_crossed(self):\n left_boundary_clusters = np.extract(self.cluster[0] > 0,\n self.cluster[0])\n right_boundary_clusters = np.extract(self.cluster[-1] > 0,\n self.cluster[-1])\n return np.in1d(left_boundary_clusters, right_boundary_clusters).any()","def locate_interesting_segment(binary_matrix, indeces, beats, during_threshold = 5):\n point = np.zeros([1, 4], dtype = int)\n segments = np.empty([0, 4], dtype = int)\n is_segment_bedin = False\n for index in indeces:\n temp = np.diag(binary_matrix, -index)\n for j in range(len(temp)):\n if (temp[j] == 0 and is_segment_bedin == False) or (temp[j] == 1 and is_segment_bedin == True):\n continue\n else:\n if temp[j] == 1:\n point[0, 0] = index + j\n point[0, 1] = j\n is_segment_bedin = True\n else:\n point[0, 2] = index + j\n point[0, 3] = j\n is_segment_bedin = False\n segments = np.append(segments, point, axis = 0)\n\n # using the time during whose default value is 4s to filter segment\n del_indeces = np.array([], dtype = int)\n new_binary_matrix = binary_matrix.copy()\n for i in range(len(segments)):\n\n time_begin = beats[segments[i, 0]]\n time_end = beats[segments[i, 2]]\n if time_end - time_begin < during_threshold:\n del_indeces = np.append(del_indeces, i)\n\n # set the binary matrix\n for row in range(segments[i, 0], segments[i, 2]):\n row_begin = segments[i, 0]\n col_begin = segments[i, 1]\n new_binary_matrix[row, row - row_begin + col_begin] = 0\n\n segments = np.delete(segments, del_indeces, axis=0)\n\n length = len(segments)\n # the matrix which denote if segment is close with each other\n segments_close_matrix = np.zeros([length, length], dtype = int)\n for i in range(length):\n for j in range(length):\n if i == j:\n continue\n x1 = segments[i, :]\n x2 = segments[j, :]\n\n # determine if segment is close with each other\n if x2[0] >= x1[0] - 5 and x2[2] <= x1[2] + 20 and abs(x2[1] - x1[1]) <= 20 and x2[3] <= x1[3] + 5:\n segments_close_matrix[i, j] = 1\n\n # delete some segments with less than 3 closed segment\n del_indeces = np.array([], dtype=int)\n close_count = np.sum(segments_close_matrix, axis = 0)\n for i in range(len(segments)):\n if close_count[i] < 3:\n del_indeces = np.append(del_indeces, i)\n\n # set the binary matrix\n for row in range(segments[i, 0], segments[i, 2]):\n row_begin = segments[i, 0]\n col_begin = segments[i, 1]\n new_binary_matrix[row, row - row_begin + col_begin] = 0\n\n segments = np.delete(segments, del_indeces, axis = 0)\n # plt.matshow(new_binary_matrix, cmap=plt.cm.gray)\n # plt.show()\n\n return segments, new_binary_matrix","def test10(self):\n a = np.arange(10000) > 5000\n b = bcolz.carray(a, chunklen=100)\n bi = b.wheretrue(skip=1020, limit=1020)\n ai = iter(np.array(a.nonzero()[0].tolist()[1020:2040]))\n self.assertEqual([i for i in ai], [i for i in bi])\n self.assertEqual([i for i in ai], [i for i in bi])","def create_region_mask(latitude_array, target_shape, lat_bounds):\n\n target_ndim = len(target_shape)\n\n southern_lat, northern_lat = lat_bounds\n mask_array = numpy.where((latitude_array >= southern_lat) & (latitude_array < northern_lat), False, True)\n\n mask = uconv.broadcast_array(mask_array, [target_ndim - 2, target_ndim - 1], target_shape)\n assert mask.shape == target_shape \n\n return mask","def tnuc_region_in_intron(np, beg, end):\n\n if beg.tpos == 0 or end.tpos == 0: return False\n if beg.pos == end.pos and beg.tpos*end.tpos > 0:\n return True\n if beg.pos+1 == end.pos and beg.tpos>0 and end.tpos<0:\n return True\n if end.pos+1 == beg.pos and beg.tpos<0 and end.tpos>0:\n return True\n\n return False","def nondetects(self, masked=False):\r\n grd = self.grd\r\n xnd = []\r\n ynd = []\r\n ncells = len(grd.cells['depth'])\r\n non_detects_i_tr = np.zeros(ncells, np.int32)\r\n if masked:\r\n not_flagged = np.where(self.rec_track.flagged==0)[0]\r\n rec_track = self.rec_track[not_flagged]\r\n rec_seg = self.make_segments(set_depth=True, \r\n input_rec_track=rec_track)\r\n else:\r\n rec_seg = self.rec_seg\r\n for nr, rseg in enumerate(rec_seg):\r\n seg = rec_seg[nr]\r\n dt = seg.dt\r\n if dt > dt_signal+1:\r\n t1 = seg.t1\r\n t2 = seg.t2\r\n nint = int(np.rint((t2-t1)/dt_signal)) - 1\r\n x1 = seg.x1\r\n x2 = seg.x2\r\n y1 = seg.y1\r\n y2 = seg.y2\r\n dx_nd = (x2 - x1)/float(nint+1)\r\n dy_nd = (y2 - y1)/float(nint+1)\r\n if nint < 120: # 10 minute cutoff for nondetect filling\r\n xint = [x1 + n*dx_nd for n in range(1,nint)]\r\n yint = [y1 + n*dy_nd for n in range(1,nint)]\r\n xnd = xnd + xint\r\n ynd = ynd + yint\r\n\r\n for nd in range(len(xnd)):\r\n xy = [xnd[nd], ynd[nd]]\r\n i = grd.select_cells_nearest(xy)\r\n if (i is not None) and (i >= 0):\r\n non_detects_i_tr[i] += 1\r\n\r\n return non_detects_i_tr","def present_in_slice(self, start, stop):\n return self.starts_before(start) and self.ends_after(stop - 1)","def ranges(self, predicate):\n\n x = np.zeros(len(self)).astype(np.bool)\n for i, elem in enumerate(self.elements):\n x[i] = predicate(elem)\n\n return np.where(x)[0]","def indices_above(a, val, extend_window: int=0, extend_dir='+'):\n idx_ = indices_below(a, val, extend_window, extend_dir)\n idx = np.ones_like(a, dtype=np.bool)\n idx[idx_] = 0\n return idx","def test05(self):\n a = np.arange(1, 1e2)\n b = bcolz.carray(a, chunklen=10)\n sl = a < 5\n b[sl] = range(6, 10)\n a[sl] = range(6, 10)\n # print \"b[%s] -> %r\" % (sl, b)\n assert_array_equal(b[:], a, \"fancy indexing does not work correctly\")","def _get_minimal_lanes(self):\n return np.argwhere(self.end_of_lanes == np.min(self.end_of_lanes)).flatten()","def in_CS(res, coverage=0.9):\n o = torch.flip(res['alpha'].argsort(), [1]) # sorts each row\n n = (torch.cumsum(torch.gather(res['alpha'], 1, o), 1) < coverage).sum(1) + 1\n result = torch.zeros(res['alpha'].shape, dtype=torch.bool)\n for i in range(result.shape[0]):\n result[i, o[i][:n[i]]] = True\n return result","def trajectory_masker(trajectory, split_start, split_length):\r\n input_mask = np.zeros(np.shape(trajectory), dtype=bool)\r\n output_mask = np.zeros(np.shape(trajectory), dtype=bool)\r\n\r\n input_mask[:, split_start:] = 1\r\n output_mask[:, :split_start+split_length] = 1\r\n # print(np.ma.masked_array(trajectory, mask=mask_array))\r\n return np.ma.masked_array(trajectory, mask=input_mask), np.ma.masked_array(trajectory, mask=output_mask)","def region_borders(X_nm):\n N,M = X_nm.shape\n return (\n np.r_[X_nm[:-1,:] != X_nm[1:,:],np.zeros((1,M),bool)] |\n np.r_[np.zeros((1,M),bool),X_nm[1:,:] != X_nm[:-1,:]] | \n np.c_[X_nm[:,:-1] != X_nm[:,1:],np.zeros((N,1),bool)] |\n np.c_[np.zeros((N,1),bool),X_nm[:,1:] != X_nm[:,:-1]])","def flag(self, arr):\n return arr","def tnuc_region_in_exon(np, beg, end):\n\n if beg.tpos != 0: return False\n if end.tpos != 0: return False\n for i in range(beg.pos, end.pos-1):\n if abs(np[i] - np[i+1]) != 1:\n return False\n return True","def find_valid_fluid_start_positions(box_rasterized, fluid_rasterized):\n fluid_shape = np.array(fluid_rasterized[2].shape)\n box_shape = np.array(box_rasterized[2].shape)\n last_pos = box_shape - fluid_shape\n\n valid_fluid_start_positions_arr = np.zeros(box_shape)\n for idx in itertools.product(range(0, last_pos[0] + 1),\n range(0, last_pos[1] + 1),\n range(0, last_pos[2] + 1)):\n pos = np.array(idx, np.int32)\n pos2 = pos + fluid_shape\n view = box_rasterized[2][pos[0]:pos2[0], pos[1]:pos2[1], pos[2]:pos2[2]]\n if np.alltrue(\n np.logical_and(view, fluid_rasterized[2]) ==\n fluid_rasterized[2]):\n if idx[1] == 0:\n valid_fluid_start_positions_arr[idx[0], idx[1], idx[2]] = 1\n elif np.count_nonzero(valid_fluid_start_positions_arr[idx[0],\n 0:idx[1],\n idx[2]]) == 0:\n valid_fluid_start_positions_arr[idx[0], idx[1], idx[2]] = 1\n\n valid_pos = np.stack(np.nonzero(valid_fluid_start_positions_arr), axis=-1)\n selected_pos = valid_pos[np.random.randint(0, valid_pos.shape[0])]\n\n # update the rasterized bounding box volume by substracting the fluid volume\n pos = selected_pos\n pos2 = pos + fluid_shape\n view = box_rasterized[2][pos[0]:pos2[0], pos[1]:pos2[1], pos[2]:pos2[2]]\n box_rasterized[2][pos[0]:pos2[0], pos[1]:pos2[1],\n pos[2]:pos2[2]] = np.logical_and(\n np.logical_not(fluid_rasterized[2]), view)\n\n selected_pos += box_rasterized[0]\n selected_pos = selected_pos.astype(np.float) * box_rasterized[1]\n\n return selected_pos","def get_contiguous_inds(inds, min_contig_len=5, trim_left=0, trim_right=0, **kwargs):\r\n start_inds, stop_inds = get_inds_start_stop(inds, **kwargs)\r\n cont_inds = [np.arange(start+trim_left, stop-trim_right) for start, stop in zip(start_inds, stop_inds) if stop-start > min_contig_len]\r\n return cont_inds","def has_been_segmented(input, loc, clockwise):\n height = np.shape(input)[0]\n width = np.shape(input)[1]\n\n if clockwise:\n if loc[0] == 0 and loc[2] + 1 < width:\n if input[int(loc[1]), int(loc[2]) + 1] < 0:\n return True\n elif loc[0] == 1 and loc[2] - 1 >= 0:\n if input[int(loc[1]), int(loc[2]) - 1] < 0:\n return True\n elif loc[0] == 2 and loc[1] - 1 >= 0:\n if input[int(loc[1]) - 1, int(loc[2])] < 0:\n return True\n elif loc[1] + 1 < height:\n if input[int(loc[1]) + 1, int(loc[2])] < 0:\n return True\n else:\n if loc[0] == 0 and loc[2] - 1 >= 0:\n if input[int(loc[1]), int(loc[2]) - 1] < 0:\n return True\n elif loc[0] == 1 and loc[2] + 1 < width:\n if input[int(loc[1]), int(loc[2]) + 1] < 0:\n return True\n elif loc[0] == 2 and loc[1] + 1 < height:\n if input[int(loc[1]) + 1, int(loc[2])] < 0:\n return True\n elif loc[1] - 1 >= 0:\n if input[int(loc[1]) - 1, int(loc[2])] < 0:\n return True\n\n return False","def move_zeros(array):\n zero_count = [x for x in array if x is not False].count(0)\n output = [str(x) if type(x) == bool else x for x in array]\n for i in range(zero_count):\n output.remove(0)\n output.append(0)\n output = [False if x == 'False' else True if x == 'True' else x for x in output]\n return output","def __generate_mask(self):\n mask = np.concatenate([np.ones(len(self.fixed[0])),\n np.zeros(self.num_points),\n np.ones(len(self.fixed[1]))])\n return mask","def get_future_mask(self, batch_size, sequence_length):\n\n xind = tf.tile(tf.range(sequence_length)[None, :], (sequence_length, 1))\n yind = tf.tile(tf.range(sequence_length)[:, None], (1, sequence_length))\n mask = yind >= xind\n mask = tf.tile(mask[None], (batch_size, 1, 1))\n\n return mask","def inside(i,j,im,h=H): #X\n return i-h >=0 and j-h >=0 and i+h+1<=im.shape[0] and j+h+1<=im.shape[1]","def cmask(self):\n mask = np.zeros(18)\n if 'full' in self.CONS: mask[:] = 1\n if 'f0' in self.CONS: mask[0] = 1\n if 'f1' in self.CONS: mask[1:4] = 1\n if 'f2' in self.CONS: mask[4:10] = 1\n if 'vx' in self.CONS: mask[10] = 1\n if 'vy' in self.CONS: mask[11] = 1\n if 'vz' in self.CONS: mask[12] = 1\n if 'TG' in self.CONS: mask[13:18] = 1\n return mask>0","def _boolean_region(all_polygons_A, all_polygons_B,\n bboxes_A, bboxes_B,\n left, bottom, right, top,\n operation = 'and',\n precision = 1e-4):\n\n polygons_to_boolean_A = _crop_edge_polygons(all_polygons_A, bboxes_A,\n left, bottom, right, top,\n precision)\n polygons_to_boolean_B = _crop_edge_polygons(all_polygons_B, bboxes_B,\n left, bottom, right, top,\n precision)\n polygons_boolean = clipper.clip(polygons_to_boolean_A,\n polygons_to_boolean_B,\n operation, 1/precision)\n return polygons_boolean","def as_mask(annotations: Sequence[Annotation],\n size: int,\n fs: float,\n include: bool = True,\n) -> npt.NDArray[np.bool_]:\n\n epochs = [(ann.time, ann.time + ann.duration) for ann in annotations]\n samples = np.round(np.array(epochs) * fs).astype(int)\n slices = [slice(*pts) for pts in samples]\n result = arraytools.filter1D(size, slices)\n result = result if include else ~result\n return cast(np.ndarray, result)","def Check(self):\n cleared = False\n while not cleared:\n for i in list(combinations([cell.Check() for cell in self.cells], 2)):\n # for i in list(combinations(zip(self.locations.x,self.locations.y,self.locations.length,self.locations.index),2)):\n x1 = i[0][0]\n y1 = i[0][1]\n r1 = i[0][2] / 2\n idx1 = i[0][3]\n x2 = i[1][0]\n y2 = i[1][1]\n r2 = i[1][2] / 2\n idx1 = i[0][3]\n idx2 = i[1][3]\n distance = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)\n radii = (r1 + r2) * (r1 + r2)\n if distance == radii:\n cleared = True\n elif distance > radii:\n cleared = True\n else:\n if x1 > x2 and y1 > y2:\n if (\n x1 + r1 > 0\n and x1 + r1 < self.boundaries[0]\n and y1 + r1 > 0\n and y1 + r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 + r1 / 2\n self.cells[idx1].y = y1 + r1 / 2\n elif x1 > x2 and y1 < y2:\n if (\n x1 + r1 > 0\n and x1 + r1 < self.boundaries[0]\n and y1 - r1 > 0\n and y1 - r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 + r1 / 2\n self.cells[idx1].y = y1 - r1 / 2\n elif x1 < x2 and y1 > y2:\n if (\n x1 - r1 > 0\n and x1 - r1 < self.boundaries[0]\n and y1 + r1 > 0\n and y1 + r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 - r1 / 2\n self.cells[idx1].y = y1 + r1 / 2\n else:\n if (\n x1 - r1 > 0\n and x1 - r1 < self.boundaries[0]\n and y1 - r1 > 0\n and y1 - r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 - r1 / 2\n self.cells[idx1].y = y1 - r1 / 2\n _logger.debug(\n f\"Bumped from {x1 :.2e}, {y1 :.2e} to {self.cells[idx1].x :.2e}, {self.cells[idx1].y :.2e}\"\n )\n cleared = False\n return","def contains ( self, pos ):\n # initialize with only \"False\" entries\n inds = zeros(pos.shape[1], dtype=bool)\n \n # add points contained in each sector\n for sec in self.sectors:\n inds += sec.contains(pos)\n \n return inds.astype(bool)","def all(self, *args, **kwargs):\n if self.fragmented:\n return (\n np.all(self[self._begin:].view(ndarray), *args, **kwargs) and\n np.all(self[:self._end].view(ndarray), *args, **kwargs)\n )\n else:\n if self._begin < self._end:\n part = self[self._begin:self._end]\n elif self._end == 0:\n part = self[self._begin:]\n\n return (np.all(part.view(ndarray), *args, **kwargs))","def get_overlap_mask(times: np.ndarray, intervals: Table):\n mask = np.zeros(len(times), dtype=\"bool\")\n for interval in intervals:\n exclude = (times >= CxoTime(interval[\"start\"]).secs) & (\n times < CxoTime(interval[\"stop\"]).secs\n )\n mask[exclude] = True\n return mask","def all_bees_lowered_flag(self):\n pos, com, success = self.perception\n return all(map(lambda x: x[1][\"flag\"] == 0, com))","def find_all_minima(arr):\n\n checks = np.r_[True, arr[1:] < arr[:-1]] & np.r_[arr[:-1] < arr[1:], True]\n minima = np.where(checks)[0]\n return minima","def getBooleanArray2D(self) -> typing.List[typing.List[bool]]:\n ...","def startEndPoints(mazz):\n for i in range (len(mazz)):\n for j in range (len(mazz[i])):\n if mazz[i][j] == 6:\n startx = i\n starty = j\n elif mazz[i][j] == 7:\n endx = i\n endy = j\n return startx, starty, endx, endy","def _fix_uniq_col(self):\n # subgradient; for two boolean arrays, multiplication seems to be the best way \n # (equivalent to logical_and)\n n_covered_col = self.a_csr.dot(np.ones(self.ncols)) \n ifix = np.zeros(self.ncols, dtype=bool)\n if (np.count_nonzero(n_covered_col) != self.mrows):\n raise ValueError(\"There are uncovered rows! Please check your input!\")\n if (np.any(n_covered_col==1)):\n inonzero = self.a_csr[n_covered_col==1,:].nonzero()\n ifix[inonzero[1]] = True\n\n return ifix","def continuous(self, x, y, X, Y):\n hor = fabs(x - X) == SSIZE and y == Y\n ver = fabs(y - Y) == SSIZE and x == X\n return (hor and not ver) or (ver and not hor)","def starting_values(self, resids: NDArray) -> NDArray:","def block_array(a, rows=3, cols=4, col_first=True, nodata=-1):\n s = np.array(a.shape)\n w = np.array([rows, cols])\n m = divmod(s, w)\n new_shape = w*m[0] + w*(m[1]!=0)\n ypad, xpad = new_shape - a.shape \n b = np.pad(a, pad_width=((0, ypad),(0, xpad)), \n mode='constant', \n constant_values=((nodata, nodata),(nodata, nodata)))\n rn, cn = new_shape\n x_s = np.arange(0, cn+cols, cols)[1:] #.tolist()\n y_s = np.arange(0, rn+rows, rows)[1:] #.tolist()\n print(\"x_s {}\\ny_s {}\".format(x_s, y_s))\n #c = np.array([i for i in np.hsplit(b, x_s) if len(i) > 0])\n c = np.array([i for i in np.split(b, x_s, axis=1) if len(i) > 0])\n d = np.array([i for i in np.split(c, y_s, axis=1) if len(i) > 0])\n e = d.swapaxes(0, 1)\n ix = np.in1d(e.ravel(), nodata).reshape(e.shape)\n f = np.ma.array(e, mask=ix, fill_value=-1)\n return b, c, d, e, f","def get_adjacent_idxs(sample, array):\n state = sample >= array # boolean array\n # Find the index where the last \"True\"\n # This is the idx lower than the sample\n idx_lower = np.where(state)[0][-1]\n\n # Find the index where the last \"False\"\n # This is the first idx lower than the sample\n idx_higher = np.where(np.logical_not(state))[0][0]\n\n return idx_lower, idx_higher","def negative_markers1(markers,positive):\n global cpt\n negative = np.array([])\n lm = len(markers)\n lp = len(positive)\n found = False\n for i in range(lm):\n for j in range(lp):\n cpt = cpt + 1\n if markers[i].cmp(positive[j]) == 0:\n found = True\n break\n if not found:\n negative = np.append(negative, markers[i])\n found = False\n return negative","def cleaned(self, start_threshold=0.01, end_threshold=0.25, shifted=True):\n start_i, end_i = None, None\n\n max_i = np.nanargmax(self.ys)\n max_y = self.ys[max_i]\n\n if start_threshold is not None:\n # includes the value before threshold is met\n for i, y in enumerate(self.ys[1:]):\n if y > max_y*start_threshold:\n start_i = i\n break\n\n if end_threshold is not None:\n for i, y in enumerate(self.ys[max_i:], start=max_i):\n if y < max_y*end_threshold:\n end_i = i\n break\n\n return self.cropped_index(start_i, end_i, shifted)","def get_Xc_starts(self):\r\n start_list = [np.random.randint(low=0, high=self.total_windows-self.buffer_needed) for _ in range(self.total_points)]\r\n return np.array(start_list)","def set_scan_sequential(starts, stops, steps):\n\n all_positions = [starts[:]]\n positions = starts[:]\n state = pos_above_stops(positions, steps, stops)\n while not state[0]:\n if not np.any(np.array(state)):\n positions[-1] += steps[-1]\n\n else:\n indexes_true = np.where(np.array(state))\n positions[indexes_true[-1][0]] = starts[indexes_true[-1][0]]\n positions[indexes_true[-1][0] - 1] += steps[indexes_true[-1][0] - 1]\n\n state = pos_above_stops(positions, steps, stops)\n if not np.any(np.array(state)):\n all_positions.append(positions[:])\n\n return np.array(all_positions)","def indicator_boundaries(bounds, d):\n\n bounds = np.array(bounds)\n check = bounds.T - d\n low = all(i <= 0 for i in check[0])\n high = all(i >= 0 for i in check[1])\n\n if low and high:\n ind = 1.\n else:\n ind = 0.\n\n return np.array([[ind]])","def _mask(self) -> np.ndarray:\n mask = np.ones(self.limits, dtype=bool)\n for ax, shape, limit in zip(\n range(1, len(self.limits)), self.shape, self.limits[1:]\n ):\n ax_mask = np.arange(limit) < np.expand_dims(shape, 1)\n new_shape = np.ones(len(self.limits), dtype=int)\n new_shape[0], new_shape[ax] = self.limits[0], limit\n mask = mask & ax_mask.reshape(*new_shape)\n return mask","def mask(self):\n mask = np.zeros((self.height, self.width))\n pts = [\n np.array(anno).reshape(-1, 2).round().astype(int)\n for anno in self.segmentation\n ]\n mask = cv2.fillPoly(mask, pts, 1)\n return mask","def __iteratively_retain(\n self,\n orf_regions: List[Tuple[int, int]]) -> List[Tuple[int, int]]:\n\n ret = []\n\n arr = np.zeros((len(self.seq), ))\n\n for start, end in orf_regions:\n ret.append((start, end))\n arr[start-1:end] = 1\n orf_coverage = np.sum(arr) / len(arr)\n if orf_coverage > self.min_orf_coverage:\n break\n\n return ret","def fullGrid(state):\n return not ((state[:, :, 0] + state[:, :, 1]) == 0).any()","def stokes_left_circular():\n return np.array([1, 0, 0, -1])","def test07(self):\n a = np.arange(10000)\n b = bcolz.carray(a,)\n wt = [v for v in a if v <= 5000][1010:2020]\n cwt = [v for v in b.where(bcolz.carray(a <= 5000, chunklen=100),\n limit=1010, skip=1010)]\n # print \"numpy ->\", [v for v in a if v>=5000][1010:2020]\n # print \"where ->\", [v for v in b.where(bcolz.carray(a>=5000,\n # chunklen=100),\n # limit=1010, skip=1010)]\n self.assertTrue(wt == cwt, \"where() does not work correctly\")","def get_continous_time_periods(binary_array):\n binary_array = np.copy(binary_array).astype(\"int8\")\n n_times = len(binary_array)\n d_times = np.diff(binary_array)\n # show the +1 and -1 edges\n pos = np.where(d_times == 1)[0] + 1\n neg = np.where(d_times == -1)[0] + 1\n\n if (pos.size == 0) and (neg.size == 0):\n if len(np.nonzero(binary_array)[0]) > 0:\n return [(0, n_times-1)]\n else:\n return []\n elif pos.size == 0:\n # i.e., starts on an spike, then stops\n return [(0, neg[0])]\n elif neg.size == 0:\n # starts, then ends on a spike.\n return [(pos[0], n_times-1)]\n else:\n if pos[0] > neg[0]:\n # we start with a spike\n pos = np.insert(pos, 0, 0)\n if neg[-1] < pos[-1]:\n # we end with aspike\n neg = np.append(neg, n_times - 1)\n # NOTE: by this time, length(pos)==length(neg), necessarily\n h = np.matrix([pos, neg])\n # print(f\"len(h[1][0]) {len(h[1][0])} h[1][0] {h[1][0]} h.size {h.size}\")\n if np.any(h):\n result = []\n for i in np.arange(h.shape[1]):\n if h[1, i] == n_times-1:\n result.append((h[0, i], h[1, i]))\n else:\n result.append((h[0, i], h[1, i]-1))\n return result\n return []","def make_removal_bool(*bools):\n return(np.invert([np.any(f) for f in zip(*bools)]))","def mask(self):\n mask = np.full(self._grid.shape, False)\n mask[np.ix_(self._lat_indices, self._lon_indices)] = True\n return mask","def PLCTYPE_ARR_BOOL(n: int) -> Type[Array]:\n return c_bool * n","def clean_detections(npts, on_off):\n on = on_off[:,0]\n off = on_off[:,1]\n idx_on = [on[0]]\n idx_off = [off[0]]\n lowest_idx = on[0]\n\n for ion, ioff in zip(on, off):\n if ion > lowest_idx + npts:\n idx_on.append(ion)\n idx_off.append(ioff)\n lowest_idx = ion\n\n return np.asarray((idx_on, idx_off)).T","def one_step_reach(base_mask):\n n, m = base_mask.shape\n\n one_step_mask = np.zeros_like(base_mask, dtype=bool)\n\n # Move right and left\n one_step_mask |= np.hstack((np.zeros((n, 1), dtype=bool), base_mask[:, :-1]))\n one_step_mask |= np.hstack((base_mask[:, 1:], np.zeros((n, 1), dtype=bool)))\n # Move up and down\n one_step_mask |= np.vstack((np.zeros((1, m), dtype=bool), base_mask[:-1, :]))\n one_step_mask |= np.vstack((base_mask[1:, :], np.zeros((1, m), dtype=bool)))\n\n return one_step_mask","def all_bees_raised_flag(self):\n pos, com, success = self.perception\n if len(pos) > 0:\n return all(map(lambda x: x[1][\"flag\"] == (self.nr_of_possible_neighbors + 1), com))\n else:\n return True","def filled_positions(self):\n return [x for x in assignable_positions if self.grid[x][0]]","def bool_constraints(Px,pk1,pk2,mu1,mu2,mu3):\n C = np.array([1,1,1,1,1,1,1,1], dtype=bool) # Initialise array as True\n \n # Constraint 1: Check polarisation basis probabilities are valid.\n if (Px >= 1.0 or Px <= 0.0):\n C[0] = False\n # Constraint 2: Check probability of pulse with intensity 1 is in bounds.\n if (pk1 >= 1.0 or pk1 <= 0.0):\n C[1] = False\n # Constraint 3: Check probability of pulse with intensity 2 is in bounds.\n if (pk2 >= 1.0 or pk2 <= 0.0):\n C[2] = False\n # Constraint 4: Check sum of probabilities for intensity 1 & 2 are less\n # than unity.\n if ((pk1 + pk2) >= 1.0):\n C[3] = False\n # Constraint 5: Check value of intensity 1 is in bounds.\n if (mu1 >= 1.0 or mu1 <= 0.0):\n C[4] = False\n # Constraint 6: Check value of intensity 2 is in bounds.\n if (mu2 >= 1.0 or mu2 <= 0.0):\n C[5] = False\n # Constraint 7: Check values of all intensities are in bounds.\n if ((mu1 - mu3) <= mu2):\n C[6] = False\n # Constraint 8: Check values of intensities 2 & 3 are in bounds.\n if (mu2 <= mu3):\n C[7] = False\n return C","def stokes_unpolarized():\n return np.array([1, 0, 0, 0])","def _red_detect_(self, nslice = 0, thresh = 2.0):\n zk_1 = 's_' + format(nslice, '03d')\n zk_2 = 's_' + format(nslice+1, '03d')\n\n zf_1 = self.z_dense[zk_1]\n zf_2 = self.z_dense[zk_2]\n\n # extract the y and x coordinates\n y1 = zf_1[:,0]\n x1 = zf_1[:,1]\n\n y2 = zf_2[:,0]\n x2 = zf_2[:,1]\n\n\n # create a meshgrid\n [YC, YR] = np.meshgrid(y2, y1)\n [XC, XR] = np.meshgrid(x2, x1)\n\n\n dist_block = np.sqrt((YC-YR)**2 + (XC-XR)**2)\n red_pair = np.where(dist_block <= thresh) # find out where the distance between cell i in plane k and cell j in plane k+1 is below the threshold.\n\n ind1 = red_pair[0] # the indices in the first frame\n ind2 = red_pair[1] # the indices in the second frame\n\n\n # select those with markers > 0 and markers < 0\n marker_1 = zf_1[ind1, 3]\n\n\n new_idx = (marker_1 == 0) # select those with zero-markers, which are never counted before. These are new cells. marker_1 needs to be updated.\n pool_new = ind1[new_idx] # select the indices in the first frame where new redundancies are detected \n pool_new_cov = ind2[new_idx] # select the indices in the second frame where new redundancies are detected.\n\n\n pool_exist = ind1[~new_idx] # among the detected redundancies, find those already marked.\n pool_exist_cov = ind2[~new_idx] # correspondingly, find those already marked in the adjacent slice\n\n n_new = len(pool_new)\n n_exist = len(pool_exist)\n if self.verbose:\n print(n_new, \"new redundancies, \", n_exist, \"existing redundancies\")\n\n for n_count in np.arange(n_new):\n # build the new keys\n # also, we need to assign each new key an identity number which is unique.\n n_ind1 = pool_new[n_count] # find the indices in the first slice that contains new redundancies\n n_ind2 = pool_new_cov[n_count] # find the indices in the following slice \n pr_number = nslice * 1000 + n_ind1\n pr_key = 'sl_' + str(pr_number) # build a key \n new_sl = Simple_list(nslice) # create a simple list with z_marker = nslice, nslice is the index of the first z-slice \n new_sl.add([nslice, zf_1[n_ind1, 4]])\n new_sl.add([nslice+1, zf_2[n_ind2, 4]])\n zf_1[n_ind1, 3] = pr_number # assign the new pr_number to zf_1\n zf_2[n_ind2, 3] = pr_number # assigne the same new pr_number to zf_2\n\n self.redundancy_pool[pr_key] = new_sl # stored into the redundancy pool\n\n\n for n_count in np.arange(n_exist):\n # search for the existing keys\n n_ind1 = pool_exist[n_count]\n n_ind2 = pool_exist_cov[n_count]\n pr_number = int(zf_1[n_ind1, 3])# catch up the pr_number\n pr_key = 'sl_' + str(pr_number) # this pr_key should already exist in the pool. \n\n self.redundancy_pool[pr_key].add([nslice+1, zf_2[n_ind2, 4]])\n zf_2[n_ind2, 3] = pr_number # update the pr_number in the adjacent slice","def jitted_line_crosses_to_nonstatic_targets(\n left_ear_array: np.ndarray,\n right_ear_array: np.ndarray,\n nose_array: np.ndarray,\n target_array: np.ndarray,\n ) -> np.ndarray:\n\n results_array = np.zeros((left_ear_array.shape[0], 4))\n for frame_no in prange(results_array.shape[0]):\n Px = np.abs(left_ear_array[frame_no][0] - target_array[frame_no][0])\n Py = np.abs(left_ear_array[frame_no][1] - target_array[frame_no][1])\n Qx = np.abs(right_ear_array[frame_no][0] - target_array[frame_no][0])\n Qy = np.abs(right_ear_array[frame_no][1] - target_array[frame_no][1])\n Nx = np.abs(nose_array[frame_no][0] - target_array[frame_no][0])\n Ny = np.abs(nose_array[frame_no][1] - target_array[frame_no][1])\n Ph = np.sqrt(Px * Px + Py * Py)\n Qh = np.sqrt(Qx * Qx + Qy * Qy)\n Nh = np.sqrt(Nx * Nx + Ny * Ny)\n if Nh < Ph and Nh < Qh and Qh < Ph:\n results_array[frame_no] = [\n 0,\n right_ear_array[frame_no][0],\n right_ear_array[frame_no][1],\n True,\n ]\n elif Nh < Ph and Nh < Qh and Ph < Qh:\n results_array[frame_no] = [\n 1,\n left_ear_array[frame_no][0],\n left_ear_array[frame_no][1],\n True,\n ]\n else:\n results_array[frame_no] = [2, -1, -1, False]\n\n return results_array","def subset(arr, start, end):\n return [[row_data for row_data in row[start[1]:end[1]]] for row in arr[start[0]:end[0]]]","def subset(mylist,mybool):\n myarray = np.array(mylist)\n return(np.squeeze(myarray.take(np.where(mybool),axis=0)))"],"string":"[\n \"def enumerate_bool(bool_array, nstart=0):\\n ind = bool_2_indices(bool_array)\\n ns = np.full(bool_array.size, nstart, dtype=int)\\n for n, lims in enumerate(ind):\\n ns[lims[0]:lims[-1]] = nstart + n + 1\\n return ns\",\n \"def masktoregions(in_mask):\\n regions = []\\n for i in [0,1]: # do the thing for the first and second strands\\n current_strand = in_mask[i].copy().astype(float)\\n current_strand[-1] = np.nan # set final position to np.nan to avoid overlap issues\\n transitions = current_strand - np.roll(current_strand,1)\\n true_start = np.where(transitions == 1)[0]\\n true_end = np.where(transitions == -1)[0] - 1\\n if current_strand[0] == 1: # if starts on True, add True start to front end\\n true_start = np.r_[0,true_start]\\n if in_mask[i][-1] == True: # if ends on True, add True end to back end\\n true_end = np.r_[true_end, len(current_strand)-1]\\n if in_mask[i][-2] == False: # if the one before is False, it's a single point True\\n true_start = np.r_[true_start,len(current_strand)-1]\\n if np.all(in_mask[i][-2:] == [True, False]):\\n true_end = np.r_[true_end, len(current_strand)-2]\\n regions.append(np.asarray([np.zeros(len(true_start))+i,true_start,true_end]).T)\\n out_regions = np.concatenate(regions,axis=0).astype(int)\\n return out_regions\",\n \"def regionstomask(in_regions, genome_len):\\n out_mask = np.zeros((2,genome_len)).astype(bool)\\n for region in in_regions:\\n out_mask[region[0],region[1]:region[2]+1] = True\\n return out_mask\",\n \"def get_mask(total, begin, end):\\n mask = np.zeros([total]).astype(np.float32)\\n mask[begin:end] = 1\\n return np.array(mask, dtype=np.bool)\",\n \"def contiguous_regions(condition):\\n\\n # Find the indicies of changes in \\\"condition\\\"\\n d = np.diff(condition)\\n idx, = d.nonzero()\\n\\n # We need to start things after the change in \\\"condition\\\". Therefore,\\n # we'll shift the index by 1 to the right.\\n idx += 1\\n\\n if condition[0]:\\n # If the start of condition is True prepend a 0\\n idx = np.r_[0, idx]\\n\\n if condition[-1]:\\n # If the end of condition is True, append the length of the array\\n idx = np.r_[idx, condition.size] # Edit\\n\\n # Reshape the result into two columns\\n idx.shape = (-1,2)\\n return idx\",\n \"def contiguous_regions(condition):\\n\\n # Find the indicies of changes in \\\"condition\\\"\\n d = np.diff(condition)\\n idx, = d.nonzero() \\n\\n # We need to start things after the change in \\\"condition\\\". Therefore, \\n # we'll shift the index by 1 to the right.\\n idx += 1\\n\\n if condition[0]:\\n idx_copy = np.zeros((idx.shape[0] + 1), dtype = np.int64)\\n idx_copy[1:] = idx\\n idx = idx_copy\\n # If the start of condition is True prepend a 0\\n ## idx = np.r_[0, idx]\\n if condition[-1]:\\n idx_copy = np.zeros((idx.shape[0] + 1), dtype = np.int64)\\n idx_copy[:-1] = idx\\n idx_copy[-1] = condition.size\\n idx = idx_copy\\n\\n # Reshape the result into two columns\\n idx= np.reshape(idx,(-1,2))\\n return idx\",\n \"def contiguousInds(args):\\n condition = (np.array(args) > 0.0)\\n\\n # Find the indicies of changes in ``condition``\\n dd = np.diff(condition)\\n idx, = dd.nonzero()\\n\\n # Start things after change in ``condition``, thus shift indices 1 rightward\\n idx += 1\\n\\n # If the start is True prepend a 0\\n if condition[0]: idx = np.r_[0, idx]\\n\\n # If the end is True, append the length of the array\\n if condition[-1]: idx = np.r_[idx, condition.size]\\n\\n # Reshape the result into two columns\\n idx.shape = (-1, 2)\\n\\n # Find lengths of each contiguous segment\\n sizes = np.diff(idx, axis=1)\\n # Find the location of maximum segment length\\n maxPos = np.argmax(sizes)\\n # Make indices spanning longest segment\\n inds = np.arange(*idx[maxPos])\\n\\n return inds\",\n \"def is_contiguous(arr):\\n mn, mx = min(arr), max(arr)\\n s = sum(arr)\\n sn = (mn*(mn-1))/2 if mn!=0 else 0\\n sx = (mx*(mx+1))/2\\n if s == sx-sn:\\n return True\\n else:\\n return False\",\n \"def as_boolean_mask(self):\\n bbox = self.bbox()\\n zs = np.unique([c.image_z_position for c in self.contours])\\n z_to_index = dict(zip(zs,range(len(zs))))\\n\\n # Get dimensions, initialize mask.\\n nx,ny = np.diff(bbox[:2], axis=1).astype(int) + 1\\n nx = int(nx); ny = int(ny)\\n nz = int(zs.shape[0])\\n mask = np.zeros((nx,ny,nz), dtype=np.bool)\\n\\n # We check if these points are enclosed within each contour \\n # for a given slice. `test_points` is a list of image coordinate \\n # points, offset by the bounding box.\\n test_points = bbox[:2,0] + np.c_[ np.where(~mask[:,:,0]) ]\\n\\n # First we \\\"turn on\\\" pixels enclosed by inclusion contours.\\n for contour in self.contours:\\n if contour.inclusion:\\n zi = z_to_index[contour.image_z_position]\\n contour_matrix = contour.to_matrix()[:,:2]\\n\\n # Turn the contour closed if it's not.\\n if (contour_matrix[0] != contour_matrix[-1]).all():\\n contour_matrix = np.append(contour_matrix,\\n contour_matrix[0].reshape(1,2),\\n axis=0)\\n\\n # Create path object and test all pixels\\n # within the contour's bounding box.\\n path = mplpath.Path(contour_matrix, closed=True)\\n contains_pts = path.contains_points(test_points)\\n mask[:,:,zi] = contains_pts.reshape(mask.shape[:2])\\n\\n # Second, we \\\"turn off\\\" pixels enclosed by exclusion contours.\\n for contour in self.contours:\\n if not contour.inclusion:\\n zi = z_to_index[contour.image_z_position]\\n contour_matrix = contour.to_matrix()[:,:2]\\n\\n # Turn the contour closed if it's not.\\n if (contour_matrix[0] != contour_matrix[-1]).all():\\n contour_matrix = np.append(contour_matrix,\\n contour_matrix[0].reshape(1,2),\\n axis=0)\\n\\n path = mplpath.Path(contour_matrix, closed=True)\\n not_contains_pts = ~path.contains_points(test_points)\\n not_contains_pts = not_contains_pts.reshape(mask.shape[:2])\\n mask[:,:,zi] = np.logical_and(mask[:,:,zi], not_contains_pts)\\n\\n # The first and second axes have to \\n # be swapped because of the reshape.\\n return mask.swapaxes(0,1), bbox[[1,0,2]]\",\n \"def test08(self):\\n a = np.arange(10000) > 5000\\n b = bcolz.carray(a, chunklen=100)\\n u = b.wheretrue(skip=1020, limit=1020)\\n w = b.wheretrue(skip=1030, limit=1030)\\n self.assertEqual(a.nonzero()[0].tolist()[1020:2040], list(u))\\n self.assertEqual(a.nonzero()[0].tolist()[1030:2060], list(w))\",\n \"def _is_contiguous(positions):\\n previous = positions[0]\\n for current in positions[1:]:\\n if current != previous + 1:\\n return False\\n previous = current\\n return True\",\n \"def subArray(self,left,rightplus):\\n lst=self.boolVals[:]\\n \\n sm=\\\"\\\"\\n for i in range(len(lst)):\\n if lst[i]:\\n sm+=\\\"1\\\"\\n else:\\n sm+=\\\"0\\\"\\n newlst=sm[left:rightplus]\\n newlst=newlst[::-1]\\n final=hex(int(newlst,2))\\n final=final[2:]\\n\\n return BoolArray(final,rightplus-left)\",\n \"def transform_preds_to_boolean(img_size, preds):\\n out = np.zeros(img_size, dtype=bool)\\n\\n adder = np.array([0., 1., 0., 1.])\\n\\n for i in preds:\\n bbox = (i[0:4] + adder).astype(int)\\n out[bbox[1]:bbox[3], bbox[0]:bbox[2]] = True\\n\\n return out\",\n \"def test07(self):\\n a = np.arange(10000) > 5000\\n b = bcolz.carray(a, chunklen=100)\\n wt = a.nonzero()[0].tolist()[1020:2040]\\n cwt = [i for i in b.wheretrue(skip=1020, limit=1020)]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()[1020:2040]\\n # print \\\"where ->\\\", [i for i in b.wheretrue(limit=1020,skip=1020)]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def test09(self):\\n a = np.arange(10000) > 5000\\n b = bcolz.carray(a, chunklen=100)\\n b1 = b.wheretrue(skip=1020, limit=1020)\\n b2 = b.wheretrue(skip=1030, limit=1020)\\n a1 = a.nonzero()[0].tolist()[1020:2040]\\n a2 = a.nonzero()[0].tolist()[1030:2050]\\n # print \\\"result:\\\", [i for i in zip(b1, b2)]\\n self.assertEqual([i for i in zip(a1, a2)], [i for i in zip(b1, b2)])\",\n \"def bool_2_indices(bool_array):\\n if ~isinstance(bool_array, np.ndarray):\\n bool_array = np.array(bool_array)\\n if bool_array[-1]:\\n bool_array[-1] = False\\n lims = np.arange(bool_array.size)[bool_array ^ np.roll(bool_array, 1)]\\n if len(lims) > 0:\\n if lims[-1] == bool_array.size - 1:\\n lims[-1] = bool_array.size\\n return np.reshape(lims, (len(lims) // 2, 2))\\n else:\\n return [[np.nan, np.nan]]\",\n \"def _get_support_mask(self):\\n mask = np.zeros(self.scores_.shape, dtype=bool)\\n mask[self.scores_ >= self.min_count] = True\\n return mask\",\n \"def test06(self):\\n a = np.arange(1, 11) > 5\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()[2:4]\\n cwt = [i for i in b.wheretrue(skip=2, limit=2)]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()[2:4]\\n # print \\\"where ->\\\", [i for i in b.wheretrue(limit=2,skip=2)]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def consecutive_sections(): # noqa: D416\",\n \"def test04(self):\\n a = np.arange(1, 11) > 5\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()[:3]\\n cwt = [i for i in b.wheretrue(limit=3)]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()[:3]\\n # print \\\"where ->\\\", [i for i in b.wheretrue(limit=3)]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def test05(self):\\n a = np.arange(1, 11) > 5\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()[2:]\\n cwt = [i for i in b.wheretrue(skip=2)]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()[2:]\\n # print \\\"where ->\\\", [i for i in b.wheretrue(skip=2)]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def segment_array_by_locs(shape, locs):\\n mask_out = np.zeros(np.prod(shape), dtype=int)\\n for i in range(len(locs) - 1):\\n l = [locs[i],\\n locs[i + 1]]\\n mask_out[l[0]:l[1]] = i + 1\\n return mask_out.reshape(shape)\",\n \"def test01(self):\\n a = np.arange(1, 11) < 0\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()\\n cwt = [i for i in b.wheretrue()]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()\\n # print \\\"where ->\\\", [i for i in b.wheretrue()]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def trajectory_splitter(trajectory, split_start, split_length):\\r\\n mask_array = np.zeros(np.shape(trajectory), dtype=bool)\\r\\n # print(np.shape(mask_array))\\r\\n mask_array[:, split_start:split_start+split_length] = 1\\r\\n # print(np.ma.masked_array(trajectory, mask=mask_array))\\r\\n return trajectory[:, :split_start],trajectory[:, split_start+split_length:], np.ma.masked_array(trajectory, mask=mask_array)\",\n \"def find_exceedences(temp, clim):\\n exceed_bool = temp - clim[\\\"thresh\\\"]\\n exceed_bool[exceed_bool <= 0] = False\\n exceed_bool[exceed_bool > 0] = True\\n\\n # Find contiguous regions of exceed_bool = True\\n events, n_events = ndimage.label(exceed_bool)\\n return events, n_events\",\n \"def continuity_test(districts):\\r\\n for tag in range(1,6):\\r\\n if tag in districts:\\r\\n X = np.where((districts==tag)|(districts==0))\\r\\n contig = set([(X[0][0],X[1][0])])\\r\\n prev_len = 0\\r\\n while len(contig) > prev_len and prev_len<5:\\r\\n prev_len = len(contig)\\r\\n for r,c in contig.copy():\\r\\n if r>0 and districts[r-1,c] in [tag,0]:\\r\\n contig.add((r-1,c))\\r\\n if r<4 and districts[r+1,c] in [tag,0]:\\r\\n contig.add((r+1,c))\\r\\n if c>0 and districts[r,c-1] in [tag,0]:\\r\\n contig.add((r,c-1))\\r\\n if c<4 and districts[r,c+1] in [tag,0]:\\r\\n contig.add((r,c+1))\\r\\n if prev_len < 5:\\r\\n return False\\r\\n return True\",\n \"def test02(self):\\n a = np.arange(1, 1e5) < 0\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()\\n cwt = [i for i in b.wheretrue()]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()\\n # print \\\"where ->\\\", [i for i in b.wheretrue()]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def segment_data(x):\\n return (x.shift(1) != x).astype(int).cumsum()\",\n \"def test00(self):\\n a = np.arange(1, 11) > 0\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()\\n cwt = [i for i in b.wheretrue()]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()\\n # print \\\"where ->\\\", [i for i in b.wheretrue()]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def data_category_inside_boundary(self: Union[pd.DataFrame, pd.Series],\\n boundary: dict, *,\\n inclusive: bool = True) -> ndarray:\\n pass\\n boolean_array = np.full(self.__getattribute__('shape')[0], fill_value=True)\\n for this_dim, this_dim_limit in boundary.items():\\n boolean_array = np.bitwise_and(boolean_array,\\n self[this_dim].between(*this_dim_limit, inclusive=inclusive).values)\\n return boolean_array\",\n \"def test03(self):\\n a = np.arange(1, 11) > 5\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()\\n cwt = [i for i in b.wheretrue()]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()\\n # print \\\"where ->\\\", [i for i in b.wheretrue()]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def trimtimes(time, elmbeg, elmend, preft = 0.0, suft = 0.0):\\n valididx = np.zeros(len(time),dtype='bool')\\n \\n elmbeg = elmbeg - preft\\n elmend = elmend + suft\\n for i in range(len(time)):\\n t = time[i]\\n boolbeg = t>=elmbeg\\n boolend = t<=elmend\\n boolelm = boolbeg & boolend\\n valididx[i] = np.sum(boolelm)\\n \\n #To use only data outside of ELMs\\n valididx = np.invert(valididx)\\n return time[valididx], valididx\",\n \"def isect_flags(arr, other):\\n flags = iter_reduce_ufunc(np.logical_or, (arr == item for item in other))\\n if flags is None:\\n flags = np.zeros(arr.shape, dtype=bool)\\n return flags\",\n \"def get_bools_array(self, bools, limit):\\n bit_array = bytearray()\\n bits_array_length = (limit) // 8\\n\\n for x in range(bits_array_length):\\n bit_array.append(0)\\n\\n\\n for x in range(limit): \\n # set the bits\\n if bools[x]['value'] == True:\\n index = x//8\\n bit = x % 8 \\n bit_array[index] |= 1 << bit \\n\\n return bit_array\",\n \"def region_growing(im: np.ndarray, seed_points: list, T: int) -> np.ndarray:\\n ### START YOUR CODE HERE ### (You can change anything inside this block)\\n # You can also define other helper functions\\n segmented = np.zeros_like(im).astype(bool)\\n\\n (H, W) = im.shape\\n\\n for seed_row, seed_col in seed_points:\\n region = []\\n region.append([seed_row, seed_col])\\n for row, col in region:\\n for rows in range((row-1),(row+2)): # Check neighbouring pixels\\n for cols in range((col-1),(col+2)):\\n if rows < H and rows >= 0 and cols < W and cols >= 0: # Is pixel inside image?\\n if (np.abs(im[seed_row, seed_col] - im[rows, cols]) <= T) and not segmented[row, col]:\\n region.append([rows, cols])\\n segmented[row, col] = True\\n return segmented\\n ### END YOUR CODE HERE ### \",\n \"def life(arr):\\n\\tres_arr = arr\\n\\tmax_x = len(arr[0]) - 1\\n\\tmax_y = len(arr) - 1\\n\\n\\tfor y, y_value in enumerate(arr):\\n\\t\\tfor x, x_value in enumerate(y_value):\\n\\t\\t\\tneighb_count = get_count_life_neighbor(arr, x, y, max_x, max_y)\\n\\t\\t\\tif x_value:\\n\\t\\t\\t\\tif neighb_count < 2 or neighb_count > 3:\\n\\t\\t\\t\\t\\tres_arr[y][x] = False\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif neighb_count == 3:\\n\\t\\t\\t\\t\\tres_arr[y][x] = True\\n\\treturn res_arr\",\n \"def is_crossed(self):\\n left_boundary_clusters = np.extract(self.cluster[0] > 0,\\n self.cluster[0])\\n right_boundary_clusters = np.extract(self.cluster[-1] > 0,\\n self.cluster[-1])\\n return np.in1d(left_boundary_clusters, right_boundary_clusters).any()\",\n \"def locate_interesting_segment(binary_matrix, indeces, beats, during_threshold = 5):\\n point = np.zeros([1, 4], dtype = int)\\n segments = np.empty([0, 4], dtype = int)\\n is_segment_bedin = False\\n for index in indeces:\\n temp = np.diag(binary_matrix, -index)\\n for j in range(len(temp)):\\n if (temp[j] == 0 and is_segment_bedin == False) or (temp[j] == 1 and is_segment_bedin == True):\\n continue\\n else:\\n if temp[j] == 1:\\n point[0, 0] = index + j\\n point[0, 1] = j\\n is_segment_bedin = True\\n else:\\n point[0, 2] = index + j\\n point[0, 3] = j\\n is_segment_bedin = False\\n segments = np.append(segments, point, axis = 0)\\n\\n # using the time during whose default value is 4s to filter segment\\n del_indeces = np.array([], dtype = int)\\n new_binary_matrix = binary_matrix.copy()\\n for i in range(len(segments)):\\n\\n time_begin = beats[segments[i, 0]]\\n time_end = beats[segments[i, 2]]\\n if time_end - time_begin < during_threshold:\\n del_indeces = np.append(del_indeces, i)\\n\\n # set the binary matrix\\n for row in range(segments[i, 0], segments[i, 2]):\\n row_begin = segments[i, 0]\\n col_begin = segments[i, 1]\\n new_binary_matrix[row, row - row_begin + col_begin] = 0\\n\\n segments = np.delete(segments, del_indeces, axis=0)\\n\\n length = len(segments)\\n # the matrix which denote if segment is close with each other\\n segments_close_matrix = np.zeros([length, length], dtype = int)\\n for i in range(length):\\n for j in range(length):\\n if i == j:\\n continue\\n x1 = segments[i, :]\\n x2 = segments[j, :]\\n\\n # determine if segment is close with each other\\n if x2[0] >= x1[0] - 5 and x2[2] <= x1[2] + 20 and abs(x2[1] - x1[1]) <= 20 and x2[3] <= x1[3] + 5:\\n segments_close_matrix[i, j] = 1\\n\\n # delete some segments with less than 3 closed segment\\n del_indeces = np.array([], dtype=int)\\n close_count = np.sum(segments_close_matrix, axis = 0)\\n for i in range(len(segments)):\\n if close_count[i] < 3:\\n del_indeces = np.append(del_indeces, i)\\n\\n # set the binary matrix\\n for row in range(segments[i, 0], segments[i, 2]):\\n row_begin = segments[i, 0]\\n col_begin = segments[i, 1]\\n new_binary_matrix[row, row - row_begin + col_begin] = 0\\n\\n segments = np.delete(segments, del_indeces, axis = 0)\\n # plt.matshow(new_binary_matrix, cmap=plt.cm.gray)\\n # plt.show()\\n\\n return segments, new_binary_matrix\",\n \"def test10(self):\\n a = np.arange(10000) > 5000\\n b = bcolz.carray(a, chunklen=100)\\n bi = b.wheretrue(skip=1020, limit=1020)\\n ai = iter(np.array(a.nonzero()[0].tolist()[1020:2040]))\\n self.assertEqual([i for i in ai], [i for i in bi])\\n self.assertEqual([i for i in ai], [i for i in bi])\",\n \"def create_region_mask(latitude_array, target_shape, lat_bounds):\\n\\n target_ndim = len(target_shape)\\n\\n southern_lat, northern_lat = lat_bounds\\n mask_array = numpy.where((latitude_array >= southern_lat) & (latitude_array < northern_lat), False, True)\\n\\n mask = uconv.broadcast_array(mask_array, [target_ndim - 2, target_ndim - 1], target_shape)\\n assert mask.shape == target_shape \\n\\n return mask\",\n \"def tnuc_region_in_intron(np, beg, end):\\n\\n if beg.tpos == 0 or end.tpos == 0: return False\\n if beg.pos == end.pos and beg.tpos*end.tpos > 0:\\n return True\\n if beg.pos+1 == end.pos and beg.tpos>0 and end.tpos<0:\\n return True\\n if end.pos+1 == beg.pos and beg.tpos<0 and end.tpos>0:\\n return True\\n\\n return False\",\n \"def nondetects(self, masked=False):\\r\\n grd = self.grd\\r\\n xnd = []\\r\\n ynd = []\\r\\n ncells = len(grd.cells['depth'])\\r\\n non_detects_i_tr = np.zeros(ncells, np.int32)\\r\\n if masked:\\r\\n not_flagged = np.where(self.rec_track.flagged==0)[0]\\r\\n rec_track = self.rec_track[not_flagged]\\r\\n rec_seg = self.make_segments(set_depth=True, \\r\\n input_rec_track=rec_track)\\r\\n else:\\r\\n rec_seg = self.rec_seg\\r\\n for nr, rseg in enumerate(rec_seg):\\r\\n seg = rec_seg[nr]\\r\\n dt = seg.dt\\r\\n if dt > dt_signal+1:\\r\\n t1 = seg.t1\\r\\n t2 = seg.t2\\r\\n nint = int(np.rint((t2-t1)/dt_signal)) - 1\\r\\n x1 = seg.x1\\r\\n x2 = seg.x2\\r\\n y1 = seg.y1\\r\\n y2 = seg.y2\\r\\n dx_nd = (x2 - x1)/float(nint+1)\\r\\n dy_nd = (y2 - y1)/float(nint+1)\\r\\n if nint < 120: # 10 minute cutoff for nondetect filling\\r\\n xint = [x1 + n*dx_nd for n in range(1,nint)]\\r\\n yint = [y1 + n*dy_nd for n in range(1,nint)]\\r\\n xnd = xnd + xint\\r\\n ynd = ynd + yint\\r\\n\\r\\n for nd in range(len(xnd)):\\r\\n xy = [xnd[nd], ynd[nd]]\\r\\n i = grd.select_cells_nearest(xy)\\r\\n if (i is not None) and (i >= 0):\\r\\n non_detects_i_tr[i] += 1\\r\\n\\r\\n return non_detects_i_tr\",\n \"def present_in_slice(self, start, stop):\\n return self.starts_before(start) and self.ends_after(stop - 1)\",\n \"def ranges(self, predicate):\\n\\n x = np.zeros(len(self)).astype(np.bool)\\n for i, elem in enumerate(self.elements):\\n x[i] = predicate(elem)\\n\\n return np.where(x)[0]\",\n \"def indices_above(a, val, extend_window: int=0, extend_dir='+'):\\n idx_ = indices_below(a, val, extend_window, extend_dir)\\n idx = np.ones_like(a, dtype=np.bool)\\n idx[idx_] = 0\\n return idx\",\n \"def test05(self):\\n a = np.arange(1, 1e2)\\n b = bcolz.carray(a, chunklen=10)\\n sl = a < 5\\n b[sl] = range(6, 10)\\n a[sl] = range(6, 10)\\n # print \\\"b[%s] -> %r\\\" % (sl, b)\\n assert_array_equal(b[:], a, \\\"fancy indexing does not work correctly\\\")\",\n \"def _get_minimal_lanes(self):\\n return np.argwhere(self.end_of_lanes == np.min(self.end_of_lanes)).flatten()\",\n \"def in_CS(res, coverage=0.9):\\n o = torch.flip(res['alpha'].argsort(), [1]) # sorts each row\\n n = (torch.cumsum(torch.gather(res['alpha'], 1, o), 1) < coverage).sum(1) + 1\\n result = torch.zeros(res['alpha'].shape, dtype=torch.bool)\\n for i in range(result.shape[0]):\\n result[i, o[i][:n[i]]] = True\\n return result\",\n \"def trajectory_masker(trajectory, split_start, split_length):\\r\\n input_mask = np.zeros(np.shape(trajectory), dtype=bool)\\r\\n output_mask = np.zeros(np.shape(trajectory), dtype=bool)\\r\\n\\r\\n input_mask[:, split_start:] = 1\\r\\n output_mask[:, :split_start+split_length] = 1\\r\\n # print(np.ma.masked_array(trajectory, mask=mask_array))\\r\\n return np.ma.masked_array(trajectory, mask=input_mask), np.ma.masked_array(trajectory, mask=output_mask)\",\n \"def region_borders(X_nm):\\n N,M = X_nm.shape\\n return (\\n np.r_[X_nm[:-1,:] != X_nm[1:,:],np.zeros((1,M),bool)] |\\n np.r_[np.zeros((1,M),bool),X_nm[1:,:] != X_nm[:-1,:]] | \\n np.c_[X_nm[:,:-1] != X_nm[:,1:],np.zeros((N,1),bool)] |\\n np.c_[np.zeros((N,1),bool),X_nm[:,1:] != X_nm[:,:-1]])\",\n \"def flag(self, arr):\\n return arr\",\n \"def tnuc_region_in_exon(np, beg, end):\\n\\n if beg.tpos != 0: return False\\n if end.tpos != 0: return False\\n for i in range(beg.pos, end.pos-1):\\n if abs(np[i] - np[i+1]) != 1:\\n return False\\n return True\",\n \"def find_valid_fluid_start_positions(box_rasterized, fluid_rasterized):\\n fluid_shape = np.array(fluid_rasterized[2].shape)\\n box_shape = np.array(box_rasterized[2].shape)\\n last_pos = box_shape - fluid_shape\\n\\n valid_fluid_start_positions_arr = np.zeros(box_shape)\\n for idx in itertools.product(range(0, last_pos[0] + 1),\\n range(0, last_pos[1] + 1),\\n range(0, last_pos[2] + 1)):\\n pos = np.array(idx, np.int32)\\n pos2 = pos + fluid_shape\\n view = box_rasterized[2][pos[0]:pos2[0], pos[1]:pos2[1], pos[2]:pos2[2]]\\n if np.alltrue(\\n np.logical_and(view, fluid_rasterized[2]) ==\\n fluid_rasterized[2]):\\n if idx[1] == 0:\\n valid_fluid_start_positions_arr[idx[0], idx[1], idx[2]] = 1\\n elif np.count_nonzero(valid_fluid_start_positions_arr[idx[0],\\n 0:idx[1],\\n idx[2]]) == 0:\\n valid_fluid_start_positions_arr[idx[0], idx[1], idx[2]] = 1\\n\\n valid_pos = np.stack(np.nonzero(valid_fluid_start_positions_arr), axis=-1)\\n selected_pos = valid_pos[np.random.randint(0, valid_pos.shape[0])]\\n\\n # update the rasterized bounding box volume by substracting the fluid volume\\n pos = selected_pos\\n pos2 = pos + fluid_shape\\n view = box_rasterized[2][pos[0]:pos2[0], pos[1]:pos2[1], pos[2]:pos2[2]]\\n box_rasterized[2][pos[0]:pos2[0], pos[1]:pos2[1],\\n pos[2]:pos2[2]] = np.logical_and(\\n np.logical_not(fluid_rasterized[2]), view)\\n\\n selected_pos += box_rasterized[0]\\n selected_pos = selected_pos.astype(np.float) * box_rasterized[1]\\n\\n return selected_pos\",\n \"def get_contiguous_inds(inds, min_contig_len=5, trim_left=0, trim_right=0, **kwargs):\\r\\n start_inds, stop_inds = get_inds_start_stop(inds, **kwargs)\\r\\n cont_inds = [np.arange(start+trim_left, stop-trim_right) for start, stop in zip(start_inds, stop_inds) if stop-start > min_contig_len]\\r\\n return cont_inds\",\n \"def has_been_segmented(input, loc, clockwise):\\n height = np.shape(input)[0]\\n width = np.shape(input)[1]\\n\\n if clockwise:\\n if loc[0] == 0 and loc[2] + 1 < width:\\n if input[int(loc[1]), int(loc[2]) + 1] < 0:\\n return True\\n elif loc[0] == 1 and loc[2] - 1 >= 0:\\n if input[int(loc[1]), int(loc[2]) - 1] < 0:\\n return True\\n elif loc[0] == 2 and loc[1] - 1 >= 0:\\n if input[int(loc[1]) - 1, int(loc[2])] < 0:\\n return True\\n elif loc[1] + 1 < height:\\n if input[int(loc[1]) + 1, int(loc[2])] < 0:\\n return True\\n else:\\n if loc[0] == 0 and loc[2] - 1 >= 0:\\n if input[int(loc[1]), int(loc[2]) - 1] < 0:\\n return True\\n elif loc[0] == 1 and loc[2] + 1 < width:\\n if input[int(loc[1]), int(loc[2]) + 1] < 0:\\n return True\\n elif loc[0] == 2 and loc[1] + 1 < height:\\n if input[int(loc[1]) + 1, int(loc[2])] < 0:\\n return True\\n elif loc[1] - 1 >= 0:\\n if input[int(loc[1]) - 1, int(loc[2])] < 0:\\n return True\\n\\n return False\",\n \"def move_zeros(array):\\n zero_count = [x for x in array if x is not False].count(0)\\n output = [str(x) if type(x) == bool else x for x in array]\\n for i in range(zero_count):\\n output.remove(0)\\n output.append(0)\\n output = [False if x == 'False' else True if x == 'True' else x for x in output]\\n return output\",\n \"def __generate_mask(self):\\n mask = np.concatenate([np.ones(len(self.fixed[0])),\\n np.zeros(self.num_points),\\n np.ones(len(self.fixed[1]))])\\n return mask\",\n \"def get_future_mask(self, batch_size, sequence_length):\\n\\n xind = tf.tile(tf.range(sequence_length)[None, :], (sequence_length, 1))\\n yind = tf.tile(tf.range(sequence_length)[:, None], (1, sequence_length))\\n mask = yind >= xind\\n mask = tf.tile(mask[None], (batch_size, 1, 1))\\n\\n return mask\",\n \"def inside(i,j,im,h=H): #X\\n return i-h >=0 and j-h >=0 and i+h+1<=im.shape[0] and j+h+1<=im.shape[1]\",\n \"def cmask(self):\\n mask = np.zeros(18)\\n if 'full' in self.CONS: mask[:] = 1\\n if 'f0' in self.CONS: mask[0] = 1\\n if 'f1' in self.CONS: mask[1:4] = 1\\n if 'f2' in self.CONS: mask[4:10] = 1\\n if 'vx' in self.CONS: mask[10] = 1\\n if 'vy' in self.CONS: mask[11] = 1\\n if 'vz' in self.CONS: mask[12] = 1\\n if 'TG' in self.CONS: mask[13:18] = 1\\n return mask>0\",\n \"def _boolean_region(all_polygons_A, all_polygons_B,\\n bboxes_A, bboxes_B,\\n left, bottom, right, top,\\n operation = 'and',\\n precision = 1e-4):\\n\\n polygons_to_boolean_A = _crop_edge_polygons(all_polygons_A, bboxes_A,\\n left, bottom, right, top,\\n precision)\\n polygons_to_boolean_B = _crop_edge_polygons(all_polygons_B, bboxes_B,\\n left, bottom, right, top,\\n precision)\\n polygons_boolean = clipper.clip(polygons_to_boolean_A,\\n polygons_to_boolean_B,\\n operation, 1/precision)\\n return polygons_boolean\",\n \"def as_mask(annotations: Sequence[Annotation],\\n size: int,\\n fs: float,\\n include: bool = True,\\n) -> npt.NDArray[np.bool_]:\\n\\n epochs = [(ann.time, ann.time + ann.duration) for ann in annotations]\\n samples = np.round(np.array(epochs) * fs).astype(int)\\n slices = [slice(*pts) for pts in samples]\\n result = arraytools.filter1D(size, slices)\\n result = result if include else ~result\\n return cast(np.ndarray, result)\",\n \"def Check(self):\\n cleared = False\\n while not cleared:\\n for i in list(combinations([cell.Check() for cell in self.cells], 2)):\\n # for i in list(combinations(zip(self.locations.x,self.locations.y,self.locations.length,self.locations.index),2)):\\n x1 = i[0][0]\\n y1 = i[0][1]\\n r1 = i[0][2] / 2\\n idx1 = i[0][3]\\n x2 = i[1][0]\\n y2 = i[1][1]\\n r2 = i[1][2] / 2\\n idx1 = i[0][3]\\n idx2 = i[1][3]\\n distance = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)\\n radii = (r1 + r2) * (r1 + r2)\\n if distance == radii:\\n cleared = True\\n elif distance > radii:\\n cleared = True\\n else:\\n if x1 > x2 and y1 > y2:\\n if (\\n x1 + r1 > 0\\n and x1 + r1 < self.boundaries[0]\\n and y1 + r1 > 0\\n and y1 + r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 + r1 / 2\\n self.cells[idx1].y = y1 + r1 / 2\\n elif x1 > x2 and y1 < y2:\\n if (\\n x1 + r1 > 0\\n and x1 + r1 < self.boundaries[0]\\n and y1 - r1 > 0\\n and y1 - r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 + r1 / 2\\n self.cells[idx1].y = y1 - r1 / 2\\n elif x1 < x2 and y1 > y2:\\n if (\\n x1 - r1 > 0\\n and x1 - r1 < self.boundaries[0]\\n and y1 + r1 > 0\\n and y1 + r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 - r1 / 2\\n self.cells[idx1].y = y1 + r1 / 2\\n else:\\n if (\\n x1 - r1 > 0\\n and x1 - r1 < self.boundaries[0]\\n and y1 - r1 > 0\\n and y1 - r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 - r1 / 2\\n self.cells[idx1].y = y1 - r1 / 2\\n _logger.debug(\\n f\\\"Bumped from {x1 :.2e}, {y1 :.2e} to {self.cells[idx1].x :.2e}, {self.cells[idx1].y :.2e}\\\"\\n )\\n cleared = False\\n return\",\n \"def contains ( self, pos ):\\n # initialize with only \\\"False\\\" entries\\n inds = zeros(pos.shape[1], dtype=bool)\\n \\n # add points contained in each sector\\n for sec in self.sectors:\\n inds += sec.contains(pos)\\n \\n return inds.astype(bool)\",\n \"def all(self, *args, **kwargs):\\n if self.fragmented:\\n return (\\n np.all(self[self._begin:].view(ndarray), *args, **kwargs) and\\n np.all(self[:self._end].view(ndarray), *args, **kwargs)\\n )\\n else:\\n if self._begin < self._end:\\n part = self[self._begin:self._end]\\n elif self._end == 0:\\n part = self[self._begin:]\\n\\n return (np.all(part.view(ndarray), *args, **kwargs))\",\n \"def get_overlap_mask(times: np.ndarray, intervals: Table):\\n mask = np.zeros(len(times), dtype=\\\"bool\\\")\\n for interval in intervals:\\n exclude = (times >= CxoTime(interval[\\\"start\\\"]).secs) & (\\n times < CxoTime(interval[\\\"stop\\\"]).secs\\n )\\n mask[exclude] = True\\n return mask\",\n \"def all_bees_lowered_flag(self):\\n pos, com, success = self.perception\\n return all(map(lambda x: x[1][\\\"flag\\\"] == 0, com))\",\n \"def find_all_minima(arr):\\n\\n checks = np.r_[True, arr[1:] < arr[:-1]] & np.r_[arr[:-1] < arr[1:], True]\\n minima = np.where(checks)[0]\\n return minima\",\n \"def getBooleanArray2D(self) -> typing.List[typing.List[bool]]:\\n ...\",\n \"def startEndPoints(mazz):\\n for i in range (len(mazz)):\\n for j in range (len(mazz[i])):\\n if mazz[i][j] == 6:\\n startx = i\\n starty = j\\n elif mazz[i][j] == 7:\\n endx = i\\n endy = j\\n return startx, starty, endx, endy\",\n \"def _fix_uniq_col(self):\\n # subgradient; for two boolean arrays, multiplication seems to be the best way \\n # (equivalent to logical_and)\\n n_covered_col = self.a_csr.dot(np.ones(self.ncols)) \\n ifix = np.zeros(self.ncols, dtype=bool)\\n if (np.count_nonzero(n_covered_col) != self.mrows):\\n raise ValueError(\\\"There are uncovered rows! Please check your input!\\\")\\n if (np.any(n_covered_col==1)):\\n inonzero = self.a_csr[n_covered_col==1,:].nonzero()\\n ifix[inonzero[1]] = True\\n\\n return ifix\",\n \"def continuous(self, x, y, X, Y):\\n hor = fabs(x - X) == SSIZE and y == Y\\n ver = fabs(y - Y) == SSIZE and x == X\\n return (hor and not ver) or (ver and not hor)\",\n \"def starting_values(self, resids: NDArray) -> NDArray:\",\n \"def block_array(a, rows=3, cols=4, col_first=True, nodata=-1):\\n s = np.array(a.shape)\\n w = np.array([rows, cols])\\n m = divmod(s, w)\\n new_shape = w*m[0] + w*(m[1]!=0)\\n ypad, xpad = new_shape - a.shape \\n b = np.pad(a, pad_width=((0, ypad),(0, xpad)), \\n mode='constant', \\n constant_values=((nodata, nodata),(nodata, nodata)))\\n rn, cn = new_shape\\n x_s = np.arange(0, cn+cols, cols)[1:] #.tolist()\\n y_s = np.arange(0, rn+rows, rows)[1:] #.tolist()\\n print(\\\"x_s {}\\\\ny_s {}\\\".format(x_s, y_s))\\n #c = np.array([i for i in np.hsplit(b, x_s) if len(i) > 0])\\n c = np.array([i for i in np.split(b, x_s, axis=1) if len(i) > 0])\\n d = np.array([i for i in np.split(c, y_s, axis=1) if len(i) > 0])\\n e = d.swapaxes(0, 1)\\n ix = np.in1d(e.ravel(), nodata).reshape(e.shape)\\n f = np.ma.array(e, mask=ix, fill_value=-1)\\n return b, c, d, e, f\",\n \"def get_adjacent_idxs(sample, array):\\n state = sample >= array # boolean array\\n # Find the index where the last \\\"True\\\"\\n # This is the idx lower than the sample\\n idx_lower = np.where(state)[0][-1]\\n\\n # Find the index where the last \\\"False\\\"\\n # This is the first idx lower than the sample\\n idx_higher = np.where(np.logical_not(state))[0][0]\\n\\n return idx_lower, idx_higher\",\n \"def negative_markers1(markers,positive):\\n global cpt\\n negative = np.array([])\\n lm = len(markers)\\n lp = len(positive)\\n found = False\\n for i in range(lm):\\n for j in range(lp):\\n cpt = cpt + 1\\n if markers[i].cmp(positive[j]) == 0:\\n found = True\\n break\\n if not found:\\n negative = np.append(negative, markers[i])\\n found = False\\n return negative\",\n \"def cleaned(self, start_threshold=0.01, end_threshold=0.25, shifted=True):\\n start_i, end_i = None, None\\n\\n max_i = np.nanargmax(self.ys)\\n max_y = self.ys[max_i]\\n\\n if start_threshold is not None:\\n # includes the value before threshold is met\\n for i, y in enumerate(self.ys[1:]):\\n if y > max_y*start_threshold:\\n start_i = i\\n break\\n\\n if end_threshold is not None:\\n for i, y in enumerate(self.ys[max_i:], start=max_i):\\n if y < max_y*end_threshold:\\n end_i = i\\n break\\n\\n return self.cropped_index(start_i, end_i, shifted)\",\n \"def get_Xc_starts(self):\\r\\n start_list = [np.random.randint(low=0, high=self.total_windows-self.buffer_needed) for _ in range(self.total_points)]\\r\\n return np.array(start_list)\",\n \"def set_scan_sequential(starts, stops, steps):\\n\\n all_positions = [starts[:]]\\n positions = starts[:]\\n state = pos_above_stops(positions, steps, stops)\\n while not state[0]:\\n if not np.any(np.array(state)):\\n positions[-1] += steps[-1]\\n\\n else:\\n indexes_true = np.where(np.array(state))\\n positions[indexes_true[-1][0]] = starts[indexes_true[-1][0]]\\n positions[indexes_true[-1][0] - 1] += steps[indexes_true[-1][0] - 1]\\n\\n state = pos_above_stops(positions, steps, stops)\\n if not np.any(np.array(state)):\\n all_positions.append(positions[:])\\n\\n return np.array(all_positions)\",\n \"def indicator_boundaries(bounds, d):\\n\\n bounds = np.array(bounds)\\n check = bounds.T - d\\n low = all(i <= 0 for i in check[0])\\n high = all(i >= 0 for i in check[1])\\n\\n if low and high:\\n ind = 1.\\n else:\\n ind = 0.\\n\\n return np.array([[ind]])\",\n \"def _mask(self) -> np.ndarray:\\n mask = np.ones(self.limits, dtype=bool)\\n for ax, shape, limit in zip(\\n range(1, len(self.limits)), self.shape, self.limits[1:]\\n ):\\n ax_mask = np.arange(limit) < np.expand_dims(shape, 1)\\n new_shape = np.ones(len(self.limits), dtype=int)\\n new_shape[0], new_shape[ax] = self.limits[0], limit\\n mask = mask & ax_mask.reshape(*new_shape)\\n return mask\",\n \"def mask(self):\\n mask = np.zeros((self.height, self.width))\\n pts = [\\n np.array(anno).reshape(-1, 2).round().astype(int)\\n for anno in self.segmentation\\n ]\\n mask = cv2.fillPoly(mask, pts, 1)\\n return mask\",\n \"def __iteratively_retain(\\n self,\\n orf_regions: List[Tuple[int, int]]) -> List[Tuple[int, int]]:\\n\\n ret = []\\n\\n arr = np.zeros((len(self.seq), ))\\n\\n for start, end in orf_regions:\\n ret.append((start, end))\\n arr[start-1:end] = 1\\n orf_coverage = np.sum(arr) / len(arr)\\n if orf_coverage > self.min_orf_coverage:\\n break\\n\\n return ret\",\n \"def fullGrid(state):\\n return not ((state[:, :, 0] + state[:, :, 1]) == 0).any()\",\n \"def stokes_left_circular():\\n return np.array([1, 0, 0, -1])\",\n \"def test07(self):\\n a = np.arange(10000)\\n b = bcolz.carray(a,)\\n wt = [v for v in a if v <= 5000][1010:2020]\\n cwt = [v for v in b.where(bcolz.carray(a <= 5000, chunklen=100),\\n limit=1010, skip=1010)]\\n # print \\\"numpy ->\\\", [v for v in a if v>=5000][1010:2020]\\n # print \\\"where ->\\\", [v for v in b.where(bcolz.carray(a>=5000,\\n # chunklen=100),\\n # limit=1010, skip=1010)]\\n self.assertTrue(wt == cwt, \\\"where() does not work correctly\\\")\",\n \"def get_continous_time_periods(binary_array):\\n binary_array = np.copy(binary_array).astype(\\\"int8\\\")\\n n_times = len(binary_array)\\n d_times = np.diff(binary_array)\\n # show the +1 and -1 edges\\n pos = np.where(d_times == 1)[0] + 1\\n neg = np.where(d_times == -1)[0] + 1\\n\\n if (pos.size == 0) and (neg.size == 0):\\n if len(np.nonzero(binary_array)[0]) > 0:\\n return [(0, n_times-1)]\\n else:\\n return []\\n elif pos.size == 0:\\n # i.e., starts on an spike, then stops\\n return [(0, neg[0])]\\n elif neg.size == 0:\\n # starts, then ends on a spike.\\n return [(pos[0], n_times-1)]\\n else:\\n if pos[0] > neg[0]:\\n # we start with a spike\\n pos = np.insert(pos, 0, 0)\\n if neg[-1] < pos[-1]:\\n # we end with aspike\\n neg = np.append(neg, n_times - 1)\\n # NOTE: by this time, length(pos)==length(neg), necessarily\\n h = np.matrix([pos, neg])\\n # print(f\\\"len(h[1][0]) {len(h[1][0])} h[1][0] {h[1][0]} h.size {h.size}\\\")\\n if np.any(h):\\n result = []\\n for i in np.arange(h.shape[1]):\\n if h[1, i] == n_times-1:\\n result.append((h[0, i], h[1, i]))\\n else:\\n result.append((h[0, i], h[1, i]-1))\\n return result\\n return []\",\n \"def make_removal_bool(*bools):\\n return(np.invert([np.any(f) for f in zip(*bools)]))\",\n \"def mask(self):\\n mask = np.full(self._grid.shape, False)\\n mask[np.ix_(self._lat_indices, self._lon_indices)] = True\\n return mask\",\n \"def PLCTYPE_ARR_BOOL(n: int) -> Type[Array]:\\n return c_bool * n\",\n \"def clean_detections(npts, on_off):\\n on = on_off[:,0]\\n off = on_off[:,1]\\n idx_on = [on[0]]\\n idx_off = [off[0]]\\n lowest_idx = on[0]\\n\\n for ion, ioff in zip(on, off):\\n if ion > lowest_idx + npts:\\n idx_on.append(ion)\\n idx_off.append(ioff)\\n lowest_idx = ion\\n\\n return np.asarray((idx_on, idx_off)).T\",\n \"def one_step_reach(base_mask):\\n n, m = base_mask.shape\\n\\n one_step_mask = np.zeros_like(base_mask, dtype=bool)\\n\\n # Move right and left\\n one_step_mask |= np.hstack((np.zeros((n, 1), dtype=bool), base_mask[:, :-1]))\\n one_step_mask |= np.hstack((base_mask[:, 1:], np.zeros((n, 1), dtype=bool)))\\n # Move up and down\\n one_step_mask |= np.vstack((np.zeros((1, m), dtype=bool), base_mask[:-1, :]))\\n one_step_mask |= np.vstack((base_mask[1:, :], np.zeros((1, m), dtype=bool)))\\n\\n return one_step_mask\",\n \"def all_bees_raised_flag(self):\\n pos, com, success = self.perception\\n if len(pos) > 0:\\n return all(map(lambda x: x[1][\\\"flag\\\"] == (self.nr_of_possible_neighbors + 1), com))\\n else:\\n return True\",\n \"def filled_positions(self):\\n return [x for x in assignable_positions if self.grid[x][0]]\",\n \"def bool_constraints(Px,pk1,pk2,mu1,mu2,mu3):\\n C = np.array([1,1,1,1,1,1,1,1], dtype=bool) # Initialise array as True\\n \\n # Constraint 1: Check polarisation basis probabilities are valid.\\n if (Px >= 1.0 or Px <= 0.0):\\n C[0] = False\\n # Constraint 2: Check probability of pulse with intensity 1 is in bounds.\\n if (pk1 >= 1.0 or pk1 <= 0.0):\\n C[1] = False\\n # Constraint 3: Check probability of pulse with intensity 2 is in bounds.\\n if (pk2 >= 1.0 or pk2 <= 0.0):\\n C[2] = False\\n # Constraint 4: Check sum of probabilities for intensity 1 & 2 are less\\n # than unity.\\n if ((pk1 + pk2) >= 1.0):\\n C[3] = False\\n # Constraint 5: Check value of intensity 1 is in bounds.\\n if (mu1 >= 1.0 or mu1 <= 0.0):\\n C[4] = False\\n # Constraint 6: Check value of intensity 2 is in bounds.\\n if (mu2 >= 1.0 or mu2 <= 0.0):\\n C[5] = False\\n # Constraint 7: Check values of all intensities are in bounds.\\n if ((mu1 - mu3) <= mu2):\\n C[6] = False\\n # Constraint 8: Check values of intensities 2 & 3 are in bounds.\\n if (mu2 <= mu3):\\n C[7] = False\\n return C\",\n \"def stokes_unpolarized():\\n return np.array([1, 0, 0, 0])\",\n \"def _red_detect_(self, nslice = 0, thresh = 2.0):\\n zk_1 = 's_' + format(nslice, '03d')\\n zk_2 = 's_' + format(nslice+1, '03d')\\n\\n zf_1 = self.z_dense[zk_1]\\n zf_2 = self.z_dense[zk_2]\\n\\n # extract the y and x coordinates\\n y1 = zf_1[:,0]\\n x1 = zf_1[:,1]\\n\\n y2 = zf_2[:,0]\\n x2 = zf_2[:,1]\\n\\n\\n # create a meshgrid\\n [YC, YR] = np.meshgrid(y2, y1)\\n [XC, XR] = np.meshgrid(x2, x1)\\n\\n\\n dist_block = np.sqrt((YC-YR)**2 + (XC-XR)**2)\\n red_pair = np.where(dist_block <= thresh) # find out where the distance between cell i in plane k and cell j in plane k+1 is below the threshold.\\n\\n ind1 = red_pair[0] # the indices in the first frame\\n ind2 = red_pair[1] # the indices in the second frame\\n\\n\\n # select those with markers > 0 and markers < 0\\n marker_1 = zf_1[ind1, 3]\\n\\n\\n new_idx = (marker_1 == 0) # select those with zero-markers, which are never counted before. These are new cells. marker_1 needs to be updated.\\n pool_new = ind1[new_idx] # select the indices in the first frame where new redundancies are detected \\n pool_new_cov = ind2[new_idx] # select the indices in the second frame where new redundancies are detected.\\n\\n\\n pool_exist = ind1[~new_idx] # among the detected redundancies, find those already marked.\\n pool_exist_cov = ind2[~new_idx] # correspondingly, find those already marked in the adjacent slice\\n\\n n_new = len(pool_new)\\n n_exist = len(pool_exist)\\n if self.verbose:\\n print(n_new, \\\"new redundancies, \\\", n_exist, \\\"existing redundancies\\\")\\n\\n for n_count in np.arange(n_new):\\n # build the new keys\\n # also, we need to assign each new key an identity number which is unique.\\n n_ind1 = pool_new[n_count] # find the indices in the first slice that contains new redundancies\\n n_ind2 = pool_new_cov[n_count] # find the indices in the following slice \\n pr_number = nslice * 1000 + n_ind1\\n pr_key = 'sl_' + str(pr_number) # build a key \\n new_sl = Simple_list(nslice) # create a simple list with z_marker = nslice, nslice is the index of the first z-slice \\n new_sl.add([nslice, zf_1[n_ind1, 4]])\\n new_sl.add([nslice+1, zf_2[n_ind2, 4]])\\n zf_1[n_ind1, 3] = pr_number # assign the new pr_number to zf_1\\n zf_2[n_ind2, 3] = pr_number # assigne the same new pr_number to zf_2\\n\\n self.redundancy_pool[pr_key] = new_sl # stored into the redundancy pool\\n\\n\\n for n_count in np.arange(n_exist):\\n # search for the existing keys\\n n_ind1 = pool_exist[n_count]\\n n_ind2 = pool_exist_cov[n_count]\\n pr_number = int(zf_1[n_ind1, 3])# catch up the pr_number\\n pr_key = 'sl_' + str(pr_number) # this pr_key should already exist in the pool. \\n\\n self.redundancy_pool[pr_key].add([nslice+1, zf_2[n_ind2, 4]])\\n zf_2[n_ind2, 3] = pr_number # update the pr_number in the adjacent slice\",\n \"def jitted_line_crosses_to_nonstatic_targets(\\n left_ear_array: np.ndarray,\\n right_ear_array: np.ndarray,\\n nose_array: np.ndarray,\\n target_array: np.ndarray,\\n ) -> np.ndarray:\\n\\n results_array = np.zeros((left_ear_array.shape[0], 4))\\n for frame_no in prange(results_array.shape[0]):\\n Px = np.abs(left_ear_array[frame_no][0] - target_array[frame_no][0])\\n Py = np.abs(left_ear_array[frame_no][1] - target_array[frame_no][1])\\n Qx = np.abs(right_ear_array[frame_no][0] - target_array[frame_no][0])\\n Qy = np.abs(right_ear_array[frame_no][1] - target_array[frame_no][1])\\n Nx = np.abs(nose_array[frame_no][0] - target_array[frame_no][0])\\n Ny = np.abs(nose_array[frame_no][1] - target_array[frame_no][1])\\n Ph = np.sqrt(Px * Px + Py * Py)\\n Qh = np.sqrt(Qx * Qx + Qy * Qy)\\n Nh = np.sqrt(Nx * Nx + Ny * Ny)\\n if Nh < Ph and Nh < Qh and Qh < Ph:\\n results_array[frame_no] = [\\n 0,\\n right_ear_array[frame_no][0],\\n right_ear_array[frame_no][1],\\n True,\\n ]\\n elif Nh < Ph and Nh < Qh and Ph < Qh:\\n results_array[frame_no] = [\\n 1,\\n left_ear_array[frame_no][0],\\n left_ear_array[frame_no][1],\\n True,\\n ]\\n else:\\n results_array[frame_no] = [2, -1, -1, False]\\n\\n return results_array\",\n \"def subset(arr, start, end):\\n return [[row_data for row_data in row[start[1]:end[1]]] for row in arr[start[0]:end[0]]]\",\n \"def subset(mylist,mybool):\\n myarray = np.array(mylist)\\n return(np.squeeze(myarray.take(np.where(mybool),axis=0)))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6591012","0.64183784","0.6045036","0.5852564","0.5838651","0.5837393","0.5796877","0.5683957","0.56573534","0.55983865","0.55705667","0.554639","0.5524945","0.5523016","0.5494886","0.54834664","0.54707986","0.5469798","0.54545856","0.5441271","0.5429074","0.54204804","0.54051983","0.5388636","0.5351503","0.5328587","0.5320112","0.5302967","0.53013444","0.5289913","0.52783525","0.52710044","0.5208834","0.5187936","0.5173357","0.51547116","0.51541126","0.514931","0.5143182","0.5139828","0.51393616","0.51372373","0.51338017","0.5128291","0.51219153","0.51212233","0.5119139","0.51039356","0.5103128","0.5102998","0.51028633","0.5101403","0.50952697","0.5086144","0.50816697","0.5079123","0.5059267","0.5048278","0.50431657","0.5030396","0.50238156","0.5020224","0.5009705","0.5005309","0.49976698","0.49908078","0.49778917","0.49754006","0.4966318","0.49661398","0.49511304","0.49500766","0.49372166","0.49361682","0.4933801","0.4927038","0.49186516","0.4916017","0.4899223","0.48947588","0.48919192","0.4888704","0.48860204","0.48847768","0.48840904","0.48838657","0.4883787","0.48794353","0.48737654","0.48672777","0.48441243","0.4840745","0.48315462","0.48288697","0.48245838","0.48174232","0.48136503","0.4798528","0.47968745","0.47915596"],"string":"[\n \"0.6591012\",\n \"0.64183784\",\n \"0.6045036\",\n \"0.5852564\",\n \"0.5838651\",\n \"0.5837393\",\n \"0.5796877\",\n \"0.5683957\",\n \"0.56573534\",\n \"0.55983865\",\n \"0.55705667\",\n \"0.554639\",\n \"0.5524945\",\n \"0.5523016\",\n \"0.5494886\",\n \"0.54834664\",\n \"0.54707986\",\n \"0.5469798\",\n \"0.54545856\",\n \"0.5441271\",\n \"0.5429074\",\n \"0.54204804\",\n \"0.54051983\",\n \"0.5388636\",\n \"0.5351503\",\n \"0.5328587\",\n \"0.5320112\",\n \"0.5302967\",\n \"0.53013444\",\n \"0.5289913\",\n \"0.52783525\",\n \"0.52710044\",\n \"0.5208834\",\n \"0.5187936\",\n \"0.5173357\",\n \"0.51547116\",\n \"0.51541126\",\n \"0.514931\",\n \"0.5143182\",\n \"0.5139828\",\n \"0.51393616\",\n \"0.51372373\",\n \"0.51338017\",\n \"0.5128291\",\n \"0.51219153\",\n \"0.51212233\",\n \"0.5119139\",\n \"0.51039356\",\n \"0.5103128\",\n \"0.5102998\",\n \"0.51028633\",\n \"0.5101403\",\n \"0.50952697\",\n \"0.5086144\",\n \"0.50816697\",\n \"0.5079123\",\n \"0.5059267\",\n \"0.5048278\",\n \"0.50431657\",\n \"0.5030396\",\n \"0.50238156\",\n \"0.5020224\",\n \"0.5009705\",\n \"0.5005309\",\n \"0.49976698\",\n \"0.49908078\",\n \"0.49778917\",\n \"0.49754006\",\n \"0.4966318\",\n \"0.49661398\",\n \"0.49511304\",\n \"0.49500766\",\n \"0.49372166\",\n \"0.49361682\",\n \"0.4933801\",\n \"0.4927038\",\n \"0.49186516\",\n \"0.4916017\",\n \"0.4899223\",\n \"0.48947588\",\n \"0.48919192\",\n \"0.4888704\",\n \"0.48860204\",\n \"0.48847768\",\n \"0.48840904\",\n \"0.48838657\",\n \"0.4883787\",\n \"0.48794353\",\n \"0.48737654\",\n \"0.48672777\",\n \"0.48441243\",\n \"0.4840745\",\n \"0.48315462\",\n \"0.48288697\",\n \"0.48245838\",\n \"0.48174232\",\n \"0.48136503\",\n \"0.4798528\",\n \"0.47968745\",\n \"0.47915596\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5647696"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":91980,"cells":{"query":{"kind":"string","value":"Set cruising altitudes to the closest cruising altitude."},"document":{"kind":"string","value":"def set_cruise_altitudes(altitudes, cruise_indicies):\n if cruise_indicies:\n for index in range(0, len(cruise_indicies), 2):\n start = cruise_indicies[index]\n stop = cruise_indicies[index + 1]\n if start < stop:\n cruise_altitude = closest_cruising_altitude(altitudes[start])\n altitudes[start] = cruise_altitude\n altitudes[stop] = cruise_altitude\n\n return altitudes"},"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_altitude(self):\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\n print('altitude set to', self.altitude)\n if self.altitude < 0:\n self.altitude = self.altitude + 360.0\n return self.altitude \n else: \n pass\n return self.altitude","def closest_cruising_altitude(altitude):\n return 1000 * ((altitude + 500) // 1000)","def calibrateElevation(self,elevation):\n if len(self.values) == self.values.maxlen:\n self.elevcomp = self.value / ((1.0 - ((elevation + self.heightAboveGround) * 0.3048 / 44330.0)) ** 5.255)\n self.calibrated = True\n else:\n self.calibratedElevation = elevation","def altitude(self, value: int):\n self._point.altitude = value","def setTargetAltitude(altitude):\n return RoboCaller().call(\"setTargetAltitude\", \"void\", altitude)","def set_azimuth(self):\n self.azimuth = self.Calculations.convert_to_azimuth( self.declination, self.right_ascension, self.Latitude, self.LHA)\n if self.azimuth < 0:\n self.azimuth = self.azimuth + 360.0\n return self.azimuth\n else:\n pass\n return self.azimuth\n print('azimuth set to', self.azimuth)","def platform_auto_calibrate_elevation_servo(self):\n self._platform_auto_calibrate_check()\n self.platform.auto_calibrate_elevation_servo()","def altitude(self):\n if self.__altitude:\n return sum(self.__altitude) / len(self.__altitude)\n else:\n return -9999","def raise_sealevel(self, perc=35):\n maxheight = self.elevation.max()\n self.elevation -= np.percentile(self.elevation, perc)\n self.elevation *= maxheight / self.elevation.max()\n self.elevation[-1] = 0","def altitude(self):\r\n pressure = self.pressure # in Si units for hPascal\r\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))","def setClosestBattery(self):\n for b in self.batteries:\n b.closestBatteryDistance = 10000\n for b2 in self.batteries:\n distance = manhattan(b,b2)\n if b.maxCapacity == b2.maxCapacity and distance < b.closestBatteryDistance and not distance == 0:\n b.closestBattery = b2\n b.closestBatteryDistance = manhattan(b,b2)","def setAltitudeAngle(self, angle):\n angle = int(round(angle))\n if angle != self._altitude:\n self._altitude = angle\n self._updateLight()\n self.sigAltitudeAngleChanged.emit()","def lift_up(self):\n\n # Can't reuse set_lift_pos due to bug above\n self.send(self.cmd.SET_LIFT_SET, self.cmd.SET_LIFT_SET[\"check\"][\"min\"])","def sim_altitude(a):\n a.takeoff()\n for i in range(20):\n b = a.refresh()\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() + 3)\n print a.altitude.get_altitudes(), b\n a.land()\n a.motor.set_speed(2000.0)\n for i in range(20):\n b = a.refresh()\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() - 3)\n print a.altitude.get_altitudes(), b","def lower_arm(self):\r\n # ---------------------------------------------------------------------\r\n # Done: 8. Implement this method; it is a ONE-LINER!\r\n # ---------------------------------------------------------------------\r\n if self.is_calibrated == False:\r\n self.calibrate_arm()\r\n self.move_arm_to_position(0)#America\r","def run_go_to_star(self):\n if self.altitude != self.tele_altitude or self.azimuth != self.tele_azimuth:\n self.azimuth_update()\n self.altitude_update()","def takeOff(self):\n\t\tself._altHoldController.setTarget(self._MAX_ALTITUDE)\n\t\tself._taking_off = False","def LAT(self):\n # The maximum update amount for these element\n LateralFraction_DELTA = self.dt * (self.LateralFraction_LIMITS[1] -\n self.LateralFraction_LIMITS[0]) / (\n 2.0)\n\n # Add either positive or negative or zero delta for each\n # NOTE: 'High' is open bracket ) so the max is 1\n LateralFraction_DIRECTION = np.random.randint(-1, 2, 1)[0]\n\n # Now, modify modifiable params AND CLIP\n self.LateralFraction += LateralFraction_DIRECTION * LateralFraction_DELTA\n self.LateralFraction = np.clip(self.LateralFraction,\n self.LateralFraction_LIMITS[0],\n self.LateralFraction_LIMITS[1])","def setAssaultTarget(self):\n if self.underAssault == 1:\n return\n closestRange = 99999\n closestShip = None\n for shipID in self.targets:\n enemyShip = self.myGalaxy.ships[shipID]\n if (enemyShip.alive == 1 and enemyShip.strength < 100 and\n enemyShip.underAssault == 0 and enemyShip.isTransport == 0\n and enemyShip.isAssault == 0 and enemyShip.positions != ['fore'] and\n self.canItakeEnemyShip(enemyShip) == 1):\n range = funcs.getTargetRange(self.posX, self.posY, enemyShip.posX, enemyShip.posY)\n if range < closestRange:\n closestRange = range\n closestShip = enemyShip\n if closestShip != None:\n self.currentTarget = closestShip\n return closestShip","def setTolerance(self, eps):\n self._simulator_.update(eps=eps)\n return","def azimuth_update(self):\n self.current_azimuth = self.azimuth_encoder.get_degrees()\n azimuth_error = self.azimuth - float(self.current_azimuth)\n # print('goal azimuth', self.azimuth, 'current azimuth', self.azimuth_encoder.get_degrees(), 'difference in azimuth', azimuth_error)\n if azimuth_error >0:\n # print('positive azimuth')\n self.azimuth_motor.set_direction(1)\n elif azimuth_error > 0:\n # print('negative azimuth')\n self.azimuth_motor.set_direction(0)\n azimuth_error = abs(azimuth_error)\n self.azimuth_error = azimuth_error\n if azimuth_error >= 0:\n self.azimuth_motor.set_speed(0)\n if azimuth_error >= 35:\n self.azimuth_motor.set_speed(1)\n if azimuth_error >= 40:\n self.azimuth_motor.set_speed(2)\n if azimuth_error >= 80:\n self.azimuth_motor.set_speed(3)\n if azimuth_error >= 160:\n self.azimuth_motor.set_speed(4)\n if azimuth_error >= 280:\n self.azimuth_motor.set_speed(5)\n self.azimuth_error = azimuth_error\n print('debug_azimuth', self.current_azimuth, self.azimuth_error, self.azimuth_motor.speed)\n return self.azimuth_error","def set_ideal_volume(self, display_opt):\n # lowest_point_2ch, lowest_point_2ch_idx, highest_points_2ch, sorted_pts_endo_epi = self.find_top_low_pts3([self.orig_cut_poly_array[1][0],self.orig_cut_poly_array[1][1]])\n # horiz_2ch_a, horiz_2ch_b, _ = self.get_horizontal_points_interp(sorted_pts_endo_epi[0], lowest_point_2ch_idx, 0)\n\n lowest_point_4ch, lowest_point_4ch_idx, highest_points_4ch, sorted_pts_endo_epi = self.find_top_low_pts3([self.orig_cut_poly_array[0][0],self.orig_cut_poly_array[0][1]])\n horiz_4ch_a, horiz_4ch_b, _ = self.get_horizontal_points_interp(sorted_pts_endo_epi[0], lowest_point_4ch_idx, 0)\n\n # compute euclidean distances for 2ch and 4ch\n horiz_2ch_dists, horiz_4ch_dists = self.compute_horizontal_distances(horiz_2ch_a, horiz_2ch_b,\n horiz_4ch_a, horiz_4ch_b)\n\n L = get_length_of_LV_cavity(horiz_2ch_a, horiz_2ch_b,\n horiz_4ch_a, horiz_4ch_b,\n lowest_point_2ch, lowest_point_4ch)\n\n ideal_vol = self.Simpson_bp(horiz_2ch_dists, horiz_4ch_dists, L) # should be approximately 142 mL\n\n self.ideal_vol = ideal_vol\n self.ideal_horiz_2ch_a = horiz_2ch_a\n self.ideal_horiz_2ch_b = horiz_2ch_b\n self.ideal_horiz_4ch_a = horiz_4ch_a\n self.ideal_horiz_4ch_b = horiz_4ch_b\n self.ideal_lowest_point_2ch = lowest_point_2ch\n self.ideal_lowest_point_4ch = lowest_point_4ch","def update_vrad_tolerance(self):\n try:\n value = float(self.edit_vrad_tolerance.text())\n except:\n value = None\n self._get_selected_model().metadata[\"velocity_tolerance\"] = value\n return None","def altitude_range(self, start_distance, finish_distance):\n start_index, start_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n\n min_alt = min(start_alt, finish_alt)\n max_alt = max(start_alt, finish_alt)\n\n if start_index < finish_index:\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\n min_alt = min(min_alt, altitudes.min())\n max_alt = max(max_alt, altitudes.max())\n\n return min_alt, max_alt","def set_rz(self, x):\n x = float(x)\n if self.rz != x:\n self.rz = x","def filter_altitude(self, gps_data, setting=None, threshold=None):\n\n # New filter settings if provided\n if setting is not None:\n self.gps_altitude_filter = setting\n if setting == 'Manual':\n self.gps_altitude_filter_change = threshold\n\n # Set threshold for Auto\n if self.gps_altitude_filter == 'Auto':\n self.gps_altitude_filter_change = 3\n\n # Set all data to valid\n self.valid_data[3, :] = True\n # self.valid_data[5, :] = True\n\n # Manual or Auto is selected, apply filter\n if not self.gps_altitude_filter == 'Off':\n # Initialize variables\n num_valid_old = np.sum(self.valid_data[3, :])\n k = 0\n change = 1\n # Loop until no change in the number of valid ensembles\n while k < 100 and change > 0.1:\n # Compute mean using valid ensembles\n alt_mean = np.nanmean(gps_data.altitude_ens_m[self.valid_data[1, :]])\n\n # Compute difference for each ensemble\n diff = np.abs(gps_data.altitude_ens_m - alt_mean)\n\n # Mark invalid those ensembles with differences greater than the change threshold\n self.valid_data[3, diff > self.gps_altitude_filter_change] = False\n k += 1\n num_valid = np.sum(self.valid_data[3, :])\n change = num_valid_old - num_valid\n\n # Combine all filter data to composite valid data\n self.valid_data[0, :] = np.all(self.valid_data[1:, :], 0)\n self.num_invalid = np.sum(self.valid_data[0, :] == False)","def platform_auto_calibrate_azimuth_servo(self):\n self._platform_auto_calibrate_check()\n self.platform.auto_calibrate_azimuth_servo()","def ARuco_calibrate(self, aruco_height):\n self.y_start = aruco_height","def antenny_calibrate(self):\n if self.antenny_config.get(\"use_bno08x_rvc\"):\n t = .25\n d = .5\n us = 50\n else:\n t = .1\n d = .5\n us = 100\n self.platform.auto_calibrate_elevation_servo(us=us, t=t, d=d)\n self.platform.auto_calibrate_azimuth_servo(us=us, t=t, d=d)\n if self.antenny_config.get(\"use_bno055\"):\n self.platform.auto_calibrate_magnetometer()\n self.platform.auto_calibrate_gyroscope()\n self.platform.auto_calibrate_accelerometer()","def arm_and_takeoff(self, aTargetAltitude):\n print(\"Basic pre-arm checks\")\n # Don't try to arm until autopilot is ready\n self.copters_armable()\n \n print(\"Arming motors\")\n self.copters_arm()\n \n print(\"Vehicle armed!\")\n\n print(\"All drones are now Taking off!\")\n aTargetAltitude = 10\n for c in self.copters:\n c.simple_takeoff(aTargetAltitude) # Take off to target altitude\n c.init_x = c.location.global_relative_frame.lat\n c.init_y = c.location.global_relative_frame.lon\n\n print(\"Waiting for copters to ascend\")\n self.copters_at_altitude(aTargetAltitude)","def correct_east(longitudes):\n longitudes[longitudes > 0] -= 360.\n return longitudes","def altitude(self) -> int:\n return self._point.altitude","def set_abs_tolerance(self, value):\n\n self._abs_tolerance = value","def set_temporal_adapted_epsilon(self):\n\t\t\n\t\t# Perfectly adapted activity level is based on the variables:\n\t\t# temporal_adaptation_mu_eps, temporal_adaptation_sigma_eps, \n\t\t# temporal_adaptation_mu_Ss0. These functions take the activity\n\t\t# level set by these variables at that signal intensity, to \n\t\t# adapt epsilon to the current Ss\n\t\tperfect_adapt_eps_base = sp.ones(self.Mm)*\\\n\t\t\t\tself.temporal_adaptation_mu_eps + random_matrix(self.Mm, \n\t\t\t\tparams=[0, self.temporal_adaptation_sigma_eps], \n\t\t\t\tseed=self.seed_eps)\n\t\tperfect_adapt_Ss = sp.zeros(self.Nn)\n\t\tperfect_adapt_Ss[self.Ss0 != 0] = self.temporal_adaptation_mu_Ss0\n\t\tperfect_adapt_Yy = receptor_activity(perfect_adapt_Ss, \n\t\t\t\t\t\t\t\tself.Kk1, self.Kk2, perfect_adapt_eps_base)\n\t\t\n\t\t# Make adaptation rate into a vector if it has not yet been set.\n\t\ttry:\n\t\t\tself.temporal_adaptation_rate_vector\n\t\texcept AttributeError:\n\t\t\tassert self.temporal_adaptation_rate_sigma == 0, \"Before \"\\\n\t\t\t\t\"setting new epsilon with set_temporal_adapted_epsilon, \"\\\n\t\t\t\t\"you must call set_ordered_temporal_adaptation_rate, since \"\\\n\t\t\t\t\"temporal_adaptation_rate_sigma is nonzero\"\n\t\t\tself.temporal_adaptation_rate_vector = sp.ones(self.Mm)*\\\n\t\t\t\tself.temporal_adaptation_rate\n\t\t\n\t\tif self.temporal_adaptation_type == 'imperfect':\n\t\t\td_eps_dt = self.temporal_adaptation_rate_vector*\\\n\t\t\t\t\t\t(self.Yy - perfect_adapt_Yy)\n\t\t\tdelta_t = self.signal_trace_Tt[1] - self.signal_trace_Tt[0]\n\t\t\tself.eps += delta_t*d_eps_dt \n\t\telif self.temporal_adaptation_type == 'perfect':\n\t\t\tself.eps = free_energy(self.Ss, self.Kk1, self.Kk2, \n\t\t\t\t\t\t\t\t\tperfect_adapt_Yy)","def lower_bri(self):\r\n for light in self.lights:\r\n bri = self.b.get_light(light,'bri')\r\n bri = bri - 50\r\n if bri < 0:\r\n bri = 1\r\n self.b.set_light(light,'bri',bri)","def fix_elevation(self):\n selected_segment = \\\n self.controller.shared_data.obj_track.selected_segment_idx\n segment_idx = selected_segment[0]\n segment = \\\n self.controller.shared_data.obj_track.get_segment(segment_idx)\n\n if len(selected_segment) == 1:\n if segment.shape[0] > constants.fix_thr:\n try:\n self.controller.shared_data.obj_track.fix_elevation(\n segment_idx)\n except ValueError:\n self.controller.shared_data.obj_track.smooth_elevation(\n segment_idx)\n else:\n self.controller.shared_data.obj_track.smooth_elevation(\n segment_idx)\n\n plots.update_plots(\n self.controller.shared_data.obj_track,\n self.controller.shared_data.ax_track,\n self.controller.shared_data.ax_ele,\n self.controller.shared_data.ax_track_info,\n canvas=self.controller.shared_data.canvas)\n\n elif len(selected_segment) > 1:\n messagebox.showerror('Warning',\n 'More than one segment is selected')\n elif len(selected_segment) == 0:\n messagebox.showerror('Warning',\n 'No segment is selected')","def altitude_speed(self, degrees = True):\n return self.angularSpeed(self.future_location.al, self.old_location.al)","def _set_tolerances(self, atol=None, rtol=None, maxiter=None):\n atol = self.atol if atol is None else atol\n rtol = self.rtol if rtol is None else rtol\n maxiter = self.maxiter if maxiter is None else maxiter\n # BUG: PETSc misses rtol requirement by ~10-20X -> Report to petsc4py\n self.ksp.setTolerances(atol=None, rtol=rtol/50, max_it=maxiter)","def altitude_callback(self, data):\n self.altitude = data\n self.altitude_bottom_clearance = np.float64(data.bottom_clearance)\n if np.isnan(self.altitude_bottom_clearance):\n # message is often enough that it should alert the user but shouldn't swamp the console\n rospy.logwarn_throttle(0.5, 'bottom clearance is invalid type: {}'.format(self.altitude_bottom_clearance))","def test_triangle_get_shortest_altitude(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)","def init_patch_clamp(self):\n\n self.pressure.nearing()\n\n # Auto pipette offset and holding at 0 V\n self.amplifier.meter_resist_enable(False)\n self.amplifier.auto_pipette_offset()\n self.amplifier.set_holding(0.)\n self.amplifier.set_holding_enable(True)\n\n # Begin metering\n self.amplifier.meter_resist_enable(True)\n # wait for stable measure\n time.sleep(4)\n # Get pipette resistance\n self.pipette_resistance = self.get_single_resistance_metering(res_type='float')\n if 5e6 > self.pipette_resistance:\n self.update_message('ERROR: Tip resistance is too low ({}).'\n ' Should be higher than 5 MOhm.'.format(self.get_single_resistance_metering('text')))\n self.amplifier.meter_resist_enable(False)\n return 0\n if 10e6 < self.pipette_resistance:\n self.update_message('ERROR: Tip resistance is too high ({}).'\n ' Should be lower than 10 MOhm.'.format(self.get_single_resistance_metering('text')))\n self.amplifier.meter_resist_enable(False)\n return 0\n else:\n self.update_message('Tip resistance is good: {}'.format(self.get_single_resistance_metering('text')))\n self.pipette_resistance_checked = True\n self.set_continuous_meter(True)\n return 1","def platform_set_elevation(self, elevation):\n self.platform.set_elevation(elevation)","def test_tolerances__ignore_from_auto_postings(self, entries, errors, options_map):\n # Interesting case: The Assets leg is filled in with 8.00 USD\n # automatically here, so it is not used in inference. Further forward,\n # the split_expenses plugin splits the first leg as well, and that is\n # also marked as automatic, so if cannot use inference there either. So\n # all legs end up being automatic... and we have to fall back on the\n # default tolerance.","def shrink(self,altRange=None,aziRange=None):\n\n if altRange is None and aziRange is None: raise LookupError('At least one of altRange and aziRange should be defined!')\n\n if altRange is not None: indAlt = np.logical_and(self.data['altitude']>=altRange[0],self.data['altitude']<=altRange[1])\n else: indAlt = np.ones(len(self.data),dtype=np.bool)\n if aziRange is not None: indAzi = np.logical_and(self.data['azimuth']>=aziRange[0],self.data['azimuth']<=aziRange[1])\n else: indAzi = np.ones(len(self.data),dtype=np.bool)\n ind = np.logical_and(indAlt,indAzi)\n self.data = self.data[ind]","def setUncertainty(self, uncertainty):\n self.uncertainty = uncertainty","def _H_correction(self, alt):\n _H_correction_fast(alt, self.Texo)","def setMinMax(self):\n currentIndustryNum = self.myParent.myIndustry[self.myIndustryData.id]\n oldIndustryNum = self.myParent.myOldIndustry[self.myIndustryData.id]\n self.setMinValue(-currentIndustryNum)\n if oldIndustryNum > currentIndustryNum:\n self.setMaxValue(oldIndustryNum-currentIndustryNum)\n elif self.isIndustryResearched() == 0:\n self.setMaxValue(0)\n else:\n max = self.getMaxFromFundsAvail()\n cityNum = (self.myParent.cities-self.myParent.citiesUsed)/self.myIndustryData.cities\n if max < cityNum:\n self.setMaxValue(max)\n else:\n self.setMaxValue(cityNum)","def initialise_calibration(self):\n for i in range(0, self.NUM_SENSORS):\n self.calibratedMax[i] = 0\n self.calibratedMin[i] = self.READING_TIMEOUT","def test_altes(self):\n ideal = np.array([0.00200822, -0.21928398, 0.66719239, 0.66719239,\n -0.17666382, -0.17009953, -0.038399, -0.00083597])\n actual = misc.altes(8, 0.1, 0.5)\n np.testing.assert_allclose(ideal, actual, atol=1e-8, rtol=1e-8)","def _update_rain(self):\n self.rain.update()\n self._make_new_drops()","def get_altitude(points):\n altitudes = np.zeros((len(points),), dtype=\"float64\")\n for i, point in tqdm(enumerate(points), desc=\"GETTING ALTITUDE\"):\n p = Point(point[0], point[1])\n altitudes[i] = alt.NM_COTA.iloc[\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\n ]\n return altitudes","def altitude_profile(self, alt):\n # checking if the units entered are km\n if alt.unit == u.km:\n if 150 <= alt.value < 500:\n alt_properties = self._altitude_profile(500)\n else:\n alt_properties = self._altitude_profile(alt.value)\n\n return [last[int(alt.value)] for last in alt_properties]","def setCrsEllipsoid(self, a, rf=None):\n self.isgeographic = True\n self.ellipsoid_a = a\n if rf is None:\n self.ellipsoid_b = a\n else:\n self.ellipsoid_b = a * (1.0 - 1.0 / rf)\n self.a2 = self.ellipsoid_a * self.ellipsoid_a\n self.b2 = self.ellipsoid_b * self.ellipsoid_b","def setFar(self, far):\n self.light.node().getLens().setFar(far)","def set_tolerance(self, tol):\n self.tolerance = tol","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 update_vrad_tolerance_2(self):\n try:\n value = float(self.edit_vrad_tolerance_2.text())\n except:\n value = None\n self._get_selected_model().metadata[\"velocity_tolerance\"] = value\n return None","def is_cruising(altitude, cruise_altitude=None):\n if cruise_altitude is None:\n cruise_altitude = closest_cruising_altitude(altitude)\n return abs(altitude - cruise_altitude) <= 200","def _update_initial_guess(self, lower, upper):\n err_mesg = 'Upper and lower bounds are identical: check solver tols!'\n assert (upper - lower) / upper > np.finfo('float').eps, err_mesg\n guess = 0.5 * (lower + upper)\n return guess","def set_default_alt_loc(self, alt_loc):\n self.default_alt_loc = alt_loc\n\n ishift = 0\n for i, atm in enumerate(self.atom_order_list):\n if isinstance(atm, Atom):\n ## case 1: atom has no alt_locs\n try:\n self.atom_list[i-ishift] = atm\n except IndexError:\n self.atom_list.append(atm)\n self.atom_dict[atm.name] = atm\n\n else:\n try:\n atmx = atm[alt_loc]\n except KeyError:\n ## case 2: atom has alt_loc partners, but not one\n ## for this given alt_loc\n try:\n del self.atom_list[i-ishift]\n except IndexError:\n pass\n for atmx in atm.itervalues():\n try:\n del self.atom_dict[atmx.name]\n except KeyError:\n pass\n break\n ishift += 1\n else:\n ## case 3: atom has alt_loc partners, and one for\n ## this alt_loc too\n try:\n self.atom_list[i-ishift] = atmx\n except IndexError:\n self.atom_list.append(atmx)\n self.atom_dict[atmx.name] = atmx","def calc_e_akin(self, ui=None, res_dir=None):\r\n print_it(\"calculating e_a,kin\")\r\n pv_local = np.multiply(self.sun.press.sum(1), self.rel_vel)\r\n self.sun.e_akin = np.absolute(\r\n np.divide(np.multiply(pv_local, self.sun.overroll_t_incr),\r\n self.sun.no_overroll_t)) / 1000\r\n self.planet.e_akin = np.absolute(\r\n np.divide(np.multiply(pv_local, self.planet.overroll_t_incr),\r\n self.planet.no_overroll_t)) / 1000","def set_contrast_range(self, zmin, zmax):\n self.get_contrast_panel().set_range(zmin, zmax)","def calibrate(self):\n\t\twl = BLi.getWavelength()\n\t\tif abs(self.stokes()) <= .5:\n\t\t\txxx=self.sign()*180/pi*asin( wl/(2*self.dspace)) - (self.thp())\n\t\t\tself.offset2(-xxx)\n\t\t\tyyy=self.tthp()-self.sign()*2*180/pi*asin(wl/(2*self.dspace))-self.offset5()\n\t\t\tself.offset4(yyy)\n\t\t\tself.offset9(self.dettrans())\n\t\telif abs(self.stokes()-90.) <= .5:\n\t\t\txxx=self.sign()*180/pi*asin( wl/(2*self.dspace)) - (self.thp())\n\t\t\tself.offset3(-xxx)\n\t\t\tyyy=self.tthp()-self.sign()*2*180/pi*asin(wl/(2*self.dspace))-self.offset5()\n\t\t\tself.offset8(yyy)\n\t\t\tself.offset10(self.dettrans())\n\t\telse:\n\t\t\tprint \"Can't calibrate at stokes=\",self.stokes()\n\t\treturn [self.sign(),self.offset2(), self.offset3(),self.offset4(),self.offset5(),self.offset8(),self.offset9(),self.offset10()]","def test_change_lower(self):\n instance = self.traits_instance\n instance.low = -4.0\n instance.value = -2\n self.assertAlmostEqual(instance.value, -2)","def reset_uncertainties(self):\n\n # Make a new temporary ExoParameter using the original self.template\n # dictionary and copy the uncertainty values.\n blank = ExoParameter(\"fake\", attr_dict=self.template)\n self.uncertainty = blank.uncertainty\n self.uncertainty_lower = blank.uncertainty_lower\n self.uncertainty_upper = blank.uncertainty_upper","def SetAbsTol(self, atol):\n return _hypre.HyprePCG_SetAbsTol(self, atol)","def diff_of_errors(self):\n self.e_of_e = self.azimuth_error - self.altitude_error\n return self.e_of_e","def elevation_servo_set_min_max(self, min: int, max: int):\n self.elevation_servo.set_min_position(min)\n self.elevation_servo.set_max_position(max)","def set_Ec_min(self, x):\n x = float(x)\n if self.Ec_min != x:\n self.Ec_min = x\n self.Ec[0] = x","def auto(self):\n self.set_thermostat = 1 if self.desired_values[0] > self.data[0] else 0\n self.set_humidifier = 1 if self.desired_values[1] > self.data[1] else 0\n self.set_sprinklers = 1 if self.desired_values[2] > self.data[2] else 0\n self.set_ventilation = 1 if (self.desired_values[3] > self.data[3] or self.desired_values[4] < self.data[4]) else 0","def SetMinTolerance(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_Tool_SetMinTolerance(self, *args)","def topographic_altitude(self, lat_d, lon_d):\n return self.altitude(lat_d, lon_d)","def topographic_altitude(self, lat_d, lon_d):\n return self.altitude(lat_d, lon_d)","def test_tolerance(self):\n # With idw no sites within tolerance should result in masked output\n dset = self.dset.spec.sel(\n lons=self.lons_inexact, lats=self.lats_inexact, method=\"idw\", tolerance=1.0\n )\n assert dset.spec.hs().values.all()\n dset = self.dset.spec.sel(\n lons=self.lons_inexact, lats=self.lats_inexact, method=\"idw\", tolerance=0.01\n )\n assert np.isnan(dset.spec.hs().values).any()\n # With nearest no sites within tolerance should raise an exception\n with pytest.raises(AssertionError):\n dset = self.dset.spec.sel(\n lons=self.lons_inexact,\n lats=self.lats_inexact,\n method=\"nearest\",\n tolerance=0.01,\n )","def test_extreme_values(self):\n with pytest.warns(RuntimeWarning) as warninfo:\n assert np.exp(laplace_approx(999999, 999999, self.data)) == 0\n with pytest.warns(RuntimeWarning) as warninfo:\n assert np.exp(laplace_approx(999999, 999999, self.data)) == 0","def altitude(press, altimeter=29.92126):\n AS = altimeter*inHg2PA\n print(AS, press**(L*R/g/M))\n h = -(press**(L*R/g/M) - AS**(L*R/g/M))*T0/L/(P0**(L*R/g/M))\n return h/ft2m","def update(self):\n if self.temperature != None and self.humidity != None:\n self.sensor.set_environmental_data(self.humidity, self.temperature)\n# Trim away error values.\n new_eco2 = self.sensor.eco2\n if new_eco2 < 65535:\n self.eco2 = new_eco2\n self.tvoc = self.sensor.tvoc","def arm_and_takeoff_nogps(aTargetAltitude):\n\n print(\"Taking of to an altitude of \", str(aTargetAltitude))\n\n print(\"Basic pre-arm checks\")\n\n while not vehicle.is_armable:\n print(\" Waiting for vehicle to initialise...\")\n time.sleep(1)\n\n print(\"Arming motors\")\n # Copter should arm in GUIDED_NOGPS mode\n vehicle.mode = VehicleMode(\"GUIDED_NOGPS\")\n vehicle.armed = True\n\n while not vehicle.armed:\n print(\" Waiting for arming...\")\n vehicle.armed = True\n time.sleep(1)\n\n print(\"Taking off!\")\n\n thrust = DEFAULT_TAKEOFF_THRUST\n while True:\n current_altitude = vehicle.location.global_relative_frame.alt\n print(\" Altitude: %f Desired: %f\" %\n (current_altitude, aTargetAltitude))\n if current_altitude >= aTargetAltitude*0.95: # Trigger just below target alt.\n print(\"Reached target altitude\")\n break\n elif current_altitude >= aTargetAltitude*0.6:\n thrust = SMOOTH_TAKEOFF_THRUST\n set_attitude(thrust = thrust)\n time.sleep(0.2)","def set_receiver(self, height, elevation, azimuth):\n\n if height < 0:\n raise ValueError(\"The height cannot be negative\")\n if elevation < 0 or elevation > 180:\n raise ValueError(\"The elevation cannot be negative or greater 180\")\n if elevation == 90:\n raise ValueError(\"The elevation can not be 90\")\n if azimuth < 0 or azimuth >= 360:\n raise ValueError(\"The azimuth cannot be negative or >= 360\")\n\n theta, phi = f.convert_direction(elevation, azimuth)\n\n idx, height = f.argclosest(f.km2m(height), self.height_array, return_value=True)\n self.receiver_height = height\n self.receiver_elevation = theta\n self.receiver_azimuth = phi","def get_altitude(self):\n self.degrees = self.altitude_encoder.get_degrees()\n self.tele_altitude = self.Calculations.convert_degrees( self.degrees)\n return self.tele_altitude","def update_newly_set_ref_V_ampl(self):\n self.qlin_ref_V_ampl_RMS.setText(\n \"%.3f\" % self.alia.config.ref_V_ampl_RMS\n )\n self.qlin_ref_V_ampl.setText(\"%.3f\" % self.alia.config.ref_V_ampl)\n self.qlbl_ref_is_clipping.setText(self.get_clipping_text())\n # QApplication.processEvents()\n\n self.alia_qdev.state.reset()\n self.clear_curves_stage_1_and_2()","def set_lz(self):\r\n self._lz = self.dz * self.nz - self.oz","def test_triangle_get_longest_altitude(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_longest_altitude(), 9.428090415820634)","def find_hypocenter(self):\n ps_hypo = min(self.pointsources, key=lambda x: x.time_shift)\n self.hypocenter_longitude = ps_hypo.longitude\n self.hypocenter_latitude = ps_hypo.latitude\n self.hypocenter_depth_in_m = ps_hypo.depth_in_m","def setTolerances(self, rtol = 1.0e-9,\n atol = 1.0e-20, rtolsens= -1.0, atolsens = -1.0):\n _cantera.reactornet_setTolerances(self.__reactornet_id, rtol, atol)\n _cantera.reactornet_setSensitivityTolerances(self.__reactornet_id, rtolsens, atolsens)","def _fix_austrian_lpis(self, eopatch):\n eopatch.vector_timeless[self.feature] = pd.merge(eopatch.vector_timeless[self.feature],\n self.mapping,\n on='SNAR_BEZEI')","def elevation(self, elevation):\n\n self.container['elevation'] = elevation","def set_ascertained(self):\n\n # Do the correction if the tree is calibrated, as ascertainment\n # correction influences timing estimates\n if self.ascertained == None:\n self.ascertained = not self.global_config.arbitrary_tree","def tolerance(self, tolerance: float) -> None:\n self._tolerance = tolerance","def ecef2LatLonAlt(x, y, z):\n\n # Calculate the polar eccentricity\n ep = np.sqrt((EARTH.EQUATORIAL_RADIUS**2 - EARTH.POLAR_RADIUS**2)/(EARTH.POLAR_RADIUS**2))\n\n # Calculate the longitude\n lon = np.arctan2(y, x)\n\n p = np.sqrt(x**2 + y**2)\n\n theta = np.arctan2( z*EARTH.EQUATORIAL_RADIUS, p*EARTH.POLAR_RADIUS)\n\n # Calculate the latitude\n lat = np.arctan2(z + (ep**2)*EARTH.POLAR_RADIUS*np.sin(theta)**3, \\\n p - (EARTH.E**2)*EARTH.EQUATORIAL_RADIUS*np.cos(theta)**3)\n\n # Get distance from Earth centre to the position given by geographical coordinates, in WGS84\n N = EARTH.EQUATORIAL_RADIUS/math.sqrt(1.0 - (EARTH.E**2)*math.sin(lat)**2)\n\n \n # Calculate the height in meters\n\n # Correct for numerical instability in altitude near exact poles (and make sure cos(lat) is not 0!)\n if((np.abs(x) < 1000) and (np.abs(y) < 1000)):\n alt = np.abs(z) - EARTH.POLAR_RADIUS\n\n else:\n # Calculate altitude anywhere else\n alt = p/np.cos(lat) - N\n\n\n return lat, lon, alt","async def _move_altaz(self, alt: float, az: float, abort_event: asyncio.Event) -> None:\n\n # alt/az coordinates to ra/dec\n coords = SkyCoord(\n alt=alt * u.degree, az=az * u.degree, obstime=Time.now(), location=self.location, frame=\"altaz\"\n )\n icrs = coords.icrs\n\n # start slewing\n await self.__move(icrs.ra.degree, icrs.dec.degree, abort_event)","def set_tolerance(self, value):\n\n self._tolerance = value","def setUp(self):\n self.upper = 230.0\n self.lower = 195.0","def set_arrive(self):\n if self._is_disabled_time():\n log.info(\"Home arrive not triggered due disabled time\")\n return\n\n for light in ARRIVE_LIGHTS():\n self.__try_to_run(self._turn_on_light, [light])\n if self.sunset.is_past_sunset():\n self.set_arrive_after_sunset()","def setNearFar(self, near, far):\n self.light.node().getLens().setNearFar(near, far)","def apply_heuristic_tile_corrections(self):\n for tile_key in self.wd_stig_corr:\n g, t = tile_key.split('.')\n g, t = int(g), int(t)\n self.gm.adjust_tile_wd(g, t, self.wd_stig_corr[tile_key][0])\n self.gm.adjust_tile_stig_xy(\n g, t, *self.wd_stig_corr[tile_key][1:3])","def altitude_control(self, altitude_cmd,\n vertical_velocity_cmd,\n altitude,\n vertical_velocity,\n attitude,\n acceleration_ff=0.0):\n \n hdot_cmd = self.Kp_alt * (altitude_cmd - altitude) + vertical_velocity_cmd\n \n # Limit the ascent/descent rate\n hdot_cmd = np.clip(hdot_cmd, -self.max_descent_rate, self.max_ascent_rate)\n\n acceleration_cmd = acceleration_ff + self.Kp_hdot*(hdot_cmd - vertical_velocity)\n \n R33 = np.cos(attitude[0]) * np.cos(attitude[1])\n thrust = DRONE_MASS_KG * acceleration_cmd / R33\n \n if thrust > MAX_THRUST:\n thrust = MAX_THRUST\n elif thrust < 0.0:\n thrust = 0.0\n return thrust","def convergence_check(self):\n air = self.air_alias.val\n flue_gas = self.fuel_alias.val + '_fg'\n fuel = self.fuel_alias.val\n\n for c in self.outl:\n if not c.fluid.val_set[air]:\n if c.fluid.val[air] > 0.95:\n c.fluid.val[air] = 0.95\n if c.fluid.val[air] < 0.5:\n c.fluid.val[air] = 0.5\n\n if not c.fluid.val_set[flue_gas]:\n if c.fluid.val[flue_gas] > 0.5:\n c.fluid.val[flue_gas] = 0.5\n if c.fluid.val[flue_gas] < 0.05:\n c.fluid.val[flue_gas] = 0.05\n\n if not c.fluid.val_set[fuel]:\n if c.fluid.val[fuel] > 0:\n c.fluid.val[fuel] = 0\n\n c.target.propagate_fluid_to_target(c, c.target)\n\n for i in self.inl:\n if i.m.val_SI < 0 and not i.m.val_set:\n i.m.val_SI = 0.01\n\n for c in self.outl:\n if c.m.val_SI < 0 and not c.m.val_set:\n c.m.val_SI = 10\n c.target.propagate_fluid_to_target(c, c.target)\n\n if self.lamb.val < 1 and not self.lamb.is_set:\n self.lamb.val = 2","def set_Ec_max(self, x):\n x = float(x)\n if self.Ec_max != x:\n self.Ec_max = x\n self.Ec[1] = x","def add_euler_error(df):\n df[\"T_vehicle_attitude_setpoint_0__NF_e_roll\"] = mpd.angle_wrap(\n df[\"T_vehicle_attitude_setpoint_0__F_roll_body\"]\n - df[\"T_vehicle_attitude_0__NF_roll\"]\n )\n df[\"T_vehicle_attitude_setpoint_0__NF_e_pitch\"] = mpd.angle_wrap(\n df[\"T_vehicle_attitude_setpoint_0__F_pitch_body\"]\n - df[\"T_vehicle_attitude_0__NF_pitch\"]\n )\n df[\"T_vehicle_attitude_setpoint_0__NF_e_yaw\"] = mpd.angle_wrap(\n df[\"T_vehicle_attitude_setpoint_0__F_yaw_body\"]\n - df[\"T_vehicle_attitude_0__NF_yaw\"]\n )"],"string":"[\n \"def set_altitude(self):\\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\\n print('altitude set to', self.altitude)\\n if self.altitude < 0:\\n self.altitude = self.altitude + 360.0\\n return self.altitude \\n else: \\n pass\\n return self.altitude\",\n \"def closest_cruising_altitude(altitude):\\n return 1000 * ((altitude + 500) // 1000)\",\n \"def calibrateElevation(self,elevation):\\n if len(self.values) == self.values.maxlen:\\n self.elevcomp = self.value / ((1.0 - ((elevation + self.heightAboveGround) * 0.3048 / 44330.0)) ** 5.255)\\n self.calibrated = True\\n else:\\n self.calibratedElevation = elevation\",\n \"def altitude(self, value: int):\\n self._point.altitude = value\",\n \"def setTargetAltitude(altitude):\\n return RoboCaller().call(\\\"setTargetAltitude\\\", \\\"void\\\", altitude)\",\n \"def set_azimuth(self):\\n self.azimuth = self.Calculations.convert_to_azimuth( self.declination, self.right_ascension, self.Latitude, self.LHA)\\n if self.azimuth < 0:\\n self.azimuth = self.azimuth + 360.0\\n return self.azimuth\\n else:\\n pass\\n return self.azimuth\\n print('azimuth set to', self.azimuth)\",\n \"def platform_auto_calibrate_elevation_servo(self):\\n self._platform_auto_calibrate_check()\\n self.platform.auto_calibrate_elevation_servo()\",\n \"def altitude(self):\\n if self.__altitude:\\n return sum(self.__altitude) / len(self.__altitude)\\n else:\\n return -9999\",\n \"def raise_sealevel(self, perc=35):\\n maxheight = self.elevation.max()\\n self.elevation -= np.percentile(self.elevation, perc)\\n self.elevation *= maxheight / self.elevation.max()\\n self.elevation[-1] = 0\",\n \"def altitude(self):\\r\\n pressure = self.pressure # in Si units for hPascal\\r\\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))\",\n \"def setClosestBattery(self):\\n for b in self.batteries:\\n b.closestBatteryDistance = 10000\\n for b2 in self.batteries:\\n distance = manhattan(b,b2)\\n if b.maxCapacity == b2.maxCapacity and distance < b.closestBatteryDistance and not distance == 0:\\n b.closestBattery = b2\\n b.closestBatteryDistance = manhattan(b,b2)\",\n \"def setAltitudeAngle(self, angle):\\n angle = int(round(angle))\\n if angle != self._altitude:\\n self._altitude = angle\\n self._updateLight()\\n self.sigAltitudeAngleChanged.emit()\",\n \"def lift_up(self):\\n\\n # Can't reuse set_lift_pos due to bug above\\n self.send(self.cmd.SET_LIFT_SET, self.cmd.SET_LIFT_SET[\\\"check\\\"][\\\"min\\\"])\",\n \"def sim_altitude(a):\\n a.takeoff()\\n for i in range(20):\\n b = a.refresh()\\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() + 3)\\n print a.altitude.get_altitudes(), b\\n a.land()\\n a.motor.set_speed(2000.0)\\n for i in range(20):\\n b = a.refresh()\\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() - 3)\\n print a.altitude.get_altitudes(), b\",\n \"def lower_arm(self):\\r\\n # ---------------------------------------------------------------------\\r\\n # Done: 8. Implement this method; it is a ONE-LINER!\\r\\n # ---------------------------------------------------------------------\\r\\n if self.is_calibrated == False:\\r\\n self.calibrate_arm()\\r\\n self.move_arm_to_position(0)#America\\r\",\n \"def run_go_to_star(self):\\n if self.altitude != self.tele_altitude or self.azimuth != self.tele_azimuth:\\n self.azimuth_update()\\n self.altitude_update()\",\n \"def takeOff(self):\\n\\t\\tself._altHoldController.setTarget(self._MAX_ALTITUDE)\\n\\t\\tself._taking_off = False\",\n \"def LAT(self):\\n # The maximum update amount for these element\\n LateralFraction_DELTA = self.dt * (self.LateralFraction_LIMITS[1] -\\n self.LateralFraction_LIMITS[0]) / (\\n 2.0)\\n\\n # Add either positive or negative or zero delta for each\\n # NOTE: 'High' is open bracket ) so the max is 1\\n LateralFraction_DIRECTION = np.random.randint(-1, 2, 1)[0]\\n\\n # Now, modify modifiable params AND CLIP\\n self.LateralFraction += LateralFraction_DIRECTION * LateralFraction_DELTA\\n self.LateralFraction = np.clip(self.LateralFraction,\\n self.LateralFraction_LIMITS[0],\\n self.LateralFraction_LIMITS[1])\",\n \"def setAssaultTarget(self):\\n if self.underAssault == 1:\\n return\\n closestRange = 99999\\n closestShip = None\\n for shipID in self.targets:\\n enemyShip = self.myGalaxy.ships[shipID]\\n if (enemyShip.alive == 1 and enemyShip.strength < 100 and\\n enemyShip.underAssault == 0 and enemyShip.isTransport == 0\\n and enemyShip.isAssault == 0 and enemyShip.positions != ['fore'] and\\n self.canItakeEnemyShip(enemyShip) == 1):\\n range = funcs.getTargetRange(self.posX, self.posY, enemyShip.posX, enemyShip.posY)\\n if range < closestRange:\\n closestRange = range\\n closestShip = enemyShip\\n if closestShip != None:\\n self.currentTarget = closestShip\\n return closestShip\",\n \"def setTolerance(self, eps):\\n self._simulator_.update(eps=eps)\\n return\",\n \"def azimuth_update(self):\\n self.current_azimuth = self.azimuth_encoder.get_degrees()\\n azimuth_error = self.azimuth - float(self.current_azimuth)\\n # print('goal azimuth', self.azimuth, 'current azimuth', self.azimuth_encoder.get_degrees(), 'difference in azimuth', azimuth_error)\\n if azimuth_error >0:\\n # print('positive azimuth')\\n self.azimuth_motor.set_direction(1)\\n elif azimuth_error > 0:\\n # print('negative azimuth')\\n self.azimuth_motor.set_direction(0)\\n azimuth_error = abs(azimuth_error)\\n self.azimuth_error = azimuth_error\\n if azimuth_error >= 0:\\n self.azimuth_motor.set_speed(0)\\n if azimuth_error >= 35:\\n self.azimuth_motor.set_speed(1)\\n if azimuth_error >= 40:\\n self.azimuth_motor.set_speed(2)\\n if azimuth_error >= 80:\\n self.azimuth_motor.set_speed(3)\\n if azimuth_error >= 160:\\n self.azimuth_motor.set_speed(4)\\n if azimuth_error >= 280:\\n self.azimuth_motor.set_speed(5)\\n self.azimuth_error = azimuth_error\\n print('debug_azimuth', self.current_azimuth, self.azimuth_error, self.azimuth_motor.speed)\\n return self.azimuth_error\",\n \"def set_ideal_volume(self, display_opt):\\n # lowest_point_2ch, lowest_point_2ch_idx, highest_points_2ch, sorted_pts_endo_epi = self.find_top_low_pts3([self.orig_cut_poly_array[1][0],self.orig_cut_poly_array[1][1]])\\n # horiz_2ch_a, horiz_2ch_b, _ = self.get_horizontal_points_interp(sorted_pts_endo_epi[0], lowest_point_2ch_idx, 0)\\n\\n lowest_point_4ch, lowest_point_4ch_idx, highest_points_4ch, sorted_pts_endo_epi = self.find_top_low_pts3([self.orig_cut_poly_array[0][0],self.orig_cut_poly_array[0][1]])\\n horiz_4ch_a, horiz_4ch_b, _ = self.get_horizontal_points_interp(sorted_pts_endo_epi[0], lowest_point_4ch_idx, 0)\\n\\n # compute euclidean distances for 2ch and 4ch\\n horiz_2ch_dists, horiz_4ch_dists = self.compute_horizontal_distances(horiz_2ch_a, horiz_2ch_b,\\n horiz_4ch_a, horiz_4ch_b)\\n\\n L = get_length_of_LV_cavity(horiz_2ch_a, horiz_2ch_b,\\n horiz_4ch_a, horiz_4ch_b,\\n lowest_point_2ch, lowest_point_4ch)\\n\\n ideal_vol = self.Simpson_bp(horiz_2ch_dists, horiz_4ch_dists, L) # should be approximately 142 mL\\n\\n self.ideal_vol = ideal_vol\\n self.ideal_horiz_2ch_a = horiz_2ch_a\\n self.ideal_horiz_2ch_b = horiz_2ch_b\\n self.ideal_horiz_4ch_a = horiz_4ch_a\\n self.ideal_horiz_4ch_b = horiz_4ch_b\\n self.ideal_lowest_point_2ch = lowest_point_2ch\\n self.ideal_lowest_point_4ch = lowest_point_4ch\",\n \"def update_vrad_tolerance(self):\\n try:\\n value = float(self.edit_vrad_tolerance.text())\\n except:\\n value = None\\n self._get_selected_model().metadata[\\\"velocity_tolerance\\\"] = value\\n return None\",\n \"def altitude_range(self, start_distance, finish_distance):\\n start_index, start_ratio = calculate_value_reference(self.distances,\\n start_distance)\\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\\n finish_index, finish_ratio = calculate_value_reference(self.distances,\\n finish_distance)\\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\\n\\n min_alt = min(start_alt, finish_alt)\\n max_alt = max(start_alt, finish_alt)\\n\\n if start_index < finish_index:\\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\\n min_alt = min(min_alt, altitudes.min())\\n max_alt = max(max_alt, altitudes.max())\\n\\n return min_alt, max_alt\",\n \"def set_rz(self, x):\\n x = float(x)\\n if self.rz != x:\\n self.rz = x\",\n \"def filter_altitude(self, gps_data, setting=None, threshold=None):\\n\\n # New filter settings if provided\\n if setting is not None:\\n self.gps_altitude_filter = setting\\n if setting == 'Manual':\\n self.gps_altitude_filter_change = threshold\\n\\n # Set threshold for Auto\\n if self.gps_altitude_filter == 'Auto':\\n self.gps_altitude_filter_change = 3\\n\\n # Set all data to valid\\n self.valid_data[3, :] = True\\n # self.valid_data[5, :] = True\\n\\n # Manual or Auto is selected, apply filter\\n if not self.gps_altitude_filter == 'Off':\\n # Initialize variables\\n num_valid_old = np.sum(self.valid_data[3, :])\\n k = 0\\n change = 1\\n # Loop until no change in the number of valid ensembles\\n while k < 100 and change > 0.1:\\n # Compute mean using valid ensembles\\n alt_mean = np.nanmean(gps_data.altitude_ens_m[self.valid_data[1, :]])\\n\\n # Compute difference for each ensemble\\n diff = np.abs(gps_data.altitude_ens_m - alt_mean)\\n\\n # Mark invalid those ensembles with differences greater than the change threshold\\n self.valid_data[3, diff > self.gps_altitude_filter_change] = False\\n k += 1\\n num_valid = np.sum(self.valid_data[3, :])\\n change = num_valid_old - num_valid\\n\\n # Combine all filter data to composite valid data\\n self.valid_data[0, :] = np.all(self.valid_data[1:, :], 0)\\n self.num_invalid = np.sum(self.valid_data[0, :] == False)\",\n \"def platform_auto_calibrate_azimuth_servo(self):\\n self._platform_auto_calibrate_check()\\n self.platform.auto_calibrate_azimuth_servo()\",\n \"def ARuco_calibrate(self, aruco_height):\\n self.y_start = aruco_height\",\n \"def antenny_calibrate(self):\\n if self.antenny_config.get(\\\"use_bno08x_rvc\\\"):\\n t = .25\\n d = .5\\n us = 50\\n else:\\n t = .1\\n d = .5\\n us = 100\\n self.platform.auto_calibrate_elevation_servo(us=us, t=t, d=d)\\n self.platform.auto_calibrate_azimuth_servo(us=us, t=t, d=d)\\n if self.antenny_config.get(\\\"use_bno055\\\"):\\n self.platform.auto_calibrate_magnetometer()\\n self.platform.auto_calibrate_gyroscope()\\n self.platform.auto_calibrate_accelerometer()\",\n \"def arm_and_takeoff(self, aTargetAltitude):\\n print(\\\"Basic pre-arm checks\\\")\\n # Don't try to arm until autopilot is ready\\n self.copters_armable()\\n \\n print(\\\"Arming motors\\\")\\n self.copters_arm()\\n \\n print(\\\"Vehicle armed!\\\")\\n\\n print(\\\"All drones are now Taking off!\\\")\\n aTargetAltitude = 10\\n for c in self.copters:\\n c.simple_takeoff(aTargetAltitude) # Take off to target altitude\\n c.init_x = c.location.global_relative_frame.lat\\n c.init_y = c.location.global_relative_frame.lon\\n\\n print(\\\"Waiting for copters to ascend\\\")\\n self.copters_at_altitude(aTargetAltitude)\",\n \"def correct_east(longitudes):\\n longitudes[longitudes > 0] -= 360.\\n return longitudes\",\n \"def altitude(self) -> int:\\n return self._point.altitude\",\n \"def set_abs_tolerance(self, value):\\n\\n self._abs_tolerance = value\",\n \"def set_temporal_adapted_epsilon(self):\\n\\t\\t\\n\\t\\t# Perfectly adapted activity level is based on the variables:\\n\\t\\t# temporal_adaptation_mu_eps, temporal_adaptation_sigma_eps, \\n\\t\\t# temporal_adaptation_mu_Ss0. These functions take the activity\\n\\t\\t# level set by these variables at that signal intensity, to \\n\\t\\t# adapt epsilon to the current Ss\\n\\t\\tperfect_adapt_eps_base = sp.ones(self.Mm)*\\\\\\n\\t\\t\\t\\tself.temporal_adaptation_mu_eps + random_matrix(self.Mm, \\n\\t\\t\\t\\tparams=[0, self.temporal_adaptation_sigma_eps], \\n\\t\\t\\t\\tseed=self.seed_eps)\\n\\t\\tperfect_adapt_Ss = sp.zeros(self.Nn)\\n\\t\\tperfect_adapt_Ss[self.Ss0 != 0] = self.temporal_adaptation_mu_Ss0\\n\\t\\tperfect_adapt_Yy = receptor_activity(perfect_adapt_Ss, \\n\\t\\t\\t\\t\\t\\t\\t\\tself.Kk1, self.Kk2, perfect_adapt_eps_base)\\n\\t\\t\\n\\t\\t# Make adaptation rate into a vector if it has not yet been set.\\n\\t\\ttry:\\n\\t\\t\\tself.temporal_adaptation_rate_vector\\n\\t\\texcept AttributeError:\\n\\t\\t\\tassert self.temporal_adaptation_rate_sigma == 0, \\\"Before \\\"\\\\\\n\\t\\t\\t\\t\\\"setting new epsilon with set_temporal_adapted_epsilon, \\\"\\\\\\n\\t\\t\\t\\t\\\"you must call set_ordered_temporal_adaptation_rate, since \\\"\\\\\\n\\t\\t\\t\\t\\\"temporal_adaptation_rate_sigma is nonzero\\\"\\n\\t\\t\\tself.temporal_adaptation_rate_vector = sp.ones(self.Mm)*\\\\\\n\\t\\t\\t\\tself.temporal_adaptation_rate\\n\\t\\t\\n\\t\\tif self.temporal_adaptation_type == 'imperfect':\\n\\t\\t\\td_eps_dt = self.temporal_adaptation_rate_vector*\\\\\\n\\t\\t\\t\\t\\t\\t(self.Yy - perfect_adapt_Yy)\\n\\t\\t\\tdelta_t = self.signal_trace_Tt[1] - self.signal_trace_Tt[0]\\n\\t\\t\\tself.eps += delta_t*d_eps_dt \\n\\t\\telif self.temporal_adaptation_type == 'perfect':\\n\\t\\t\\tself.eps = free_energy(self.Ss, self.Kk1, self.Kk2, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\tperfect_adapt_Yy)\",\n \"def lower_bri(self):\\r\\n for light in self.lights:\\r\\n bri = self.b.get_light(light,'bri')\\r\\n bri = bri - 50\\r\\n if bri < 0:\\r\\n bri = 1\\r\\n self.b.set_light(light,'bri',bri)\",\n \"def fix_elevation(self):\\n selected_segment = \\\\\\n self.controller.shared_data.obj_track.selected_segment_idx\\n segment_idx = selected_segment[0]\\n segment = \\\\\\n self.controller.shared_data.obj_track.get_segment(segment_idx)\\n\\n if len(selected_segment) == 1:\\n if segment.shape[0] > constants.fix_thr:\\n try:\\n self.controller.shared_data.obj_track.fix_elevation(\\n segment_idx)\\n except ValueError:\\n self.controller.shared_data.obj_track.smooth_elevation(\\n segment_idx)\\n else:\\n self.controller.shared_data.obj_track.smooth_elevation(\\n segment_idx)\\n\\n plots.update_plots(\\n self.controller.shared_data.obj_track,\\n self.controller.shared_data.ax_track,\\n self.controller.shared_data.ax_ele,\\n self.controller.shared_data.ax_track_info,\\n canvas=self.controller.shared_data.canvas)\\n\\n elif len(selected_segment) > 1:\\n messagebox.showerror('Warning',\\n 'More than one segment is selected')\\n elif len(selected_segment) == 0:\\n messagebox.showerror('Warning',\\n 'No segment is selected')\",\n \"def altitude_speed(self, degrees = True):\\n return self.angularSpeed(self.future_location.al, self.old_location.al)\",\n \"def _set_tolerances(self, atol=None, rtol=None, maxiter=None):\\n atol = self.atol if atol is None else atol\\n rtol = self.rtol if rtol is None else rtol\\n maxiter = self.maxiter if maxiter is None else maxiter\\n # BUG: PETSc misses rtol requirement by ~10-20X -> Report to petsc4py\\n self.ksp.setTolerances(atol=None, rtol=rtol/50, max_it=maxiter)\",\n \"def altitude_callback(self, data):\\n self.altitude = data\\n self.altitude_bottom_clearance = np.float64(data.bottom_clearance)\\n if np.isnan(self.altitude_bottom_clearance):\\n # message is often enough that it should alert the user but shouldn't swamp the console\\n rospy.logwarn_throttle(0.5, 'bottom clearance is invalid type: {}'.format(self.altitude_bottom_clearance))\",\n \"def test_triangle_get_shortest_altitude(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)\",\n \"def init_patch_clamp(self):\\n\\n self.pressure.nearing()\\n\\n # Auto pipette offset and holding at 0 V\\n self.amplifier.meter_resist_enable(False)\\n self.amplifier.auto_pipette_offset()\\n self.amplifier.set_holding(0.)\\n self.amplifier.set_holding_enable(True)\\n\\n # Begin metering\\n self.amplifier.meter_resist_enable(True)\\n # wait for stable measure\\n time.sleep(4)\\n # Get pipette resistance\\n self.pipette_resistance = self.get_single_resistance_metering(res_type='float')\\n if 5e6 > self.pipette_resistance:\\n self.update_message('ERROR: Tip resistance is too low ({}).'\\n ' Should be higher than 5 MOhm.'.format(self.get_single_resistance_metering('text')))\\n self.amplifier.meter_resist_enable(False)\\n return 0\\n if 10e6 < self.pipette_resistance:\\n self.update_message('ERROR: Tip resistance is too high ({}).'\\n ' Should be lower than 10 MOhm.'.format(self.get_single_resistance_metering('text')))\\n self.amplifier.meter_resist_enable(False)\\n return 0\\n else:\\n self.update_message('Tip resistance is good: {}'.format(self.get_single_resistance_metering('text')))\\n self.pipette_resistance_checked = True\\n self.set_continuous_meter(True)\\n return 1\",\n \"def platform_set_elevation(self, elevation):\\n self.platform.set_elevation(elevation)\",\n \"def test_tolerances__ignore_from_auto_postings(self, entries, errors, options_map):\\n # Interesting case: The Assets leg is filled in with 8.00 USD\\n # automatically here, so it is not used in inference. Further forward,\\n # the split_expenses plugin splits the first leg as well, and that is\\n # also marked as automatic, so if cannot use inference there either. So\\n # all legs end up being automatic... and we have to fall back on the\\n # default tolerance.\",\n \"def shrink(self,altRange=None,aziRange=None):\\n\\n if altRange is None and aziRange is None: raise LookupError('At least one of altRange and aziRange should be defined!')\\n\\n if altRange is not None: indAlt = np.logical_and(self.data['altitude']>=altRange[0],self.data['altitude']<=altRange[1])\\n else: indAlt = np.ones(len(self.data),dtype=np.bool)\\n if aziRange is not None: indAzi = np.logical_and(self.data['azimuth']>=aziRange[0],self.data['azimuth']<=aziRange[1])\\n else: indAzi = np.ones(len(self.data),dtype=np.bool)\\n ind = np.logical_and(indAlt,indAzi)\\n self.data = self.data[ind]\",\n \"def setUncertainty(self, uncertainty):\\n self.uncertainty = uncertainty\",\n \"def _H_correction(self, alt):\\n _H_correction_fast(alt, self.Texo)\",\n \"def setMinMax(self):\\n currentIndustryNum = self.myParent.myIndustry[self.myIndustryData.id]\\n oldIndustryNum = self.myParent.myOldIndustry[self.myIndustryData.id]\\n self.setMinValue(-currentIndustryNum)\\n if oldIndustryNum > currentIndustryNum:\\n self.setMaxValue(oldIndustryNum-currentIndustryNum)\\n elif self.isIndustryResearched() == 0:\\n self.setMaxValue(0)\\n else:\\n max = self.getMaxFromFundsAvail()\\n cityNum = (self.myParent.cities-self.myParent.citiesUsed)/self.myIndustryData.cities\\n if max < cityNum:\\n self.setMaxValue(max)\\n else:\\n self.setMaxValue(cityNum)\",\n \"def initialise_calibration(self):\\n for i in range(0, self.NUM_SENSORS):\\n self.calibratedMax[i] = 0\\n self.calibratedMin[i] = self.READING_TIMEOUT\",\n \"def test_altes(self):\\n ideal = np.array([0.00200822, -0.21928398, 0.66719239, 0.66719239,\\n -0.17666382, -0.17009953, -0.038399, -0.00083597])\\n actual = misc.altes(8, 0.1, 0.5)\\n np.testing.assert_allclose(ideal, actual, atol=1e-8, rtol=1e-8)\",\n \"def _update_rain(self):\\n self.rain.update()\\n self._make_new_drops()\",\n \"def get_altitude(points):\\n altitudes = np.zeros((len(points),), dtype=\\\"float64\\\")\\n for i, point in tqdm(enumerate(points), desc=\\\"GETTING ALTITUDE\\\"):\\n p = Point(point[0], point[1])\\n altitudes[i] = alt.NM_COTA.iloc[\\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\\n ]\\n return altitudes\",\n \"def altitude_profile(self, alt):\\n # checking if the units entered are km\\n if alt.unit == u.km:\\n if 150 <= alt.value < 500:\\n alt_properties = self._altitude_profile(500)\\n else:\\n alt_properties = self._altitude_profile(alt.value)\\n\\n return [last[int(alt.value)] for last in alt_properties]\",\n \"def setCrsEllipsoid(self, a, rf=None):\\n self.isgeographic = True\\n self.ellipsoid_a = a\\n if rf is None:\\n self.ellipsoid_b = a\\n else:\\n self.ellipsoid_b = a * (1.0 - 1.0 / rf)\\n self.a2 = self.ellipsoid_a * self.ellipsoid_a\\n self.b2 = self.ellipsoid_b * self.ellipsoid_b\",\n \"def setFar(self, far):\\n self.light.node().getLens().setFar(far)\",\n \"def set_tolerance(self, tol):\\n self.tolerance = tol\",\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 update_vrad_tolerance_2(self):\\n try:\\n value = float(self.edit_vrad_tolerance_2.text())\\n except:\\n value = None\\n self._get_selected_model().metadata[\\\"velocity_tolerance\\\"] = value\\n return None\",\n \"def is_cruising(altitude, cruise_altitude=None):\\n if cruise_altitude is None:\\n cruise_altitude = closest_cruising_altitude(altitude)\\n return abs(altitude - cruise_altitude) <= 200\",\n \"def _update_initial_guess(self, lower, upper):\\n err_mesg = 'Upper and lower bounds are identical: check solver tols!'\\n assert (upper - lower) / upper > np.finfo('float').eps, err_mesg\\n guess = 0.5 * (lower + upper)\\n return guess\",\n \"def set_default_alt_loc(self, alt_loc):\\n self.default_alt_loc = alt_loc\\n\\n ishift = 0\\n for i, atm in enumerate(self.atom_order_list):\\n if isinstance(atm, Atom):\\n ## case 1: atom has no alt_locs\\n try:\\n self.atom_list[i-ishift] = atm\\n except IndexError:\\n self.atom_list.append(atm)\\n self.atom_dict[atm.name] = atm\\n\\n else:\\n try:\\n atmx = atm[alt_loc]\\n except KeyError:\\n ## case 2: atom has alt_loc partners, but not one\\n ## for this given alt_loc\\n try:\\n del self.atom_list[i-ishift]\\n except IndexError:\\n pass\\n for atmx in atm.itervalues():\\n try:\\n del self.atom_dict[atmx.name]\\n except KeyError:\\n pass\\n break\\n ishift += 1\\n else:\\n ## case 3: atom has alt_loc partners, and one for\\n ## this alt_loc too\\n try:\\n self.atom_list[i-ishift] = atmx\\n except IndexError:\\n self.atom_list.append(atmx)\\n self.atom_dict[atmx.name] = atmx\",\n \"def calc_e_akin(self, ui=None, res_dir=None):\\r\\n print_it(\\\"calculating e_a,kin\\\")\\r\\n pv_local = np.multiply(self.sun.press.sum(1), self.rel_vel)\\r\\n self.sun.e_akin = np.absolute(\\r\\n np.divide(np.multiply(pv_local, self.sun.overroll_t_incr),\\r\\n self.sun.no_overroll_t)) / 1000\\r\\n self.planet.e_akin = np.absolute(\\r\\n np.divide(np.multiply(pv_local, self.planet.overroll_t_incr),\\r\\n self.planet.no_overroll_t)) / 1000\",\n \"def set_contrast_range(self, zmin, zmax):\\n self.get_contrast_panel().set_range(zmin, zmax)\",\n \"def calibrate(self):\\n\\t\\twl = BLi.getWavelength()\\n\\t\\tif abs(self.stokes()) <= .5:\\n\\t\\t\\txxx=self.sign()*180/pi*asin( wl/(2*self.dspace)) - (self.thp())\\n\\t\\t\\tself.offset2(-xxx)\\n\\t\\t\\tyyy=self.tthp()-self.sign()*2*180/pi*asin(wl/(2*self.dspace))-self.offset5()\\n\\t\\t\\tself.offset4(yyy)\\n\\t\\t\\tself.offset9(self.dettrans())\\n\\t\\telif abs(self.stokes()-90.) <= .5:\\n\\t\\t\\txxx=self.sign()*180/pi*asin( wl/(2*self.dspace)) - (self.thp())\\n\\t\\t\\tself.offset3(-xxx)\\n\\t\\t\\tyyy=self.tthp()-self.sign()*2*180/pi*asin(wl/(2*self.dspace))-self.offset5()\\n\\t\\t\\tself.offset8(yyy)\\n\\t\\t\\tself.offset10(self.dettrans())\\n\\t\\telse:\\n\\t\\t\\tprint \\\"Can't calibrate at stokes=\\\",self.stokes()\\n\\t\\treturn [self.sign(),self.offset2(), self.offset3(),self.offset4(),self.offset5(),self.offset8(),self.offset9(),self.offset10()]\",\n \"def test_change_lower(self):\\n instance = self.traits_instance\\n instance.low = -4.0\\n instance.value = -2\\n self.assertAlmostEqual(instance.value, -2)\",\n \"def reset_uncertainties(self):\\n\\n # Make a new temporary ExoParameter using the original self.template\\n # dictionary and copy the uncertainty values.\\n blank = ExoParameter(\\\"fake\\\", attr_dict=self.template)\\n self.uncertainty = blank.uncertainty\\n self.uncertainty_lower = blank.uncertainty_lower\\n self.uncertainty_upper = blank.uncertainty_upper\",\n \"def SetAbsTol(self, atol):\\n return _hypre.HyprePCG_SetAbsTol(self, atol)\",\n \"def diff_of_errors(self):\\n self.e_of_e = self.azimuth_error - self.altitude_error\\n return self.e_of_e\",\n \"def elevation_servo_set_min_max(self, min: int, max: int):\\n self.elevation_servo.set_min_position(min)\\n self.elevation_servo.set_max_position(max)\",\n \"def set_Ec_min(self, x):\\n x = float(x)\\n if self.Ec_min != x:\\n self.Ec_min = x\\n self.Ec[0] = x\",\n \"def auto(self):\\n self.set_thermostat = 1 if self.desired_values[0] > self.data[0] else 0\\n self.set_humidifier = 1 if self.desired_values[1] > self.data[1] else 0\\n self.set_sprinklers = 1 if self.desired_values[2] > self.data[2] else 0\\n self.set_ventilation = 1 if (self.desired_values[3] > self.data[3] or self.desired_values[4] < self.data[4]) else 0\",\n \"def SetMinTolerance(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_Tool_SetMinTolerance(self, *args)\",\n \"def topographic_altitude(self, lat_d, lon_d):\\n return self.altitude(lat_d, lon_d)\",\n \"def topographic_altitude(self, lat_d, lon_d):\\n return self.altitude(lat_d, lon_d)\",\n \"def test_tolerance(self):\\n # With idw no sites within tolerance should result in masked output\\n dset = self.dset.spec.sel(\\n lons=self.lons_inexact, lats=self.lats_inexact, method=\\\"idw\\\", tolerance=1.0\\n )\\n assert dset.spec.hs().values.all()\\n dset = self.dset.spec.sel(\\n lons=self.lons_inexact, lats=self.lats_inexact, method=\\\"idw\\\", tolerance=0.01\\n )\\n assert np.isnan(dset.spec.hs().values).any()\\n # With nearest no sites within tolerance should raise an exception\\n with pytest.raises(AssertionError):\\n dset = self.dset.spec.sel(\\n lons=self.lons_inexact,\\n lats=self.lats_inexact,\\n method=\\\"nearest\\\",\\n tolerance=0.01,\\n )\",\n \"def test_extreme_values(self):\\n with pytest.warns(RuntimeWarning) as warninfo:\\n assert np.exp(laplace_approx(999999, 999999, self.data)) == 0\\n with pytest.warns(RuntimeWarning) as warninfo:\\n assert np.exp(laplace_approx(999999, 999999, self.data)) == 0\",\n \"def altitude(press, altimeter=29.92126):\\n AS = altimeter*inHg2PA\\n print(AS, press**(L*R/g/M))\\n h = -(press**(L*R/g/M) - AS**(L*R/g/M))*T0/L/(P0**(L*R/g/M))\\n return h/ft2m\",\n \"def update(self):\\n if self.temperature != None and self.humidity != None:\\n self.sensor.set_environmental_data(self.humidity, self.temperature)\\n# Trim away error values.\\n new_eco2 = self.sensor.eco2\\n if new_eco2 < 65535:\\n self.eco2 = new_eco2\\n self.tvoc = self.sensor.tvoc\",\n \"def arm_and_takeoff_nogps(aTargetAltitude):\\n\\n print(\\\"Taking of to an altitude of \\\", str(aTargetAltitude))\\n\\n print(\\\"Basic pre-arm checks\\\")\\n\\n while not vehicle.is_armable:\\n print(\\\" Waiting for vehicle to initialise...\\\")\\n time.sleep(1)\\n\\n print(\\\"Arming motors\\\")\\n # Copter should arm in GUIDED_NOGPS mode\\n vehicle.mode = VehicleMode(\\\"GUIDED_NOGPS\\\")\\n vehicle.armed = True\\n\\n while not vehicle.armed:\\n print(\\\" Waiting for arming...\\\")\\n vehicle.armed = True\\n time.sleep(1)\\n\\n print(\\\"Taking off!\\\")\\n\\n thrust = DEFAULT_TAKEOFF_THRUST\\n while True:\\n current_altitude = vehicle.location.global_relative_frame.alt\\n print(\\\" Altitude: %f Desired: %f\\\" %\\n (current_altitude, aTargetAltitude))\\n if current_altitude >= aTargetAltitude*0.95: # Trigger just below target alt.\\n print(\\\"Reached target altitude\\\")\\n break\\n elif current_altitude >= aTargetAltitude*0.6:\\n thrust = SMOOTH_TAKEOFF_THRUST\\n set_attitude(thrust = thrust)\\n time.sleep(0.2)\",\n \"def set_receiver(self, height, elevation, azimuth):\\n\\n if height < 0:\\n raise ValueError(\\\"The height cannot be negative\\\")\\n if elevation < 0 or elevation > 180:\\n raise ValueError(\\\"The elevation cannot be negative or greater 180\\\")\\n if elevation == 90:\\n raise ValueError(\\\"The elevation can not be 90\\\")\\n if azimuth < 0 or azimuth >= 360:\\n raise ValueError(\\\"The azimuth cannot be negative or >= 360\\\")\\n\\n theta, phi = f.convert_direction(elevation, azimuth)\\n\\n idx, height = f.argclosest(f.km2m(height), self.height_array, return_value=True)\\n self.receiver_height = height\\n self.receiver_elevation = theta\\n self.receiver_azimuth = phi\",\n \"def get_altitude(self):\\n self.degrees = self.altitude_encoder.get_degrees()\\n self.tele_altitude = self.Calculations.convert_degrees( self.degrees)\\n return self.tele_altitude\",\n \"def update_newly_set_ref_V_ampl(self):\\n self.qlin_ref_V_ampl_RMS.setText(\\n \\\"%.3f\\\" % self.alia.config.ref_V_ampl_RMS\\n )\\n self.qlin_ref_V_ampl.setText(\\\"%.3f\\\" % self.alia.config.ref_V_ampl)\\n self.qlbl_ref_is_clipping.setText(self.get_clipping_text())\\n # QApplication.processEvents()\\n\\n self.alia_qdev.state.reset()\\n self.clear_curves_stage_1_and_2()\",\n \"def set_lz(self):\\r\\n self._lz = self.dz * self.nz - self.oz\",\n \"def test_triangle_get_longest_altitude(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_longest_altitude(), 9.428090415820634)\",\n \"def find_hypocenter(self):\\n ps_hypo = min(self.pointsources, key=lambda x: x.time_shift)\\n self.hypocenter_longitude = ps_hypo.longitude\\n self.hypocenter_latitude = ps_hypo.latitude\\n self.hypocenter_depth_in_m = ps_hypo.depth_in_m\",\n \"def setTolerances(self, rtol = 1.0e-9,\\n atol = 1.0e-20, rtolsens= -1.0, atolsens = -1.0):\\n _cantera.reactornet_setTolerances(self.__reactornet_id, rtol, atol)\\n _cantera.reactornet_setSensitivityTolerances(self.__reactornet_id, rtolsens, atolsens)\",\n \"def _fix_austrian_lpis(self, eopatch):\\n eopatch.vector_timeless[self.feature] = pd.merge(eopatch.vector_timeless[self.feature],\\n self.mapping,\\n on='SNAR_BEZEI')\",\n \"def elevation(self, elevation):\\n\\n self.container['elevation'] = elevation\",\n \"def set_ascertained(self):\\n\\n # Do the correction if the tree is calibrated, as ascertainment\\n # correction influences timing estimates\\n if self.ascertained == None:\\n self.ascertained = not self.global_config.arbitrary_tree\",\n \"def tolerance(self, tolerance: float) -> None:\\n self._tolerance = tolerance\",\n \"def ecef2LatLonAlt(x, y, z):\\n\\n # Calculate the polar eccentricity\\n ep = np.sqrt((EARTH.EQUATORIAL_RADIUS**2 - EARTH.POLAR_RADIUS**2)/(EARTH.POLAR_RADIUS**2))\\n\\n # Calculate the longitude\\n lon = np.arctan2(y, x)\\n\\n p = np.sqrt(x**2 + y**2)\\n\\n theta = np.arctan2( z*EARTH.EQUATORIAL_RADIUS, p*EARTH.POLAR_RADIUS)\\n\\n # Calculate the latitude\\n lat = np.arctan2(z + (ep**2)*EARTH.POLAR_RADIUS*np.sin(theta)**3, \\\\\\n p - (EARTH.E**2)*EARTH.EQUATORIAL_RADIUS*np.cos(theta)**3)\\n\\n # Get distance from Earth centre to the position given by geographical coordinates, in WGS84\\n N = EARTH.EQUATORIAL_RADIUS/math.sqrt(1.0 - (EARTH.E**2)*math.sin(lat)**2)\\n\\n \\n # Calculate the height in meters\\n\\n # Correct for numerical instability in altitude near exact poles (and make sure cos(lat) is not 0!)\\n if((np.abs(x) < 1000) and (np.abs(y) < 1000)):\\n alt = np.abs(z) - EARTH.POLAR_RADIUS\\n\\n else:\\n # Calculate altitude anywhere else\\n alt = p/np.cos(lat) - N\\n\\n\\n return lat, lon, alt\",\n \"async def _move_altaz(self, alt: float, az: float, abort_event: asyncio.Event) -> None:\\n\\n # alt/az coordinates to ra/dec\\n coords = SkyCoord(\\n alt=alt * u.degree, az=az * u.degree, obstime=Time.now(), location=self.location, frame=\\\"altaz\\\"\\n )\\n icrs = coords.icrs\\n\\n # start slewing\\n await self.__move(icrs.ra.degree, icrs.dec.degree, abort_event)\",\n \"def set_tolerance(self, value):\\n\\n self._tolerance = value\",\n \"def setUp(self):\\n self.upper = 230.0\\n self.lower = 195.0\",\n \"def set_arrive(self):\\n if self._is_disabled_time():\\n log.info(\\\"Home arrive not triggered due disabled time\\\")\\n return\\n\\n for light in ARRIVE_LIGHTS():\\n self.__try_to_run(self._turn_on_light, [light])\\n if self.sunset.is_past_sunset():\\n self.set_arrive_after_sunset()\",\n \"def setNearFar(self, near, far):\\n self.light.node().getLens().setNearFar(near, far)\",\n \"def apply_heuristic_tile_corrections(self):\\n for tile_key in self.wd_stig_corr:\\n g, t = tile_key.split('.')\\n g, t = int(g), int(t)\\n self.gm.adjust_tile_wd(g, t, self.wd_stig_corr[tile_key][0])\\n self.gm.adjust_tile_stig_xy(\\n g, t, *self.wd_stig_corr[tile_key][1:3])\",\n \"def altitude_control(self, altitude_cmd,\\n vertical_velocity_cmd,\\n altitude,\\n vertical_velocity,\\n attitude,\\n acceleration_ff=0.0):\\n \\n hdot_cmd = self.Kp_alt * (altitude_cmd - altitude) + vertical_velocity_cmd\\n \\n # Limit the ascent/descent rate\\n hdot_cmd = np.clip(hdot_cmd, -self.max_descent_rate, self.max_ascent_rate)\\n\\n acceleration_cmd = acceleration_ff + self.Kp_hdot*(hdot_cmd - vertical_velocity)\\n \\n R33 = np.cos(attitude[0]) * np.cos(attitude[1])\\n thrust = DRONE_MASS_KG * acceleration_cmd / R33\\n \\n if thrust > MAX_THRUST:\\n thrust = MAX_THRUST\\n elif thrust < 0.0:\\n thrust = 0.0\\n return thrust\",\n \"def convergence_check(self):\\n air = self.air_alias.val\\n flue_gas = self.fuel_alias.val + '_fg'\\n fuel = self.fuel_alias.val\\n\\n for c in self.outl:\\n if not c.fluid.val_set[air]:\\n if c.fluid.val[air] > 0.95:\\n c.fluid.val[air] = 0.95\\n if c.fluid.val[air] < 0.5:\\n c.fluid.val[air] = 0.5\\n\\n if not c.fluid.val_set[flue_gas]:\\n if c.fluid.val[flue_gas] > 0.5:\\n c.fluid.val[flue_gas] = 0.5\\n if c.fluid.val[flue_gas] < 0.05:\\n c.fluid.val[flue_gas] = 0.05\\n\\n if not c.fluid.val_set[fuel]:\\n if c.fluid.val[fuel] > 0:\\n c.fluid.val[fuel] = 0\\n\\n c.target.propagate_fluid_to_target(c, c.target)\\n\\n for i in self.inl:\\n if i.m.val_SI < 0 and not i.m.val_set:\\n i.m.val_SI = 0.01\\n\\n for c in self.outl:\\n if c.m.val_SI < 0 and not c.m.val_set:\\n c.m.val_SI = 10\\n c.target.propagate_fluid_to_target(c, c.target)\\n\\n if self.lamb.val < 1 and not self.lamb.is_set:\\n self.lamb.val = 2\",\n \"def set_Ec_max(self, x):\\n x = float(x)\\n if self.Ec_max != x:\\n self.Ec_max = x\\n self.Ec[1] = x\",\n \"def add_euler_error(df):\\n df[\\\"T_vehicle_attitude_setpoint_0__NF_e_roll\\\"] = mpd.angle_wrap(\\n df[\\\"T_vehicle_attitude_setpoint_0__F_roll_body\\\"]\\n - df[\\\"T_vehicle_attitude_0__NF_roll\\\"]\\n )\\n df[\\\"T_vehicle_attitude_setpoint_0__NF_e_pitch\\\"] = mpd.angle_wrap(\\n df[\\\"T_vehicle_attitude_setpoint_0__F_pitch_body\\\"]\\n - df[\\\"T_vehicle_attitude_0__NF_pitch\\\"]\\n )\\n df[\\\"T_vehicle_attitude_setpoint_0__NF_e_yaw\\\"] = mpd.angle_wrap(\\n df[\\\"T_vehicle_attitude_setpoint_0__F_yaw_body\\\"]\\n - df[\\\"T_vehicle_attitude_0__NF_yaw\\\"]\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6397559","0.60705537","0.58555746","0.58198625","0.5693789","0.55685645","0.5377789","0.5350137","0.5192501","0.5148783","0.51282614","0.51085854","0.51039815","0.49786505","0.49037406","0.48799503","0.48787838","0.48784757","0.48330465","0.48201117","0.48099634","0.4800165","0.47971594","0.47958562","0.47889027","0.47757047","0.473079","0.4717674","0.4713176","0.47085378","0.47069892","0.47028366","0.4700267","0.469128","0.46912187","0.46830288","0.467064","0.46634644","0.46628803","0.4659539","0.46545038","0.46497622","0.46422926","0.46319258","0.46157017","0.4615235","0.4608651","0.46047932","0.4603889","0.45978868","0.45951056","0.45926797","0.45815068","0.4570915","0.45541224","0.45535856","0.4553071","0.4548362","0.45448637","0.45420295","0.45397165","0.45393768","0.4537974","0.45334598","0.45302823","0.45284623","0.4527838","0.45277303","0.4520079","0.45195174","0.45153657","0.45118538","0.45118538","0.4508477","0.45074648","0.4500222","0.44973576","0.4496912","0.44906622","0.44831237","0.44820246","0.44791952","0.4477916","0.44778404","0.4477669","0.44776136","0.4473638","0.44689006","0.44669402","0.44659418","0.44647136","0.44605893","0.44603395","0.4449372","0.44391492","0.44387463","0.44386935","0.44340646","0.4433797","0.44314623"],"string":"[\n \"0.6397559\",\n \"0.60705537\",\n \"0.58555746\",\n \"0.58198625\",\n \"0.5693789\",\n \"0.55685645\",\n \"0.5377789\",\n \"0.5350137\",\n \"0.5192501\",\n \"0.5148783\",\n \"0.51282614\",\n \"0.51085854\",\n \"0.51039815\",\n \"0.49786505\",\n \"0.49037406\",\n \"0.48799503\",\n \"0.48787838\",\n \"0.48784757\",\n \"0.48330465\",\n \"0.48201117\",\n \"0.48099634\",\n \"0.4800165\",\n \"0.47971594\",\n \"0.47958562\",\n \"0.47889027\",\n \"0.47757047\",\n \"0.473079\",\n \"0.4717674\",\n \"0.4713176\",\n \"0.47085378\",\n \"0.47069892\",\n \"0.47028366\",\n \"0.4700267\",\n \"0.469128\",\n \"0.46912187\",\n \"0.46830288\",\n \"0.467064\",\n \"0.46634644\",\n \"0.46628803\",\n \"0.4659539\",\n \"0.46545038\",\n \"0.46497622\",\n \"0.46422926\",\n \"0.46319258\",\n \"0.46157017\",\n \"0.4615235\",\n \"0.4608651\",\n \"0.46047932\",\n \"0.4603889\",\n \"0.45978868\",\n \"0.45951056\",\n \"0.45926797\",\n \"0.45815068\",\n \"0.4570915\",\n \"0.45541224\",\n \"0.45535856\",\n \"0.4553071\",\n \"0.4548362\",\n \"0.45448637\",\n \"0.45420295\",\n \"0.45397165\",\n \"0.45393768\",\n \"0.4537974\",\n \"0.45334598\",\n \"0.45302823\",\n \"0.45284623\",\n \"0.4527838\",\n \"0.45277303\",\n \"0.4520079\",\n \"0.45195174\",\n \"0.45153657\",\n \"0.45118538\",\n \"0.45118538\",\n \"0.4508477\",\n \"0.45074648\",\n \"0.4500222\",\n \"0.44973576\",\n \"0.4496912\",\n \"0.44906622\",\n \"0.44831237\",\n \"0.44820246\",\n \"0.44791952\",\n \"0.4477916\",\n \"0.44778404\",\n \"0.4477669\",\n \"0.44776136\",\n \"0.4473638\",\n \"0.44689006\",\n \"0.44669402\",\n \"0.44659418\",\n \"0.44647136\",\n \"0.44605893\",\n \"0.44603395\",\n \"0.4449372\",\n \"0.44391492\",\n \"0.44387463\",\n \"0.44386935\",\n \"0.44340646\",\n \"0.4433797\",\n \"0.44314623\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6250826"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":91981,"cells":{"query":{"kind":"string","value":"Classify an altitude profile based on the altitudes."},"document":{"kind":"string","value":"def classify_altitude_profile(altitudes):\n max_alt = altitudes.max()\n has_climb = (max_alt > altitudes[0])\n has_descent = (max_alt > altitudes[-1])\n\n if has_climb or has_descent:\n if has_climb != has_descent:\n return AltitudeProfileType.CLIMBING if has_climb \\\n else AltitudeProfileType.DESCENDING\n else:\n return AltitudeProfileType.CLIMBING_AND_DESCENDING\n else:\n return AltitudeProfileType.CRUISING"},"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 altitude_profile(self, alt):\n # checking if the units entered are km\n if alt.unit == u.km:\n if 150 <= alt.value < 500:\n alt_properties = self._altitude_profile(500)\n else:\n alt_properties = self._altitude_profile(alt.value)\n\n return [last[int(alt.value)] for last in alt_properties]","def create_altitude_profile(self, max_altitude=32, exponential_constant=0.05, ground_altitude=6, timespan=30,\n timestep=1 / 60):\n x_time = np.arange(0, timespan, timestep)\n y_target_profile = max_altitude * np.exp(-exponential_constant * x_time) + ground_altitude\n return x_time, y_target_profile","def altitude(self):\n if self.__altitude:\n return sum(self.__altitude) / len(self.__altitude)\n else:\n return -9999","def getAltitudeProfile(pass_length,terrain,uav_altitude,u,start_v,wind_angle):\n altitude_profile = []\n v = start_v\n for k in range(0,round(pass_length)):\n coord = convertCoords([[u,v]],wind_angle,'xy')\n x = coord[0][0]\n y = coord[0][1]\n x_points = [int(x),int(x),int(x)+1,int(x)+1]\n y_points = [int(y),int(y)+1,int(y)+1,int(y)]\n z_points = [terrain[int(y)][int(x)],terrain[int(y)+1][int(x)],\n terrain[int(y)+1][int(x)+1],terrain[int(y)][int(x)+1]]\n\n # For created terrain ONLY\n z = griddata((x_points,y_points),z_points,(x,y)) # Interpolate \n altitude = z + uav_altitude\n\n altitude_profile.append(altitude)\n v +=1\n return altitude_profile","def altitude(self):\r\n pressure = self.pressure # in Si units for hPascal\r\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))","def altitude(self, value: int):\n self._point.altitude = value","def filter_altitude(self, gps_data, setting=None, threshold=None):\n\n # New filter settings if provided\n if setting is not None:\n self.gps_altitude_filter = setting\n if setting == 'Manual':\n self.gps_altitude_filter_change = threshold\n\n # Set threshold for Auto\n if self.gps_altitude_filter == 'Auto':\n self.gps_altitude_filter_change = 3\n\n # Set all data to valid\n self.valid_data[3, :] = True\n # self.valid_data[5, :] = True\n\n # Manual or Auto is selected, apply filter\n if not self.gps_altitude_filter == 'Off':\n # Initialize variables\n num_valid_old = np.sum(self.valid_data[3, :])\n k = 0\n change = 1\n # Loop until no change in the number of valid ensembles\n while k < 100 and change > 0.1:\n # Compute mean using valid ensembles\n alt_mean = np.nanmean(gps_data.altitude_ens_m[self.valid_data[1, :]])\n\n # Compute difference for each ensemble\n diff = np.abs(gps_data.altitude_ens_m - alt_mean)\n\n # Mark invalid those ensembles with differences greater than the change threshold\n self.valid_data[3, diff > self.gps_altitude_filter_change] = False\n k += 1\n num_valid = np.sum(self.valid_data[3, :])\n change = num_valid_old - num_valid\n\n # Combine all filter data to composite valid data\n self.valid_data[0, :] = np.all(self.valid_data[1:, :], 0)\n self.num_invalid = np.sum(self.valid_data[0, :] == False)","def process_driver_altitude(coordinate: Coordinate) -> ProcessDescription:\n city = get_city_by_coordinates(\n latitude=coordinate.latitude,\n longitude=coordinate.longitude,\n )\n city_coordinates = CITIES_COORDINATES_MAP.get(city)\n if not city_coordinates:\n return ProcessDescription(\n detect=False,\n description='Invalid city coordinates.'\n )\n\n altitude_min = city_coordinates['altitude_min']\n altitude_max = city_coordinates['altitude_max']\n\n if altitude_min <= coordinate.altitude <= altitude_max:\n return ProcessDescription(\n detect=False,\n description=(\n f'Driver altitude {coordinate.altitude} '\n f'is normal for city {city.capitalize()}.'\n )\n )\n\n return ProcessDescription(\n detect=True,\n description=(\n f'Driver has incorrect altitude {coordinate.altitude} '\n f'for city {city.capitalize()}.'\n )\n )","def set_altitude(self):\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\n print('altitude set to', self.altitude)\n if self.altitude < 0:\n self.altitude = self.altitude + 360.0\n return self.altitude \n else: \n pass\n return self.altitude","def altitude(self) -> int:\n return self._point.altitude","def setTargetAltitude(altitude):\n return RoboCaller().call(\"setTargetAltitude\", \"void\", altitude)","def topographic_altitude(self, lat_d, lon_d):\n return self.altitude(lat_d, lon_d)","def topographic_altitude(self, lat_d, lon_d):\n return self.altitude(lat_d, lon_d)","def topographic_altitude(lat, lon):\n global __model\n type_output = type(lat)\n lat = prepare_input_array(lat)\n lon = prepare_input_array(lon)\n lon = np.mod(lon, 360)\n val = __model.topographic_altitude(lat, lon)\n val = np.maximum(val, 1e-7)\n return prepare_output_array(val, type_output) * u.km","def altitude_control(self, altitude_cmd,\n vertical_velocity_cmd,\n altitude,\n vertical_velocity,\n attitude,\n acceleration_ff=0.0):\n \n hdot_cmd = self.Kp_alt * (altitude_cmd - altitude) + vertical_velocity_cmd\n \n # Limit the ascent/descent rate\n hdot_cmd = np.clip(hdot_cmd, -self.max_descent_rate, self.max_ascent_rate)\n\n acceleration_cmd = acceleration_ff + self.Kp_hdot*(hdot_cmd - vertical_velocity)\n \n R33 = np.cos(attitude[0]) * np.cos(attitude[1])\n thrust = DRONE_MASS_KG * acceleration_cmd / R33\n \n if thrust > MAX_THRUST:\n thrust = MAX_THRUST\n elif thrust < 0.0:\n thrust = 0.0\n return thrust","def get_altitude(self):\n self.degrees = self.altitude_encoder.get_degrees()\n self.tele_altitude = self.Calculations.convert_degrees( self.degrees)\n return self.tele_altitude","def pressure(altitude):\n t = temperature(altitude) # R\n if altitude <= 36152:\n p = 2116*(t/518.6)**5.256 # psf\n else:\n p = 473.1*exp(1.73-0.000048*altitude) # psf\n return p","def get_air_density(self, altitude):\n\n altitude /= 1000 # convert to kilometers\n\n return self.get_air_density_from_model(altitude)","def altitude_to_pressure(alt):\n for i in range(len(_heights)-1,0,-1):\n h0 = _heights[i]\n T0 = _basetemps[i]\n if alt > h0:\n if _isotherm[i]:\n rP = math.exp(-_g / _R / T0 * (alt - h0))\n else:\n l0 = _lapsert[i]\n rP = math.pow(1 + (alt - h0) * l0 / T0, -_g / _R / l0)\n return _basepress[i] * rP\n l0 = _lapsert[0]\n return _stdpres * math.pow(1 + alt * l0 / _stdtemp, -_g / _R / l0)","def get_altitude(points):\n altitudes = np.zeros((len(points),), dtype=\"float64\")\n for i, point in tqdm(enumerate(points), desc=\"GETTING ALTITUDE\"):\n p = Point(point[0], point[1])\n altitudes[i] = alt.NM_COTA.iloc[\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\n ]\n return altitudes","def read_altitude(self, meanSeaLevelPressureInBar):\n phPa = self.read_pressure() / 100.0\n\n return float(44330.0 * (1.0 - math.pow((phPa / meanSeaLevelPressureInBar), 0.1903)))","def read_altitude(self, meanSeaLevelPressureInBar):\n phPa = self.read_pressure() / 100.0\n\n return float(44330.0 * (1.0 - math.pow((phPa / meanSeaLevelPressureInBar), 0.1903)))","def altitude_callback(self, data):\n self.altitude = data\n self.altitude_bottom_clearance = np.float64(data.bottom_clearance)\n if np.isnan(self.altitude_bottom_clearance):\n # message is often enough that it should alert the user but shouldn't swamp the console\n rospy.logwarn_throttle(0.5, 'bottom clearance is invalid type: {}'.format(self.altitude_bottom_clearance))","def offset_to_altaz(xoff, yoff, azimuth, altitude):\n #Deal with situations where offset = 0?\n\n d = sqrt(xoff*xoff+yoff*yoff)\n pos = np.where(d==0)\n d=1e-12 * u.deg # add a very small offset to prevent math errors\n\n q = arctan(d.to(u.rad).value)\n\n sq = sin(q)\n xp1 = xoff * (sq/d)\n yp1 = yoff * (sq/d)\n zp1 = cos(q)\n\n cx = sin(altitude)\n sx = cos(altitude)\n\n xp0 = cx*xp1 - sx*zp1\n yp0 = yp1\n zp0 = sx*xp1 + cx*zp1\n\n obj_altitude = arcsin(zp0)\n obj_altitude[pos]=altitude\n obj_azimuth = arctan2(yp0,-xp0) + azimuth\n obj_azimuth[pos] = azimuth\n\n #if obj_azimuth.value < 0.:\n # obj_azimuth += 2.*pi\n #elif obj_azimuth.value >= (2.*pi ):\n # obj_azimuth -= 2.*pi\n\n return obj_altitude,obj_azimuth","def pressure_to_altitude(pres):\n for i in range(len(_heights)-1,0,-1):\n P0 = _basepress[i]\n T0 = _basetemps[i]\n if pres < P0:\n if _isotherm[i]:\n dh = _R * T0 / _g * math.log(P0 / pres)\n else:\n l0 = _lapsert[i]\n dh = T0 / l0 * (math.pow(pres / P0, -l0 * _R / _g) - 1)\n return _heights[i] + dh\n l0 = _lapsert[0]\n return _stdtemp / l0 * (math.pow(pres / _stdpres, -l0 * _R / _g) - 1)","def temperature(self, alt):\n T = self.altitude_profile(alt)[1]\n return T","def test_triangle_get_shortest_altitude(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)","def sim_altitude(a):\n a.takeoff()\n for i in range(20):\n b = a.refresh()\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() + 3)\n print a.altitude.get_altitudes(), b\n a.land()\n a.motor.set_speed(2000.0)\n for i in range(20):\n b = a.refresh()\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() - 3)\n print a.altitude.get_altitudes(), b","def temperature(altitude):\n if altitude <= 36152:\n t = 59-0.00356*altitude # deg F\n else:\n t = -70 # deg F\n t = t + 459.7 # R\n return t","def check_altitude_at(self, altim, coords, altitude_bounds):\n altitude = altim.mesh.point_altitude(coords)\n self.assertWithin(altitude, *altitude_bounds)","def test_triangle_get_longest_altitude(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_longest_altitude(), 9.428090415820634)","def get_user_sector_altitude_range(db_id):\n found, sector = user_sector_finder(\"id\", int(db_id))\n if found:\n return (sector[0]['min_altitude'], sector[0]['max_altitude'])\n else:\n raise NotFoundException(db_id, \"User sector not found.\")","def altitude(press, altimeter=29.92126):\n AS = altimeter*inHg2PA\n print(AS, press**(L*R/g/M))\n h = -(press**(L*R/g/M) - AS**(L*R/g/M))*T0/L/(P0**(L*R/g/M))\n return h/ft2m","def ClassificationAccuracy(Class=[7], folds = 20, neighbours = 25):\n S, dig = CreateDS_Torus_Digits(Class)\n i = 0\n\n Digit_isomap_embed = Isomap(dig[i][0], 2, neighbours)\n Digit_LLE_embed = LLE(dig[i][0], 2, neighbours)\n clf = SVC()\n Accuracies_ISOMAP = cross_val_score(clf,Digit_isomap_embed,dig[i][1], cv=folds)\n Accuracies_LLE = cross_val_score(clf,Digit_LLE_embed,dig[i][1], cv=folds)\n\n print('The mean accuracy is:')\n print('ISOMAPPING {:.3f}'.format(np.mean(Accuracies_ISOMAP)))\n print('LLE {:.3f}'.format(np.mean(Accuracies_LLE)))","def closest_cruising_altitude(altitude):\n return 1000 * ((altitude + 500) // 1000)","def classify(self, ep):\n # just here for defining the interface; work is done in subclasses\n pass","def set_cruise_altitudes(altitudes, cruise_indicies):\n if cruise_indicies:\n for index in range(0, len(cruise_indicies), 2):\n start = cruise_indicies[index]\n stop = cruise_indicies[index + 1]\n if start < stop:\n cruise_altitude = closest_cruising_altitude(altitudes[start])\n altitudes[start] = cruise_altitude\n altitudes[stop] = cruise_altitude\n\n return altitudes","def altitude_range(self, start_distance, finish_distance):\n start_index, start_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n\n min_alt = min(start_alt, finish_alt)\n max_alt = max(start_alt, finish_alt)\n\n if start_index < finish_index:\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\n min_alt = min(min_alt, altitudes.min())\n max_alt = max(max_alt, altitudes.max())\n\n return min_alt, max_alt","def viscosity(altitude):\n t_ref = temperature(0) # R\n t = temperature(altitude) # R\n s = 198.72 # R\n mu_ref = 3.737 * 10 ** (-7) # [slug/(ft*s)]\n mu = mu_ref*((t/t_ref)**(3/2))*(t_ref + s)/(t + s) # [slug/(ft*s)]\n return mu","def add_altitude():\n\n doc = Metashape.app.document\n if not len(doc.chunks):\n raise Exception(\"No chunks!\")\n\n # alt = Metashape.app.getFloat(\"Please specify the height to be added:\", 100)\n alt = float(sys.argv[1])\n\n\n chunk = doc.chunk\n\n for camera in chunk.cameras:\n if camera.reference.location:\n coord = camera.reference.location\n camera.reference.location = Metashape.Vector([coord.x, coord.y, coord.z + alt])\n print(\"Add : \"+str(sys.argv[1]))","def get_elementary_airspace_altitude_range(db_id):\n connection = get_geo_db_connection()\n sector = find_sector(db_id, connection)\n if (sector):\n return (sector['min_altitude'], sector['max_altitude'])\n else:\n raise NotFoundException(db_id, \"Elementary sector not found.\")","def get_altitude(self):\n return self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_GET_ALTITUDE, (), '', 'i')","def pressure(self, alt):\n alt_profile = self.altitude_profile(alt)\n T, number_density = alt_profile[1], alt_profile[8]\n\n # using eqn(42) of COESA76\n pressure = number_density * k * T\n return pressure","def isa(h):\n if np.any((h<0)|(h>11000)):\n print (\"The altitude must be between 0m and 11000m\")\n return \"Returning a string to cause errors later\"\n T = T0 + -0.0065*h\n p = p0*(T/T0)**(-g0/(-0.0065*R))\n rho = p/(R*T)\n return T,p,rho","def createTerraces(u,v,altitude_profile,wind_angle,pass_length,image_passes,max_alt_diff,min_terrace_len):\n # Create terraces from pass\n current_terrace = [] # Initilise current terrace points as empty\n average_alt = 0 # Store the average altitude\n if len(altitude_profile) > 0: # If there is some altitude data for this pass\n max_altitude = np.max(altitude_profile)\n min_altitude = np.min(altitude_profile)\n if max_altitude - min_altitude < max_alt_diff: # If the entire pass is within the altitude limits\n # Find the mean altitude\n for i in range(0,len(altitude_profile)):\n average_alt += altitude_profile[i]\n average_alt = average_alt/len(altitude_profile)\n terrace_start = (u,v,average_alt)\n terrace_end = (u,v+pass_length,average_alt)\n\n coords = convertCoords([[terrace_start[0],terrace_start[1]]],wind_angle,'xy')\n terrace_start = (coords[0][0],coords[0][1],average_alt)\n\n coords = convertCoords([[terrace_end[0],terrace_end[1]]],wind_angle,'xy')\n terrace_end = (coords[0][0],coords[0][1],average_alt)\n\n image_passes.append(Image_Pass(terrace_start,terrace_end,average_alt,wind_angle))\n else:\n # Calculate terraces\n index = 0\n\n current_altitude = 0\n current_min_altitude = 0\n current_max_altitude = 0\n while index < len(altitude_profile):\n if index + 3 > len(altitude_profile):\n if current_altitude == 0:\n for alt in range(0,2):\n current_altitude += altitude_profile[index+alt]\n current_altitude = current_altitude/3\n for val in range(0,3):\n current_terrace.append([x,y,current_altitude])\n # Add all to current pass\n terrace_start = current_terrace[0]\n terrace_end = current_terrace[len(current_terrace)-1]\n image_passes.append(Image_Pass(terrace_start,terrace_end,current_altitude,wind_angle))\n break\n\n if len(current_terrace) == 0:\n # Look ahead to find gradient\n grad = altitude_profile[index+1] - altitude_profile[index]\n grad += altitude_profile[index+2] - altitude_profile[index]\n #grad += altitude_profile[index+3] - altitude_profile[index]\n grad = grad/2\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\n x = coords[0][0]\n y = coords[0][1]\n if grad > 0:\n current_altitude = altitude_profile[index]+max_alt_diff/2\n current_terrace.append([x,y,current_altitude])\n elif grad < 0:\n current_altitude = altitude_profile[index]-max_alt_diff/2\n current_terrace.append([x,y,current_altitude])\n else:\n current_altitude = altitude_profile[index]\n current_terrace.append([x,y,current_altitude])\n current_min_altitude = current_altitude - max_alt_diff/2\n current_max_altitude = current_altitude + max_alt_diff/2\n\n else:\n # Add to the terrace\n if altitude_profile[index] > current_min_altitude and altitude_profile[index] < current_max_altitude:\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\n x = coords[0][0]\n y = coords[0][1]\n current_terrace.append([x,y,current_altitude])\n elif altitude_profile[index+1] > current_min_altitude and altitude_profile[index+1] < current_max_altitude:\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\n x = coords[0][0]\n y = coords[0][1]\n current_terrace.append([x,y,current_altitude])\n index += 1\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\n x = coords[0][0]\n y = coords[0][1]\n current_terrace.append([x,y,current_altitude])\n elif altitude_profile[index+2] > current_min_altitude and altitude_profile[index+2] < current_max_altitude:\n for val in range(0,2):\n coords = convertCoords([[u,v+index+val]],wind_angle,'xy')\n x = coords[0][0]\n y = coords[0][1]\n current_terrace.append([x,y,current_altitude])\n index += 1\n index -= 1\n else:\n if len(current_terrace) > min_terrace_len:\n # Create new terrace\n terrace_start = current_terrace[0]\n terrace_end = current_terrace[len(current_terrace)-1]\n image_passes.append(Image_Pass(terrace_start,terrace_end,current_altitude,wind_angle))\n current_terrace = []\n current_altitude = 0\n else:\n # Requires more image locations\n print(\"Not long enough\")\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\n x = coords[0][0]\n y = coords[0][1]\n current_terrace.append([x,y,current_altitude])\n #current_max_altitude += max_alt_diff/2\n #current_min_altitude -+ max_alt_diff/2\n\n index += 1\n else:\n pass\n return image_passes","def getAltitudeAngle(self):\n return self._altitude","def classifier(self):\n\n print \"Starting Classification\"\n self.detections.rotationClass = [ self.detections.rotationTimeTags[index] for index, theta in enumerate(self.detections.rotations) if theta > 30]\n if len(self.detections.rotationClass) < 1:\n print \"Too little rotation hits\"\n self.detections.classification = \"Too little rotation hits\"\n\n else:\n \n for attribute, value in classIterator(self.detections):\n print value[1]\n if 'crease' in attribute:\n \n if value[1] > self.detections.rotationClass[0] and value[1] < self.detections.rotationClass[-1]:\n print \"direct hit\", attribute, value[1]\n self.detections.classification = \"Direct hit\"\n #if self.detections.\n else:\n for angleStamp in self.detections.rotationClass:\n if secondsCount(value[1],angleStamp).total_seconds < 10:\n self.detections.classification = \"Near miss\"\n \n else:\n self.detections.classification = \"Nothing impressive\"\n print \"Ending Classification\"","def intersection_distances(self, altitude, start_distance, finish_distance):\n distances = []\n alt_index, alt_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, alt_index, alt_ratio)\n\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n while alt_index < finish_index:\n next_index = alt_index + 1\n next_ratio = 0.0\n next_alt = calculate_value(self.altitudes, next_index, next_ratio)\n\n # Does this section span the given altitude?\n if (next_alt != start_alt) and \\\n (min(start_alt, next_alt) < altitude < max(start_alt, next_alt)):\n delta = altitude - start_alt\n denom = next_alt - start_alt\n ratio = delta / denom\n distance = calculate_value(self.distances, alt_index, ratio)\n distances.append(distance)\n\n alt_index = next_index\n alt_ratio = next_ratio\n start_alt = next_alt\n\n if finish_ratio:\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n # Does the last section span the given altitude?\n if (start_alt != finish_alt) and \\\n (min(start_alt, finish_alt) < altitude < max(start_alt, finish_alt)):\n # Calculate the altitude at the end of the section to maximimse accuracy\n next_alt = calculate_value(self.altitudes, finish_index, 1.0)\n delta = altitude - start_alt\n denom = next_alt - start_alt\n ratio = delta / denom\n distance = calculate_value(self.distances, alt_index, ratio)\n distances.append(distance)\n\n return distances","def ecef2LatLonAlt(x, y, z):\n\n # Calculate the polar eccentricity\n ep = np.sqrt((EARTH.EQUATORIAL_RADIUS**2 - EARTH.POLAR_RADIUS**2)/(EARTH.POLAR_RADIUS**2))\n\n # Calculate the longitude\n lon = np.arctan2(y, x)\n\n p = np.sqrt(x**2 + y**2)\n\n theta = np.arctan2( z*EARTH.EQUATORIAL_RADIUS, p*EARTH.POLAR_RADIUS)\n\n # Calculate the latitude\n lat = np.arctan2(z + (ep**2)*EARTH.POLAR_RADIUS*np.sin(theta)**3, \\\n p - (EARTH.E**2)*EARTH.EQUATORIAL_RADIUS*np.cos(theta)**3)\n\n # Get distance from Earth centre to the position given by geographical coordinates, in WGS84\n N = EARTH.EQUATORIAL_RADIUS/math.sqrt(1.0 - (EARTH.E**2)*math.sin(lat)**2)\n\n \n # Calculate the height in meters\n\n # Correct for numerical instability in altitude near exact poles (and make sure cos(lat) is not 0!)\n if((np.abs(x) < 1000) and (np.abs(y) < 1000)):\n alt = np.abs(z) - EARTH.POLAR_RADIUS\n\n else:\n # Calculate altitude anywhere else\n alt = p/np.cos(lat) - N\n\n\n return lat, lon, alt","def air_density(altitude):\n p = pressure(altitude) # psf\n t = temperature(altitude) # R\n rho = p/(gas_constant*t) # lb/ft3\n return rho","def adience_resolve_class_label(age):\n if age == '(0, 2)' or age == '2':\n age_id = 0\n elif age == '(4, 6)' or age == '3':\n age_id = 1\n elif age == '(8, 12)' or age == '(8, 23)' or age == '13':\n age_id = 2\n elif age == '(15, 20)' or age == '22':\n age_id = 3\n elif age == '(25, 32)' or age == '(27, 32)' or age in ['23', '29', '34', '35']:\n age_id = 4\n elif age == '(38, 42)' or age == '(38, 43)' or age == '(38, 48)' or age in ['36', '42', '45']:\n age_id = 5\n elif age == '(48, 53)' or age in ['46', '55']:\n age_id = 6\n elif age == '(60, 100)' or age in ['57', '58']:\n age_id = 7\n else:\n raise ValueError(\"Not sure how to handle this age: {}\".format(age))\n\n return age_id","def get_altitude(self, degrees=True):\n if degrees:\n return math.degrees(self.current_location.al)\n else:\n return self.current_location.al","def classify(trainX, trainY, testX, testY):\n trainC = getClasses(trainY)\n P = estimatePosterior(trainX, trainC, testX)\n E = fit(testX, P)\n (e_rate, se, interval) = error.confidenceInterval(testY, E)\n return (P, E, e_rate, se, interval)","def impact_prediction(\n radius: float,\n target_altitude: float,\n vertical_speed: float,\n horizontal_speed: float,\n surface_gravity: float,\n ut: float,\n):\n fall_speed = -vertical_speed\n downward_acceleration = (\n surface_gravity - horizontal_speed * horizontal_speed / radius\n )\n\n # do we already landed?\n if target_altitude < 0:\n return None, None\n\n # do we land?\n if downward_acceleration < 0:\n max_fall_distance = -(fall_speed * fall_speed) / (\n 2.0 * downward_acceleration\n )\n if max_fall_distance < (target_altitude + 1.0):\n return None, None\n\n sec_until_impact = (\n -fall_speed\n + math.sqrt(\n fall_speed * fall_speed\n + 2.0 * downward_acceleration * target_altitude\n )\n ) / downward_acceleration\n\n vertical_speed_at_impact = (\n fall_speed + sec_until_impact * downward_acceleration\n )\n impact_speed = math.sqrt(\n vertical_speed_at_impact * vertical_speed_at_impact\n + horizontal_speed * horizontal_speed\n )\n impact_ut = sec_until_impact + ut\n return impact_ut, impact_speed","def ap_per_class(tp, conf, pred_cls, target_cls, plot=False, save_dir='.', names=()):\n\n # Sort by objectness\n i = np.argsort(-conf)\n tp, conf, pred_cls = tp[i], conf[i], pred_cls[i]\n\n # Find unique classes\n unique_classes = np.unique(target_cls)\n nc = unique_classes.shape[0] # number of classes, number of detections\n\n # Create Precision-Recall curve and compute AP for each class\n px, py = np.linspace(0, 1, 1000), [] # for plotting\n ap, p, r = np.zeros((nc, tp.shape[1])), np.zeros((nc, 1000)), np.zeros((nc, 1000))\n for ci, c in enumerate(unique_classes):\n i = pred_cls == c\n n_l = (target_cls == c).sum() # number of labels\n n_p = i.sum() # number of predictions\n\n if n_p == 0 or n_l == 0:\n continue\n else:\n # Accumulate FPs and TPs\n fpc = (1 - tp[i]).cumsum(0)\n tpc = tp[i].cumsum(0)\n\n # Recall\n recall = tpc / (n_l + 1e-16) # recall curve\n r[ci] = np.interp(-px, -conf[i], recall[:, 0], left=0) # negative x, xp because xp decreases\n\n # Precision\n precision = tpc / (tpc + fpc) # precision curve\n p[ci] = np.interp(-px, -conf[i], precision[:, 0], left=1) # p at pr_score\n\n # AP from recall-precision curve\n for j in range(tp.shape[1]):\n ap[ci, j], mpre, mrec = compute_ap(recall[:, j], precision[:, j])\n if plot and j == 0:\n py.append(np.interp(px, mrec, mpre)) # precision at mAP@0.5\n\n # Compute F1 (harmonic mean of precision and recall)\n f1 = 2 * p * r / (p + r + 1e-16)\n\n i = f1.mean(0).argmax() # max F1 index\n return p[:, i], r[:, i], ap, f1[:, i], unique_classes.astype('int32')","def add_altitude(chunk, flightHeightFile): \n # Get the flight height\n try:\n # flightHeightFile = \"/SNOWDATA/SnowDrones-Processing/LDP/01-31-2020/RGB/100MEDIA/FlightHeight.txt\"\n with open(flightHeightFile , 'r') as myfile:\n data = myfile.read()\n alt = int(data)\n except:\n alt = int(55)\n\n # Update flight altitudes\n for camera in chunk.cameras:\n if camera.reference.location:\n coord = camera.reference.location\n camera.reference.location = PhotoScan.Vector([coord.x, coord.y, alt])","def alpha_profiles(image, attribute, adjacency=4,\n image_name=None, filtering_rule='direct'):\n atree = trees.AlphaTree(image, adjacency, image_name)\n return create_profiles(atree, attribute, 'altitude', filtering_rule, 'alpha profiles')","def calibrateElevation(self,elevation):\n if len(self.values) == self.values.maxlen:\n self.elevcomp = self.value / ((1.0 - ((elevation + self.heightAboveGround) * 0.3048 / 44330.0)) ** 5.255)\n self.calibrated = True\n else:\n self.calibratedElevation = elevation","def __init__(self,\n\t MAX_ALTITUDE: int,\n\t priority: int,\n\t channels: List[int],\n\t kP: float = 0.002,\n\t kI: float = 0.0,\n\t kD: float = 0.00085,\n\t available = False\n\t ):\n\t\tself._altHoldController = AltitudeController(kP=kP, kI=kI, kD=kD)\n\t\tself._altH_priority = priority\n\t\tself._altH_channels = channels\n\t\tself._altHoldController.setAvailability(available)\n\t\tself._altH_checkAvMethod = self._altHoldController.isAvailable\n\t\tself._altH_getLockMethod = self._altHoldController.getLock\n\t\tself._taking_off = True\n\t\tself._landing = False\n\t\tself._actual_alt = 0\n\t\tself._MAX_ALTITUDE = MAX_ALTITUDE\n\t\tself._last_call = time.time()\n\t\tself._ready_to_fly = False","def eval(self):\n target_truth_labels = self.get_target_labels()\n for key in self.id_uncertainty_measures.keys():\n # deep copy needed as we mutate confidence values later on\n decision_fn_value = np.concatenate((copy.deepcopy(self.id_uncertainty_measures[key]),\n copy.deepcopy(self.ood_uncertainty_measures[key])),\n axis=0)\n # negation needed for confidence, as confidence is indicator of label=0 samples\n # i.e for correct classified samples.\n # But we need scores for label=1 samples i.e misclassified samples\n # to be higher, so we negate.\n if key == UncertaintyMeasuresEnum.CONFIDENCE or key == UncertaintyMeasuresEnum.PRECISION:\n decision_fn_value *= -1.0\n\n aupr, auroc = ClassifierPredictionEvaluator.compute_pr_roc_curves(\n decision_fn_value, target_truth_labels, self.result_dir, key._value_)\n\n with open(os.path.join(self.result_dir, 'results.txt'), 'a') as f:\n f.write('AUPR using ' + key._value_ + \": \" +\n str(np.round(aupr * 100.0, 1)) + '\\n')\n f.write('AUROC using ' + key._value_ + \": \" +\n str(np.round(auroc * 100.0, 1)) + '\\n')","def __init__(self, type, high_elevation, low_elevation):\n\t\tself.type = type\n\t\tself.high_elevation = high_elevation\n\t\tself.low_elevation = low_elevation\n\t\tself.occupant = 0 # use 0 to initilize tile which \n\t\t\t\t\t\t\t# means it has not been explored.\n\t\tif type == \"plains\": # initialize the shade\n\t\t\tself.terrain = \" \"\n\t\telse:\n\t\t\tself.terrain = \"#\"","def arm_and_takeoff_nogps(aTargetAltitude):\n\n print(\"Taking of to an altitude of \", str(aTargetAltitude))\n\n print(\"Basic pre-arm checks\")\n\n while not vehicle.is_armable:\n print(\" Waiting for vehicle to initialise...\")\n time.sleep(1)\n\n print(\"Arming motors\")\n # Copter should arm in GUIDED_NOGPS mode\n vehicle.mode = VehicleMode(\"GUIDED_NOGPS\")\n vehicle.armed = True\n\n while not vehicle.armed:\n print(\" Waiting for arming...\")\n vehicle.armed = True\n time.sleep(1)\n\n print(\"Taking off!\")\n\n thrust = DEFAULT_TAKEOFF_THRUST\n while True:\n current_altitude = vehicle.location.global_relative_frame.alt\n print(\" Altitude: %f Desired: %f\" %\n (current_altitude, aTargetAltitude))\n if current_altitude >= aTargetAltitude*0.95: # Trigger just below target alt.\n print(\"Reached target altitude\")\n break\n elif current_altitude >= aTargetAltitude*0.6:\n thrust = SMOOTH_TAKEOFF_THRUST\n set_attitude(thrust = thrust)\n time.sleep(0.2)","def eval_det(pred_all, gt_all, ovthresh=0.25, use_07_metric=False):\n pred = {} # map {classname: pred}\n gt = {} # map {classname: gt}\n for img_id in pred_all.keys():\n for classname, bbox, score in pred_all[img_id]:\n if classname not in pred: pred[classname] = {}\n if img_id not in pred[classname]:\n pred[classname][img_id] = []\n if classname not in gt: gt[classname] = {}\n if img_id not in gt[classname]:\n gt[classname][img_id] = []\n pred[classname][img_id].append((bbox,score))\n for img_id in gt_all.keys():\n for classname, bbox in gt_all[img_id]:\n if classname not in gt: gt[classname] = {}\n if img_id not in gt[classname]:\n gt[classname][img_id] = []\n gt[classname][img_id].append(bbox)\n\n rec = {}\n prec = {}\n ap = {}\n for classname in gt.keys():\n print('Computing AP for class: ', classname)\n rec[classname], prec[classname], ap[classname] = eval_det_cls(pred[classname], gt[classname], ovthresh, use_07_metric)\n print(classname, ap[classname])\n \n return rec, prec, ap","def create_profiles(tree, attribute, out_feature='altitude',\n filtering_rule='direct', profiles_name='unknow'):\n data = []\n description = []\n\n # Create Trees\n try:\n if isinstance(tree, trees.Tree):\n # Dual tree\n ndual = False\n thinning_tree = None\n thickening_tree = tree\n else:\n # Non dual trees\n ndual = True\n thinning_tree = tree[0]\n thickening_tree = tree[1]\n except:\n raise TypeError('Parameter tree_type must be a tuple or a single' \\\n ' instance of Tree, not {}'.format(tree))\n\n out_features = (out_feature, ) if isinstance(out_feature, str) else out_feature\n\n iter_count = (sum(len(x) for x in attribute.values()) * (1 + ndual) + \\\n len(attribute)) * len(out_features)\n ttq = tqdm(desc='Total', total=iter_count)\n for att, thresholds in attribute.items():\n tq = tqdm(total=(len(thresholds) * (1 + ndual) + 1) * len(out_features), desc=att)\n\n for out_feature in out_features:\n profiles = []; profiles_description = []\n of = att if out_feature == 'same' else out_feature\n\n if ndual:\n # thinning\n prof, desc = _compute_profiles(thinning_tree, att,\n thresholds[::-1], (ttq, tq), of, filtering_rule)\n profiles += prof\n profiles_description += desc\n\n # Origin\n tq.update(); ttq.update()\n profiles += [thickening_tree.reconstruct(feature=of)]\n profiles_description += [{'operation': 'copy feature {}'.format(of)}]\n\n # thickening\n prof, desc = _compute_profiles(thickening_tree, att, thresholds,\n (ttq, tq), of, filtering_rule)\n profiles += prof\n profiles_description += desc\n\n\n data += [np.stack(profiles)]\n description += [{'tree': thickening_tree.get_params(),\n 'name': profiles_name,\n 'attribute': att,\n 'profiles': profiles_description,\n 'filtering rule': filtering_rule,\n 'out feature': of}]\n tq.close()\n ttq.close()\n\n return Profiles(data, description)","def getAltitudeFromLatLon(self, lat, lon):\r\n # print \"-----\\nFromLatLon\", lon, lat\r\n lat -= self.lat\r\n lon -= self.lon\r\n # print \"lon, lat\", lon, lat\r\n if lat < 0.0 or lat >= 1.0 or lon < 0.0 or lon >= 1.0:\r\n raise WrongTileError(self.lat, self.lon, self.lat+lat, self.lon+lon)\r\n x = lon * (self.size - 1)\r\n y = lat * (self.size - 1)\r\n # print \"x,y\", x, y\r\n x_int = int(x)\r\n x_frac = x - int(x)\r\n y_int = int(y)\r\n y_frac = y - int(y)\r\n # print \"frac\", x_int, x_frac, y_int, y_frac\r\n value00 = self.getPixelValue(x_int, y_int)\r\n value10 = self.getPixelValue(x_int+1, y_int)\r\n value01 = self.getPixelValue(x_int, y_int+1)\r\n value11 = self.getPixelValue(x_int+1, y_int+1)\r\n value1 = self._avg(value00, value10, x_frac)\r\n value2 = self._avg(value01, value11, x_frac)\r\n value = self._avg(value1, value2, y_frac)\r\n # print \"%4d %4d | %4d\\n%4d %4d | %4d\\n-------------\\n%4d\" % (\r\n # value00, value10, value1, value01, value11, value2, value)\r\n return value","def classify(self, patch):\n if self.algorithm == 'adaboost':\n ret = 0\n for t in range(0, len(self.classifiers)):\n wc = self.classifiers[t]\n a = wc.alpha\n ret += wc.classify(patch) * a\n return np.sign(ret)\n elif self.algorithm == 'wald':\n for t in range(0, len(self.classifiers)):\n h_ = self.h_t(patch, t)\n wc = self.classifiers[t]\n if h_ >= wc.theta_b:\n return +1\n if h_ <= wc.theta_a:\n return -1\n if self.h_t(patch, self.layers) > self.gamma:\n return +1\n else:\n return -1","def classify(self, patch):\n if self.algorithm == 'adaboost':\n ret = 0\n for t in range(0, len(self.classifiers)):\n wc = self.classifiers[t]\n a = wc.alpha\n ret += wc.classify(patch) * a\n return np.sign(ret)\n elif self.algorithm == 'wald':\n for t in range(0, len(self.classifiers)):\n h_ = self.h_t(patch, t)\n wc = self.classifiers[t]\n if h_ >= wc.theta_b:\n return +1\n if h_ <= wc.theta_a:\n return -1\n if self.h_t(patch, self.layers) > self.gamma:\n return +1\n else:\n return -1","def eval_pascal_one_class(pascal, detections, c):\n gts = {} \n num_objs = 0 \n for img_name in pascal:\n gts[img_name] = []\n for obj in pascal[img_name]:\n if obj['class_id'] == c and obj['difficult']==0:\n gts[img_name] += [{'bbox':obj['bbox'], 'detected': False}]\n num_objs += 1\n\n dts = []\n scores = []\n num_dets = 0\n for img_name in detections:\n for dt in detections[img_name]:\n if dt['class_id'] == c:\n dts.append([img_name, dt['bbox'], dt['score']])\n scores.append(dt['score'])\n num_dets += 1\n \n # Sort the detections based on their scores\n scores = np.array(scores, np.float32)\n sorted_idx = np.argsort(scores)[::-1]\n\n tp = np.zeros((num_dets))\n fp = np.zeros((num_dets))\n\n for i in tqdm(list(range(num_dets))):\n idx = sorted_idx[i]\n img_name = dts[idx][0]\n bbox = dts[idx][1] \n gt_bboxes = np.array([obj['bbox'] for obj in gts[img_name]], np.float32) \n\n # Compute the max IoU of current detection with the ground truths\n max_iou = 0.0\n if gt_bboxes.size > 0:\n ixmin = np.maximum(gt_bboxes[:, 0], bbox[0])\n iymin = np.maximum(gt_bboxes[:, 1], bbox[1])\n ixmax = np.minimum(gt_bboxes[:, 2], bbox[2])\n iymax = np.minimum(gt_bboxes[:, 3], bbox[3])\n\n iw = np.maximum(ixmax - ixmin + 1.0, 0.0)\n ih = np.maximum(iymax - iymin + 1.0, 0.0)\n\n area_intersect = iw * ih\n area_union = (bbox[2] - bbox[0] + 1.0) * (bbox[3] - bbox[1] + 1.0) + (gt_bboxes[:, 2] - gt_bboxes[:, 0] + 1.0) * (gt_bboxes[:, 3] - gt_bboxes[:, 1] + 1.0) - area_intersect\n\n ious = area_intersect / area_union\n max_iou = np.max(ious, axis=0)\n j = np.argmax(ious)\n\n # Determine if the current detection is a true or false positive\n if max_iou > 0.5:\n if not gts[img_name][j]['detected']:\n tp[i] = 1.0\n gts[img_name][j]['detected'] = True\n else:\n fp[i] = 1.0\n else:\n fp[i] = 1.0\n\n # Accumulate the numbers of true and false positives\n tp = np.cumsum(tp)\n fp = np.cumsum(fp)\n\n # Compute the average precision based on these data\n rec = tp * 1.0 / num_objs\n prec = tp * 1.0 / np.maximum((tp + fp), np.finfo(np.float64).eps)\n\n mrec = np.concatenate(([0.], rec, [1.]))\n mpre = np.concatenate(([0.], prec, [0.]))\n\n for i in range(mpre.size - 1, 0, -1):\n mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])\n\n i = np.where(mrec[1:] != mrec[:-1])[0]\n\n ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])\n print('average precision for class %s = %f' %(pascal_class_names[c], ap))\n\n return ap","def attribute_profiles(image, attribute, adjacency=4, image_name=None,\n filtering_rule='direct'):\n maxt = trees.MaxTree(image, adjacency, image_name)\n mint = trees.MinTree(image, adjacency, image_name)\n\n return create_profiles((mint, maxt), attribute, 'altitude',\n filtering_rule, 'attribute profiles')","def is_in_imagenet(self, ade_class):\n spaced_class = \" \".join(ade_class.split(\"_\"))\n for imagenet_class in self.IMAGENET_CLASSES:\n if spaced_class in imagenet_class.split(\", \"):\n logger.debug(f\"ADE20K class: {spaced_class} is in imagenet: {imagenet_class.split(', ')}\")\n return self.IMAGENET_CLASSES[imagenet_class]\n return None","def altitude(p):\r\n \r\n R = 290 #specific gas constant \r\n T = 93.65 #surface temperature K from A.Coustenis book\r\n g = 1.354 #surface gravity from A.Coustenis book\r\n p0 = 1467 #surface pressure in hPa 6.1 for mars\r\n \r\n z = np.empty_like(p)\r\n \r\n for i in range(p.shape[0]):\r\n z[i] = (-1)*(R*T/g)*np.log((p[i])/p0)/(10**3)\r\n \r\n # Make into an xarray DataArray\r\n z_xr = xr.DataArray(z, coords=[z], dims=['pfull'])\r\n z_xr.attrs['units'] = 'km'\r\n \r\n #below is the inverse of the calculation\r\n #p[i] = p0*np.exp((-1)*z[i]*(10**3)/((R*T/g)))\r\n \r\n return z_xr","def image_prediction(self, type, zenith, azimuth, energy, impact, x_max, pix_x, pix_y):\n\n return self.prediction[type].interpolate([energy, impact,\n x_max], pix_x, pix_y)","def update_unsupervised_target(ensemble_prediction, y, num_class, alpha, cur_pred, epoch):\n # Z = αZ + (1 - α)z\n ensemble_prediction = alpha * ensemble_prediction + (1 - alpha) * cur_pred\n\n # initial_epoch = 0\n y[:, 0:num_class] = ensemble_prediction / (1 - alpha ** (epoch + 1))\n\n return ensemble_prediction, y","def eval_det_cls(pred, gt, ovthresh=0.25, use_07_metric=False):\n\n # construct gt objects\n class_recs = {} # {img_id: {'bbox': bbox list, 'det': matched list}}\n npos = 0\n for img_id in gt.keys():\n bbox = np.array(gt[img_id])\n det = [False] * len(bbox)\n npos += len(bbox)\n class_recs[img_id] = {'bbox': bbox, 'det': det}\n # pad empty list to all other imgids\n for img_id in pred.keys():\n if img_id not in gt:\n class_recs[img_id] = {'bbox': np.array([]), 'det': []}\n\n # construct dets\n image_ids = []\n confidence = []\n BB = []\n for img_id in pred.keys():\n for box,score in pred[img_id]:\n image_ids.append(img_id)\n confidence.append(score)\n BB.append(box)\n confidence = np.array(confidence)\n BB = np.array(BB) # (nd,4 or 8,3)\n\n # sort by confidence\n sorted_ind = np.argsort(-confidence)\n sorted_scores = np.sort(-confidence)\n BB = BB[sorted_ind, ...]\n image_ids = [image_ids[x] for x in sorted_ind]\n\n # go down dets and mark TPs and FPs\n nd = len(image_ids)\n tp = np.zeros(nd)\n fp = np.zeros(nd)\n for d in range(nd):\n if d%100==0: \n print(d)\n R = class_recs[image_ids[d]]\n bb = BB[d,:].astype(float)\n ovmax = -np.inf\n BBGT = R['bbox'].astype(float)\n\n if BBGT.size > 0:\n # compute overlaps\n for j in range(BBGT.shape[0]):\n iou = get_iou(bb, BBGT[j,...]) \n if iou > ovmax:\n ovmax = iou\n jmax = j\n\n #print d, ovmax\n if ovmax > ovthresh:\n if not R['det'][jmax]:\n tp[d] = 1.\n R['det'][jmax] = 1\n else:\n fp[d] = 1.\n else:\n fp[d] = 1.\n\n # compute precision recall\n fp = np.cumsum(fp)\n tp = np.cumsum(tp)\n rec = tp / float(npos)\n print('NPOS: ', npos)\n print('ND:', nd)\n # avoid divide by zero in case the first detection matches a difficult\n # ground truth\n prec = tp / np.maximum(tp + fp, np.finfo(np.float64).eps)\n ap = voc_ap(rec, prec, use_07_metric)\n\n return rec, prec, ap","def _load_pascal_annotation(self, index):\n imagefile = os.path.join(self._data_path, 'Images', index + self._image_ext)\n labelfile = os.path.join(self._data_path, 'GroundTruth', index + '.txt')\n print 'Loading: image {} and label {}'.format(imagefile, labelfile)\n\n labels = np.loadtxt(labelfile) + 1\n image = cv2.imread(imagefile)\n\n gt_classes = []\n gt_boxes = []\n\n boxes, classes = self._get_boxes(image, labels)\n\n boxes = np.array(boxes)\n classes = np.array(classes)\n\n scores = np.ones(len(boxes), dtype=np.float32)\n dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32)\n\n # keep = nms(dets, 0.2)\n _, keep = non_max_suppression_fast(dets, 0.2)\n boxes = boxes[keep, :]\n classes = classes[keep]\n\n for n, (x, y, w, h) in enumerate(boxes):\n # gt_boxes.append([min(x, w), min(y, h), min(abs(w - x), w), min(abs(h - y), h)])\n gt_boxes.append([x, y, w - x, h - y])\n gt_classes.append(classes[n])\n\n overlaps = np.zeros((len(gt_boxes), len(self._classes)), dtype=np.float32)\n for n, obj in enumerate(gt_boxes):\n overlaps[n, gt_classes[n]] = 1.0\n\n overlaps = scipy.sparse.csr_matrix(overlaps)\n\n return {'boxes': np.array(gt_boxes),\n 'gt_classes': np.array(gt_classes, dtype=np.int32),\n 'gt_overlaps': overlaps,\n 'flipped': False}\n\n # def get_data_from_tag(node, tag):\n # return node.getElementsByTagName(tag)[0].childNodes[0].data\n\n # with open(filename) as f:\n # data = minidom.parseString(f.read())\n\n # objs = data.getElementsByTagName('object')\n # num_objs = len(objs)\n\n # boxes = np.zeros((num_objs, 4), dtype=np.uint16)\n # gt_classes = np.zeros((num_objs), dtype=np.int32)\n # overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32)\n\n # # Load object bounding boxes into a data frame.\n # for ix, obj in enumerate(objs):\n # # Make pixel indexes 0-based\n # x1 = float(get_data_from_tag(obj, 'xmin')) - 1\n # y1 = float(get_data_from_tag(obj, 'ymin')) - 1\n # x2 = float(get_data_from_tag(obj, 'xmax')) - 1\n # y2 = float(get_data_from_tag(obj, 'ymax')) - 1\n # cls = self._class_to_ind[str(get_data_from_tag(obj, \"name\")).lower().strip()]\n # boxes[ix, :] = [x1, y1, x2, y2]\n # gt_classes[ix] = cls\n # overlaps[ix, cls] = 1.0\n\n # overlaps = scipy.sparse.csr_matrix(overlaps)\n\n # return {'boxes': boxes,\n # 'gt_classes': gt_classes,\n # 'gt_overlaps': overlaps,\n # 'flipped': False}","def density(self, alt):\n (Z, T, CN2, CO2, CO, CAr, CHe, CH, CM, WM) = self.altitude_profile(alt)\n\n # using eqn(42) of COESA for multiple gases\n M_i = [wmN2, wmO2, wmO, wmAr, wmHe, wmH] << (u.g / u.mol)\n n_i = [\n CN2.to_value(u.m**-3),\n CO2.to_value(u.m**-3),\n CO.to_value(u.m**-3),\n CAr.to_value(u.m**-3),\n CHe.to_value(u.m**-3),\n CH.to_value(u.m**-3),\n ] << (1 / u.m**3)\n rho = (n_i @ M_i) / Na\n return rho.to(u.kg / u.m**3)","def ap_per_class(tp, conf, pred_cls, target_cls):\n\n # lists/pytorch to numpy\n tp, conf, pred_cls, target_cls = np.array(tp), np.array(conf.cpu().data), np.array(pred_cls.cpu().data), np.array(target_cls)\n\n # Sort by objectness\n i = np.argsort(-conf)\n tp, conf, pred_cls = tp[i], conf[i], pred_cls[i]\n\n # Find unique classes\n unique_classes = np.unique(np.concatenate((pred_cls, target_cls), 0))\n\n # Create Precision-Recall curve and compute AP for each class\n ap = []\n for c in unique_classes:\n i = pred_cls == c\n n_gt = sum(target_cls == c) # Number of ground truth objects\n n_p = sum(i) # Number of predicted objects\n\n if (n_p == 0) and (n_gt == 0):\n continue\n elif (np == 0) and (n_gt > 0):\n ap.append(0)\n elif (n_p > 0) and (n_gt == 0):\n ap.append(0)\n else:\n # Accumulate FPs and TPs\n fpa = np.cumsum(1 - tp[i])\n tpa = np.cumsum(tp[i])\n\n # Recall\n recall = tpa / (n_gt + 1e-16)\n\n # Precision\n precision = tpa / (tpa + fpa)\n\n # AP from recall-precision curve\n ap.append(compute_ap(recall, precision))\n\n return np.array(ap)","def classifyExonStats(actual, predicted, ref, classifiedexons):\n\tactualexons = actual.exonList(ref)\n\tpredictedexons = predicted.exonList(ref)\n\texon = [{'Wrong':0, 'Partial':0, 'Correct':0}, {'Wrong':0, 'Partial':0, 'Correct':0}]\n\t\n\tfor (astart, aend) in actualexons:\n\t\tcategory = 'Wrong'\n\t\tfor (pstart, pend) in predictedexons:\n\t\t\tif (pstart, pend) == (astart, aend):\n\t\t\t\tcategory = 'Correct'\n\t\t\t\tbreak\n\t\t\telif (pstart <= astart and pend >= astart) or (astart <= pstart and aend >= pend):\n\t\t\t\tcategory ='Partial'\n\t\t\t\tbreak\n\t\texon[0][category] += 1\n\tfor (pstart, pend) in predictedexons:\n\t\tcategory = 'Wrong'\n\t\tfor (astart, aend) in actualexons:\n\t\t\tif (pstart, pend) == (astart, aend):\n\t\t\t\tcategory = 'Correct'\n\t\t\t\tbreak\n\t\t\telif (astart <= pstart and aend >= pend) or (pstart <= astart and pend >= astart):\n\t\t\t\tcategory ='Partial'\n\t\t\t\tbreak\n\t\texon[1][category] += 1\n\tclassifiedexons['ME'] += exon[0]['Wrong']\n\tclassifiedexons['WE'] += exon[1]['Wrong']\n\tclassifiedexons['PE'] += (exon[1]['Partial'] + exon[0]['Partial'])/2\n\tclassifiedexons['CE'] += exon[1]['Correct']","def accuracy(cls, test_labels):\n N = len(test_labels)\n\n # Calculate total correct as precentage\n total_correct = 100*(N - np.count_nonzero(cls - test_labels))/N\n\n # Calculate precentag correct for each class\n lab = np.unique(test_labels)\n cls_correct = {}\n for label in lab:\n idx = np.where(test_labels == label)[0]\n N_cls = len(idx)\n cls_correct[label] = 100*(N_cls - np.count_nonzero(label -\n cls[idx]))/N_cls\n\n print(\"Accuracy for:\")\n print(\"All classes is %.2f%%\" % total_correct)\n for label in lab:\n print(\"Class %d is %.2f%%\" % (label, cls_correct[label]))\n return(total_correct, cls_correct)","def generate_elevation_profile(line):\n\n elem = from_shape(line, 4326)\n line_cte = db.session.query(\n func.ST_Transform(elem, 28992).label(\"geom\")).cte(name=\"line\")\n\n cells_cte = db.session.query(\n # Get the centroid of the cell which intersects our line\n func.ST_Centroid(\n # Type coerce the return value so we van access the `geom` and\n # `val` attributes\n type_coerce(\n func.ST_Intersection(AHNRaster.rast, line_cte.c.geom),\n RasterIntersection()\n ).geom\n ).label(\"geom\"),\n type_coerce(\n func.ST_Intersection(AHNRaster.rast, line_cte.c.geom),\n RasterIntersection()\n ).val.label(\"val\")\n ).filter(\n func.ST_Intersects(AHNRaster.rast, line_cte.c.geom)\n ).cte(name=\"cells\")\n\n height_data_cte = db.session.query(\n func.ST_Transform(\n func.ST_SetSrid(func.ST_MakePoint(\n func.ST_X(cells_cte.c.geom), func.ST_Y(cells_cte.c.geom),\n ), 28992),\n 4326\n ).label(\"point\"),\n # Select value separately instead of a Point with Z value because\n # geoalchemy and shapely do not really play nicely with higher order\n # geometries\n cells_cte.c.val.label(\"val\"),\n line_cte\n ).order_by(func.ST_X(cells_cte.c.geom)).cte(name=\"height_data\")\n\n return db.session.query(height_data_cte.c.point, height_data_cte.c.val)","def elevation(self):\n return self.altitude - self.heightAboveGround","def accuracy(self):","def get_accuracy(self, output, target, target_weight):\n accuracy = dict()\n if self.target_type == 'GaussianHeatmap':\n _, avg_acc, _ = pose_pck_accuracy(output[-1].detach().cpu().numpy(), target.detach().cpu().numpy(), target_weight.detach().cpu().numpy().squeeze(-1) > 0)\n accuracy['acc_pose'] = float(avg_acc)\n return accuracy","def keypoint_pck_accuracy(pred, gt, mask, thr, normalize):\n distances = _calc_distances(pred, gt, mask, normalize)\n acc = np.array([_distance_acc(d, thr) for d in distances])\n valid_acc = acc[acc >= 0]\n cnt = len(valid_acc)\n avg_acc = valid_acc.mean() if cnt > 0 else 0\n return acc, avg_acc, cnt","def get_accuracy(self, output, target, target_weight):\n accuracy = dict()\n if self.target_type.lower() == 'GaussianHeatmap'.lower():\n _, avg_acc, _ = pose_pck_accuracy(output.detach().cpu().numpy(), target.detach().cpu().numpy(), target_weight.detach().cpu().numpy().squeeze(-1) > 0)\n accuracy['acc_pose'] = float(avg_acc)\n return accuracy","def is_cruising(altitude, cruise_altitude=None):\n if cruise_altitude is None:\n cruise_altitude = closest_cruising_altitude(altitude)\n return abs(altitude - cruise_altitude) <= 200","def AEH2LatLonAlt(azim, elev, h, lat, lon, alt):\n\n # Compute the range to the point\n r = AEH2Range(azim, elev, h, lat, lon, alt)\n\n\n # Compute lat/lon/alt of the point on the line of sight\n x, y, z = AER2ECEF(azim, elev, r, lat, lon, alt)\n lat2, lon2, alt2 = ecef2LatLonAlt(x, y, z)\n lat2, lon2 = np.degrees(lat2), np.degrees(lon2)\n\n\n return lat2, lon2, alt2","def get_accuracy(self, output, target, target_weight):\n accuracy = dict()\n if self.target_type == 'GaussianHeatmap':\n _, avg_acc, _ = pose_pck_accuracy(output.detach().cpu().numpy(), target.detach().cpu().numpy(), target_weight.detach().cpu().numpy().squeeze(-1) > 0)\n accuracy['acc_pose'] = float(avg_acc)\n return accuracy","def calculate_accuracy(ground_truth_object_list, pred_object_list):\n\n ground_truth_list = np.zeros((1,10))\n pred_list = np.zeros((1,10))\n \n for gt_index in range(len(ground_truth_object_list)):\n \n intClass_ground_truth = classMappingDict[ground_truth_object_list[gt_index]['name']]\n ground_truth_list[0][intClass_ground_truth] = ground_truth_list[0][intClass_ground_truth] + 1\n\n for pred_index in range(len(pred_object_list)):\n\n intClass_pred = classMappingDict[pred_object_list[pred_index]['name']]\n pred_list[0][intClass_pred] = pred_list[0][intClass_pred] + 1\n return ground_truth_list, pred_list","def change_altitude_cm_m(data_array):\n data_array[:, 3] = data_array[:, 3]*0.3048\n return data_array","def altaz_to_offset(obj_azimuth,obj_altitude,azimuth,altitude):\n\n daz = obj_azimuth - azimuth\n coa = cos(obj_altitude)\n\n xp0 = -cos(daz) * coa\n yp0 = sin(daz) * coa\n zp0 = sin(obj_altitude)\n\n cx = sin(altitude)\n sx = cos(altitude)\n\n xp1 = cx*xp0 + sx*zp0\n yp1 = yp0\n zp1 = -sx*xp0 + cx*zp0\n\n q = arccos(zp1)\n d = tan(q)\n alpha = arctan2(yp1,xp1)\n\n xoff = d * cos(alpha)\n yoff = d * sin(alpha)\n\n return xoff,yoff","def predict_qth(self):\n return (self.latitude, -self.longitude, self.altitude)","def get_accuracy(self, output, target, target_weight):\n accuracy = dict()\n if self.target_type == 'GaussianHeatmap':\n assert isinstance(output, list)\n assert target.dim() == 5 and target_weight.dim() == 4\n _, avg_acc, _ = pose_pck_accuracy(output[-1].detach().cpu().numpy(), target[:, -1, ...].detach().cpu().numpy(), target_weight[:, -1, ...].detach().cpu().numpy().squeeze(-1) > 0)\n accuracy['acc_pose'] = float(avg_acc)\n return accuracy","def TileInfoLoaderCfg(flags, **kwargs):\n\n from AthenaCommon.Logging import logging\n msg = logging.getLogger('TileInfoLoaderCfg')\n\n from TileConditions.TileCablingSvcConfig import TileCablingSvcCfg\n acc = ComponentAccumulator()\n acc.merge (TileCablingSvcCfg(flags))\n\n if 'NoiseScaleIndex' not in kwargs:\n if flags.Tile.doOpt2 and not flags.Tile.doOptATLAS:\n msg.info(\"Adjusting TileInfo to return cell noise for Opt.Filter with iterations\")\n kwargs['NoiseScaleIndex'] = 2 # Noise for Optimal Filter with iterations\n else:\n msg.info(\"Adjusting TileInfo to return cell noise for Opt.Filter without iterations\")\n kwargs['NoiseScaleIndex'] = 1 # Noise for Optimal Filter without iterations\n\n\n if (flags.Input.isMC or flags.Detector.OverlayTile) and ('TileHitVec' in flags.Input.Collections or 'TileHitVec' in flags.Input.SecondaryCollections):\n\n G4Version = flags.Sim.G4Version\n G4VersionMajor, G4VersionMinor = G4Version.split(\".\")[1:3]\n G4V = int(G4VersionMajor) + int(G4VersionMinor) / 100.\n\n physicsList = flags.Sim.PhysicsList\n\n if 'EmScaleA' not in kwargs:\n\n # Default value since May-2011\n EmScaleA = 34.0\n\n # Default value for G4 9.6 since Nov-2013 (need to check G4 version as well)\n if physicsList == 'FTFP_BERT' or (physicsList == 'QGSP_BERT' and G4V > 9.05999) :\n EmScaleA = 33.9\n\n # Default value for G4 10.0 since June-2016\n # see https://indico.cern.ch/event/489520/contributions/2193913/attachments/1285565/1914309/sampling_fractions.pdf\n if G4V >= 10.0 :\n EmScaleA = 33.7\n\n # Old value\n if physicsList == 'QGSP_EMV' or physicsList == 'QGSP_BERT_EMV' or physicsList == '':\n EmScaleA = 35.9\n\n kwargs['EmScaleA'] = EmScaleA # 1/s.f. value for all normal cells\n\n else:\n EmScaleA = kwargs['EmScaleA']\n\n msg.info(\"Using 1/s.f. = %s for %s physics list and G4version %s (%s)\", EmScaleA, physicsList, G4V, G4Version)\n\n kwargs.setdefault('TileNoise', flags.Digitization.DoCaloNoise)\n if kwargs['TileNoise']:\n msg.info(\"Switching ON noise in Tile Digitization\" )\n else:\n msg.info(\"Switching OFF noise in Tile Digitization\" )\n\n\n TileInfoLoader=CompFactory.TileInfoLoader\n acc.addService(TileInfoLoader(**kwargs), primary = True)\n\n return acc","def __init__(self, threshold=torch.linspace(0.5,0.95,10), num_points=101, *args, **kwargs):\n\n self.threshold = threshold\n self.IOU = IOU(average=False)\n self.AP = AveragePrecision(num_points=num_points, *args, **kwargs)\n\n self.result_dir = kwargs['result_dir']\n final_shape = kwargs['final_shape']\n #assuming model predictions are normalized between 0-1\n self.scale = torch.Tensor([1, final_shape[0], final_shape[1], final_shape[0], final_shape[1]]) #[1, height, width, height, width]\n\n self.ndata = kwargs['ndata']\n self.count = 0","def class_average_withali(images,ptcl_info,xform,ref,averager=(\"mean\",{}),normproc=(\"normalize.edgemean\",{}),setsfref=0,verbose=0):\n\n\tif isinstance(images[0],EMData) : nimg=len(images)\n\telif isinstance(images[0],str) and isinstance(images[1],int) : nimg=len(images)-1\n\telse : raise Exception,\"Bad images list\"\n\n\tincl=[]\n\texcl=[]\n#\txforms=[]\n\tavgr=Averagers.get(averager[0], averager[1])\n\tfor i in range(nimg):\n\t\timg=get_image(images,i,normproc)\n\t\tptcl_info[i]=(ptcl_info[i][0],xform*ptcl_info[i][1],ptcl_info[i][2])\t\t# apply the new Transform to the existing one\n#\t\tptcl_info[i]=(ptcl_info[i][0],ptcl_info[i][1]*xform,ptcl_info[i][2])\t\t# apply the new Transform to the existing one\n\t\timg.process_inplace(\"xform\",{\"transform\":ptcl_info[i][1]})\n\t\ttry: use=ptcl_info[i][2]\n\t\texcept: use=1\n\t\tif use :\n\t\t\tavgr.add_image(img)\t\t\t\t# only include the particle if we've tagged it as good\n\t\t\tif img.has_attr(\"source_n\") : incl.append(img[\"source_n\"])\n#\t\t\txforms.append(ptcl_info[i][1])\n\t\telif img.has_attr(\"source_n\") : excl.append(img[\"source_n\"])\n\n\tavg=avgr.finish()\n\n\t# normalize to the reference, this should make make3dpar work better as we can skip the normalization step\n\tif ref!=None :\n\t\tif setsfref:\n\t\t\tavg.process_inplace(\"filter.matchto\",{\"to\":ref,\"interpolate\":0,\"keephires\":1})\n\t\t\tavg-=avg.get_edge_mean()\n\t\telse : avg.process_inplace(\"normalize.toimage\",{\"to\":ref})\n\n\t\tavg[\"class_qual\"]=avg.cmp(\"ccc\",ref)\n\n\t# set some useful attributes\n\tif len(incl)>0 or len(excl)>0 :\n\t\tif len(incl)>0 : avg[\"class_ptcl_idxs\"]=incl\n\t\tif len(excl)>0 : avg[\"exc_class_ptcl_idxs\"]=excl\n#\t\tif len(xforms)>0: avg[\"class_ptcl_xforms\"]=xforms\n\t\tavg[\"class_ptcl_src\"]=img[\"source_path\"]\n\n\treturn avg","def multiclass_accuracy(prediction, ground_truth):\n correct = sum(a == b for a, b in zip(prediction, ground_truth))\n\n accuracy = correct / len(ground_truth)\n\n return accuracy","def facility_etl():\r\n with arcetl.ArcETL(\"Facilities\") as etl:\r\n etl.extract(dataset.FACILITY.path(\"maint\"))\r\n etl.transform(\r\n arcetl.dataset.rename_field,\r\n field_name=\"geofeat_id\",\r\n new_field_name=\"address_intid\",\r\n )\r\n # Clean maintenance values.\r\n transform.clear_nonpositive(etl, field_names=[\"address_intid\"])\r\n transform.clean_whitespace(\r\n etl, field_names=[\"label\", \"label_full\", \"type\", \"type_full\"]\r\n )\r\n transform.force_lowercase(etl, field_names=[\"type\"])\r\n transform.force_uppercase(etl, field_names=[\"label\"])\r\n transform.add_missing_fields(etl, dataset.FACILITY, tags=[\"pub\"])\r\n # Assign geometry attributes.\r\n coordinate_system_xy_keys = {\r\n 2914: {\"x\": \"x_coordinate\", \"y\": \"y_coordinate\"},\r\n 4326: {\"x\": \"longitude\", \"y\": \"latitude\"},\r\n }\r\n for spatial_reference_id, xy_key in coordinate_system_xy_keys.items():\r\n for axis, key in xy_key.items():\r\n etl.transform(\r\n arcetl.attributes.update_by_geometry,\r\n field_name=key,\r\n spatial_reference_item=spatial_reference_id,\r\n geometry_properties=[\"centroid\", axis],\r\n )\r\n etl.transform(\r\n arcetl.attributes.update_by_mapping,\r\n field_name=\"address_uuid\",\r\n mapping=address_intid_to_uuid_map,\r\n key_field_names=[\"address_intid\"],\r\n )\r\n etl.load(dataset.FACILITY.path(\"pub\"))","def benthos_psa916_dict(calib, signal):\n\n #array mode\n try:\n altitude = []\n for signal_x in signal:\n temp = (300 * signal_x / calib['ScaleFactor']) + calib['Offset']\n altitude.append(temp)\n #single mode\n except:\n altitude = (300 * signal / calib['ScaleFactor']) + calib['Offset']\n return altitude","def get_alt(self, dec, i_alt):\n return self.decisions[dec].value[i_alt]"],"string":"[\n \"def altitude_profile(self, alt):\\n # checking if the units entered are km\\n if alt.unit == u.km:\\n if 150 <= alt.value < 500:\\n alt_properties = self._altitude_profile(500)\\n else:\\n alt_properties = self._altitude_profile(alt.value)\\n\\n return [last[int(alt.value)] for last in alt_properties]\",\n \"def create_altitude_profile(self, max_altitude=32, exponential_constant=0.05, ground_altitude=6, timespan=30,\\n timestep=1 / 60):\\n x_time = np.arange(0, timespan, timestep)\\n y_target_profile = max_altitude * np.exp(-exponential_constant * x_time) + ground_altitude\\n return x_time, y_target_profile\",\n \"def altitude(self):\\n if self.__altitude:\\n return sum(self.__altitude) / len(self.__altitude)\\n else:\\n return -9999\",\n \"def getAltitudeProfile(pass_length,terrain,uav_altitude,u,start_v,wind_angle):\\n altitude_profile = []\\n v = start_v\\n for k in range(0,round(pass_length)):\\n coord = convertCoords([[u,v]],wind_angle,'xy')\\n x = coord[0][0]\\n y = coord[0][1]\\n x_points = [int(x),int(x),int(x)+1,int(x)+1]\\n y_points = [int(y),int(y)+1,int(y)+1,int(y)]\\n z_points = [terrain[int(y)][int(x)],terrain[int(y)+1][int(x)],\\n terrain[int(y)+1][int(x)+1],terrain[int(y)][int(x)+1]]\\n\\n # For created terrain ONLY\\n z = griddata((x_points,y_points),z_points,(x,y)) # Interpolate \\n altitude = z + uav_altitude\\n\\n altitude_profile.append(altitude)\\n v +=1\\n return altitude_profile\",\n \"def altitude(self):\\r\\n pressure = self.pressure # in Si units for hPascal\\r\\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))\",\n \"def altitude(self, value: int):\\n self._point.altitude = value\",\n \"def filter_altitude(self, gps_data, setting=None, threshold=None):\\n\\n # New filter settings if provided\\n if setting is not None:\\n self.gps_altitude_filter = setting\\n if setting == 'Manual':\\n self.gps_altitude_filter_change = threshold\\n\\n # Set threshold for Auto\\n if self.gps_altitude_filter == 'Auto':\\n self.gps_altitude_filter_change = 3\\n\\n # Set all data to valid\\n self.valid_data[3, :] = True\\n # self.valid_data[5, :] = True\\n\\n # Manual or Auto is selected, apply filter\\n if not self.gps_altitude_filter == 'Off':\\n # Initialize variables\\n num_valid_old = np.sum(self.valid_data[3, :])\\n k = 0\\n change = 1\\n # Loop until no change in the number of valid ensembles\\n while k < 100 and change > 0.1:\\n # Compute mean using valid ensembles\\n alt_mean = np.nanmean(gps_data.altitude_ens_m[self.valid_data[1, :]])\\n\\n # Compute difference for each ensemble\\n diff = np.abs(gps_data.altitude_ens_m - alt_mean)\\n\\n # Mark invalid those ensembles with differences greater than the change threshold\\n self.valid_data[3, diff > self.gps_altitude_filter_change] = False\\n k += 1\\n num_valid = np.sum(self.valid_data[3, :])\\n change = num_valid_old - num_valid\\n\\n # Combine all filter data to composite valid data\\n self.valid_data[0, :] = np.all(self.valid_data[1:, :], 0)\\n self.num_invalid = np.sum(self.valid_data[0, :] == False)\",\n \"def process_driver_altitude(coordinate: Coordinate) -> ProcessDescription:\\n city = get_city_by_coordinates(\\n latitude=coordinate.latitude,\\n longitude=coordinate.longitude,\\n )\\n city_coordinates = CITIES_COORDINATES_MAP.get(city)\\n if not city_coordinates:\\n return ProcessDescription(\\n detect=False,\\n description='Invalid city coordinates.'\\n )\\n\\n altitude_min = city_coordinates['altitude_min']\\n altitude_max = city_coordinates['altitude_max']\\n\\n if altitude_min <= coordinate.altitude <= altitude_max:\\n return ProcessDescription(\\n detect=False,\\n description=(\\n f'Driver altitude {coordinate.altitude} '\\n f'is normal for city {city.capitalize()}.'\\n )\\n )\\n\\n return ProcessDescription(\\n detect=True,\\n description=(\\n f'Driver has incorrect altitude {coordinate.altitude} '\\n f'for city {city.capitalize()}.'\\n )\\n )\",\n \"def set_altitude(self):\\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\\n print('altitude set to', self.altitude)\\n if self.altitude < 0:\\n self.altitude = self.altitude + 360.0\\n return self.altitude \\n else: \\n pass\\n return self.altitude\",\n \"def altitude(self) -> int:\\n return self._point.altitude\",\n \"def setTargetAltitude(altitude):\\n return RoboCaller().call(\\\"setTargetAltitude\\\", \\\"void\\\", altitude)\",\n \"def topographic_altitude(self, lat_d, lon_d):\\n return self.altitude(lat_d, lon_d)\",\n \"def topographic_altitude(self, lat_d, lon_d):\\n return self.altitude(lat_d, lon_d)\",\n \"def topographic_altitude(lat, lon):\\n global __model\\n type_output = type(lat)\\n lat = prepare_input_array(lat)\\n lon = prepare_input_array(lon)\\n lon = np.mod(lon, 360)\\n val = __model.topographic_altitude(lat, lon)\\n val = np.maximum(val, 1e-7)\\n return prepare_output_array(val, type_output) * u.km\",\n \"def altitude_control(self, altitude_cmd,\\n vertical_velocity_cmd,\\n altitude,\\n vertical_velocity,\\n attitude,\\n acceleration_ff=0.0):\\n \\n hdot_cmd = self.Kp_alt * (altitude_cmd - altitude) + vertical_velocity_cmd\\n \\n # Limit the ascent/descent rate\\n hdot_cmd = np.clip(hdot_cmd, -self.max_descent_rate, self.max_ascent_rate)\\n\\n acceleration_cmd = acceleration_ff + self.Kp_hdot*(hdot_cmd - vertical_velocity)\\n \\n R33 = np.cos(attitude[0]) * np.cos(attitude[1])\\n thrust = DRONE_MASS_KG * acceleration_cmd / R33\\n \\n if thrust > MAX_THRUST:\\n thrust = MAX_THRUST\\n elif thrust < 0.0:\\n thrust = 0.0\\n return thrust\",\n \"def get_altitude(self):\\n self.degrees = self.altitude_encoder.get_degrees()\\n self.tele_altitude = self.Calculations.convert_degrees( self.degrees)\\n return self.tele_altitude\",\n \"def pressure(altitude):\\n t = temperature(altitude) # R\\n if altitude <= 36152:\\n p = 2116*(t/518.6)**5.256 # psf\\n else:\\n p = 473.1*exp(1.73-0.000048*altitude) # psf\\n return p\",\n \"def get_air_density(self, altitude):\\n\\n altitude /= 1000 # convert to kilometers\\n\\n return self.get_air_density_from_model(altitude)\",\n \"def altitude_to_pressure(alt):\\n for i in range(len(_heights)-1,0,-1):\\n h0 = _heights[i]\\n T0 = _basetemps[i]\\n if alt > h0:\\n if _isotherm[i]:\\n rP = math.exp(-_g / _R / T0 * (alt - h0))\\n else:\\n l0 = _lapsert[i]\\n rP = math.pow(1 + (alt - h0) * l0 / T0, -_g / _R / l0)\\n return _basepress[i] * rP\\n l0 = _lapsert[0]\\n return _stdpres * math.pow(1 + alt * l0 / _stdtemp, -_g / _R / l0)\",\n \"def get_altitude(points):\\n altitudes = np.zeros((len(points),), dtype=\\\"float64\\\")\\n for i, point in tqdm(enumerate(points), desc=\\\"GETTING ALTITUDE\\\"):\\n p = Point(point[0], point[1])\\n altitudes[i] = alt.NM_COTA.iloc[\\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\\n ]\\n return altitudes\",\n \"def read_altitude(self, meanSeaLevelPressureInBar):\\n phPa = self.read_pressure() / 100.0\\n\\n return float(44330.0 * (1.0 - math.pow((phPa / meanSeaLevelPressureInBar), 0.1903)))\",\n \"def read_altitude(self, meanSeaLevelPressureInBar):\\n phPa = self.read_pressure() / 100.0\\n\\n return float(44330.0 * (1.0 - math.pow((phPa / meanSeaLevelPressureInBar), 0.1903)))\",\n \"def altitude_callback(self, data):\\n self.altitude = data\\n self.altitude_bottom_clearance = np.float64(data.bottom_clearance)\\n if np.isnan(self.altitude_bottom_clearance):\\n # message is often enough that it should alert the user but shouldn't swamp the console\\n rospy.logwarn_throttle(0.5, 'bottom clearance is invalid type: {}'.format(self.altitude_bottom_clearance))\",\n \"def offset_to_altaz(xoff, yoff, azimuth, altitude):\\n #Deal with situations where offset = 0?\\n\\n d = sqrt(xoff*xoff+yoff*yoff)\\n pos = np.where(d==0)\\n d=1e-12 * u.deg # add a very small offset to prevent math errors\\n\\n q = arctan(d.to(u.rad).value)\\n\\n sq = sin(q)\\n xp1 = xoff * (sq/d)\\n yp1 = yoff * (sq/d)\\n zp1 = cos(q)\\n\\n cx = sin(altitude)\\n sx = cos(altitude)\\n\\n xp0 = cx*xp1 - sx*zp1\\n yp0 = yp1\\n zp0 = sx*xp1 + cx*zp1\\n\\n obj_altitude = arcsin(zp0)\\n obj_altitude[pos]=altitude\\n obj_azimuth = arctan2(yp0,-xp0) + azimuth\\n obj_azimuth[pos] = azimuth\\n\\n #if obj_azimuth.value < 0.:\\n # obj_azimuth += 2.*pi\\n #elif obj_azimuth.value >= (2.*pi ):\\n # obj_azimuth -= 2.*pi\\n\\n return obj_altitude,obj_azimuth\",\n \"def pressure_to_altitude(pres):\\n for i in range(len(_heights)-1,0,-1):\\n P0 = _basepress[i]\\n T0 = _basetemps[i]\\n if pres < P0:\\n if _isotherm[i]:\\n dh = _R * T0 / _g * math.log(P0 / pres)\\n else:\\n l0 = _lapsert[i]\\n dh = T0 / l0 * (math.pow(pres / P0, -l0 * _R / _g) - 1)\\n return _heights[i] + dh\\n l0 = _lapsert[0]\\n return _stdtemp / l0 * (math.pow(pres / _stdpres, -l0 * _R / _g) - 1)\",\n \"def temperature(self, alt):\\n T = self.altitude_profile(alt)[1]\\n return T\",\n \"def test_triangle_get_shortest_altitude(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)\",\n \"def sim_altitude(a):\\n a.takeoff()\\n for i in range(20):\\n b = a.refresh()\\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() + 3)\\n print a.altitude.get_altitudes(), b\\n a.land()\\n a.motor.set_speed(2000.0)\\n for i in range(20):\\n b = a.refresh()\\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() - 3)\\n print a.altitude.get_altitudes(), b\",\n \"def temperature(altitude):\\n if altitude <= 36152:\\n t = 59-0.00356*altitude # deg F\\n else:\\n t = -70 # deg F\\n t = t + 459.7 # R\\n return t\",\n \"def check_altitude_at(self, altim, coords, altitude_bounds):\\n altitude = altim.mesh.point_altitude(coords)\\n self.assertWithin(altitude, *altitude_bounds)\",\n \"def test_triangle_get_longest_altitude(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_longest_altitude(), 9.428090415820634)\",\n \"def get_user_sector_altitude_range(db_id):\\n found, sector = user_sector_finder(\\\"id\\\", int(db_id))\\n if found:\\n return (sector[0]['min_altitude'], sector[0]['max_altitude'])\\n else:\\n raise NotFoundException(db_id, \\\"User sector not found.\\\")\",\n \"def altitude(press, altimeter=29.92126):\\n AS = altimeter*inHg2PA\\n print(AS, press**(L*R/g/M))\\n h = -(press**(L*R/g/M) - AS**(L*R/g/M))*T0/L/(P0**(L*R/g/M))\\n return h/ft2m\",\n \"def ClassificationAccuracy(Class=[7], folds = 20, neighbours = 25):\\n S, dig = CreateDS_Torus_Digits(Class)\\n i = 0\\n\\n Digit_isomap_embed = Isomap(dig[i][0], 2, neighbours)\\n Digit_LLE_embed = LLE(dig[i][0], 2, neighbours)\\n clf = SVC()\\n Accuracies_ISOMAP = cross_val_score(clf,Digit_isomap_embed,dig[i][1], cv=folds)\\n Accuracies_LLE = cross_val_score(clf,Digit_LLE_embed,dig[i][1], cv=folds)\\n\\n print('The mean accuracy is:')\\n print('ISOMAPPING {:.3f}'.format(np.mean(Accuracies_ISOMAP)))\\n print('LLE {:.3f}'.format(np.mean(Accuracies_LLE)))\",\n \"def closest_cruising_altitude(altitude):\\n return 1000 * ((altitude + 500) // 1000)\",\n \"def classify(self, ep):\\n # just here for defining the interface; work is done in subclasses\\n pass\",\n \"def set_cruise_altitudes(altitudes, cruise_indicies):\\n if cruise_indicies:\\n for index in range(0, len(cruise_indicies), 2):\\n start = cruise_indicies[index]\\n stop = cruise_indicies[index + 1]\\n if start < stop:\\n cruise_altitude = closest_cruising_altitude(altitudes[start])\\n altitudes[start] = cruise_altitude\\n altitudes[stop] = cruise_altitude\\n\\n return altitudes\",\n \"def altitude_range(self, start_distance, finish_distance):\\n start_index, start_ratio = calculate_value_reference(self.distances,\\n start_distance)\\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\\n finish_index, finish_ratio = calculate_value_reference(self.distances,\\n finish_distance)\\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\\n\\n min_alt = min(start_alt, finish_alt)\\n max_alt = max(start_alt, finish_alt)\\n\\n if start_index < finish_index:\\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\\n min_alt = min(min_alt, altitudes.min())\\n max_alt = max(max_alt, altitudes.max())\\n\\n return min_alt, max_alt\",\n \"def viscosity(altitude):\\n t_ref = temperature(0) # R\\n t = temperature(altitude) # R\\n s = 198.72 # R\\n mu_ref = 3.737 * 10 ** (-7) # [slug/(ft*s)]\\n mu = mu_ref*((t/t_ref)**(3/2))*(t_ref + s)/(t + s) # [slug/(ft*s)]\\n return mu\",\n \"def add_altitude():\\n\\n doc = Metashape.app.document\\n if not len(doc.chunks):\\n raise Exception(\\\"No chunks!\\\")\\n\\n # alt = Metashape.app.getFloat(\\\"Please specify the height to be added:\\\", 100)\\n alt = float(sys.argv[1])\\n\\n\\n chunk = doc.chunk\\n\\n for camera in chunk.cameras:\\n if camera.reference.location:\\n coord = camera.reference.location\\n camera.reference.location = Metashape.Vector([coord.x, coord.y, coord.z + alt])\\n print(\\\"Add : \\\"+str(sys.argv[1]))\",\n \"def get_elementary_airspace_altitude_range(db_id):\\n connection = get_geo_db_connection()\\n sector = find_sector(db_id, connection)\\n if (sector):\\n return (sector['min_altitude'], sector['max_altitude'])\\n else:\\n raise NotFoundException(db_id, \\\"Elementary sector not found.\\\")\",\n \"def get_altitude(self):\\n return self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_GET_ALTITUDE, (), '', 'i')\",\n \"def pressure(self, alt):\\n alt_profile = self.altitude_profile(alt)\\n T, number_density = alt_profile[1], alt_profile[8]\\n\\n # using eqn(42) of COESA76\\n pressure = number_density * k * T\\n return pressure\",\n \"def isa(h):\\n if np.any((h<0)|(h>11000)):\\n print (\\\"The altitude must be between 0m and 11000m\\\")\\n return \\\"Returning a string to cause errors later\\\"\\n T = T0 + -0.0065*h\\n p = p0*(T/T0)**(-g0/(-0.0065*R))\\n rho = p/(R*T)\\n return T,p,rho\",\n \"def createTerraces(u,v,altitude_profile,wind_angle,pass_length,image_passes,max_alt_diff,min_terrace_len):\\n # Create terraces from pass\\n current_terrace = [] # Initilise current terrace points as empty\\n average_alt = 0 # Store the average altitude\\n if len(altitude_profile) > 0: # If there is some altitude data for this pass\\n max_altitude = np.max(altitude_profile)\\n min_altitude = np.min(altitude_profile)\\n if max_altitude - min_altitude < max_alt_diff: # If the entire pass is within the altitude limits\\n # Find the mean altitude\\n for i in range(0,len(altitude_profile)):\\n average_alt += altitude_profile[i]\\n average_alt = average_alt/len(altitude_profile)\\n terrace_start = (u,v,average_alt)\\n terrace_end = (u,v+pass_length,average_alt)\\n\\n coords = convertCoords([[terrace_start[0],terrace_start[1]]],wind_angle,'xy')\\n terrace_start = (coords[0][0],coords[0][1],average_alt)\\n\\n coords = convertCoords([[terrace_end[0],terrace_end[1]]],wind_angle,'xy')\\n terrace_end = (coords[0][0],coords[0][1],average_alt)\\n\\n image_passes.append(Image_Pass(terrace_start,terrace_end,average_alt,wind_angle))\\n else:\\n # Calculate terraces\\n index = 0\\n\\n current_altitude = 0\\n current_min_altitude = 0\\n current_max_altitude = 0\\n while index < len(altitude_profile):\\n if index + 3 > len(altitude_profile):\\n if current_altitude == 0:\\n for alt in range(0,2):\\n current_altitude += altitude_profile[index+alt]\\n current_altitude = current_altitude/3\\n for val in range(0,3):\\n current_terrace.append([x,y,current_altitude])\\n # Add all to current pass\\n terrace_start = current_terrace[0]\\n terrace_end = current_terrace[len(current_terrace)-1]\\n image_passes.append(Image_Pass(terrace_start,terrace_end,current_altitude,wind_angle))\\n break\\n\\n if len(current_terrace) == 0:\\n # Look ahead to find gradient\\n grad = altitude_profile[index+1] - altitude_profile[index]\\n grad += altitude_profile[index+2] - altitude_profile[index]\\n #grad += altitude_profile[index+3] - altitude_profile[index]\\n grad = grad/2\\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\\n x = coords[0][0]\\n y = coords[0][1]\\n if grad > 0:\\n current_altitude = altitude_profile[index]+max_alt_diff/2\\n current_terrace.append([x,y,current_altitude])\\n elif grad < 0:\\n current_altitude = altitude_profile[index]-max_alt_diff/2\\n current_terrace.append([x,y,current_altitude])\\n else:\\n current_altitude = altitude_profile[index]\\n current_terrace.append([x,y,current_altitude])\\n current_min_altitude = current_altitude - max_alt_diff/2\\n current_max_altitude = current_altitude + max_alt_diff/2\\n\\n else:\\n # Add to the terrace\\n if altitude_profile[index] > current_min_altitude and altitude_profile[index] < current_max_altitude:\\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\\n x = coords[0][0]\\n y = coords[0][1]\\n current_terrace.append([x,y,current_altitude])\\n elif altitude_profile[index+1] > current_min_altitude and altitude_profile[index+1] < current_max_altitude:\\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\\n x = coords[0][0]\\n y = coords[0][1]\\n current_terrace.append([x,y,current_altitude])\\n index += 1\\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\\n x = coords[0][0]\\n y = coords[0][1]\\n current_terrace.append([x,y,current_altitude])\\n elif altitude_profile[index+2] > current_min_altitude and altitude_profile[index+2] < current_max_altitude:\\n for val in range(0,2):\\n coords = convertCoords([[u,v+index+val]],wind_angle,'xy')\\n x = coords[0][0]\\n y = coords[0][1]\\n current_terrace.append([x,y,current_altitude])\\n index += 1\\n index -= 1\\n else:\\n if len(current_terrace) > min_terrace_len:\\n # Create new terrace\\n terrace_start = current_terrace[0]\\n terrace_end = current_terrace[len(current_terrace)-1]\\n image_passes.append(Image_Pass(terrace_start,terrace_end,current_altitude,wind_angle))\\n current_terrace = []\\n current_altitude = 0\\n else:\\n # Requires more image locations\\n print(\\\"Not long enough\\\")\\n coords = convertCoords([[u,v+index]],wind_angle,'xy')\\n x = coords[0][0]\\n y = coords[0][1]\\n current_terrace.append([x,y,current_altitude])\\n #current_max_altitude += max_alt_diff/2\\n #current_min_altitude -+ max_alt_diff/2\\n\\n index += 1\\n else:\\n pass\\n return image_passes\",\n \"def getAltitudeAngle(self):\\n return self._altitude\",\n \"def classifier(self):\\n\\n print \\\"Starting Classification\\\"\\n self.detections.rotationClass = [ self.detections.rotationTimeTags[index] for index, theta in enumerate(self.detections.rotations) if theta > 30]\\n if len(self.detections.rotationClass) < 1:\\n print \\\"Too little rotation hits\\\"\\n self.detections.classification = \\\"Too little rotation hits\\\"\\n\\n else:\\n \\n for attribute, value in classIterator(self.detections):\\n print value[1]\\n if 'crease' in attribute:\\n \\n if value[1] > self.detections.rotationClass[0] and value[1] < self.detections.rotationClass[-1]:\\n print \\\"direct hit\\\", attribute, value[1]\\n self.detections.classification = \\\"Direct hit\\\"\\n #if self.detections.\\n else:\\n for angleStamp in self.detections.rotationClass:\\n if secondsCount(value[1],angleStamp).total_seconds < 10:\\n self.detections.classification = \\\"Near miss\\\"\\n \\n else:\\n self.detections.classification = \\\"Nothing impressive\\\"\\n print \\\"Ending Classification\\\"\",\n \"def intersection_distances(self, altitude, start_distance, finish_distance):\\n distances = []\\n alt_index, alt_ratio = calculate_value_reference(self.distances,\\n start_distance)\\n start_alt = calculate_value(self.altitudes, alt_index, alt_ratio)\\n\\n finish_index, finish_ratio = calculate_value_reference(self.distances,\\n finish_distance)\\n while alt_index < finish_index:\\n next_index = alt_index + 1\\n next_ratio = 0.0\\n next_alt = calculate_value(self.altitudes, next_index, next_ratio)\\n\\n # Does this section span the given altitude?\\n if (next_alt != start_alt) and \\\\\\n (min(start_alt, next_alt) < altitude < max(start_alt, next_alt)):\\n delta = altitude - start_alt\\n denom = next_alt - start_alt\\n ratio = delta / denom\\n distance = calculate_value(self.distances, alt_index, ratio)\\n distances.append(distance)\\n\\n alt_index = next_index\\n alt_ratio = next_ratio\\n start_alt = next_alt\\n\\n if finish_ratio:\\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\\n # Does the last section span the given altitude?\\n if (start_alt != finish_alt) and \\\\\\n (min(start_alt, finish_alt) < altitude < max(start_alt, finish_alt)):\\n # Calculate the altitude at the end of the section to maximimse accuracy\\n next_alt = calculate_value(self.altitudes, finish_index, 1.0)\\n delta = altitude - start_alt\\n denom = next_alt - start_alt\\n ratio = delta / denom\\n distance = calculate_value(self.distances, alt_index, ratio)\\n distances.append(distance)\\n\\n return distances\",\n \"def ecef2LatLonAlt(x, y, z):\\n\\n # Calculate the polar eccentricity\\n ep = np.sqrt((EARTH.EQUATORIAL_RADIUS**2 - EARTH.POLAR_RADIUS**2)/(EARTH.POLAR_RADIUS**2))\\n\\n # Calculate the longitude\\n lon = np.arctan2(y, x)\\n\\n p = np.sqrt(x**2 + y**2)\\n\\n theta = np.arctan2( z*EARTH.EQUATORIAL_RADIUS, p*EARTH.POLAR_RADIUS)\\n\\n # Calculate the latitude\\n lat = np.arctan2(z + (ep**2)*EARTH.POLAR_RADIUS*np.sin(theta)**3, \\\\\\n p - (EARTH.E**2)*EARTH.EQUATORIAL_RADIUS*np.cos(theta)**3)\\n\\n # Get distance from Earth centre to the position given by geographical coordinates, in WGS84\\n N = EARTH.EQUATORIAL_RADIUS/math.sqrt(1.0 - (EARTH.E**2)*math.sin(lat)**2)\\n\\n \\n # Calculate the height in meters\\n\\n # Correct for numerical instability in altitude near exact poles (and make sure cos(lat) is not 0!)\\n if((np.abs(x) < 1000) and (np.abs(y) < 1000)):\\n alt = np.abs(z) - EARTH.POLAR_RADIUS\\n\\n else:\\n # Calculate altitude anywhere else\\n alt = p/np.cos(lat) - N\\n\\n\\n return lat, lon, alt\",\n \"def air_density(altitude):\\n p = pressure(altitude) # psf\\n t = temperature(altitude) # R\\n rho = p/(gas_constant*t) # lb/ft3\\n return rho\",\n \"def adience_resolve_class_label(age):\\n if age == '(0, 2)' or age == '2':\\n age_id = 0\\n elif age == '(4, 6)' or age == '3':\\n age_id = 1\\n elif age == '(8, 12)' or age == '(8, 23)' or age == '13':\\n age_id = 2\\n elif age == '(15, 20)' or age == '22':\\n age_id = 3\\n elif age == '(25, 32)' or age == '(27, 32)' or age in ['23', '29', '34', '35']:\\n age_id = 4\\n elif age == '(38, 42)' or age == '(38, 43)' or age == '(38, 48)' or age in ['36', '42', '45']:\\n age_id = 5\\n elif age == '(48, 53)' or age in ['46', '55']:\\n age_id = 6\\n elif age == '(60, 100)' or age in ['57', '58']:\\n age_id = 7\\n else:\\n raise ValueError(\\\"Not sure how to handle this age: {}\\\".format(age))\\n\\n return age_id\",\n \"def get_altitude(self, degrees=True):\\n if degrees:\\n return math.degrees(self.current_location.al)\\n else:\\n return self.current_location.al\",\n \"def classify(trainX, trainY, testX, testY):\\n trainC = getClasses(trainY)\\n P = estimatePosterior(trainX, trainC, testX)\\n E = fit(testX, P)\\n (e_rate, se, interval) = error.confidenceInterval(testY, E)\\n return (P, E, e_rate, se, interval)\",\n \"def impact_prediction(\\n radius: float,\\n target_altitude: float,\\n vertical_speed: float,\\n horizontal_speed: float,\\n surface_gravity: float,\\n ut: float,\\n):\\n fall_speed = -vertical_speed\\n downward_acceleration = (\\n surface_gravity - horizontal_speed * horizontal_speed / radius\\n )\\n\\n # do we already landed?\\n if target_altitude < 0:\\n return None, None\\n\\n # do we land?\\n if downward_acceleration < 0:\\n max_fall_distance = -(fall_speed * fall_speed) / (\\n 2.0 * downward_acceleration\\n )\\n if max_fall_distance < (target_altitude + 1.0):\\n return None, None\\n\\n sec_until_impact = (\\n -fall_speed\\n + math.sqrt(\\n fall_speed * fall_speed\\n + 2.0 * downward_acceleration * target_altitude\\n )\\n ) / downward_acceleration\\n\\n vertical_speed_at_impact = (\\n fall_speed + sec_until_impact * downward_acceleration\\n )\\n impact_speed = math.sqrt(\\n vertical_speed_at_impact * vertical_speed_at_impact\\n + horizontal_speed * horizontal_speed\\n )\\n impact_ut = sec_until_impact + ut\\n return impact_ut, impact_speed\",\n \"def ap_per_class(tp, conf, pred_cls, target_cls, plot=False, save_dir='.', names=()):\\n\\n # Sort by objectness\\n i = np.argsort(-conf)\\n tp, conf, pred_cls = tp[i], conf[i], pred_cls[i]\\n\\n # Find unique classes\\n unique_classes = np.unique(target_cls)\\n nc = unique_classes.shape[0] # number of classes, number of detections\\n\\n # Create Precision-Recall curve and compute AP for each class\\n px, py = np.linspace(0, 1, 1000), [] # for plotting\\n ap, p, r = np.zeros((nc, tp.shape[1])), np.zeros((nc, 1000)), np.zeros((nc, 1000))\\n for ci, c in enumerate(unique_classes):\\n i = pred_cls == c\\n n_l = (target_cls == c).sum() # number of labels\\n n_p = i.sum() # number of predictions\\n\\n if n_p == 0 or n_l == 0:\\n continue\\n else:\\n # Accumulate FPs and TPs\\n fpc = (1 - tp[i]).cumsum(0)\\n tpc = tp[i].cumsum(0)\\n\\n # Recall\\n recall = tpc / (n_l + 1e-16) # recall curve\\n r[ci] = np.interp(-px, -conf[i], recall[:, 0], left=0) # negative x, xp because xp decreases\\n\\n # Precision\\n precision = tpc / (tpc + fpc) # precision curve\\n p[ci] = np.interp(-px, -conf[i], precision[:, 0], left=1) # p at pr_score\\n\\n # AP from recall-precision curve\\n for j in range(tp.shape[1]):\\n ap[ci, j], mpre, mrec = compute_ap(recall[:, j], precision[:, j])\\n if plot and j == 0:\\n py.append(np.interp(px, mrec, mpre)) # precision at mAP@0.5\\n\\n # Compute F1 (harmonic mean of precision and recall)\\n f1 = 2 * p * r / (p + r + 1e-16)\\n\\n i = f1.mean(0).argmax() # max F1 index\\n return p[:, i], r[:, i], ap, f1[:, i], unique_classes.astype('int32')\",\n \"def add_altitude(chunk, flightHeightFile): \\n # Get the flight height\\n try:\\n # flightHeightFile = \\\"/SNOWDATA/SnowDrones-Processing/LDP/01-31-2020/RGB/100MEDIA/FlightHeight.txt\\\"\\n with open(flightHeightFile , 'r') as myfile:\\n data = myfile.read()\\n alt = int(data)\\n except:\\n alt = int(55)\\n\\n # Update flight altitudes\\n for camera in chunk.cameras:\\n if camera.reference.location:\\n coord = camera.reference.location\\n camera.reference.location = PhotoScan.Vector([coord.x, coord.y, alt])\",\n \"def alpha_profiles(image, attribute, adjacency=4,\\n image_name=None, filtering_rule='direct'):\\n atree = trees.AlphaTree(image, adjacency, image_name)\\n return create_profiles(atree, attribute, 'altitude', filtering_rule, 'alpha profiles')\",\n \"def calibrateElevation(self,elevation):\\n if len(self.values) == self.values.maxlen:\\n self.elevcomp = self.value / ((1.0 - ((elevation + self.heightAboveGround) * 0.3048 / 44330.0)) ** 5.255)\\n self.calibrated = True\\n else:\\n self.calibratedElevation = elevation\",\n \"def __init__(self,\\n\\t MAX_ALTITUDE: int,\\n\\t priority: int,\\n\\t channels: List[int],\\n\\t kP: float = 0.002,\\n\\t kI: float = 0.0,\\n\\t kD: float = 0.00085,\\n\\t available = False\\n\\t ):\\n\\t\\tself._altHoldController = AltitudeController(kP=kP, kI=kI, kD=kD)\\n\\t\\tself._altH_priority = priority\\n\\t\\tself._altH_channels = channels\\n\\t\\tself._altHoldController.setAvailability(available)\\n\\t\\tself._altH_checkAvMethod = self._altHoldController.isAvailable\\n\\t\\tself._altH_getLockMethod = self._altHoldController.getLock\\n\\t\\tself._taking_off = True\\n\\t\\tself._landing = False\\n\\t\\tself._actual_alt = 0\\n\\t\\tself._MAX_ALTITUDE = MAX_ALTITUDE\\n\\t\\tself._last_call = time.time()\\n\\t\\tself._ready_to_fly = False\",\n \"def eval(self):\\n target_truth_labels = self.get_target_labels()\\n for key in self.id_uncertainty_measures.keys():\\n # deep copy needed as we mutate confidence values later on\\n decision_fn_value = np.concatenate((copy.deepcopy(self.id_uncertainty_measures[key]),\\n copy.deepcopy(self.ood_uncertainty_measures[key])),\\n axis=0)\\n # negation needed for confidence, as confidence is indicator of label=0 samples\\n # i.e for correct classified samples.\\n # But we need scores for label=1 samples i.e misclassified samples\\n # to be higher, so we negate.\\n if key == UncertaintyMeasuresEnum.CONFIDENCE or key == UncertaintyMeasuresEnum.PRECISION:\\n decision_fn_value *= -1.0\\n\\n aupr, auroc = ClassifierPredictionEvaluator.compute_pr_roc_curves(\\n decision_fn_value, target_truth_labels, self.result_dir, key._value_)\\n\\n with open(os.path.join(self.result_dir, 'results.txt'), 'a') as f:\\n f.write('AUPR using ' + key._value_ + \\\": \\\" +\\n str(np.round(aupr * 100.0, 1)) + '\\\\n')\\n f.write('AUROC using ' + key._value_ + \\\": \\\" +\\n str(np.round(auroc * 100.0, 1)) + '\\\\n')\",\n \"def __init__(self, type, high_elevation, low_elevation):\\n\\t\\tself.type = type\\n\\t\\tself.high_elevation = high_elevation\\n\\t\\tself.low_elevation = low_elevation\\n\\t\\tself.occupant = 0 # use 0 to initilize tile which \\n\\t\\t\\t\\t\\t\\t\\t# means it has not been explored.\\n\\t\\tif type == \\\"plains\\\": # initialize the shade\\n\\t\\t\\tself.terrain = \\\" \\\"\\n\\t\\telse:\\n\\t\\t\\tself.terrain = \\\"#\\\"\",\n \"def arm_and_takeoff_nogps(aTargetAltitude):\\n\\n print(\\\"Taking of to an altitude of \\\", str(aTargetAltitude))\\n\\n print(\\\"Basic pre-arm checks\\\")\\n\\n while not vehicle.is_armable:\\n print(\\\" Waiting for vehicle to initialise...\\\")\\n time.sleep(1)\\n\\n print(\\\"Arming motors\\\")\\n # Copter should arm in GUIDED_NOGPS mode\\n vehicle.mode = VehicleMode(\\\"GUIDED_NOGPS\\\")\\n vehicle.armed = True\\n\\n while not vehicle.armed:\\n print(\\\" Waiting for arming...\\\")\\n vehicle.armed = True\\n time.sleep(1)\\n\\n print(\\\"Taking off!\\\")\\n\\n thrust = DEFAULT_TAKEOFF_THRUST\\n while True:\\n current_altitude = vehicle.location.global_relative_frame.alt\\n print(\\\" Altitude: %f Desired: %f\\\" %\\n (current_altitude, aTargetAltitude))\\n if current_altitude >= aTargetAltitude*0.95: # Trigger just below target alt.\\n print(\\\"Reached target altitude\\\")\\n break\\n elif current_altitude >= aTargetAltitude*0.6:\\n thrust = SMOOTH_TAKEOFF_THRUST\\n set_attitude(thrust = thrust)\\n time.sleep(0.2)\",\n \"def eval_det(pred_all, gt_all, ovthresh=0.25, use_07_metric=False):\\n pred = {} # map {classname: pred}\\n gt = {} # map {classname: gt}\\n for img_id in pred_all.keys():\\n for classname, bbox, score in pred_all[img_id]:\\n if classname not in pred: pred[classname] = {}\\n if img_id not in pred[classname]:\\n pred[classname][img_id] = []\\n if classname not in gt: gt[classname] = {}\\n if img_id not in gt[classname]:\\n gt[classname][img_id] = []\\n pred[classname][img_id].append((bbox,score))\\n for img_id in gt_all.keys():\\n for classname, bbox in gt_all[img_id]:\\n if classname not in gt: gt[classname] = {}\\n if img_id not in gt[classname]:\\n gt[classname][img_id] = []\\n gt[classname][img_id].append(bbox)\\n\\n rec = {}\\n prec = {}\\n ap = {}\\n for classname in gt.keys():\\n print('Computing AP for class: ', classname)\\n rec[classname], prec[classname], ap[classname] = eval_det_cls(pred[classname], gt[classname], ovthresh, use_07_metric)\\n print(classname, ap[classname])\\n \\n return rec, prec, ap\",\n \"def create_profiles(tree, attribute, out_feature='altitude',\\n filtering_rule='direct', profiles_name='unknow'):\\n data = []\\n description = []\\n\\n # Create Trees\\n try:\\n if isinstance(tree, trees.Tree):\\n # Dual tree\\n ndual = False\\n thinning_tree = None\\n thickening_tree = tree\\n else:\\n # Non dual trees\\n ndual = True\\n thinning_tree = tree[0]\\n thickening_tree = tree[1]\\n except:\\n raise TypeError('Parameter tree_type must be a tuple or a single' \\\\\\n ' instance of Tree, not {}'.format(tree))\\n\\n out_features = (out_feature, ) if isinstance(out_feature, str) else out_feature\\n\\n iter_count = (sum(len(x) for x in attribute.values()) * (1 + ndual) + \\\\\\n len(attribute)) * len(out_features)\\n ttq = tqdm(desc='Total', total=iter_count)\\n for att, thresholds in attribute.items():\\n tq = tqdm(total=(len(thresholds) * (1 + ndual) + 1) * len(out_features), desc=att)\\n\\n for out_feature in out_features:\\n profiles = []; profiles_description = []\\n of = att if out_feature == 'same' else out_feature\\n\\n if ndual:\\n # thinning\\n prof, desc = _compute_profiles(thinning_tree, att,\\n thresholds[::-1], (ttq, tq), of, filtering_rule)\\n profiles += prof\\n profiles_description += desc\\n\\n # Origin\\n tq.update(); ttq.update()\\n profiles += [thickening_tree.reconstruct(feature=of)]\\n profiles_description += [{'operation': 'copy feature {}'.format(of)}]\\n\\n # thickening\\n prof, desc = _compute_profiles(thickening_tree, att, thresholds,\\n (ttq, tq), of, filtering_rule)\\n profiles += prof\\n profiles_description += desc\\n\\n\\n data += [np.stack(profiles)]\\n description += [{'tree': thickening_tree.get_params(),\\n 'name': profiles_name,\\n 'attribute': att,\\n 'profiles': profiles_description,\\n 'filtering rule': filtering_rule,\\n 'out feature': of}]\\n tq.close()\\n ttq.close()\\n\\n return Profiles(data, description)\",\n \"def getAltitudeFromLatLon(self, lat, lon):\\r\\n # print \\\"-----\\\\nFromLatLon\\\", lon, lat\\r\\n lat -= self.lat\\r\\n lon -= self.lon\\r\\n # print \\\"lon, lat\\\", lon, lat\\r\\n if lat < 0.0 or lat >= 1.0 or lon < 0.0 or lon >= 1.0:\\r\\n raise WrongTileError(self.lat, self.lon, self.lat+lat, self.lon+lon)\\r\\n x = lon * (self.size - 1)\\r\\n y = lat * (self.size - 1)\\r\\n # print \\\"x,y\\\", x, y\\r\\n x_int = int(x)\\r\\n x_frac = x - int(x)\\r\\n y_int = int(y)\\r\\n y_frac = y - int(y)\\r\\n # print \\\"frac\\\", x_int, x_frac, y_int, y_frac\\r\\n value00 = self.getPixelValue(x_int, y_int)\\r\\n value10 = self.getPixelValue(x_int+1, y_int)\\r\\n value01 = self.getPixelValue(x_int, y_int+1)\\r\\n value11 = self.getPixelValue(x_int+1, y_int+1)\\r\\n value1 = self._avg(value00, value10, x_frac)\\r\\n value2 = self._avg(value01, value11, x_frac)\\r\\n value = self._avg(value1, value2, y_frac)\\r\\n # print \\\"%4d %4d | %4d\\\\n%4d %4d | %4d\\\\n-------------\\\\n%4d\\\" % (\\r\\n # value00, value10, value1, value01, value11, value2, value)\\r\\n return value\",\n \"def classify(self, patch):\\n if self.algorithm == 'adaboost':\\n ret = 0\\n for t in range(0, len(self.classifiers)):\\n wc = self.classifiers[t]\\n a = wc.alpha\\n ret += wc.classify(patch) * a\\n return np.sign(ret)\\n elif self.algorithm == 'wald':\\n for t in range(0, len(self.classifiers)):\\n h_ = self.h_t(patch, t)\\n wc = self.classifiers[t]\\n if h_ >= wc.theta_b:\\n return +1\\n if h_ <= wc.theta_a:\\n return -1\\n if self.h_t(patch, self.layers) > self.gamma:\\n return +1\\n else:\\n return -1\",\n \"def classify(self, patch):\\n if self.algorithm == 'adaboost':\\n ret = 0\\n for t in range(0, len(self.classifiers)):\\n wc = self.classifiers[t]\\n a = wc.alpha\\n ret += wc.classify(patch) * a\\n return np.sign(ret)\\n elif self.algorithm == 'wald':\\n for t in range(0, len(self.classifiers)):\\n h_ = self.h_t(patch, t)\\n wc = self.classifiers[t]\\n if h_ >= wc.theta_b:\\n return +1\\n if h_ <= wc.theta_a:\\n return -1\\n if self.h_t(patch, self.layers) > self.gamma:\\n return +1\\n else:\\n return -1\",\n \"def eval_pascal_one_class(pascal, detections, c):\\n gts = {} \\n num_objs = 0 \\n for img_name in pascal:\\n gts[img_name] = []\\n for obj in pascal[img_name]:\\n if obj['class_id'] == c and obj['difficult']==0:\\n gts[img_name] += [{'bbox':obj['bbox'], 'detected': False}]\\n num_objs += 1\\n\\n dts = []\\n scores = []\\n num_dets = 0\\n for img_name in detections:\\n for dt in detections[img_name]:\\n if dt['class_id'] == c:\\n dts.append([img_name, dt['bbox'], dt['score']])\\n scores.append(dt['score'])\\n num_dets += 1\\n \\n # Sort the detections based on their scores\\n scores = np.array(scores, np.float32)\\n sorted_idx = np.argsort(scores)[::-1]\\n\\n tp = np.zeros((num_dets))\\n fp = np.zeros((num_dets))\\n\\n for i in tqdm(list(range(num_dets))):\\n idx = sorted_idx[i]\\n img_name = dts[idx][0]\\n bbox = dts[idx][1] \\n gt_bboxes = np.array([obj['bbox'] for obj in gts[img_name]], np.float32) \\n\\n # Compute the max IoU of current detection with the ground truths\\n max_iou = 0.0\\n if gt_bboxes.size > 0:\\n ixmin = np.maximum(gt_bboxes[:, 0], bbox[0])\\n iymin = np.maximum(gt_bboxes[:, 1], bbox[1])\\n ixmax = np.minimum(gt_bboxes[:, 2], bbox[2])\\n iymax = np.minimum(gt_bboxes[:, 3], bbox[3])\\n\\n iw = np.maximum(ixmax - ixmin + 1.0, 0.0)\\n ih = np.maximum(iymax - iymin + 1.0, 0.0)\\n\\n area_intersect = iw * ih\\n area_union = (bbox[2] - bbox[0] + 1.0) * (bbox[3] - bbox[1] + 1.0) + (gt_bboxes[:, 2] - gt_bboxes[:, 0] + 1.0) * (gt_bboxes[:, 3] - gt_bboxes[:, 1] + 1.0) - area_intersect\\n\\n ious = area_intersect / area_union\\n max_iou = np.max(ious, axis=0)\\n j = np.argmax(ious)\\n\\n # Determine if the current detection is a true or false positive\\n if max_iou > 0.5:\\n if not gts[img_name][j]['detected']:\\n tp[i] = 1.0\\n gts[img_name][j]['detected'] = True\\n else:\\n fp[i] = 1.0\\n else:\\n fp[i] = 1.0\\n\\n # Accumulate the numbers of true and false positives\\n tp = np.cumsum(tp)\\n fp = np.cumsum(fp)\\n\\n # Compute the average precision based on these data\\n rec = tp * 1.0 / num_objs\\n prec = tp * 1.0 / np.maximum((tp + fp), np.finfo(np.float64).eps)\\n\\n mrec = np.concatenate(([0.], rec, [1.]))\\n mpre = np.concatenate(([0.], prec, [0.]))\\n\\n for i in range(mpre.size - 1, 0, -1):\\n mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])\\n\\n i = np.where(mrec[1:] != mrec[:-1])[0]\\n\\n ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])\\n print('average precision for class %s = %f' %(pascal_class_names[c], ap))\\n\\n return ap\",\n \"def attribute_profiles(image, attribute, adjacency=4, image_name=None,\\n filtering_rule='direct'):\\n maxt = trees.MaxTree(image, adjacency, image_name)\\n mint = trees.MinTree(image, adjacency, image_name)\\n\\n return create_profiles((mint, maxt), attribute, 'altitude',\\n filtering_rule, 'attribute profiles')\",\n \"def is_in_imagenet(self, ade_class):\\n spaced_class = \\\" \\\".join(ade_class.split(\\\"_\\\"))\\n for imagenet_class in self.IMAGENET_CLASSES:\\n if spaced_class in imagenet_class.split(\\\", \\\"):\\n logger.debug(f\\\"ADE20K class: {spaced_class} is in imagenet: {imagenet_class.split(', ')}\\\")\\n return self.IMAGENET_CLASSES[imagenet_class]\\n return None\",\n \"def altitude(p):\\r\\n \\r\\n R = 290 #specific gas constant \\r\\n T = 93.65 #surface temperature K from A.Coustenis book\\r\\n g = 1.354 #surface gravity from A.Coustenis book\\r\\n p0 = 1467 #surface pressure in hPa 6.1 for mars\\r\\n \\r\\n z = np.empty_like(p)\\r\\n \\r\\n for i in range(p.shape[0]):\\r\\n z[i] = (-1)*(R*T/g)*np.log((p[i])/p0)/(10**3)\\r\\n \\r\\n # Make into an xarray DataArray\\r\\n z_xr = xr.DataArray(z, coords=[z], dims=['pfull'])\\r\\n z_xr.attrs['units'] = 'km'\\r\\n \\r\\n #below is the inverse of the calculation\\r\\n #p[i] = p0*np.exp((-1)*z[i]*(10**3)/((R*T/g)))\\r\\n \\r\\n return z_xr\",\n \"def image_prediction(self, type, zenith, azimuth, energy, impact, x_max, pix_x, pix_y):\\n\\n return self.prediction[type].interpolate([energy, impact,\\n x_max], pix_x, pix_y)\",\n \"def update_unsupervised_target(ensemble_prediction, y, num_class, alpha, cur_pred, epoch):\\n # Z = αZ + (1 - α)z\\n ensemble_prediction = alpha * ensemble_prediction + (1 - alpha) * cur_pred\\n\\n # initial_epoch = 0\\n y[:, 0:num_class] = ensemble_prediction / (1 - alpha ** (epoch + 1))\\n\\n return ensemble_prediction, y\",\n \"def eval_det_cls(pred, gt, ovthresh=0.25, use_07_metric=False):\\n\\n # construct gt objects\\n class_recs = {} # {img_id: {'bbox': bbox list, 'det': matched list}}\\n npos = 0\\n for img_id in gt.keys():\\n bbox = np.array(gt[img_id])\\n det = [False] * len(bbox)\\n npos += len(bbox)\\n class_recs[img_id] = {'bbox': bbox, 'det': det}\\n # pad empty list to all other imgids\\n for img_id in pred.keys():\\n if img_id not in gt:\\n class_recs[img_id] = {'bbox': np.array([]), 'det': []}\\n\\n # construct dets\\n image_ids = []\\n confidence = []\\n BB = []\\n for img_id in pred.keys():\\n for box,score in pred[img_id]:\\n image_ids.append(img_id)\\n confidence.append(score)\\n BB.append(box)\\n confidence = np.array(confidence)\\n BB = np.array(BB) # (nd,4 or 8,3)\\n\\n # sort by confidence\\n sorted_ind = np.argsort(-confidence)\\n sorted_scores = np.sort(-confidence)\\n BB = BB[sorted_ind, ...]\\n image_ids = [image_ids[x] for x in sorted_ind]\\n\\n # go down dets and mark TPs and FPs\\n nd = len(image_ids)\\n tp = np.zeros(nd)\\n fp = np.zeros(nd)\\n for d in range(nd):\\n if d%100==0: \\n print(d)\\n R = class_recs[image_ids[d]]\\n bb = BB[d,:].astype(float)\\n ovmax = -np.inf\\n BBGT = R['bbox'].astype(float)\\n\\n if BBGT.size > 0:\\n # compute overlaps\\n for j in range(BBGT.shape[0]):\\n iou = get_iou(bb, BBGT[j,...]) \\n if iou > ovmax:\\n ovmax = iou\\n jmax = j\\n\\n #print d, ovmax\\n if ovmax > ovthresh:\\n if not R['det'][jmax]:\\n tp[d] = 1.\\n R['det'][jmax] = 1\\n else:\\n fp[d] = 1.\\n else:\\n fp[d] = 1.\\n\\n # compute precision recall\\n fp = np.cumsum(fp)\\n tp = np.cumsum(tp)\\n rec = tp / float(npos)\\n print('NPOS: ', npos)\\n print('ND:', nd)\\n # avoid divide by zero in case the first detection matches a difficult\\n # ground truth\\n prec = tp / np.maximum(tp + fp, np.finfo(np.float64).eps)\\n ap = voc_ap(rec, prec, use_07_metric)\\n\\n return rec, prec, ap\",\n \"def _load_pascal_annotation(self, index):\\n imagefile = os.path.join(self._data_path, 'Images', index + self._image_ext)\\n labelfile = os.path.join(self._data_path, 'GroundTruth', index + '.txt')\\n print 'Loading: image {} and label {}'.format(imagefile, labelfile)\\n\\n labels = np.loadtxt(labelfile) + 1\\n image = cv2.imread(imagefile)\\n\\n gt_classes = []\\n gt_boxes = []\\n\\n boxes, classes = self._get_boxes(image, labels)\\n\\n boxes = np.array(boxes)\\n classes = np.array(classes)\\n\\n scores = np.ones(len(boxes), dtype=np.float32)\\n dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32)\\n\\n # keep = nms(dets, 0.2)\\n _, keep = non_max_suppression_fast(dets, 0.2)\\n boxes = boxes[keep, :]\\n classes = classes[keep]\\n\\n for n, (x, y, w, h) in enumerate(boxes):\\n # gt_boxes.append([min(x, w), min(y, h), min(abs(w - x), w), min(abs(h - y), h)])\\n gt_boxes.append([x, y, w - x, h - y])\\n gt_classes.append(classes[n])\\n\\n overlaps = np.zeros((len(gt_boxes), len(self._classes)), dtype=np.float32)\\n for n, obj in enumerate(gt_boxes):\\n overlaps[n, gt_classes[n]] = 1.0\\n\\n overlaps = scipy.sparse.csr_matrix(overlaps)\\n\\n return {'boxes': np.array(gt_boxes),\\n 'gt_classes': np.array(gt_classes, dtype=np.int32),\\n 'gt_overlaps': overlaps,\\n 'flipped': False}\\n\\n # def get_data_from_tag(node, tag):\\n # return node.getElementsByTagName(tag)[0].childNodes[0].data\\n\\n # with open(filename) as f:\\n # data = minidom.parseString(f.read())\\n\\n # objs = data.getElementsByTagName('object')\\n # num_objs = len(objs)\\n\\n # boxes = np.zeros((num_objs, 4), dtype=np.uint16)\\n # gt_classes = np.zeros((num_objs), dtype=np.int32)\\n # overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32)\\n\\n # # Load object bounding boxes into a data frame.\\n # for ix, obj in enumerate(objs):\\n # # Make pixel indexes 0-based\\n # x1 = float(get_data_from_tag(obj, 'xmin')) - 1\\n # y1 = float(get_data_from_tag(obj, 'ymin')) - 1\\n # x2 = float(get_data_from_tag(obj, 'xmax')) - 1\\n # y2 = float(get_data_from_tag(obj, 'ymax')) - 1\\n # cls = self._class_to_ind[str(get_data_from_tag(obj, \\\"name\\\")).lower().strip()]\\n # boxes[ix, :] = [x1, y1, x2, y2]\\n # gt_classes[ix] = cls\\n # overlaps[ix, cls] = 1.0\\n\\n # overlaps = scipy.sparse.csr_matrix(overlaps)\\n\\n # return {'boxes': boxes,\\n # 'gt_classes': gt_classes,\\n # 'gt_overlaps': overlaps,\\n # 'flipped': False}\",\n \"def density(self, alt):\\n (Z, T, CN2, CO2, CO, CAr, CHe, CH, CM, WM) = self.altitude_profile(alt)\\n\\n # using eqn(42) of COESA for multiple gases\\n M_i = [wmN2, wmO2, wmO, wmAr, wmHe, wmH] << (u.g / u.mol)\\n n_i = [\\n CN2.to_value(u.m**-3),\\n CO2.to_value(u.m**-3),\\n CO.to_value(u.m**-3),\\n CAr.to_value(u.m**-3),\\n CHe.to_value(u.m**-3),\\n CH.to_value(u.m**-3),\\n ] << (1 / u.m**3)\\n rho = (n_i @ M_i) / Na\\n return rho.to(u.kg / u.m**3)\",\n \"def ap_per_class(tp, conf, pred_cls, target_cls):\\n\\n # lists/pytorch to numpy\\n tp, conf, pred_cls, target_cls = np.array(tp), np.array(conf.cpu().data), np.array(pred_cls.cpu().data), np.array(target_cls)\\n\\n # Sort by objectness\\n i = np.argsort(-conf)\\n tp, conf, pred_cls = tp[i], conf[i], pred_cls[i]\\n\\n # Find unique classes\\n unique_classes = np.unique(np.concatenate((pred_cls, target_cls), 0))\\n\\n # Create Precision-Recall curve and compute AP for each class\\n ap = []\\n for c in unique_classes:\\n i = pred_cls == c\\n n_gt = sum(target_cls == c) # Number of ground truth objects\\n n_p = sum(i) # Number of predicted objects\\n\\n if (n_p == 0) and (n_gt == 0):\\n continue\\n elif (np == 0) and (n_gt > 0):\\n ap.append(0)\\n elif (n_p > 0) and (n_gt == 0):\\n ap.append(0)\\n else:\\n # Accumulate FPs and TPs\\n fpa = np.cumsum(1 - tp[i])\\n tpa = np.cumsum(tp[i])\\n\\n # Recall\\n recall = tpa / (n_gt + 1e-16)\\n\\n # Precision\\n precision = tpa / (tpa + fpa)\\n\\n # AP from recall-precision curve\\n ap.append(compute_ap(recall, precision))\\n\\n return np.array(ap)\",\n \"def classifyExonStats(actual, predicted, ref, classifiedexons):\\n\\tactualexons = actual.exonList(ref)\\n\\tpredictedexons = predicted.exonList(ref)\\n\\texon = [{'Wrong':0, 'Partial':0, 'Correct':0}, {'Wrong':0, 'Partial':0, 'Correct':0}]\\n\\t\\n\\tfor (astart, aend) in actualexons:\\n\\t\\tcategory = 'Wrong'\\n\\t\\tfor (pstart, pend) in predictedexons:\\n\\t\\t\\tif (pstart, pend) == (astart, aend):\\n\\t\\t\\t\\tcategory = 'Correct'\\n\\t\\t\\t\\tbreak\\n\\t\\t\\telif (pstart <= astart and pend >= astart) or (astart <= pstart and aend >= pend):\\n\\t\\t\\t\\tcategory ='Partial'\\n\\t\\t\\t\\tbreak\\n\\t\\texon[0][category] += 1\\n\\tfor (pstart, pend) in predictedexons:\\n\\t\\tcategory = 'Wrong'\\n\\t\\tfor (astart, aend) in actualexons:\\n\\t\\t\\tif (pstart, pend) == (astart, aend):\\n\\t\\t\\t\\tcategory = 'Correct'\\n\\t\\t\\t\\tbreak\\n\\t\\t\\telif (astart <= pstart and aend >= pend) or (pstart <= astart and pend >= astart):\\n\\t\\t\\t\\tcategory ='Partial'\\n\\t\\t\\t\\tbreak\\n\\t\\texon[1][category] += 1\\n\\tclassifiedexons['ME'] += exon[0]['Wrong']\\n\\tclassifiedexons['WE'] += exon[1]['Wrong']\\n\\tclassifiedexons['PE'] += (exon[1]['Partial'] + exon[0]['Partial'])/2\\n\\tclassifiedexons['CE'] += exon[1]['Correct']\",\n \"def accuracy(cls, test_labels):\\n N = len(test_labels)\\n\\n # Calculate total correct as precentage\\n total_correct = 100*(N - np.count_nonzero(cls - test_labels))/N\\n\\n # Calculate precentag correct for each class\\n lab = np.unique(test_labels)\\n cls_correct = {}\\n for label in lab:\\n idx = np.where(test_labels == label)[0]\\n N_cls = len(idx)\\n cls_correct[label] = 100*(N_cls - np.count_nonzero(label -\\n cls[idx]))/N_cls\\n\\n print(\\\"Accuracy for:\\\")\\n print(\\\"All classes is %.2f%%\\\" % total_correct)\\n for label in lab:\\n print(\\\"Class %d is %.2f%%\\\" % (label, cls_correct[label]))\\n return(total_correct, cls_correct)\",\n \"def generate_elevation_profile(line):\\n\\n elem = from_shape(line, 4326)\\n line_cte = db.session.query(\\n func.ST_Transform(elem, 28992).label(\\\"geom\\\")).cte(name=\\\"line\\\")\\n\\n cells_cte = db.session.query(\\n # Get the centroid of the cell which intersects our line\\n func.ST_Centroid(\\n # Type coerce the return value so we van access the `geom` and\\n # `val` attributes\\n type_coerce(\\n func.ST_Intersection(AHNRaster.rast, line_cte.c.geom),\\n RasterIntersection()\\n ).geom\\n ).label(\\\"geom\\\"),\\n type_coerce(\\n func.ST_Intersection(AHNRaster.rast, line_cte.c.geom),\\n RasterIntersection()\\n ).val.label(\\\"val\\\")\\n ).filter(\\n func.ST_Intersects(AHNRaster.rast, line_cte.c.geom)\\n ).cte(name=\\\"cells\\\")\\n\\n height_data_cte = db.session.query(\\n func.ST_Transform(\\n func.ST_SetSrid(func.ST_MakePoint(\\n func.ST_X(cells_cte.c.geom), func.ST_Y(cells_cte.c.geom),\\n ), 28992),\\n 4326\\n ).label(\\\"point\\\"),\\n # Select value separately instead of a Point with Z value because\\n # geoalchemy and shapely do not really play nicely with higher order\\n # geometries\\n cells_cte.c.val.label(\\\"val\\\"),\\n line_cte\\n ).order_by(func.ST_X(cells_cte.c.geom)).cte(name=\\\"height_data\\\")\\n\\n return db.session.query(height_data_cte.c.point, height_data_cte.c.val)\",\n \"def elevation(self):\\n return self.altitude - self.heightAboveGround\",\n \"def accuracy(self):\",\n \"def get_accuracy(self, output, target, target_weight):\\n accuracy = dict()\\n if self.target_type == 'GaussianHeatmap':\\n _, avg_acc, _ = pose_pck_accuracy(output[-1].detach().cpu().numpy(), target.detach().cpu().numpy(), target_weight.detach().cpu().numpy().squeeze(-1) > 0)\\n accuracy['acc_pose'] = float(avg_acc)\\n return accuracy\",\n \"def keypoint_pck_accuracy(pred, gt, mask, thr, normalize):\\n distances = _calc_distances(pred, gt, mask, normalize)\\n acc = np.array([_distance_acc(d, thr) for d in distances])\\n valid_acc = acc[acc >= 0]\\n cnt = len(valid_acc)\\n avg_acc = valid_acc.mean() if cnt > 0 else 0\\n return acc, avg_acc, cnt\",\n \"def get_accuracy(self, output, target, target_weight):\\n accuracy = dict()\\n if self.target_type.lower() == 'GaussianHeatmap'.lower():\\n _, avg_acc, _ = pose_pck_accuracy(output.detach().cpu().numpy(), target.detach().cpu().numpy(), target_weight.detach().cpu().numpy().squeeze(-1) > 0)\\n accuracy['acc_pose'] = float(avg_acc)\\n return accuracy\",\n \"def is_cruising(altitude, cruise_altitude=None):\\n if cruise_altitude is None:\\n cruise_altitude = closest_cruising_altitude(altitude)\\n return abs(altitude - cruise_altitude) <= 200\",\n \"def AEH2LatLonAlt(azim, elev, h, lat, lon, alt):\\n\\n # Compute the range to the point\\n r = AEH2Range(azim, elev, h, lat, lon, alt)\\n\\n\\n # Compute lat/lon/alt of the point on the line of sight\\n x, y, z = AER2ECEF(azim, elev, r, lat, lon, alt)\\n lat2, lon2, alt2 = ecef2LatLonAlt(x, y, z)\\n lat2, lon2 = np.degrees(lat2), np.degrees(lon2)\\n\\n\\n return lat2, lon2, alt2\",\n \"def get_accuracy(self, output, target, target_weight):\\n accuracy = dict()\\n if self.target_type == 'GaussianHeatmap':\\n _, avg_acc, _ = pose_pck_accuracy(output.detach().cpu().numpy(), target.detach().cpu().numpy(), target_weight.detach().cpu().numpy().squeeze(-1) > 0)\\n accuracy['acc_pose'] = float(avg_acc)\\n return accuracy\",\n \"def calculate_accuracy(ground_truth_object_list, pred_object_list):\\n\\n ground_truth_list = np.zeros((1,10))\\n pred_list = np.zeros((1,10))\\n \\n for gt_index in range(len(ground_truth_object_list)):\\n \\n intClass_ground_truth = classMappingDict[ground_truth_object_list[gt_index]['name']]\\n ground_truth_list[0][intClass_ground_truth] = ground_truth_list[0][intClass_ground_truth] + 1\\n\\n for pred_index in range(len(pred_object_list)):\\n\\n intClass_pred = classMappingDict[pred_object_list[pred_index]['name']]\\n pred_list[0][intClass_pred] = pred_list[0][intClass_pred] + 1\\n return ground_truth_list, pred_list\",\n \"def change_altitude_cm_m(data_array):\\n data_array[:, 3] = data_array[:, 3]*0.3048\\n return data_array\",\n \"def altaz_to_offset(obj_azimuth,obj_altitude,azimuth,altitude):\\n\\n daz = obj_azimuth - azimuth\\n coa = cos(obj_altitude)\\n\\n xp0 = -cos(daz) * coa\\n yp0 = sin(daz) * coa\\n zp0 = sin(obj_altitude)\\n\\n cx = sin(altitude)\\n sx = cos(altitude)\\n\\n xp1 = cx*xp0 + sx*zp0\\n yp1 = yp0\\n zp1 = -sx*xp0 + cx*zp0\\n\\n q = arccos(zp1)\\n d = tan(q)\\n alpha = arctan2(yp1,xp1)\\n\\n xoff = d * cos(alpha)\\n yoff = d * sin(alpha)\\n\\n return xoff,yoff\",\n \"def predict_qth(self):\\n return (self.latitude, -self.longitude, self.altitude)\",\n \"def get_accuracy(self, output, target, target_weight):\\n accuracy = dict()\\n if self.target_type == 'GaussianHeatmap':\\n assert isinstance(output, list)\\n assert target.dim() == 5 and target_weight.dim() == 4\\n _, avg_acc, _ = pose_pck_accuracy(output[-1].detach().cpu().numpy(), target[:, -1, ...].detach().cpu().numpy(), target_weight[:, -1, ...].detach().cpu().numpy().squeeze(-1) > 0)\\n accuracy['acc_pose'] = float(avg_acc)\\n return accuracy\",\n \"def TileInfoLoaderCfg(flags, **kwargs):\\n\\n from AthenaCommon.Logging import logging\\n msg = logging.getLogger('TileInfoLoaderCfg')\\n\\n from TileConditions.TileCablingSvcConfig import TileCablingSvcCfg\\n acc = ComponentAccumulator()\\n acc.merge (TileCablingSvcCfg(flags))\\n\\n if 'NoiseScaleIndex' not in kwargs:\\n if flags.Tile.doOpt2 and not flags.Tile.doOptATLAS:\\n msg.info(\\\"Adjusting TileInfo to return cell noise for Opt.Filter with iterations\\\")\\n kwargs['NoiseScaleIndex'] = 2 # Noise for Optimal Filter with iterations\\n else:\\n msg.info(\\\"Adjusting TileInfo to return cell noise for Opt.Filter without iterations\\\")\\n kwargs['NoiseScaleIndex'] = 1 # Noise for Optimal Filter without iterations\\n\\n\\n if (flags.Input.isMC or flags.Detector.OverlayTile) and ('TileHitVec' in flags.Input.Collections or 'TileHitVec' in flags.Input.SecondaryCollections):\\n\\n G4Version = flags.Sim.G4Version\\n G4VersionMajor, G4VersionMinor = G4Version.split(\\\".\\\")[1:3]\\n G4V = int(G4VersionMajor) + int(G4VersionMinor) / 100.\\n\\n physicsList = flags.Sim.PhysicsList\\n\\n if 'EmScaleA' not in kwargs:\\n\\n # Default value since May-2011\\n EmScaleA = 34.0\\n\\n # Default value for G4 9.6 since Nov-2013 (need to check G4 version as well)\\n if physicsList == 'FTFP_BERT' or (physicsList == 'QGSP_BERT' and G4V > 9.05999) :\\n EmScaleA = 33.9\\n\\n # Default value for G4 10.0 since June-2016\\n # see https://indico.cern.ch/event/489520/contributions/2193913/attachments/1285565/1914309/sampling_fractions.pdf\\n if G4V >= 10.0 :\\n EmScaleA = 33.7\\n\\n # Old value\\n if physicsList == 'QGSP_EMV' or physicsList == 'QGSP_BERT_EMV' or physicsList == '':\\n EmScaleA = 35.9\\n\\n kwargs['EmScaleA'] = EmScaleA # 1/s.f. value for all normal cells\\n\\n else:\\n EmScaleA = kwargs['EmScaleA']\\n\\n msg.info(\\\"Using 1/s.f. = %s for %s physics list and G4version %s (%s)\\\", EmScaleA, physicsList, G4V, G4Version)\\n\\n kwargs.setdefault('TileNoise', flags.Digitization.DoCaloNoise)\\n if kwargs['TileNoise']:\\n msg.info(\\\"Switching ON noise in Tile Digitization\\\" )\\n else:\\n msg.info(\\\"Switching OFF noise in Tile Digitization\\\" )\\n\\n\\n TileInfoLoader=CompFactory.TileInfoLoader\\n acc.addService(TileInfoLoader(**kwargs), primary = True)\\n\\n return acc\",\n \"def __init__(self, threshold=torch.linspace(0.5,0.95,10), num_points=101, *args, **kwargs):\\n\\n self.threshold = threshold\\n self.IOU = IOU(average=False)\\n self.AP = AveragePrecision(num_points=num_points, *args, **kwargs)\\n\\n self.result_dir = kwargs['result_dir']\\n final_shape = kwargs['final_shape']\\n #assuming model predictions are normalized between 0-1\\n self.scale = torch.Tensor([1, final_shape[0], final_shape[1], final_shape[0], final_shape[1]]) #[1, height, width, height, width]\\n\\n self.ndata = kwargs['ndata']\\n self.count = 0\",\n \"def class_average_withali(images,ptcl_info,xform,ref,averager=(\\\"mean\\\",{}),normproc=(\\\"normalize.edgemean\\\",{}),setsfref=0,verbose=0):\\n\\n\\tif isinstance(images[0],EMData) : nimg=len(images)\\n\\telif isinstance(images[0],str) and isinstance(images[1],int) : nimg=len(images)-1\\n\\telse : raise Exception,\\\"Bad images list\\\"\\n\\n\\tincl=[]\\n\\texcl=[]\\n#\\txforms=[]\\n\\tavgr=Averagers.get(averager[0], averager[1])\\n\\tfor i in range(nimg):\\n\\t\\timg=get_image(images,i,normproc)\\n\\t\\tptcl_info[i]=(ptcl_info[i][0],xform*ptcl_info[i][1],ptcl_info[i][2])\\t\\t# apply the new Transform to the existing one\\n#\\t\\tptcl_info[i]=(ptcl_info[i][0],ptcl_info[i][1]*xform,ptcl_info[i][2])\\t\\t# apply the new Transform to the existing one\\n\\t\\timg.process_inplace(\\\"xform\\\",{\\\"transform\\\":ptcl_info[i][1]})\\n\\t\\ttry: use=ptcl_info[i][2]\\n\\t\\texcept: use=1\\n\\t\\tif use :\\n\\t\\t\\tavgr.add_image(img)\\t\\t\\t\\t# only include the particle if we've tagged it as good\\n\\t\\t\\tif img.has_attr(\\\"source_n\\\") : incl.append(img[\\\"source_n\\\"])\\n#\\t\\t\\txforms.append(ptcl_info[i][1])\\n\\t\\telif img.has_attr(\\\"source_n\\\") : excl.append(img[\\\"source_n\\\"])\\n\\n\\tavg=avgr.finish()\\n\\n\\t# normalize to the reference, this should make make3dpar work better as we can skip the normalization step\\n\\tif ref!=None :\\n\\t\\tif setsfref:\\n\\t\\t\\tavg.process_inplace(\\\"filter.matchto\\\",{\\\"to\\\":ref,\\\"interpolate\\\":0,\\\"keephires\\\":1})\\n\\t\\t\\tavg-=avg.get_edge_mean()\\n\\t\\telse : avg.process_inplace(\\\"normalize.toimage\\\",{\\\"to\\\":ref})\\n\\n\\t\\tavg[\\\"class_qual\\\"]=avg.cmp(\\\"ccc\\\",ref)\\n\\n\\t# set some useful attributes\\n\\tif len(incl)>0 or len(excl)>0 :\\n\\t\\tif len(incl)>0 : avg[\\\"class_ptcl_idxs\\\"]=incl\\n\\t\\tif len(excl)>0 : avg[\\\"exc_class_ptcl_idxs\\\"]=excl\\n#\\t\\tif len(xforms)>0: avg[\\\"class_ptcl_xforms\\\"]=xforms\\n\\t\\tavg[\\\"class_ptcl_src\\\"]=img[\\\"source_path\\\"]\\n\\n\\treturn avg\",\n \"def multiclass_accuracy(prediction, ground_truth):\\n correct = sum(a == b for a, b in zip(prediction, ground_truth))\\n\\n accuracy = correct / len(ground_truth)\\n\\n return accuracy\",\n \"def facility_etl():\\r\\n with arcetl.ArcETL(\\\"Facilities\\\") as etl:\\r\\n etl.extract(dataset.FACILITY.path(\\\"maint\\\"))\\r\\n etl.transform(\\r\\n arcetl.dataset.rename_field,\\r\\n field_name=\\\"geofeat_id\\\",\\r\\n new_field_name=\\\"address_intid\\\",\\r\\n )\\r\\n # Clean maintenance values.\\r\\n transform.clear_nonpositive(etl, field_names=[\\\"address_intid\\\"])\\r\\n transform.clean_whitespace(\\r\\n etl, field_names=[\\\"label\\\", \\\"label_full\\\", \\\"type\\\", \\\"type_full\\\"]\\r\\n )\\r\\n transform.force_lowercase(etl, field_names=[\\\"type\\\"])\\r\\n transform.force_uppercase(etl, field_names=[\\\"label\\\"])\\r\\n transform.add_missing_fields(etl, dataset.FACILITY, tags=[\\\"pub\\\"])\\r\\n # Assign geometry attributes.\\r\\n coordinate_system_xy_keys = {\\r\\n 2914: {\\\"x\\\": \\\"x_coordinate\\\", \\\"y\\\": \\\"y_coordinate\\\"},\\r\\n 4326: {\\\"x\\\": \\\"longitude\\\", \\\"y\\\": \\\"latitude\\\"},\\r\\n }\\r\\n for spatial_reference_id, xy_key in coordinate_system_xy_keys.items():\\r\\n for axis, key in xy_key.items():\\r\\n etl.transform(\\r\\n arcetl.attributes.update_by_geometry,\\r\\n field_name=key,\\r\\n spatial_reference_item=spatial_reference_id,\\r\\n geometry_properties=[\\\"centroid\\\", axis],\\r\\n )\\r\\n etl.transform(\\r\\n arcetl.attributes.update_by_mapping,\\r\\n field_name=\\\"address_uuid\\\",\\r\\n mapping=address_intid_to_uuid_map,\\r\\n key_field_names=[\\\"address_intid\\\"],\\r\\n )\\r\\n etl.load(dataset.FACILITY.path(\\\"pub\\\"))\",\n \"def benthos_psa916_dict(calib, signal):\\n\\n #array mode\\n try:\\n altitude = []\\n for signal_x in signal:\\n temp = (300 * signal_x / calib['ScaleFactor']) + calib['Offset']\\n altitude.append(temp)\\n #single mode\\n except:\\n altitude = (300 * signal / calib['ScaleFactor']) + calib['Offset']\\n return altitude\",\n \"def get_alt(self, dec, i_alt):\\n return self.decisions[dec].value[i_alt]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7040563","0.60490364","0.5742719","0.569368","0.56679446","0.5570887","0.5441801","0.54371053","0.5434901","0.53988135","0.52956814","0.5294227","0.5294227","0.52853245","0.5224944","0.52045184","0.51312333","0.51289755","0.50556916","0.50430584","0.50328046","0.50328046","0.49942443","0.49904338","0.49566332","0.4934707","0.48897076","0.48859343","0.48707607","0.48648039","0.48556888","0.48437208","0.48006552","0.47929806","0.47871894","0.4784387","0.47835767","0.4742957","0.47248897","0.4675056","0.46616402","0.46523562","0.4627872","0.4620398","0.4578425","0.45593503","0.4540505","0.45131147","0.4487099","0.44861394","0.44654232","0.44645226","0.4463698","0.44630337","0.44533342","0.4449891","0.44341937","0.4424932","0.43925333","0.43838203","0.43631464","0.43602458","0.4359327","0.43552518","0.43459743","0.4344894","0.4344894","0.4338861","0.43382803","0.43362886","0.43171814","0.43157685","0.4307107","0.4302361","0.43009436","0.4297414","0.4289432","0.4288451","0.42728403","0.42692113","0.42686015","0.42521054","0.42445916","0.4232783","0.4232632","0.42284873","0.42284372","0.42268714","0.42265233","0.42243412","0.4213602","0.42094547","0.42077616","0.418384","0.4180669","0.4178668","0.41749397","0.41681355","0.41678706","0.41572678"],"string":"[\n \"0.7040563\",\n \"0.60490364\",\n \"0.5742719\",\n \"0.569368\",\n \"0.56679446\",\n \"0.5570887\",\n \"0.5441801\",\n \"0.54371053\",\n \"0.5434901\",\n \"0.53988135\",\n \"0.52956814\",\n \"0.5294227\",\n \"0.5294227\",\n \"0.52853245\",\n \"0.5224944\",\n \"0.52045184\",\n \"0.51312333\",\n \"0.51289755\",\n \"0.50556916\",\n \"0.50430584\",\n \"0.50328046\",\n \"0.50328046\",\n \"0.49942443\",\n \"0.49904338\",\n \"0.49566332\",\n \"0.4934707\",\n \"0.48897076\",\n \"0.48859343\",\n \"0.48707607\",\n \"0.48648039\",\n \"0.48556888\",\n \"0.48437208\",\n \"0.48006552\",\n \"0.47929806\",\n \"0.47871894\",\n \"0.4784387\",\n \"0.47835767\",\n \"0.4742957\",\n \"0.47248897\",\n \"0.4675056\",\n \"0.46616402\",\n \"0.46523562\",\n \"0.4627872\",\n \"0.4620398\",\n \"0.4578425\",\n \"0.45593503\",\n \"0.4540505\",\n \"0.45131147\",\n \"0.4487099\",\n \"0.44861394\",\n \"0.44654232\",\n \"0.44645226\",\n \"0.4463698\",\n \"0.44630337\",\n \"0.44533342\",\n \"0.4449891\",\n \"0.44341937\",\n \"0.4424932\",\n \"0.43925333\",\n \"0.43838203\",\n \"0.43631464\",\n \"0.43602458\",\n \"0.4359327\",\n \"0.43552518\",\n \"0.43459743\",\n \"0.4344894\",\n \"0.4344894\",\n \"0.4338861\",\n \"0.43382803\",\n \"0.43362886\",\n \"0.43171814\",\n \"0.43157685\",\n \"0.4307107\",\n \"0.4302361\",\n \"0.43009436\",\n \"0.4297414\",\n \"0.4289432\",\n \"0.4288451\",\n \"0.42728403\",\n \"0.42692113\",\n \"0.42686015\",\n \"0.42521054\",\n \"0.42445916\",\n \"0.4232783\",\n \"0.4232632\",\n \"0.42284873\",\n \"0.42284372\",\n \"0.42268714\",\n \"0.42265233\",\n \"0.42243412\",\n \"0.4213602\",\n \"0.42094547\",\n \"0.42077616\",\n \"0.418384\",\n \"0.4180669\",\n \"0.4178668\",\n \"0.41749397\",\n \"0.41681355\",\n \"0.41678706\",\n \"0.41572678\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7570481"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":91982,"cells":{"query":{"kind":"string","value":"Interpolate altitudes at distance values. Uses the scipy.interpolate.interp1d function to linearly interpolate altitudes at the required distances."},"document":{"kind":"string","value":"def interpolate(self, distances):\n cs = interp1d(self.distances, self.altitudes, fill_value='extrapolate')\n return cs(distances)"},"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 interpolate(self, distance, normalized=...): # -> BaseGeometry:\n ...","def interpolate(i0, d0, i1, d1):\n if i0 == i1:\n return [d0]\n values = []\n a = (d1 - d0) / (i1 - i0)\n d = d0\n for i in range(i0,i1+1):\n values.append(d)\n d = d + a\n return values","def InterpolateDerivs(self, , p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=...):\n ...","def interpolate_meridional(self, *interp1d_args, **interp1d_kwargs):\n return self.interp1d_meridional(*interp1d_args, **interp1d_kwargs)(self.lat)","def get_altitude(points):\n altitudes = np.zeros((len(points),), dtype=\"float64\")\n for i, point in tqdm(enumerate(points), desc=\"GETTING ALTITUDE\"):\n p = Point(point[0], point[1])\n altitudes[i] = alt.NM_COTA.iloc[\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\n ]\n return altitudes","def intersection_distances(self, altitude, start_distance, finish_distance):\n distances = []\n alt_index, alt_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, alt_index, alt_ratio)\n\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n while alt_index < finish_index:\n next_index = alt_index + 1\n next_ratio = 0.0\n next_alt = calculate_value(self.altitudes, next_index, next_ratio)\n\n # Does this section span the given altitude?\n if (next_alt != start_alt) and \\\n (min(start_alt, next_alt) < altitude < max(start_alt, next_alt)):\n delta = altitude - start_alt\n denom = next_alt - start_alt\n ratio = delta / denom\n distance = calculate_value(self.distances, alt_index, ratio)\n distances.append(distance)\n\n alt_index = next_index\n alt_ratio = next_ratio\n start_alt = next_alt\n\n if finish_ratio:\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n # Does the last section span the given altitude?\n if (start_alt != finish_alt) and \\\n (min(start_alt, finish_alt) < altitude < max(start_alt, finish_alt)):\n # Calculate the altitude at the end of the section to maximimse accuracy\n next_alt = calculate_value(self.altitudes, finish_index, 1.0)\n delta = altitude - start_alt\n denom = next_alt - start_alt\n ratio = delta / denom\n distance = calculate_value(self.distances, alt_index, ratio)\n distances.append(distance)\n\n return distances","def interpolate(x0, y0, x1, y1, x):\n y = (y0 * (x1 - x) + y1 * (x - x0)) / (x1 - x0)\n\n return y","def interpolate(self, interpolation=\"nearest\", **kwargs):\n return podpac.interpolators.Interpolate(source=self, interpolation=interpolation, **kwargs)","def interpolator(mat, distance):\n\n# calculate the place of each meassurement relative to the whole yourney of the\n# ship\n gesdistance = np.zeros(len(distance)+1)\n gesdis = distance[0]\n for i in range(1, len(distance)+1):\n gesdistance[i] = gesdistance[i-1] + distance[i-1]\n if i < len(distance):\n gesdis = gesdis + distance[i]\n\n# calculates the minimum distance for number of points of the interpolation\n mini = distance[0]\n for i in range(len(distance)):\n if distance[i] < mini:\n mini = distance[i]\n\n# interpolates linear over every depth\n newmat = np.zeros((len(mat), int(gesdis/mini)))\n\n wth = 0\n for leng in range(len(newmat)):\n newveloc = interp1d(gesdistance, mat[leng, :], kind=\"linear\")\n for wth in range(int(gesdis/mini)):\n newmat[leng, wth] = newveloc(wth*mini)\n for wdth in range(int(gesdis/mini)):\n newvelocdepth = interp1d(np.append(np.arange(0, 458, 20), 458), np.append(newmat[::20, wdth], newmat[457, wdth]), kind=\"linear\")\n for le in range(len(newmat)):\n newmat[le, wdth] = newvelocdepth(le)\n\n return np.flip(newmat), gesdis","def interp_z(array, heights, goal):\n\n f = interpolate.interp1d(heights, array, fill_value='extrapolate')\n return f(goal)","def InterpolationDerivs(self, , p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=...):\n ...","def altitude_range(self, start_distance, finish_distance):\n start_index, start_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n\n min_alt = min(start_alt, finish_alt)\n max_alt = max(start_alt, finish_alt)\n\n if start_index < finish_index:\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\n min_alt = min(min_alt, altitudes.min())\n max_alt = max(max_alt, altitudes.max())\n\n return min_alt, max_alt","def interpolate(x_list, y_list, z_list):\n x1 = x_list[-2]\n x2 = x_list[-1]\n y1 = y_list[-2]\n y2 = y_list[-1]\n z1 = z_list[-2]\n z2 = z_list[-1]\n r = -y1/y2\n x_land = (x1+r*x2)/(r+1)\n z_land = (z1+r*z2)/(r+1)\n x_list[-1] = x_land\n y_list[-1] = 0.0\n z_list[-1] = z_land","def test_1d_linear_interpolation_basic(self):\n\n # Define pixel centers along each direction\n x = [1.0, 2.0, 4.0]\n\n # Define array with corresponding values\n A = numpy.zeros((len(x)))\n\n # Define values for each xas a linear function\n for i in range(len(x)):\n A[i] = linear_function(x[i], 0)\n\n # Test first that original points are reproduced correctly\n for i, xi in enumerate(x):\n val = interpolate1d(x, A, [xi], mode='linear')[0]\n ref = linear_function(xi, 0)\n assert numpy.allclose(val, ref, rtol=1e-12, atol=1e-12)\n\n # Then test that genuinly interpolated points are correct\n xis = numpy.linspace(x[0], x[-1], 10)\n points = xis\n\n vals = interpolate1d(x, A, points, mode='linear')\n refs = linear_function(points, 0)\n assert numpy.allclose(vals, refs, rtol=1e-12, atol=1e-12)\n\n # Exercise bounds_error flag\n vals = interpolate1d(x, A, points, mode='linear',\n bounds_error=True)\n refs = linear_function(points, 0)\n assert numpy.allclose(vals, refs, rtol=1e-12, atol=1e-12)","def interpolate(self, _val1h) :\n\n\t\tval1h = _val1h.reshape(reduce(operator.mul, _val1h.shape))\t# Convert to 1-D\n\t\tv1h = np.copy(val1h)\n\t\tv1h[np.isnan(val1h)] = 0\t# Prepare for multiply\n\t\tval2 = self.M.transpose() * v1h\n\t\tval2[np.logical_not(self.mask2)] = np.nan\n\t\treturn val2","def interpolate(self, kind='equidistant_steps', num=1):\n x = self.x\n y = self.y\n d = self.d\n\n # cubic requires a different calculation, so check the kind first\n if not (kind == 'equidistant_steps') | (kind == 'absolute_steps'):\n raise ValueError(\"Keyword argument for 'kind' not recognised. See docs for options.\")\n\n\n if kind == 'equidistant_steps':\n # New list of distance points to interpolate Route data against\n dist = list(np.arange(d.min(), d.max()+num, step=num))\n\n elif kind == 'absolute_steps':\n # New list of distance points to interpolate Route data against\n dist = list(np.linspace(d.min(), d.max(), num=num))\n\n # Interpolate x and y wrt to d against the new list of distanced points\n xx = np.interp(dist, d, x)\n yy = np.interp(dist, d, y)\n\n # interpolate z too if it exists\n if self.z is not None:\n # Start a new dict of z-axis data\n zz = {}\n # for each, interpolate and add to the new dict\n for k, v in self.z.items():\n zz[k] = np.interp(dist, d, v)\n else:\n zz = None\n\n return Route(xx, yy, z=zz)","def interpolate(self, lon, lat, egy=None):\n raise NotImplementedError(\"MapBase.interpolate()\")","def interpolate(self, xs):\n tck = splrep(self._xs, self._ys)\n new_ys = splev(xs, tck, der=0)\n return new_ys","def interpolate(self, interp):\n x = np.linspace(0, 29, len(self.ya))\n f_ya = interpolate.interp1d(x, self.ya)\n f_yv = interpolate.interp1d(x, self.yv)\n f_pa = interpolate.interp1d(x, np.reshape(self.pa, [-1]))\n f_pv = interpolate.interp1d(x, np.reshape(self.pv, [-1]))\n\n x_interp = np.linspace(0, 29, len(self.ya)*interp)\n self.ya = list(f_ya(x_interp))\n self.yv = list(f_yv(x_interp))\n self.pa = list(f_pa(x_interp))\n self.pv = list(f_pv(x_interp))","def dardar2era(dardar, ERA, p_grid):\n lon_d = dardar.get_data('longitude')\n lat_d = dardar.get_data('latitude')\n height_d = dardar.get_data('height')\n\n \n# convert longitude from -180-180 to 0-360\n if lon_d.min() < 0:\n lon_d = lon_d % 360\n \n# add extra pressure level in ERA5 data\n xlevel = 1200\n ERA.add_extra_level('temperature', xlevel)\n ERA.add_extra_level('geopotential', xlevel)\n \n# get ERA lat/lon/pressure grids\n \n lat = ERA.t.latitude.data\n lon = ERA.t.longitude.data\n level = ERA.t.level.data \n t = ERA.t.t[0].data\n z = ERA.z.z[0].data\n \n level = np.log(level) # convert pressure to log\n \n \n# add two extra dimension to longitudes to wrap around during interpolation\n \n lon, z = expand_lon(ERA.z.longitude.data, z )\n lon, t = expand_lon(ERA.t.longitude.data, t )\n \n #my_interpolating_function = RegularGridInterpolator((level, lat, lon), A)\n \n p_grid = np.arange(1, 1150, 10)\n points = []\n \n# interpolate ERA5 to DARDAR lat/lon locations\n \n for i in range(len(p_grid)):\n p = np.log(p_grid[i]) # convert pressure to log range\n pts = [[p, lat_d[j], lon_d[j]] for j in range(len(lat_d))] \n points.append(pts)\n \n my_interpolating_function = interpolate(level, lat, lon, t) \n grid_t = my_interpolating_function(points)\n \n my_interpolating_function = interpolate(level, lat, lon, z) \n grid_z = my_interpolating_function(points)\n \n return grid_t, grid_z","def interpolate(self, freq, data):\n func = scipy.interpolate.interp1d(\n freq, data,\n kind='nearest',\n copy=False,\n assume_sorted=True,\n bounds_error=False,\n fill_value=np.nan,\n )\n return func(self.freq)","def _LinearInterpolate(x0, target, x1, y0, y1):\n if x0 == x1:\n return (y0 + y1) / 2\n return (y1 - y0) * (target - x0) / (x1 - x0) + y0","def linear_interpolate(x, x0, y0, x1, y1):\n try:\n return (y0 * (x1 - x) + y1 * (x - x0)) / (x1 - x0)\n except ZeroDivisionError:\n return 0.0","def position_extrapolate(dist_1_coords, dist_2_coords, delta_heading, delta_distance):\n ref_coord = dist_1_coords\n ref_dir = np.arctan2(dist_1_coords[1] - dist_2_coords[1], dist_1_coords[0] - dist_2_coords[0])\n\n curr_dir = ref_dir + delta_heading\n x = ref_coord[0] + delta_distance*np.cos(curr_dir)\n y = ref_coord[1] + delta_distance*np.sin(curr_dir)\n z = ref_coord[2]\n\n return [x, y, z]","def interpolator(self, states):\n t = np.asarray([state.t for state in states])\n y = np.asarray([state.y for state in states])\n\n return interp1d(t, y, assume_sorted=True, kind='cubic')","def __hinterpolate(self):\n \n # Temp. Data holders\n upperint = []\n lowerint = []\n \n # Dont like this, because here we insert points into the rawdata\n # But it creates consisitent results in the interpolation results\n if self.__upper[0][0] != 0: self.__upper.insert(0,(0.,0.))\n if self.__lower[0][0] != 0: self.__lower.insert(0,(0.,0.))\n \n # Create points\n if self.__interpolation_method == \"l\":\n xpointsU = list(map(lambda x:x/float(self.__procPointsCount),range(0,self.__procPointsCount+1)))\n xpointsL = list(map(lambda x:x/float(self.__procPointsCount),range(0,self.__procPointsCount+1)))\n elif self.__interpolation_method == \"p\":\n xpointsU = [x**2/float(self.__procPointsCount)**2 for x in range(self.__procPointsCount+1)]\n xpointsL = [x**2/float(self.__procPointsCount)**2 for x in range(self.__procPointsCount+1)]\n \n # Calculate secants\n uppersec = [(self.__upper[i+1][1]-self.__upper[i][1])/(self.__upper[i+1][0]-self.__upper[i][0]) for i in range(len(self.__upper)-1)]\n lowersec = [(self.__lower[i+1][1]-self.__lower[i][1])/(self.__lower[i+1][0]-self.__lower[i][0]) for i in range(len(self.__lower)-1)]\n \n # Calculate tangents\n uppertan = [(uppersec[k-1]+uppersec[k])/2 for k in range(1,len(uppersec))]\n uppertan.insert(0,uppersec[0])\n uppertan.append(uppersec[-1])\n\n lowertan = [(lowersec[k-1]+lowersec[k])/2 for k in range(1,len(lowersec))]\n lowertan.insert(0,lowersec[0])\n lowertan.append(lowersec[-1])\n \n # Hermite blending functions\n p0 = lambda t: 2*t**3 - 3*t**2 + 1\n m0 = lambda t: t**3 - 2*t**2 + t\n p1 = lambda t: -2*t**3 + 3*t**2\n m1 = lambda t: t**3 - t**2\n \n # Find matching points to improve accuarcy\n matchU = [(i,j) for i in range(len(xpointsU)) for j in range(len(self.__upper)) if xpointsU[i] == self.__upper[j][0]]\n matchL = [(i,j) for i in range(len(xpointsL)) for j in range(len(self.__lower)) if xpointsL[i] == self.__lower[j][0]]\n \n # Reverse match pairs to insure no index errors\n matchU.reverse()\n matchL.reverse()\n\n# print(self.__lower)\n# print(xpointsL)\n # Pop xpoints that dont require interpolation and append the point into the upperint list\n for i in matchU:\n xpointsU.pop(i[0])\n upperint.append(self.__upper[i[1]])\n \n# print(matchL)\n \n # Same process as above but for lower airfoil\n for i in matchL:\n xpointsL.pop(i[0])\n lowerint.append(self.__lower[i[1]])\n \n # Interpolate upper points\n for xp in xpointsU:\n for i in range(len(self.__upper)-1):\n if self.__upper[i][0] < xp < self.__upper[i+1][0]:\n h = self.__upper[i+1][0]-self.__upper[i][0]\n t = (xp - self.__upper[i][0]) / h\n solution = ( p0(t)*self.__upper[i][1] + h*m0(t)*uppertan[i] + p1(t)*self.__upper[i+1][1] + h*m1(t)*uppertan[i+1] )\n upperint.append((xp,solution))\n \n # Interpolate lower points\n for xp in xpointsL:\n for i in range(len(self.__lower)-1):\n if self.__lower[i][0] < xp < self.__lower[i+1][0]:\n h = self.__lower[i+1][0]-self.__lower[i][0]\n t = (xp - self.__lower[i][0]) / h\n solution = ( p0(t)*self.__lower[i][1] + h*m0(t)*lowertan[i] + p1(t)*self.__lower[i+1][1] + h*m1(t)*lowertan[i+1] )\n lowerint.append((xp,solution))\n \n # Sort the points to keep the correct sequence\n upperint.sort(key=lambda x:x[0], reverse=True)\n lowerint.sort(key=lambda x:x[0])\n \n # Do checks to insure no duplicates\n if upperint[0][0] != 1.0: upperint.insert(0,(1.0,0.0))\n if upperint[-1][0] != 0.0: upperint.append((0.0,0.0))\n if lowerint[0][0] == 0.0: lowerint.pop(0)\n if lowerint[-1][0] != 1.0: lowerint.append((1.0,0.0))\n\n self.__ProcPoints = upperint + lowerint","def interpolate_ephemeris(self):\n #Compute the offsets into the lookup tables\n startemiss, stopemiss = self.get_emissivity_offsets()\n hourslice, starttime = self.get_hour_offsets()\n latslice = self.get_lat_offsets()\n \n #Compute the start and stop dates\n startdata = self.extract_season(self.startseason,startemiss,\n hourslice, latslice)\n stopdata = self.extract_season(self.stopseason,startemiss,\n hourslice, latslice)\n # Interpolate Season\n seasons = [self.startseason, self.stopseason]\n season_f = compute_interpolation_function(seasons, [startdata, stopdata], 'linear')\n data = season_f(self.season)\n #Interpolate time\n self.data = self.interpolatehour(hourslice, starttime, data)","def bil_interpolate(p, ls, dx, dy):\n m = p.shape[0]\n max_i = ls.shape[0]\n max_j = ls.shape[1]\n\n z = np.zeros(p.shape[0])\n code = \\\n \"\"\"\n #line 38 \"distmesh2d.py\"\n int i=0, j=0;\n double x=0.0, y=0.0;\n\n // Loop through all coordinates\n for(int k=0; k<m; k++) {\n // Get grid indices\n i = int( P2(k,0)/dx-0.5 );\n j = int( P2(k,1)/dy-0.5 );\n\n // Probably not helpful.\n // Just take care that (x,y) lie inside the grid ...\n if(i<0 || i>=max_i || j<0 || j>=max_j) {\n Z1(k) = 100000.0;\n continue;\n }\n\n // Handle corner case when coordinates lie on border\n if(i==max_i-1) i-=1;\n if(j==max_j-1) j-=1;\n\n // Local coordinates scaled to [0,1]\n // Maybe this would rather be fmod()?\n x = (P2(k,0)-i*dx)/dx;\n y = (P2(k,1)-j*dy)/dy;\n\n // Interpolate ls values\n double tmp;\n Z1(k) = LS2(i,j)*(1.0-x)*(1.0-y)\n +LS2(i+1,j)*x*(1.0-y)\n +LS2(i,j+1)*(1-x)*y\n +LS2(i+1,j+1)*x*y;\n }\n \"\"\"\n weave.inline(code, \n ['p', 'ls', 'dx', 'dy', 'z', 'm', 'max_i', 'max_j']) \n return z","def test_1d_constant_interpolation_basic(self):\n\n # Define pixel centers along each direction\n x = numpy.array([1.0, 2.0, 4.0])\n\n # Define ny by nx array with corresponding values\n A = numpy.zeros((len(x)))\n\n # Define values for each x, y pair as a linear function\n for i in range(len(x)):\n A[i] = linear_function(x[i], 0)\n\n # Then test that interpolated points are always assigned value of\n # closest neighbour\n xis = numpy.linspace(x[0], x[-1], 10)\n points = xis\n\n vals = interpolate1d(x, A, points, mode='constant')\n\n # Find upper neighbours for each interpolation point\n xi = points[:]\n idx = numpy.searchsorted(x, xi, side='left')\n\n # Get the neighbours for each interpolation point\n x0 = x[idx - 1]\n x1 = x[idx]\n\n z0 = A[idx - 1]\n z1 = A[idx]\n\n # Location coefficients\n alpha = (xi - x0) / (x1 - x0)\n\n refs = numpy.zeros(len(vals))\n for i in range(len(refs)):\n if alpha[i] < 0.5:\n refs[i] = z0[i]\n\n if alpha[i] >= 0.5:\n refs[i] = z1[i]\n\n assert numpy.allclose(vals, refs, rtol=1e-12, atol=1e-12)","def interp_1d(z, x, fx, dfx=None, y=None, fpy=None, dfpy=None, \\\n compute_dfz=False):\n # verifying and handling arguments\n assert z.ndim == x.ndim == fx.ndim == 1 and x.size == fx.size\n if dfx is None:\n dfx = zeros(x.shape)\n else:\n assert dfx.shape == x.shape\n if y is None:\n assert fpy is None and dfpy is None\n y = zeros(0); fpy = zeros(0); dfpy = zeros(0)\n else:\n assert fpy is not None and fpy.shape == y.shape\n if dfpy is None:\n dfpy = zeros(y.shape)\n else:\n assert dfpy.shape == y.shape\n n = x.size; m = y.size\n # calculate beta and gamma\n beta = calc_beta(fx, dfx)\n gamma = calc_gamma_1d(x, fx, dfx, y, fpy, dfpy)\n # interpolation for each z[i]\n t0 = time.time()\n fz, dz = [], []\n for zi in z:\n a, b, er2 = interp_1d_coef(zi, x, dfx, y, dfpy, beta, gamma)\n fz.append(dot(a, fx) + dot(b, fpy))\n dz.append(sqrt(er2))\n print ' time: ', time.time() - t0\n if compute_dfz:\n return numpy.array(fz), numpy.array(dz)\n else:\n return numpy.array(fz)","def nearest_neighbor_dted_interp(lon_lat, dted_directory, dted_extension):\n\n # Set these to NAN for the moment\n heights = np.empty((lon_lat.shape[0], 1))\n heights[:] = np.NAN\n\n # First find the corresponding dted files\n dted_files = find_containing_dted_file(lon_lat, dted_directory,\n dted_extension)\n\n # Go through each file\n for tile in set(dted_files):\n\n # Open DTED, get the image, and affine transform\n dted = gdal.Open(tile)\n gt_dted = dted.GetGeoTransform()\n band = dted.GetRasterBand(1)\n img = band.ReadAsArray(0, 0, dted.RasterXSize, dted.RasterYSize)\n\n # Get raster space idx for the points in this tile\n idx = np.nonzero(np.array(dted_files) == tile)[0]\n d_pix = pix_from_geo(lon_lat[idx, :], gt_dted)\n\n # Grab nearest neighbor\n d_pix = np.round(d_pix).astype('int')\n\n # Index into image to grab heights, remember that because the\n # coordinate systems between raster space and ndarray are rotated we\n # need to transpose x,y\n heights[idx] = img[d_pix[:, 1], d_pix[:, 0]].reshape((idx.shape[0], 1))\n\n # Put heights into msl\n lon_lat_msl = np.hstack((lon_lat, heights))\n return lon_lat_msl","def altitude(p):\r\n \r\n R = 290 #specific gas constant \r\n T = 93.65 #surface temperature K from A.Coustenis book\r\n g = 1.354 #surface gravity from A.Coustenis book\r\n p0 = 1467 #surface pressure in hPa 6.1 for mars\r\n \r\n z = np.empty_like(p)\r\n \r\n for i in range(p.shape[0]):\r\n z[i] = (-1)*(R*T/g)*np.log((p[i])/p0)/(10**3)\r\n \r\n # Make into an xarray DataArray\r\n z_xr = xr.DataArray(z, coords=[z], dims=['pfull'])\r\n z_xr.attrs['units'] = 'km'\r\n \r\n #below is the inverse of the calculation\r\n #p[i] = p0*np.exp((-1)*z[i]*(10**3)/((R*T/g)))\r\n \r\n return z_xr","def interpolate_na(\n self, method: str = \"nearest\", extrapolate: bool = False, **kwargs\n ):\n dim0 = self.dim0\n kwargs.update(dict(method=method, extrapolate=extrapolate))\n if dim0:\n interp_data = np.empty(self._obj.shape, dtype=self._obj.dtype)\n for i, (_, sub_xds) in enumerate(self._obj.groupby(dim0)):\n interp_data[i, ...] = self._interpolate_na(\n sub_xds.load().data, **kwargs\n )\n else:\n interp_data = self._interpolate_na(self._obj.load().data, **kwargs)\n interp_array = xr.DataArray(\n name=self._obj.name,\n dims=self._obj.dims,\n coords=self._obj.coords,\n data=interp_data,\n attrs=self._obj.attrs,\n )\n interp_array.raster.set_nodata(self.nodata)\n interp_array.raster.set_crs(self.crs)\n return interp_array","def altitude_to_pressure(alt):\n for i in range(len(_heights)-1,0,-1):\n h0 = _heights[i]\n T0 = _basetemps[i]\n if alt > h0:\n if _isotherm[i]:\n rP = math.exp(-_g / _R / T0 * (alt - h0))\n else:\n l0 = _lapsert[i]\n rP = math.pow(1 + (alt - h0) * l0 / T0, -_g / _R / l0)\n return _basepress[i] * rP\n l0 = _lapsert[0]\n return _stdpres * math.pow(1 + alt * l0 / _stdtemp, -_g / _R / l0)","def _interpolate(self, kps1: List[List[kp]], kps2: List[List[kp]]) -> np.ndarray:\n interpolated_kps = []\n for i in range(len(kps1)):\n # If one of the two points is empty -> Not interpolate\n if len(kps1[i]) != 0 and len(kps2[i]) != 0:\n interpolated_coords = np.linspace(np.array(kps1[i]), np.array(kps2[i]), num=3).tolist()\n interpolated_kps.append(interpolated_coords[1])\n else:\n interpolated_kps.append([None, None, None])\n return np.array(interpolated_kps)","def interpolate(self, *point, **kwargs):\n\n # Assume alpha enhancement of 0.4 if not given.\n if len(point) == 3:\n point = [] + list(point) + [0.4]\n warnings.warn(\n \"Assuming [alpha/Fe] = 0.4 composition unless \"\n \"otherwise specified.\", StandardCompositionAssumed)\n elif len(point) == 4:\n point = list(point)\n warnings.warn(\n \"Fourth stellar param is [alpha/Fe] = {}\".format(point[3]))\n\n return super(self.__class__, self).interpolate(*point, **kwargs)","def interpolate(self):\n print(\"Interpolating points...\")\n interpolated_points = set()\n if os.cpu_count():\n processes = os.cpu_count()\n print(f\"Running on all {processes} cores.\")\n else:\n processes = 1\n length = len(self.main_cluster)\n delta = math.ceil(length / processes)\n manager = Manager()\n result_map = manager.dict()\n jobs = []\n for index in range(processes):\n start = index * delta\n stop = (index + 1) * delta\n if stop > length:\n stop = length\n p = Process(target=worker, args=(start, stop,\n result_map, index,\n self.distances,\n self.interpolation_threshold,\n self.main_cluster,\n self.color_lookup_table_points))\n jobs.append(p)\n p.start()\n\n for proc in jobs:\n proc.join()\n\n for index in result_map.keys():\n print(index)\n interpolated_points.update(result_map[index])\n\n main_points = [self.get_value_tuple(index) for index in self.main_cluster]\n interpolated_points.update(main_points)\n\n print(\"Finished interpolation!\")\n\n self.interpolated_points = list(interpolated_points)","def interpolate(x1, x2, u, N):\n \n # finding the magnitude of each component\n a1 = np.matmul(x1, u)\n a2 = np.matmul(x2, u)\n\n ims = [np.matmul(u, t * a1 + (1 - t) * a2) \\\n for t in np.linspace(0, 1, N)]\n\n return np.stack(ims, 0)","def trilinear_interpolate(point, atom_index, emap, emap_max, emap_min):\n point1 = []\n point0 = []\n dif = []\n for p in point:\n if round(p) == p:\n p += 1E-10\n point0.append(math.floor(p))\n point1.append(math.ceil(p))\n dif.append((p - point0[-1]) / (point1[-1] - point0[-1]))\n\n i000 = energy_map_index(point0, emap_max, emap_min) # (0, 0, 0)\n i100 = energy_map_index([point1[0], point0[1], point0[2]], emap_max, emap_min) # (1, 0, 0)\n i001 = energy_map_index([point0[0], point0[1], point1[2]], emap_max, emap_min) # (0, 0, 1)\n i101 = energy_map_index([point1[0], point0[1], point1[2]], emap_max, emap_min) # (1, 0, 1)\n i010 = energy_map_index([point0[0], point1[1], point0[2]], emap_max, emap_min) # (0, 1, 0)\n i110 = energy_map_index([point1[0], point1[1], point0[2]], emap_max, emap_min) # (1, 1, 0)\n i011 = energy_map_index([point0[0], point1[1], point1[2]], emap_max, emap_min) # (0, 1, 1)\n i111 = energy_map_index(point1, emap_max, emap_min) # (1, 1, 1)\n\n c00 = emap[i000][atom_index] * (1 - dif[0]) + emap[i100][atom_index] * dif[0]\n c01 = emap[i001][atom_index] * (1 - dif[0]) + emap[i101][atom_index] * dif[0]\n c10 = emap[i010][atom_index] * (1 - dif[0]) + emap[i110][atom_index] * dif[0]\n c11 = emap[i011][atom_index] * (1 - dif[0]) + emap[i111][atom_index] * dif[0]\n\n c0 = c00 * (1 - dif[1]) + c10 * dif[1]\n c1 = c01 * (1 - dif[1]) + c11 * dif[1]\n\n c = c0 * (1 - dif[2]) + c1 * dif[2]\n\n return c","def interpolate(traj: cs.DM, T: float, **interp_args) -> interp1d:\n assert isinstance(\n traj, cs.DM\n ), f\"traj is incorrect type, got '{type(traj)}', expected casadi.DM'\"\n t = np.linspace(0, T, traj.shape[1])\n return interp1d(t, traj.toarray(), **interp_args)","def interpolate(self):\n interp = (\n self._get_ticks() - self._last_update\n ) / self._tick_step / self.dilation\n if interp > 1.0:\n interp = 1.0\n return interp","def interp_zt(array, heights, goal):\n\n print('Coffee time :-)')\n nt = array.shape[0]\n out = np.empty((nt,goal.size), dtype=np.float)\n for i in range(nt):\n out[i,:] = np.interp(goal, heights[i,:], array[i,:])\n return out","def interpolation(self, experiments):\n # get all TAD lengths and multiply it by bin size of the experiment\n norm_tads = []\n for tad in experiments:\n for brk in self.experiments[tad]['tads'].values():\n if not brk['brk']:\n continue\n norm_tads.append((brk['end'] - brk['start']) * self.resolution)\n x = [0.0]\n y = [0.0]\n max_d = max(norm_tads)\n # we ask here for a mean number of 20 values per bin \n bin_s = int(max_d / (float(len(norm_tads)) / 20))\n for b in range(0, int(max_d) + bin_s, bin_s):\n x.append(len([i for i in norm_tads if b < i <= b + bin_s]) + x[-1])\n y.append(b + float(bin_s))\n x = [float(v) / max(x) for v in x]\n ## to see the distribution and its interpolation\n #distr = interp1d(x, y)\n #from matplotlib import pyplot as plt\n #plt.plot([distr(float(i)/1000) for i in xrange(1000)],\n # [float(i)/1000 for i in xrange(1000)])\n #plt.hist(norm_tads, normed=True, bins=20, cumulative=True)\n #plt.show()\n return interp1d(x, y)","def interpolate_linear(self, known_coords, known_values, interp_coords, groupname):\n\t\t#First need to reshape known_coords and known_values\n\t\tn_params = self.signal[groupname]['dimension']\n\t\tknown_coords = np.reshape( known_coords, (-1,n_params) )\n\t\tknown_values = np.reshape( known_values, (-1) )\t\t\n\t\treturn griddata(known_coords, known_values, interp_coords, method='linear')","def interpolate(self, known_coords, known_values, interp_coords, groupname):\n\t\t#Find which interpolation method is desired\n\t\tif self.interp_method == \"Grid Linear\":\n\t\t\tinterp_values = self.grid_interpolation_linear(known_coords=known_coords, known_values=known_values, interp_coords=interp_coords, groupname=groupname)\n\t\telif self.interp_method == \"Linear\":\n\t\t\tfrom scipy.interpolate import griddata\n\t\t\tinterp_values = self.interpolate_linear(known_coords=known_coords, known_values=known_values, interp_coords=interp_coords, groupname=groupname)\n\t\telse:\n\t\t\t#Should raise error\n\t\t\tpass\n\t\t\n\t\treturn interp_values","def test_linear_interpolation_basic(self):\n\n # Define pixel centers along each direction\n x = [1.0, 2.0, 4.0]\n y = [5.0, 9.0]\n\n # Define ny by nx array with corresponding values\n A = numpy.zeros((len(x), len(y)))\n\n # Define values for each x, y pair as a linear function\n for i in range(len(x)):\n for j in range(len(y)):\n A[i, j] = linear_function(x[i], y[j])\n\n # Test first that original points are reproduced correctly\n for i, xi in enumerate(x):\n for j, eta in enumerate(y):\n val = interpolate2d(x, y, A, [(xi, eta)], mode='linear')[0]\n ref = linear_function(xi, eta)\n assert numpy.allclose(val, ref, rtol=1e-12, atol=1e-12)\n\n # Then test that genuinly interpolated points are correct\n xis = numpy.linspace(x[0], x[-1], 10)\n etas = numpy.linspace(y[0], y[-1], 10)\n points = combine_coordinates(xis, etas)\n\n vals = interpolate2d(x, y, A, points, mode='linear')\n refs = linear_function(points[:, 0], points[:, 1])\n assert numpy.allclose(vals, refs, rtol=1e-12, atol=1e-12)","def get_air_density(self, altitude):\n\n altitude /= 1000 # convert to kilometers\n\n return self.get_air_density_from_model(altitude)","def extrapolate(self, known_coords, known_values, extrap_coords, groupname):\n\t\t#Find which extrapolation method is desired\n\t\tif self.extrap_method == \"Grid Nearest\":\n\t\t\textrap_values = self.grid_interpolation_linear(known_coords=known_coords, known_values=known_values, interp_coords=extrap_coords, groupname=groupname)\n\t\telif self.extrap_method == \"Nearest\":\n\t\t\textrap_values = self.extrapolate_nearest(known_coords=known_coords, known_values=known_values, extrap_coords=extrap_coords, groupname=groupname)\n\t\telse:\n\t\t\t#Should raise error\n\t\t\tpass\n\t\t\n\t\treturn extrap_values","def extrap1d(x,y,kind=\"linear\"):\n interpolator = interp1d(x,y,kind=kind)\n xs = interpolator.x\n ys = interpolator.y\n def pointwise(x):\n if x < xs[0]: return ys[0]+(x-xs[0])*(ys[1]-ys[0])/(xs[1]-xs[0])\n elif x > xs[-1]: return ys[-1]+(x-xs[-1])*(ys[-1]-ys[-2])/(xs[-1]-xs[-2])\n else: return interpolator(x)\n def ufunclike(xs):\n return array(list(map(pointwise, array(xs))))\n return ufunclike","def set_cruise_altitudes(altitudes, cruise_indicies):\n if cruise_indicies:\n for index in range(0, len(cruise_indicies), 2):\n start = cruise_indicies[index]\n stop = cruise_indicies[index + 1]\n if start < stop:\n cruise_altitude = closest_cruising_altitude(altitudes[start])\n altitudes[start] = cruise_altitude\n altitudes[stop] = cruise_altitude\n\n return altitudes","def haversine_distance_ignore_altitude(loc1_lat, loc1_lon, loc2_lat, loc2_lon):\n R = 6372797.560856 # radius of the earth in meters\n\n lat_arc = math.radians(loc1_lat - loc2_lat)\n lon_arc = math.radians(loc1_lon - loc2_lon)\n\n lat_h = math.sin(lat_arc * 0.5)\n lat_h = lat_h * lat_h\n\n lon_h = math.sin(lon_arc * 0.5)\n lon_h = lon_h * lon_h\n\n tmp = math.cos(math.radians(loc1_lat)) * math.cos(math.radians(loc2_lat))\n rad = 2.0 * math.asin(math.sqrt(lat_h + tmp * lon_h))\n\n return rad * R","def myChordFunctionAirliner(Epsilon):\n ChordLengths = np.array([0.5, 0.3792, 0.2867, 0.232, 0.1763, 0.1393, 0.1155,\n 0.093, 0.0713, 0.055, 0.007])\n\n EpsArray = np.linspace(0, 1, 11)\n return np.interp(Epsilon, EpsArray, ChordLengths)","def test_isentropic_pressure_addition_args_interp():\n lev = [100000., 95000., 90000., 85000.] * units.Pa\n tmp = np.ones((4, 5, 5))\n tmp[0, :] = 296.\n tmp[1, :] = 292.\n tmp[2, :] = 290.\n tmp[3, :] = 288.\n rh = np.ones((4, 5, 5))\n rh[0, :] = 100.\n rh[1, :] = 80.\n rh[2, :] = 40.\n rh[3, :] = 20.\n relh = rh * units.percent\n tmpk = tmp * units.kelvin\n isentlev = [296., 297.] * units.kelvin\n isentprs = isentropic_interpolation(isentlev, lev, tmpk, relh)\n truerh = 69.197 * units.percent\n assert_almost_equal(isentprs[1][1], truerh, 3)","def linear_interpolation(self, pt1, pt2, unknown):\n\n #Write your code for linear interpolation here\n pt1,intensity1=pt1\n pt2,intensity2=pt2\n newPoint=unknown\n intensity_diff=pt2-pt1\n if(intensity_diff<=0):\n intensity_diff=1\n\n a1=pt2-newPoint\n b1=a1/intensity_diff\n x=intensity1*b1\n a2=newPoint - pt1\n b2=a2/intensity_diff\n y=intensity2*b2\n new_intensity=x+y\n\n return new_intensity","def interpolate(self, var, time, lat, lon):\n\n # Get the nearest four points in space\n # Check to see if lat/lons are 2d or 1d\n if len(self['lat'].shape) == 2:\n closey, closex, distances = self.nearest_points(lat, lon, npt=4)\n # Distances in km\n# distances = np.array([self.haversine(\n# (self['lat'][y,x].values, self['lon'][y,x].values),\n# (lat, lon)) for y,x in \n# zip(list(closey), list(closex))])\n else:\n closen = self.nearest_points(lat, lon, npt=4)\n closey = closen\n closex = closen\n # Distances in km\n distances = np.array([self.haversine(\n (self['lat'][n].values, self['lon'][n].values),\n (lat, lon)) for n in list(closen)])\n # Check for exact match (within some tolerance)\n spaceweights = np.zeros(distances.shape)\n if (distances < 1.0).sum() > 0:\n spaceweights[distances.argmin()] = 1\n else:\n # Here, inverse distance weighting (for simplicity)\n spaceweights = 1.0 / distances\n spaceweights /= spaceweights.sum()\n # Get weights in time\n #time64 = np.datetime64(time)\n #all the valid times in the ensemble\n valids = self['validtime'].values\n timeweights = np.zeros(valids.shape)\n # Check if we are outside the valid time range\n if (time < valids[0]) or (time > valids[-1]):\n print(\"Interpolation is outside of time range in state!\")\n return None\n # Find where we are in this list\n #index after the time of the observation\n lastdex = (valids >= time).argmax()\n # If we match a particular time value, then\n # this is just an identity\n if valids[lastdex] == time:\n # Just make a one at this time\n timeweights[lastdex] = 1\n else:\n # Linear interpolation\n #often going to be 6 hours, subtracts datetime objects I think\n diff = (valids[lastdex] - valids[lastdex-1])\n #print(valids[lastdex], valids[lastdex-1], diff)\n #often going to be 21600 seconds\n totsec = diff.seconds\n #totsec = np.abs(diff / np.timedelta64(1, 's'))\n #ST\n #calculate time difference between time after and time of observation\n #the abs will make this positive definite, which is okay since\n #the difference will always be negative\n thisdiff = abs(time - valids[lastdex])\n #thissec = np.abs(thisdiff / np.timedelta64(1,'s'))\n thissec = thisdiff.seconds\n # Put in appropriate weights\n #ST switched the -1 between the two lines to match up with the positive-\n #definite thisdiff\n timeweights[lastdex-1] = float(thissec) / totsec\n timeweights[lastdex] = 1.0 - (float(thissec)/totsec)\n # Now that we have the weights, do the interpolation\n #ST an ntimes x 4 x nens array\n interp = self.variables[var].values[:,closey,closex,:]\n # Do a dot product with the time weights\n # And with the space weights\n if len(interp.shape) == 3:\n interp = (timeweights[:,None,None] * interp).sum(axis=0)\n else:\n interp = (timeweights[:,None,None,None] * interp).sum(axis=0)\n \n if len(interp.shape) == 3:\n #ST Changed 2nd : to None\n interp = (spaceweights[:,None,None] * interp).sum(axis=1)\n else:\n interp = (spaceweights[:,None] * interp).sum(axis=0)\n # Return estimate from all ensemble members\n return interp","def _interpolate_table(self, key, leap_second_correction=False, derivative_order=0):\n days = np.unique(self.time.utc.mjd_int)\n offsets = range(-math.ceil(self.window / 2) + 1, math.floor(self.window / 2) + 1)\n\n if leap_second_correction:\n leap = {\n d: np.array(\n [self.data[d + o].get(\"leap_offset\", np.nan) - self.data[d][\"leap_offset\"] for o in offsets]\n )\n for d in days\n }\n for lo in leap.values():\n lo[np.isnan(lo)] = 0\n else:\n leap = {d: 0 for d in days}\n\n table_values = {d: np.array([self.data[d + o][key] for o in offsets]) + leap[d] for d in days}\n interpolators = {d: interpolate.lagrange(offsets, v) for d, v in table_values.items()}\n for poly in interpolators.values():\n poly.c[np.abs(poly.c) < 1e-15] = 0 # Avoid numerical instabilities for constant values\n\n if derivative_order:\n interp_values = {\n d: np.polyder(ip, derivative_order)(self.time.utc.mjd_frac) for d, ip in interpolators.items()\n }\n else:\n interp_values = {d: ip(self.time.utc.mjd_frac) for d, ip in interpolators.items()}\n\n if self.time.isscalar:\n return interp_values[self.time.utc.mjd_int]\n\n values = np.empty(self.time.size)\n for day in days:\n idx = self.time.utc.mjd_int == day\n values[idx] = interp_values[day][idx]\n\n return values","def topographic_altitude(self, lat_d, lon_d):\n return self.altitude(lat_d, lon_d)","def topographic_altitude(self, lat_d, lon_d):\n return self.altitude(lat_d, lon_d)","def __interp__(T0, g0, T, g, dT_max=0.1, eps=1e-6):\r\n\r\n kappa = 0.1\r\n idx = np.arange(len(g))\r\n deltag = g - g0\r\n deltaT = T - T0\r\n dist = kappa * abs(deltag) + abs(deltaT)\r\n if dist.min() == 0:\r\n return (dist.argmin(), -1, -1, -1), (1.0, 0.0, 0.0, 0.0)\r\n\r\n # Looking for i_{1..4}\r\n ind_dT = deltaT >= 0\r\n ind_dg = deltag >= 0\r\n # i1\r\n ind = ind_dT & ind_dg\r\n if True in ind:\r\n i1 = idx[ind][dist[ind].argmin()]\r\n else:\r\n i1 = -1\r\n\r\n # i2\r\n ind = ind_dT & ~ind_dg\r\n if True in ind:\r\n i2 = idx[ind][dist[ind].argmin()]\r\n else:\r\n i2 = -1\r\n\r\n # i3\r\n ind = ~ind_dT & ind_dg\r\n if True in ind:\r\n i3 = idx[ind][dist[ind].argmin()]\r\n else:\r\n i3 = -1\r\n\r\n # i4\r\n ind = ~ind_dT & ~ind_dg\r\n if True in ind:\r\n i4 = idx[ind][dist[ind].argmin()]\r\n else:\r\n i4 = -1\r\n\r\n # checking integrity\r\n if (i1 < 0) & (i2 < 0) & (i3 < 0) & (i4 < 0):\r\n raise ValueError(\"Interp. Error, could not find appropriate knots\")\r\n\r\n T1 = T[i1]\r\n T2 = T[i2]\r\n T3 = T[i3]\r\n T4 = T[i4]\r\n g1 = g[i1]\r\n g2 = g[i2]\r\n g3 = g[i3]\r\n g4 = g[i4]\r\n\r\n # If, T2 (resp. T1) is too far from T compared to T1\r\n # (resp. T2), i2 (resp. i1) is not used.\r\n # The same for i3 and i4.\r\n if (i1 > 0) & (i2 > 0):\r\n if T1 < T2 - dT_max:\r\n i2 = -1\r\n elif T2 < T1 - dT_max:\r\n i1 = -1\r\n\r\n if (i3 > 0) & (i4 > 0):\r\n if T3 > T4 + dT_max:\r\n i4 = -1\r\n elif T4 > T3 + dT_max:\r\n i3 = -1\r\n\r\n if (i1 < 0) & (i2 < 0) & (i3 < 0) & (i4 < 0):\r\n raise ValueError(\"Interp. Error, could not find appropriate knots\")\r\n\r\n # Interpolation in the (T, g) plane between the used points\r\n # (at least 1, at most 4).\r\n # Code \"0110\" means that i1 = i4 = 0, i2 /=0 and i3 /= 0.\r\n #\r\n # Note: preference is always given to the temperature over\r\n # the gravity when needed.\r\n if i1 < 0:\r\n if i2 < 0:\r\n if i3 < 0:\r\n if i4 < 0:\r\n # # 0000\r\n raise ValueError(\"Error\") # should not be possible\r\n else: # 0001\r\n alpha1 = 0.0\r\n alpha2 = 0.0\r\n alpha3 = 0.0\r\n alpha4 = 1.0\r\n # endif\r\n elif i4 < 0: # 0010\r\n alpha1 = 0.0\r\n alpha2 = 0.0\r\n alpha3 = 1.0\r\n alpha4 = 0.0\r\n else: # 0011\r\n alpha1 = 0.0\r\n alpha2 = 0.0\r\n if abs(T3 - T4) < eps:\r\n if g3 == g4:\r\n alpha3 = 0.5\r\n else:\r\n alpha3 = (g0 - g4) / (g3 - g4)\r\n # endif\r\n alpha4 = 1.0 - alpha3\r\n else:\r\n if T3 > T4:\r\n alpha3 = 1.0\r\n alpha4 = 0.0\r\n i4 = -1\r\n else:\r\n alpha3 = 0.0\r\n i3 = -1\r\n alpha4 = 1.0\r\n # endif\r\n # endif\r\n # endif\r\n elif i3 < 0:\r\n if i4 < 0:\r\n # # 0100\r\n alpha1 = 0.0\r\n alpha2 = 1.0\r\n alpha3 = 0.0\r\n alpha4 = 0.0\r\n else: # 0101\r\n alpha1 = 0.0\r\n if T2 == T4:\r\n alpha2 = 0.5\r\n else:\r\n alpha2 = (T0 - T4) / (T2 - T4)\r\n # endif\r\n alpha3 = 0.0\r\n alpha4 = 1.0 - alpha2\r\n # endif\r\n elif i4 < 0: # 0110\r\n alpha1 = 0.0\r\n if T2 == T3:\r\n alpha2 = 0.5\r\n else:\r\n alpha2 = (T0 - T3) / (T2 - T3)\r\n # endif\r\n alpha3 = 1.0 - alpha2\r\n alpha4 = 0.0\r\n else: # 0111\r\n # Assume that (T, g) is within the triangle i\r\n # formed by the three points.\r\n\r\n mat0 = np.asarray([[T2, T3, T4], [g2, g3, g4], [1.0, 1.0, 1.0]])\r\n mat2 = np.asarray([[T0, T3, T4], [g0, g3, g4], [1.0, 1.0, 1.0]])\r\n mat3 = np.asarray([[T2, T0, T4], [g2, g0, g4], [1.0, 1.0, 1.0]])\r\n mat4 = np.asarray([[T2, T3, T0], [g2, g3, g0], [1.0, 1.0, 1.0]])\r\n det0 = __det3x3__(mat0.ravel())\r\n det2 = __det3x3__(mat2.ravel())\r\n det3 = __det3x3__(mat3.ravel())\r\n det4 = __det3x3__(mat4.ravel())\r\n alpha1 = 0.0\r\n alpha2 = det2 / det0\r\n alpha3 = det3 / det0\r\n alpha4 = det4 / det0\r\n\r\n # If (T, g) is outside the triangle formed\r\n # by the three used points use only two points.\r\n if (\r\n (alpha2 < 0.0)\r\n | (alpha2 > 1.0)\r\n | (alpha3 < 0.0)\r\n | (alpha3 > 1.0)\r\n | (alpha4 < 0.0)\r\n | (alpha4 > 1.0)\r\n ):\r\n alpha1 = 0.0\r\n if T2 == T3:\r\n alpha2 = 0.5\r\n else:\r\n alpha2 = (T0 - T3) / (T2 - T3)\r\n # endif\r\n alpha3 = 1.0 - alpha2\r\n alpha4 = 0.0\r\n i4 = -1\r\n # endif\r\n # endif\r\n elif i2 < 0:\r\n if i3 < 0:\r\n if i4 < 0:\r\n # # 1000\r\n alpha1 = 1.0\r\n alpha2 = 0.0\r\n alpha3 = 0.0\r\n alpha4 = 0.0\r\n else: # 1001\r\n if T1 == T4:\r\n alpha1 = 0.5\r\n else:\r\n alpha1 = (T0 - T4) / (T1 - T4)\r\n # endif\r\n alpha2 = 0.0\r\n alpha3 = 0.0\r\n alpha4 = 1.0 - alpha1\r\n # endif\r\n elif i4 < 0: # 1010\r\n if T1 == T3:\r\n alpha1 = 0.5\r\n else:\r\n alpha1 = (T0 - T3) / (T1 - T3)\r\n # endif\r\n alpha2 = 0.0\r\n alpha3 = 1.0 - alpha1\r\n alpha4 = 0.0\r\n else: # 1011\r\n # Assume that (T, g) is within the triangle formed by the three points.\r\n mat0 = np.asarray([[T1, T3, T4], [g1, g3, g4], [1.0, 1.0, 1.0]])\r\n mat1 = np.asarray([[T0, T3, T4], [g0, g3, g4], [1.0, 1.0, 1.0]])\r\n mat3 = np.asarray([[T1, T0, T4], [g1, g0, g4], [1.0, 1.0, 1.0]])\r\n mat4 = np.asarray([[T1, T3, T0], [g1, g3, g0], [1.0, 1.0, 1.0]])\r\n det0 = __det3x3__(mat0.ravel())\r\n det1 = __det3x3__(mat1.ravel())\r\n det3 = __det3x3__(mat3.ravel())\r\n det4 = __det3x3__(mat4.ravel())\r\n alpha1 = det1 / det0\r\n alpha2 = 0.0\r\n alpha3 = det3 / det0\r\n alpha4 = det4 / det0\r\n # If (T, g) is outside the triangle formed by the three used points, # use only two points.\r\n\r\n if (\r\n (alpha1 < 0.0)\r\n | (alpha1 > 1.0)\r\n | (alpha3 < 0.0)\r\n | (alpha3 > 1.0)\r\n | (alpha4 < 0.0)\r\n | (alpha4 > 1.0)\r\n ):\r\n if T1 == T4:\r\n alpha1 = 0.5\r\n else:\r\n alpha1 = (T0 - T4) / (T1 - T4)\r\n # endif\r\n alpha2 = 0.0\r\n alpha3 = 0.0\r\n i3 = -1\r\n alpha4 = 1.0 - alpha1\r\n # endif\r\n # endif\r\n elif i3 < 0:\r\n if i4 < 0:\r\n # # 1100\r\n if abs(T1 - T2) < eps:\r\n if g1 == g2:\r\n alpha1 = 0.5\r\n else:\r\n alpha1 = (g0 - g2) / (g1 - g2)\r\n # endif\r\n alpha2 = 1.0 - alpha1\r\n else:\r\n if T1 < T2:\r\n alpha1 = 1.0\r\n alpha2 = 0.0\r\n i2 = -1\r\n else:\r\n alpha1 = 0.0\r\n i1 = -1\r\n alpha2 = 1.0\r\n # endif\r\n # endif\r\n alpha3 = 0.0\r\n alpha4 = 0.0\r\n else: # 1101\r\n # Assume that (T, g) is within the triangle formed by the three points.\r\n mat0 = np.asarray([[T1, T2, T4], [g1, g2, g4], [1.0, 1.0, 1.0]])\r\n mat1 = np.asarray([[T0, T2, T4], [g0, g2, g4], [1.0, 1.0, 1.0]])\r\n mat2 = np.asarray([[T1, T0, T4], [g1, g0, g4], [1.0, 1.0, 1.0]])\r\n mat4 = np.asarray([[T1, T2, T0], [g1, g2, g0], [1.0, 1.0, 1.0]])\r\n det0 = __det3x3__(mat0.ravel())\r\n det1 = __det3x3__(mat1.ravel())\r\n det2 = __det3x3__(mat2.ravel())\r\n det4 = __det3x3__(mat4.ravel())\r\n alpha1 = det1 / det0\r\n alpha2 = det2 / det0\r\n alpha3 = 0.0\r\n alpha4 = det4 / det0\r\n\r\n # If (T, g) is outside the triangle formed by the three used points,\r\n # use only two points.\r\n if (\r\n (alpha1 < 0.0)\r\n | (alpha1 > 1.0)\r\n | (alpha2 < 0.0)\r\n | (alpha2 > 1.0)\r\n | (alpha4 < 0.0)\r\n | (alpha4 > 1.0)\r\n ):\r\n if T1 == T4:\r\n alpha1 = 0.5\r\n else:\r\n alpha1 = (T0 - T4) / (T1 - T4)\r\n # endif\r\n alpha2 = 0.0\r\n i2 = -1\r\n alpha3 = 0.0\r\n alpha4 = 1.0 - alpha1\r\n # endif\r\n # endif\r\n elif i4 < 0:\r\n # # 1110\r\n # Assume that (T, g) is within the triangle formed by the three points.\r\n mat0 = np.asarray([[T1, T2, T3], [g1, g2, g3], [1.0, 1.0, 1.0]])\r\n mat1 = np.asarray([[T0, T2, T3], [g0, g2, g3], [1.0, 1.0, 1.0]])\r\n mat2 = np.asarray([[T1, T0, T3], [g1, g0, g3], [1.0, 1.0, 1.0]])\r\n mat3 = np.asarray([[T1, T2, T0], [g1, g2, g0], [1.0, 1.0, 1.0]])\r\n det0 = __det3x3__(mat0.ravel())\r\n det1 = __det3x3__(mat1.ravel())\r\n det2 = __det3x3__(mat2.ravel())\r\n det3 = __det3x3__(mat3.ravel())\r\n alpha1 = det1 / det0\r\n alpha2 = det2 / det0\r\n alpha3 = det3 / det0\r\n alpha4 = 0.0\r\n\r\n # If (T, g) is outside the triangle formed by the three used points,\r\n # use only two points.\r\n if (\r\n (alpha1 < 0.0)\r\n | (alpha1 > 1.0)\r\n | (alpha2 < 0.0)\r\n | (alpha2 > 1.0)\r\n | (alpha3 < 0.0)\r\n | (alpha3 > 1.0)\r\n ):\r\n alpha1 = 0.0\r\n i1 = -1\r\n if T2 == T3:\r\n alpha2 = 0.5\r\n else:\r\n alpha2 = (T0 - T3) / (T2 - T3)\r\n # endif\r\n alpha3 = 1.0 - alpha2\r\n alpha4 = 0.0\r\n # endif\r\n # endif\r\n\r\n # All four points used.\r\n\r\n if (i3 >= 0) & (i4 >= 0) & (i1 >= 0) & (i2 >= 0):\r\n if T1 != T3:\r\n alpha = (T0 - T3) / (T1 - T3)\r\n else:\r\n alpha = 0.5\r\n # endif\r\n if T2 != T4:\r\n beta = (T0 - T4) / (T2 - T4)\r\n else:\r\n beta = 0.5\r\n # endif\r\n gprim = alpha * g1 + (1 - alpha) * g3\r\n gsec = beta * g2 + (1 - beta) * g4\r\n if gprim != gsec:\r\n gamma = (g0 - gsec) / (gprim - gsec)\r\n else:\r\n gamma = 0.5\r\n # endif\r\n alpha1 = alpha * gamma\r\n alpha2 = beta * (1 - gamma)\r\n alpha3 = (1 - alpha) * gamma\r\n alpha4 = (1 - beta) * (1 - gamma)\r\n # endif\r\n\r\n return (\r\n np.asarray((i1, i2, i3, i4)),\r\n np.asarray((alpha1, alpha2, alpha3, alpha4)),\r\n )","def interpolate(self, new_times):\n\n # check if the times are to be grabbed from a ping_data object\n if isinstance(new_times, ping_data):\n new_times = new_times.ping_time\n\n # and interpolate\n self.data[:] = np.interp(self.ping_time, new_times,\n self.data, left=np.nan, right=np.nan)\n self.ping_time = new_times.copy()","def linear_interpolate_value_change(t0, v0, t1, v1, dt):\n return (v1 - v0)/float(t1-t0) * dt","def interp_1d(_x, _x_min, _x_step, _nx, _ar_f, _ord=3, _ix_per=1, _ix_ofst=0):\r\n if(_ord == 1):\r\n i0 = int(trunc((_x - _x_min)/_x_step + 1.e-09))\r\n if(i0 < 0):\r\n i0 = 0\r\n elif(i0 >= _nx - 1):\r\n i0 = _nx - 2\r\n i1 = i0 + 1\r\n f0 = _ar_f[i0*_ix_per + _ix_ofst]\r\n f1 = _ar_f[i1*_ix_per + _ix_ofst]\r\n t = (_x - (_x_min + _x_step*i0))/_x_step\r\n return f0 + (f1 - f0)*t\r\n elif(_ord == 2):\r\n i0 = int(round((_x - _x_min)/_x_step))\r\n if(i0 < 1):\r\n i0 = 1\r\n elif(i0 >= _nx - 1):\r\n i0 = _nx - 2\r\n im1 = i0 - 1\r\n i1 = i0 + 1\r\n t = (_x - (_x_min + _x_step*i0))/_x_step\r\n a0 = _ar_f[i0*_ix_per + _ix_ofst]\r\n fm1 = _ar_f[im1*_ix_per + _ix_ofst]\r\n f1 = _ar_f[i1*_ix_per + _ix_ofst]\r\n a1 = 0.5*(f1 - fm1)\r\n a2 = 0.5*(fm1 + f1 - 2*a0)\r\n return a0 + t*(a1 + t*a2)\r\n elif(_ord == 3):\r\n i0 = int(trunc((_x - _x_min)/_x_step + 1.e-09))\r\n if(i0 < 1):\r\n i0 = 1\r\n elif(i0 >= _nx - 2):\r\n i0 = _nx - 3\r\n im1 = i0 - 1\r\n i1 = i0 + 1\r\n i2 = i0 + 2\r\n t = (_x - (_x_min + _x_step*i0))/_x_step\r\n a0 = _ar_f[i0*_ix_per + _ix_ofst]\r\n fm1 = _ar_f[im1*_ix_per + _ix_ofst]\r\n f1 = _ar_f[i1*_ix_per + _ix_ofst]\r\n f2 = _ar_f[i2*_ix_per + _ix_ofst]\r\n a1 = -0.5*a0 + f1 - f2/6. - fm1/3.\r\n a2 = -a0 + 0.5*(f1 + fm1)\r\n a3 = 0.5*(a0 - f1) + (f2 - fm1)/6.\r\n return a0 + t*(a1 + t*(a2 + t*a3))\r\n return 0","def interpolate(self, image):\n return","def get_elementary_airspace_altitude_range(db_id):\n connection = get_geo_db_connection()\n sector = find_sector(db_id, connection)\n if (sector):\n return (sector['min_altitude'], sector['max_altitude'])\n else:\n raise NotFoundException(db_id, \"Elementary sector not found.\")","def interpolate ( hsl1, hsl2, amt ):\n if isinstance( hsl1, Colz ):\n h1 = hsl1.h\n s1 = hsl1.s\n l1 = hsl1.l\n a1 = hsl1.a\n if isinstance( hsl1, list ):\n h1 = hsl1[0]\n s1 = hsl1[1]\n l1 = hsl1[2]\n if len(hsl1) > 3:\n a1 = hsl1[3]\n\n if isinstance( h1, int ):\n h1 = h1 / 360.0\n if isinstance( s1, int ):\n s1 = s1 / 100.0\n if isinstance( l1, int ):\n l1 = l1 / 100.0\n\n if isinstance( hsl2, Colz ):\n h2 = hsl2.h\n s2 = hsl2.s\n l2 = hsl2.l\n a2 = hsl2.a\n if isinstance( hsl2, list ):\n h2 = hsl2[0]\n s2 = hsl2[1]\n l2 = hsl2[2]\n if len(hsl2) > 3:\n a2 = hsl2[3]\n\n if isinstance( h2, int ):\n h2 = h2 / 360.0\n if isinstance( s2, int ):\n s2 = s2 / 100.0\n if isinstance( l2, int ):\n l2 = l2 / 100.0\n\n h3 = Colz.hueLerp( h1, h2, amt )\n s3 = Colz.linearLerp( s1, s2, amt )\n l3 = Colz.linearLerp( l1, l2, amt )\n\n if 'a1' in locals() and 'a2' in locals():\n a3 = Colz.linearLerp( a1, a2, amt )\n else:\n a3 = 1.0\n\n c_result = Colz()\n c_result.setHsla( h3, s3, l3, a3 )\n return c_result","def _get_age_func(self)\t:\n\t\tage_nc_Arr = self['age_nc_Arr'].value\n\t\tage_lon_Vec = self['age_lon_Vec'].value\n\t\tage_lat_Vec = self['age_lat_Vec'].value\n\t\txx, yy = np.meshgrid(age_lon_Vec, age_lat_Vec) # xx for longitude, yy for latitude\n\t\txx = xx.reshape(xx.size) #nearest\n\t\tyy = yy.reshape(yy.size)\n\t\tx = np.column_stack((xx,yy))\n\t\ty = age_nc_Arr.reshape(age_nc_Arr.size)\n\t\tself.age_func = NearestNDInterpolator(x,y,rescale=False)\n\t\treturn","def interpolate_na(self, method: str = \"nearest\", **kwargs):\n ds_out = xr.Dataset(attrs=self._obj.attrs)\n for var in self.vars:\n ds_out[var] = self._obj[var].raster.interpolate_na(method=method, **kwargs)\n return ds_out","def _interp1(x, y, xi):\n x_length = len(x)\n xi_length = len(xi)\n yi = np.zeros(xi_length)\n k = np.zeros(xi_length, dtype=int)\n h = x[1:] - x[:-1]\n \n _histc(x, xi, k)\n\n for i in range(xi_length):\n s = (xi[i] - x[k[i] - 1]) / h[k[i] - 1]\n yi[i] = y[k[i] - 1] + s * (y[k[i]] - y[k[i] - 1])\n return yi","def interpol(self,x,y,x1):\n \n N = len(x)\n i = np.minimum(np.maximum(np.searchsorted(x,x1,side='right'),1),N-1)\n xl = x[i-1]\n xr = x[i]\n yl = y[i-1]\n yr = y[i]\n y1 = yl + (yr-yl)/(xr-xl) * (x1-xl)\n above = x1 > x[-1]\n below = x1 < x[0]\n y1 = np.where(above,y[-1] + (x1 - x[-1]) * (y[-1]-y[-2])/(x[-1]-x[-2]), y1)\n y1 = np.where(below,y[0],y1)\n \n return y1, i","def interpPoints(self, interpRad=False):\n # print(np.shape(long_distances))\n long_sections, long_distances, meddist = self.findLongSections()\n \n print('Long inter-point distances found: %i' % len(long_sections))\n count = 0\n for sec in long_sections:\n print('Supposed long section %i has %i nodes' \\\n % (sec, len(self.sections[sec])))\n # set first and last points for interpolation\n pt0, pt1 = self.sections[sec][0], self.sections[sec][-1]\n # find number of points\n numpts = int(long_distances[long_sections.index(sec)]/meddist)\n Xs = np.linspace(pt0[0], pt1[0], numpts)\n Ys = np.linspace(pt0[1], pt1[1], numpts)\n Zs = np.linspace(pt0[2], pt1[2], numpts)\n \n newpts = np.dstack((Xs, Ys, Zs))\n newpts = [newpts[0][i] for i in xrange(len(newpts[0]))]\n self.sections[sec] = newpts\n count = count + 1\n rad0, rad1 = self.secRads[sec][0], self.secRads[sec][-1]\n # print(rad0, rad1)\n rads = np.linspace(rad0, rad1, numpts)\n # print(rads)\n self.secRads[sec] = rads \n \n long_sections, long_distances, meddist = self.findLongSections()\n print('Long sections still remaining: %i' % len(long_sections))\n if len(long_sections) > 0:\n print(long_distances, meddist)\n \n return self","def interpolation_array(a1, a2):\n return (a1+a2)/2.","def interpolate(self, a, b, t):\n d1 = (t - a[0]).seconds\n d2 = (b[0] - t).seconds\n # The total time difference\n d = float(d1 + d2)\n point = []\n # Need to return a (time, lat, lon, elev) point\n point.append(t)\n # Linear interpolation of the latitude, longitude, and elevation\n point.append(float(a[1])*(d2/d) + float(b[1])*(d1/d))\n point.append(float(a[2])*(d2/d) + float(b[2])*(d1/d))\n point.append(float(a[3])*(d2/d) + float(b[3])*(d1/d))\n if self.verbose:\n sys.stderr.write('Interpolate:\\n')\n sys.stderr.write('\\t%s\\n' % repr(a))\n sys.stderr.write('\\t%s\\n' % repr(point))\n sys.stderr.write('\\t%s\\n' % repr(b))\n return point","def altitude(self, value: int):\n self._point.altitude = value","def pressure_to_altitude(pres):\n for i in range(len(_heights)-1,0,-1):\n P0 = _basepress[i]\n T0 = _basetemps[i]\n if pres < P0:\n if _isotherm[i]:\n dh = _R * T0 / _g * math.log(P0 / pres)\n else:\n l0 = _lapsert[i]\n dh = T0 / l0 * (math.pow(pres / P0, -l0 * _R / _g) - 1)\n return _heights[i] + dh\n l0 = _lapsert[0]\n return _stdtemp / l0 * (math.pow(pres / _stdpres, -l0 * _R / _g) - 1)","def interpolate_linear(self, transect):\n\n u = np.copy(self.u_mps)\n v = np.copy(self.v_mps)\n\n valid = np.isnan(u) == False\n\n # Check for valid data\n if sum(valid) > 1 and sum(self.valid_data[0, :]) > 1:\n\n # Compute ens_time\n ens_time = np.nancumsum(transect.date_time.ens_duration_sec)\n\n # Apply linear interpolation\n self.u_processed_mps = np.interp(x=ens_time,\n xp=ens_time[self.valid_data[0, :]],\n fp=u[self.valid_data[0, :]],\n left=np.nan,\n right=np.nan)\n # Apply linear interpolation\n self.v_processed_mps = np.interp(x=ens_time,\n xp=ens_time[self.valid_data[0, :]],\n fp=v[self.valid_data[0, :]],\n left=np.nan,\n right=np.nan)","def linear_interp(x,y,xi) :\n \n f = interp1d(x,y,kind='linear')\n yi = f(xi)\n \n return yi","def interpolate_loss_calculation(self, interpolates):\n _, fake_scores = self.D(interpolates)\n return fake_scores","def AEH2LatLonAlt(azim, elev, h, lat, lon, alt):\n\n # Compute the range to the point\n r = AEH2Range(azim, elev, h, lat, lon, alt)\n\n\n # Compute lat/lon/alt of the point on the line of sight\n x, y, z = AER2ECEF(azim, elev, r, lat, lon, alt)\n lat2, lon2, alt2 = ecef2LatLonAlt(x, y, z)\n lat2, lon2 = np.degrees(lat2), np.degrees(lon2)\n\n\n return lat2, lon2, alt2","def interpolate_variable(self, wavelengths, apertures):\n\n if self.n_ap == 1:\n return self.flux[0, :]\n\n sed_apertures = self.apertures.to(u.au).value\n sed_wav = self.wav.to(u.micron).value\n\n # If any apertures are larger than the defined max, reset to max\n apertures[apertures > sed_apertures.max()] = sed_apertures.max() * 0.999\n\n # If any apertures are smaller than the defined min, raise Exception\n if np.any(apertures < sed_apertures.min()):\n raise Exception(\"Aperture(s) requested too small\")\n\n # Find wavelength order\n order = np.argsort(wavelengths)\n\n # Interpolate apertures vs wavelength\n log10_ap_interp = interp1d(np.log10(wavelengths[order]), np.log10(apertures[order]), bounds_error=False, fill_value=np.nan)\n\n # Create interpolating function\n flux_interp = interp1d(sed_apertures, self.flux.swapaxes(0, 1))\n\n # Interpolate the apertures\n apertures = 10. ** log10_ap_interp(np.log10(sed_wav))\n\n # Extrapolate on either side\n apertures[np.log10(sed_wav) < log10_ap_interp.x[0]] = 10. ** log10_ap_interp.y[0]\n apertures[np.log10(sed_wav) > log10_ap_interp.x[-1]] = 10. ** log10_ap_interp.y[-1]\n\n # Interpolate and return only diagonal elements\n return flux_interp(apertures).diagonal()","def extrapolate_nearest(self, known_coords, known_values, extrap_coords, groupname):\n\t\t#First need to reshape known_coords and known_values\n\t\tn_params = self.signal[groupname]['dimension']\n\t\tknown_coords = np.reshape( known_coords, (-1,n_params) )\n\t\tknown_values = np.reshape( known_values, (-1) )\n\t\t\t\t\n\t\t#Different methods if dimension is (!/=)= 1\n\t\tif self.signal[groupname]['dimension'] == 1:\n\t\t\t#Reshape extrap_coords\n\t\t\textrap_coords = np.reshape(extrap_coords, (-1))\n\t\t\t\n\t\t\t#Initialize array for extrapolation values\n\t\t\textrap_values = np.ones(len(extrap_coords))*np.nan\n\t\t\t\n\t\t\t#Find minimum and maximum coordinates and the respective values at those coordinates\n\t\t\tmin_coord_index = np.argmin(known_coords)\n\t\t\tmin_coord = known_coords[min_coord_index]\n\t\t\tmin_coord_value = known_values[min_coord_index]\n\t\t\t\n\t\t\tmax_coord_index = np.argmax(known_coords)\n\t\t\tmax_coord = known_coords[max_coord_index]\n\t\t\tmax_coord_value = known_values[max_coord_index]\n\t\t\t\n\t\t\t#Do the nearest-bound extrapolation\n\t\t\textrap_values[np.absolute(extrap_coords - max_coord) >= np.absolute(extrap_coords - min_coord)] = min_coord_value\n\t\t\textrap_values[np.absolute(extrap_coords - max_coord) < np.absolute(extrap_coords - min_coord)] = max_coord_value\n\t\t\t\n\t\telif self.signal[groupname]['dimension'] > 1:\n\t\t\textrap_values = griddata(known_coords, known_values, extrap_coords, method='nearest')\n\t\t\n\t\treturn extrap_values","def slerp(q0: np.ndarray, q1: np.ndarray, t_array: np.ndarray, threshold: float = 0.9995) -> np.ndarray:\n qdot = np.dot(q0, q1)\n # Ensure SLERP takes the shortest path\n if qdot < 0.0:\n q1 *= -1.0\n qdot *= -1.0\n # Interpolate linearly (LERP)\n if qdot > threshold:\n result = q0[np.newaxis, :] + t_array[:, np.newaxis]*(q1 - q0)[np.newaxis, :]\n return (result.T / np.linalg.norm(result, axis=1)).T\n # Angle between vectors\n theta_0 = np.arccos(qdot)\n sin_theta_0 = np.sin(theta_0)\n theta = theta_0*t_array\n sin_theta = np.sin(theta)\n s0 = np.cos(theta) - qdot*sin_theta/sin_theta_0\n s1 = sin_theta/sin_theta_0\n return s0[:, np.newaxis]*q0[np.newaxis, :] + s1[:, np.newaxis]*q1[np.newaxis, :]","def interpolated(self, Any, Any_1, p_float): # real signature unknown; restored from __doc__\n pass","def see_what_its_doing_1d():\n all_points = create_points_with_random_pollution_1d(100, 100, 10)\n picked_points = pick_uniform_random_points(all_points, 20)\n interpolated_points = interpolate_unknown_points(picked_points, all_points)\n\n picked_x = []\n picked_pollution = []\n for label, point in picked_points.items():\n picked_x.append(label)\n picked_pollution.append(point.get_pollution_value())\n\n interp_x = []\n inter_pollution = []\n\n for label, point in interpolated_points.items():\n if not label in picked_x:\n interp_x.append(label)\n inter_pollution.append(point.get_pollution_value())\n\n plt.plot(picked_x, picked_pollution, \"ro\", interp_x, inter_pollution, \"go\")\n plt.xlabel(\"Point Label\")\n plt.ylabel(\"Pollution Value\")\n plt.show()","def see_what_its_doing_1d():\n all_points = create_points_with_random_pollution_1d(100, 100, 10)\n picked_points = pick_uniform_random_points(all_points, 20)\n interpolated_points = interpolate_unknown_points(picked_points, all_points)\n\n picked_x = []\n picked_pollution = []\n for label, point in picked_points.items():\n picked_x.append(label)\n picked_pollution.append(point.get_pollution_value())\n\n interp_x = []\n inter_pollution = []\n\n for label, point in interpolated_points.items():\n if not label in picked_x:\n interp_x.append(label)\n inter_pollution.append(point.get_pollution_value())\n\n plt.plot(picked_x, picked_pollution, \"ro\", interp_x, inter_pollution, \"go\")\n plt.xlabel(\"Point Label\")\n plt.ylabel(\"Pollution Value\")\n plt.show()","def see_what_its_doing_1d():\n all_points = create_points_with_random_pollution_1d(100, 100, 10)\n picked_points = pick_uniform_random_points(all_points, 20)\n interpolated_points = interpolate_unknown_points(picked_points, all_points)\n\n picked_x = []\n picked_pollution = []\n for label, point in picked_points.items():\n picked_x.append(label)\n picked_pollution.append(point.get_pollution_value())\n\n interp_x = []\n inter_pollution = []\n\n for label, point in interpolated_points.items():\n if not label in picked_x:\n interp_x.append(label)\n inter_pollution.append(point.get_pollution_value())\n\n plt.plot(picked_x, picked_pollution, \"ro\", interp_x, inter_pollution, \"go\")\n plt.xlabel(\"Point Label\")\n plt.ylabel(\"Pollution Value\")\n plt.show()","def InterpolatePoint(self, p_int, vtkDataSetAttributes, vtkIdList, *float, **kwargs):\n ...","def myinterp2d(x, y, z, xnew, ynew, method='linear'):\n x = np.ravel(x)\n y = np.ravel(y)\n z = np.ravel(z)\n znew = griddata((x, y), z, (xnew, ynew), method=method, fill_value=0.)\n return znew","def test_linear_interpolation_nan_points(self):\n\n # Define pixel centers along each direction\n x = [1.0, 2.0, 4.0]\n y = [5.0, 9.0]\n\n # Define ny by nx array with corresponding values\n A = numpy.zeros((len(x), len(y)))\n\n # Define values for each x, y pair as a linear function\n for i in range(len(x)):\n for j in range(len(y)):\n A[i, j] = linear_function(x[i], y[j])\n\n # Then test that interpolated points can contain NaN\n xis = numpy.linspace(x[0], x[-1], 10)\n etas = numpy.linspace(y[0], y[-1], 10)\n xis[6:7] = numpy.nan\n etas[3] = numpy.nan\n points = combine_coordinates(xis, etas)\n\n vals = interpolate2d(x, y, A, points, mode='linear')\n refs = linear_function(points[:, 0], points[:, 1])\n assert nanallclose(vals, refs, rtol=1e-12, atol=1e-12)","def healpixels2dist(nside, hp1,hp2):\n lat1, ra1 = hp.pix2ang(nside,hp1)\n lat2, ra2 = hp.pix2ang(nside,hp2)\n dec1 = np.pi/2.0 - lat1\n dec2 = np.pi/2.0 - lat2\n\n angDist = haversine(ra1,dec1,ra2,dec2)\n return angDist","def augmentDistance(self):\n\n for key,value in self._models.iteritems():\n src=[float(i) for i in value['src'].replace('#',' ').split()]\n tgt=[float(i) for i in value['tgt'].replace('#',' ').split()]\n\n dist = haversine((np.mean(src[0:2]),np.mean(src[2:])),\n (np.mean(tgt[0:2]),np.mean(tgt[2:])),\n miles=True)\n self._models[key]['distance'] = dist\n\n return","def interpolate(\n layer_attribution: Tensor,\n interpolate_dims: Union[int, Tuple[int, ...]],\n interpolate_mode: str = \"nearest\",\n ) -> Tensor:\n return F.interpolate(layer_attribution, interpolate_dims, mode=interpolate_mode)","def altitude(press, altimeter=29.92126):\n AS = altimeter*inHg2PA\n print(AS, press**(L*R/g/M))\n h = -(press**(L*R/g/M) - AS**(L*R/g/M))*T0/L/(P0**(L*R/g/M))\n return h/ft2m","def set_altitude(self):\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\n print('altitude set to', self.altitude)\n if self.altitude < 0:\n self.altitude = self.altitude + 360.0\n return self.altitude \n else: \n pass\n return self.altitude","def interpolate(self, mobject1, mobject2, alpha, path_func=straight_path()):\n self.set_points(path_func(mobject1.points, mobject2.points, alpha))\n return self","def lin_int(xs, ys):\n return scipy.interpolate.interp1d(xs, ys)","def Interpolate(self, ind, results):\n return _gmat_py.Interpolator_Interpolate(self, ind, results)","def dayInterpA(table, date):\n iDate = date.strftime('%Y-%m-%d')\n # age 0 to 99\n popi = table[table.date1 == iDate]\n\n # Remove the columns for age 100 and the date1\n popi = popi.iloc[:,0:100]\n\n # store the popi results into an array for the interpolation\n #popi = (np.asarray(popi)).tolist()\n popi = np.asarray(popi)\n\n # Interpolate the age in Days\n iuspl2 = InterpolatedUnivariateSpline(AGE3, popi/365)\n iuspl2_pred = iuspl2(AGEOUT)\n\n # the output\n merged = pd.DataFrame(index = range(0,len(AGEOUT)), columns = ['AGE','POP'])\n merged['AGE'] = AGEOUT\n merged['POP'] = iuspl2_pred\n return merged","def interpolate(Position_i1, Position_i2, inBetween):\r\n \r\n # Chain the timestamps together and calculate the delta t\r\n T1 = Position_i1[0][:5] + [int(Position_i1[0][5])] + [int((Position_i1[0][5]%1)*1000000)] \r\n T2 = Position_i2[0][:5] + [int(Position_i2[0][5])] + [int((Position_i2[0][5]%1)*1000000)]\r\n dt = dT(T1, T2)\r\n\r\n # Do the same with longitude and latitude.\r\n ds = [i[1]- i[0] for i in zip(Position_i1[1], Position_i2[1])]\r\n \r\n # Calculate the \"slope\":\r\n ds_dt = [i/dt for i in ds]\r\n \r\n # Make the timeStamp for (inBetween) more precise:\r\n precise_Time = inBetween[:5] + [int(inBetween[5])] + [int((inBetween[5]%1)*1000000)]\r\n \r\n # Calculate the time since the first measurement passed till \"inBetween\"\r\n DeltaT = dT(T1, precise_Time)\r\n\r\n # Calculate the precise position at \"inBetween\":\r\n Position = [DeltaT* i[0] + i[1] for i in zip(ds_dt, Position_i1[1])]\r\n\r\n # Then return the [timeStamp, [lon, lat]]\r\n return [inBetween, Position]","def interpolate_nans(self):\n\n signal = self.signal\n\n # check for more than one nan in row\n for i in range(len(signal)-1) :\n if np.isnan(signal[i]) and np.isnan(signal[i+1]) :\n raise Exception('There are two nans in a row ask moritz what to do !')\n\n if np.isnan(signal[0]) :\n np.signal[0] = signal[1]\n if np.isnan(signal[-1]) :\n signal[-1] = signal[-2]\n\n for i in range(1,len(signal)-1) :\n if np.isnan(signal[i]):\n signal[i] = (signal[i-1] + signal[i+1])/2","def interpolation_1D(rawdata, squint_vec, angle_vec):\n rawdata_corr = rawdata * 1\n for idx_freq in range(rawdata.shape[0]):\n az_new = angle_vec - squint_vec[idx_freq]\n current_data = rawdata[idx_freq, :]\n interpolator = _interp.interp1d(angle_vec, current_data, kind='linear', bounds_error=False, fill_value=0, assume_sorted=True)\n rawdata_corr[idx_freq, :] = interpolator(az_new)\n # rawdata_corr[idx_freq, :] = _np.interp(az_new, angle_vec, current_data, left=0.0, right=0.0)\n if idx_freq % 500 == 0:\n print_str = \"interp sample: {idx}, ,shift: {sh} samples\".format(idx=idx_freq, sh=az_new[0] - angle_vec[0])\n print(print_str)\n rawdata_corr = rawdata_corr.__array_wrap__(rawdata)\n return rawdata_corr"],"string":"[\n \"def interpolate(self, distance, normalized=...): # -> BaseGeometry:\\n ...\",\n \"def interpolate(i0, d0, i1, d1):\\n if i0 == i1:\\n return [d0]\\n values = []\\n a = (d1 - d0) / (i1 - i0)\\n d = d0\\n for i in range(i0,i1+1):\\n values.append(d)\\n d = d + a\\n return values\",\n \"def InterpolateDerivs(self, , p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=...):\\n ...\",\n \"def interpolate_meridional(self, *interp1d_args, **interp1d_kwargs):\\n return self.interp1d_meridional(*interp1d_args, **interp1d_kwargs)(self.lat)\",\n \"def get_altitude(points):\\n altitudes = np.zeros((len(points),), dtype=\\\"float64\\\")\\n for i, point in tqdm(enumerate(points), desc=\\\"GETTING ALTITUDE\\\"):\\n p = Point(point[0], point[1])\\n altitudes[i] = alt.NM_COTA.iloc[\\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\\n ]\\n return altitudes\",\n \"def intersection_distances(self, altitude, start_distance, finish_distance):\\n distances = []\\n alt_index, alt_ratio = calculate_value_reference(self.distances,\\n start_distance)\\n start_alt = calculate_value(self.altitudes, alt_index, alt_ratio)\\n\\n finish_index, finish_ratio = calculate_value_reference(self.distances,\\n finish_distance)\\n while alt_index < finish_index:\\n next_index = alt_index + 1\\n next_ratio = 0.0\\n next_alt = calculate_value(self.altitudes, next_index, next_ratio)\\n\\n # Does this section span the given altitude?\\n if (next_alt != start_alt) and \\\\\\n (min(start_alt, next_alt) < altitude < max(start_alt, next_alt)):\\n delta = altitude - start_alt\\n denom = next_alt - start_alt\\n ratio = delta / denom\\n distance = calculate_value(self.distances, alt_index, ratio)\\n distances.append(distance)\\n\\n alt_index = next_index\\n alt_ratio = next_ratio\\n start_alt = next_alt\\n\\n if finish_ratio:\\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\\n # Does the last section span the given altitude?\\n if (start_alt != finish_alt) and \\\\\\n (min(start_alt, finish_alt) < altitude < max(start_alt, finish_alt)):\\n # Calculate the altitude at the end of the section to maximimse accuracy\\n next_alt = calculate_value(self.altitudes, finish_index, 1.0)\\n delta = altitude - start_alt\\n denom = next_alt - start_alt\\n ratio = delta / denom\\n distance = calculate_value(self.distances, alt_index, ratio)\\n distances.append(distance)\\n\\n return distances\",\n \"def interpolate(x0, y0, x1, y1, x):\\n y = (y0 * (x1 - x) + y1 * (x - x0)) / (x1 - x0)\\n\\n return y\",\n \"def interpolate(self, interpolation=\\\"nearest\\\", **kwargs):\\n return podpac.interpolators.Interpolate(source=self, interpolation=interpolation, **kwargs)\",\n \"def interpolator(mat, distance):\\n\\n# calculate the place of each meassurement relative to the whole yourney of the\\n# ship\\n gesdistance = np.zeros(len(distance)+1)\\n gesdis = distance[0]\\n for i in range(1, len(distance)+1):\\n gesdistance[i] = gesdistance[i-1] + distance[i-1]\\n if i < len(distance):\\n gesdis = gesdis + distance[i]\\n\\n# calculates the minimum distance for number of points of the interpolation\\n mini = distance[0]\\n for i in range(len(distance)):\\n if distance[i] < mini:\\n mini = distance[i]\\n\\n# interpolates linear over every depth\\n newmat = np.zeros((len(mat), int(gesdis/mini)))\\n\\n wth = 0\\n for leng in range(len(newmat)):\\n newveloc = interp1d(gesdistance, mat[leng, :], kind=\\\"linear\\\")\\n for wth in range(int(gesdis/mini)):\\n newmat[leng, wth] = newveloc(wth*mini)\\n for wdth in range(int(gesdis/mini)):\\n newvelocdepth = interp1d(np.append(np.arange(0, 458, 20), 458), np.append(newmat[::20, wdth], newmat[457, wdth]), kind=\\\"linear\\\")\\n for le in range(len(newmat)):\\n newmat[le, wdth] = newvelocdepth(le)\\n\\n return np.flip(newmat), gesdis\",\n \"def interp_z(array, heights, goal):\\n\\n f = interpolate.interp1d(heights, array, fill_value='extrapolate')\\n return f(goal)\",\n \"def InterpolationDerivs(self, , p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=...):\\n ...\",\n \"def altitude_range(self, start_distance, finish_distance):\\n start_index, start_ratio = calculate_value_reference(self.distances,\\n start_distance)\\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\\n finish_index, finish_ratio = calculate_value_reference(self.distances,\\n finish_distance)\\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\\n\\n min_alt = min(start_alt, finish_alt)\\n max_alt = max(start_alt, finish_alt)\\n\\n if start_index < finish_index:\\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\\n min_alt = min(min_alt, altitudes.min())\\n max_alt = max(max_alt, altitudes.max())\\n\\n return min_alt, max_alt\",\n \"def interpolate(x_list, y_list, z_list):\\n x1 = x_list[-2]\\n x2 = x_list[-1]\\n y1 = y_list[-2]\\n y2 = y_list[-1]\\n z1 = z_list[-2]\\n z2 = z_list[-1]\\n r = -y1/y2\\n x_land = (x1+r*x2)/(r+1)\\n z_land = (z1+r*z2)/(r+1)\\n x_list[-1] = x_land\\n y_list[-1] = 0.0\\n z_list[-1] = z_land\",\n \"def test_1d_linear_interpolation_basic(self):\\n\\n # Define pixel centers along each direction\\n x = [1.0, 2.0, 4.0]\\n\\n # Define array with corresponding values\\n A = numpy.zeros((len(x)))\\n\\n # Define values for each xas a linear function\\n for i in range(len(x)):\\n A[i] = linear_function(x[i], 0)\\n\\n # Test first that original points are reproduced correctly\\n for i, xi in enumerate(x):\\n val = interpolate1d(x, A, [xi], mode='linear')[0]\\n ref = linear_function(xi, 0)\\n assert numpy.allclose(val, ref, rtol=1e-12, atol=1e-12)\\n\\n # Then test that genuinly interpolated points are correct\\n xis = numpy.linspace(x[0], x[-1], 10)\\n points = xis\\n\\n vals = interpolate1d(x, A, points, mode='linear')\\n refs = linear_function(points, 0)\\n assert numpy.allclose(vals, refs, rtol=1e-12, atol=1e-12)\\n\\n # Exercise bounds_error flag\\n vals = interpolate1d(x, A, points, mode='linear',\\n bounds_error=True)\\n refs = linear_function(points, 0)\\n assert numpy.allclose(vals, refs, rtol=1e-12, atol=1e-12)\",\n \"def interpolate(self, _val1h) :\\n\\n\\t\\tval1h = _val1h.reshape(reduce(operator.mul, _val1h.shape))\\t# Convert to 1-D\\n\\t\\tv1h = np.copy(val1h)\\n\\t\\tv1h[np.isnan(val1h)] = 0\\t# Prepare for multiply\\n\\t\\tval2 = self.M.transpose() * v1h\\n\\t\\tval2[np.logical_not(self.mask2)] = np.nan\\n\\t\\treturn val2\",\n \"def interpolate(self, kind='equidistant_steps', num=1):\\n x = self.x\\n y = self.y\\n d = self.d\\n\\n # cubic requires a different calculation, so check the kind first\\n if not (kind == 'equidistant_steps') | (kind == 'absolute_steps'):\\n raise ValueError(\\\"Keyword argument for 'kind' not recognised. See docs for options.\\\")\\n\\n\\n if kind == 'equidistant_steps':\\n # New list of distance points to interpolate Route data against\\n dist = list(np.arange(d.min(), d.max()+num, step=num))\\n\\n elif kind == 'absolute_steps':\\n # New list of distance points to interpolate Route data against\\n dist = list(np.linspace(d.min(), d.max(), num=num))\\n\\n # Interpolate x and y wrt to d against the new list of distanced points\\n xx = np.interp(dist, d, x)\\n yy = np.interp(dist, d, y)\\n\\n # interpolate z too if it exists\\n if self.z is not None:\\n # Start a new dict of z-axis data\\n zz = {}\\n # for each, interpolate and add to the new dict\\n for k, v in self.z.items():\\n zz[k] = np.interp(dist, d, v)\\n else:\\n zz = None\\n\\n return Route(xx, yy, z=zz)\",\n \"def interpolate(self, lon, lat, egy=None):\\n raise NotImplementedError(\\\"MapBase.interpolate()\\\")\",\n \"def interpolate(self, xs):\\n tck = splrep(self._xs, self._ys)\\n new_ys = splev(xs, tck, der=0)\\n return new_ys\",\n \"def interpolate(self, interp):\\n x = np.linspace(0, 29, len(self.ya))\\n f_ya = interpolate.interp1d(x, self.ya)\\n f_yv = interpolate.interp1d(x, self.yv)\\n f_pa = interpolate.interp1d(x, np.reshape(self.pa, [-1]))\\n f_pv = interpolate.interp1d(x, np.reshape(self.pv, [-1]))\\n\\n x_interp = np.linspace(0, 29, len(self.ya)*interp)\\n self.ya = list(f_ya(x_interp))\\n self.yv = list(f_yv(x_interp))\\n self.pa = list(f_pa(x_interp))\\n self.pv = list(f_pv(x_interp))\",\n \"def dardar2era(dardar, ERA, p_grid):\\n lon_d = dardar.get_data('longitude')\\n lat_d = dardar.get_data('latitude')\\n height_d = dardar.get_data('height')\\n\\n \\n# convert longitude from -180-180 to 0-360\\n if lon_d.min() < 0:\\n lon_d = lon_d % 360\\n \\n# add extra pressure level in ERA5 data\\n xlevel = 1200\\n ERA.add_extra_level('temperature', xlevel)\\n ERA.add_extra_level('geopotential', xlevel)\\n \\n# get ERA lat/lon/pressure grids\\n \\n lat = ERA.t.latitude.data\\n lon = ERA.t.longitude.data\\n level = ERA.t.level.data \\n t = ERA.t.t[0].data\\n z = ERA.z.z[0].data\\n \\n level = np.log(level) # convert pressure to log\\n \\n \\n# add two extra dimension to longitudes to wrap around during interpolation\\n \\n lon, z = expand_lon(ERA.z.longitude.data, z )\\n lon, t = expand_lon(ERA.t.longitude.data, t )\\n \\n #my_interpolating_function = RegularGridInterpolator((level, lat, lon), A)\\n \\n p_grid = np.arange(1, 1150, 10)\\n points = []\\n \\n# interpolate ERA5 to DARDAR lat/lon locations\\n \\n for i in range(len(p_grid)):\\n p = np.log(p_grid[i]) # convert pressure to log range\\n pts = [[p, lat_d[j], lon_d[j]] for j in range(len(lat_d))] \\n points.append(pts)\\n \\n my_interpolating_function = interpolate(level, lat, lon, t) \\n grid_t = my_interpolating_function(points)\\n \\n my_interpolating_function = interpolate(level, lat, lon, z) \\n grid_z = my_interpolating_function(points)\\n \\n return grid_t, grid_z\",\n \"def interpolate(self, freq, data):\\n func = scipy.interpolate.interp1d(\\n freq, data,\\n kind='nearest',\\n copy=False,\\n assume_sorted=True,\\n bounds_error=False,\\n fill_value=np.nan,\\n )\\n return func(self.freq)\",\n \"def _LinearInterpolate(x0, target, x1, y0, y1):\\n if x0 == x1:\\n return (y0 + y1) / 2\\n return (y1 - y0) * (target - x0) / (x1 - x0) + y0\",\n \"def linear_interpolate(x, x0, y0, x1, y1):\\n try:\\n return (y0 * (x1 - x) + y1 * (x - x0)) / (x1 - x0)\\n except ZeroDivisionError:\\n return 0.0\",\n \"def position_extrapolate(dist_1_coords, dist_2_coords, delta_heading, delta_distance):\\n ref_coord = dist_1_coords\\n ref_dir = np.arctan2(dist_1_coords[1] - dist_2_coords[1], dist_1_coords[0] - dist_2_coords[0])\\n\\n curr_dir = ref_dir + delta_heading\\n x = ref_coord[0] + delta_distance*np.cos(curr_dir)\\n y = ref_coord[1] + delta_distance*np.sin(curr_dir)\\n z = ref_coord[2]\\n\\n return [x, y, z]\",\n \"def interpolator(self, states):\\n t = np.asarray([state.t for state in states])\\n y = np.asarray([state.y for state in states])\\n\\n return interp1d(t, y, assume_sorted=True, kind='cubic')\",\n \"def __hinterpolate(self):\\n \\n # Temp. Data holders\\n upperint = []\\n lowerint = []\\n \\n # Dont like this, because here we insert points into the rawdata\\n # But it creates consisitent results in the interpolation results\\n if self.__upper[0][0] != 0: self.__upper.insert(0,(0.,0.))\\n if self.__lower[0][0] != 0: self.__lower.insert(0,(0.,0.))\\n \\n # Create points\\n if self.__interpolation_method == \\\"l\\\":\\n xpointsU = list(map(lambda x:x/float(self.__procPointsCount),range(0,self.__procPointsCount+1)))\\n xpointsL = list(map(lambda x:x/float(self.__procPointsCount),range(0,self.__procPointsCount+1)))\\n elif self.__interpolation_method == \\\"p\\\":\\n xpointsU = [x**2/float(self.__procPointsCount)**2 for x in range(self.__procPointsCount+1)]\\n xpointsL = [x**2/float(self.__procPointsCount)**2 for x in range(self.__procPointsCount+1)]\\n \\n # Calculate secants\\n uppersec = [(self.__upper[i+1][1]-self.__upper[i][1])/(self.__upper[i+1][0]-self.__upper[i][0]) for i in range(len(self.__upper)-1)]\\n lowersec = [(self.__lower[i+1][1]-self.__lower[i][1])/(self.__lower[i+1][0]-self.__lower[i][0]) for i in range(len(self.__lower)-1)]\\n \\n # Calculate tangents\\n uppertan = [(uppersec[k-1]+uppersec[k])/2 for k in range(1,len(uppersec))]\\n uppertan.insert(0,uppersec[0])\\n uppertan.append(uppersec[-1])\\n\\n lowertan = [(lowersec[k-1]+lowersec[k])/2 for k in range(1,len(lowersec))]\\n lowertan.insert(0,lowersec[0])\\n lowertan.append(lowersec[-1])\\n \\n # Hermite blending functions\\n p0 = lambda t: 2*t**3 - 3*t**2 + 1\\n m0 = lambda t: t**3 - 2*t**2 + t\\n p1 = lambda t: -2*t**3 + 3*t**2\\n m1 = lambda t: t**3 - t**2\\n \\n # Find matching points to improve accuarcy\\n matchU = [(i,j) for i in range(len(xpointsU)) for j in range(len(self.__upper)) if xpointsU[i] == self.__upper[j][0]]\\n matchL = [(i,j) for i in range(len(xpointsL)) for j in range(len(self.__lower)) if xpointsL[i] == self.__lower[j][0]]\\n \\n # Reverse match pairs to insure no index errors\\n matchU.reverse()\\n matchL.reverse()\\n\\n# print(self.__lower)\\n# print(xpointsL)\\n # Pop xpoints that dont require interpolation and append the point into the upperint list\\n for i in matchU:\\n xpointsU.pop(i[0])\\n upperint.append(self.__upper[i[1]])\\n \\n# print(matchL)\\n \\n # Same process as above but for lower airfoil\\n for i in matchL:\\n xpointsL.pop(i[0])\\n lowerint.append(self.__lower[i[1]])\\n \\n # Interpolate upper points\\n for xp in xpointsU:\\n for i in range(len(self.__upper)-1):\\n if self.__upper[i][0] < xp < self.__upper[i+1][0]:\\n h = self.__upper[i+1][0]-self.__upper[i][0]\\n t = (xp - self.__upper[i][0]) / h\\n solution = ( p0(t)*self.__upper[i][1] + h*m0(t)*uppertan[i] + p1(t)*self.__upper[i+1][1] + h*m1(t)*uppertan[i+1] )\\n upperint.append((xp,solution))\\n \\n # Interpolate lower points\\n for xp in xpointsL:\\n for i in range(len(self.__lower)-1):\\n if self.__lower[i][0] < xp < self.__lower[i+1][0]:\\n h = self.__lower[i+1][0]-self.__lower[i][0]\\n t = (xp - self.__lower[i][0]) / h\\n solution = ( p0(t)*self.__lower[i][1] + h*m0(t)*lowertan[i] + p1(t)*self.__lower[i+1][1] + h*m1(t)*lowertan[i+1] )\\n lowerint.append((xp,solution))\\n \\n # Sort the points to keep the correct sequence\\n upperint.sort(key=lambda x:x[0], reverse=True)\\n lowerint.sort(key=lambda x:x[0])\\n \\n # Do checks to insure no duplicates\\n if upperint[0][0] != 1.0: upperint.insert(0,(1.0,0.0))\\n if upperint[-1][0] != 0.0: upperint.append((0.0,0.0))\\n if lowerint[0][0] == 0.0: lowerint.pop(0)\\n if lowerint[-1][0] != 1.0: lowerint.append((1.0,0.0))\\n\\n self.__ProcPoints = upperint + lowerint\",\n \"def interpolate_ephemeris(self):\\n #Compute the offsets into the lookup tables\\n startemiss, stopemiss = self.get_emissivity_offsets()\\n hourslice, starttime = self.get_hour_offsets()\\n latslice = self.get_lat_offsets()\\n \\n #Compute the start and stop dates\\n startdata = self.extract_season(self.startseason,startemiss,\\n hourslice, latslice)\\n stopdata = self.extract_season(self.stopseason,startemiss,\\n hourslice, latslice)\\n # Interpolate Season\\n seasons = [self.startseason, self.stopseason]\\n season_f = compute_interpolation_function(seasons, [startdata, stopdata], 'linear')\\n data = season_f(self.season)\\n #Interpolate time\\n self.data = self.interpolatehour(hourslice, starttime, data)\",\n \"def bil_interpolate(p, ls, dx, dy):\\n m = p.shape[0]\\n max_i = ls.shape[0]\\n max_j = ls.shape[1]\\n\\n z = np.zeros(p.shape[0])\\n code = \\\\\\n \\\"\\\"\\\"\\n #line 38 \\\"distmesh2d.py\\\"\\n int i=0, j=0;\\n double x=0.0, y=0.0;\\n\\n // Loop through all coordinates\\n for(int k=0; k<m; k++) {\\n // Get grid indices\\n i = int( P2(k,0)/dx-0.5 );\\n j = int( P2(k,1)/dy-0.5 );\\n\\n // Probably not helpful.\\n // Just take care that (x,y) lie inside the grid ...\\n if(i<0 || i>=max_i || j<0 || j>=max_j) {\\n Z1(k) = 100000.0;\\n continue;\\n }\\n\\n // Handle corner case when coordinates lie on border\\n if(i==max_i-1) i-=1;\\n if(j==max_j-1) j-=1;\\n\\n // Local coordinates scaled to [0,1]\\n // Maybe this would rather be fmod()?\\n x = (P2(k,0)-i*dx)/dx;\\n y = (P2(k,1)-j*dy)/dy;\\n\\n // Interpolate ls values\\n double tmp;\\n Z1(k) = LS2(i,j)*(1.0-x)*(1.0-y)\\n +LS2(i+1,j)*x*(1.0-y)\\n +LS2(i,j+1)*(1-x)*y\\n +LS2(i+1,j+1)*x*y;\\n }\\n \\\"\\\"\\\"\\n weave.inline(code, \\n ['p', 'ls', 'dx', 'dy', 'z', 'm', 'max_i', 'max_j']) \\n return z\",\n \"def test_1d_constant_interpolation_basic(self):\\n\\n # Define pixel centers along each direction\\n x = numpy.array([1.0, 2.0, 4.0])\\n\\n # Define ny by nx array with corresponding values\\n A = numpy.zeros((len(x)))\\n\\n # Define values for each x, y pair as a linear function\\n for i in range(len(x)):\\n A[i] = linear_function(x[i], 0)\\n\\n # Then test that interpolated points are always assigned value of\\n # closest neighbour\\n xis = numpy.linspace(x[0], x[-1], 10)\\n points = xis\\n\\n vals = interpolate1d(x, A, points, mode='constant')\\n\\n # Find upper neighbours for each interpolation point\\n xi = points[:]\\n idx = numpy.searchsorted(x, xi, side='left')\\n\\n # Get the neighbours for each interpolation point\\n x0 = x[idx - 1]\\n x1 = x[idx]\\n\\n z0 = A[idx - 1]\\n z1 = A[idx]\\n\\n # Location coefficients\\n alpha = (xi - x0) / (x1 - x0)\\n\\n refs = numpy.zeros(len(vals))\\n for i in range(len(refs)):\\n if alpha[i] < 0.5:\\n refs[i] = z0[i]\\n\\n if alpha[i] >= 0.5:\\n refs[i] = z1[i]\\n\\n assert numpy.allclose(vals, refs, rtol=1e-12, atol=1e-12)\",\n \"def interp_1d(z, x, fx, dfx=None, y=None, fpy=None, dfpy=None, \\\\\\n compute_dfz=False):\\n # verifying and handling arguments\\n assert z.ndim == x.ndim == fx.ndim == 1 and x.size == fx.size\\n if dfx is None:\\n dfx = zeros(x.shape)\\n else:\\n assert dfx.shape == x.shape\\n if y is None:\\n assert fpy is None and dfpy is None\\n y = zeros(0); fpy = zeros(0); dfpy = zeros(0)\\n else:\\n assert fpy is not None and fpy.shape == y.shape\\n if dfpy is None:\\n dfpy = zeros(y.shape)\\n else:\\n assert dfpy.shape == y.shape\\n n = x.size; m = y.size\\n # calculate beta and gamma\\n beta = calc_beta(fx, dfx)\\n gamma = calc_gamma_1d(x, fx, dfx, y, fpy, dfpy)\\n # interpolation for each z[i]\\n t0 = time.time()\\n fz, dz = [], []\\n for zi in z:\\n a, b, er2 = interp_1d_coef(zi, x, dfx, y, dfpy, beta, gamma)\\n fz.append(dot(a, fx) + dot(b, fpy))\\n dz.append(sqrt(er2))\\n print ' time: ', time.time() - t0\\n if compute_dfz:\\n return numpy.array(fz), numpy.array(dz)\\n else:\\n return numpy.array(fz)\",\n \"def nearest_neighbor_dted_interp(lon_lat, dted_directory, dted_extension):\\n\\n # Set these to NAN for the moment\\n heights = np.empty((lon_lat.shape[0], 1))\\n heights[:] = np.NAN\\n\\n # First find the corresponding dted files\\n dted_files = find_containing_dted_file(lon_lat, dted_directory,\\n dted_extension)\\n\\n # Go through each file\\n for tile in set(dted_files):\\n\\n # Open DTED, get the image, and affine transform\\n dted = gdal.Open(tile)\\n gt_dted = dted.GetGeoTransform()\\n band = dted.GetRasterBand(1)\\n img = band.ReadAsArray(0, 0, dted.RasterXSize, dted.RasterYSize)\\n\\n # Get raster space idx for the points in this tile\\n idx = np.nonzero(np.array(dted_files) == tile)[0]\\n d_pix = pix_from_geo(lon_lat[idx, :], gt_dted)\\n\\n # Grab nearest neighbor\\n d_pix = np.round(d_pix).astype('int')\\n\\n # Index into image to grab heights, remember that because the\\n # coordinate systems between raster space and ndarray are rotated we\\n # need to transpose x,y\\n heights[idx] = img[d_pix[:, 1], d_pix[:, 0]].reshape((idx.shape[0], 1))\\n\\n # Put heights into msl\\n lon_lat_msl = np.hstack((lon_lat, heights))\\n return lon_lat_msl\",\n \"def altitude(p):\\r\\n \\r\\n R = 290 #specific gas constant \\r\\n T = 93.65 #surface temperature K from A.Coustenis book\\r\\n g = 1.354 #surface gravity from A.Coustenis book\\r\\n p0 = 1467 #surface pressure in hPa 6.1 for mars\\r\\n \\r\\n z = np.empty_like(p)\\r\\n \\r\\n for i in range(p.shape[0]):\\r\\n z[i] = (-1)*(R*T/g)*np.log((p[i])/p0)/(10**3)\\r\\n \\r\\n # Make into an xarray DataArray\\r\\n z_xr = xr.DataArray(z, coords=[z], dims=['pfull'])\\r\\n z_xr.attrs['units'] = 'km'\\r\\n \\r\\n #below is the inverse of the calculation\\r\\n #p[i] = p0*np.exp((-1)*z[i]*(10**3)/((R*T/g)))\\r\\n \\r\\n return z_xr\",\n \"def interpolate_na(\\n self, method: str = \\\"nearest\\\", extrapolate: bool = False, **kwargs\\n ):\\n dim0 = self.dim0\\n kwargs.update(dict(method=method, extrapolate=extrapolate))\\n if dim0:\\n interp_data = np.empty(self._obj.shape, dtype=self._obj.dtype)\\n for i, (_, sub_xds) in enumerate(self._obj.groupby(dim0)):\\n interp_data[i, ...] = self._interpolate_na(\\n sub_xds.load().data, **kwargs\\n )\\n else:\\n interp_data = self._interpolate_na(self._obj.load().data, **kwargs)\\n interp_array = xr.DataArray(\\n name=self._obj.name,\\n dims=self._obj.dims,\\n coords=self._obj.coords,\\n data=interp_data,\\n attrs=self._obj.attrs,\\n )\\n interp_array.raster.set_nodata(self.nodata)\\n interp_array.raster.set_crs(self.crs)\\n return interp_array\",\n \"def altitude_to_pressure(alt):\\n for i in range(len(_heights)-1,0,-1):\\n h0 = _heights[i]\\n T0 = _basetemps[i]\\n if alt > h0:\\n if _isotherm[i]:\\n rP = math.exp(-_g / _R / T0 * (alt - h0))\\n else:\\n l0 = _lapsert[i]\\n rP = math.pow(1 + (alt - h0) * l0 / T0, -_g / _R / l0)\\n return _basepress[i] * rP\\n l0 = _lapsert[0]\\n return _stdpres * math.pow(1 + alt * l0 / _stdtemp, -_g / _R / l0)\",\n \"def _interpolate(self, kps1: List[List[kp]], kps2: List[List[kp]]) -> np.ndarray:\\n interpolated_kps = []\\n for i in range(len(kps1)):\\n # If one of the two points is empty -> Not interpolate\\n if len(kps1[i]) != 0 and len(kps2[i]) != 0:\\n interpolated_coords = np.linspace(np.array(kps1[i]), np.array(kps2[i]), num=3).tolist()\\n interpolated_kps.append(interpolated_coords[1])\\n else:\\n interpolated_kps.append([None, None, None])\\n return np.array(interpolated_kps)\",\n \"def interpolate(self, *point, **kwargs):\\n\\n # Assume alpha enhancement of 0.4 if not given.\\n if len(point) == 3:\\n point = [] + list(point) + [0.4]\\n warnings.warn(\\n \\\"Assuming [alpha/Fe] = 0.4 composition unless \\\"\\n \\\"otherwise specified.\\\", StandardCompositionAssumed)\\n elif len(point) == 4:\\n point = list(point)\\n warnings.warn(\\n \\\"Fourth stellar param is [alpha/Fe] = {}\\\".format(point[3]))\\n\\n return super(self.__class__, self).interpolate(*point, **kwargs)\",\n \"def interpolate(self):\\n print(\\\"Interpolating points...\\\")\\n interpolated_points = set()\\n if os.cpu_count():\\n processes = os.cpu_count()\\n print(f\\\"Running on all {processes} cores.\\\")\\n else:\\n processes = 1\\n length = len(self.main_cluster)\\n delta = math.ceil(length / processes)\\n manager = Manager()\\n result_map = manager.dict()\\n jobs = []\\n for index in range(processes):\\n start = index * delta\\n stop = (index + 1) * delta\\n if stop > length:\\n stop = length\\n p = Process(target=worker, args=(start, stop,\\n result_map, index,\\n self.distances,\\n self.interpolation_threshold,\\n self.main_cluster,\\n self.color_lookup_table_points))\\n jobs.append(p)\\n p.start()\\n\\n for proc in jobs:\\n proc.join()\\n\\n for index in result_map.keys():\\n print(index)\\n interpolated_points.update(result_map[index])\\n\\n main_points = [self.get_value_tuple(index) for index in self.main_cluster]\\n interpolated_points.update(main_points)\\n\\n print(\\\"Finished interpolation!\\\")\\n\\n self.interpolated_points = list(interpolated_points)\",\n \"def interpolate(x1, x2, u, N):\\n \\n # finding the magnitude of each component\\n a1 = np.matmul(x1, u)\\n a2 = np.matmul(x2, u)\\n\\n ims = [np.matmul(u, t * a1 + (1 - t) * a2) \\\\\\n for t in np.linspace(0, 1, N)]\\n\\n return np.stack(ims, 0)\",\n \"def trilinear_interpolate(point, atom_index, emap, emap_max, emap_min):\\n point1 = []\\n point0 = []\\n dif = []\\n for p in point:\\n if round(p) == p:\\n p += 1E-10\\n point0.append(math.floor(p))\\n point1.append(math.ceil(p))\\n dif.append((p - point0[-1]) / (point1[-1] - point0[-1]))\\n\\n i000 = energy_map_index(point0, emap_max, emap_min) # (0, 0, 0)\\n i100 = energy_map_index([point1[0], point0[1], point0[2]], emap_max, emap_min) # (1, 0, 0)\\n i001 = energy_map_index([point0[0], point0[1], point1[2]], emap_max, emap_min) # (0, 0, 1)\\n i101 = energy_map_index([point1[0], point0[1], point1[2]], emap_max, emap_min) # (1, 0, 1)\\n i010 = energy_map_index([point0[0], point1[1], point0[2]], emap_max, emap_min) # (0, 1, 0)\\n i110 = energy_map_index([point1[0], point1[1], point0[2]], emap_max, emap_min) # (1, 1, 0)\\n i011 = energy_map_index([point0[0], point1[1], point1[2]], emap_max, emap_min) # (0, 1, 1)\\n i111 = energy_map_index(point1, emap_max, emap_min) # (1, 1, 1)\\n\\n c00 = emap[i000][atom_index] * (1 - dif[0]) + emap[i100][atom_index] * dif[0]\\n c01 = emap[i001][atom_index] * (1 - dif[0]) + emap[i101][atom_index] * dif[0]\\n c10 = emap[i010][atom_index] * (1 - dif[0]) + emap[i110][atom_index] * dif[0]\\n c11 = emap[i011][atom_index] * (1 - dif[0]) + emap[i111][atom_index] * dif[0]\\n\\n c0 = c00 * (1 - dif[1]) + c10 * dif[1]\\n c1 = c01 * (1 - dif[1]) + c11 * dif[1]\\n\\n c = c0 * (1 - dif[2]) + c1 * dif[2]\\n\\n return c\",\n \"def interpolate(traj: cs.DM, T: float, **interp_args) -> interp1d:\\n assert isinstance(\\n traj, cs.DM\\n ), f\\\"traj is incorrect type, got '{type(traj)}', expected casadi.DM'\\\"\\n t = np.linspace(0, T, traj.shape[1])\\n return interp1d(t, traj.toarray(), **interp_args)\",\n \"def interpolate(self):\\n interp = (\\n self._get_ticks() - self._last_update\\n ) / self._tick_step / self.dilation\\n if interp > 1.0:\\n interp = 1.0\\n return interp\",\n \"def interp_zt(array, heights, goal):\\n\\n print('Coffee time :-)')\\n nt = array.shape[0]\\n out = np.empty((nt,goal.size), dtype=np.float)\\n for i in range(nt):\\n out[i,:] = np.interp(goal, heights[i,:], array[i,:])\\n return out\",\n \"def interpolation(self, experiments):\\n # get all TAD lengths and multiply it by bin size of the experiment\\n norm_tads = []\\n for tad in experiments:\\n for brk in self.experiments[tad]['tads'].values():\\n if not brk['brk']:\\n continue\\n norm_tads.append((brk['end'] - brk['start']) * self.resolution)\\n x = [0.0]\\n y = [0.0]\\n max_d = max(norm_tads)\\n # we ask here for a mean number of 20 values per bin \\n bin_s = int(max_d / (float(len(norm_tads)) / 20))\\n for b in range(0, int(max_d) + bin_s, bin_s):\\n x.append(len([i for i in norm_tads if b < i <= b + bin_s]) + x[-1])\\n y.append(b + float(bin_s))\\n x = [float(v) / max(x) for v in x]\\n ## to see the distribution and its interpolation\\n #distr = interp1d(x, y)\\n #from matplotlib import pyplot as plt\\n #plt.plot([distr(float(i)/1000) for i in xrange(1000)],\\n # [float(i)/1000 for i in xrange(1000)])\\n #plt.hist(norm_tads, normed=True, bins=20, cumulative=True)\\n #plt.show()\\n return interp1d(x, y)\",\n \"def interpolate_linear(self, known_coords, known_values, interp_coords, groupname):\\n\\t\\t#First need to reshape known_coords and known_values\\n\\t\\tn_params = self.signal[groupname]['dimension']\\n\\t\\tknown_coords = np.reshape( known_coords, (-1,n_params) )\\n\\t\\tknown_values = np.reshape( known_values, (-1) )\\t\\t\\n\\t\\treturn griddata(known_coords, known_values, interp_coords, method='linear')\",\n \"def interpolate(self, known_coords, known_values, interp_coords, groupname):\\n\\t\\t#Find which interpolation method is desired\\n\\t\\tif self.interp_method == \\\"Grid Linear\\\":\\n\\t\\t\\tinterp_values = self.grid_interpolation_linear(known_coords=known_coords, known_values=known_values, interp_coords=interp_coords, groupname=groupname)\\n\\t\\telif self.interp_method == \\\"Linear\\\":\\n\\t\\t\\tfrom scipy.interpolate import griddata\\n\\t\\t\\tinterp_values = self.interpolate_linear(known_coords=known_coords, known_values=known_values, interp_coords=interp_coords, groupname=groupname)\\n\\t\\telse:\\n\\t\\t\\t#Should raise error\\n\\t\\t\\tpass\\n\\t\\t\\n\\t\\treturn interp_values\",\n \"def test_linear_interpolation_basic(self):\\n\\n # Define pixel centers along each direction\\n x = [1.0, 2.0, 4.0]\\n y = [5.0, 9.0]\\n\\n # Define ny by nx array with corresponding values\\n A = numpy.zeros((len(x), len(y)))\\n\\n # Define values for each x, y pair as a linear function\\n for i in range(len(x)):\\n for j in range(len(y)):\\n A[i, j] = linear_function(x[i], y[j])\\n\\n # Test first that original points are reproduced correctly\\n for i, xi in enumerate(x):\\n for j, eta in enumerate(y):\\n val = interpolate2d(x, y, A, [(xi, eta)], mode='linear')[0]\\n ref = linear_function(xi, eta)\\n assert numpy.allclose(val, ref, rtol=1e-12, atol=1e-12)\\n\\n # Then test that genuinly interpolated points are correct\\n xis = numpy.linspace(x[0], x[-1], 10)\\n etas = numpy.linspace(y[0], y[-1], 10)\\n points = combine_coordinates(xis, etas)\\n\\n vals = interpolate2d(x, y, A, points, mode='linear')\\n refs = linear_function(points[:, 0], points[:, 1])\\n assert numpy.allclose(vals, refs, rtol=1e-12, atol=1e-12)\",\n \"def get_air_density(self, altitude):\\n\\n altitude /= 1000 # convert to kilometers\\n\\n return self.get_air_density_from_model(altitude)\",\n \"def extrapolate(self, known_coords, known_values, extrap_coords, groupname):\\n\\t\\t#Find which extrapolation method is desired\\n\\t\\tif self.extrap_method == \\\"Grid Nearest\\\":\\n\\t\\t\\textrap_values = self.grid_interpolation_linear(known_coords=known_coords, known_values=known_values, interp_coords=extrap_coords, groupname=groupname)\\n\\t\\telif self.extrap_method == \\\"Nearest\\\":\\n\\t\\t\\textrap_values = self.extrapolate_nearest(known_coords=known_coords, known_values=known_values, extrap_coords=extrap_coords, groupname=groupname)\\n\\t\\telse:\\n\\t\\t\\t#Should raise error\\n\\t\\t\\tpass\\n\\t\\t\\n\\t\\treturn extrap_values\",\n \"def extrap1d(x,y,kind=\\\"linear\\\"):\\n interpolator = interp1d(x,y,kind=kind)\\n xs = interpolator.x\\n ys = interpolator.y\\n def pointwise(x):\\n if x < xs[0]: return ys[0]+(x-xs[0])*(ys[1]-ys[0])/(xs[1]-xs[0])\\n elif x > xs[-1]: return ys[-1]+(x-xs[-1])*(ys[-1]-ys[-2])/(xs[-1]-xs[-2])\\n else: return interpolator(x)\\n def ufunclike(xs):\\n return array(list(map(pointwise, array(xs))))\\n return ufunclike\",\n \"def set_cruise_altitudes(altitudes, cruise_indicies):\\n if cruise_indicies:\\n for index in range(0, len(cruise_indicies), 2):\\n start = cruise_indicies[index]\\n stop = cruise_indicies[index + 1]\\n if start < stop:\\n cruise_altitude = closest_cruising_altitude(altitudes[start])\\n altitudes[start] = cruise_altitude\\n altitudes[stop] = cruise_altitude\\n\\n return altitudes\",\n \"def haversine_distance_ignore_altitude(loc1_lat, loc1_lon, loc2_lat, loc2_lon):\\n R = 6372797.560856 # radius of the earth in meters\\n\\n lat_arc = math.radians(loc1_lat - loc2_lat)\\n lon_arc = math.radians(loc1_lon - loc2_lon)\\n\\n lat_h = math.sin(lat_arc * 0.5)\\n lat_h = lat_h * lat_h\\n\\n lon_h = math.sin(lon_arc * 0.5)\\n lon_h = lon_h * lon_h\\n\\n tmp = math.cos(math.radians(loc1_lat)) * math.cos(math.radians(loc2_lat))\\n rad = 2.0 * math.asin(math.sqrt(lat_h + tmp * lon_h))\\n\\n return rad * R\",\n \"def myChordFunctionAirliner(Epsilon):\\n ChordLengths = np.array([0.5, 0.3792, 0.2867, 0.232, 0.1763, 0.1393, 0.1155,\\n 0.093, 0.0713, 0.055, 0.007])\\n\\n EpsArray = np.linspace(0, 1, 11)\\n return np.interp(Epsilon, EpsArray, ChordLengths)\",\n \"def test_isentropic_pressure_addition_args_interp():\\n lev = [100000., 95000., 90000., 85000.] * units.Pa\\n tmp = np.ones((4, 5, 5))\\n tmp[0, :] = 296.\\n tmp[1, :] = 292.\\n tmp[2, :] = 290.\\n tmp[3, :] = 288.\\n rh = np.ones((4, 5, 5))\\n rh[0, :] = 100.\\n rh[1, :] = 80.\\n rh[2, :] = 40.\\n rh[3, :] = 20.\\n relh = rh * units.percent\\n tmpk = tmp * units.kelvin\\n isentlev = [296., 297.] * units.kelvin\\n isentprs = isentropic_interpolation(isentlev, lev, tmpk, relh)\\n truerh = 69.197 * units.percent\\n assert_almost_equal(isentprs[1][1], truerh, 3)\",\n \"def linear_interpolation(self, pt1, pt2, unknown):\\n\\n #Write your code for linear interpolation here\\n pt1,intensity1=pt1\\n pt2,intensity2=pt2\\n newPoint=unknown\\n intensity_diff=pt2-pt1\\n if(intensity_diff<=0):\\n intensity_diff=1\\n\\n a1=pt2-newPoint\\n b1=a1/intensity_diff\\n x=intensity1*b1\\n a2=newPoint - pt1\\n b2=a2/intensity_diff\\n y=intensity2*b2\\n new_intensity=x+y\\n\\n return new_intensity\",\n \"def interpolate(self, var, time, lat, lon):\\n\\n # Get the nearest four points in space\\n # Check to see if lat/lons are 2d or 1d\\n if len(self['lat'].shape) == 2:\\n closey, closex, distances = self.nearest_points(lat, lon, npt=4)\\n # Distances in km\\n# distances = np.array([self.haversine(\\n# (self['lat'][y,x].values, self['lon'][y,x].values),\\n# (lat, lon)) for y,x in \\n# zip(list(closey), list(closex))])\\n else:\\n closen = self.nearest_points(lat, lon, npt=4)\\n closey = closen\\n closex = closen\\n # Distances in km\\n distances = np.array([self.haversine(\\n (self['lat'][n].values, self['lon'][n].values),\\n (lat, lon)) for n in list(closen)])\\n # Check for exact match (within some tolerance)\\n spaceweights = np.zeros(distances.shape)\\n if (distances < 1.0).sum() > 0:\\n spaceweights[distances.argmin()] = 1\\n else:\\n # Here, inverse distance weighting (for simplicity)\\n spaceweights = 1.0 / distances\\n spaceweights /= spaceweights.sum()\\n # Get weights in time\\n #time64 = np.datetime64(time)\\n #all the valid times in the ensemble\\n valids = self['validtime'].values\\n timeweights = np.zeros(valids.shape)\\n # Check if we are outside the valid time range\\n if (time < valids[0]) or (time > valids[-1]):\\n print(\\\"Interpolation is outside of time range in state!\\\")\\n return None\\n # Find where we are in this list\\n #index after the time of the observation\\n lastdex = (valids >= time).argmax()\\n # If we match a particular time value, then\\n # this is just an identity\\n if valids[lastdex] == time:\\n # Just make a one at this time\\n timeweights[lastdex] = 1\\n else:\\n # Linear interpolation\\n #often going to be 6 hours, subtracts datetime objects I think\\n diff = (valids[lastdex] - valids[lastdex-1])\\n #print(valids[lastdex], valids[lastdex-1], diff)\\n #often going to be 21600 seconds\\n totsec = diff.seconds\\n #totsec = np.abs(diff / np.timedelta64(1, 's'))\\n #ST\\n #calculate time difference between time after and time of observation\\n #the abs will make this positive definite, which is okay since\\n #the difference will always be negative\\n thisdiff = abs(time - valids[lastdex])\\n #thissec = np.abs(thisdiff / np.timedelta64(1,'s'))\\n thissec = thisdiff.seconds\\n # Put in appropriate weights\\n #ST switched the -1 between the two lines to match up with the positive-\\n #definite thisdiff\\n timeweights[lastdex-1] = float(thissec) / totsec\\n timeweights[lastdex] = 1.0 - (float(thissec)/totsec)\\n # Now that we have the weights, do the interpolation\\n #ST an ntimes x 4 x nens array\\n interp = self.variables[var].values[:,closey,closex,:]\\n # Do a dot product with the time weights\\n # And with the space weights\\n if len(interp.shape) == 3:\\n interp = (timeweights[:,None,None] * interp).sum(axis=0)\\n else:\\n interp = (timeweights[:,None,None,None] * interp).sum(axis=0)\\n \\n if len(interp.shape) == 3:\\n #ST Changed 2nd : to None\\n interp = (spaceweights[:,None,None] * interp).sum(axis=1)\\n else:\\n interp = (spaceweights[:,None] * interp).sum(axis=0)\\n # Return estimate from all ensemble members\\n return interp\",\n \"def _interpolate_table(self, key, leap_second_correction=False, derivative_order=0):\\n days = np.unique(self.time.utc.mjd_int)\\n offsets = range(-math.ceil(self.window / 2) + 1, math.floor(self.window / 2) + 1)\\n\\n if leap_second_correction:\\n leap = {\\n d: np.array(\\n [self.data[d + o].get(\\\"leap_offset\\\", np.nan) - self.data[d][\\\"leap_offset\\\"] for o in offsets]\\n )\\n for d in days\\n }\\n for lo in leap.values():\\n lo[np.isnan(lo)] = 0\\n else:\\n leap = {d: 0 for d in days}\\n\\n table_values = {d: np.array([self.data[d + o][key] for o in offsets]) + leap[d] for d in days}\\n interpolators = {d: interpolate.lagrange(offsets, v) for d, v in table_values.items()}\\n for poly in interpolators.values():\\n poly.c[np.abs(poly.c) < 1e-15] = 0 # Avoid numerical instabilities for constant values\\n\\n if derivative_order:\\n interp_values = {\\n d: np.polyder(ip, derivative_order)(self.time.utc.mjd_frac) for d, ip in interpolators.items()\\n }\\n else:\\n interp_values = {d: ip(self.time.utc.mjd_frac) for d, ip in interpolators.items()}\\n\\n if self.time.isscalar:\\n return interp_values[self.time.utc.mjd_int]\\n\\n values = np.empty(self.time.size)\\n for day in days:\\n idx = self.time.utc.mjd_int == day\\n values[idx] = interp_values[day][idx]\\n\\n return values\",\n \"def topographic_altitude(self, lat_d, lon_d):\\n return self.altitude(lat_d, lon_d)\",\n \"def topographic_altitude(self, lat_d, lon_d):\\n return self.altitude(lat_d, lon_d)\",\n \"def __interp__(T0, g0, T, g, dT_max=0.1, eps=1e-6):\\r\\n\\r\\n kappa = 0.1\\r\\n idx = np.arange(len(g))\\r\\n deltag = g - g0\\r\\n deltaT = T - T0\\r\\n dist = kappa * abs(deltag) + abs(deltaT)\\r\\n if dist.min() == 0:\\r\\n return (dist.argmin(), -1, -1, -1), (1.0, 0.0, 0.0, 0.0)\\r\\n\\r\\n # Looking for i_{1..4}\\r\\n ind_dT = deltaT >= 0\\r\\n ind_dg = deltag >= 0\\r\\n # i1\\r\\n ind = ind_dT & ind_dg\\r\\n if True in ind:\\r\\n i1 = idx[ind][dist[ind].argmin()]\\r\\n else:\\r\\n i1 = -1\\r\\n\\r\\n # i2\\r\\n ind = ind_dT & ~ind_dg\\r\\n if True in ind:\\r\\n i2 = idx[ind][dist[ind].argmin()]\\r\\n else:\\r\\n i2 = -1\\r\\n\\r\\n # i3\\r\\n ind = ~ind_dT & ind_dg\\r\\n if True in ind:\\r\\n i3 = idx[ind][dist[ind].argmin()]\\r\\n else:\\r\\n i3 = -1\\r\\n\\r\\n # i4\\r\\n ind = ~ind_dT & ~ind_dg\\r\\n if True in ind:\\r\\n i4 = idx[ind][dist[ind].argmin()]\\r\\n else:\\r\\n i4 = -1\\r\\n\\r\\n # checking integrity\\r\\n if (i1 < 0) & (i2 < 0) & (i3 < 0) & (i4 < 0):\\r\\n raise ValueError(\\\"Interp. Error, could not find appropriate knots\\\")\\r\\n\\r\\n T1 = T[i1]\\r\\n T2 = T[i2]\\r\\n T3 = T[i3]\\r\\n T4 = T[i4]\\r\\n g1 = g[i1]\\r\\n g2 = g[i2]\\r\\n g3 = g[i3]\\r\\n g4 = g[i4]\\r\\n\\r\\n # If, T2 (resp. T1) is too far from T compared to T1\\r\\n # (resp. T2), i2 (resp. i1) is not used.\\r\\n # The same for i3 and i4.\\r\\n if (i1 > 0) & (i2 > 0):\\r\\n if T1 < T2 - dT_max:\\r\\n i2 = -1\\r\\n elif T2 < T1 - dT_max:\\r\\n i1 = -1\\r\\n\\r\\n if (i3 > 0) & (i4 > 0):\\r\\n if T3 > T4 + dT_max:\\r\\n i4 = -1\\r\\n elif T4 > T3 + dT_max:\\r\\n i3 = -1\\r\\n\\r\\n if (i1 < 0) & (i2 < 0) & (i3 < 0) & (i4 < 0):\\r\\n raise ValueError(\\\"Interp. Error, could not find appropriate knots\\\")\\r\\n\\r\\n # Interpolation in the (T, g) plane between the used points\\r\\n # (at least 1, at most 4).\\r\\n # Code \\\"0110\\\" means that i1 = i4 = 0, i2 /=0 and i3 /= 0.\\r\\n #\\r\\n # Note: preference is always given to the temperature over\\r\\n # the gravity when needed.\\r\\n if i1 < 0:\\r\\n if i2 < 0:\\r\\n if i3 < 0:\\r\\n if i4 < 0:\\r\\n # # 0000\\r\\n raise ValueError(\\\"Error\\\") # should not be possible\\r\\n else: # 0001\\r\\n alpha1 = 0.0\\r\\n alpha2 = 0.0\\r\\n alpha3 = 0.0\\r\\n alpha4 = 1.0\\r\\n # endif\\r\\n elif i4 < 0: # 0010\\r\\n alpha1 = 0.0\\r\\n alpha2 = 0.0\\r\\n alpha3 = 1.0\\r\\n alpha4 = 0.0\\r\\n else: # 0011\\r\\n alpha1 = 0.0\\r\\n alpha2 = 0.0\\r\\n if abs(T3 - T4) < eps:\\r\\n if g3 == g4:\\r\\n alpha3 = 0.5\\r\\n else:\\r\\n alpha3 = (g0 - g4) / (g3 - g4)\\r\\n # endif\\r\\n alpha4 = 1.0 - alpha3\\r\\n else:\\r\\n if T3 > T4:\\r\\n alpha3 = 1.0\\r\\n alpha4 = 0.0\\r\\n i4 = -1\\r\\n else:\\r\\n alpha3 = 0.0\\r\\n i3 = -1\\r\\n alpha4 = 1.0\\r\\n # endif\\r\\n # endif\\r\\n # endif\\r\\n elif i3 < 0:\\r\\n if i4 < 0:\\r\\n # # 0100\\r\\n alpha1 = 0.0\\r\\n alpha2 = 1.0\\r\\n alpha3 = 0.0\\r\\n alpha4 = 0.0\\r\\n else: # 0101\\r\\n alpha1 = 0.0\\r\\n if T2 == T4:\\r\\n alpha2 = 0.5\\r\\n else:\\r\\n alpha2 = (T0 - T4) / (T2 - T4)\\r\\n # endif\\r\\n alpha3 = 0.0\\r\\n alpha4 = 1.0 - alpha2\\r\\n # endif\\r\\n elif i4 < 0: # 0110\\r\\n alpha1 = 0.0\\r\\n if T2 == T3:\\r\\n alpha2 = 0.5\\r\\n else:\\r\\n alpha2 = (T0 - T3) / (T2 - T3)\\r\\n # endif\\r\\n alpha3 = 1.0 - alpha2\\r\\n alpha4 = 0.0\\r\\n else: # 0111\\r\\n # Assume that (T, g) is within the triangle i\\r\\n # formed by the three points.\\r\\n\\r\\n mat0 = np.asarray([[T2, T3, T4], [g2, g3, g4], [1.0, 1.0, 1.0]])\\r\\n mat2 = np.asarray([[T0, T3, T4], [g0, g3, g4], [1.0, 1.0, 1.0]])\\r\\n mat3 = np.asarray([[T2, T0, T4], [g2, g0, g4], [1.0, 1.0, 1.0]])\\r\\n mat4 = np.asarray([[T2, T3, T0], [g2, g3, g0], [1.0, 1.0, 1.0]])\\r\\n det0 = __det3x3__(mat0.ravel())\\r\\n det2 = __det3x3__(mat2.ravel())\\r\\n det3 = __det3x3__(mat3.ravel())\\r\\n det4 = __det3x3__(mat4.ravel())\\r\\n alpha1 = 0.0\\r\\n alpha2 = det2 / det0\\r\\n alpha3 = det3 / det0\\r\\n alpha4 = det4 / det0\\r\\n\\r\\n # If (T, g) is outside the triangle formed\\r\\n # by the three used points use only two points.\\r\\n if (\\r\\n (alpha2 < 0.0)\\r\\n | (alpha2 > 1.0)\\r\\n | (alpha3 < 0.0)\\r\\n | (alpha3 > 1.0)\\r\\n | (alpha4 < 0.0)\\r\\n | (alpha4 > 1.0)\\r\\n ):\\r\\n alpha1 = 0.0\\r\\n if T2 == T3:\\r\\n alpha2 = 0.5\\r\\n else:\\r\\n alpha2 = (T0 - T3) / (T2 - T3)\\r\\n # endif\\r\\n alpha3 = 1.0 - alpha2\\r\\n alpha4 = 0.0\\r\\n i4 = -1\\r\\n # endif\\r\\n # endif\\r\\n elif i2 < 0:\\r\\n if i3 < 0:\\r\\n if i4 < 0:\\r\\n # # 1000\\r\\n alpha1 = 1.0\\r\\n alpha2 = 0.0\\r\\n alpha3 = 0.0\\r\\n alpha4 = 0.0\\r\\n else: # 1001\\r\\n if T1 == T4:\\r\\n alpha1 = 0.5\\r\\n else:\\r\\n alpha1 = (T0 - T4) / (T1 - T4)\\r\\n # endif\\r\\n alpha2 = 0.0\\r\\n alpha3 = 0.0\\r\\n alpha4 = 1.0 - alpha1\\r\\n # endif\\r\\n elif i4 < 0: # 1010\\r\\n if T1 == T3:\\r\\n alpha1 = 0.5\\r\\n else:\\r\\n alpha1 = (T0 - T3) / (T1 - T3)\\r\\n # endif\\r\\n alpha2 = 0.0\\r\\n alpha3 = 1.0 - alpha1\\r\\n alpha4 = 0.0\\r\\n else: # 1011\\r\\n # Assume that (T, g) is within the triangle formed by the three points.\\r\\n mat0 = np.asarray([[T1, T3, T4], [g1, g3, g4], [1.0, 1.0, 1.0]])\\r\\n mat1 = np.asarray([[T0, T3, T4], [g0, g3, g4], [1.0, 1.0, 1.0]])\\r\\n mat3 = np.asarray([[T1, T0, T4], [g1, g0, g4], [1.0, 1.0, 1.0]])\\r\\n mat4 = np.asarray([[T1, T3, T0], [g1, g3, g0], [1.0, 1.0, 1.0]])\\r\\n det0 = __det3x3__(mat0.ravel())\\r\\n det1 = __det3x3__(mat1.ravel())\\r\\n det3 = __det3x3__(mat3.ravel())\\r\\n det4 = __det3x3__(mat4.ravel())\\r\\n alpha1 = det1 / det0\\r\\n alpha2 = 0.0\\r\\n alpha3 = det3 / det0\\r\\n alpha4 = det4 / det0\\r\\n # If (T, g) is outside the triangle formed by the three used points, # use only two points.\\r\\n\\r\\n if (\\r\\n (alpha1 < 0.0)\\r\\n | (alpha1 > 1.0)\\r\\n | (alpha3 < 0.0)\\r\\n | (alpha3 > 1.0)\\r\\n | (alpha4 < 0.0)\\r\\n | (alpha4 > 1.0)\\r\\n ):\\r\\n if T1 == T4:\\r\\n alpha1 = 0.5\\r\\n else:\\r\\n alpha1 = (T0 - T4) / (T1 - T4)\\r\\n # endif\\r\\n alpha2 = 0.0\\r\\n alpha3 = 0.0\\r\\n i3 = -1\\r\\n alpha4 = 1.0 - alpha1\\r\\n # endif\\r\\n # endif\\r\\n elif i3 < 0:\\r\\n if i4 < 0:\\r\\n # # 1100\\r\\n if abs(T1 - T2) < eps:\\r\\n if g1 == g2:\\r\\n alpha1 = 0.5\\r\\n else:\\r\\n alpha1 = (g0 - g2) / (g1 - g2)\\r\\n # endif\\r\\n alpha2 = 1.0 - alpha1\\r\\n else:\\r\\n if T1 < T2:\\r\\n alpha1 = 1.0\\r\\n alpha2 = 0.0\\r\\n i2 = -1\\r\\n else:\\r\\n alpha1 = 0.0\\r\\n i1 = -1\\r\\n alpha2 = 1.0\\r\\n # endif\\r\\n # endif\\r\\n alpha3 = 0.0\\r\\n alpha4 = 0.0\\r\\n else: # 1101\\r\\n # Assume that (T, g) is within the triangle formed by the three points.\\r\\n mat0 = np.asarray([[T1, T2, T4], [g1, g2, g4], [1.0, 1.0, 1.0]])\\r\\n mat1 = np.asarray([[T0, T2, T4], [g0, g2, g4], [1.0, 1.0, 1.0]])\\r\\n mat2 = np.asarray([[T1, T0, T4], [g1, g0, g4], [1.0, 1.0, 1.0]])\\r\\n mat4 = np.asarray([[T1, T2, T0], [g1, g2, g0], [1.0, 1.0, 1.0]])\\r\\n det0 = __det3x3__(mat0.ravel())\\r\\n det1 = __det3x3__(mat1.ravel())\\r\\n det2 = __det3x3__(mat2.ravel())\\r\\n det4 = __det3x3__(mat4.ravel())\\r\\n alpha1 = det1 / det0\\r\\n alpha2 = det2 / det0\\r\\n alpha3 = 0.0\\r\\n alpha4 = det4 / det0\\r\\n\\r\\n # If (T, g) is outside the triangle formed by the three used points,\\r\\n # use only two points.\\r\\n if (\\r\\n (alpha1 < 0.0)\\r\\n | (alpha1 > 1.0)\\r\\n | (alpha2 < 0.0)\\r\\n | (alpha2 > 1.0)\\r\\n | (alpha4 < 0.0)\\r\\n | (alpha4 > 1.0)\\r\\n ):\\r\\n if T1 == T4:\\r\\n alpha1 = 0.5\\r\\n else:\\r\\n alpha1 = (T0 - T4) / (T1 - T4)\\r\\n # endif\\r\\n alpha2 = 0.0\\r\\n i2 = -1\\r\\n alpha3 = 0.0\\r\\n alpha4 = 1.0 - alpha1\\r\\n # endif\\r\\n # endif\\r\\n elif i4 < 0:\\r\\n # # 1110\\r\\n # Assume that (T, g) is within the triangle formed by the three points.\\r\\n mat0 = np.asarray([[T1, T2, T3], [g1, g2, g3], [1.0, 1.0, 1.0]])\\r\\n mat1 = np.asarray([[T0, T2, T3], [g0, g2, g3], [1.0, 1.0, 1.0]])\\r\\n mat2 = np.asarray([[T1, T0, T3], [g1, g0, g3], [1.0, 1.0, 1.0]])\\r\\n mat3 = np.asarray([[T1, T2, T0], [g1, g2, g0], [1.0, 1.0, 1.0]])\\r\\n det0 = __det3x3__(mat0.ravel())\\r\\n det1 = __det3x3__(mat1.ravel())\\r\\n det2 = __det3x3__(mat2.ravel())\\r\\n det3 = __det3x3__(mat3.ravel())\\r\\n alpha1 = det1 / det0\\r\\n alpha2 = det2 / det0\\r\\n alpha3 = det3 / det0\\r\\n alpha4 = 0.0\\r\\n\\r\\n # If (T, g) is outside the triangle formed by the three used points,\\r\\n # use only two points.\\r\\n if (\\r\\n (alpha1 < 0.0)\\r\\n | (alpha1 > 1.0)\\r\\n | (alpha2 < 0.0)\\r\\n | (alpha2 > 1.0)\\r\\n | (alpha3 < 0.0)\\r\\n | (alpha3 > 1.0)\\r\\n ):\\r\\n alpha1 = 0.0\\r\\n i1 = -1\\r\\n if T2 == T3:\\r\\n alpha2 = 0.5\\r\\n else:\\r\\n alpha2 = (T0 - T3) / (T2 - T3)\\r\\n # endif\\r\\n alpha3 = 1.0 - alpha2\\r\\n alpha4 = 0.0\\r\\n # endif\\r\\n # endif\\r\\n\\r\\n # All four points used.\\r\\n\\r\\n if (i3 >= 0) & (i4 >= 0) & (i1 >= 0) & (i2 >= 0):\\r\\n if T1 != T3:\\r\\n alpha = (T0 - T3) / (T1 - T3)\\r\\n else:\\r\\n alpha = 0.5\\r\\n # endif\\r\\n if T2 != T4:\\r\\n beta = (T0 - T4) / (T2 - T4)\\r\\n else:\\r\\n beta = 0.5\\r\\n # endif\\r\\n gprim = alpha * g1 + (1 - alpha) * g3\\r\\n gsec = beta * g2 + (1 - beta) * g4\\r\\n if gprim != gsec:\\r\\n gamma = (g0 - gsec) / (gprim - gsec)\\r\\n else:\\r\\n gamma = 0.5\\r\\n # endif\\r\\n alpha1 = alpha * gamma\\r\\n alpha2 = beta * (1 - gamma)\\r\\n alpha3 = (1 - alpha) * gamma\\r\\n alpha4 = (1 - beta) * (1 - gamma)\\r\\n # endif\\r\\n\\r\\n return (\\r\\n np.asarray((i1, i2, i3, i4)),\\r\\n np.asarray((alpha1, alpha2, alpha3, alpha4)),\\r\\n )\",\n \"def interpolate(self, new_times):\\n\\n # check if the times are to be grabbed from a ping_data object\\n if isinstance(new_times, ping_data):\\n new_times = new_times.ping_time\\n\\n # and interpolate\\n self.data[:] = np.interp(self.ping_time, new_times,\\n self.data, left=np.nan, right=np.nan)\\n self.ping_time = new_times.copy()\",\n \"def linear_interpolate_value_change(t0, v0, t1, v1, dt):\\n return (v1 - v0)/float(t1-t0) * dt\",\n \"def interp_1d(_x, _x_min, _x_step, _nx, _ar_f, _ord=3, _ix_per=1, _ix_ofst=0):\\r\\n if(_ord == 1):\\r\\n i0 = int(trunc((_x - _x_min)/_x_step + 1.e-09))\\r\\n if(i0 < 0):\\r\\n i0 = 0\\r\\n elif(i0 >= _nx - 1):\\r\\n i0 = _nx - 2\\r\\n i1 = i0 + 1\\r\\n f0 = _ar_f[i0*_ix_per + _ix_ofst]\\r\\n f1 = _ar_f[i1*_ix_per + _ix_ofst]\\r\\n t = (_x - (_x_min + _x_step*i0))/_x_step\\r\\n return f0 + (f1 - f0)*t\\r\\n elif(_ord == 2):\\r\\n i0 = int(round((_x - _x_min)/_x_step))\\r\\n if(i0 < 1):\\r\\n i0 = 1\\r\\n elif(i0 >= _nx - 1):\\r\\n i0 = _nx - 2\\r\\n im1 = i0 - 1\\r\\n i1 = i0 + 1\\r\\n t = (_x - (_x_min + _x_step*i0))/_x_step\\r\\n a0 = _ar_f[i0*_ix_per + _ix_ofst]\\r\\n fm1 = _ar_f[im1*_ix_per + _ix_ofst]\\r\\n f1 = _ar_f[i1*_ix_per + _ix_ofst]\\r\\n a1 = 0.5*(f1 - fm1)\\r\\n a2 = 0.5*(fm1 + f1 - 2*a0)\\r\\n return a0 + t*(a1 + t*a2)\\r\\n elif(_ord == 3):\\r\\n i0 = int(trunc((_x - _x_min)/_x_step + 1.e-09))\\r\\n if(i0 < 1):\\r\\n i0 = 1\\r\\n elif(i0 >= _nx - 2):\\r\\n i0 = _nx - 3\\r\\n im1 = i0 - 1\\r\\n i1 = i0 + 1\\r\\n i2 = i0 + 2\\r\\n t = (_x - (_x_min + _x_step*i0))/_x_step\\r\\n a0 = _ar_f[i0*_ix_per + _ix_ofst]\\r\\n fm1 = _ar_f[im1*_ix_per + _ix_ofst]\\r\\n f1 = _ar_f[i1*_ix_per + _ix_ofst]\\r\\n f2 = _ar_f[i2*_ix_per + _ix_ofst]\\r\\n a1 = -0.5*a0 + f1 - f2/6. - fm1/3.\\r\\n a2 = -a0 + 0.5*(f1 + fm1)\\r\\n a3 = 0.5*(a0 - f1) + (f2 - fm1)/6.\\r\\n return a0 + t*(a1 + t*(a2 + t*a3))\\r\\n return 0\",\n \"def interpolate(self, image):\\n return\",\n \"def get_elementary_airspace_altitude_range(db_id):\\n connection = get_geo_db_connection()\\n sector = find_sector(db_id, connection)\\n if (sector):\\n return (sector['min_altitude'], sector['max_altitude'])\\n else:\\n raise NotFoundException(db_id, \\\"Elementary sector not found.\\\")\",\n \"def interpolate ( hsl1, hsl2, amt ):\\n if isinstance( hsl1, Colz ):\\n h1 = hsl1.h\\n s1 = hsl1.s\\n l1 = hsl1.l\\n a1 = hsl1.a\\n if isinstance( hsl1, list ):\\n h1 = hsl1[0]\\n s1 = hsl1[1]\\n l1 = hsl1[2]\\n if len(hsl1) > 3:\\n a1 = hsl1[3]\\n\\n if isinstance( h1, int ):\\n h1 = h1 / 360.0\\n if isinstance( s1, int ):\\n s1 = s1 / 100.0\\n if isinstance( l1, int ):\\n l1 = l1 / 100.0\\n\\n if isinstance( hsl2, Colz ):\\n h2 = hsl2.h\\n s2 = hsl2.s\\n l2 = hsl2.l\\n a2 = hsl2.a\\n if isinstance( hsl2, list ):\\n h2 = hsl2[0]\\n s2 = hsl2[1]\\n l2 = hsl2[2]\\n if len(hsl2) > 3:\\n a2 = hsl2[3]\\n\\n if isinstance( h2, int ):\\n h2 = h2 / 360.0\\n if isinstance( s2, int ):\\n s2 = s2 / 100.0\\n if isinstance( l2, int ):\\n l2 = l2 / 100.0\\n\\n h3 = Colz.hueLerp( h1, h2, amt )\\n s3 = Colz.linearLerp( s1, s2, amt )\\n l3 = Colz.linearLerp( l1, l2, amt )\\n\\n if 'a1' in locals() and 'a2' in locals():\\n a3 = Colz.linearLerp( a1, a2, amt )\\n else:\\n a3 = 1.0\\n\\n c_result = Colz()\\n c_result.setHsla( h3, s3, l3, a3 )\\n return c_result\",\n \"def _get_age_func(self)\\t:\\n\\t\\tage_nc_Arr = self['age_nc_Arr'].value\\n\\t\\tage_lon_Vec = self['age_lon_Vec'].value\\n\\t\\tage_lat_Vec = self['age_lat_Vec'].value\\n\\t\\txx, yy = np.meshgrid(age_lon_Vec, age_lat_Vec) # xx for longitude, yy for latitude\\n\\t\\txx = xx.reshape(xx.size) #nearest\\n\\t\\tyy = yy.reshape(yy.size)\\n\\t\\tx = np.column_stack((xx,yy))\\n\\t\\ty = age_nc_Arr.reshape(age_nc_Arr.size)\\n\\t\\tself.age_func = NearestNDInterpolator(x,y,rescale=False)\\n\\t\\treturn\",\n \"def interpolate_na(self, method: str = \\\"nearest\\\", **kwargs):\\n ds_out = xr.Dataset(attrs=self._obj.attrs)\\n for var in self.vars:\\n ds_out[var] = self._obj[var].raster.interpolate_na(method=method, **kwargs)\\n return ds_out\",\n \"def _interp1(x, y, xi):\\n x_length = len(x)\\n xi_length = len(xi)\\n yi = np.zeros(xi_length)\\n k = np.zeros(xi_length, dtype=int)\\n h = x[1:] - x[:-1]\\n \\n _histc(x, xi, k)\\n\\n for i in range(xi_length):\\n s = (xi[i] - x[k[i] - 1]) / h[k[i] - 1]\\n yi[i] = y[k[i] - 1] + s * (y[k[i]] - y[k[i] - 1])\\n return yi\",\n \"def interpol(self,x,y,x1):\\n \\n N = len(x)\\n i = np.minimum(np.maximum(np.searchsorted(x,x1,side='right'),1),N-1)\\n xl = x[i-1]\\n xr = x[i]\\n yl = y[i-1]\\n yr = y[i]\\n y1 = yl + (yr-yl)/(xr-xl) * (x1-xl)\\n above = x1 > x[-1]\\n below = x1 < x[0]\\n y1 = np.where(above,y[-1] + (x1 - x[-1]) * (y[-1]-y[-2])/(x[-1]-x[-2]), y1)\\n y1 = np.where(below,y[0],y1)\\n \\n return y1, i\",\n \"def interpPoints(self, interpRad=False):\\n # print(np.shape(long_distances))\\n long_sections, long_distances, meddist = self.findLongSections()\\n \\n print('Long inter-point distances found: %i' % len(long_sections))\\n count = 0\\n for sec in long_sections:\\n print('Supposed long section %i has %i nodes' \\\\\\n % (sec, len(self.sections[sec])))\\n # set first and last points for interpolation\\n pt0, pt1 = self.sections[sec][0], self.sections[sec][-1]\\n # find number of points\\n numpts = int(long_distances[long_sections.index(sec)]/meddist)\\n Xs = np.linspace(pt0[0], pt1[0], numpts)\\n Ys = np.linspace(pt0[1], pt1[1], numpts)\\n Zs = np.linspace(pt0[2], pt1[2], numpts)\\n \\n newpts = np.dstack((Xs, Ys, Zs))\\n newpts = [newpts[0][i] for i in xrange(len(newpts[0]))]\\n self.sections[sec] = newpts\\n count = count + 1\\n rad0, rad1 = self.secRads[sec][0], self.secRads[sec][-1]\\n # print(rad0, rad1)\\n rads = np.linspace(rad0, rad1, numpts)\\n # print(rads)\\n self.secRads[sec] = rads \\n \\n long_sections, long_distances, meddist = self.findLongSections()\\n print('Long sections still remaining: %i' % len(long_sections))\\n if len(long_sections) > 0:\\n print(long_distances, meddist)\\n \\n return self\",\n \"def interpolation_array(a1, a2):\\n return (a1+a2)/2.\",\n \"def interpolate(self, a, b, t):\\n d1 = (t - a[0]).seconds\\n d2 = (b[0] - t).seconds\\n # The total time difference\\n d = float(d1 + d2)\\n point = []\\n # Need to return a (time, lat, lon, elev) point\\n point.append(t)\\n # Linear interpolation of the latitude, longitude, and elevation\\n point.append(float(a[1])*(d2/d) + float(b[1])*(d1/d))\\n point.append(float(a[2])*(d2/d) + float(b[2])*(d1/d))\\n point.append(float(a[3])*(d2/d) + float(b[3])*(d1/d))\\n if self.verbose:\\n sys.stderr.write('Interpolate:\\\\n')\\n sys.stderr.write('\\\\t%s\\\\n' % repr(a))\\n sys.stderr.write('\\\\t%s\\\\n' % repr(point))\\n sys.stderr.write('\\\\t%s\\\\n' % repr(b))\\n return point\",\n \"def altitude(self, value: int):\\n self._point.altitude = value\",\n \"def pressure_to_altitude(pres):\\n for i in range(len(_heights)-1,0,-1):\\n P0 = _basepress[i]\\n T0 = _basetemps[i]\\n if pres < P0:\\n if _isotherm[i]:\\n dh = _R * T0 / _g * math.log(P0 / pres)\\n else:\\n l0 = _lapsert[i]\\n dh = T0 / l0 * (math.pow(pres / P0, -l0 * _R / _g) - 1)\\n return _heights[i] + dh\\n l0 = _lapsert[0]\\n return _stdtemp / l0 * (math.pow(pres / _stdpres, -l0 * _R / _g) - 1)\",\n \"def interpolate_linear(self, transect):\\n\\n u = np.copy(self.u_mps)\\n v = np.copy(self.v_mps)\\n\\n valid = np.isnan(u) == False\\n\\n # Check for valid data\\n if sum(valid) > 1 and sum(self.valid_data[0, :]) > 1:\\n\\n # Compute ens_time\\n ens_time = np.nancumsum(transect.date_time.ens_duration_sec)\\n\\n # Apply linear interpolation\\n self.u_processed_mps = np.interp(x=ens_time,\\n xp=ens_time[self.valid_data[0, :]],\\n fp=u[self.valid_data[0, :]],\\n left=np.nan,\\n right=np.nan)\\n # Apply linear interpolation\\n self.v_processed_mps = np.interp(x=ens_time,\\n xp=ens_time[self.valid_data[0, :]],\\n fp=v[self.valid_data[0, :]],\\n left=np.nan,\\n right=np.nan)\",\n \"def linear_interp(x,y,xi) :\\n \\n f = interp1d(x,y,kind='linear')\\n yi = f(xi)\\n \\n return yi\",\n \"def interpolate_loss_calculation(self, interpolates):\\n _, fake_scores = self.D(interpolates)\\n return fake_scores\",\n \"def AEH2LatLonAlt(azim, elev, h, lat, lon, alt):\\n\\n # Compute the range to the point\\n r = AEH2Range(azim, elev, h, lat, lon, alt)\\n\\n\\n # Compute lat/lon/alt of the point on the line of sight\\n x, y, z = AER2ECEF(azim, elev, r, lat, lon, alt)\\n lat2, lon2, alt2 = ecef2LatLonAlt(x, y, z)\\n lat2, lon2 = np.degrees(lat2), np.degrees(lon2)\\n\\n\\n return lat2, lon2, alt2\",\n \"def interpolate_variable(self, wavelengths, apertures):\\n\\n if self.n_ap == 1:\\n return self.flux[0, :]\\n\\n sed_apertures = self.apertures.to(u.au).value\\n sed_wav = self.wav.to(u.micron).value\\n\\n # If any apertures are larger than the defined max, reset to max\\n apertures[apertures > sed_apertures.max()] = sed_apertures.max() * 0.999\\n\\n # If any apertures are smaller than the defined min, raise Exception\\n if np.any(apertures < sed_apertures.min()):\\n raise Exception(\\\"Aperture(s) requested too small\\\")\\n\\n # Find wavelength order\\n order = np.argsort(wavelengths)\\n\\n # Interpolate apertures vs wavelength\\n log10_ap_interp = interp1d(np.log10(wavelengths[order]), np.log10(apertures[order]), bounds_error=False, fill_value=np.nan)\\n\\n # Create interpolating function\\n flux_interp = interp1d(sed_apertures, self.flux.swapaxes(0, 1))\\n\\n # Interpolate the apertures\\n apertures = 10. ** log10_ap_interp(np.log10(sed_wav))\\n\\n # Extrapolate on either side\\n apertures[np.log10(sed_wav) < log10_ap_interp.x[0]] = 10. ** log10_ap_interp.y[0]\\n apertures[np.log10(sed_wav) > log10_ap_interp.x[-1]] = 10. ** log10_ap_interp.y[-1]\\n\\n # Interpolate and return only diagonal elements\\n return flux_interp(apertures).diagonal()\",\n \"def extrapolate_nearest(self, known_coords, known_values, extrap_coords, groupname):\\n\\t\\t#First need to reshape known_coords and known_values\\n\\t\\tn_params = self.signal[groupname]['dimension']\\n\\t\\tknown_coords = np.reshape( known_coords, (-1,n_params) )\\n\\t\\tknown_values = np.reshape( known_values, (-1) )\\n\\t\\t\\t\\t\\n\\t\\t#Different methods if dimension is (!/=)= 1\\n\\t\\tif self.signal[groupname]['dimension'] == 1:\\n\\t\\t\\t#Reshape extrap_coords\\n\\t\\t\\textrap_coords = np.reshape(extrap_coords, (-1))\\n\\t\\t\\t\\n\\t\\t\\t#Initialize array for extrapolation values\\n\\t\\t\\textrap_values = np.ones(len(extrap_coords))*np.nan\\n\\t\\t\\t\\n\\t\\t\\t#Find minimum and maximum coordinates and the respective values at those coordinates\\n\\t\\t\\tmin_coord_index = np.argmin(known_coords)\\n\\t\\t\\tmin_coord = known_coords[min_coord_index]\\n\\t\\t\\tmin_coord_value = known_values[min_coord_index]\\n\\t\\t\\t\\n\\t\\t\\tmax_coord_index = np.argmax(known_coords)\\n\\t\\t\\tmax_coord = known_coords[max_coord_index]\\n\\t\\t\\tmax_coord_value = known_values[max_coord_index]\\n\\t\\t\\t\\n\\t\\t\\t#Do the nearest-bound extrapolation\\n\\t\\t\\textrap_values[np.absolute(extrap_coords - max_coord) >= np.absolute(extrap_coords - min_coord)] = min_coord_value\\n\\t\\t\\textrap_values[np.absolute(extrap_coords - max_coord) < np.absolute(extrap_coords - min_coord)] = max_coord_value\\n\\t\\t\\t\\n\\t\\telif self.signal[groupname]['dimension'] > 1:\\n\\t\\t\\textrap_values = griddata(known_coords, known_values, extrap_coords, method='nearest')\\n\\t\\t\\n\\t\\treturn extrap_values\",\n \"def slerp(q0: np.ndarray, q1: np.ndarray, t_array: np.ndarray, threshold: float = 0.9995) -> np.ndarray:\\n qdot = np.dot(q0, q1)\\n # Ensure SLERP takes the shortest path\\n if qdot < 0.0:\\n q1 *= -1.0\\n qdot *= -1.0\\n # Interpolate linearly (LERP)\\n if qdot > threshold:\\n result = q0[np.newaxis, :] + t_array[:, np.newaxis]*(q1 - q0)[np.newaxis, :]\\n return (result.T / np.linalg.norm(result, axis=1)).T\\n # Angle between vectors\\n theta_0 = np.arccos(qdot)\\n sin_theta_0 = np.sin(theta_0)\\n theta = theta_0*t_array\\n sin_theta = np.sin(theta)\\n s0 = np.cos(theta) - qdot*sin_theta/sin_theta_0\\n s1 = sin_theta/sin_theta_0\\n return s0[:, np.newaxis]*q0[np.newaxis, :] + s1[:, np.newaxis]*q1[np.newaxis, :]\",\n \"def interpolated(self, Any, Any_1, p_float): # real signature unknown; restored from __doc__\\n pass\",\n \"def see_what_its_doing_1d():\\n all_points = create_points_with_random_pollution_1d(100, 100, 10)\\n picked_points = pick_uniform_random_points(all_points, 20)\\n interpolated_points = interpolate_unknown_points(picked_points, all_points)\\n\\n picked_x = []\\n picked_pollution = []\\n for label, point in picked_points.items():\\n picked_x.append(label)\\n picked_pollution.append(point.get_pollution_value())\\n\\n interp_x = []\\n inter_pollution = []\\n\\n for label, point in interpolated_points.items():\\n if not label in picked_x:\\n interp_x.append(label)\\n inter_pollution.append(point.get_pollution_value())\\n\\n plt.plot(picked_x, picked_pollution, \\\"ro\\\", interp_x, inter_pollution, \\\"go\\\")\\n plt.xlabel(\\\"Point Label\\\")\\n plt.ylabel(\\\"Pollution Value\\\")\\n plt.show()\",\n \"def see_what_its_doing_1d():\\n all_points = create_points_with_random_pollution_1d(100, 100, 10)\\n picked_points = pick_uniform_random_points(all_points, 20)\\n interpolated_points = interpolate_unknown_points(picked_points, all_points)\\n\\n picked_x = []\\n picked_pollution = []\\n for label, point in picked_points.items():\\n picked_x.append(label)\\n picked_pollution.append(point.get_pollution_value())\\n\\n interp_x = []\\n inter_pollution = []\\n\\n for label, point in interpolated_points.items():\\n if not label in picked_x:\\n interp_x.append(label)\\n inter_pollution.append(point.get_pollution_value())\\n\\n plt.plot(picked_x, picked_pollution, \\\"ro\\\", interp_x, inter_pollution, \\\"go\\\")\\n plt.xlabel(\\\"Point Label\\\")\\n plt.ylabel(\\\"Pollution Value\\\")\\n plt.show()\",\n \"def see_what_its_doing_1d():\\n all_points = create_points_with_random_pollution_1d(100, 100, 10)\\n picked_points = pick_uniform_random_points(all_points, 20)\\n interpolated_points = interpolate_unknown_points(picked_points, all_points)\\n\\n picked_x = []\\n picked_pollution = []\\n for label, point in picked_points.items():\\n picked_x.append(label)\\n picked_pollution.append(point.get_pollution_value())\\n\\n interp_x = []\\n inter_pollution = []\\n\\n for label, point in interpolated_points.items():\\n if not label in picked_x:\\n interp_x.append(label)\\n inter_pollution.append(point.get_pollution_value())\\n\\n plt.plot(picked_x, picked_pollution, \\\"ro\\\", interp_x, inter_pollution, \\\"go\\\")\\n plt.xlabel(\\\"Point Label\\\")\\n plt.ylabel(\\\"Pollution Value\\\")\\n plt.show()\",\n \"def InterpolatePoint(self, p_int, vtkDataSetAttributes, vtkIdList, *float, **kwargs):\\n ...\",\n \"def myinterp2d(x, y, z, xnew, ynew, method='linear'):\\n x = np.ravel(x)\\n y = np.ravel(y)\\n z = np.ravel(z)\\n znew = griddata((x, y), z, (xnew, ynew), method=method, fill_value=0.)\\n return znew\",\n \"def test_linear_interpolation_nan_points(self):\\n\\n # Define pixel centers along each direction\\n x = [1.0, 2.0, 4.0]\\n y = [5.0, 9.0]\\n\\n # Define ny by nx array with corresponding values\\n A = numpy.zeros((len(x), len(y)))\\n\\n # Define values for each x, y pair as a linear function\\n for i in range(len(x)):\\n for j in range(len(y)):\\n A[i, j] = linear_function(x[i], y[j])\\n\\n # Then test that interpolated points can contain NaN\\n xis = numpy.linspace(x[0], x[-1], 10)\\n etas = numpy.linspace(y[0], y[-1], 10)\\n xis[6:7] = numpy.nan\\n etas[3] = numpy.nan\\n points = combine_coordinates(xis, etas)\\n\\n vals = interpolate2d(x, y, A, points, mode='linear')\\n refs = linear_function(points[:, 0], points[:, 1])\\n assert nanallclose(vals, refs, rtol=1e-12, atol=1e-12)\",\n \"def healpixels2dist(nside, hp1,hp2):\\n lat1, ra1 = hp.pix2ang(nside,hp1)\\n lat2, ra2 = hp.pix2ang(nside,hp2)\\n dec1 = np.pi/2.0 - lat1\\n dec2 = np.pi/2.0 - lat2\\n\\n angDist = haversine(ra1,dec1,ra2,dec2)\\n return angDist\",\n \"def augmentDistance(self):\\n\\n for key,value in self._models.iteritems():\\n src=[float(i) for i in value['src'].replace('#',' ').split()]\\n tgt=[float(i) for i in value['tgt'].replace('#',' ').split()]\\n\\n dist = haversine((np.mean(src[0:2]),np.mean(src[2:])),\\n (np.mean(tgt[0:2]),np.mean(tgt[2:])),\\n miles=True)\\n self._models[key]['distance'] = dist\\n\\n return\",\n \"def interpolate(\\n layer_attribution: Tensor,\\n interpolate_dims: Union[int, Tuple[int, ...]],\\n interpolate_mode: str = \\\"nearest\\\",\\n ) -> Tensor:\\n return F.interpolate(layer_attribution, interpolate_dims, mode=interpolate_mode)\",\n \"def altitude(press, altimeter=29.92126):\\n AS = altimeter*inHg2PA\\n print(AS, press**(L*R/g/M))\\n h = -(press**(L*R/g/M) - AS**(L*R/g/M))*T0/L/(P0**(L*R/g/M))\\n return h/ft2m\",\n \"def set_altitude(self):\\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\\n print('altitude set to', self.altitude)\\n if self.altitude < 0:\\n self.altitude = self.altitude + 360.0\\n return self.altitude \\n else: \\n pass\\n return self.altitude\",\n \"def interpolate(self, mobject1, mobject2, alpha, path_func=straight_path()):\\n self.set_points(path_func(mobject1.points, mobject2.points, alpha))\\n return self\",\n \"def lin_int(xs, ys):\\n return scipy.interpolate.interp1d(xs, ys)\",\n \"def Interpolate(self, ind, results):\\n return _gmat_py.Interpolator_Interpolate(self, ind, results)\",\n \"def dayInterpA(table, date):\\n iDate = date.strftime('%Y-%m-%d')\\n # age 0 to 99\\n popi = table[table.date1 == iDate]\\n\\n # Remove the columns for age 100 and the date1\\n popi = popi.iloc[:,0:100]\\n\\n # store the popi results into an array for the interpolation\\n #popi = (np.asarray(popi)).tolist()\\n popi = np.asarray(popi)\\n\\n # Interpolate the age in Days\\n iuspl2 = InterpolatedUnivariateSpline(AGE3, popi/365)\\n iuspl2_pred = iuspl2(AGEOUT)\\n\\n # the output\\n merged = pd.DataFrame(index = range(0,len(AGEOUT)), columns = ['AGE','POP'])\\n merged['AGE'] = AGEOUT\\n merged['POP'] = iuspl2_pred\\n return merged\",\n \"def interpolate(Position_i1, Position_i2, inBetween):\\r\\n \\r\\n # Chain the timestamps together and calculate the delta t\\r\\n T1 = Position_i1[0][:5] + [int(Position_i1[0][5])] + [int((Position_i1[0][5]%1)*1000000)] \\r\\n T2 = Position_i2[0][:5] + [int(Position_i2[0][5])] + [int((Position_i2[0][5]%1)*1000000)]\\r\\n dt = dT(T1, T2)\\r\\n\\r\\n # Do the same with longitude and latitude.\\r\\n ds = [i[1]- i[0] for i in zip(Position_i1[1], Position_i2[1])]\\r\\n \\r\\n # Calculate the \\\"slope\\\":\\r\\n ds_dt = [i/dt for i in ds]\\r\\n \\r\\n # Make the timeStamp for (inBetween) more precise:\\r\\n precise_Time = inBetween[:5] + [int(inBetween[5])] + [int((inBetween[5]%1)*1000000)]\\r\\n \\r\\n # Calculate the time since the first measurement passed till \\\"inBetween\\\"\\r\\n DeltaT = dT(T1, precise_Time)\\r\\n\\r\\n # Calculate the precise position at \\\"inBetween\\\":\\r\\n Position = [DeltaT* i[0] + i[1] for i in zip(ds_dt, Position_i1[1])]\\r\\n\\r\\n # Then return the [timeStamp, [lon, lat]]\\r\\n return [inBetween, Position]\",\n \"def interpolate_nans(self):\\n\\n signal = self.signal\\n\\n # check for more than one nan in row\\n for i in range(len(signal)-1) :\\n if np.isnan(signal[i]) and np.isnan(signal[i+1]) :\\n raise Exception('There are two nans in a row ask moritz what to do !')\\n\\n if np.isnan(signal[0]) :\\n np.signal[0] = signal[1]\\n if np.isnan(signal[-1]) :\\n signal[-1] = signal[-2]\\n\\n for i in range(1,len(signal)-1) :\\n if np.isnan(signal[i]):\\n signal[i] = (signal[i-1] + signal[i+1])/2\",\n \"def interpolation_1D(rawdata, squint_vec, angle_vec):\\n rawdata_corr = rawdata * 1\\n for idx_freq in range(rawdata.shape[0]):\\n az_new = angle_vec - squint_vec[idx_freq]\\n current_data = rawdata[idx_freq, :]\\n interpolator = _interp.interp1d(angle_vec, current_data, kind='linear', bounds_error=False, fill_value=0, assume_sorted=True)\\n rawdata_corr[idx_freq, :] = interpolator(az_new)\\n # rawdata_corr[idx_freq, :] = _np.interp(az_new, angle_vec, current_data, left=0.0, right=0.0)\\n if idx_freq % 500 == 0:\\n print_str = \\\"interp sample: {idx}, ,shift: {sh} samples\\\".format(idx=idx_freq, sh=az_new[0] - angle_vec[0])\\n print(print_str)\\n rawdata_corr = rawdata_corr.__array_wrap__(rawdata)\\n return rawdata_corr\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6566528","0.5902961","0.58026075","0.57675046","0.5665642","0.5541325","0.5525913","0.5521779","0.5509595","0.5484826","0.5441326","0.54245895","0.5362832","0.5246091","0.52411157","0.5231471","0.5227989","0.5221338","0.5212287","0.520249","0.5196203","0.51740986","0.5164642","0.51544","0.51482093","0.5145057","0.5125298","0.5107973","0.5087494","0.50067586","0.49814948","0.49721435","0.4969759","0.49526846","0.49433592","0.49295315","0.49025348","0.49013606","0.48979005","0.4889248","0.48867968","0.4876803","0.4866553","0.48649725","0.48616928","0.48587567","0.48577088","0.48480812","0.48401323","0.48290616","0.482868","0.48259464","0.48192933","0.481633","0.47809786","0.4778534","0.47772744","0.47772744","0.4777195","0.47726145","0.47657672","0.47562847","0.47532704","0.47476974","0.47471958","0.47413376","0.47375184","0.47370267","0.47314227","0.47292206","0.47219825","0.47182396","0.47174916","0.4713365","0.47094107","0.4697303","0.46901464","0.4687006","0.46845028","0.468395","0.4676198","0.4666063","0.46635783","0.46635783","0.46635783","0.46589625","0.46585017","0.46553218","0.4650387","0.46466506","0.4636969","0.46312276","0.46266246","0.46265268","0.46260917","0.46213856","0.46120116","0.46111748","0.4607733","0.45802107"],"string":"[\n \"0.6566528\",\n \"0.5902961\",\n \"0.58026075\",\n \"0.57675046\",\n \"0.5665642\",\n \"0.5541325\",\n \"0.5525913\",\n \"0.5521779\",\n \"0.5509595\",\n \"0.5484826\",\n \"0.5441326\",\n \"0.54245895\",\n \"0.5362832\",\n \"0.5246091\",\n \"0.52411157\",\n \"0.5231471\",\n \"0.5227989\",\n \"0.5221338\",\n \"0.5212287\",\n \"0.520249\",\n \"0.5196203\",\n \"0.51740986\",\n \"0.5164642\",\n \"0.51544\",\n \"0.51482093\",\n \"0.5145057\",\n \"0.5125298\",\n \"0.5107973\",\n \"0.5087494\",\n \"0.50067586\",\n \"0.49814948\",\n \"0.49721435\",\n \"0.4969759\",\n \"0.49526846\",\n \"0.49433592\",\n \"0.49295315\",\n \"0.49025348\",\n \"0.49013606\",\n \"0.48979005\",\n \"0.4889248\",\n \"0.48867968\",\n \"0.4876803\",\n \"0.4866553\",\n \"0.48649725\",\n \"0.48616928\",\n \"0.48587567\",\n \"0.48577088\",\n \"0.48480812\",\n \"0.48401323\",\n \"0.48290616\",\n \"0.482868\",\n \"0.48259464\",\n \"0.48192933\",\n \"0.481633\",\n \"0.47809786\",\n \"0.4778534\",\n \"0.47772744\",\n \"0.47772744\",\n \"0.4777195\",\n \"0.47726145\",\n \"0.47657672\",\n \"0.47562847\",\n \"0.47532704\",\n \"0.47476974\",\n \"0.47471958\",\n \"0.47413376\",\n \"0.47375184\",\n \"0.47370267\",\n \"0.47314227\",\n \"0.47292206\",\n \"0.47219825\",\n \"0.47182396\",\n \"0.47174916\",\n \"0.4713365\",\n \"0.47094107\",\n \"0.4697303\",\n \"0.46901464\",\n \"0.4687006\",\n \"0.46845028\",\n \"0.468395\",\n \"0.4676198\",\n \"0.4666063\",\n \"0.46635783\",\n \"0.46635783\",\n \"0.46635783\",\n \"0.46589625\",\n \"0.46585017\",\n \"0.46553218\",\n \"0.4650387\",\n \"0.46466506\",\n \"0.4636969\",\n \"0.46312276\",\n \"0.46266246\",\n \"0.46265268\",\n \"0.46260917\",\n \"0.46213856\",\n \"0.46120116\",\n \"0.46111748\",\n \"0.4607733\",\n \"0.45802107\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8268463"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":91983,"cells":{"query":{"kind":"string","value":"Determine the range of altitudes between start_distance and finish_distance."},"document":{"kind":"string","value":"def altitude_range(self, start_distance, finish_distance):\n start_index, start_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n\n min_alt = min(start_alt, finish_alt)\n max_alt = max(start_alt, finish_alt)\n\n if start_index < finish_index:\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\n min_alt = min(min_alt, altitudes.min())\n max_alt = max(max_alt, altitudes.max())\n\n return min_alt, max_alt"},"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 intersection_distances(self, altitude, start_distance, finish_distance):\n distances = []\n alt_index, alt_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, alt_index, alt_ratio)\n\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n while alt_index < finish_index:\n next_index = alt_index + 1\n next_ratio = 0.0\n next_alt = calculate_value(self.altitudes, next_index, next_ratio)\n\n # Does this section span the given altitude?\n if (next_alt != start_alt) and \\\n (min(start_alt, next_alt) < altitude < max(start_alt, next_alt)):\n delta = altitude - start_alt\n denom = next_alt - start_alt\n ratio = delta / denom\n distance = calculate_value(self.distances, alt_index, ratio)\n distances.append(distance)\n\n alt_index = next_index\n alt_ratio = next_ratio\n start_alt = next_alt\n\n if finish_ratio:\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n # Does the last section span the given altitude?\n if (start_alt != finish_alt) and \\\n (min(start_alt, finish_alt) < altitude < max(start_alt, finish_alt)):\n # Calculate the altitude at the end of the section to maximimse accuracy\n next_alt = calculate_value(self.altitudes, finish_index, 1.0)\n delta = altitude - start_alt\n denom = next_alt - start_alt\n ratio = delta / denom\n distance = calculate_value(self.distances, alt_index, ratio)\n distances.append(distance)\n\n return distances","def get_elementary_airspace_altitude_range(db_id):\n connection = get_geo_db_connection()\n sector = find_sector(db_id, connection)\n if (sector):\n return (sector['min_altitude'], sector['max_altitude'])\n else:\n raise NotFoundException(db_id, \"Elementary sector not found.\")","def get_user_sector_altitude_range(db_id):\n found, sector = user_sector_finder(\"id\", int(db_id))\n if found:\n return (sector[0]['min_altitude'], sector[0]['max_altitude'])\n else:\n raise NotFoundException(db_id, \"User sector not found.\")","def points2distance(start, end):\r\n start_long = math.radians(recalculate_coordinate(start[0], 'deg'))\r\n #print 'dzcx ',start_long\r\n start_latt = math.radians(recalculate_coordinate(start[1], 'deg'))\r\n\r\n end_long = math.radians(recalculate_coordinate(end[0], 'deg'))\r\n end_latt = math.radians(recalculate_coordinate(end[1], 'deg'))\r\n \r\n d_latt = end_latt - start_latt\r\n d_long = end_long - start_long\r\n \r\n r = 6371\r\n hav = math.sin(d_latt/2)**2 + math.cos(start_latt) * math.cos(end_latt) * math.sin(d_long/2)**2\r\n c = 2 * r * math.asin(math.sqrt(hav))\r\n return c","def end_points(self, origin, destination):\n # origin and destination are components with bounding-boxes\n # direction is a 2 char code representing starting and ending directions\n # 'h' horizontal, 'v' vertical\n o_coords = origin.bounding_coords()\n d_coords = destination.bounding_coords()\n\n start = {\n \"h\": core.Coords(o_coords.x2, o_coords.y1 + origin.height / 2),\n \"v\": core.Coords(origin.x + (o_coords.x2 - o_coords.x1) / 2, o_coords.y2),\n }\n end = {\n \"h\": core.Coords(d_coords.x1, d_coords.y1 + destination.height / 2),\n \"v\": core.Coords(\n destination.x + (d_coords.x2 - d_coords.x1) / 2, d_coords.y1\n ),\n }\n self.start = start[self.direction[0]]\n self.end = end[self.direction[-1]]\n return (self.start, self.end)","def AEH2Range(azim, elev, h, lat, lon, alt):\n\n\n def _heightCostFunction(params, azim, elev, h, lat, lon, alt):\n\n # Get the guessed range\n r = params\n\n # Compute the ECEF coordinates with the given range\n x, y, z = AER2ECEF(azim, elev, r, lat, lon, alt)\n\n # Compute the height\n _, _, h_computed = ecef2LatLonAlt(x, y, z)\n\n # Return residual between the heights\n return (h_computed - h)**2\n\n\n # Use a flat-Earth range as a first guess of range if the elevation is higher than 10 degrees\n if elev > np.radians(10):\n r0 = (h - alt)/np.sin(np.radians(elev))\n else:\n # Otherwise, use a distance of 1000 km\n r0 = 1e6\n\n # Numerically find the range which corresponds to the given height above the ground\n res = scipy.optimize.minimize(_heightCostFunction, r0, \\\n args=(azim, elev, h, lat, lon, alt))\n\n # Return the minimized solution\n return res.x[0]","def location_of_stops(self, choice, distance):\r\n avg_dist = 0\r\n min_dist = 1000\r\n max_dist = 0\r\n\r\n if choice == 1:\r\n #for dist_ in distance:\r\n # if int(dist_) < min_dist:\r\n # min_dist = dist_\r\n return min(distance)\r\n elif choice == 2:\r\n for dist_ in distance:\r\n if int(dist_) > max_dist:\r\n max_dist = dist_\r\n return max_dist\r\n elif choice == 3:\r\n for dist_ in distance:\r\n avg_dist += int(dist_)\r\n return avg_dist/9\r\n else:\r\n print \"Wrong Choice\"\r\n return None","def _get_energy_range(self):\n\n e0_min = self.network.isomers[0].E0\n e0_max = e0_min\n\n for isomer in self.network.isomers[1:]:\n E0 = isomer.E0\n if E0 < e0_min:\n e0_min = E0\n if E0 > e0_max:\n e0_max = E0\n for reactant in self.network.reactants:\n E0 = reactant.E0\n if E0 < e0_min:\n e0_min = E0\n if E0 > e0_max:\n e0_max = E0\n for product in self.network.products:\n E0 = product.E0\n if E0 < e0_min:\n e0_min = E0\n if E0 > e0_max:\n e0_max = E0\n for rxn in self.network.path_reactions:\n E0 = rxn.transition_state.conformer.E0.value_si\n if E0 < e0_min:\n e0_min = E0\n if E0 > e0_max:\n e0_max = E0\n\n return e0_min, e0_max","def bounds(self, start=None, finish=None):\n lower = start if start is not None else self.limits[0]\n upper = finish if finish is not None else self.limits[1]\n\n lower = lower + self.offsets[0]\n upper = upper + self.offsets[1]\n\n return (lower, upper)","def _adjustRange(self, start, end):\n adjusted_start = start\n if self._start:\n if end < self._start:\n return None\n adjusted_start = max(self._start, start)\n \n adjusted_end = end\n if self._end:\n if self._end < start:\n return None\n adjusted_end = min(self._end, end)\n \n return (adjusted_start, adjusted_end)","def get_distance(start, end):\n\n\t\tloc_start, loc_end, dst_node = create_distance(start, end)\n\t\tdistance = cmds.getAttr(\"%s.distance\" % dst_node)\n\n\t\tcmds.delete([loc_start, loc_end, dst_node])\n\n\t\treturn distance","def get_min_max_electrode_distances(self):\n distances = pdist(self.get_electrode_positions())\n return distances.min(), distances.max()","def find_distance(start, end, transit_mode=None):\n dis_url = build_url(start, end, transit_mode)[1]\n print(dis_url)\n json_response = json.loads(urllib.request.urlopen(dis_url).read().decode('utf-8'))\n travel_info = json_response[rows_key][0][elements_key][0]\n distance = travel_info[distance_key][text_key]\n if duration_key in json_response:\n duration = travel_info[duration_traf_key][text_key]\n else:\n duration = travel_info[duration_key][text_key]\n cost = None\n if fare_key in travel_info:\n cost = travel_info[fare_key]\n return duration, distance, cost","def find_best_point(self, start_i, end_i, ranges):\n max_val = 0\n target = start_i\n for i in range(start_i, end_i):\n if ranges[i] > max_val:\n target = i\n max_val = ranges[i]\n \n angle = -(540-target)*3\n return float(angle)/1080, target","def get_ival_start_end(\n coordinate: str, start: int, end: int, cds_start: int,\n errors: List) -> Optional[Tuple[int, int]]:\n try:\n start = int(start)\n if end is None:\n end = start\n end = int(end)\n except (ValueError, TypeError):\n errors.append(\"Start/End must be valid ints\")\n return None\n\n if coordinate == \"c\":\n if cds_start:\n start += cds_start\n end += cds_start\n return start, end","def calc_distance(start_lat, start_lng, end_lat, end_lng):\n # approximate radius of earth in km\n r = 6373.0\n\n # Convert to radians\n lat1 = math.radians(start_lat)\n lon1 = math.radians(start_lng)\n lat2 = math.radians(end_lat)\n lon2 = math.radians(end_lng)\n\n dlon = lon2 - lon1\n dlat = lat2 - lat1\n\n a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2\n c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))\n\n return r * c","def getAltitudeProfile(pass_length,terrain,uav_altitude,u,start_v,wind_angle):\n altitude_profile = []\n v = start_v\n for k in range(0,round(pass_length)):\n coord = convertCoords([[u,v]],wind_angle,'xy')\n x = coord[0][0]\n y = coord[0][1]\n x_points = [int(x),int(x),int(x)+1,int(x)+1]\n y_points = [int(y),int(y)+1,int(y)+1,int(y)]\n z_points = [terrain[int(y)][int(x)],terrain[int(y)+1][int(x)],\n terrain[int(y)+1][int(x)+1],terrain[int(y)][int(x)+1]]\n\n # For created terrain ONLY\n z = griddata((x_points,y_points),z_points,(x,y)) # Interpolate \n altitude = z + uav_altitude\n\n altitude_profile.append(altitude)\n v +=1\n return altitude_profile","def fix_addresses(start=None, end=None):\n if start in (None, idaapi.BADADDR):\n start = idaapi.cvar.inf.minEA\n\n if end in (None, idaapi.BADADDR):\n end = idaapi.cvar.inf.maxEA\n\n return start, end","def _euclidian_distances(stop_list):\n e_dists2 = [transitfeed.approximate_distance_between_stops(stop, tail) for\n (stop, tail) in zip(stop_list, stop_list[1:])]\n\n return e_dists2","def get_altitude(points):\n altitudes = np.zeros((len(points),), dtype=\"float64\")\n for i, point in tqdm(enumerate(points), desc=\"GETTING ALTITUDE\"):\n p = Point(point[0], point[1])\n altitudes[i] = alt.NM_COTA.iloc[\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\n ]\n return altitudes","def __distance(start_x, start_y, end_x, end_y):\n distance = math.sqrt((start_x - end_x) ** 2 + (start_y - end_y) ** 2)\n return distance","def getSlantRangeElevationHeight(self, groundRange, z):\r\n \r\n lat = self.ctrLat * pi / 180.0\r\n \r\n #figure out earth's radius at radar's lat ... non-spherical earth model\r\n e2 = self.eccen # First eccentricity squared - WGS-84 value = 0.00669437999013\r\n a = self.Requator # Equatorial radius - WGS-84 value = 6378137.0\r\n Rearth = a/sqrt(1-e2*(sin(lat))**2) # radius of curvature\r\n \r\n Rprime = self.effectiveRadiusMultiplier * self.Requator\r\n \r\n h = array(z - self.ctrAlt, dtype='float64')\r\n s = array(groundRange, dtype='float64')\r\n \r\n # Use law of cosines (Side-Angle-Side triangle theorem) with \r\n # R', R'+h as sides and s/R' as the angle to get slant range\r\n r = sqrt(Rprime**2.0 + (Rprime+h)**2.0 - 2*(Rprime+h)*Rprime*cos(s/Rprime))\r\n # Inverse of eq. 2.28c in Doviak and Zrnic 1993\r\n # Will return NaN for r=0\r\n el = arccos((Rprime+h) * sin(s/Rprime) / r) \r\n el *= 180.0 / pi\r\n \r\n return r, el","def altitude(self):\n if self.__altitude:\n return sum(self.__altitude) / len(self.__altitude)\n else:\n return -9999","async def test_get_alt_ac_start_and_end(test_db, tpm3_1_8_start_genomic,\n tpm3_1_8_end_genomic):\n resp = await test_db.get_alt_ac_start_and_end(\n \"NM_152263.3\", [\"117\", \"234\"], [\"822\", \"892\"], \"TPM3\")\n assert resp[0] == (tpm3_1_8_start_genomic, tpm3_1_8_end_genomic)\n assert resp[1] is None\n\n resp = await test_db.get_alt_ac_start_and_end(\"NM_152263.3\", gene=\"TPM3\")\n assert resp[0] is None\n assert resp[1] == \"Unable to find `alt_ac_start` or `alt_ac_end`\"","def startEndPoints(mazz):\n for i in range (len(mazz)):\n for j in range (len(mazz[i])):\n if mazz[i][j] == 6:\n startx = i\n starty = j\n elif mazz[i][j] == 7:\n endx = i\n endy = j\n return startx, starty, endx, endy","async def test_get_alt_ac_start_or_end(test_db, tpm3_1_8_start_genomic,\n tpm3_1_8_end_genomic):\n resp = await test_db.get_alt_ac_start_or_end(\"NM_152263.3\", 117, 234, None)\n assert resp[0] == tpm3_1_8_start_genomic\n assert resp[1] is None\n\n resp = await test_db.get_alt_ac_start_or_end(\"NM_152263.3\", 822, 892, None)\n assert resp[0] == tpm3_1_8_end_genomic\n assert resp[1] is None\n\n resp = await test_db.get_alt_ac_start_or_end(\n \"NM_152263.63\", 822, 892, None)\n assert resp[0] is None\n assert resp[1] == \"Unable to find a result where NM_152263.63 has \" \\\n \"transcript coordinates 822 and 892 between an exon's \" \\\n \"start and end coordinates\"","def get_valid_lidar_range(distances, angles, threshold = 600, n_points = 6):\n\n # 1. First, check array sizes\n if len(distances) != len(angles):\n print(\"ERROR ARRAY SIZES: distances and angles must have the same size\")\n return (0,len(distances)-1)\n\n # find the first index\n number_of_valid_points = 0\n for i, distance in enumerate(distances):\n if distance < threshold:\n number_of_valid_points += 1 \n if number_of_valid_points >= n_points:\n break \n i1 = i - number_of_valid_points + 2\n\n # find the last index \n number_of_valid_points = 0\n for i, distance in enumerate(distances[-1::-1]):\n if distance < threshold:\n number_of_valid_points += 1 \n if number_of_valid_points >= n_points:\n break \n i2 = len(distances) - (i - number_of_valid_points) - 1\n\n return (i1, i2)","def eta_range(self):\n\t\tticks = self.eta_details.keys()\n\t\treturn min(ticks), max(ticks)","def set_altitude(self):\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\n print('altitude set to', self.altitude)\n if self.altitude < 0:\n self.altitude = self.altitude + 360.0\n return self.altitude \n else: \n pass\n return self.altitude","def getSlantRangeElevation(self, groundRange, el):\r\n \r\n lat = self.ctrLat * pi / 180.0\r\n theta = el * pi / 180.0\r\n \r\n #figure out earth's radius at radar's lat ... non-spherical earth model\r\n e2 = self.eccen # First eccentricity squared - WGS-84 value = 0.00669437999013\r\n a = self.Requator # Equatorial radius - WGS-84 value = 6378137.0\r\n Rearth = a/sqrt(1-e2*(sin(lat))**2) # radius of curvature\r\n \r\n # Inverse of eq. 2.28b in Doviak and Zrnic 1993\r\n # Inverse of eq. 2.28c in Doviak and Zrnic 1993\r\n\r\n Rprime = self.effectiveRadiusMultiplier * self.Requator\r\n\r\n s = array(groundRange, dtype='float64')\r\n\r\n h = Rprime * ( math.cos(theta) / math.cos( theta + s / Rprime) - 1)\r\n\r\n r = (Rprime + h) * math.sin(s / Rprime) / math.cos(theta);\r\n\r\n # Use law of cosines (Side-Angle-Side triangle theorem) with \r\n # R', R'+h as sides and s/R' as the angle to get slant range\r\n #r = sqrt(Rprime**2.0 + (Rprime+h)**2.0 - 2*(Rprime+h)*Rprime*cos(s/Rprime))\r\n # Will return NaN for r=0\r\n #el = arccos((Rprime+h) * sin(s/Rprime) / r) \r\n #el *= 180.0 / pi\r\n \r\n return r,h","def manhattan_distance_between(start, destination):\n return abs(destination.x - start.x) + abs(destination.y - start.y)","def get_lat_offsets(self):\n\n startlat = self.parameters['startlatitude']\n stoplat = self.parameters['stoplatitude']\n\n #Given the start and stops,\n startidx, startvalue = utils.getnearest(self.latitudes, startlat)\n stopidx, stopvalue = utils.getnearest(self.latitudes, stoplat)\n startidx -= 2\n stopidx += 2\n latslice = np.arange(startidx, stopidx + 1)\n if utils.checkmonotonic(latslice):\n latslice = latslice\n else:\n #TODO: Support pole crossing images\n logger.error('Image is pole crossing, not currently supported.')\n '''\n print \"NOT MONOTONIC\"\n #Handle wraps around the poles\n latslice = np.arange(start_idx, stop_idx + 1)\n nlats = self.startlookup.shape[1]\n greatermask = np.where(latslice >= nlats)\n latslice[greatermask] -= nlats\n lessmask = np.where(latslice < 0)\n latslice[lessmask] += self.startlookup.shape[1]\n\n self.latsort = np.argsort(latslice)\n self.latslice = latslice[self.latsort]\n self.latsort = np.argsort(self.latsort)\n '''\n latslice = None\n logger.debug('Start latitude node is {}. Nearest lookup node is {}.'.format(startlat, startidx))\n logger.debug('Stop latitude node is {}. Nearest lookup node is {}.'.format(stoplat, stopidx))\n return latslice","def interval_distance(min_a: float, max_a: float, min_b: float, max_b: float):\n return min_b - max_a if min_a < min_b else min_a - max_b","def get_airport_start_end(result, geo_airport_cities):\n crs={'init': 'epsg:4326'}\n geometry_st = [Point(xy) for xy in zip(result.start_lon, result.start_lat)]\n geometry_end = [Point(xy) for xy in zip(result.end_lon, result.end_lat)]\n geo_st = gpd.GeoDataFrame(geometry_st, crs=crs, geometry=geometry_st)[['geometry']]\n geo_end = gpd.GeoDataFrame(geometry_end, crs=crs, geometry=geometry_end)[['geometry']]\n geo_st.crs = crs\n geo_end.crs = crs\n st_airport = pd.DataFrame(geo_st.within(geo_airport_cities['geometry'].unary_union.buffer(0.1)))\n st_airport.index=result.index\n result['geometry_st'] = st_airport\n end_airport = pd.DataFrame(geo_end.within(geo_airport_cities['geometry'].unary_union.buffer(0.1)))\n end_airport.index=result.index\n result['geometry_end'] = end_airport\n st_florence = pd.DataFrame(geo_st.within(geo_airport_cities['geometry'].loc[1].buffer(0.1)))\n st_florence.index=result.index\n result['geometry_st_fl'] = st_florence\n end_florence = pd.DataFrame(geo_end.within(geo_airport_cities['geometry'].loc[1].buffer(0.1)))\n end_florence.index=result.index\n result['geometry_end_fl'] = end_florence\n st_pisa = pd.DataFrame(geo_st.within(geo_airport_cities['geometry'].loc[0].buffer(0.1)))\n st_pisa.index=result.index\n result['geometry_st_pisa'] = st_pisa\n end_pisa = pd.DataFrame(geo_end.within(geo_airport_cities['geometry'].loc[0].buffer(0.1)))\n end_pisa.index=result.index\n result['geometry_end_pisa'] = end_pisa\n return result","def fetchbounds(self):\n pnts = [x for x in [self.out_start, self.start, self.in_start, \\\n self.in_end, self.end, self.out_end] \\\n if x is not None]\n return min(pnts), max(pnts)","def get_start_end_points(path, transect): \n transect_array = np.genfromtxt(path + 'tran_sim_pts.csv', delimiter=\",\")\n start_point = transect_array[2 * transect, :]\n end_point = transect_array[2 * transect + 1, :]\n \n # force start points to be west of end points\n if start_point[0] > end_point[0]:\n previous_start_point = start_point\n start_point = end_point\n end_point = previous_start_point\n return start_point, end_point","def check_positions_in_range(self):\n reachable = 0\n total = 0\n reachable, total = self.check_positions_in_range_for_list(reachable, total, self.close_positions_world)\n reachable, total = self.check_positions_in_range_for_list(reachable, total, self.medium_positions_world)\n reachable, total = self.check_positions_in_range_for_list(reachable, total, self.far_positions_world)\n\n return float(reachable) / float(total)","def diff(start, end):\n tz = timezone_sydney()\n correction = tz.localize(end).utcoffset() - tz.localize(start).utcoffset()\n return end - start + correction","def altitude_profile(self, alt):\n # checking if the units entered are km\n if alt.unit == u.km:\n if 150 <= alt.value < 500:\n alt_properties = self._altitude_profile(500)\n else:\n alt_properties = self._altitude_profile(alt.value)\n\n return [last[int(alt.value)] for last in alt_properties]","def get_bounds(self):\n\n northing=self.f.variables['y']\n easting=self.f.variables['x']\n\n lat1,lon1 = utm.to_latlon(np.min(easting),np.min(northing),11,northern=True)\n lat2,lon2 = utm.to_latlon(np.max(easting),np.max(northing),11,northern=True)\n\n return (lon1,lon2,lat1,lat2)","def __calculate_input_ranges(diagonal_num: int, input_seq_len: int, output_seq_len: int):\n min_len = min(input_seq_len, output_seq_len)\n max_len = max(input_seq_len, output_seq_len)\n assert 0 <= diagonal_num < min_len + max_len\n\n if diagonal_num < min_len:\n max_range = (0, diagonal_num + 1)\n min_range = max_range\n elif diagonal_num < max_len:\n max_range = (diagonal_num - (min_len - 1), diagonal_num + 1)\n min_range = (0, min_len)\n else:\n max_range = (diagonal_num - (min_len - 1), max_len)\n min_range = (diagonal_num - (max_len - 1), min_len)\n\n assert (max_range[1] - max_range[0]) == (min_range[1] - min_range[0])\n assert max_len >= max_range[1] > max_range[0] >= 0\n assert min_len >= min_range[1] > min_range[0] >= 0\n\n # determine which one is for the input and which one for the output\n if min_len == input_seq_len: # the input (vertical) is shorter or of equal length to the output\n input_range = min_range\n output_range = max_range\n else: # the output (horizontal) is shorter or of equal length to the input\n input_range = max_range\n output_range = min_range\n\n return input_range, output_range","def pairwise_distance(self, start, end):\n x1 = start[0]\n y1 = start[1]\n x2 = end[0]\n y2 = end[1]\n pairwise_dist = sqrt(((x2 - x1) * 10.29) ** 2 + ((y2 - y1) * 7.55) ** 2)\n return pairwise_dist","def data_range(self, n=-1):\n if self.rotate and len(self.results['velocities']) > 1:\n # Then we can use the last two velocities and time to extrapolate the line.\n prevVel = self.results['velocities'][-2:]\n prevTime = self.results['times'][-2:]\n\n coefficents = imageRot.computeFit(prevTime, prevVel)\n nextCenter = imageRot.extrapolate(coefficents, self.time[self.time_index])\n\n velocity_index = self.spectrogram._velocity_to_index(nextCenter)\n start_index = max(0, velocity_index - 2*self.span)\n end_index = min(velocity_index + 2*self.span,\n len(self.spectrogram.velocity))\n \n return start_index, end_index, coefficents\n # Compute the angle.\n if len(self.results['velocities']) > 0:\n last_v = self.results['velocities'][n]\n else:\n last_v = self.v_start\n velocity_index = self.spectrogram._velocity_to_index(last_v)\n start_index = max(0, velocity_index - self.span)\n end_index = min(velocity_index + self.span,\n len(self.spectrogram.velocity))\n return (start_index, end_index)","def _calc_range(self) -> np.ndarray:\n if self._is_ct25k():\n range_resolution = 30\n n_gates = 256\n else:\n n_gates = int(self.metadata[\"number_of_gates\"])\n range_resolution = int(self.metadata[\"range_resolution\"])\n return np.arange(n_gates) * range_resolution + range_resolution / 2","def __len__(self):\n return self.start.dist(self.end)","def longest_flight(self):\r\n distance = 0\r\n for code, _list in self.edges.items():\r\n for edge in _list:\r\n if edge.distance > distance:\r\n distance = edge.distance\r\n start = edge.start\r\n destination = edge.destination\r\n return start, destination, distance","def coords_in_range(self, anchor, steps):\n coords = list()\n x_low = -steps\n x_high = steps\n\n #Generate using an axial formula to make it easier\n #calculate z via the other two and throw away ones that aren't in bounds\n for x in range(x_low, x_high+1):\n for y in range(max(-steps, -x-steps), min(steps, -x+steps)+1):\n z = -x - y\n coords.append(anchor+self.coord(x, y, z))\n return coords","def check_altitude_at(self, altim, coords, altitude_bounds):\n altitude = altim.mesh.point_altitude(coords)\n self.assertWithin(altitude, *altitude_bounds)","def extent(self, start=None, finish=None):\n start, finish = self.bounds(start, finish)\n try:\n return finish - start + 1\n except TypeError:\n return None","def extract_from_range(tgt_start, tgt_end, src_start, src_end, max_phrase_len):\n # print(\"rages\", tgt_start, tgt_end, src_start, src_end)\n if tgt_end < 0:\n return \n # If `src_align_idx` out of the `src_start` and `src_target`.\n for src_align_idx, tgt_align_idx in alignment:\n # target align point\n # sorce align point out of range\n if ((tgt_start <= tgt_align_idx <= tgt_end) and \n (src_align_idx < src_start or src_align_idx > src_end)): \n return\n phrase_set = set()\n ts = tgt_start # For increment\n while True:\n te = min(tgt_end, ts+max_phrase_len-1) # For decrement\n # te = tgt_end \n while True:\n # Add phrase pair (src_start, src_end, tgt_start, tgt_end)\n src_phrase = \" \".join(src_sent[i] for i in range(src_start,src_end+1))\n tgt_phrase = \" \".join(tgt_sent[i] for i in range(ts,te+1))\n phrase_set.add(((src_start, src_end+1), src_phrase, tgt_phrase))\n te+= 1\n # Add phrase until `te` aligned or out of range\n if te in tgt_aligned or te == tgt_len:\n break\n ts-=1\n # Add phrase until `te` aligned or out of range\n if ts in tgt_aligned or ts < 0:\n break\n \n return phrase_set","def get_elevation_along_edge(self, from_, to):\n pass","def degree_range(n, start=0, end=180):\n start_ = np.linspace(start, end, n+1, endpoint=True)[0:-1]\n end_ = np.linspace(start, end, n+1, endpoint=True)[1::]\n mid_points = start_ + ((end_-start_)/2.)\n return np.c_[start_, end_], mid_points","def getAngDist(ra1, dec1, ra2, dec2): \n \n delt_lon = (ra1 - ra2)*np.pi/180.\n delt_lat = (dec1 - dec2)*np.pi/180.\n # Haversine formula\n dist = 2.0*np.arcsin( np.sqrt( np.sin(delt_lat/2.0)**2 + np.cos(dec1*np.pi/180.)*np.cos(dec2*np.pi/180.)*np.sin(delt_lon/2.0)**2 ) ) \n\n return dist/np.pi*180.","def get_range(self) -> tuple[int, int]:\n return self.range_from, self.range_to","def _translate_range(self, len_, start, end):\n start = int(start)\n end = int(end)\n if start < 0:\n start += len_\n start = max(0, min(start, len_))\n if end < 0:\n end += len_\n end = max(-1, min(end, len_ - 1))\n return start, end","def get_range(cls, data: tuple or list) -> float:\n cls._data_validation(data)\n max_ = cls.get_max(data)\n min_ = cls.get_min(data)\n return float(max_ - min_)","def get_kaalas(start_span, end_span, part_start, num_parts):\n start_fraction = part_start / num_parts\n end_fraction = (part_start + 1) / num_parts\n\n start_time = start_span + (end_span - start_span) * start_fraction\n end_time = start_span + (end_span - start_span) * end_fraction\n\n return (start_time, end_time)","def dist_from_goal( area ):\r\n dist = 99\r\n prev = goal_lkup[ 0 ]\r\n\r\n for cur in goal_lkup:\r\n #=============================================================\r\n # If the area is less than the currently selected area, but\r\n # greater then the previous area, then the distance is some\r\n # where in between. Then do linear interpolation\r\n #=============================================================\r\n if area > cur[ 'area' ] and area < prev[ 'area' ]:\r\n dist = lin_scale( area, cur[ 'area' ], cur[ 'dist ft' ], prev[ 'area' ], prev[ 'dist ft' ] )\r\n return dist\r\n prev = cur\r\n return dist","def _get_elevation_percentage(height: float, distance: float) -> float:\n return height / (distance * 1000)","def get_range(lst):\n return float(max(lst)) - float(min(lst))","def manhattan_heuristic_cost(curr, end):\n curr_x, curr_y = curr\n end_x, end_y = end\n return abs(curr_x-end_x) + abs(curr_y-end_y)","def estimate(self, xDest, yDest):\n dx = xDest - self.xPos\n dy = yDest - self.yPos\n # Euclidian Distance\n d= np.sqrt(dx**2 + dy**2)\n \n # Octile Distance\n #d = max(dx,dy)+.4*min(dx,dy)\n \n return(d)","def get_range(self, start=None, end=None):\n\n # handle the case of no data\n if self.data.shape[0] == 0 or self.source.data[\"index\"].shape[0] == 0:\n return None, None\n\n first_source_idx = self.source.data[\"index\"][0]\n last_source_idx = self.source.data[\"index\"][-1]\n\n # convert to timestamp if necessary\n if isinstance(self.data.index, pd.DatetimeIndex):\n start = pd.to_datetime(start, unit=\"ms\")\n end = pd.to_datetime(end, unit=\"ms\")\n first_source_idx = pd.to_datetime(first_source_idx, unit=\"ms\")\n last_source_idx = pd.to_datetime(last_source_idx, unit=\"ms\")\n\n # get new start and end\n if start is not None:\n if start < first_source_idx:\n start = max(self.data.index[0], start)\n elif start > last_source_idx:\n start = min(self.data.index[-1], start)\n elif start < self.data.index[0]:\n start = self.data.index[0]\n elif start > self.data.index[-1]:\n start = self.data.index[-1]\n elif len(self.source.data[\"index\"]) > 0:\n start = first_source_idx\n else:\n start = self.data.index[0]\n\n if end is not None:\n if end < first_source_idx:\n end = max(self.data.index[0], end)\n elif end > last_source_idx:\n end = min(self.data.index[-1], end)\n elif end < self.data.index[0]:\n end = self.data.index[0]\n elif end > self.data.index[-1]:\n end = self.data.index[-1]\n elif len(self.source.data[\"index\"]) > 0:\n end = last_source_idx\n else:\n end = self.data.index[-1]\n\n return start, end","def nbhd_range(pt_list, dx_mat, dy_mat, tri, pt_dict, max_dist=None, calc_min_slope=None):\n dxy_range=np.zeros([len(pt_list), 4])\n if calc_min_slope is not None:\n dxy_slope=np.zeros([len(pt_list), 2])\n for row, pt in enumerate(pt_list):\n neighbors=pt_dict[pt]\n nbhd_pts=tri.points[neighbors,:]\n this_pt=tri.points[pt,:]\n if max_dist is not None:\n dist2=(nbhd_pts[:,1]-this_pt[1])**2 + (nbhd_pts[:,0]-this_pt[0])**2\n nbhd_pts=nbhd_pts[dist2 < max_dist**2,:]\n if nbhd_pts is None or min(nbhd_pts.shape) < 1:\n continue\n dx_vals=np.append(np.array(dx_mat[nbhd_pts[:,1], nbhd_pts[:,0]]), dx_mat[this_pt[1], this_pt[0]])\n dy_vals=np.append(np.array(dy_mat[nbhd_pts[:,1], nbhd_pts[:,0]]), dy_mat[this_pt[1], this_pt[0]])\n if calc_min_slope is not None:\n dist=np.sqrt((nbhd_pts[:,1]-this_pt[1])**2 + (nbhd_pts[:,0]-this_pt[0])**2)\n dx_slope=np.abs(dx_vals[0:-1]-dx_vals[-1])/dist\n dy_slope=np.abs(dy_vals[0:-1]-dy_vals[-1])/dist\n dxy_slope[row,:]=[np.min(dx_slope), np.min(dy_slope)];\n\n dxy_range[row,[0,1]]=[np.min(dx_vals), np.max(dx_vals)]\n dxy_range[row,[2,3]]=[np.min(dy_vals), np.max(dy_vals)]\n if calc_min_slope is not None:\n return dxy_range, dxy_slope\n else:\n return dxy_range ##, dxy_bar","def _check_start_and_end_steps(self):\n start_step = end_step = None\n\n if self.start_step is not None:\n if hasattr(self, self.start_step):\n start_step = getattr(self, self.start_step)\n else:\n raise ValueError(\n \"start_step {0!r} not found\".format(\n self.start_step))\n\n if self.end_step is not None:\n if hasattr(self, self.end_step):\n end_step = getattr(self, self.end_step)\n else:\n raise ValueError(\n \"end_step {0!r} not found\".format(\n self.end_step))\n\n return start_step, end_step","def _calculate_h(self, end):\n return PATH_COST * (abs(self.x - end.x) + abs(self.y - end.y))","def cost(self, start_value, end_value):\n cost = np.linalg.norm(start_value - end_value)\n return cost","def range(self) -> ty.Tuple[float, float]:\r\n ...","def boundaries_end(*args):\n return _ida_hexrays.boundaries_end(*args)","def arc_tangents(amount, start, stop, truncated, sequence):\n ratio = (start + stop) / 2\n for x in range(start, amount):\n y = abs(round(ratio * math.atan(x)))\n if truncated and y >= stop:\n sequence.append(stop)\n elif y < start:\n sequence.append(start)\n else:\n sequence.append(y)\n return sequence","def get_valid_fret_range(history, *, dist_range, guitar):\n min_w = guitar.max_fret\n max_w = guitar.min_fret\n for fret in history:\n min_w = min(min_w, fret)\n max_w = max(max_w, fret)\n min_x = max(max_w - dist_range, guitar.min_fret)\n max_x = min(min_w + dist_range, guitar.max_fret)\n return min_x, max_x","def getGroundRangeHeight(self, r, elevationAngle):\r\n \r\n #Double precison arithmetic is crucial to proper operation.\r\n lat = self.ctrLat * pi / 180.0\r\n elev = array(elevationAngle * pi / 180.0, dtype='float64')\r\n slantr = array(r, dtype='float64')\r\n \r\n #figure out earth's radius at radar's lat ... non-spherical earth model\r\n e2 = self.eccen # First eccentricity squared - WGS-84 value = 0.00669437999013\r\n a = self.Requator # Equatorial radius - WGS-84 value = 6378137.0\r\n Rearth = a/sqrt(1-e2*(sin(lat))**2) # radius of curvature\r\n \r\n Rprime = self.effectiveRadiusMultiplier * self.Requator\r\n \r\n # Eqns 2.28b,c in Doviak and Zrnic 1993\r\n # Radar altitude is tacked on at the end, which isn't part of their derivation. At 100 km, it's \r\n # worth < 10 m range error total for a radar at 500 m MSL. For 250 m gate spacing (typical at S-band), \r\n # this is not too important.\r\n h = sqrt(slantr**2.0 + Rprime**2.0 + 2*slantr*Rprime*sin(elev)) - Rprime\r\n s = Rprime * arcsin( (slantr*cos(elev)) / (Rprime + h) )\r\n \r\n h += self.ctrAlt\r\n \r\n return s, h","def latency_get_between(self, start, end):\n\n return self.__get_between(Latency, start, end)","def walk_away_from_end(start, stop,\n direction, walk=3):\n if direction == \"+\":\n # changed as this is the gene end\n current_start = int(end)\n current_end = int(end) + int(walk)\n else:\n assert direction == \"-\", \"direction does sign error!\"\n current_end = start\n current_start = int(start) - int(walk)\n return current_start, current_end","def calc_line(start, target, map):\n\t\"\"\" Returns the real world point at the farthest range \"\"\"\n\tdx = abs(target[0] - start[0])\n\tdy = abs(target[1] - start[1])\n\txi = start[0]\n\tyi = start[1]\n\tn = 1 + dx + dy\n\tx_dir = np.sign(target[0] - start[0])\n\ty_dir = np.sign(target[1] - start[1])\n\terror = dx - dy;\n\tdx *= 2\n\tdy *= 2\n\n\tfor i in xrange(n):\n\t\tif map.grid[xi,yi] is not map.empty and map.grid[xi,yi] > 0:\n\t\t\treturn xi, yi\n\n\t\tif error > 0:\n\t\t\txi += x_dir\n\t\t\terror -= dy\n\t\telse:\n\t\t\tyi += y_dir\n\t\t\terror += dx\n\treturn target","def compute_start_end_points(linestrings):\n starts = []\n stops = []\n for ls in linestrings:\n pt = Point(ls.coords[0])\n starts.append(round(CONUS[\"poly\"].exterior.project(pt), 2))\n pt = Point(ls.coords[-1])\n stops.append(round(CONUS[\"poly\"].exterior.project(pt), 2))\n return starts, stops","def calc_overlap(self, start, stop):\n\n overlaps = []\n for s in self.map:\n e = self.map[s]\n if s >= start or s <= stop:\n # We found an overlap\n if e <= stop:\n overlaps.append({\"start\": s, \"stop\": e})\n else:\n overlaps.append({\"start\": s, \"stop\": stop})\n elif e >= start or e <= stop:\n if s >= start:\n overlaps.append({\"start\": s, \"stop\": e})\n else:\n overlaps.append({\"start\": start, \"stop\": e})\n return overlaps","def air_range(self) -> Union[int, float]:\n return self.air_weapon and self.air_weapon.range","def travel_time(self, origin, destination):\n assert 2 <= len(origin) <= 3, \"Origin should by (x, y) or (x, y, z)\"\n assert 2 <= len(destination) <= 3, \"Origin should by (x, y) or (x, y, z)\"\n assert len(origin) == len(destination), \"Elevation should be present in origin and destination or absent in both\"\n if len(origin) == 2:\n xo, yo = origin\n xd, yd = destination\n zo = zd = 0\n else:\n assert len(origin) == 3\n xo, yo, zo = origin\n xd, yd, zd = destination\n\n ground_distance = np.sqrt((xd-xo)**2 + (yd-yo)**2)\n elevation_diff = zd - zo\n if elevation_diff >= 0:\n return max(ground_distance / self.max_airspeed, elevation_diff / self.max_rate_of_climb)\n else:\n return max(ground_distance / self.max_airspeed, -elevation_diff / self.max_rate_of_descent)","def __calculate_average_distance(self):\n game = self.__game # type: Game\n all_icebergs = game.get_all_icebergs()\n all_icebergs_length = len(all_icebergs)\n sum_distances = 0\n for i in range(all_icebergs_length):\n for j in range(i + 1, all_icebergs_length):\n iceberg1 = all_icebergs[i]\n iceberg2 = all_icebergs[j]\n sum_distances += iceberg1.get_turns_till_arrival(iceberg2)\n\n return sum_distances / (all_icebergs_length * (all_icebergs_length - 1) / 2)","def distances_and_limits(road_map):\n \n distance_list = [math.sqrt((road_map[(i-1) % len(road_map)][3] - road_map[i][3])**2 + \\\n (road_map[(i-1) % len(road_map)][2] - road_map[i][2])**2) \\\n for i, city in enumerate(road_map)]\n \n lats_list = [road_map[i][2] for i, city in enumerate(road_map)]\n longs_list = [road_map[i][3] for i, city in enumerate(road_map)]\n \n min_lat, max_lat = min(lats_list), max(lats_list)\n min_long, max_long = min(longs_list), max(longs_list)\n \n if min_lat < -90 or max_lat > 90 or min_long < -180 or max_long > 180:\n raise Exception(\"Please check the latitude and longitude values in your map.\")\n else:\n return distance_list, min_lat, max_lat, min_long, max_long","def _center_distance(self):\n # Split positions in segments of two points :\n cut = np.vsplit(self.a_position, int(self.a_position.shape[0]/2))\n # Get center position and starting line position :\n center = np.mean(cut, axis=1)\n\n # ============ EUCLIDIAN DISTANCE ============\n diff = np.sqrt(np.square(center[:, np.newaxis, :] - center).sum(2))\n diff[np.tril_indices_from(diff)] = np.inf\n\n return center, diff","def get_dec_i_range(data_decs):\n data_dec_is = map_list(lambda x: (x - 1800)//10, data_decs)\n lower_range_i = data_dec_is[0]\n upper_range_i = data_dec_is[-1] + 1\n return (lower_range_i, upper_range_i)","def CalcGroundRange(numRxScanAngles, altitude, slantRanges):\n GR_Arr = [] \n for i in range(numRxScanAngles):\n core_angle_arr = SEM.CoreAngle(altitude, slantRanges[i])\n gr_arr = SEM.GroundRangeFromCoreAngle(core_angle_arr)\n GR_Arr.append(gr_arr)\n return GR_Arr","def _find_break_points(self, start, end, num_classes):\r\n if start >= end:\r\n raise ValueError(\"Cannot find breakpoints because the starting \"\r\n \"point is greater than or equal to the ending \"\r\n \"point.\")\r\n if num_classes < 1:\r\n raise ValueError(\"Cannot have fewer than one distance class.\")\r\n\r\n width = (end - start) / num_classes\r\n break_points = [start + width * class_num\r\n for class_num in range(num_classes)]\r\n break_points.append(float(end))\r\n\r\n # Move the first breakpoint a little bit to the left. Machine epsilon\r\n # is taken from:\r\n # http://en.wikipedia.org/wiki/Machine_epsilon#\r\n # Approximation_using_Python\r\n epsilon = finfo(float).eps\r\n break_points[0] = break_points[0] - epsilon\r\n\r\n return break_points","def get_dist_cost(data, start_node_id, end_node_id):\n p1 = get_coords(data, start_node_id)\n p2 = get_coords(data, end_node_id)\n return great_circle_distance(p1, p2)","def get_distance_metres(aLocation1, aLocation2):\n [dNorth, dEast, dDown] = get_position_error(aLocation1, aLocation2)\n \n return math.sqrt((dNorth*dNorth) + (dEast*dEast))","def getClosestMatch(start,end,lookup):\n newStart = None\n newEnd = None\n for x in lookup.keys():\n if x < start: \n newStart = x\n if x > end and newEnd == None: \n newEnd = x\n\n if newStart != None:\n return newStart, newEnd\n else:\n break\n \n if newStart == None and newEnd == None:\n return 0,list(lookup.keys())[-1]\n elif newStart == None: \n return 0,newEnd\n elif newEnd == None: \n return newStart,list(lookup.keys())[-1]\n else:\n print(\"error occured in file execution should not have reached this \\\n point, componentsExternSpacy.py getClosestMatch(start,end,lookup)\")\n\n return newStart, newEnd","def learning_rate_range():\n # Lower and upper bounds\n #######\n lower_bound = 0.1 \n upper_bound = 1e-6\n #######\n return lower_bound, upper_bound","def derive_features(self):\n\n temp = int(self.stop_id)\n\n while temp not in self.stops_latlon.keys():\n if temp < 7692:\n temp += 1\n else:\n while temp not in self.stops_latlon.keys():\n temp -= 1\n\n self.latitude = self.stops_latlon[temp][0]\n self.longitude = self.stops_latlon[temp][1]\n\n self.distance_centre = FormatInput.haversine(self.latitude, self.longitude)\n\n self.cluster = FormatInput.map_stop_to_cluster(self.cluster_map, self.stop_id)\n\n self.holiday = FormatInput.add_holiday(self.date)","def get_all_map_info(start, end, transit_mode=None):\n directions = find_directions(start, end, transit_mode)\n distance = find_distance(start, end, transit_mode)\n static_map = find_map(start, end)\n return (distance, directions, static_map)","def _calc_intervall_diff(i1, i2):\n assert i1.overlaps(i2)\n mi = max([i1.left, i2.left])\n ma = min([i1.right, i2.right])\n #return pd.Interval(mi, ma)\n return ma-mi","def _query_range_get(self):\n return (self.query_start, self.query_end)","def elapsed_raw(self, start=\"__enter__\", end=\"__exit__\"):\n return self.laps[end] - self.laps[start]","def set_cruise_altitudes(altitudes, cruise_indicies):\n if cruise_indicies:\n for index in range(0, len(cruise_indicies), 2):\n start = cruise_indicies[index]\n stop = cruise_indicies[index + 1]\n if start < stop:\n cruise_altitude = closest_cruising_altitude(altitudes[start])\n altitudes[start] = cruise_altitude\n altitudes[stop] = cruise_altitude\n\n return altitudes","def line_segment_distance(start1, end1, start2, end2):\n assert end1 >= start1\n assert end2 >= start2\n if start1 <= start2 <= end1:\n return 0\n elif start1 <= start2:\n return start2 - end1\n elif start2 <= start1 <= end2:\n return 0\n else:\n return start1 - end2","def speed_get_between(self, start, end):\n\n return self.__get_between(Speed, start, end)","def calc_distance_efficiency(edgenode1: NodeID, edgenode2: NodeID, endnode: NodeID):\n \n (edgenode1_x, edgenode1_y) = G.nodes[edgenode1]['x'], G.nodes[edgenode1]['y']\n (edgenode2_x, edgenode2_y) = G.nodes[edgenode2]['x'], G.nodes[edgenode2]['y']\n (endnode_x, endnode_y) = G.nodes[endnode]['x'], G.nodes[endnode]['y']\n \n distance_edgenode1_edgenode2 = np.sqrt(np.square(edgenode1_x - edgenode2_x) + np.square(edgenode1_y - edgenode2_y))\n distance_edgenode1_end = np.sqrt(np.square(edgenode1_x - endnode_x) + np.square(edgenode1_y - endnode_y))\n distance_edgenode2_end = np.sqrt(np.square(endnode_x - edgenode2_x) + np.square(endnode_y - edgenode2_y))\n\n progress_to_end = distance_edgenode1_end - distance_edgenode2_end\n \n efficiency_calculation = (progress_to_end/distance_edgenode1_edgenode2)\n return efficiency_calculation","def _all_dist_to_end(args):\n idx = args[0]\n spiketrains = args[1]\n start = args[2]\n end = args[3]\n N = args[4]\n num_spiketrains = len(spiketrains)\n distances = []\n for jdx in range(idx+1, num_spiketrains):\n dist = distance(spiketrains[idx], spiketrains[jdx], start, end, N)\n times = dist[0] # should be the same for all\n distances.append(dist[1])\n return times, distances","def compute_pair_bounds(self, edges, pair):\n lower_bounds =[]\n upper_bounds = []\n for arc in edges:\n l_e = self.arc_info[arc][\"lower_bound\"]\n u_e = self.arc_info[arc][\"upper_bound\"]\n f_mij = self.compute_f_mij(arc, pair)\n lower_bounds.append(l_e - f_mij)\n upper_bounds.append(u_e - f_mij)\n lb = max(lower_bounds + [0])\n # in case no edges in here, make max of 5,000\n if len(upper_bounds) == 0:\n i = pair[0]\n j = pair[1]\n print(\"Path i ({}): {}\".format(i, self.paths[i]))\n print(\"Path j ({}): {}\".format(j, self.paths[j]))\n ub = min(upper_bounds + [5000])\n #print(\"lower bounds: {}\".format(lower_bounds))\n #print(\"upper bounds: {}\".format(upper_bounds))\n return(lb, ub)"],"string":"[\n \"def intersection_distances(self, altitude, start_distance, finish_distance):\\n distances = []\\n alt_index, alt_ratio = calculate_value_reference(self.distances,\\n start_distance)\\n start_alt = calculate_value(self.altitudes, alt_index, alt_ratio)\\n\\n finish_index, finish_ratio = calculate_value_reference(self.distances,\\n finish_distance)\\n while alt_index < finish_index:\\n next_index = alt_index + 1\\n next_ratio = 0.0\\n next_alt = calculate_value(self.altitudes, next_index, next_ratio)\\n\\n # Does this section span the given altitude?\\n if (next_alt != start_alt) and \\\\\\n (min(start_alt, next_alt) < altitude < max(start_alt, next_alt)):\\n delta = altitude - start_alt\\n denom = next_alt - start_alt\\n ratio = delta / denom\\n distance = calculate_value(self.distances, alt_index, ratio)\\n distances.append(distance)\\n\\n alt_index = next_index\\n alt_ratio = next_ratio\\n start_alt = next_alt\\n\\n if finish_ratio:\\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\\n # Does the last section span the given altitude?\\n if (start_alt != finish_alt) and \\\\\\n (min(start_alt, finish_alt) < altitude < max(start_alt, finish_alt)):\\n # Calculate the altitude at the end of the section to maximimse accuracy\\n next_alt = calculate_value(self.altitudes, finish_index, 1.0)\\n delta = altitude - start_alt\\n denom = next_alt - start_alt\\n ratio = delta / denom\\n distance = calculate_value(self.distances, alt_index, ratio)\\n distances.append(distance)\\n\\n return distances\",\n \"def get_elementary_airspace_altitude_range(db_id):\\n connection = get_geo_db_connection()\\n sector = find_sector(db_id, connection)\\n if (sector):\\n return (sector['min_altitude'], sector['max_altitude'])\\n else:\\n raise NotFoundException(db_id, \\\"Elementary sector not found.\\\")\",\n \"def get_user_sector_altitude_range(db_id):\\n found, sector = user_sector_finder(\\\"id\\\", int(db_id))\\n if found:\\n return (sector[0]['min_altitude'], sector[0]['max_altitude'])\\n else:\\n raise NotFoundException(db_id, \\\"User sector not found.\\\")\",\n \"def points2distance(start, end):\\r\\n start_long = math.radians(recalculate_coordinate(start[0], 'deg'))\\r\\n #print 'dzcx ',start_long\\r\\n start_latt = math.radians(recalculate_coordinate(start[1], 'deg'))\\r\\n\\r\\n end_long = math.radians(recalculate_coordinate(end[0], 'deg'))\\r\\n end_latt = math.radians(recalculate_coordinate(end[1], 'deg'))\\r\\n \\r\\n d_latt = end_latt - start_latt\\r\\n d_long = end_long - start_long\\r\\n \\r\\n r = 6371\\r\\n hav = math.sin(d_latt/2)**2 + math.cos(start_latt) * math.cos(end_latt) * math.sin(d_long/2)**2\\r\\n c = 2 * r * math.asin(math.sqrt(hav))\\r\\n return c\",\n \"def end_points(self, origin, destination):\\n # origin and destination are components with bounding-boxes\\n # direction is a 2 char code representing starting and ending directions\\n # 'h' horizontal, 'v' vertical\\n o_coords = origin.bounding_coords()\\n d_coords = destination.bounding_coords()\\n\\n start = {\\n \\\"h\\\": core.Coords(o_coords.x2, o_coords.y1 + origin.height / 2),\\n \\\"v\\\": core.Coords(origin.x + (o_coords.x2 - o_coords.x1) / 2, o_coords.y2),\\n }\\n end = {\\n \\\"h\\\": core.Coords(d_coords.x1, d_coords.y1 + destination.height / 2),\\n \\\"v\\\": core.Coords(\\n destination.x + (d_coords.x2 - d_coords.x1) / 2, d_coords.y1\\n ),\\n }\\n self.start = start[self.direction[0]]\\n self.end = end[self.direction[-1]]\\n return (self.start, self.end)\",\n \"def AEH2Range(azim, elev, h, lat, lon, alt):\\n\\n\\n def _heightCostFunction(params, azim, elev, h, lat, lon, alt):\\n\\n # Get the guessed range\\n r = params\\n\\n # Compute the ECEF coordinates with the given range\\n x, y, z = AER2ECEF(azim, elev, r, lat, lon, alt)\\n\\n # Compute the height\\n _, _, h_computed = ecef2LatLonAlt(x, y, z)\\n\\n # Return residual between the heights\\n return (h_computed - h)**2\\n\\n\\n # Use a flat-Earth range as a first guess of range if the elevation is higher than 10 degrees\\n if elev > np.radians(10):\\n r0 = (h - alt)/np.sin(np.radians(elev))\\n else:\\n # Otherwise, use a distance of 1000 km\\n r0 = 1e6\\n\\n # Numerically find the range which corresponds to the given height above the ground\\n res = scipy.optimize.minimize(_heightCostFunction, r0, \\\\\\n args=(azim, elev, h, lat, lon, alt))\\n\\n # Return the minimized solution\\n return res.x[0]\",\n \"def location_of_stops(self, choice, distance):\\r\\n avg_dist = 0\\r\\n min_dist = 1000\\r\\n max_dist = 0\\r\\n\\r\\n if choice == 1:\\r\\n #for dist_ in distance:\\r\\n # if int(dist_) < min_dist:\\r\\n # min_dist = dist_\\r\\n return min(distance)\\r\\n elif choice == 2:\\r\\n for dist_ in distance:\\r\\n if int(dist_) > max_dist:\\r\\n max_dist = dist_\\r\\n return max_dist\\r\\n elif choice == 3:\\r\\n for dist_ in distance:\\r\\n avg_dist += int(dist_)\\r\\n return avg_dist/9\\r\\n else:\\r\\n print \\\"Wrong Choice\\\"\\r\\n return None\",\n \"def _get_energy_range(self):\\n\\n e0_min = self.network.isomers[0].E0\\n e0_max = e0_min\\n\\n for isomer in self.network.isomers[1:]:\\n E0 = isomer.E0\\n if E0 < e0_min:\\n e0_min = E0\\n if E0 > e0_max:\\n e0_max = E0\\n for reactant in self.network.reactants:\\n E0 = reactant.E0\\n if E0 < e0_min:\\n e0_min = E0\\n if E0 > e0_max:\\n e0_max = E0\\n for product in self.network.products:\\n E0 = product.E0\\n if E0 < e0_min:\\n e0_min = E0\\n if E0 > e0_max:\\n e0_max = E0\\n for rxn in self.network.path_reactions:\\n E0 = rxn.transition_state.conformer.E0.value_si\\n if E0 < e0_min:\\n e0_min = E0\\n if E0 > e0_max:\\n e0_max = E0\\n\\n return e0_min, e0_max\",\n \"def bounds(self, start=None, finish=None):\\n lower = start if start is not None else self.limits[0]\\n upper = finish if finish is not None else self.limits[1]\\n\\n lower = lower + self.offsets[0]\\n upper = upper + self.offsets[1]\\n\\n return (lower, upper)\",\n \"def _adjustRange(self, start, end):\\n adjusted_start = start\\n if self._start:\\n if end < self._start:\\n return None\\n adjusted_start = max(self._start, start)\\n \\n adjusted_end = end\\n if self._end:\\n if self._end < start:\\n return None\\n adjusted_end = min(self._end, end)\\n \\n return (adjusted_start, adjusted_end)\",\n \"def get_distance(start, end):\\n\\n\\t\\tloc_start, loc_end, dst_node = create_distance(start, end)\\n\\t\\tdistance = cmds.getAttr(\\\"%s.distance\\\" % dst_node)\\n\\n\\t\\tcmds.delete([loc_start, loc_end, dst_node])\\n\\n\\t\\treturn distance\",\n \"def get_min_max_electrode_distances(self):\\n distances = pdist(self.get_electrode_positions())\\n return distances.min(), distances.max()\",\n \"def find_distance(start, end, transit_mode=None):\\n dis_url = build_url(start, end, transit_mode)[1]\\n print(dis_url)\\n json_response = json.loads(urllib.request.urlopen(dis_url).read().decode('utf-8'))\\n travel_info = json_response[rows_key][0][elements_key][0]\\n distance = travel_info[distance_key][text_key]\\n if duration_key in json_response:\\n duration = travel_info[duration_traf_key][text_key]\\n else:\\n duration = travel_info[duration_key][text_key]\\n cost = None\\n if fare_key in travel_info:\\n cost = travel_info[fare_key]\\n return duration, distance, cost\",\n \"def find_best_point(self, start_i, end_i, ranges):\\n max_val = 0\\n target = start_i\\n for i in range(start_i, end_i):\\n if ranges[i] > max_val:\\n target = i\\n max_val = ranges[i]\\n \\n angle = -(540-target)*3\\n return float(angle)/1080, target\",\n \"def get_ival_start_end(\\n coordinate: str, start: int, end: int, cds_start: int,\\n errors: List) -> Optional[Tuple[int, int]]:\\n try:\\n start = int(start)\\n if end is None:\\n end = start\\n end = int(end)\\n except (ValueError, TypeError):\\n errors.append(\\\"Start/End must be valid ints\\\")\\n return None\\n\\n if coordinate == \\\"c\\\":\\n if cds_start:\\n start += cds_start\\n end += cds_start\\n return start, end\",\n \"def calc_distance(start_lat, start_lng, end_lat, end_lng):\\n # approximate radius of earth in km\\n r = 6373.0\\n\\n # Convert to radians\\n lat1 = math.radians(start_lat)\\n lon1 = math.radians(start_lng)\\n lat2 = math.radians(end_lat)\\n lon2 = math.radians(end_lng)\\n\\n dlon = lon2 - lon1\\n dlat = lat2 - lat1\\n\\n a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2\\n c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))\\n\\n return r * c\",\n \"def getAltitudeProfile(pass_length,terrain,uav_altitude,u,start_v,wind_angle):\\n altitude_profile = []\\n v = start_v\\n for k in range(0,round(pass_length)):\\n coord = convertCoords([[u,v]],wind_angle,'xy')\\n x = coord[0][0]\\n y = coord[0][1]\\n x_points = [int(x),int(x),int(x)+1,int(x)+1]\\n y_points = [int(y),int(y)+1,int(y)+1,int(y)]\\n z_points = [terrain[int(y)][int(x)],terrain[int(y)+1][int(x)],\\n terrain[int(y)+1][int(x)+1],terrain[int(y)][int(x)+1]]\\n\\n # For created terrain ONLY\\n z = griddata((x_points,y_points),z_points,(x,y)) # Interpolate \\n altitude = z + uav_altitude\\n\\n altitude_profile.append(altitude)\\n v +=1\\n return altitude_profile\",\n \"def fix_addresses(start=None, end=None):\\n if start in (None, idaapi.BADADDR):\\n start = idaapi.cvar.inf.minEA\\n\\n if end in (None, idaapi.BADADDR):\\n end = idaapi.cvar.inf.maxEA\\n\\n return start, end\",\n \"def _euclidian_distances(stop_list):\\n e_dists2 = [transitfeed.approximate_distance_between_stops(stop, tail) for\\n (stop, tail) in zip(stop_list, stop_list[1:])]\\n\\n return e_dists2\",\n \"def get_altitude(points):\\n altitudes = np.zeros((len(points),), dtype=\\\"float64\\\")\\n for i, point in tqdm(enumerate(points), desc=\\\"GETTING ALTITUDE\\\"):\\n p = Point(point[0], point[1])\\n altitudes[i] = alt.NM_COTA.iloc[\\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\\n ]\\n return altitudes\",\n \"def __distance(start_x, start_y, end_x, end_y):\\n distance = math.sqrt((start_x - end_x) ** 2 + (start_y - end_y) ** 2)\\n return distance\",\n \"def getSlantRangeElevationHeight(self, groundRange, z):\\r\\n \\r\\n lat = self.ctrLat * pi / 180.0\\r\\n \\r\\n #figure out earth's radius at radar's lat ... non-spherical earth model\\r\\n e2 = self.eccen # First eccentricity squared - WGS-84 value = 0.00669437999013\\r\\n a = self.Requator # Equatorial radius - WGS-84 value = 6378137.0\\r\\n Rearth = a/sqrt(1-e2*(sin(lat))**2) # radius of curvature\\r\\n \\r\\n Rprime = self.effectiveRadiusMultiplier * self.Requator\\r\\n \\r\\n h = array(z - self.ctrAlt, dtype='float64')\\r\\n s = array(groundRange, dtype='float64')\\r\\n \\r\\n # Use law of cosines (Side-Angle-Side triangle theorem) with \\r\\n # R', R'+h as sides and s/R' as the angle to get slant range\\r\\n r = sqrt(Rprime**2.0 + (Rprime+h)**2.0 - 2*(Rprime+h)*Rprime*cos(s/Rprime))\\r\\n # Inverse of eq. 2.28c in Doviak and Zrnic 1993\\r\\n # Will return NaN for r=0\\r\\n el = arccos((Rprime+h) * sin(s/Rprime) / r) \\r\\n el *= 180.0 / pi\\r\\n \\r\\n return r, el\",\n \"def altitude(self):\\n if self.__altitude:\\n return sum(self.__altitude) / len(self.__altitude)\\n else:\\n return -9999\",\n \"async def test_get_alt_ac_start_and_end(test_db, tpm3_1_8_start_genomic,\\n tpm3_1_8_end_genomic):\\n resp = await test_db.get_alt_ac_start_and_end(\\n \\\"NM_152263.3\\\", [\\\"117\\\", \\\"234\\\"], [\\\"822\\\", \\\"892\\\"], \\\"TPM3\\\")\\n assert resp[0] == (tpm3_1_8_start_genomic, tpm3_1_8_end_genomic)\\n assert resp[1] is None\\n\\n resp = await test_db.get_alt_ac_start_and_end(\\\"NM_152263.3\\\", gene=\\\"TPM3\\\")\\n assert resp[0] is None\\n assert resp[1] == \\\"Unable to find `alt_ac_start` or `alt_ac_end`\\\"\",\n \"def startEndPoints(mazz):\\n for i in range (len(mazz)):\\n for j in range (len(mazz[i])):\\n if mazz[i][j] == 6:\\n startx = i\\n starty = j\\n elif mazz[i][j] == 7:\\n endx = i\\n endy = j\\n return startx, starty, endx, endy\",\n \"async def test_get_alt_ac_start_or_end(test_db, tpm3_1_8_start_genomic,\\n tpm3_1_8_end_genomic):\\n resp = await test_db.get_alt_ac_start_or_end(\\\"NM_152263.3\\\", 117, 234, None)\\n assert resp[0] == tpm3_1_8_start_genomic\\n assert resp[1] is None\\n\\n resp = await test_db.get_alt_ac_start_or_end(\\\"NM_152263.3\\\", 822, 892, None)\\n assert resp[0] == tpm3_1_8_end_genomic\\n assert resp[1] is None\\n\\n resp = await test_db.get_alt_ac_start_or_end(\\n \\\"NM_152263.63\\\", 822, 892, None)\\n assert resp[0] is None\\n assert resp[1] == \\\"Unable to find a result where NM_152263.63 has \\\" \\\\\\n \\\"transcript coordinates 822 and 892 between an exon's \\\" \\\\\\n \\\"start and end coordinates\\\"\",\n \"def get_valid_lidar_range(distances, angles, threshold = 600, n_points = 6):\\n\\n # 1. First, check array sizes\\n if len(distances) != len(angles):\\n print(\\\"ERROR ARRAY SIZES: distances and angles must have the same size\\\")\\n return (0,len(distances)-1)\\n\\n # find the first index\\n number_of_valid_points = 0\\n for i, distance in enumerate(distances):\\n if distance < threshold:\\n number_of_valid_points += 1 \\n if number_of_valid_points >= n_points:\\n break \\n i1 = i - number_of_valid_points + 2\\n\\n # find the last index \\n number_of_valid_points = 0\\n for i, distance in enumerate(distances[-1::-1]):\\n if distance < threshold:\\n number_of_valid_points += 1 \\n if number_of_valid_points >= n_points:\\n break \\n i2 = len(distances) - (i - number_of_valid_points) - 1\\n\\n return (i1, i2)\",\n \"def eta_range(self):\\n\\t\\tticks = self.eta_details.keys()\\n\\t\\treturn min(ticks), max(ticks)\",\n \"def set_altitude(self):\\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\\n print('altitude set to', self.altitude)\\n if self.altitude < 0:\\n self.altitude = self.altitude + 360.0\\n return self.altitude \\n else: \\n pass\\n return self.altitude\",\n \"def getSlantRangeElevation(self, groundRange, el):\\r\\n \\r\\n lat = self.ctrLat * pi / 180.0\\r\\n theta = el * pi / 180.0\\r\\n \\r\\n #figure out earth's radius at radar's lat ... non-spherical earth model\\r\\n e2 = self.eccen # First eccentricity squared - WGS-84 value = 0.00669437999013\\r\\n a = self.Requator # Equatorial radius - WGS-84 value = 6378137.0\\r\\n Rearth = a/sqrt(1-e2*(sin(lat))**2) # radius of curvature\\r\\n \\r\\n # Inverse of eq. 2.28b in Doviak and Zrnic 1993\\r\\n # Inverse of eq. 2.28c in Doviak and Zrnic 1993\\r\\n\\r\\n Rprime = self.effectiveRadiusMultiplier * self.Requator\\r\\n\\r\\n s = array(groundRange, dtype='float64')\\r\\n\\r\\n h = Rprime * ( math.cos(theta) / math.cos( theta + s / Rprime) - 1)\\r\\n\\r\\n r = (Rprime + h) * math.sin(s / Rprime) / math.cos(theta);\\r\\n\\r\\n # Use law of cosines (Side-Angle-Side triangle theorem) with \\r\\n # R', R'+h as sides and s/R' as the angle to get slant range\\r\\n #r = sqrt(Rprime**2.0 + (Rprime+h)**2.0 - 2*(Rprime+h)*Rprime*cos(s/Rprime))\\r\\n # Will return NaN for r=0\\r\\n #el = arccos((Rprime+h) * sin(s/Rprime) / r) \\r\\n #el *= 180.0 / pi\\r\\n \\r\\n return r,h\",\n \"def manhattan_distance_between(start, destination):\\n return abs(destination.x - start.x) + abs(destination.y - start.y)\",\n \"def get_lat_offsets(self):\\n\\n startlat = self.parameters['startlatitude']\\n stoplat = self.parameters['stoplatitude']\\n\\n #Given the start and stops,\\n startidx, startvalue = utils.getnearest(self.latitudes, startlat)\\n stopidx, stopvalue = utils.getnearest(self.latitudes, stoplat)\\n startidx -= 2\\n stopidx += 2\\n latslice = np.arange(startidx, stopidx + 1)\\n if utils.checkmonotonic(latslice):\\n latslice = latslice\\n else:\\n #TODO: Support pole crossing images\\n logger.error('Image is pole crossing, not currently supported.')\\n '''\\n print \\\"NOT MONOTONIC\\\"\\n #Handle wraps around the poles\\n latslice = np.arange(start_idx, stop_idx + 1)\\n nlats = self.startlookup.shape[1]\\n greatermask = np.where(latslice >= nlats)\\n latslice[greatermask] -= nlats\\n lessmask = np.where(latslice < 0)\\n latslice[lessmask] += self.startlookup.shape[1]\\n\\n self.latsort = np.argsort(latslice)\\n self.latslice = latslice[self.latsort]\\n self.latsort = np.argsort(self.latsort)\\n '''\\n latslice = None\\n logger.debug('Start latitude node is {}. Nearest lookup node is {}.'.format(startlat, startidx))\\n logger.debug('Stop latitude node is {}. Nearest lookup node is {}.'.format(stoplat, stopidx))\\n return latslice\",\n \"def interval_distance(min_a: float, max_a: float, min_b: float, max_b: float):\\n return min_b - max_a if min_a < min_b else min_a - max_b\",\n \"def get_airport_start_end(result, geo_airport_cities):\\n crs={'init': 'epsg:4326'}\\n geometry_st = [Point(xy) for xy in zip(result.start_lon, result.start_lat)]\\n geometry_end = [Point(xy) for xy in zip(result.end_lon, result.end_lat)]\\n geo_st = gpd.GeoDataFrame(geometry_st, crs=crs, geometry=geometry_st)[['geometry']]\\n geo_end = gpd.GeoDataFrame(geometry_end, crs=crs, geometry=geometry_end)[['geometry']]\\n geo_st.crs = crs\\n geo_end.crs = crs\\n st_airport = pd.DataFrame(geo_st.within(geo_airport_cities['geometry'].unary_union.buffer(0.1)))\\n st_airport.index=result.index\\n result['geometry_st'] = st_airport\\n end_airport = pd.DataFrame(geo_end.within(geo_airport_cities['geometry'].unary_union.buffer(0.1)))\\n end_airport.index=result.index\\n result['geometry_end'] = end_airport\\n st_florence = pd.DataFrame(geo_st.within(geo_airport_cities['geometry'].loc[1].buffer(0.1)))\\n st_florence.index=result.index\\n result['geometry_st_fl'] = st_florence\\n end_florence = pd.DataFrame(geo_end.within(geo_airport_cities['geometry'].loc[1].buffer(0.1)))\\n end_florence.index=result.index\\n result['geometry_end_fl'] = end_florence\\n st_pisa = pd.DataFrame(geo_st.within(geo_airport_cities['geometry'].loc[0].buffer(0.1)))\\n st_pisa.index=result.index\\n result['geometry_st_pisa'] = st_pisa\\n end_pisa = pd.DataFrame(geo_end.within(geo_airport_cities['geometry'].loc[0].buffer(0.1)))\\n end_pisa.index=result.index\\n result['geometry_end_pisa'] = end_pisa\\n return result\",\n \"def fetchbounds(self):\\n pnts = [x for x in [self.out_start, self.start, self.in_start, \\\\\\n self.in_end, self.end, self.out_end] \\\\\\n if x is not None]\\n return min(pnts), max(pnts)\",\n \"def get_start_end_points(path, transect): \\n transect_array = np.genfromtxt(path + 'tran_sim_pts.csv', delimiter=\\\",\\\")\\n start_point = transect_array[2 * transect, :]\\n end_point = transect_array[2 * transect + 1, :]\\n \\n # force start points to be west of end points\\n if start_point[0] > end_point[0]:\\n previous_start_point = start_point\\n start_point = end_point\\n end_point = previous_start_point\\n return start_point, end_point\",\n \"def check_positions_in_range(self):\\n reachable = 0\\n total = 0\\n reachable, total = self.check_positions_in_range_for_list(reachable, total, self.close_positions_world)\\n reachable, total = self.check_positions_in_range_for_list(reachable, total, self.medium_positions_world)\\n reachable, total = self.check_positions_in_range_for_list(reachable, total, self.far_positions_world)\\n\\n return float(reachable) / float(total)\",\n \"def diff(start, end):\\n tz = timezone_sydney()\\n correction = tz.localize(end).utcoffset() - tz.localize(start).utcoffset()\\n return end - start + correction\",\n \"def altitude_profile(self, alt):\\n # checking if the units entered are km\\n if alt.unit == u.km:\\n if 150 <= alt.value < 500:\\n alt_properties = self._altitude_profile(500)\\n else:\\n alt_properties = self._altitude_profile(alt.value)\\n\\n return [last[int(alt.value)] for last in alt_properties]\",\n \"def get_bounds(self):\\n\\n northing=self.f.variables['y']\\n easting=self.f.variables['x']\\n\\n lat1,lon1 = utm.to_latlon(np.min(easting),np.min(northing),11,northern=True)\\n lat2,lon2 = utm.to_latlon(np.max(easting),np.max(northing),11,northern=True)\\n\\n return (lon1,lon2,lat1,lat2)\",\n \"def __calculate_input_ranges(diagonal_num: int, input_seq_len: int, output_seq_len: int):\\n min_len = min(input_seq_len, output_seq_len)\\n max_len = max(input_seq_len, output_seq_len)\\n assert 0 <= diagonal_num < min_len + max_len\\n\\n if diagonal_num < min_len:\\n max_range = (0, diagonal_num + 1)\\n min_range = max_range\\n elif diagonal_num < max_len:\\n max_range = (diagonal_num - (min_len - 1), diagonal_num + 1)\\n min_range = (0, min_len)\\n else:\\n max_range = (diagonal_num - (min_len - 1), max_len)\\n min_range = (diagonal_num - (max_len - 1), min_len)\\n\\n assert (max_range[1] - max_range[0]) == (min_range[1] - min_range[0])\\n assert max_len >= max_range[1] > max_range[0] >= 0\\n assert min_len >= min_range[1] > min_range[0] >= 0\\n\\n # determine which one is for the input and which one for the output\\n if min_len == input_seq_len: # the input (vertical) is shorter or of equal length to the output\\n input_range = min_range\\n output_range = max_range\\n else: # the output (horizontal) is shorter or of equal length to the input\\n input_range = max_range\\n output_range = min_range\\n\\n return input_range, output_range\",\n \"def pairwise_distance(self, start, end):\\n x1 = start[0]\\n y1 = start[1]\\n x2 = end[0]\\n y2 = end[1]\\n pairwise_dist = sqrt(((x2 - x1) * 10.29) ** 2 + ((y2 - y1) * 7.55) ** 2)\\n return pairwise_dist\",\n \"def data_range(self, n=-1):\\n if self.rotate and len(self.results['velocities']) > 1:\\n # Then we can use the last two velocities and time to extrapolate the line.\\n prevVel = self.results['velocities'][-2:]\\n prevTime = self.results['times'][-2:]\\n\\n coefficents = imageRot.computeFit(prevTime, prevVel)\\n nextCenter = imageRot.extrapolate(coefficents, self.time[self.time_index])\\n\\n velocity_index = self.spectrogram._velocity_to_index(nextCenter)\\n start_index = max(0, velocity_index - 2*self.span)\\n end_index = min(velocity_index + 2*self.span,\\n len(self.spectrogram.velocity))\\n \\n return start_index, end_index, coefficents\\n # Compute the angle.\\n if len(self.results['velocities']) > 0:\\n last_v = self.results['velocities'][n]\\n else:\\n last_v = self.v_start\\n velocity_index = self.spectrogram._velocity_to_index(last_v)\\n start_index = max(0, velocity_index - self.span)\\n end_index = min(velocity_index + self.span,\\n len(self.spectrogram.velocity))\\n return (start_index, end_index)\",\n \"def _calc_range(self) -> np.ndarray:\\n if self._is_ct25k():\\n range_resolution = 30\\n n_gates = 256\\n else:\\n n_gates = int(self.metadata[\\\"number_of_gates\\\"])\\n range_resolution = int(self.metadata[\\\"range_resolution\\\"])\\n return np.arange(n_gates) * range_resolution + range_resolution / 2\",\n \"def __len__(self):\\n return self.start.dist(self.end)\",\n \"def longest_flight(self):\\r\\n distance = 0\\r\\n for code, _list in self.edges.items():\\r\\n for edge in _list:\\r\\n if edge.distance > distance:\\r\\n distance = edge.distance\\r\\n start = edge.start\\r\\n destination = edge.destination\\r\\n return start, destination, distance\",\n \"def coords_in_range(self, anchor, steps):\\n coords = list()\\n x_low = -steps\\n x_high = steps\\n\\n #Generate using an axial formula to make it easier\\n #calculate z via the other two and throw away ones that aren't in bounds\\n for x in range(x_low, x_high+1):\\n for y in range(max(-steps, -x-steps), min(steps, -x+steps)+1):\\n z = -x - y\\n coords.append(anchor+self.coord(x, y, z))\\n return coords\",\n \"def check_altitude_at(self, altim, coords, altitude_bounds):\\n altitude = altim.mesh.point_altitude(coords)\\n self.assertWithin(altitude, *altitude_bounds)\",\n \"def extent(self, start=None, finish=None):\\n start, finish = self.bounds(start, finish)\\n try:\\n return finish - start + 1\\n except TypeError:\\n return None\",\n \"def extract_from_range(tgt_start, tgt_end, src_start, src_end, max_phrase_len):\\n # print(\\\"rages\\\", tgt_start, tgt_end, src_start, src_end)\\n if tgt_end < 0:\\n return \\n # If `src_align_idx` out of the `src_start` and `src_target`.\\n for src_align_idx, tgt_align_idx in alignment:\\n # target align point\\n # sorce align point out of range\\n if ((tgt_start <= tgt_align_idx <= tgt_end) and \\n (src_align_idx < src_start or src_align_idx > src_end)): \\n return\\n phrase_set = set()\\n ts = tgt_start # For increment\\n while True:\\n te = min(tgt_end, ts+max_phrase_len-1) # For decrement\\n # te = tgt_end \\n while True:\\n # Add phrase pair (src_start, src_end, tgt_start, tgt_end)\\n src_phrase = \\\" \\\".join(src_sent[i] for i in range(src_start,src_end+1))\\n tgt_phrase = \\\" \\\".join(tgt_sent[i] for i in range(ts,te+1))\\n phrase_set.add(((src_start, src_end+1), src_phrase, tgt_phrase))\\n te+= 1\\n # Add phrase until `te` aligned or out of range\\n if te in tgt_aligned or te == tgt_len:\\n break\\n ts-=1\\n # Add phrase until `te` aligned or out of range\\n if ts in tgt_aligned or ts < 0:\\n break\\n \\n return phrase_set\",\n \"def get_elevation_along_edge(self, from_, to):\\n pass\",\n \"def degree_range(n, start=0, end=180):\\n start_ = np.linspace(start, end, n+1, endpoint=True)[0:-1]\\n end_ = np.linspace(start, end, n+1, endpoint=True)[1::]\\n mid_points = start_ + ((end_-start_)/2.)\\n return np.c_[start_, end_], mid_points\",\n \"def getAngDist(ra1, dec1, ra2, dec2): \\n \\n delt_lon = (ra1 - ra2)*np.pi/180.\\n delt_lat = (dec1 - dec2)*np.pi/180.\\n # Haversine formula\\n dist = 2.0*np.arcsin( np.sqrt( np.sin(delt_lat/2.0)**2 + np.cos(dec1*np.pi/180.)*np.cos(dec2*np.pi/180.)*np.sin(delt_lon/2.0)**2 ) ) \\n\\n return dist/np.pi*180.\",\n \"def get_range(self) -> tuple[int, int]:\\n return self.range_from, self.range_to\",\n \"def _translate_range(self, len_, start, end):\\n start = int(start)\\n end = int(end)\\n if start < 0:\\n start += len_\\n start = max(0, min(start, len_))\\n if end < 0:\\n end += len_\\n end = max(-1, min(end, len_ - 1))\\n return start, end\",\n \"def get_range(cls, data: tuple or list) -> float:\\n cls._data_validation(data)\\n max_ = cls.get_max(data)\\n min_ = cls.get_min(data)\\n return float(max_ - min_)\",\n \"def get_kaalas(start_span, end_span, part_start, num_parts):\\n start_fraction = part_start / num_parts\\n end_fraction = (part_start + 1) / num_parts\\n\\n start_time = start_span + (end_span - start_span) * start_fraction\\n end_time = start_span + (end_span - start_span) * end_fraction\\n\\n return (start_time, end_time)\",\n \"def dist_from_goal( area ):\\r\\n dist = 99\\r\\n prev = goal_lkup[ 0 ]\\r\\n\\r\\n for cur in goal_lkup:\\r\\n #=============================================================\\r\\n # If the area is less than the currently selected area, but\\r\\n # greater then the previous area, then the distance is some\\r\\n # where in between. Then do linear interpolation\\r\\n #=============================================================\\r\\n if area > cur[ 'area' ] and area < prev[ 'area' ]:\\r\\n dist = lin_scale( area, cur[ 'area' ], cur[ 'dist ft' ], prev[ 'area' ], prev[ 'dist ft' ] )\\r\\n return dist\\r\\n prev = cur\\r\\n return dist\",\n \"def _get_elevation_percentage(height: float, distance: float) -> float:\\n return height / (distance * 1000)\",\n \"def get_range(lst):\\n return float(max(lst)) - float(min(lst))\",\n \"def manhattan_heuristic_cost(curr, end):\\n curr_x, curr_y = curr\\n end_x, end_y = end\\n return abs(curr_x-end_x) + abs(curr_y-end_y)\",\n \"def estimate(self, xDest, yDest):\\n dx = xDest - self.xPos\\n dy = yDest - self.yPos\\n # Euclidian Distance\\n d= np.sqrt(dx**2 + dy**2)\\n \\n # Octile Distance\\n #d = max(dx,dy)+.4*min(dx,dy)\\n \\n return(d)\",\n \"def get_range(self, start=None, end=None):\\n\\n # handle the case of no data\\n if self.data.shape[0] == 0 or self.source.data[\\\"index\\\"].shape[0] == 0:\\n return None, None\\n\\n first_source_idx = self.source.data[\\\"index\\\"][0]\\n last_source_idx = self.source.data[\\\"index\\\"][-1]\\n\\n # convert to timestamp if necessary\\n if isinstance(self.data.index, pd.DatetimeIndex):\\n start = pd.to_datetime(start, unit=\\\"ms\\\")\\n end = pd.to_datetime(end, unit=\\\"ms\\\")\\n first_source_idx = pd.to_datetime(first_source_idx, unit=\\\"ms\\\")\\n last_source_idx = pd.to_datetime(last_source_idx, unit=\\\"ms\\\")\\n\\n # get new start and end\\n if start is not None:\\n if start < first_source_idx:\\n start = max(self.data.index[0], start)\\n elif start > last_source_idx:\\n start = min(self.data.index[-1], start)\\n elif start < self.data.index[0]:\\n start = self.data.index[0]\\n elif start > self.data.index[-1]:\\n start = self.data.index[-1]\\n elif len(self.source.data[\\\"index\\\"]) > 0:\\n start = first_source_idx\\n else:\\n start = self.data.index[0]\\n\\n if end is not None:\\n if end < first_source_idx:\\n end = max(self.data.index[0], end)\\n elif end > last_source_idx:\\n end = min(self.data.index[-1], end)\\n elif end < self.data.index[0]:\\n end = self.data.index[0]\\n elif end > self.data.index[-1]:\\n end = self.data.index[-1]\\n elif len(self.source.data[\\\"index\\\"]) > 0:\\n end = last_source_idx\\n else:\\n end = self.data.index[-1]\\n\\n return start, end\",\n \"def nbhd_range(pt_list, dx_mat, dy_mat, tri, pt_dict, max_dist=None, calc_min_slope=None):\\n dxy_range=np.zeros([len(pt_list), 4])\\n if calc_min_slope is not None:\\n dxy_slope=np.zeros([len(pt_list), 2])\\n for row, pt in enumerate(pt_list):\\n neighbors=pt_dict[pt]\\n nbhd_pts=tri.points[neighbors,:]\\n this_pt=tri.points[pt,:]\\n if max_dist is not None:\\n dist2=(nbhd_pts[:,1]-this_pt[1])**2 + (nbhd_pts[:,0]-this_pt[0])**2\\n nbhd_pts=nbhd_pts[dist2 < max_dist**2,:]\\n if nbhd_pts is None or min(nbhd_pts.shape) < 1:\\n continue\\n dx_vals=np.append(np.array(dx_mat[nbhd_pts[:,1], nbhd_pts[:,0]]), dx_mat[this_pt[1], this_pt[0]])\\n dy_vals=np.append(np.array(dy_mat[nbhd_pts[:,1], nbhd_pts[:,0]]), dy_mat[this_pt[1], this_pt[0]])\\n if calc_min_slope is not None:\\n dist=np.sqrt((nbhd_pts[:,1]-this_pt[1])**2 + (nbhd_pts[:,0]-this_pt[0])**2)\\n dx_slope=np.abs(dx_vals[0:-1]-dx_vals[-1])/dist\\n dy_slope=np.abs(dy_vals[0:-1]-dy_vals[-1])/dist\\n dxy_slope[row,:]=[np.min(dx_slope), np.min(dy_slope)];\\n\\n dxy_range[row,[0,1]]=[np.min(dx_vals), np.max(dx_vals)]\\n dxy_range[row,[2,3]]=[np.min(dy_vals), np.max(dy_vals)]\\n if calc_min_slope is not None:\\n return dxy_range, dxy_slope\\n else:\\n return dxy_range ##, dxy_bar\",\n \"def _check_start_and_end_steps(self):\\n start_step = end_step = None\\n\\n if self.start_step is not None:\\n if hasattr(self, self.start_step):\\n start_step = getattr(self, self.start_step)\\n else:\\n raise ValueError(\\n \\\"start_step {0!r} not found\\\".format(\\n self.start_step))\\n\\n if self.end_step is not None:\\n if hasattr(self, self.end_step):\\n end_step = getattr(self, self.end_step)\\n else:\\n raise ValueError(\\n \\\"end_step {0!r} not found\\\".format(\\n self.end_step))\\n\\n return start_step, end_step\",\n \"def _calculate_h(self, end):\\n return PATH_COST * (abs(self.x - end.x) + abs(self.y - end.y))\",\n \"def cost(self, start_value, end_value):\\n cost = np.linalg.norm(start_value - end_value)\\n return cost\",\n \"def range(self) -> ty.Tuple[float, float]:\\r\\n ...\",\n \"def boundaries_end(*args):\\n return _ida_hexrays.boundaries_end(*args)\",\n \"def arc_tangents(amount, start, stop, truncated, sequence):\\n ratio = (start + stop) / 2\\n for x in range(start, amount):\\n y = abs(round(ratio * math.atan(x)))\\n if truncated and y >= stop:\\n sequence.append(stop)\\n elif y < start:\\n sequence.append(start)\\n else:\\n sequence.append(y)\\n return sequence\",\n \"def get_valid_fret_range(history, *, dist_range, guitar):\\n min_w = guitar.max_fret\\n max_w = guitar.min_fret\\n for fret in history:\\n min_w = min(min_w, fret)\\n max_w = max(max_w, fret)\\n min_x = max(max_w - dist_range, guitar.min_fret)\\n max_x = min(min_w + dist_range, guitar.max_fret)\\n return min_x, max_x\",\n \"def getGroundRangeHeight(self, r, elevationAngle):\\r\\n \\r\\n #Double precison arithmetic is crucial to proper operation.\\r\\n lat = self.ctrLat * pi / 180.0\\r\\n elev = array(elevationAngle * pi / 180.0, dtype='float64')\\r\\n slantr = array(r, dtype='float64')\\r\\n \\r\\n #figure out earth's radius at radar's lat ... non-spherical earth model\\r\\n e2 = self.eccen # First eccentricity squared - WGS-84 value = 0.00669437999013\\r\\n a = self.Requator # Equatorial radius - WGS-84 value = 6378137.0\\r\\n Rearth = a/sqrt(1-e2*(sin(lat))**2) # radius of curvature\\r\\n \\r\\n Rprime = self.effectiveRadiusMultiplier * self.Requator\\r\\n \\r\\n # Eqns 2.28b,c in Doviak and Zrnic 1993\\r\\n # Radar altitude is tacked on at the end, which isn't part of their derivation. At 100 km, it's \\r\\n # worth < 10 m range error total for a radar at 500 m MSL. For 250 m gate spacing (typical at S-band), \\r\\n # this is not too important.\\r\\n h = sqrt(slantr**2.0 + Rprime**2.0 + 2*slantr*Rprime*sin(elev)) - Rprime\\r\\n s = Rprime * arcsin( (slantr*cos(elev)) / (Rprime + h) )\\r\\n \\r\\n h += self.ctrAlt\\r\\n \\r\\n return s, h\",\n \"def latency_get_between(self, start, end):\\n\\n return self.__get_between(Latency, start, end)\",\n \"def walk_away_from_end(start, stop,\\n direction, walk=3):\\n if direction == \\\"+\\\":\\n # changed as this is the gene end\\n current_start = int(end)\\n current_end = int(end) + int(walk)\\n else:\\n assert direction == \\\"-\\\", \\\"direction does sign error!\\\"\\n current_end = start\\n current_start = int(start) - int(walk)\\n return current_start, current_end\",\n \"def calc_line(start, target, map):\\n\\t\\\"\\\"\\\" Returns the real world point at the farthest range \\\"\\\"\\\"\\n\\tdx = abs(target[0] - start[0])\\n\\tdy = abs(target[1] - start[1])\\n\\txi = start[0]\\n\\tyi = start[1]\\n\\tn = 1 + dx + dy\\n\\tx_dir = np.sign(target[0] - start[0])\\n\\ty_dir = np.sign(target[1] - start[1])\\n\\terror = dx - dy;\\n\\tdx *= 2\\n\\tdy *= 2\\n\\n\\tfor i in xrange(n):\\n\\t\\tif map.grid[xi,yi] is not map.empty and map.grid[xi,yi] > 0:\\n\\t\\t\\treturn xi, yi\\n\\n\\t\\tif error > 0:\\n\\t\\t\\txi += x_dir\\n\\t\\t\\terror -= dy\\n\\t\\telse:\\n\\t\\t\\tyi += y_dir\\n\\t\\t\\terror += dx\\n\\treturn target\",\n \"def compute_start_end_points(linestrings):\\n starts = []\\n stops = []\\n for ls in linestrings:\\n pt = Point(ls.coords[0])\\n starts.append(round(CONUS[\\\"poly\\\"].exterior.project(pt), 2))\\n pt = Point(ls.coords[-1])\\n stops.append(round(CONUS[\\\"poly\\\"].exterior.project(pt), 2))\\n return starts, stops\",\n \"def calc_overlap(self, start, stop):\\n\\n overlaps = []\\n for s in self.map:\\n e = self.map[s]\\n if s >= start or s <= stop:\\n # We found an overlap\\n if e <= stop:\\n overlaps.append({\\\"start\\\": s, \\\"stop\\\": e})\\n else:\\n overlaps.append({\\\"start\\\": s, \\\"stop\\\": stop})\\n elif e >= start or e <= stop:\\n if s >= start:\\n overlaps.append({\\\"start\\\": s, \\\"stop\\\": e})\\n else:\\n overlaps.append({\\\"start\\\": start, \\\"stop\\\": e})\\n return overlaps\",\n \"def air_range(self) -> Union[int, float]:\\n return self.air_weapon and self.air_weapon.range\",\n \"def travel_time(self, origin, destination):\\n assert 2 <= len(origin) <= 3, \\\"Origin should by (x, y) or (x, y, z)\\\"\\n assert 2 <= len(destination) <= 3, \\\"Origin should by (x, y) or (x, y, z)\\\"\\n assert len(origin) == len(destination), \\\"Elevation should be present in origin and destination or absent in both\\\"\\n if len(origin) == 2:\\n xo, yo = origin\\n xd, yd = destination\\n zo = zd = 0\\n else:\\n assert len(origin) == 3\\n xo, yo, zo = origin\\n xd, yd, zd = destination\\n\\n ground_distance = np.sqrt((xd-xo)**2 + (yd-yo)**2)\\n elevation_diff = zd - zo\\n if elevation_diff >= 0:\\n return max(ground_distance / self.max_airspeed, elevation_diff / self.max_rate_of_climb)\\n else:\\n return max(ground_distance / self.max_airspeed, -elevation_diff / self.max_rate_of_descent)\",\n \"def __calculate_average_distance(self):\\n game = self.__game # type: Game\\n all_icebergs = game.get_all_icebergs()\\n all_icebergs_length = len(all_icebergs)\\n sum_distances = 0\\n for i in range(all_icebergs_length):\\n for j in range(i + 1, all_icebergs_length):\\n iceberg1 = all_icebergs[i]\\n iceberg2 = all_icebergs[j]\\n sum_distances += iceberg1.get_turns_till_arrival(iceberg2)\\n\\n return sum_distances / (all_icebergs_length * (all_icebergs_length - 1) / 2)\",\n \"def distances_and_limits(road_map):\\n \\n distance_list = [math.sqrt((road_map[(i-1) % len(road_map)][3] - road_map[i][3])**2 + \\\\\\n (road_map[(i-1) % len(road_map)][2] - road_map[i][2])**2) \\\\\\n for i, city in enumerate(road_map)]\\n \\n lats_list = [road_map[i][2] for i, city in enumerate(road_map)]\\n longs_list = [road_map[i][3] for i, city in enumerate(road_map)]\\n \\n min_lat, max_lat = min(lats_list), max(lats_list)\\n min_long, max_long = min(longs_list), max(longs_list)\\n \\n if min_lat < -90 or max_lat > 90 or min_long < -180 or max_long > 180:\\n raise Exception(\\\"Please check the latitude and longitude values in your map.\\\")\\n else:\\n return distance_list, min_lat, max_lat, min_long, max_long\",\n \"def _center_distance(self):\\n # Split positions in segments of two points :\\n cut = np.vsplit(self.a_position, int(self.a_position.shape[0]/2))\\n # Get center position and starting line position :\\n center = np.mean(cut, axis=1)\\n\\n # ============ EUCLIDIAN DISTANCE ============\\n diff = np.sqrt(np.square(center[:, np.newaxis, :] - center).sum(2))\\n diff[np.tril_indices_from(diff)] = np.inf\\n\\n return center, diff\",\n \"def get_dec_i_range(data_decs):\\n data_dec_is = map_list(lambda x: (x - 1800)//10, data_decs)\\n lower_range_i = data_dec_is[0]\\n upper_range_i = data_dec_is[-1] + 1\\n return (lower_range_i, upper_range_i)\",\n \"def CalcGroundRange(numRxScanAngles, altitude, slantRanges):\\n GR_Arr = [] \\n for i in range(numRxScanAngles):\\n core_angle_arr = SEM.CoreAngle(altitude, slantRanges[i])\\n gr_arr = SEM.GroundRangeFromCoreAngle(core_angle_arr)\\n GR_Arr.append(gr_arr)\\n return GR_Arr\",\n \"def _find_break_points(self, start, end, num_classes):\\r\\n if start >= end:\\r\\n raise ValueError(\\\"Cannot find breakpoints because the starting \\\"\\r\\n \\\"point is greater than or equal to the ending \\\"\\r\\n \\\"point.\\\")\\r\\n if num_classes < 1:\\r\\n raise ValueError(\\\"Cannot have fewer than one distance class.\\\")\\r\\n\\r\\n width = (end - start) / num_classes\\r\\n break_points = [start + width * class_num\\r\\n for class_num in range(num_classes)]\\r\\n break_points.append(float(end))\\r\\n\\r\\n # Move the first breakpoint a little bit to the left. Machine epsilon\\r\\n # is taken from:\\r\\n # http://en.wikipedia.org/wiki/Machine_epsilon#\\r\\n # Approximation_using_Python\\r\\n epsilon = finfo(float).eps\\r\\n break_points[0] = break_points[0] - epsilon\\r\\n\\r\\n return break_points\",\n \"def get_dist_cost(data, start_node_id, end_node_id):\\n p1 = get_coords(data, start_node_id)\\n p2 = get_coords(data, end_node_id)\\n return great_circle_distance(p1, p2)\",\n \"def get_distance_metres(aLocation1, aLocation2):\\n [dNorth, dEast, dDown] = get_position_error(aLocation1, aLocation2)\\n \\n return math.sqrt((dNorth*dNorth) + (dEast*dEast))\",\n \"def getClosestMatch(start,end,lookup):\\n newStart = None\\n newEnd = None\\n for x in lookup.keys():\\n if x < start: \\n newStart = x\\n if x > end and newEnd == None: \\n newEnd = x\\n\\n if newStart != None:\\n return newStart, newEnd\\n else:\\n break\\n \\n if newStart == None and newEnd == None:\\n return 0,list(lookup.keys())[-1]\\n elif newStart == None: \\n return 0,newEnd\\n elif newEnd == None: \\n return newStart,list(lookup.keys())[-1]\\n else:\\n print(\\\"error occured in file execution should not have reached this \\\\\\n point, componentsExternSpacy.py getClosestMatch(start,end,lookup)\\\")\\n\\n return newStart, newEnd\",\n \"def learning_rate_range():\\n # Lower and upper bounds\\n #######\\n lower_bound = 0.1 \\n upper_bound = 1e-6\\n #######\\n return lower_bound, upper_bound\",\n \"def derive_features(self):\\n\\n temp = int(self.stop_id)\\n\\n while temp not in self.stops_latlon.keys():\\n if temp < 7692:\\n temp += 1\\n else:\\n while temp not in self.stops_latlon.keys():\\n temp -= 1\\n\\n self.latitude = self.stops_latlon[temp][0]\\n self.longitude = self.stops_latlon[temp][1]\\n\\n self.distance_centre = FormatInput.haversine(self.latitude, self.longitude)\\n\\n self.cluster = FormatInput.map_stop_to_cluster(self.cluster_map, self.stop_id)\\n\\n self.holiday = FormatInput.add_holiday(self.date)\",\n \"def get_all_map_info(start, end, transit_mode=None):\\n directions = find_directions(start, end, transit_mode)\\n distance = find_distance(start, end, transit_mode)\\n static_map = find_map(start, end)\\n return (distance, directions, static_map)\",\n \"def _calc_intervall_diff(i1, i2):\\n assert i1.overlaps(i2)\\n mi = max([i1.left, i2.left])\\n ma = min([i1.right, i2.right])\\n #return pd.Interval(mi, ma)\\n return ma-mi\",\n \"def _query_range_get(self):\\n return (self.query_start, self.query_end)\",\n \"def elapsed_raw(self, start=\\\"__enter__\\\", end=\\\"__exit__\\\"):\\n return self.laps[end] - self.laps[start]\",\n \"def set_cruise_altitudes(altitudes, cruise_indicies):\\n if cruise_indicies:\\n for index in range(0, len(cruise_indicies), 2):\\n start = cruise_indicies[index]\\n stop = cruise_indicies[index + 1]\\n if start < stop:\\n cruise_altitude = closest_cruising_altitude(altitudes[start])\\n altitudes[start] = cruise_altitude\\n altitudes[stop] = cruise_altitude\\n\\n return altitudes\",\n \"def line_segment_distance(start1, end1, start2, end2):\\n assert end1 >= start1\\n assert end2 >= start2\\n if start1 <= start2 <= end1:\\n return 0\\n elif start1 <= start2:\\n return start2 - end1\\n elif start2 <= start1 <= end2:\\n return 0\\n else:\\n return start1 - end2\",\n \"def speed_get_between(self, start, end):\\n\\n return self.__get_between(Speed, start, end)\",\n \"def calc_distance_efficiency(edgenode1: NodeID, edgenode2: NodeID, endnode: NodeID):\\n \\n (edgenode1_x, edgenode1_y) = G.nodes[edgenode1]['x'], G.nodes[edgenode1]['y']\\n (edgenode2_x, edgenode2_y) = G.nodes[edgenode2]['x'], G.nodes[edgenode2]['y']\\n (endnode_x, endnode_y) = G.nodes[endnode]['x'], G.nodes[endnode]['y']\\n \\n distance_edgenode1_edgenode2 = np.sqrt(np.square(edgenode1_x - edgenode2_x) + np.square(edgenode1_y - edgenode2_y))\\n distance_edgenode1_end = np.sqrt(np.square(edgenode1_x - endnode_x) + np.square(edgenode1_y - endnode_y))\\n distance_edgenode2_end = np.sqrt(np.square(endnode_x - edgenode2_x) + np.square(endnode_y - edgenode2_y))\\n\\n progress_to_end = distance_edgenode1_end - distance_edgenode2_end\\n \\n efficiency_calculation = (progress_to_end/distance_edgenode1_edgenode2)\\n return efficiency_calculation\",\n \"def _all_dist_to_end(args):\\n idx = args[0]\\n spiketrains = args[1]\\n start = args[2]\\n end = args[3]\\n N = args[4]\\n num_spiketrains = len(spiketrains)\\n distances = []\\n for jdx in range(idx+1, num_spiketrains):\\n dist = distance(spiketrains[idx], spiketrains[jdx], start, end, N)\\n times = dist[0] # should be the same for all\\n distances.append(dist[1])\\n return times, distances\",\n \"def compute_pair_bounds(self, edges, pair):\\n lower_bounds =[]\\n upper_bounds = []\\n for arc in edges:\\n l_e = self.arc_info[arc][\\\"lower_bound\\\"]\\n u_e = self.arc_info[arc][\\\"upper_bound\\\"]\\n f_mij = self.compute_f_mij(arc, pair)\\n lower_bounds.append(l_e - f_mij)\\n upper_bounds.append(u_e - f_mij)\\n lb = max(lower_bounds + [0])\\n # in case no edges in here, make max of 5,000\\n if len(upper_bounds) == 0:\\n i = pair[0]\\n j = pair[1]\\n print(\\\"Path i ({}): {}\\\".format(i, self.paths[i]))\\n print(\\\"Path j ({}): {}\\\".format(j, self.paths[j]))\\n ub = min(upper_bounds + [5000])\\n #print(\\\"lower bounds: {}\\\".format(lower_bounds))\\n #print(\\\"upper bounds: {}\\\".format(upper_bounds))\\n return(lb, ub)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7745811","0.5996923","0.58210236","0.5799497","0.5713338","0.57017654","0.56947106","0.5679401","0.5613159","0.5584916","0.5583578","0.55816114","0.5579437","0.54959893","0.54946244","0.5478117","0.5467547","0.5465406","0.54653704","0.54519516","0.54467183","0.543742","0.53594273","0.535325","0.5349753","0.5287857","0.5276015","0.5261266","0.5260135","0.52235526","0.5203186","0.5202706","0.51899993","0.5179157","0.51501936","0.51496494","0.51463526","0.5141662","0.5137718","0.5131263","0.51264435","0.5120787","0.5111962","0.5092981","0.5090294","0.5083267","0.5078139","0.50653577","0.50646603","0.50420845","0.5039895","0.5039285","0.50334597","0.5030064","0.5027244","0.5015813","0.5014896","0.5007282","0.49976683","0.4978444","0.49637294","0.49629086","0.49624097","0.49618217","0.49600986","0.49549875","0.49424595","0.49408284","0.49299997","0.4927233","0.491997","0.49051505","0.48988226","0.48916793","0.48905307","0.48899263","0.48845378","0.48824677","0.48772454","0.48766744","0.487133","0.4870979","0.48683977","0.48650664","0.48635107","0.48622316","0.48613083","0.48539296","0.48511246","0.48503703","0.48502815","0.48492536","0.48490995","0.4845194","0.48437327","0.48428592","0.48400933","0.48335227","0.48330098","0.483198"],"string":"[\n \"0.7745811\",\n \"0.5996923\",\n \"0.58210236\",\n \"0.5799497\",\n \"0.5713338\",\n \"0.57017654\",\n \"0.56947106\",\n \"0.5679401\",\n \"0.5613159\",\n \"0.5584916\",\n \"0.5583578\",\n \"0.55816114\",\n \"0.5579437\",\n \"0.54959893\",\n \"0.54946244\",\n \"0.5478117\",\n \"0.5467547\",\n \"0.5465406\",\n \"0.54653704\",\n \"0.54519516\",\n \"0.54467183\",\n \"0.543742\",\n \"0.53594273\",\n \"0.535325\",\n \"0.5349753\",\n \"0.5287857\",\n \"0.5276015\",\n \"0.5261266\",\n \"0.5260135\",\n \"0.52235526\",\n \"0.5203186\",\n \"0.5202706\",\n \"0.51899993\",\n \"0.5179157\",\n \"0.51501936\",\n \"0.51496494\",\n \"0.51463526\",\n \"0.5141662\",\n \"0.5137718\",\n \"0.5131263\",\n \"0.51264435\",\n \"0.5120787\",\n \"0.5111962\",\n \"0.5092981\",\n \"0.5090294\",\n \"0.5083267\",\n \"0.5078139\",\n \"0.50653577\",\n \"0.50646603\",\n \"0.50420845\",\n \"0.5039895\",\n \"0.5039285\",\n \"0.50334597\",\n \"0.5030064\",\n \"0.5027244\",\n \"0.5015813\",\n \"0.5014896\",\n \"0.5007282\",\n \"0.49976683\",\n \"0.4978444\",\n \"0.49637294\",\n \"0.49629086\",\n \"0.49624097\",\n \"0.49618217\",\n \"0.49600986\",\n \"0.49549875\",\n \"0.49424595\",\n \"0.49408284\",\n \"0.49299997\",\n \"0.4927233\",\n \"0.491997\",\n \"0.49051505\",\n \"0.48988226\",\n \"0.48916793\",\n \"0.48905307\",\n \"0.48899263\",\n \"0.48845378\",\n \"0.48824677\",\n \"0.48772454\",\n \"0.48766744\",\n \"0.487133\",\n \"0.4870979\",\n \"0.48683977\",\n \"0.48650664\",\n \"0.48635107\",\n \"0.48622316\",\n \"0.48613083\",\n \"0.48539296\",\n \"0.48511246\",\n \"0.48503703\",\n \"0.48502815\",\n \"0.48492536\",\n \"0.48490995\",\n \"0.4845194\",\n \"0.48437327\",\n \"0.48428592\",\n \"0.48400933\",\n \"0.48335227\",\n \"0.48330098\",\n \"0.483198\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.912184"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":91984,"cells":{"query":{"kind":"string","value":"Determine the index of the top of climb altitude. Returns The index of the first cruising altitude."},"document":{"kind":"string","value":"def top_of_climb_index(self):\n return self.altitudes.argmax()"},"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 top_of_descent_index(self):\n tod = self.altitudes.argmax()\n # if the altitude profile is not just a climb\n # and there is a cruising section\n if (tod < len(self.altitudes) - 1) and \\\n (self.altitudes[tod] == self.altitudes[tod + 1]):\n tod += 1\n\n return tod","def alt_index(self) -> Optional[int]:\n if not self.is_hom_alt():\n return None\n return max(self.allele1, self.allele2) - 1","def top_of_climb_distance(self):\n return self.distances[self.top_of_climb_index()]","def top_offset(self):\n raise NotImplementedError","def top(self):\n return self.get_cards()[-1]","def top(self):\n return self.a[-1]","def top_distance(self):\n return self.y","def get_index_of_surface_gate(data, setup={}):\n alts = data['alt']\n return np.argmin(np.abs(alts), 1)","def top_ele(self):\n if not self.is_empty():\n return self.arr[self.top]\n return -1","def top(self) -> int:\n return self.topvalue","def get_topmost_visible() -> int:\n prev_lineno = ui_content.line_count - 1\n used_height = 0\n for lineno in range(ui_content.line_count - 1, -1, -1):\n used_height += get_line_height(lineno)\n if used_height > height:\n return prev_lineno\n else:\n prev_lineno = lineno\n return prev_lineno","def _get_out_of_screen_item_loc_prev(self):\n\n new_loc = self.page_current.item_onscreenlocs[self.page_current.item_selected] - self.terminal_height\n closest_item_index = self._get_index_closest_val(self.page_current.item_onscreenlocs, new_loc)\n\n return closest_item_index","def top(self) -> int:\n return self.topEle","def top(state):\n if len(state[STACK]) <= 0:\n return -1\n else:\n return state[STACK][-1]","def get_main_array_top(self):\n return self.bitcell_array_inst.uy()","def get_topBlock(self):\n return self.blocks[len(self.blocks)-1]","def top(self) -> int:\n return self.q1[-1]","def altitude(self):\n if self.__altitude:\n return sum(self.__altitude) / len(self.__altitude)\n else:\n return -9999","def current_cover_position(self):\n state = self.channel_data.get(\"state\")\n if state:\n return 100 - state[\"shut\"]\n return None","def top(self):\n return self.arr[-1]","def top(self) -> float:\n points = self.get_adjusted_points()\n y_points = [point[1] for point in points]\n return max(y_points)","def get_card_at_top_index(deck):\n \n small_joker_value = get_small_joker_value(deck)\n if deck[0] == get_big_joker_value(deck):\n return deck[get_small_joker_value(deck)]\n else:\n return deck[deck[0]]","def top(self) -> int:\n return self._deque[0]","def top(self):\n return self.points['topRight'].y","def top(self):\n return self.points['topRight'].y","def top(self) -> int:\n return self.q[0]","def top(self) -> int:\n return self.q[0]","def top(self) -> int:\n return self.q[0]","def Ethanol(self) -> int:\n return self.raw_measure()[1]","def table_top_abs(self):\n table_height = np.array([0, 0, self.table_full_size[2]])\n return string_to_array(self.floor.get(\"pos\")) + table_height","def last_low(self):\n return self.data.last('1D').low.iat[0]","def get_card_at_top_index(deck: List[int]) -> int:\n top_card = deck[0]\n\n if top_card == max(deck):\n top_card = get_small_joker_value(deck)\n keystream = deck[top_card]\n else:\n keystream = deck[top_card]\n\n return keystream","def get_latest_locant(self):\n return self._next_locant - 1","def altitude(self) -> int:\n return self._point.altitude","def top_layer(self):\n return self._top","def closest_cruising_altitude(altitude):\n return 1000 * ((altitude + 500) // 1000)","def looks_azimuth(self) -> Optional[int]:\n return self._get_property(LOOKS_AZIMUTH_PROP, int)","def top(self) -> int:\n return self.stack[-1]","def top(self) -> int:\n return self.stack[-1]","def east_index(self, index):\n # Add a check for the edge of the board\n if index % self.size == self.size - 1:\n # Indices of < 0 are filtered out in cardinal_indices()\n return -1\n else:\n return index + 1","def getExceedingBoxTop(self):\n return self.exceedingBoxTop","def top_left_tile_value(self):\n\t\treturn 1","def top(self):\n # type: () -> float\n return self._top","def get_top_cheese(self, index):\n if len(self._stools[index]) == 0:\n return None\n else:\n cheese = self._stools[index][-1]\n return cheese","def peek(self) -> int:\n\t\treturn self.s1[-1]","def top(self):\n \n assert not self.empty()\n return self._s[-1]","def bb_top(self) -> float:\n return self._bb_top","def top_of_descent_distance(self):\n return self.distances[self.top_of_descent_index()]","def top(self):\n return self[0]","def _index(self) -> int:\n return -1","def Front(self) -> int:\n return self.circular[self.front] if self.size else -1\n # if self.size:\n # return self.cicular[self.front]\n # else:\n # return -1","def get_oldest_neuron(self):\n\t\tassert self.check_tabu_list\n\t\tif (float(\"inf\") in self._tabu_list):\n\t\t\treturn self._tabu_list.index(float(\"inf\"))\n\t\tnumIter = min(self._tabu_list)\n\t\treturn self._tabu_list.index(numIter)","def north_index(self, index):\n return index - self.size","def get_cloc(self):\n return self.order_hist[-1]","def peek(self, index):\n x = -1\n if (self.top - index + 1) < 0:\n print(\"Invalid Index\")\n else:\n x = self.arr[self.top - index + 1]\n return x","def _get_start_render_index(self):\n\n for ol in self.overlay_list[-1::-1]:\n # FIXME There may be even no 'label' in a label's name, so we need use other method to recognize a label.\n if \"label\" not in ol.get_name() and ol.get_alpha() == 1. and ol.is_visible()\\\n and ol.get_min() <= np.min(ol.get_data()):\n return self.overlay_list.index(ol)\n\n # 0 means that the render will start with the bottom overlay.\n return 0","def get_nearest_row(self):\n return (self.rect.top - (self.screen.get_height() // 12)) // self.maze.block_size","def get_top_cell(self):\n return self._top_cell","def _first_leg(self, instrument):\n if instrument.InsType() == 'CurrSwap':\n for leg in instrument.Legs():\n if leg.IsFixedLeg() and leg.Currency().Name() == 'ZAR':\n return leg\n else:\n return None\n return instrument.FirstFloatLeg()","def find_unsettled_spot(self):\n\t\tfor i in range(9):\n\t\t\tfor j in range(9):\n\t\t\t\tif self.grid[i][j] == 0:\n\t\t\t\t\treturn i, j\n\t\treturn","def getLimbIndex(self):\n\n data = self.name.split('-')\n return int(data[1]) - 1","def top(self) -> int:\n last = self.pop()\n self.push(last)\n return last","def peek(self) -> int:\r\n return self.items[0]","def top_y(self):\r\n return self.position.y + self.size.y + self.bulk","def get_replica_top(self):\n return self.dummy_row_insts[0].by()","def bottom(self) -> float:\n bottom = 0\n for part in self.line_parts:\n if part.state.rise < 0 and -part.state.rise > bottom:\n bottom = -part.state.rise\n return bottom","def current_cover_position(self) -> int:\n return int(self._value)","def top(self):\r\n\r\n if self.is_empty():\r\n pass\r\n\r\n else:\r\n return self._data[0]","def last_pos(self):\n return self.locs[self.indices[-1], 2:4]","def GetFirstLocationIndex(self):\n regionVectorData = self.VectorData[self.SelectedRegion]\n return regionVectorData['FirstLocationIndex']","def get_top_discard_card(self):\n discard_pile_index = len(self.discard_pile) - 1\n return self.discard_pile[discard_pile_index]","def min_offset(self):\n return self.offset","def top_or_down():\n ct = random.randint(1,2)\n if (ct == 1):\n return 1\n else:\n return -1","def _get_out_of_screen_item_loc_next(self):\n\n new_loc = self.page_current.item_onscreenlocs[self.page_current.item_selected] + self.terminal_height + 1\n closest_item_index = self._get_index_closest_val(self.page_current.item_onscreenlocs, new_loc)\n\n return closest_item_index","def getFront(self) -> int:\n return self._deque[(self._front - 1)%self._k] if not self.isEmpty() else -1","def current_cup_idx(self):\n return self.cups.index(self.current_cup)","def current_cover_position(self) -> int:\n return self._device[\"current_state\"]","def top(self) -> object:\n return self._data[-1]","def top(self) -> object:\n return self._data[-1]","def top_right_tile_value(self):\n\t\treturn self.expected_cols","def get_closest_interest_amortization(self):\n differences = [abs(self.table[\"interest\"][i] - self.table[\"amortization\"][i])\\\n for i in self.table[\"index\"][1:]]\n min_diff = min(differences)\n return differences.index(min_diff) + 1","def get_nearest_col(self):\n return (self.rect.left - (self.screen.get_width() // 5)) // self.maze.block_size","def baseline_eCO2(self) -> int:\n return self.get_iaq_baseline()[0]","def find_exit_position(labyrinth: Labyrinth) -> Tuple[int, int]:\n return labyrinth.get_exit_position()","def getLowerBound(self) -> int:\n return self.lower_bound","def getFront(self) -> int:\n if self.isEmpty():\n return -1\n\n return self.arr[self.front]","def y(self):\n return self.top","def bottom_left_tile_value(self):\n\t\treturn self.expected_cols * (self.expected_rows - 1) + 1","def top(self):\n print(self.arr[-1])","def getMin(self) -> int:\n return self.minStack[-1]","def top(self):\r\n return self.topele","def top(self):\n return self._top","def top(self):\n return self._top","def getLPos(self):\n c = 0\n while c <= ALIENS_IN_ROW-1:\n i = 0\n for a in range(ALIEN_ROWS):\n if self._aliens[a][c] != None:\n return self._aliens[a][c].x - ALIEN_WIDTH/2\n else:\n i +=1\n if i == ALIEN_ROWS:\n c +=1","def best_B(Ag):\n top = 0\n for i in range(len(Ag)):\n etop = np.min(cf.TD20[int(Ag[i]) - 1])\n top += etop\n return top","def getFront(self) -> int:\n if not self.isEmpty():\n return self.q[self.move_forward(self.front)]\n else:\n return -1","def break_index(self, **kwargs):\n return self.peak_indices(**kwargs)[0][-1]","def locus_start(self):\n return int(open(self.locus_file).read().split('\\t')[3])","def get_card_at_top_index(deck_of_cards):\n big_joker_value = get_big_joker_value(deck_of_cards)\n small_joker_value = get_small_joker_value(deck_of_cards)\n first_card = deck_of_cards[0]\n \n if first_card == big_joker_value:\n return deck_of_cards[small_joker_value]\n else:\n return deck_of_cards[first_card]\n # Consideres two cases where if the first_card is big_joker_value then \n # the card that has the index small_joker_value is returned. Else it will \n # return the card that has the index of the first_card.","def getAbsoluteTop(self):\n return self.canvas.getAbsoluteTop()"],"string":"[\n \"def top_of_descent_index(self):\\n tod = self.altitudes.argmax()\\n # if the altitude profile is not just a climb\\n # and there is a cruising section\\n if (tod < len(self.altitudes) - 1) and \\\\\\n (self.altitudes[tod] == self.altitudes[tod + 1]):\\n tod += 1\\n\\n return tod\",\n \"def alt_index(self) -> Optional[int]:\\n if not self.is_hom_alt():\\n return None\\n return max(self.allele1, self.allele2) - 1\",\n \"def top_of_climb_distance(self):\\n return self.distances[self.top_of_climb_index()]\",\n \"def top_offset(self):\\n raise NotImplementedError\",\n \"def top(self):\\n return self.get_cards()[-1]\",\n \"def top(self):\\n return self.a[-1]\",\n \"def top_distance(self):\\n return self.y\",\n \"def get_index_of_surface_gate(data, setup={}):\\n alts = data['alt']\\n return np.argmin(np.abs(alts), 1)\",\n \"def top_ele(self):\\n if not self.is_empty():\\n return self.arr[self.top]\\n return -1\",\n \"def top(self) -> int:\\n return self.topvalue\",\n \"def get_topmost_visible() -> int:\\n prev_lineno = ui_content.line_count - 1\\n used_height = 0\\n for lineno in range(ui_content.line_count - 1, -1, -1):\\n used_height += get_line_height(lineno)\\n if used_height > height:\\n return prev_lineno\\n else:\\n prev_lineno = lineno\\n return prev_lineno\",\n \"def _get_out_of_screen_item_loc_prev(self):\\n\\n new_loc = self.page_current.item_onscreenlocs[self.page_current.item_selected] - self.terminal_height\\n closest_item_index = self._get_index_closest_val(self.page_current.item_onscreenlocs, new_loc)\\n\\n return closest_item_index\",\n \"def top(self) -> int:\\n return self.topEle\",\n \"def top(state):\\n if len(state[STACK]) <= 0:\\n return -1\\n else:\\n return state[STACK][-1]\",\n \"def get_main_array_top(self):\\n return self.bitcell_array_inst.uy()\",\n \"def get_topBlock(self):\\n return self.blocks[len(self.blocks)-1]\",\n \"def top(self) -> int:\\n return self.q1[-1]\",\n \"def altitude(self):\\n if self.__altitude:\\n return sum(self.__altitude) / len(self.__altitude)\\n else:\\n return -9999\",\n \"def current_cover_position(self):\\n state = self.channel_data.get(\\\"state\\\")\\n if state:\\n return 100 - state[\\\"shut\\\"]\\n return None\",\n \"def top(self):\\n return self.arr[-1]\",\n \"def top(self) -> float:\\n points = self.get_adjusted_points()\\n y_points = [point[1] for point in points]\\n return max(y_points)\",\n \"def get_card_at_top_index(deck):\\n \\n small_joker_value = get_small_joker_value(deck)\\n if deck[0] == get_big_joker_value(deck):\\n return deck[get_small_joker_value(deck)]\\n else:\\n return deck[deck[0]]\",\n \"def top(self) -> int:\\n return self._deque[0]\",\n \"def top(self):\\n return self.points['topRight'].y\",\n \"def top(self):\\n return self.points['topRight'].y\",\n \"def top(self) -> int:\\n return self.q[0]\",\n \"def top(self) -> int:\\n return self.q[0]\",\n \"def top(self) -> int:\\n return self.q[0]\",\n \"def Ethanol(self) -> int:\\n return self.raw_measure()[1]\",\n \"def table_top_abs(self):\\n table_height = np.array([0, 0, self.table_full_size[2]])\\n return string_to_array(self.floor.get(\\\"pos\\\")) + table_height\",\n \"def last_low(self):\\n return self.data.last('1D').low.iat[0]\",\n \"def get_card_at_top_index(deck: List[int]) -> int:\\n top_card = deck[0]\\n\\n if top_card == max(deck):\\n top_card = get_small_joker_value(deck)\\n keystream = deck[top_card]\\n else:\\n keystream = deck[top_card]\\n\\n return keystream\",\n \"def get_latest_locant(self):\\n return self._next_locant - 1\",\n \"def altitude(self) -> int:\\n return self._point.altitude\",\n \"def top_layer(self):\\n return self._top\",\n \"def closest_cruising_altitude(altitude):\\n return 1000 * ((altitude + 500) // 1000)\",\n \"def looks_azimuth(self) -> Optional[int]:\\n return self._get_property(LOOKS_AZIMUTH_PROP, int)\",\n \"def top(self) -> int:\\n return self.stack[-1]\",\n \"def top(self) -> int:\\n return self.stack[-1]\",\n \"def east_index(self, index):\\n # Add a check for the edge of the board\\n if index % self.size == self.size - 1:\\n # Indices of < 0 are filtered out in cardinal_indices()\\n return -1\\n else:\\n return index + 1\",\n \"def getExceedingBoxTop(self):\\n return self.exceedingBoxTop\",\n \"def top_left_tile_value(self):\\n\\t\\treturn 1\",\n \"def top(self):\\n # type: () -> float\\n return self._top\",\n \"def get_top_cheese(self, index):\\n if len(self._stools[index]) == 0:\\n return None\\n else:\\n cheese = self._stools[index][-1]\\n return cheese\",\n \"def peek(self) -> int:\\n\\t\\treturn self.s1[-1]\",\n \"def top(self):\\n \\n assert not self.empty()\\n return self._s[-1]\",\n \"def bb_top(self) -> float:\\n return self._bb_top\",\n \"def top_of_descent_distance(self):\\n return self.distances[self.top_of_descent_index()]\",\n \"def top(self):\\n return self[0]\",\n \"def _index(self) -> int:\\n return -1\",\n \"def Front(self) -> int:\\n return self.circular[self.front] if self.size else -1\\n # if self.size:\\n # return self.cicular[self.front]\\n # else:\\n # return -1\",\n \"def get_oldest_neuron(self):\\n\\t\\tassert self.check_tabu_list\\n\\t\\tif (float(\\\"inf\\\") in self._tabu_list):\\n\\t\\t\\treturn self._tabu_list.index(float(\\\"inf\\\"))\\n\\t\\tnumIter = min(self._tabu_list)\\n\\t\\treturn self._tabu_list.index(numIter)\",\n \"def north_index(self, index):\\n return index - self.size\",\n \"def get_cloc(self):\\n return self.order_hist[-1]\",\n \"def peek(self, index):\\n x = -1\\n if (self.top - index + 1) < 0:\\n print(\\\"Invalid Index\\\")\\n else:\\n x = self.arr[self.top - index + 1]\\n return x\",\n \"def _get_start_render_index(self):\\n\\n for ol in self.overlay_list[-1::-1]:\\n # FIXME There may be even no 'label' in a label's name, so we need use other method to recognize a label.\\n if \\\"label\\\" not in ol.get_name() and ol.get_alpha() == 1. and ol.is_visible()\\\\\\n and ol.get_min() <= np.min(ol.get_data()):\\n return self.overlay_list.index(ol)\\n\\n # 0 means that the render will start with the bottom overlay.\\n return 0\",\n \"def get_nearest_row(self):\\n return (self.rect.top - (self.screen.get_height() // 12)) // self.maze.block_size\",\n \"def get_top_cell(self):\\n return self._top_cell\",\n \"def _first_leg(self, instrument):\\n if instrument.InsType() == 'CurrSwap':\\n for leg in instrument.Legs():\\n if leg.IsFixedLeg() and leg.Currency().Name() == 'ZAR':\\n return leg\\n else:\\n return None\\n return instrument.FirstFloatLeg()\",\n \"def find_unsettled_spot(self):\\n\\t\\tfor i in range(9):\\n\\t\\t\\tfor j in range(9):\\n\\t\\t\\t\\tif self.grid[i][j] == 0:\\n\\t\\t\\t\\t\\treturn i, j\\n\\t\\treturn\",\n \"def getLimbIndex(self):\\n\\n data = self.name.split('-')\\n return int(data[1]) - 1\",\n \"def top(self) -> int:\\n last = self.pop()\\n self.push(last)\\n return last\",\n \"def peek(self) -> int:\\r\\n return self.items[0]\",\n \"def top_y(self):\\r\\n return self.position.y + self.size.y + self.bulk\",\n \"def get_replica_top(self):\\n return self.dummy_row_insts[0].by()\",\n \"def bottom(self) -> float:\\n bottom = 0\\n for part in self.line_parts:\\n if part.state.rise < 0 and -part.state.rise > bottom:\\n bottom = -part.state.rise\\n return bottom\",\n \"def current_cover_position(self) -> int:\\n return int(self._value)\",\n \"def top(self):\\r\\n\\r\\n if self.is_empty():\\r\\n pass\\r\\n\\r\\n else:\\r\\n return self._data[0]\",\n \"def last_pos(self):\\n return self.locs[self.indices[-1], 2:4]\",\n \"def GetFirstLocationIndex(self):\\n regionVectorData = self.VectorData[self.SelectedRegion]\\n return regionVectorData['FirstLocationIndex']\",\n \"def get_top_discard_card(self):\\n discard_pile_index = len(self.discard_pile) - 1\\n return self.discard_pile[discard_pile_index]\",\n \"def min_offset(self):\\n return self.offset\",\n \"def top_or_down():\\n ct = random.randint(1,2)\\n if (ct == 1):\\n return 1\\n else:\\n return -1\",\n \"def _get_out_of_screen_item_loc_next(self):\\n\\n new_loc = self.page_current.item_onscreenlocs[self.page_current.item_selected] + self.terminal_height + 1\\n closest_item_index = self._get_index_closest_val(self.page_current.item_onscreenlocs, new_loc)\\n\\n return closest_item_index\",\n \"def getFront(self) -> int:\\n return self._deque[(self._front - 1)%self._k] if not self.isEmpty() else -1\",\n \"def current_cup_idx(self):\\n return self.cups.index(self.current_cup)\",\n \"def current_cover_position(self) -> int:\\n return self._device[\\\"current_state\\\"]\",\n \"def top(self) -> object:\\n return self._data[-1]\",\n \"def top(self) -> object:\\n return self._data[-1]\",\n \"def top_right_tile_value(self):\\n\\t\\treturn self.expected_cols\",\n \"def get_closest_interest_amortization(self):\\n differences = [abs(self.table[\\\"interest\\\"][i] - self.table[\\\"amortization\\\"][i])\\\\\\n for i in self.table[\\\"index\\\"][1:]]\\n min_diff = min(differences)\\n return differences.index(min_diff) + 1\",\n \"def get_nearest_col(self):\\n return (self.rect.left - (self.screen.get_width() // 5)) // self.maze.block_size\",\n \"def baseline_eCO2(self) -> int:\\n return self.get_iaq_baseline()[0]\",\n \"def find_exit_position(labyrinth: Labyrinth) -> Tuple[int, int]:\\n return labyrinth.get_exit_position()\",\n \"def getLowerBound(self) -> int:\\n return self.lower_bound\",\n \"def getFront(self) -> int:\\n if self.isEmpty():\\n return -1\\n\\n return self.arr[self.front]\",\n \"def y(self):\\n return self.top\",\n \"def bottom_left_tile_value(self):\\n\\t\\treturn self.expected_cols * (self.expected_rows - 1) + 1\",\n \"def top(self):\\n print(self.arr[-1])\",\n \"def getMin(self) -> int:\\n return self.minStack[-1]\",\n \"def top(self):\\r\\n return self.topele\",\n \"def top(self):\\n return self._top\",\n \"def top(self):\\n return self._top\",\n \"def getLPos(self):\\n c = 0\\n while c <= ALIENS_IN_ROW-1:\\n i = 0\\n for a in range(ALIEN_ROWS):\\n if self._aliens[a][c] != None:\\n return self._aliens[a][c].x - ALIEN_WIDTH/2\\n else:\\n i +=1\\n if i == ALIEN_ROWS:\\n c +=1\",\n \"def best_B(Ag):\\n top = 0\\n for i in range(len(Ag)):\\n etop = np.min(cf.TD20[int(Ag[i]) - 1])\\n top += etop\\n return top\",\n \"def getFront(self) -> int:\\n if not self.isEmpty():\\n return self.q[self.move_forward(self.front)]\\n else:\\n return -1\",\n \"def break_index(self, **kwargs):\\n return self.peak_indices(**kwargs)[0][-1]\",\n \"def locus_start(self):\\n return int(open(self.locus_file).read().split('\\\\t')[3])\",\n \"def get_card_at_top_index(deck_of_cards):\\n big_joker_value = get_big_joker_value(deck_of_cards)\\n small_joker_value = get_small_joker_value(deck_of_cards)\\n first_card = deck_of_cards[0]\\n \\n if first_card == big_joker_value:\\n return deck_of_cards[small_joker_value]\\n else:\\n return deck_of_cards[first_card]\\n # Consideres two cases where if the first_card is big_joker_value then \\n # the card that has the index small_joker_value is returned. Else it will \\n # return the card that has the index of the first_card.\",\n \"def getAbsoluteTop(self):\\n return self.canvas.getAbsoluteTop()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.82650274","0.6586973","0.64087886","0.63747007","0.63523763","0.62209785","0.60802037","0.6078412","0.60293245","0.60026336","0.59891087","0.5984468","0.5980566","0.5978508","0.5973972","0.59719825","0.59692377","0.5964401","0.59599084","0.59111434","0.5883518","0.58755785","0.58472216","0.584409","0.584409","0.5842175","0.5842175","0.5842175","0.5835824","0.5816697","0.5809029","0.5780798","0.57749337","0.5770715","0.5767951","0.5764992","0.5751041","0.57373923","0.57373923","0.57299334","0.5726278","0.5700171","0.56991965","0.56881744","0.56770676","0.5666969","0.56398016","0.5635197","0.56257457","0.5613407","0.5612584","0.56099904","0.56061685","0.56021315","0.5588243","0.55795556","0.5579152","0.5576609","0.5573737","0.55697036","0.5548449","0.5541025","0.55142874","0.55125","0.551017","0.5501556","0.5500096","0.5484236","0.54833245","0.5471361","0.54693896","0.5466805","0.546574","0.5461442","0.545633","0.54551744","0.545123","0.54510236","0.54510236","0.5449476","0.54471874","0.5432562","0.54295737","0.54235035","0.5419193","0.5407668","0.5407594","0.5405298","0.5405145","0.5402779","0.5388023","0.53872496","0.53872496","0.5383778","0.53827983","0.5376413","0.5372327","0.53722143","0.537186","0.53632414"],"string":"[\n \"0.82650274\",\n \"0.6586973\",\n \"0.64087886\",\n \"0.63747007\",\n \"0.63523763\",\n \"0.62209785\",\n \"0.60802037\",\n \"0.6078412\",\n \"0.60293245\",\n \"0.60026336\",\n \"0.59891087\",\n \"0.5984468\",\n \"0.5980566\",\n \"0.5978508\",\n \"0.5973972\",\n \"0.59719825\",\n \"0.59692377\",\n \"0.5964401\",\n \"0.59599084\",\n \"0.59111434\",\n \"0.5883518\",\n \"0.58755785\",\n \"0.58472216\",\n \"0.584409\",\n \"0.584409\",\n \"0.5842175\",\n \"0.5842175\",\n \"0.5842175\",\n \"0.5835824\",\n \"0.5816697\",\n \"0.5809029\",\n \"0.5780798\",\n \"0.57749337\",\n \"0.5770715\",\n \"0.5767951\",\n \"0.5764992\",\n \"0.5751041\",\n \"0.57373923\",\n \"0.57373923\",\n \"0.57299334\",\n \"0.5726278\",\n \"0.5700171\",\n \"0.56991965\",\n \"0.56881744\",\n \"0.56770676\",\n \"0.5666969\",\n \"0.56398016\",\n \"0.5635197\",\n \"0.56257457\",\n \"0.5613407\",\n \"0.5612584\",\n \"0.56099904\",\n \"0.56061685\",\n \"0.56021315\",\n \"0.5588243\",\n \"0.55795556\",\n \"0.5579152\",\n \"0.5576609\",\n \"0.5573737\",\n \"0.55697036\",\n \"0.5548449\",\n \"0.5541025\",\n \"0.55142874\",\n \"0.55125\",\n \"0.551017\",\n \"0.5501556\",\n \"0.5500096\",\n \"0.5484236\",\n \"0.54833245\",\n \"0.5471361\",\n \"0.54693896\",\n \"0.5466805\",\n \"0.546574\",\n \"0.5461442\",\n \"0.545633\",\n \"0.54551744\",\n \"0.545123\",\n \"0.54510236\",\n \"0.54510236\",\n \"0.5449476\",\n \"0.54471874\",\n \"0.5432562\",\n \"0.54295737\",\n \"0.54235035\",\n \"0.5419193\",\n \"0.5407668\",\n \"0.5407594\",\n \"0.5405298\",\n \"0.5405145\",\n \"0.5402779\",\n \"0.5388023\",\n \"0.53872496\",\n \"0.53872496\",\n \"0.5383778\",\n \"0.53827983\",\n \"0.5376413\",\n \"0.5372327\",\n \"0.53722143\",\n \"0.537186\",\n \"0.53632414\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.84036976"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":91985,"cells":{"query":{"kind":"string","value":"Determine the index of the top of climb altitude. Returns The index of the last cruising altitude."},"document":{"kind":"string","value":"def top_of_descent_index(self):\n tod = self.altitudes.argmax()\n # if the altitude profile is not just a climb\n # and there is a cruising section\n if (tod < len(self.altitudes) - 1) and \\\n (self.altitudes[tod] == self.altitudes[tod + 1]):\n tod += 1\n\n return tod"},"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 top_of_climb_index(self):\n return self.altitudes.argmax()","def alt_index(self) -> Optional[int]:\n if not self.is_hom_alt():\n return None\n return max(self.allele1, self.allele2) - 1","def top_offset(self):\n raise NotImplementedError","def top(self):\n return self.get_cards()[-1]","def top(self):\n return self.a[-1]","def top_of_climb_distance(self):\n return self.distances[self.top_of_climb_index()]","def _get_out_of_screen_item_loc_prev(self):\n\n new_loc = self.page_current.item_onscreenlocs[self.page_current.item_selected] - self.terminal_height\n closest_item_index = self._get_index_closest_val(self.page_current.item_onscreenlocs, new_loc)\n\n return closest_item_index","def top_distance(self):\n return self.y","def top(self):\n return self.arr[-1]","def get_latest_locant(self):\n return self._next_locant - 1","def top(self) -> int:\n return self.q1[-1]","def get_topBlock(self):\n return self.blocks[len(self.blocks)-1]","def top(self) -> int:\n return self.topvalue","def get_topmost_visible() -> int:\n prev_lineno = ui_content.line_count - 1\n used_height = 0\n for lineno in range(ui_content.line_count - 1, -1, -1):\n used_height += get_line_height(lineno)\n if used_height > height:\n return prev_lineno\n else:\n prev_lineno = lineno\n return prev_lineno","def altitude(self):\n if self.__altitude:\n return sum(self.__altitude) / len(self.__altitude)\n else:\n return -9999","def get_main_array_top(self):\n return self.bitcell_array_inst.uy()","def top(self) -> float:\n points = self.get_adjusted_points()\n y_points = [point[1] for point in points]\n return max(y_points)","def top(self):\n return self.points['topRight'].y","def top(self):\n return self.points['topRight'].y","def last_pos(self):\n return self.locs[self.indices[-1], 2:4]","def top(self) -> int:\n return self.topEle","def last_low(self):\n return self.data.last('1D').low.iat[0]","def top(state):\n if len(state[STACK]) <= 0:\n return -1\n else:\n return state[STACK][-1]","def top_ele(self):\n if not self.is_empty():\n return self.arr[self.top]\n return -1","def current_cover_position(self):\n state = self.channel_data.get(\"state\")\n if state:\n return 100 - state[\"shut\"]\n return None","def table_top_abs(self):\n table_height = np.array([0, 0, self.table_full_size[2]])\n return string_to_array(self.floor.get(\"pos\")) + table_height","def altitude(self) -> int:\n return self._point.altitude","def top(self) -> int:\n return self.q[0]","def top(self) -> int:\n return self.q[0]","def top(self) -> int:\n return self.q[0]","def top(self) -> int:\n return self._deque[0]","def top(self) -> int:\n return self.stack[-1]","def top(self) -> int:\n return self.stack[-1]","def bottom(self) -> float:\n bottom = 0\n for part in self.line_parts:\n if part.state.rise < 0 and -part.state.rise > bottom:\n bottom = -part.state.rise\n return bottom","def get_cloc(self):\n return self.order_hist[-1]","def top(self):\n \n assert not self.empty()\n return self._s[-1]","def top_layer(self):\n return self._top","def get_index_of_surface_gate(data, setup={}):\n alts = data['alt']\n return np.argmin(np.abs(alts), 1)","def east_index(self, index):\n # Add a check for the edge of the board\n if index % self.size == self.size - 1:\n # Indices of < 0 are filtered out in cardinal_indices()\n return -1\n else:\n return index + 1","def getExceedingBoxTop(self):\n return self.exceedingBoxTop","def bb_top(self) -> float:\n return self._bb_top","def getLimbIndex(self):\n\n data = self.name.split('-')\n return int(data[1]) - 1","def Ethanol(self) -> int:\n return self.raw_measure()[1]","def top(self):\n # type: () -> float\n return self._top","def top(self) -> int:\n last = self.pop()\n self.push(last)\n return last","def top_y(self):\r\n return self.position.y + self.size.y + self.bulk","def peek(self) -> int:\n\t\treturn self.s1[-1]","def getLastBlock(self):\n if (len(self.chain) == 0):\n return -1\n else:\n return self.chain[len(self.chain)-1]","def looks_azimuth(self) -> Optional[int]:\n return self._get_property(LOOKS_AZIMUTH_PROP, int)","def top(self) -> object:\n return self._data[-1]","def top(self) -> object:\n return self._data[-1]","def get_card_at_top_index(deck):\n \n small_joker_value = get_small_joker_value(deck)\n if deck[0] == get_big_joker_value(deck):\n return deck[get_small_joker_value(deck)]\n else:\n return deck[deck[0]]","def get_card_at_top_index(deck: List[int]) -> int:\n top_card = deck[0]\n\n if top_card == max(deck):\n top_card = get_small_joker_value(deck)\n keystream = deck[top_card]\n else:\n keystream = deck[top_card]\n\n return keystream","def y(self):\n return self.top","def last_index(self) -> int:\n return self._last_index","def bottom_left_tile_value(self):\n\t\treturn self.expected_cols * (self.expected_rows - 1) + 1","def get_oldest_neuron(self):\n\t\tassert self.check_tabu_list\n\t\tif (float(\"inf\") in self._tabu_list):\n\t\t\treturn self._tabu_list.index(float(\"inf\"))\n\t\tnumIter = min(self._tabu_list)\n\t\treturn self._tabu_list.index(numIter)","def _get_out_of_screen_item_loc_next(self):\n\n new_loc = self.page_current.item_onscreenlocs[self.page_current.item_selected] + self.terminal_height + 1\n closest_item_index = self._get_index_closest_val(self.page_current.item_onscreenlocs, new_loc)\n\n return closest_item_index","def north_index(self, index):\n return index - self.size","def top(self):\n print(self.arr[-1])","def i (self):\n\n return self.end - 1","def _index(self) -> int:\n return -1","def top_of_descent_distance(self):\n return self.distances[self.top_of_descent_index()]","def top(self):\n return self[0]","def last_high(self):\n return self.data.last('1D').high.iat[0]","def closest_cruising_altitude(altitude):\n return 1000 * ((altitude + 500) // 1000)","def find_exit_position(labyrinth: Labyrinth) -> Tuple[int, int]:\n return labyrinth.get_exit_position()","def get_last_index(self):\n return len(self.chain) - 1","def getAbsoluteTop(self):\n return self.canvas.getAbsoluteTop()","def top_left_tile_value(self):\n\t\treturn 1","def _get_start_render_index(self):\n\n for ol in self.overlay_list[-1::-1]:\n # FIXME There may be even no 'label' in a label's name, so we need use other method to recognize a label.\n if \"label\" not in ol.get_name() and ol.get_alpha() == 1. and ol.is_visible()\\\n and ol.get_min() <= np.min(ol.get_data()):\n return self.overlay_list.index(ol)\n\n # 0 means that the render will start with the bottom overlay.\n return 0","def last_position(self):\n return self.visited_positions[-1]","def get_nearest_row(self):\n return (self.rect.top - (self.screen.get_height() // 12)) // self.maze.block_size","def bottom(self) -> float:\n points = self.get_adjusted_points()\n y_points = [point[1] for point in points]\n return min(y_points)","def top_right_tile_value(self):\n\t\treturn self.expected_cols","def get_replica_bottom(self):\n return self.dummy_row_insts[0].uy()","def get_top_cell(self):\n return self._top_cell","def top(self):\n return self._top","def top(self):\n return self._top","def get_top_cheese(self, index):\n if len(self._stools[index]) == 0:\n return None\n else:\n cheese = self._stools[index][-1]\n return cheese","def top(self):\r\n return self.topele","def get_replica_top(self):\n return self.dummy_row_insts[0].by()","def top(self):\n return self.stack[-1]","def peek(self, index):\n x = -1\n if (self.top - index + 1) < 0:\n print(\"Invalid Index\")\n else:\n x = self.arr[self.top - index + 1]\n return x","def last_provided(self):\n last = self.current()\n if last == 0:\n return None\n return self._cnt2bc(last - 1)","def top(self):\r\n\r\n if self.is_empty():\r\n pass\r\n\r\n else:\r\n return self._data[0]","def Front(self) -> int:\n return self.circular[self.front] if self.size else -1\n # if self.size:\n # return self.cicular[self.front]\n # else:\n # return -1","def get_top_discard_card(self):\n discard_pile_index = len(self.discard_pile) - 1\n return self.discard_pile[discard_pile_index]","def most_recent_damaged_pos(self):\n\n idx = len(self.oxygen_profile) - self.count - 1\n if idx < 0:\n idx = 0\n return (self.oxygen_cards[idx].render_pos[0] + self.pos[0],\n self.oxygen_cards[idx].render_pos[1] + self.pos[1])","def baseline_eCO2(self) -> int:\n return self.get_iaq_baseline()[0]","def getLPos(self):\n c = 0\n while c <= ALIENS_IN_ROW-1:\n i = 0\n for a in range(ALIEN_ROWS):\n if self._aliens[a][c] != None:\n return self._aliens[a][c].x - ALIEN_WIDTH/2\n else:\n i +=1\n if i == ALIEN_ROWS:\n c +=1","def top(self) -> int:\n r = self.data.get()\n self.push(r)\n return r","def to_index(self):\r\n return (BOARD_HEIGHT - 1 - self.y) * BOARD_HEIGHT + (BOARD_WIDTH - 1 - self.x)","def current_cover_position(self) -> int:\n return int(self._value)","def offset(self):\r\n return self._get_instantiation()[3]","def break_index(self, **kwargs):\n return self.peak_indices(**kwargs)[0][-1]","def _rect_top(self):\n\treturn max(self.y, self.y + self.h)","def get_last_step(self):\n return self.get_step_by_index(-1)","def get_oldest_index(self):\n for k in self.go_forward(start=self.write_pos):\n if self.log[k] != None:\n break\n return k","def current_cover_position(self) -> int:\n return self._device[\"current_state\"]"],"string":"[\n \"def top_of_climb_index(self):\\n return self.altitudes.argmax()\",\n \"def alt_index(self) -> Optional[int]:\\n if not self.is_hom_alt():\\n return None\\n return max(self.allele1, self.allele2) - 1\",\n \"def top_offset(self):\\n raise NotImplementedError\",\n \"def top(self):\\n return self.get_cards()[-1]\",\n \"def top(self):\\n return self.a[-1]\",\n \"def top_of_climb_distance(self):\\n return self.distances[self.top_of_climb_index()]\",\n \"def _get_out_of_screen_item_loc_prev(self):\\n\\n new_loc = self.page_current.item_onscreenlocs[self.page_current.item_selected] - self.terminal_height\\n closest_item_index = self._get_index_closest_val(self.page_current.item_onscreenlocs, new_loc)\\n\\n return closest_item_index\",\n \"def top_distance(self):\\n return self.y\",\n \"def top(self):\\n return self.arr[-1]\",\n \"def get_latest_locant(self):\\n return self._next_locant - 1\",\n \"def top(self) -> int:\\n return self.q1[-1]\",\n \"def get_topBlock(self):\\n return self.blocks[len(self.blocks)-1]\",\n \"def top(self) -> int:\\n return self.topvalue\",\n \"def get_topmost_visible() -> int:\\n prev_lineno = ui_content.line_count - 1\\n used_height = 0\\n for lineno in range(ui_content.line_count - 1, -1, -1):\\n used_height += get_line_height(lineno)\\n if used_height > height:\\n return prev_lineno\\n else:\\n prev_lineno = lineno\\n return prev_lineno\",\n \"def altitude(self):\\n if self.__altitude:\\n return sum(self.__altitude) / len(self.__altitude)\\n else:\\n return -9999\",\n \"def get_main_array_top(self):\\n return self.bitcell_array_inst.uy()\",\n \"def top(self) -> float:\\n points = self.get_adjusted_points()\\n y_points = [point[1] for point in points]\\n return max(y_points)\",\n \"def top(self):\\n return self.points['topRight'].y\",\n \"def top(self):\\n return self.points['topRight'].y\",\n \"def last_pos(self):\\n return self.locs[self.indices[-1], 2:4]\",\n \"def top(self) -> int:\\n return self.topEle\",\n \"def last_low(self):\\n return self.data.last('1D').low.iat[0]\",\n \"def top(state):\\n if len(state[STACK]) <= 0:\\n return -1\\n else:\\n return state[STACK][-1]\",\n \"def top_ele(self):\\n if not self.is_empty():\\n return self.arr[self.top]\\n return -1\",\n \"def current_cover_position(self):\\n state = self.channel_data.get(\\\"state\\\")\\n if state:\\n return 100 - state[\\\"shut\\\"]\\n return None\",\n \"def table_top_abs(self):\\n table_height = np.array([0, 0, self.table_full_size[2]])\\n return string_to_array(self.floor.get(\\\"pos\\\")) + table_height\",\n \"def altitude(self) -> int:\\n return self._point.altitude\",\n \"def top(self) -> int:\\n return self.q[0]\",\n \"def top(self) -> int:\\n return self.q[0]\",\n \"def top(self) -> int:\\n return self.q[0]\",\n \"def top(self) -> int:\\n return self._deque[0]\",\n \"def top(self) -> int:\\n return self.stack[-1]\",\n \"def top(self) -> int:\\n return self.stack[-1]\",\n \"def bottom(self) -> float:\\n bottom = 0\\n for part in self.line_parts:\\n if part.state.rise < 0 and -part.state.rise > bottom:\\n bottom = -part.state.rise\\n return bottom\",\n \"def get_cloc(self):\\n return self.order_hist[-1]\",\n \"def top(self):\\n \\n assert not self.empty()\\n return self._s[-1]\",\n \"def top_layer(self):\\n return self._top\",\n \"def get_index_of_surface_gate(data, setup={}):\\n alts = data['alt']\\n return np.argmin(np.abs(alts), 1)\",\n \"def east_index(self, index):\\n # Add a check for the edge of the board\\n if index % self.size == self.size - 1:\\n # Indices of < 0 are filtered out in cardinal_indices()\\n return -1\\n else:\\n return index + 1\",\n \"def getExceedingBoxTop(self):\\n return self.exceedingBoxTop\",\n \"def bb_top(self) -> float:\\n return self._bb_top\",\n \"def getLimbIndex(self):\\n\\n data = self.name.split('-')\\n return int(data[1]) - 1\",\n \"def Ethanol(self) -> int:\\n return self.raw_measure()[1]\",\n \"def top(self):\\n # type: () -> float\\n return self._top\",\n \"def top(self) -> int:\\n last = self.pop()\\n self.push(last)\\n return last\",\n \"def top_y(self):\\r\\n return self.position.y + self.size.y + self.bulk\",\n \"def peek(self) -> int:\\n\\t\\treturn self.s1[-1]\",\n \"def getLastBlock(self):\\n if (len(self.chain) == 0):\\n return -1\\n else:\\n return self.chain[len(self.chain)-1]\",\n \"def looks_azimuth(self) -> Optional[int]:\\n return self._get_property(LOOKS_AZIMUTH_PROP, int)\",\n \"def top(self) -> object:\\n return self._data[-1]\",\n \"def top(self) -> object:\\n return self._data[-1]\",\n \"def get_card_at_top_index(deck):\\n \\n small_joker_value = get_small_joker_value(deck)\\n if deck[0] == get_big_joker_value(deck):\\n return deck[get_small_joker_value(deck)]\\n else:\\n return deck[deck[0]]\",\n \"def get_card_at_top_index(deck: List[int]) -> int:\\n top_card = deck[0]\\n\\n if top_card == max(deck):\\n top_card = get_small_joker_value(deck)\\n keystream = deck[top_card]\\n else:\\n keystream = deck[top_card]\\n\\n return keystream\",\n \"def y(self):\\n return self.top\",\n \"def last_index(self) -> int:\\n return self._last_index\",\n \"def bottom_left_tile_value(self):\\n\\t\\treturn self.expected_cols * (self.expected_rows - 1) + 1\",\n \"def get_oldest_neuron(self):\\n\\t\\tassert self.check_tabu_list\\n\\t\\tif (float(\\\"inf\\\") in self._tabu_list):\\n\\t\\t\\treturn self._tabu_list.index(float(\\\"inf\\\"))\\n\\t\\tnumIter = min(self._tabu_list)\\n\\t\\treturn self._tabu_list.index(numIter)\",\n \"def _get_out_of_screen_item_loc_next(self):\\n\\n new_loc = self.page_current.item_onscreenlocs[self.page_current.item_selected] + self.terminal_height + 1\\n closest_item_index = self._get_index_closest_val(self.page_current.item_onscreenlocs, new_loc)\\n\\n return closest_item_index\",\n \"def north_index(self, index):\\n return index - self.size\",\n \"def top(self):\\n print(self.arr[-1])\",\n \"def i (self):\\n\\n return self.end - 1\",\n \"def _index(self) -> int:\\n return -1\",\n \"def top_of_descent_distance(self):\\n return self.distances[self.top_of_descent_index()]\",\n \"def top(self):\\n return self[0]\",\n \"def last_high(self):\\n return self.data.last('1D').high.iat[0]\",\n \"def closest_cruising_altitude(altitude):\\n return 1000 * ((altitude + 500) // 1000)\",\n \"def find_exit_position(labyrinth: Labyrinth) -> Tuple[int, int]:\\n return labyrinth.get_exit_position()\",\n \"def get_last_index(self):\\n return len(self.chain) - 1\",\n \"def getAbsoluteTop(self):\\n return self.canvas.getAbsoluteTop()\",\n \"def top_left_tile_value(self):\\n\\t\\treturn 1\",\n \"def _get_start_render_index(self):\\n\\n for ol in self.overlay_list[-1::-1]:\\n # FIXME There may be even no 'label' in a label's name, so we need use other method to recognize a label.\\n if \\\"label\\\" not in ol.get_name() and ol.get_alpha() == 1. and ol.is_visible()\\\\\\n and ol.get_min() <= np.min(ol.get_data()):\\n return self.overlay_list.index(ol)\\n\\n # 0 means that the render will start with the bottom overlay.\\n return 0\",\n \"def last_position(self):\\n return self.visited_positions[-1]\",\n \"def get_nearest_row(self):\\n return (self.rect.top - (self.screen.get_height() // 12)) // self.maze.block_size\",\n \"def bottom(self) -> float:\\n points = self.get_adjusted_points()\\n y_points = [point[1] for point in points]\\n return min(y_points)\",\n \"def top_right_tile_value(self):\\n\\t\\treturn self.expected_cols\",\n \"def get_replica_bottom(self):\\n return self.dummy_row_insts[0].uy()\",\n \"def get_top_cell(self):\\n return self._top_cell\",\n \"def top(self):\\n return self._top\",\n \"def top(self):\\n return self._top\",\n \"def get_top_cheese(self, index):\\n if len(self._stools[index]) == 0:\\n return None\\n else:\\n cheese = self._stools[index][-1]\\n return cheese\",\n \"def top(self):\\r\\n return self.topele\",\n \"def get_replica_top(self):\\n return self.dummy_row_insts[0].by()\",\n \"def top(self):\\n return self.stack[-1]\",\n \"def peek(self, index):\\n x = -1\\n if (self.top - index + 1) < 0:\\n print(\\\"Invalid Index\\\")\\n else:\\n x = self.arr[self.top - index + 1]\\n return x\",\n \"def last_provided(self):\\n last = self.current()\\n if last == 0:\\n return None\\n return self._cnt2bc(last - 1)\",\n \"def top(self):\\r\\n\\r\\n if self.is_empty():\\r\\n pass\\r\\n\\r\\n else:\\r\\n return self._data[0]\",\n \"def Front(self) -> int:\\n return self.circular[self.front] if self.size else -1\\n # if self.size:\\n # return self.cicular[self.front]\\n # else:\\n # return -1\",\n \"def get_top_discard_card(self):\\n discard_pile_index = len(self.discard_pile) - 1\\n return self.discard_pile[discard_pile_index]\",\n \"def most_recent_damaged_pos(self):\\n\\n idx = len(self.oxygen_profile) - self.count - 1\\n if idx < 0:\\n idx = 0\\n return (self.oxygen_cards[idx].render_pos[0] + self.pos[0],\\n self.oxygen_cards[idx].render_pos[1] + self.pos[1])\",\n \"def baseline_eCO2(self) -> int:\\n return self.get_iaq_baseline()[0]\",\n \"def getLPos(self):\\n c = 0\\n while c <= ALIENS_IN_ROW-1:\\n i = 0\\n for a in range(ALIEN_ROWS):\\n if self._aliens[a][c] != None:\\n return self._aliens[a][c].x - ALIEN_WIDTH/2\\n else:\\n i +=1\\n if i == ALIEN_ROWS:\\n c +=1\",\n \"def top(self) -> int:\\n r = self.data.get()\\n self.push(r)\\n return r\",\n \"def to_index(self):\\r\\n return (BOARD_HEIGHT - 1 - self.y) * BOARD_HEIGHT + (BOARD_WIDTH - 1 - self.x)\",\n \"def current_cover_position(self) -> int:\\n return int(self._value)\",\n \"def offset(self):\\r\\n return self._get_instantiation()[3]\",\n \"def break_index(self, **kwargs):\\n return self.peak_indices(**kwargs)[0][-1]\",\n \"def _rect_top(self):\\n\\treturn max(self.y, self.y + self.h)\",\n \"def get_last_step(self):\\n return self.get_step_by_index(-1)\",\n \"def get_oldest_index(self):\\n for k in self.go_forward(start=self.write_pos):\\n if self.log[k] != None:\\n break\\n return k\",\n \"def current_cover_position(self) -> int:\\n return self._device[\\\"current_state\\\"]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.845523","0.66592854","0.6438688","0.64357513","0.64272976","0.64195174","0.6181029","0.6179077","0.6126768","0.61237574","0.6112536","0.61075664","0.61017954","0.60960674","0.60574836","0.6043104","0.60421985","0.6038397","0.6038397","0.60144544","0.6013455","0.6002849","0.59793866","0.5974088","0.59306955","0.5930241","0.59172875","0.59057087","0.59057087","0.59057087","0.5903391","0.5870116","0.5870116","0.58471","0.5844655","0.58321774","0.58149904","0.58038926","0.5798754","0.57958925","0.57931995","0.57850903","0.57819736","0.5778744","0.5762367","0.5714149","0.570712","0.57033706","0.5696724","0.5662882","0.5662882","0.565218","0.5648773","0.5643511","0.56391275","0.56273085","0.5626925","0.5621011","0.5611708","0.5608623","0.5607665","0.5602308","0.55996984","0.55994004","0.55912405","0.55871516","0.5577275","0.55683714","0.5561577","0.55583084","0.5540353","0.553969","0.553364","0.5529486","0.55235153","0.55190396","0.5508106","0.5494267","0.5494267","0.549302","0.5486006","0.548599","0.54851156","0.54808855","0.54794365","0.54789454","0.5475932","0.5472998","0.54720455","0.54703885","0.5468187","0.54680526","0.54659796","0.54536724","0.545354","0.5447853","0.54435366","0.54433","0.5443204","0.5440725"],"string":"[\n \"0.845523\",\n \"0.66592854\",\n \"0.6438688\",\n \"0.64357513\",\n \"0.64272976\",\n \"0.64195174\",\n \"0.6181029\",\n \"0.6179077\",\n \"0.6126768\",\n \"0.61237574\",\n \"0.6112536\",\n \"0.61075664\",\n \"0.61017954\",\n \"0.60960674\",\n \"0.60574836\",\n \"0.6043104\",\n \"0.60421985\",\n \"0.6038397\",\n \"0.6038397\",\n \"0.60144544\",\n \"0.6013455\",\n \"0.6002849\",\n \"0.59793866\",\n \"0.5974088\",\n \"0.59306955\",\n \"0.5930241\",\n \"0.59172875\",\n \"0.59057087\",\n \"0.59057087\",\n \"0.59057087\",\n \"0.5903391\",\n \"0.5870116\",\n \"0.5870116\",\n \"0.58471\",\n \"0.5844655\",\n \"0.58321774\",\n \"0.58149904\",\n \"0.58038926\",\n \"0.5798754\",\n \"0.57958925\",\n \"0.57931995\",\n \"0.57850903\",\n \"0.57819736\",\n \"0.5778744\",\n \"0.5762367\",\n \"0.5714149\",\n \"0.570712\",\n \"0.57033706\",\n \"0.5696724\",\n \"0.5662882\",\n \"0.5662882\",\n \"0.565218\",\n \"0.5648773\",\n \"0.5643511\",\n \"0.56391275\",\n \"0.56273085\",\n \"0.5626925\",\n \"0.5621011\",\n \"0.5611708\",\n \"0.5608623\",\n \"0.5607665\",\n \"0.5602308\",\n \"0.55996984\",\n \"0.55994004\",\n \"0.55912405\",\n \"0.55871516\",\n \"0.5577275\",\n \"0.55683714\",\n \"0.5561577\",\n \"0.55583084\",\n \"0.5540353\",\n \"0.553969\",\n \"0.553364\",\n \"0.5529486\",\n \"0.55235153\",\n \"0.55190396\",\n \"0.5508106\",\n \"0.5494267\",\n \"0.5494267\",\n \"0.549302\",\n \"0.5486006\",\n \"0.548599\",\n \"0.54851156\",\n \"0.54808855\",\n \"0.54794365\",\n \"0.54789454\",\n \"0.5475932\",\n \"0.5472998\",\n \"0.54720455\",\n \"0.54703885\",\n \"0.5468187\",\n \"0.54680526\",\n \"0.54659796\",\n \"0.54536724\",\n \"0.545354\",\n \"0.5447853\",\n \"0.54435366\",\n \"0.54433\",\n \"0.5443204\",\n \"0.5440725\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.82606477"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":91986,"cells":{"query":{"kind":"string","value":"Determine the path distance of the top of climb altitude. Returns The path distance of the first cruising altitude."},"document":{"kind":"string","value":"def top_of_climb_distance(self):\n return self.distances[self.top_of_climb_index()]"},"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 closest_cruising_altitude(altitude):\n return 1000 * ((altitude + 500) // 1000)","def find_closest_path(self):\n\t\tclosest_distance = sys.maxint\n\t\tclosest_path = 0\n\t\tbike_position = (self.map_model.bike.xB, self.map_model.bike.yB)\n\t\tfor path_index in range(len(self.map_model.paths)):\n\t\t\tnearest_point = geometry.nearest_point_on_path(self.map_model.paths[path_index], bike_position)\n\t\t\tdistance_to_bike = geometry.distance(nearest_point, bike_position)\n\t\t\tif (closest_distance > distance_to_bike):\n\t\t\t\tclosest_distance = distance_to_bike\n\t\t\t\tclosest_path = path_index \n\t\tdisp_next = self.displacement_to_turn(target_path = (closest_path+1)%len(self.map_model.paths))\n\t\ttarget_path = (closest_path+1)%len(self.map_model.paths)\n\t\tdistance_next = geometry.distance_from_path(bike_position, self.map_model.paths[target_path])\n\t\tif disp_next - np.abs(distance_next)>-0.01:\n\t\t\tclosest_path = np.mod(closest_path + 1,len(self.map_model.paths))\n\t\treturn closest_path","def get_closest_distance_to_path(self, path):\n min_distance_to_line = float(\"inf\")\n for p in path:\n game_path = p[:]\n\n game_path.sort(key = lambda coord: calculate_distance(self, coord))\n point_A = game_path[0] # Closest point out of all the points on the path to to the tower\n\n try:\n point_after_A = p[p.index(point_A) + 1]\n point_before_A = p[p.index(point_A) - 1]\n closest_to_A = min(point_after_A, point_before_A, key = lambda point: calculate_distance(point_A, point))\n except:\n if p.index(point_A) == 0:\n closest_to_A = p[p.index(point_A) + 1]\n \n elif p.index(point_A) == len(p) - 1:\n closest_to_A = p[p.index(point_A) - 1]\n finally:\n if closest_to_A[0] != point_A[0]:\n m = (closest_to_A[1] - point_A[1]) / (closest_to_A[0] - point_A[0])\n else:\n m = 2\n\n b = point_A[1] - m * point_A[0]\n\n closest_distance = abs(-m * self.x + self.y - b) / math.sqrt((-m) ** 2 + 1)\n min_distance_to_line = min(closest_distance, min_distance_to_line)\n \n return min_distance_to_line","def top_distance(self):\n return self.y","def top_of_climb_index(self):\n return self.altitudes.argmax()","def top_of_descent_index(self):\n tod = self.altitudes.argmax()\n # if the altitude profile is not just a climb\n # and there is a cruising section\n if (tod < len(self.altitudes) - 1) and \\\n (self.altitudes[tod] == self.altitudes[tod + 1]):\n tod += 1\n\n return tod","def top_of_descent_distance(self):\n return self.distances[self.top_of_descent_index()]","def lidar_relative(self):\n return self.distance","def get_path_distance(self, path):\n distance = VectorMath.get_magnitude(self.drone.get_point(), path[0])\n for index in range(len(path[:-1])):\n distance += VectorMath.get_magnitude(path[index], path[index + 1])\n distance += VectorMath.get_magnitude(path[-1], self.drone.get_waypoint_holder().get_current_waypoint())\n\n if abs(self.drone.get_point()[2] - path[0][2]) > 1:\n distance *= Constants.VERTICAL_PATH_WEIGHTING_MULTIPLE\n\n return distance","def get_true_bearing(shot, top):\n tripidx = shot[\"trip\"]\n\n if tripidx != -1:\n decl = top[\"trips\"][tripidx][KEY_DECLINATION]\n else:\n decl = 0\n\n return shot[\"compass\"] + decl","def GetAbsBeer(epsilon, conc, pathLength):\n return epsilon * conc * pathLength","def getDistance(self):\n taBox = (self.thor * self.tvert)/(720*960) #box area as percentage of whole\n if(taBox==None or taBox<=0): return -1\n const = 4 * math.tan(0.471)*math.tan(0.3576)\n return math.sqrt((self.abox)/(const*taBox))","def test_triangle_get_shortest_altitude(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)","def distance_to_current_waypoint(self):\n next_waypoint = self.vehicle.commands.next\n if next_waypoint == 1:\n return None\n mission_item = self.vehicle.commands[next_waypoint]\n lat = mission_item.x\n lon = mission_item.y\n alt = mission_item.z\n waypoint_location = Location(lat, lon, alt, is_relative=True)\n distance = get_distance_meters(self.vehicle.location, waypoint_location)\n return distance","def get_global_total_distance_on_bike(self):\n return self._get_global_total_distance([ActivityType.Ride])","def _plunge_distance(self, volume):\n percent = self._volume_percentage(volume)\n top = self._get_plunger_position('top')\n bottom = self._get_plunger_position('bottom')\n travel = bottom - top\n if travel <= 0:\n self.robot.add_warning('Plunger calibrated incorrectly')\n return travel * percent","def get_distance(self):\n\n # Activate trigger\n self.trigger()\n\n # Detect rising edge of echo pin\n channel = GPIO.wait_for_edge(self.echo_pin, GPIO.RISING, timeout=2)\n if channel is None:\n # Timeout on wait of rising interrupt\n return None\n else:\n # Rising edge detected, save pulse start\n pulse_start = time.time()\n\n\n # Detect falling edge of echo pin\n channel = GPIO.wait_for_edge(self.echo_pin, GPIO.FALLING, timeout=2)\n if channel is None:\n # Timeout on wait of falling interrupt\")\n return None\n else:\n # Falling edge detected, save pulse end\n pulse_end = time.time()\n\n # Calculated pulse width in microseconds (x1mln)\n pulse_width = (pulse_end - pulse_start)*1000000\n\n # Return distance in cm\n return pulse_width / 58","def evaluatePath(self):\n pathLength = 0\n if len(self.path) > 0:\n previousCity = self.path[0]\n for ind in range(1, len(self.path)):\n pathLength += previousCity.distanceWith(self.path[ind].name)\n previousCity = self.path[ind]\n return pathLength","def altitude(self):\n if self.__altitude:\n return sum(self.__altitude) / len(self.__altitude)\n else:\n return -9999","def get_best_move_toward(self, target_ground):\n options_by_parent, cost_to_reach = self.a_star_search(start=self.ground, goal=target_ground)\n ground = target_ground\n\n # Can't reach it?\n if ground not in options_by_parent:\n return None\n\n while options_by_parent[ground] is not self.ground:\n ground = options_by_parent[ground]\n\n return ground.x - self.ground.x, ground.y - self.ground.y","def distance_to_current_waypoint():\n nextwaypoint = vehicle.commands.next\n if nextwaypoint == 0:\n return None\n missionitem = vehicle.commands[nextwaypoint -\n 1] #commands are zero indexed\n lat = missionitem.x\n lon = missionitem.y\n alt = missionitem.z\n targetWaypointLocation = LocationGlobalRelative(lat, lon, alt)\n distancetopoint = get_distance_metres(vehicle.location.global_frame,\n targetWaypointLocation)\n return distancetopoint","def getDistance(self):\n return sqrt(self.state[0] * self.state[0] + self.state[2] * self.state[2])","def GetEpsilonBeer(Abs, conc, pathLength):\n return Abs / (conc * pathLength)","def _distance_next(self):\n\n self.distance = 10\n\n # Here a set index to 0 if the car is finishing a lap\n # Also reset the farthest\n if self.index > (len(self.x_trajectory) - 6) and self.closed:\n self.index = 0\n self.farthest = -1\n self.laps += 1\n\n for w in range(self.index, self.index + 20):\n\n self.dist_point = math.sqrt((self.x_trajectory[w] - self.x)**2\n + (self.y_trajectory[w] - self.y)**2)\n\n if self.dist_point < self.distance:\n self.distance = self.dist_point\n self.index = w\n\n if w >= (len(self.x_trajectory) - 1):\n break\n\n self._calc_side()\n\n self.distance = self.distance * self.sign\n\n return self.distance","def calculate_made_up_dist(self):\n\n # Ensure if current state equals goal, cost is only the current cost\n if self._goal_loc == self._current_loc:\n return self._current_cost\n\n # Distance is at least the Manhattan distance as cannot move diagonal\n estimated_distance = self.calculate_manhattan_dist()\n\n # Assume two board parts in the priority queue have the same weight.\n # For those board paths with higher actual cost and lower heuristic\n # cost, there is more assurance in the accuracy of the actual cost\n # than in the heuristic cost. Give a very small penalty (i.e. less\n # than one step) to prefer a path with a higher known cost than a\n # path with a higher heuristic cost.\n # Extract the number of portion of the move cost from the heuristic\n heuristic_cost = estimated_distance - self._current_cost\n # Heuristic cost penalty is normalized to a maximum of 0.1 steps\n # This is achieved by dividing the heuristic cost by the size of the\n # board. Since the heuristic cost can never be larger than the board\n # size, this quotient is less than or equal to 1. To normalize to a\n # maximum of 0.1, just multiply the number by 0.1. This is than added\n # to the estimated distance determined so far.\n heuristic_cost_penalty = 0.1 * heuristic_cost\n heuristic_cost_penalty /= BoardPath._traversed_board_size\n # Add what is essentially an \"uncertainty penalty\"\n estimated_distance += heuristic_cost_penalty\n\n # In case where all neighboring spaces are blocked or already\n # traversed, then set the path cost prohibitively large so it is\n # given minimum priority.\n if not (self.is_move_valid(\"d\", BoardPath._traversed_board)) \\\n and not (self.is_move_valid(\"u\", BoardPath._traversed_board)) \\\n and not (self.is_move_valid(\"l\", BoardPath._traversed_board)) \\\n and not (self.is_move_valid(\"r\", BoardPath._traversed_board)):\n # Total board area is sufficient as a prohibitive distance\n estimated_distance += BoardPath._traversed_board_size\n return estimated_distance\n\n # If all next steps that load directly to the goal are blocked, then\n # it takes at least two additional moves to get around the blocked\n # paths it (due to an obstacle or already traversed square) so add\n # two to the estimated distance to include that cost.\n if self._is_all_direct_next_moves_blocked(BoardPath._traversed_board):\n estimated_distance += 2\n\n # In a heap, if two nodes have the same cost, the object that was\n # put into the heap first in many implementations will be on top of the\n # heap. To make the algorithm more efficient, apply a slight penalty to\n # a non valid solution to ensure if an invalid solution and a valid\n # solution have the same cost that the valid solution would always be\n # on top of the heap. This is done by giving all non-valid solutions a\n # penalty term that is greater than zero and less than the minimum step\n # size (e.g. in this case 0 < 0.1 < 1).\n estimated_distance += 0.1\n\n # Return estimated distance\n return estimated_distance","def well_diameter_at_top(self):\n return self.radius_from_liquid_depth(self.well_depth) * 2 # a generic impl; subclasses can optimize","def GetTotalDurationOfPath(PathInfo):\r\n\tif PathInfo == None: return 0\r\n\tif len(PathInfo) < 2: return 0\r\n\t\r\n\tdeparture_first_station = PathInfo[0][ConnInfoInd['arrival_hour']]*60 + PathInfo[0][ConnInfoInd['arrival_min']]\r\n\t# departure_first_station = PathInfo[1][ConnInfoInd['departure_hour']]*60 + PathInfo[1][ConnInfoInd['departure_min']]\r\n\r\n\tarrival_last_station = PathInfo[-1][ConnInfoInd['arrival_hour']]*60 + PathInfo[-1][ConnInfoInd['arrival_min']]\r\n\treturn (arrival_last_station - departure_first_station)","def calc_distance(self, observation):\n actual_obs = observation[0]\n scrn_player = actual_obs.observation.feature_screen.player_relative\n scrn_select = actual_obs.observation.feature_screen.selected\n scrn_density = actual_obs.observation.feature_screen.unit_density\n\n state_added = scrn_select + scrn_density\n\n marine_center = np.mean(self.xy_locs(scrn_player == 1), axis=0).round()\n\n # first step\n if np.sum(scrn_select) == 0:\n marine_center = np.mean(self.xy_locs(scrn_player == 1), axis=0).round()\n # marine behind beacon\n if isinstance(marine_center, float):\n marine_center = np.mean(self.xy_locs(state_added == 2), axis=0).round()\n else:\n # normal navigation\n marine_center = np.mean(self.xy_locs(state_added == 2), axis=0).round()\n if isinstance(marine_center, float):\n marine_center = np.mean(self.xy_locs(state_added == 3), axis=0).round()\n\n beacon_center = np.mean(self.xy_locs(scrn_player == 3), axis=0).round()\n #\n # print(state_added)\n # print(\"---- Marine {} | {} Beacon ----\".format(marine_center, beacon_center))\n # time.sleep(0.2)\n distance = math.hypot(beacon_center[0] - marine_center[0],\n beacon_center[1] - marine_center[1])\n\n return beacon_center, marine_center, distance","def test_triangle_get_longest_altitude(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_longest_altitude(), 9.428090415820634)","def find_path(self):\n \n if self.line_num != -1:\n return self.line_num\n\n max_line = self.graph.gps_length - 1\n min_line = 0\n #last_id = dg.normalize(self.graph.lines[-1])[0]\n last_id = normalize_simple(self.graph.lines[-1])[0]\n pivot = int((self.trip_id-1)/float(last_id)*self.graph.gps_length)\n #cur_id = dg.normalize(self.graph.lines[pivot])[0]\n cur_id = normalize_simple(self.graph.lines[pivot])[0]\n while cur_id != self.trip_id:\n if cur_id < self.trip_id:\n min_line = pivot\n else:\n max_line = pivot\n #TODO: could make this run in essentially constant time by hopping predetermined distance\n pivot = (min_line + max_line) / 2\n #cur_id = dg.normalize(self.graph.lines[pivot])[0]\n cur_id = normalize_simple(self.graph.lines[pivot])[0]\n\n #while dg.normalize(self.graph.lines[pivot])[0] == self.trip_id:\n while normalize_simple(self.graph.lines[pivot])[0] == self.trip_id:\n pivot -= 1\n\n pivot += 1\n self.line_num = pivot\n return pivot","def get_last_flight(self):\n return self.path[len(self.path) - 1]","def diversion(self) -> Optional[\"Flight\"]:\n from ..data import airports\n\n # The following cast secures the typing\n self = cast(\"Flight\", self)\n\n f_above: Optional[\"Flight\"] = self.query(\"altitude > 15000\")\n if (\n self.destination != self.destination\n or airports[self.destination] is None # type: ignore\n or f_above is None\n ):\n return None\n\n return (\n f_above.distance(airports[self.destination]) # type: ignore\n .diff(\"distance\")\n .agg_time(\"10T\", distance_diff=\"mean\")\n .query(\"distance_diff > 0\")\n )","def get_distance(self) -> int:\n return self.get_measurement_data().distance","def get_path_distance(self, path):\n length = len(path)\n distance = 0\n for i in range(length):\n distance += self.distances[path[i]][path[(i + 1) % length]]\n return distance","def _find_fastest_path(self):\n from simulator import Robot\n clone_robot = Robot(exploration_status=self._robot.exploration_status,\n facing=self._robot.facing,\n discovered_map=self._robot.discovered_map,\n real_map=[[0] * 15 for _ in range(20)])\n\n fastest_path_start_way_point = get_shortest_path_moves(clone_robot,\n start=(1, 1),\n goal=self._way_point)\n\n if fastest_path_start_way_point:\n for move in fastest_path_start_way_point:\n clone_robot.move_robot(move)\n\n before_way_point = previous_cell(clone_robot.center, clone_robot.facing)\n\n fastest_path_way_point_goal = get_shortest_path_moves(clone_robot,\n start=self._way_point,\n goal=(18, 13),\n before_start_point=before_way_point)\n\n return fastest_path_start_way_point + fastest_path_way_point_goal","def get_min_distance(self):\n return round(min(self.combined_euclidian_distance))","def altitude(self) -> int:\n return self._point.altitude","def _get_distance(self, target): \r\n sensor_transform = self._sensors['rgb_front'].get_transform()\r\n\r\n distance = np.sqrt(\r\n (sensor_transform.location.x - target.x) ** 2 +\r\n (sensor_transform.location.y - target.y) ** 2 +\r\n (sensor_transform.location.z - target.z) ** 2)\r\n\r\n return distance","def path(most_important_up, most_important_down, total_distance, to_source2, to_source1):\n\n if total_distance == min(total_distance, to_source2[0], to_source1[0]):\n return source_to_source(most_important_up, most_important_down), total_distance\n elif to_source2[0] == min(total_distance, to_source2[0], to_source1[0]):\n return most_important_to_source(to_source2[1]), to_source2[0]\n else:\n return most_important_to_source(to_source1[1], up=False), to_source1[0]","def measure_distance(self):\n # set Trigger to HIGH\n GPIO.output(self.GPIO_TRIGGER, True)\n\n # set Trigger after 0.01ms to LOW\n time.sleep(0.00001)\n GPIO.output(self.GPIO_TRIGGER, False)\n\n start_time = time.time()\n stop_time = time.time()\n\n # save StartTime\n while GPIO.input(self.GPIO_ECHO) == 0:\n start_time = time.time()\n\n # save time of arrival\n while GPIO.input(self.GPIO_ECHO) == 1:\n stop_time = time.time()\n\n # time difference between start and arrival\n time_elapsed = stop_time - start_time\n # multiply with the sonic speed (343.00 m/s)\n # and divide by 2, because there and back\n distance = (time_elapsed * 343.00) / 2\n\n return distance","def get_distance(self):\n values = self.speakers.values()\n values.sort(reverse=True)\n try:\n return abs(values[1]) - abs(values[0])\n except (IndexError, ValueError):\n return -1","def get_distance(self, heuristic=\"\"):\n # If no heuristic is specified, used the default\n if(heuristic == \"\"):\n heuristic = BoardPath._heuristic\n\n if(heuristic == \"manhattan\"):\n return self.calculate_manhattan_dist()\n elif(heuristic == \"euclidean\"):\n return self.calculate_euclidean_dist()\n elif(heuristic == \"made_up\"):\n return self.calculate_made_up_dist()\n else:\n sys.exit()","def h_score(self):\n if self.estimated_moves_to_goal is None:\n self.estimated_moves_to_goal = \\\n max(nx.single_source_shortest_path_length(self.graph, self.head_node).items(), key=lambda x: x[1])[1]\n return self.estimated_moves_to_goal","def distance(self) -> float:\n return self._dist_two_wire() # at this time we only support 2-wire meausre","def _distance_covered(self):\n\n # Calculation of distance traveled compared to the previous point\n self.gap = math.sqrt((self.x - self.x_ant)**2\n + (self.y - self.y_ant)**2)\n\n self.x_ant = self.x\n self.y_ant = self.y\n\n return self.gap","def elevation(self):\n return self.altitude - self.heightAboveGround","def path_cost(path):\n # path = [state, (action, total_cost), state, ... ]\n if len(path) < 2:\n return 0\n else:\n return path[-2][-1]","def _calculate_h(self, end):\n return PATH_COST * (abs(self.x - end.x) + abs(self.y - end.y))","def distance(self):\n return Distance(length_of(self.position.au))","def bottom(self) -> float:\n bottom = 0\n for part in self.line_parts:\n if part.state.rise < 0 and -part.state.rise > bottom:\n bottom = -part.state.rise\n return bottom","def GetConcBeer(Abs, epsilon, pathLength):\n return Abs / (epsilon * pathLength)","def getAltitudeAngle(self):\n return self._altitude","def lidar_absolute(self):\n return np.roll(self.distance, self.heading_idx)","def get_closest_waypoint(self, pose):\n if self.kdtree:\n return kdtree_closest_point(self.kdtree,\n (pose.x,\n pose.y))\n else:\n return 0","def get_closest_waypoint(self, pose):\n if self.kdtree:\n return kdtree_closest_point(self.kdtree,\n (pose.position.x,\n pose.position.y))\n else:\n return 0","def calculate_path(self):\n\n mid_states = []\n\n # Add in between states\n for i in range(Constants.NUMBER_LAPS):\n mid_states = mid_states + Constants.LAP_STATES\n\n # Concatenate beginning, middle and end states to obtain full path of states\n self.path_states = Constants.BEGINNING_STATES + mid_states + Constants.END_STATES\n\n # Determine the amount of times that the smallbot will drive forward during the path\n self.times_driven_forward = self.path_states.count('CREEP_FORWARD')\n\n print(\"Calculated path: \", self.path_states)","def manhatam_distance(self) -> int:\n return abs(self.north) + abs(self.east)","def wind_bearing(self) -> float:\r\n return self._first_timeserie[\"data\"][\"instant\"][\"details\"][\r\n \"wind_from_direction\"\r\n ]","def getAboveDistance(self):\n return self.__aboveDistance","def longest_path_callback(self, data):\n min_idx = self.find_minimum_distance(data.poses) # closest point index\n if min_idx is None:\n return\n else:\n # extract 20 points along the closest point\n # use z position of ego car since z displacement doesn't matter\n # truncate if encounter head or tail\n path_points = np.array([\n (pose.pose.position.x, pose.pose.position.y, self.car_pos[2])\n for pose in data.poses[max(min_idx-10, 0):min_idx+10]]\n )\n # use svd to find the approximate tangent direction of longest path\n approx_dir = np.linalg.svd(path_points-np.mean(path_points,axis=0))[2][0]\n self.last_yaw_longestpath = np.arctan2(approx_dir[1], approx_dir[0])\n # perpendicular distance is then the norm of vector\n # (car_pos - pos_point) x approx_dir, x is cross product\n self.last_dist_longestpath = np.linalg.norm(\n np.cross(path_points[0,:] - self.car_pos, approx_dir)\n )\n # publish\n self.pub_closest_dist_longestpath.publish(self.last_dist_longestpath)","def longest_flight(self):\r\n distance = 0\r\n for code, _list in self.edges.items():\r\n for edge in _list:\r\n if edge.distance > distance:\r\n distance = edge.distance\r\n start = edge.start\r\n destination = edge.destination\r\n return start, destination, distance","def radius(self):\n c = self.centroid()\n dmax = -np.inf\n for vertex in self.path.vertices:\n d = np.linalg.norm(vertex - c)\n if d > dmax:\n dmax = d\n return d","def get_lift(self):\n return 0.0","def distance_to_current_waypoint(vehicle):\n nextwaypoint = vehicle.commands.next\n if nextwaypoint==0:\n return None\n missionitem=vehicle.commands[nextwaypoint-1] #commands are zero indexed\n lat = missionitem.x\n lon = missionitem.y\n alt = missionitem.z\n targetWaypointLocation = LocationGlobalRelative(lat,lon,alt)\n distancetopoint = get_distance_metres(vehicle.location.global_frame, targetWaypointLocation)\n return distancetopoint","def distance(self) -> int:\n return 0","def test_shortest_route_from_a_to_c(self):\n railroad = trains.Railroad()\n self.assertEqual(railroad.shortest_route_distance('A', 'C'), 9)","def estimated_distance(self, log=False):\n\t\t\n\t\tx0 = GRAVITY - self.thrust*.95 / (self.total_mass - self.fuel_consumption * 0.0)\n\t\tx1 = GRAVITY - self.thrust*.95 / (self.total_mass - self.fuel_consumption * 1.0)\n\n\t\t# Derivative at x=0 and x=1\n\t\tu = x0\n\t\tv = x1\n\t\t# Initial height at x=0\n\t\ty = abs(self.velocity)\n\n\t\tif log:\n\t\t\tprint(f'u: {u}, v: {v}, y: {y}\\nEstimated distance: {get_positive_area(u, v, y)}\\n')\n\t\t\n\t\treturn get_positive_area(u, v, y)","def total_cost(path: Path) -> float:\n\t\n\tdistance = calc_total_dist(path)\n\tavg_speed = calc_average_speed(path)\n\t\n\t# Speed is less important, but gets a huge multiplier, because speed and\n\t# \tdistance are in different units. Speed requires a high ratio to have\n\t# \tsimilar amounts of variation.\n\tSPEED_DISTANCE_COST_RATIO = 7865.099\n\t\n\treturn (\n\t\t(distance * 1) +\n\t\t(-avg_speed * SPEED_DISTANCE_COST_RATIO)\n\t)","def _earth_distance(time='now'):\n return get_earth(time).radius","def get_position_total_distance_on_bike(self, user_id: int):\n return self._get_position_total_distance(user_id, [ActivityType.Ride])","def altitude(self):\r\n pressure = self.pressure # in Si units for hPascal\r\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))","def GetDistanceFromDropPoint(self):\n return self.distanceFromDropPoint","def calcPath(self):\n return None","def test_distance_aebcd(self):\n railroad = trains.Railroad()\n self.assertEqual(railroad.distance('AEBCD'), '22')","def player_goal_distance(self) -> float:\n route = self.best_route\n return sum(route.values())","def getEdgeDistance():\n '''\n a\n ◿\n b c\n\n hypotenuse\n ◿ adjacent\n opposite\n\n tan(a) = opposite/adjacent\n adjacent * tan(a) = opposite\n '''\n\n # An estimated multiplier to take into account the larger infrared dot\n # observed when further away from as surface - think torch beam onto a\n # wall getting larger as it gets further away, but only the radius\n # (center downwards) being relevant.\n # TODO: Maybe move into infrared sensor code?\n MULTI = 1.2\n\n edgeDistance = BOT_HEIGHT * math.tan(math.radians(getEdgeAngle()))\n edgeDistance *= MULTI\n\n if DEBUG:\n print \"Distance to edge: \", int(round(edgeDistance))\n\n return edgeDistance","def ecliptic_position(self):\n vector = _ECLIPJ2000.dot(self.position.au)\n return Distance(vector)","def get_race_distance(self):\n race_id = self.get_current_race_id(include_horse=False)\n race_id_with_horse = self.get_current_race_id(include_horse=True)\n try:\n distance = self.consolidated_races_db.data.loc[race_id, 'distance']\n return distance\n except KeyError:\n try:\n distance = self.db.data.loc[race_id_with_horse, 'distance']\n return distance\n except KeyError:\n self.verbose_print(f'No race distance info found for {self.current_race_id}')\n return None","def topo_diameter(self):\n import math\n \n Temp = 0\n for i in range(self.nodenum):\n for j in range(self.nodenum):\n pathlist = []\n self.pathij(i, j, pathlist)\n distance = []\n \n for k in range(len(pathlist)):\n distance.append(len(pathlist[k]) - 1)\n \n if(len(distance) == 0):\n continue\n else:\n if(min(distance) >= Temp):\n Temp = min(distance)\n \n self.topodiameter = Temp","def euclidean_distance(self):\n return sqrt(pow((self.goal_pose.x - self.ground_truth_pose.x), 2) +\n pow((self.goal_pose.y - self.ground_truth_pose.y), 2))","def computeExactPathDistance(self, path: str):\n\n if not path:\n return 0\n\n if len(path) == 2 and path[0] == path[-1]:\n # Assignment says impossible ¯\\_(ツ)_/¯\n return \"NO SUCH ROUTE\"\n\n # access each path in the hash table, O(N) time of O(1) access ops\n # get the weight of said edge and move on\n index = 0\n distance = 0\n while index < len(path) - 1:\n edgeBubble = path[index: index + 2]\n edge = self.hashTable.get(edgeBubble)\n # bad path given, distance is irrelevant\n if not edge:\n return \"NO SUCH ROUTE\"\n distance += edge.weight\n index += 1\n\n return distance","def _get_distance(reindeer, race_time):\n interval = reindeer.flight_time + reindeer.rest_time\n cycles = race_time // interval\n flight_time = min(reindeer.flight_time, race_time - interval * cycles)\n total_flying_time = reindeer.flight_time * cycles + flight_time\n return total_flying_time * reindeer.flight_speed","def cutoff_distance(self):\n return self._cutoff_distance","def getCutoffDistance(self):\n return self.cutoffDistance","def calculate_distance_edge(self):\n if self.mu > 0:\n # right interface is intersected next\n dx = self.cell_xr - self.x\n self.next_cell_index = self.cell_index + 1\n else:\n # left interface is intersected next\n dx = self.cell_xl - self.x\n self.next_cell_index = self.cell_index - 1\n\n return dx / self.mu","def get_clutch_distance(current_joint_angles, clutch_poses):\n residuals = clutch_poses - current_joint_angles\n # remove tip angles for better performance\n residuals = np.delete(residuals, EXTREMETY_IDX, axis=1)\n distances = np.sum(np.abs(residuals) ** (1. / 2), axis=1) ** 2\n distance = np.min(distances)\n return distance","def path(self):\n return self.alignment.matching_function_bestpath(self.idx)","def get_global_total_distance_on_foot(self):\n return self._get_global_total_distance([ActivityType.Run, ActivityType.Walk])","def findShortestPath(self):\r\n pass","def getBelowDistance(self):\n return self.__belowDistance","def find_minimum_path_cost(cls, start_point: Coordination, current_point: Coordination) -> int:\n return abs(start_point.x - current_point.x) + abs(start_point.y - current_point.y)","def heuristic(current, goal):\r\n # First tried manhattan distance but wasn't good enough so did direct distance which makes sense since the robot came move diagonally \r\n #return abs(current[0]-goal[0])+abs(current[1]-goal[1])\r\n return math.sqrt((current[0]-goal[0])**2+(current[1]-goal[1])**2)","def __find_max_distance(self):\n return utils.find_max_distance(self.__game)","def extract_path(self):\n if self.extracted_path is not None:\n return self.extracted_path\n current = self\n path = []\n while current:\n path.append([current.end, current.path_cost])\n current = current.parent\n return list(reversed(path))","def virtual_distance(self):\n conflict_zone_radio = 384.0\n path_width = 172.0\n right_turn_radio = path_width / 4.0\n left_turn_radio = 3 * path_width / 4.0\n initial_straight_section = conflict_zone_radio - path_width / 2.0\n if self.get_intention() == \"s\":\n virtual_distance_value = self.get_virtual_x_position()\n elif self.get_intention() == \"r\":\n # Calculate real virtual distance\n if self.get_virtual_x_position() <= initial_straight_section:\n virtual_distance_value = self.get_virtual_x_position()\n elif self.get_virtual_y_position() > -right_turn_radio:\n virtual_distance_value = (\n initial_straight_section + atan(\n (\n self.get_virtual_x_position() -\n initial_straight_section\n ) / (right_turn_radio + self.get_virtual_y_position())\n ) * right_turn_radio\n )\n else:\n virtual_distance_value = (\n initial_straight_section + pi * right_turn_radio / 2.0 -\n self.get_virtual_y_position() - right_turn_radio\n )\n\n a = path_width / 2.0\n b = right_turn_radio + path_width / 4.0\n c = pi * right_turn_radio / 2.0\n # Scale virtual distance\n if virtual_distance_value <= initial_straight_section + c:\n virtual_distance_value *= (\n (initial_straight_section + a + b) /\n (initial_straight_section + c)\n )\n else:\n virtual_distance_value += a + b - c\n\n else:\n # Calculate real virtual distance\n if self.get_virtual_x_position() <= initial_straight_section:\n virtual_distance_value = self.get_virtual_x_position()\n elif self.get_virtual_y_position() < left_turn_radio:\n virtual_distance_value = (\n initial_straight_section + atan(\n (\n self.get_virtual_x_position() -\n initial_straight_section\n ) / (\n left_turn_radio -\n self.get_virtual_y_position()\n )\n ) * left_turn_radio\n )\n else:\n virtual_distance_value = (\n initial_straight_section + pi * left_turn_radio / 2 +\n self.get_virtual_y_position() - left_turn_radio\n )\n\n a = path_width / 2\n b = right_turn_radio + path_width / 4\n c = pi * left_turn_radio / 2\n # Scale virtual distance\n if virtual_distance_value <= initial_straight_section + c:\n virtual_distance_value *= (\n (initial_straight_section + a + b) /\n (initial_straight_section + c)\n )\n else:\n virtual_distance_value += a + b - c\n\n return virtual_distance_value","def time_for_travel(self):\n return great_circle(self.pickupcoords, self.dropoffcoords).miles * 3600 / 25","def crack_legth_compute(self):\n crack_grad = self.gradient(4,5)\n avegrad = self.average_grad()\n cracklen = self.distance(self.points[4,:],self.points[5,:])\n #print(\"photo_crack_len\", cracklen)\n\n #print(\"Crack_grad:\", crack_grad)\n\n angle_between_crack_and_vertical = np.arctan(np.abs((crack_grad - avegrad)/(1+crack_grad*avegrad)))\n #print(\"angle between crack and vertical: \", np.rad2deg(angle_between_crack_and_vertical),\"degrees\")\n\n\n h_dist = np.sin(angle_between_crack_and_vertical)*cracklen\n h_rel = h_dist/self.hline[2]\n #print('relative horizontal_crack distance:', h_rel)\n v_dist = np.cos(angle_between_crack_and_vertical)*cracklen\n v_rel = v_dist / self.vline[2]\n #print('relative vertical_crack distance:', v_rel)\n\n actual_crack_length = np.sqrt((h_rel*self.cut_breadth)**2 + (v_rel*self.cut_depth)**2)\n\n #print(\"Actual_crack_length\\n,\", actual_crack_length)\n print(actual_crack_length) # This is later writen to a text file and read into the main program\n\n return actual_crack_length","def one_way_path(most_important, total_distance, to_source2, to_source1):\n\n if total_distance == min(total_distance, to_source2[0], to_source1[0]):\n return most_important_to_source(most_important), total_distance\n elif to_source2[0] == min(total_distance, to_source2[0], to_source1[0]):\n return most_important_to_source(to_source2[1]), to_source2[0]\n else:\n return most_important_to_source(to_source1[1], up=False), to_source1[0]","def z_distance(self):\n return self.get_distance(self.Z_INDEX)","def get_distance(self):\n print(\"voici la distance à l'obstacle\")"],"string":"[\n \"def closest_cruising_altitude(altitude):\\n return 1000 * ((altitude + 500) // 1000)\",\n \"def find_closest_path(self):\\n\\t\\tclosest_distance = sys.maxint\\n\\t\\tclosest_path = 0\\n\\t\\tbike_position = (self.map_model.bike.xB, self.map_model.bike.yB)\\n\\t\\tfor path_index in range(len(self.map_model.paths)):\\n\\t\\t\\tnearest_point = geometry.nearest_point_on_path(self.map_model.paths[path_index], bike_position)\\n\\t\\t\\tdistance_to_bike = geometry.distance(nearest_point, bike_position)\\n\\t\\t\\tif (closest_distance > distance_to_bike):\\n\\t\\t\\t\\tclosest_distance = distance_to_bike\\n\\t\\t\\t\\tclosest_path = path_index \\n\\t\\tdisp_next = self.displacement_to_turn(target_path = (closest_path+1)%len(self.map_model.paths))\\n\\t\\ttarget_path = (closest_path+1)%len(self.map_model.paths)\\n\\t\\tdistance_next = geometry.distance_from_path(bike_position, self.map_model.paths[target_path])\\n\\t\\tif disp_next - np.abs(distance_next)>-0.01:\\n\\t\\t\\tclosest_path = np.mod(closest_path + 1,len(self.map_model.paths))\\n\\t\\treturn closest_path\",\n \"def get_closest_distance_to_path(self, path):\\n min_distance_to_line = float(\\\"inf\\\")\\n for p in path:\\n game_path = p[:]\\n\\n game_path.sort(key = lambda coord: calculate_distance(self, coord))\\n point_A = game_path[0] # Closest point out of all the points on the path to to the tower\\n\\n try:\\n point_after_A = p[p.index(point_A) + 1]\\n point_before_A = p[p.index(point_A) - 1]\\n closest_to_A = min(point_after_A, point_before_A, key = lambda point: calculate_distance(point_A, point))\\n except:\\n if p.index(point_A) == 0:\\n closest_to_A = p[p.index(point_A) + 1]\\n \\n elif p.index(point_A) == len(p) - 1:\\n closest_to_A = p[p.index(point_A) - 1]\\n finally:\\n if closest_to_A[0] != point_A[0]:\\n m = (closest_to_A[1] - point_A[1]) / (closest_to_A[0] - point_A[0])\\n else:\\n m = 2\\n\\n b = point_A[1] - m * point_A[0]\\n\\n closest_distance = abs(-m * self.x + self.y - b) / math.sqrt((-m) ** 2 + 1)\\n min_distance_to_line = min(closest_distance, min_distance_to_line)\\n \\n return min_distance_to_line\",\n \"def top_distance(self):\\n return self.y\",\n \"def top_of_climb_index(self):\\n return self.altitudes.argmax()\",\n \"def top_of_descent_index(self):\\n tod = self.altitudes.argmax()\\n # if the altitude profile is not just a climb\\n # and there is a cruising section\\n if (tod < len(self.altitudes) - 1) and \\\\\\n (self.altitudes[tod] == self.altitudes[tod + 1]):\\n tod += 1\\n\\n return tod\",\n \"def top_of_descent_distance(self):\\n return self.distances[self.top_of_descent_index()]\",\n \"def lidar_relative(self):\\n return self.distance\",\n \"def get_path_distance(self, path):\\n distance = VectorMath.get_magnitude(self.drone.get_point(), path[0])\\n for index in range(len(path[:-1])):\\n distance += VectorMath.get_magnitude(path[index], path[index + 1])\\n distance += VectorMath.get_magnitude(path[-1], self.drone.get_waypoint_holder().get_current_waypoint())\\n\\n if abs(self.drone.get_point()[2] - path[0][2]) > 1:\\n distance *= Constants.VERTICAL_PATH_WEIGHTING_MULTIPLE\\n\\n return distance\",\n \"def get_true_bearing(shot, top):\\n tripidx = shot[\\\"trip\\\"]\\n\\n if tripidx != -1:\\n decl = top[\\\"trips\\\"][tripidx][KEY_DECLINATION]\\n else:\\n decl = 0\\n\\n return shot[\\\"compass\\\"] + decl\",\n \"def GetAbsBeer(epsilon, conc, pathLength):\\n return epsilon * conc * pathLength\",\n \"def getDistance(self):\\n taBox = (self.thor * self.tvert)/(720*960) #box area as percentage of whole\\n if(taBox==None or taBox<=0): return -1\\n const = 4 * math.tan(0.471)*math.tan(0.3576)\\n return math.sqrt((self.abox)/(const*taBox))\",\n \"def test_triangle_get_shortest_altitude(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)\",\n \"def distance_to_current_waypoint(self):\\n next_waypoint = self.vehicle.commands.next\\n if next_waypoint == 1:\\n return None\\n mission_item = self.vehicle.commands[next_waypoint]\\n lat = mission_item.x\\n lon = mission_item.y\\n alt = mission_item.z\\n waypoint_location = Location(lat, lon, alt, is_relative=True)\\n distance = get_distance_meters(self.vehicle.location, waypoint_location)\\n return distance\",\n \"def get_global_total_distance_on_bike(self):\\n return self._get_global_total_distance([ActivityType.Ride])\",\n \"def _plunge_distance(self, volume):\\n percent = self._volume_percentage(volume)\\n top = self._get_plunger_position('top')\\n bottom = self._get_plunger_position('bottom')\\n travel = bottom - top\\n if travel <= 0:\\n self.robot.add_warning('Plunger calibrated incorrectly')\\n return travel * percent\",\n \"def get_distance(self):\\n\\n # Activate trigger\\n self.trigger()\\n\\n # Detect rising edge of echo pin\\n channel = GPIO.wait_for_edge(self.echo_pin, GPIO.RISING, timeout=2)\\n if channel is None:\\n # Timeout on wait of rising interrupt\\n return None\\n else:\\n # Rising edge detected, save pulse start\\n pulse_start = time.time()\\n\\n\\n # Detect falling edge of echo pin\\n channel = GPIO.wait_for_edge(self.echo_pin, GPIO.FALLING, timeout=2)\\n if channel is None:\\n # Timeout on wait of falling interrupt\\\")\\n return None\\n else:\\n # Falling edge detected, save pulse end\\n pulse_end = time.time()\\n\\n # Calculated pulse width in microseconds (x1mln)\\n pulse_width = (pulse_end - pulse_start)*1000000\\n\\n # Return distance in cm\\n return pulse_width / 58\",\n \"def evaluatePath(self):\\n pathLength = 0\\n if len(self.path) > 0:\\n previousCity = self.path[0]\\n for ind in range(1, len(self.path)):\\n pathLength += previousCity.distanceWith(self.path[ind].name)\\n previousCity = self.path[ind]\\n return pathLength\",\n \"def altitude(self):\\n if self.__altitude:\\n return sum(self.__altitude) / len(self.__altitude)\\n else:\\n return -9999\",\n \"def get_best_move_toward(self, target_ground):\\n options_by_parent, cost_to_reach = self.a_star_search(start=self.ground, goal=target_ground)\\n ground = target_ground\\n\\n # Can't reach it?\\n if ground not in options_by_parent:\\n return None\\n\\n while options_by_parent[ground] is not self.ground:\\n ground = options_by_parent[ground]\\n\\n return ground.x - self.ground.x, ground.y - self.ground.y\",\n \"def distance_to_current_waypoint():\\n nextwaypoint = vehicle.commands.next\\n if nextwaypoint == 0:\\n return None\\n missionitem = vehicle.commands[nextwaypoint -\\n 1] #commands are zero indexed\\n lat = missionitem.x\\n lon = missionitem.y\\n alt = missionitem.z\\n targetWaypointLocation = LocationGlobalRelative(lat, lon, alt)\\n distancetopoint = get_distance_metres(vehicle.location.global_frame,\\n targetWaypointLocation)\\n return distancetopoint\",\n \"def getDistance(self):\\n return sqrt(self.state[0] * self.state[0] + self.state[2] * self.state[2])\",\n \"def GetEpsilonBeer(Abs, conc, pathLength):\\n return Abs / (conc * pathLength)\",\n \"def _distance_next(self):\\n\\n self.distance = 10\\n\\n # Here a set index to 0 if the car is finishing a lap\\n # Also reset the farthest\\n if self.index > (len(self.x_trajectory) - 6) and self.closed:\\n self.index = 0\\n self.farthest = -1\\n self.laps += 1\\n\\n for w in range(self.index, self.index + 20):\\n\\n self.dist_point = math.sqrt((self.x_trajectory[w] - self.x)**2\\n + (self.y_trajectory[w] - self.y)**2)\\n\\n if self.dist_point < self.distance:\\n self.distance = self.dist_point\\n self.index = w\\n\\n if w >= (len(self.x_trajectory) - 1):\\n break\\n\\n self._calc_side()\\n\\n self.distance = self.distance * self.sign\\n\\n return self.distance\",\n \"def calculate_made_up_dist(self):\\n\\n # Ensure if current state equals goal, cost is only the current cost\\n if self._goal_loc == self._current_loc:\\n return self._current_cost\\n\\n # Distance is at least the Manhattan distance as cannot move diagonal\\n estimated_distance = self.calculate_manhattan_dist()\\n\\n # Assume two board parts in the priority queue have the same weight.\\n # For those board paths with higher actual cost and lower heuristic\\n # cost, there is more assurance in the accuracy of the actual cost\\n # than in the heuristic cost. Give a very small penalty (i.e. less\\n # than one step) to prefer a path with a higher known cost than a\\n # path with a higher heuristic cost.\\n # Extract the number of portion of the move cost from the heuristic\\n heuristic_cost = estimated_distance - self._current_cost\\n # Heuristic cost penalty is normalized to a maximum of 0.1 steps\\n # This is achieved by dividing the heuristic cost by the size of the\\n # board. Since the heuristic cost can never be larger than the board\\n # size, this quotient is less than or equal to 1. To normalize to a\\n # maximum of 0.1, just multiply the number by 0.1. This is than added\\n # to the estimated distance determined so far.\\n heuristic_cost_penalty = 0.1 * heuristic_cost\\n heuristic_cost_penalty /= BoardPath._traversed_board_size\\n # Add what is essentially an \\\"uncertainty penalty\\\"\\n estimated_distance += heuristic_cost_penalty\\n\\n # In case where all neighboring spaces are blocked or already\\n # traversed, then set the path cost prohibitively large so it is\\n # given minimum priority.\\n if not (self.is_move_valid(\\\"d\\\", BoardPath._traversed_board)) \\\\\\n and not (self.is_move_valid(\\\"u\\\", BoardPath._traversed_board)) \\\\\\n and not (self.is_move_valid(\\\"l\\\", BoardPath._traversed_board)) \\\\\\n and not (self.is_move_valid(\\\"r\\\", BoardPath._traversed_board)):\\n # Total board area is sufficient as a prohibitive distance\\n estimated_distance += BoardPath._traversed_board_size\\n return estimated_distance\\n\\n # If all next steps that load directly to the goal are blocked, then\\n # it takes at least two additional moves to get around the blocked\\n # paths it (due to an obstacle or already traversed square) so add\\n # two to the estimated distance to include that cost.\\n if self._is_all_direct_next_moves_blocked(BoardPath._traversed_board):\\n estimated_distance += 2\\n\\n # In a heap, if two nodes have the same cost, the object that was\\n # put into the heap first in many implementations will be on top of the\\n # heap. To make the algorithm more efficient, apply a slight penalty to\\n # a non valid solution to ensure if an invalid solution and a valid\\n # solution have the same cost that the valid solution would always be\\n # on top of the heap. This is done by giving all non-valid solutions a\\n # penalty term that is greater than zero and less than the minimum step\\n # size (e.g. in this case 0 < 0.1 < 1).\\n estimated_distance += 0.1\\n\\n # Return estimated distance\\n return estimated_distance\",\n \"def well_diameter_at_top(self):\\n return self.radius_from_liquid_depth(self.well_depth) * 2 # a generic impl; subclasses can optimize\",\n \"def GetTotalDurationOfPath(PathInfo):\\r\\n\\tif PathInfo == None: return 0\\r\\n\\tif len(PathInfo) < 2: return 0\\r\\n\\t\\r\\n\\tdeparture_first_station = PathInfo[0][ConnInfoInd['arrival_hour']]*60 + PathInfo[0][ConnInfoInd['arrival_min']]\\r\\n\\t# departure_first_station = PathInfo[1][ConnInfoInd['departure_hour']]*60 + PathInfo[1][ConnInfoInd['departure_min']]\\r\\n\\r\\n\\tarrival_last_station = PathInfo[-1][ConnInfoInd['arrival_hour']]*60 + PathInfo[-1][ConnInfoInd['arrival_min']]\\r\\n\\treturn (arrival_last_station - departure_first_station)\",\n \"def calc_distance(self, observation):\\n actual_obs = observation[0]\\n scrn_player = actual_obs.observation.feature_screen.player_relative\\n scrn_select = actual_obs.observation.feature_screen.selected\\n scrn_density = actual_obs.observation.feature_screen.unit_density\\n\\n state_added = scrn_select + scrn_density\\n\\n marine_center = np.mean(self.xy_locs(scrn_player == 1), axis=0).round()\\n\\n # first step\\n if np.sum(scrn_select) == 0:\\n marine_center = np.mean(self.xy_locs(scrn_player == 1), axis=0).round()\\n # marine behind beacon\\n if isinstance(marine_center, float):\\n marine_center = np.mean(self.xy_locs(state_added == 2), axis=0).round()\\n else:\\n # normal navigation\\n marine_center = np.mean(self.xy_locs(state_added == 2), axis=0).round()\\n if isinstance(marine_center, float):\\n marine_center = np.mean(self.xy_locs(state_added == 3), axis=0).round()\\n\\n beacon_center = np.mean(self.xy_locs(scrn_player == 3), axis=0).round()\\n #\\n # print(state_added)\\n # print(\\\"---- Marine {} | {} Beacon ----\\\".format(marine_center, beacon_center))\\n # time.sleep(0.2)\\n distance = math.hypot(beacon_center[0] - marine_center[0],\\n beacon_center[1] - marine_center[1])\\n\\n return beacon_center, marine_center, distance\",\n \"def test_triangle_get_longest_altitude(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_longest_altitude(), 9.428090415820634)\",\n \"def find_path(self):\\n \\n if self.line_num != -1:\\n return self.line_num\\n\\n max_line = self.graph.gps_length - 1\\n min_line = 0\\n #last_id = dg.normalize(self.graph.lines[-1])[0]\\n last_id = normalize_simple(self.graph.lines[-1])[0]\\n pivot = int((self.trip_id-1)/float(last_id)*self.graph.gps_length)\\n #cur_id = dg.normalize(self.graph.lines[pivot])[0]\\n cur_id = normalize_simple(self.graph.lines[pivot])[0]\\n while cur_id != self.trip_id:\\n if cur_id < self.trip_id:\\n min_line = pivot\\n else:\\n max_line = pivot\\n #TODO: could make this run in essentially constant time by hopping predetermined distance\\n pivot = (min_line + max_line) / 2\\n #cur_id = dg.normalize(self.graph.lines[pivot])[0]\\n cur_id = normalize_simple(self.graph.lines[pivot])[0]\\n\\n #while dg.normalize(self.graph.lines[pivot])[0] == self.trip_id:\\n while normalize_simple(self.graph.lines[pivot])[0] == self.trip_id:\\n pivot -= 1\\n\\n pivot += 1\\n self.line_num = pivot\\n return pivot\",\n \"def get_last_flight(self):\\n return self.path[len(self.path) - 1]\",\n \"def diversion(self) -> Optional[\\\"Flight\\\"]:\\n from ..data import airports\\n\\n # The following cast secures the typing\\n self = cast(\\\"Flight\\\", self)\\n\\n f_above: Optional[\\\"Flight\\\"] = self.query(\\\"altitude > 15000\\\")\\n if (\\n self.destination != self.destination\\n or airports[self.destination] is None # type: ignore\\n or f_above is None\\n ):\\n return None\\n\\n return (\\n f_above.distance(airports[self.destination]) # type: ignore\\n .diff(\\\"distance\\\")\\n .agg_time(\\\"10T\\\", distance_diff=\\\"mean\\\")\\n .query(\\\"distance_diff > 0\\\")\\n )\",\n \"def get_distance(self) -> int:\\n return self.get_measurement_data().distance\",\n \"def get_path_distance(self, path):\\n length = len(path)\\n distance = 0\\n for i in range(length):\\n distance += self.distances[path[i]][path[(i + 1) % length]]\\n return distance\",\n \"def _find_fastest_path(self):\\n from simulator import Robot\\n clone_robot = Robot(exploration_status=self._robot.exploration_status,\\n facing=self._robot.facing,\\n discovered_map=self._robot.discovered_map,\\n real_map=[[0] * 15 for _ in range(20)])\\n\\n fastest_path_start_way_point = get_shortest_path_moves(clone_robot,\\n start=(1, 1),\\n goal=self._way_point)\\n\\n if fastest_path_start_way_point:\\n for move in fastest_path_start_way_point:\\n clone_robot.move_robot(move)\\n\\n before_way_point = previous_cell(clone_robot.center, clone_robot.facing)\\n\\n fastest_path_way_point_goal = get_shortest_path_moves(clone_robot,\\n start=self._way_point,\\n goal=(18, 13),\\n before_start_point=before_way_point)\\n\\n return fastest_path_start_way_point + fastest_path_way_point_goal\",\n \"def get_min_distance(self):\\n return round(min(self.combined_euclidian_distance))\",\n \"def altitude(self) -> int:\\n return self._point.altitude\",\n \"def _get_distance(self, target): \\r\\n sensor_transform = self._sensors['rgb_front'].get_transform()\\r\\n\\r\\n distance = np.sqrt(\\r\\n (sensor_transform.location.x - target.x) ** 2 +\\r\\n (sensor_transform.location.y - target.y) ** 2 +\\r\\n (sensor_transform.location.z - target.z) ** 2)\\r\\n\\r\\n return distance\",\n \"def path(most_important_up, most_important_down, total_distance, to_source2, to_source1):\\n\\n if total_distance == min(total_distance, to_source2[0], to_source1[0]):\\n return source_to_source(most_important_up, most_important_down), total_distance\\n elif to_source2[0] == min(total_distance, to_source2[0], to_source1[0]):\\n return most_important_to_source(to_source2[1]), to_source2[0]\\n else:\\n return most_important_to_source(to_source1[1], up=False), to_source1[0]\",\n \"def measure_distance(self):\\n # set Trigger to HIGH\\n GPIO.output(self.GPIO_TRIGGER, True)\\n\\n # set Trigger after 0.01ms to LOW\\n time.sleep(0.00001)\\n GPIO.output(self.GPIO_TRIGGER, False)\\n\\n start_time = time.time()\\n stop_time = time.time()\\n\\n # save StartTime\\n while GPIO.input(self.GPIO_ECHO) == 0:\\n start_time = time.time()\\n\\n # save time of arrival\\n while GPIO.input(self.GPIO_ECHO) == 1:\\n stop_time = time.time()\\n\\n # time difference between start and arrival\\n time_elapsed = stop_time - start_time\\n # multiply with the sonic speed (343.00 m/s)\\n # and divide by 2, because there and back\\n distance = (time_elapsed * 343.00) / 2\\n\\n return distance\",\n \"def get_distance(self):\\n values = self.speakers.values()\\n values.sort(reverse=True)\\n try:\\n return abs(values[1]) - abs(values[0])\\n except (IndexError, ValueError):\\n return -1\",\n \"def get_distance(self, heuristic=\\\"\\\"):\\n # If no heuristic is specified, used the default\\n if(heuristic == \\\"\\\"):\\n heuristic = BoardPath._heuristic\\n\\n if(heuristic == \\\"manhattan\\\"):\\n return self.calculate_manhattan_dist()\\n elif(heuristic == \\\"euclidean\\\"):\\n return self.calculate_euclidean_dist()\\n elif(heuristic == \\\"made_up\\\"):\\n return self.calculate_made_up_dist()\\n else:\\n sys.exit()\",\n \"def h_score(self):\\n if self.estimated_moves_to_goal is None:\\n self.estimated_moves_to_goal = \\\\\\n max(nx.single_source_shortest_path_length(self.graph, self.head_node).items(), key=lambda x: x[1])[1]\\n return self.estimated_moves_to_goal\",\n \"def distance(self) -> float:\\n return self._dist_two_wire() # at this time we only support 2-wire meausre\",\n \"def _distance_covered(self):\\n\\n # Calculation of distance traveled compared to the previous point\\n self.gap = math.sqrt((self.x - self.x_ant)**2\\n + (self.y - self.y_ant)**2)\\n\\n self.x_ant = self.x\\n self.y_ant = self.y\\n\\n return self.gap\",\n \"def elevation(self):\\n return self.altitude - self.heightAboveGround\",\n \"def path_cost(path):\\n # path = [state, (action, total_cost), state, ... ]\\n if len(path) < 2:\\n return 0\\n else:\\n return path[-2][-1]\",\n \"def _calculate_h(self, end):\\n return PATH_COST * (abs(self.x - end.x) + abs(self.y - end.y))\",\n \"def distance(self):\\n return Distance(length_of(self.position.au))\",\n \"def bottom(self) -> float:\\n bottom = 0\\n for part in self.line_parts:\\n if part.state.rise < 0 and -part.state.rise > bottom:\\n bottom = -part.state.rise\\n return bottom\",\n \"def GetConcBeer(Abs, epsilon, pathLength):\\n return Abs / (epsilon * pathLength)\",\n \"def getAltitudeAngle(self):\\n return self._altitude\",\n \"def lidar_absolute(self):\\n return np.roll(self.distance, self.heading_idx)\",\n \"def get_closest_waypoint(self, pose):\\n if self.kdtree:\\n return kdtree_closest_point(self.kdtree,\\n (pose.x,\\n pose.y))\\n else:\\n return 0\",\n \"def get_closest_waypoint(self, pose):\\n if self.kdtree:\\n return kdtree_closest_point(self.kdtree,\\n (pose.position.x,\\n pose.position.y))\\n else:\\n return 0\",\n \"def calculate_path(self):\\n\\n mid_states = []\\n\\n # Add in between states\\n for i in range(Constants.NUMBER_LAPS):\\n mid_states = mid_states + Constants.LAP_STATES\\n\\n # Concatenate beginning, middle and end states to obtain full path of states\\n self.path_states = Constants.BEGINNING_STATES + mid_states + Constants.END_STATES\\n\\n # Determine the amount of times that the smallbot will drive forward during the path\\n self.times_driven_forward = self.path_states.count('CREEP_FORWARD')\\n\\n print(\\\"Calculated path: \\\", self.path_states)\",\n \"def manhatam_distance(self) -> int:\\n return abs(self.north) + abs(self.east)\",\n \"def wind_bearing(self) -> float:\\r\\n return self._first_timeserie[\\\"data\\\"][\\\"instant\\\"][\\\"details\\\"][\\r\\n \\\"wind_from_direction\\\"\\r\\n ]\",\n \"def getAboveDistance(self):\\n return self.__aboveDistance\",\n \"def longest_path_callback(self, data):\\n min_idx = self.find_minimum_distance(data.poses) # closest point index\\n if min_idx is None:\\n return\\n else:\\n # extract 20 points along the closest point\\n # use z position of ego car since z displacement doesn't matter\\n # truncate if encounter head or tail\\n path_points = np.array([\\n (pose.pose.position.x, pose.pose.position.y, self.car_pos[2])\\n for pose in data.poses[max(min_idx-10, 0):min_idx+10]]\\n )\\n # use svd to find the approximate tangent direction of longest path\\n approx_dir = np.linalg.svd(path_points-np.mean(path_points,axis=0))[2][0]\\n self.last_yaw_longestpath = np.arctan2(approx_dir[1], approx_dir[0])\\n # perpendicular distance is then the norm of vector\\n # (car_pos - pos_point) x approx_dir, x is cross product\\n self.last_dist_longestpath = np.linalg.norm(\\n np.cross(path_points[0,:] - self.car_pos, approx_dir)\\n )\\n # publish\\n self.pub_closest_dist_longestpath.publish(self.last_dist_longestpath)\",\n \"def longest_flight(self):\\r\\n distance = 0\\r\\n for code, _list in self.edges.items():\\r\\n for edge in _list:\\r\\n if edge.distance > distance:\\r\\n distance = edge.distance\\r\\n start = edge.start\\r\\n destination = edge.destination\\r\\n return start, destination, distance\",\n \"def radius(self):\\n c = self.centroid()\\n dmax = -np.inf\\n for vertex in self.path.vertices:\\n d = np.linalg.norm(vertex - c)\\n if d > dmax:\\n dmax = d\\n return d\",\n \"def get_lift(self):\\n return 0.0\",\n \"def distance_to_current_waypoint(vehicle):\\n nextwaypoint = vehicle.commands.next\\n if nextwaypoint==0:\\n return None\\n missionitem=vehicle.commands[nextwaypoint-1] #commands are zero indexed\\n lat = missionitem.x\\n lon = missionitem.y\\n alt = missionitem.z\\n targetWaypointLocation = LocationGlobalRelative(lat,lon,alt)\\n distancetopoint = get_distance_metres(vehicle.location.global_frame, targetWaypointLocation)\\n return distancetopoint\",\n \"def distance(self) -> int:\\n return 0\",\n \"def test_shortest_route_from_a_to_c(self):\\n railroad = trains.Railroad()\\n self.assertEqual(railroad.shortest_route_distance('A', 'C'), 9)\",\n \"def estimated_distance(self, log=False):\\n\\t\\t\\n\\t\\tx0 = GRAVITY - self.thrust*.95 / (self.total_mass - self.fuel_consumption * 0.0)\\n\\t\\tx1 = GRAVITY - self.thrust*.95 / (self.total_mass - self.fuel_consumption * 1.0)\\n\\n\\t\\t# Derivative at x=0 and x=1\\n\\t\\tu = x0\\n\\t\\tv = x1\\n\\t\\t# Initial height at x=0\\n\\t\\ty = abs(self.velocity)\\n\\n\\t\\tif log:\\n\\t\\t\\tprint(f'u: {u}, v: {v}, y: {y}\\\\nEstimated distance: {get_positive_area(u, v, y)}\\\\n')\\n\\t\\t\\n\\t\\treturn get_positive_area(u, v, y)\",\n \"def total_cost(path: Path) -> float:\\n\\t\\n\\tdistance = calc_total_dist(path)\\n\\tavg_speed = calc_average_speed(path)\\n\\t\\n\\t# Speed is less important, but gets a huge multiplier, because speed and\\n\\t# \\tdistance are in different units. Speed requires a high ratio to have\\n\\t# \\tsimilar amounts of variation.\\n\\tSPEED_DISTANCE_COST_RATIO = 7865.099\\n\\t\\n\\treturn (\\n\\t\\t(distance * 1) +\\n\\t\\t(-avg_speed * SPEED_DISTANCE_COST_RATIO)\\n\\t)\",\n \"def _earth_distance(time='now'):\\n return get_earth(time).radius\",\n \"def get_position_total_distance_on_bike(self, user_id: int):\\n return self._get_position_total_distance(user_id, [ActivityType.Ride])\",\n \"def altitude(self):\\r\\n pressure = self.pressure # in Si units for hPascal\\r\\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))\",\n \"def GetDistanceFromDropPoint(self):\\n return self.distanceFromDropPoint\",\n \"def calcPath(self):\\n return None\",\n \"def test_distance_aebcd(self):\\n railroad = trains.Railroad()\\n self.assertEqual(railroad.distance('AEBCD'), '22')\",\n \"def player_goal_distance(self) -> float:\\n route = self.best_route\\n return sum(route.values())\",\n \"def getEdgeDistance():\\n '''\\n a\\n ◿\\n b c\\n\\n hypotenuse\\n ◿ adjacent\\n opposite\\n\\n tan(a) = opposite/adjacent\\n adjacent * tan(a) = opposite\\n '''\\n\\n # An estimated multiplier to take into account the larger infrared dot\\n # observed when further away from as surface - think torch beam onto a\\n # wall getting larger as it gets further away, but only the radius\\n # (center downwards) being relevant.\\n # TODO: Maybe move into infrared sensor code?\\n MULTI = 1.2\\n\\n edgeDistance = BOT_HEIGHT * math.tan(math.radians(getEdgeAngle()))\\n edgeDistance *= MULTI\\n\\n if DEBUG:\\n print \\\"Distance to edge: \\\", int(round(edgeDistance))\\n\\n return edgeDistance\",\n \"def ecliptic_position(self):\\n vector = _ECLIPJ2000.dot(self.position.au)\\n return Distance(vector)\",\n \"def get_race_distance(self):\\n race_id = self.get_current_race_id(include_horse=False)\\n race_id_with_horse = self.get_current_race_id(include_horse=True)\\n try:\\n distance = self.consolidated_races_db.data.loc[race_id, 'distance']\\n return distance\\n except KeyError:\\n try:\\n distance = self.db.data.loc[race_id_with_horse, 'distance']\\n return distance\\n except KeyError:\\n self.verbose_print(f'No race distance info found for {self.current_race_id}')\\n return None\",\n \"def topo_diameter(self):\\n import math\\n \\n Temp = 0\\n for i in range(self.nodenum):\\n for j in range(self.nodenum):\\n pathlist = []\\n self.pathij(i, j, pathlist)\\n distance = []\\n \\n for k in range(len(pathlist)):\\n distance.append(len(pathlist[k]) - 1)\\n \\n if(len(distance) == 0):\\n continue\\n else:\\n if(min(distance) >= Temp):\\n Temp = min(distance)\\n \\n self.topodiameter = Temp\",\n \"def euclidean_distance(self):\\n return sqrt(pow((self.goal_pose.x - self.ground_truth_pose.x), 2) +\\n pow((self.goal_pose.y - self.ground_truth_pose.y), 2))\",\n \"def computeExactPathDistance(self, path: str):\\n\\n if not path:\\n return 0\\n\\n if len(path) == 2 and path[0] == path[-1]:\\n # Assignment says impossible ¯\\\\_(ツ)_/¯\\n return \\\"NO SUCH ROUTE\\\"\\n\\n # access each path in the hash table, O(N) time of O(1) access ops\\n # get the weight of said edge and move on\\n index = 0\\n distance = 0\\n while index < len(path) - 1:\\n edgeBubble = path[index: index + 2]\\n edge = self.hashTable.get(edgeBubble)\\n # bad path given, distance is irrelevant\\n if not edge:\\n return \\\"NO SUCH ROUTE\\\"\\n distance += edge.weight\\n index += 1\\n\\n return distance\",\n \"def _get_distance(reindeer, race_time):\\n interval = reindeer.flight_time + reindeer.rest_time\\n cycles = race_time // interval\\n flight_time = min(reindeer.flight_time, race_time - interval * cycles)\\n total_flying_time = reindeer.flight_time * cycles + flight_time\\n return total_flying_time * reindeer.flight_speed\",\n \"def cutoff_distance(self):\\n return self._cutoff_distance\",\n \"def getCutoffDistance(self):\\n return self.cutoffDistance\",\n \"def calculate_distance_edge(self):\\n if self.mu > 0:\\n # right interface is intersected next\\n dx = self.cell_xr - self.x\\n self.next_cell_index = self.cell_index + 1\\n else:\\n # left interface is intersected next\\n dx = self.cell_xl - self.x\\n self.next_cell_index = self.cell_index - 1\\n\\n return dx / self.mu\",\n \"def get_clutch_distance(current_joint_angles, clutch_poses):\\n residuals = clutch_poses - current_joint_angles\\n # remove tip angles for better performance\\n residuals = np.delete(residuals, EXTREMETY_IDX, axis=1)\\n distances = np.sum(np.abs(residuals) ** (1. / 2), axis=1) ** 2\\n distance = np.min(distances)\\n return distance\",\n \"def path(self):\\n return self.alignment.matching_function_bestpath(self.idx)\",\n \"def get_global_total_distance_on_foot(self):\\n return self._get_global_total_distance([ActivityType.Run, ActivityType.Walk])\",\n \"def findShortestPath(self):\\r\\n pass\",\n \"def getBelowDistance(self):\\n return self.__belowDistance\",\n \"def find_minimum_path_cost(cls, start_point: Coordination, current_point: Coordination) -> int:\\n return abs(start_point.x - current_point.x) + abs(start_point.y - current_point.y)\",\n \"def heuristic(current, goal):\\r\\n # First tried manhattan distance but wasn't good enough so did direct distance which makes sense since the robot came move diagonally \\r\\n #return abs(current[0]-goal[0])+abs(current[1]-goal[1])\\r\\n return math.sqrt((current[0]-goal[0])**2+(current[1]-goal[1])**2)\",\n \"def __find_max_distance(self):\\n return utils.find_max_distance(self.__game)\",\n \"def extract_path(self):\\n if self.extracted_path is not None:\\n return self.extracted_path\\n current = self\\n path = []\\n while current:\\n path.append([current.end, current.path_cost])\\n current = current.parent\\n return list(reversed(path))\",\n \"def virtual_distance(self):\\n conflict_zone_radio = 384.0\\n path_width = 172.0\\n right_turn_radio = path_width / 4.0\\n left_turn_radio = 3 * path_width / 4.0\\n initial_straight_section = conflict_zone_radio - path_width / 2.0\\n if self.get_intention() == \\\"s\\\":\\n virtual_distance_value = self.get_virtual_x_position()\\n elif self.get_intention() == \\\"r\\\":\\n # Calculate real virtual distance\\n if self.get_virtual_x_position() <= initial_straight_section:\\n virtual_distance_value = self.get_virtual_x_position()\\n elif self.get_virtual_y_position() > -right_turn_radio:\\n virtual_distance_value = (\\n initial_straight_section + atan(\\n (\\n self.get_virtual_x_position() -\\n initial_straight_section\\n ) / (right_turn_radio + self.get_virtual_y_position())\\n ) * right_turn_radio\\n )\\n else:\\n virtual_distance_value = (\\n initial_straight_section + pi * right_turn_radio / 2.0 -\\n self.get_virtual_y_position() - right_turn_radio\\n )\\n\\n a = path_width / 2.0\\n b = right_turn_radio + path_width / 4.0\\n c = pi * right_turn_radio / 2.0\\n # Scale virtual distance\\n if virtual_distance_value <= initial_straight_section + c:\\n virtual_distance_value *= (\\n (initial_straight_section + a + b) /\\n (initial_straight_section + c)\\n )\\n else:\\n virtual_distance_value += a + b - c\\n\\n else:\\n # Calculate real virtual distance\\n if self.get_virtual_x_position() <= initial_straight_section:\\n virtual_distance_value = self.get_virtual_x_position()\\n elif self.get_virtual_y_position() < left_turn_radio:\\n virtual_distance_value = (\\n initial_straight_section + atan(\\n (\\n self.get_virtual_x_position() -\\n initial_straight_section\\n ) / (\\n left_turn_radio -\\n self.get_virtual_y_position()\\n )\\n ) * left_turn_radio\\n )\\n else:\\n virtual_distance_value = (\\n initial_straight_section + pi * left_turn_radio / 2 +\\n self.get_virtual_y_position() - left_turn_radio\\n )\\n\\n a = path_width / 2\\n b = right_turn_radio + path_width / 4\\n c = pi * left_turn_radio / 2\\n # Scale virtual distance\\n if virtual_distance_value <= initial_straight_section + c:\\n virtual_distance_value *= (\\n (initial_straight_section + a + b) /\\n (initial_straight_section + c)\\n )\\n else:\\n virtual_distance_value += a + b - c\\n\\n return virtual_distance_value\",\n \"def time_for_travel(self):\\n return great_circle(self.pickupcoords, self.dropoffcoords).miles * 3600 / 25\",\n \"def crack_legth_compute(self):\\n crack_grad = self.gradient(4,5)\\n avegrad = self.average_grad()\\n cracklen = self.distance(self.points[4,:],self.points[5,:])\\n #print(\\\"photo_crack_len\\\", cracklen)\\n\\n #print(\\\"Crack_grad:\\\", crack_grad)\\n\\n angle_between_crack_and_vertical = np.arctan(np.abs((crack_grad - avegrad)/(1+crack_grad*avegrad)))\\n #print(\\\"angle between crack and vertical: \\\", np.rad2deg(angle_between_crack_and_vertical),\\\"degrees\\\")\\n\\n\\n h_dist = np.sin(angle_between_crack_and_vertical)*cracklen\\n h_rel = h_dist/self.hline[2]\\n #print('relative horizontal_crack distance:', h_rel)\\n v_dist = np.cos(angle_between_crack_and_vertical)*cracklen\\n v_rel = v_dist / self.vline[2]\\n #print('relative vertical_crack distance:', v_rel)\\n\\n actual_crack_length = np.sqrt((h_rel*self.cut_breadth)**2 + (v_rel*self.cut_depth)**2)\\n\\n #print(\\\"Actual_crack_length\\\\n,\\\", actual_crack_length)\\n print(actual_crack_length) # This is later writen to a text file and read into the main program\\n\\n return actual_crack_length\",\n \"def one_way_path(most_important, total_distance, to_source2, to_source1):\\n\\n if total_distance == min(total_distance, to_source2[0], to_source1[0]):\\n return most_important_to_source(most_important), total_distance\\n elif to_source2[0] == min(total_distance, to_source2[0], to_source1[0]):\\n return most_important_to_source(to_source2[1]), to_source2[0]\\n else:\\n return most_important_to_source(to_source1[1], up=False), to_source1[0]\",\n \"def z_distance(self):\\n return self.get_distance(self.Z_INDEX)\",\n \"def get_distance(self):\\n print(\\\"voici la distance à l'obstacle\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6739397","0.63740313","0.62297326","0.6201111","0.61479735","0.6109232","0.58568966","0.57820773","0.5728556","0.5677432","0.5653691","0.5620571","0.5601367","0.55796075","0.55561036","0.5536733","0.5516684","0.55092776","0.54958546","0.5482631","0.54581463","0.5446268","0.5443477","0.54391706","0.5437497","0.54230523","0.53992385","0.5386073","0.5382618","0.5377344","0.5349134","0.5347046","0.53287494","0.5303166","0.52845466","0.52796185","0.5265217","0.52626544","0.5260013","0.52578044","0.525562","0.5238883","0.52250457","0.5218651","0.52151287","0.52112883","0.52104574","0.52009374","0.5188435","0.5179363","0.5168811","0.5165981","0.51658297","0.5159746","0.51543915","0.5144393","0.5139106","0.5127064","0.5109801","0.5102992","0.51025474","0.50963646","0.50948375","0.5092838","0.5081543","0.50814056","0.5080681","0.5078546","0.5067699","0.5057832","0.50569034","0.5051553","0.5051123","0.50472","0.5043225","0.50428236","0.5038554","0.5026697","0.50257903","0.50244343","0.50226223","0.50188035","0.50115746","0.5007052","0.5006887","0.49998504","0.49995318","0.49944073","0.49829763","0.49827462","0.49819458","0.4970431","0.49649447","0.49620104","0.49606556","0.4958927","0.49565977","0.49523097","0.495208","0.49519932"],"string":"[\n \"0.6739397\",\n \"0.63740313\",\n \"0.62297326\",\n \"0.6201111\",\n \"0.61479735\",\n \"0.6109232\",\n \"0.58568966\",\n \"0.57820773\",\n \"0.5728556\",\n \"0.5677432\",\n \"0.5653691\",\n \"0.5620571\",\n \"0.5601367\",\n \"0.55796075\",\n \"0.55561036\",\n \"0.5536733\",\n \"0.5516684\",\n \"0.55092776\",\n \"0.54958546\",\n \"0.5482631\",\n \"0.54581463\",\n \"0.5446268\",\n \"0.5443477\",\n \"0.54391706\",\n \"0.5437497\",\n \"0.54230523\",\n \"0.53992385\",\n \"0.5386073\",\n \"0.5382618\",\n \"0.5377344\",\n \"0.5349134\",\n \"0.5347046\",\n \"0.53287494\",\n \"0.5303166\",\n \"0.52845466\",\n \"0.52796185\",\n \"0.5265217\",\n \"0.52626544\",\n \"0.5260013\",\n \"0.52578044\",\n \"0.525562\",\n \"0.5238883\",\n \"0.52250457\",\n \"0.5218651\",\n \"0.52151287\",\n \"0.52112883\",\n \"0.52104574\",\n \"0.52009374\",\n \"0.5188435\",\n \"0.5179363\",\n \"0.5168811\",\n \"0.5165981\",\n \"0.51658297\",\n \"0.5159746\",\n \"0.51543915\",\n \"0.5144393\",\n \"0.5139106\",\n \"0.5127064\",\n \"0.5109801\",\n \"0.5102992\",\n \"0.51025474\",\n \"0.50963646\",\n \"0.50948375\",\n \"0.5092838\",\n \"0.5081543\",\n \"0.50814056\",\n \"0.5080681\",\n \"0.5078546\",\n \"0.5067699\",\n \"0.5057832\",\n \"0.50569034\",\n \"0.5051553\",\n \"0.5051123\",\n \"0.50472\",\n \"0.5043225\",\n \"0.50428236\",\n \"0.5038554\",\n \"0.5026697\",\n \"0.50257903\",\n \"0.50244343\",\n \"0.50226223\",\n \"0.50188035\",\n \"0.50115746\",\n \"0.5007052\",\n \"0.5006887\",\n \"0.49998504\",\n \"0.49995318\",\n \"0.49944073\",\n \"0.49829763\",\n \"0.49827462\",\n \"0.49819458\",\n \"0.4970431\",\n \"0.49649447\",\n \"0.49620104\",\n \"0.49606556\",\n \"0.4958927\",\n \"0.49565977\",\n \"0.49523097\",\n \"0.495208\",\n \"0.49519932\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69647264"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":91987,"cells":{"query":{"kind":"string","value":"Determine the path distance of the top of descent altitude. Returns The path distance of the first cruising altitude."},"document":{"kind":"string","value":"def top_of_descent_distance(self):\n return self.distances[self.top_of_descent_index()]"},"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 closest_cruising_altitude(altitude):\n return 1000 * ((altitude + 500) // 1000)","def top_of_descent_index(self):\n tod = self.altitudes.argmax()\n # if the altitude profile is not just a climb\n # and there is a cruising section\n if (tod < len(self.altitudes) - 1) and \\\n (self.altitudes[tod] == self.altitudes[tod + 1]):\n tod += 1\n\n return tod","def top_distance(self):\n return self.y","def test_triangle_get_shortest_altitude(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)","def altitude(self):\n if self.__altitude:\n return sum(self.__altitude) / len(self.__altitude)\n else:\n return -9999","def get_closest_distance_to_path(self, path):\n min_distance_to_line = float(\"inf\")\n for p in path:\n game_path = p[:]\n\n game_path.sort(key = lambda coord: calculate_distance(self, coord))\n point_A = game_path[0] # Closest point out of all the points on the path to to the tower\n\n try:\n point_after_A = p[p.index(point_A) + 1]\n point_before_A = p[p.index(point_A) - 1]\n closest_to_A = min(point_after_A, point_before_A, key = lambda point: calculate_distance(point_A, point))\n except:\n if p.index(point_A) == 0:\n closest_to_A = p[p.index(point_A) + 1]\n \n elif p.index(point_A) == len(p) - 1:\n closest_to_A = p[p.index(point_A) - 1]\n finally:\n if closest_to_A[0] != point_A[0]:\n m = (closest_to_A[1] - point_A[1]) / (closest_to_A[0] - point_A[0])\n else:\n m = 2\n\n b = point_A[1] - m * point_A[0]\n\n closest_distance = abs(-m * self.x + self.y - b) / math.sqrt((-m) ** 2 + 1)\n min_distance_to_line = min(closest_distance, min_distance_to_line)\n \n return min_distance_to_line","def altitude(self) -> int:\n return self._point.altitude","def test_triangle_get_longest_altitude(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_longest_altitude(), 9.428090415820634)","def find_closest_path(self):\n\t\tclosest_distance = sys.maxint\n\t\tclosest_path = 0\n\t\tbike_position = (self.map_model.bike.xB, self.map_model.bike.yB)\n\t\tfor path_index in range(len(self.map_model.paths)):\n\t\t\tnearest_point = geometry.nearest_point_on_path(self.map_model.paths[path_index], bike_position)\n\t\t\tdistance_to_bike = geometry.distance(nearest_point, bike_position)\n\t\t\tif (closest_distance > distance_to_bike):\n\t\t\t\tclosest_distance = distance_to_bike\n\t\t\t\tclosest_path = path_index \n\t\tdisp_next = self.displacement_to_turn(target_path = (closest_path+1)%len(self.map_model.paths))\n\t\ttarget_path = (closest_path+1)%len(self.map_model.paths)\n\t\tdistance_next = geometry.distance_from_path(bike_position, self.map_model.paths[target_path])\n\t\tif disp_next - np.abs(distance_next)>-0.01:\n\t\t\tclosest_path = np.mod(closest_path + 1,len(self.map_model.paths))\n\t\treturn closest_path","def top_of_climb_index(self):\n return self.altitudes.argmax()","def getAltitudeAngle(self):\n return self._altitude","def altitude(self):\r\n pressure = self.pressure # in Si units for hPascal\r\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))","def distance_to_current_waypoint(self):\n next_waypoint = self.vehicle.commands.next\n if next_waypoint == 1:\n return None\n mission_item = self.vehicle.commands[next_waypoint]\n lat = mission_item.x\n lon = mission_item.y\n alt = mission_item.z\n waypoint_location = Location(lat, lon, alt, is_relative=True)\n distance = get_distance_meters(self.vehicle.location, waypoint_location)\n return distance","def top_of_climb_distance(self):\n return self.distances[self.top_of_climb_index()]","def get_path_distance(self, path):\n distance = VectorMath.get_magnitude(self.drone.get_point(), path[0])\n for index in range(len(path[:-1])):\n distance += VectorMath.get_magnitude(path[index], path[index + 1])\n distance += VectorMath.get_magnitude(path[-1], self.drone.get_waypoint_holder().get_current_waypoint())\n\n if abs(self.drone.get_point()[2] - path[0][2]) > 1:\n distance *= Constants.VERTICAL_PATH_WEIGHTING_MULTIPLE\n\n return distance","def lidar_relative(self):\n return self.distance","def get_altitude(self):\n self.degrees = self.altitude_encoder.get_degrees()\n self.tele_altitude = self.Calculations.convert_degrees( self.degrees)\n return self.tele_altitude","def distance_to_current_waypoint():\n nextwaypoint = vehicle.commands.next\n if nextwaypoint == 0:\n return None\n missionitem = vehicle.commands[nextwaypoint -\n 1] #commands are zero indexed\n lat = missionitem.x\n lon = missionitem.y\n alt = missionitem.z\n targetWaypointLocation = LocationGlobalRelative(lat, lon, alt)\n distancetopoint = get_distance_metres(vehicle.location.global_frame,\n targetWaypointLocation)\n return distancetopoint","def path(most_important_up, most_important_down, total_distance, to_source2, to_source1):\n\n if total_distance == min(total_distance, to_source2[0], to_source1[0]):\n return source_to_source(most_important_up, most_important_down), total_distance\n elif to_source2[0] == min(total_distance, to_source2[0], to_source1[0]):\n return most_important_to_source(to_source2[1]), to_source2[0]\n else:\n return most_important_to_source(to_source1[1], up=False), to_source1[0]","def evaluatePath(self):\n pathLength = 0\n if len(self.path) > 0:\n previousCity = self.path[0]\n for ind in range(1, len(self.path)):\n pathLength += previousCity.distanceWith(self.path[ind].name)\n previousCity = self.path[ind]\n return pathLength","def topographic_altitude(self, lat_d, lon_d):\n return self.altitude(lat_d, lon_d)","def topographic_altitude(self, lat_d, lon_d):\n return self.altitude(lat_d, lon_d)","def elevation(self):\n return self.altitude - self.heightAboveGround","def GetTotalDurationOfPath(PathInfo):\r\n\tif PathInfo == None: return 0\r\n\tif len(PathInfo) < 2: return 0\r\n\t\r\n\tdeparture_first_station = PathInfo[0][ConnInfoInd['arrival_hour']]*60 + PathInfo[0][ConnInfoInd['arrival_min']]\r\n\t# departure_first_station = PathInfo[1][ConnInfoInd['departure_hour']]*60 + PathInfo[1][ConnInfoInd['departure_min']]\r\n\r\n\tarrival_last_station = PathInfo[-1][ConnInfoInd['arrival_hour']]*60 + PathInfo[-1][ConnInfoInd['arrival_min']]\r\n\treturn (arrival_last_station - departure_first_station)","def altitude_speed(self, degrees = True):\n return self.angularSpeed(self.future_location.al, self.old_location.al)","def getEdgeDistance():\n '''\n a\n ◿\n b c\n\n hypotenuse\n ◿ adjacent\n opposite\n\n tan(a) = opposite/adjacent\n adjacent * tan(a) = opposite\n '''\n\n # An estimated multiplier to take into account the larger infrared dot\n # observed when further away from as surface - think torch beam onto a\n # wall getting larger as it gets further away, but only the radius\n # (center downwards) being relevant.\n # TODO: Maybe move into infrared sensor code?\n MULTI = 1.2\n\n edgeDistance = BOT_HEIGHT * math.tan(math.radians(getEdgeAngle()))\n edgeDistance *= MULTI\n\n if DEBUG:\n print \"Distance to edge: \", int(round(edgeDistance))\n\n return edgeDistance","def diversion(self) -> Optional[\"Flight\"]:\n from ..data import airports\n\n # The following cast secures the typing\n self = cast(\"Flight\", self)\n\n f_above: Optional[\"Flight\"] = self.query(\"altitude > 15000\")\n if (\n self.destination != self.destination\n or airports[self.destination] is None # type: ignore\n or f_above is None\n ):\n return None\n\n return (\n f_above.distance(airports[self.destination]) # type: ignore\n .diff(\"distance\")\n .agg_time(\"10T\", distance_diff=\"mean\")\n .query(\"distance_diff > 0\")\n )","def longest_flight(self):\r\n distance = 0\r\n for code, _list in self.edges.items():\r\n for edge in _list:\r\n if edge.distance > distance:\r\n distance = edge.distance\r\n start = edge.start\r\n destination = edge.destination\r\n return start, destination, distance","def get_last_flight(self):\n return self.path[len(self.path) - 1]","def longest_path_callback(self, data):\n min_idx = self.find_minimum_distance(data.poses) # closest point index\n if min_idx is None:\n return\n else:\n # extract 20 points along the closest point\n # use z position of ego car since z displacement doesn't matter\n # truncate if encounter head or tail\n path_points = np.array([\n (pose.pose.position.x, pose.pose.position.y, self.car_pos[2])\n for pose in data.poses[max(min_idx-10, 0):min_idx+10]]\n )\n # use svd to find the approximate tangent direction of longest path\n approx_dir = np.linalg.svd(path_points-np.mean(path_points,axis=0))[2][0]\n self.last_yaw_longestpath = np.arctan2(approx_dir[1], approx_dir[0])\n # perpendicular distance is then the norm of vector\n # (car_pos - pos_point) x approx_dir, x is cross product\n self.last_dist_longestpath = np.linalg.norm(\n np.cross(path_points[0,:] - self.car_pos, approx_dir)\n )\n # publish\n self.pub_closest_dist_longestpath.publish(self.last_dist_longestpath)","def GetAbsBeer(epsilon, conc, pathLength):\n return epsilon * conc * pathLength","def calculate_made_up_dist(self):\n\n # Ensure if current state equals goal, cost is only the current cost\n if self._goal_loc == self._current_loc:\n return self._current_cost\n\n # Distance is at least the Manhattan distance as cannot move diagonal\n estimated_distance = self.calculate_manhattan_dist()\n\n # Assume two board parts in the priority queue have the same weight.\n # For those board paths with higher actual cost and lower heuristic\n # cost, there is more assurance in the accuracy of the actual cost\n # than in the heuristic cost. Give a very small penalty (i.e. less\n # than one step) to prefer a path with a higher known cost than a\n # path with a higher heuristic cost.\n # Extract the number of portion of the move cost from the heuristic\n heuristic_cost = estimated_distance - self._current_cost\n # Heuristic cost penalty is normalized to a maximum of 0.1 steps\n # This is achieved by dividing the heuristic cost by the size of the\n # board. Since the heuristic cost can never be larger than the board\n # size, this quotient is less than or equal to 1. To normalize to a\n # maximum of 0.1, just multiply the number by 0.1. This is than added\n # to the estimated distance determined so far.\n heuristic_cost_penalty = 0.1 * heuristic_cost\n heuristic_cost_penalty /= BoardPath._traversed_board_size\n # Add what is essentially an \"uncertainty penalty\"\n estimated_distance += heuristic_cost_penalty\n\n # In case where all neighboring spaces are blocked or already\n # traversed, then set the path cost prohibitively large so it is\n # given minimum priority.\n if not (self.is_move_valid(\"d\", BoardPath._traversed_board)) \\\n and not (self.is_move_valid(\"u\", BoardPath._traversed_board)) \\\n and not (self.is_move_valid(\"l\", BoardPath._traversed_board)) \\\n and not (self.is_move_valid(\"r\", BoardPath._traversed_board)):\n # Total board area is sufficient as a prohibitive distance\n estimated_distance += BoardPath._traversed_board_size\n return estimated_distance\n\n # If all next steps that load directly to the goal are blocked, then\n # it takes at least two additional moves to get around the blocked\n # paths it (due to an obstacle or already traversed square) so add\n # two to the estimated distance to include that cost.\n if self._is_all_direct_next_moves_blocked(BoardPath._traversed_board):\n estimated_distance += 2\n\n # In a heap, if two nodes have the same cost, the object that was\n # put into the heap first in many implementations will be on top of the\n # heap. To make the algorithm more efficient, apply a slight penalty to\n # a non valid solution to ensure if an invalid solution and a valid\n # solution have the same cost that the valid solution would always be\n # on top of the heap. This is done by giving all non-valid solutions a\n # penalty term that is greater than zero and less than the minimum step\n # size (e.g. in this case 0 < 0.1 < 1).\n estimated_distance += 0.1\n\n # Return estimated distance\n return estimated_distance","def get_best_move_toward(self, target_ground):\n options_by_parent, cost_to_reach = self.a_star_search(start=self.ground, goal=target_ground)\n ground = target_ground\n\n # Can't reach it?\n if ground not in options_by_parent:\n return None\n\n while options_by_parent[ground] is not self.ground:\n ground = options_by_parent[ground]\n\n return ground.x - self.ground.x, ground.y - self.ground.y","def _calculate_h(self, end):\n return PATH_COST * (abs(self.x - end.x) + abs(self.y - end.y))","def one_way_path(most_important, total_distance, to_source2, to_source1):\n\n if total_distance == min(total_distance, to_source2[0], to_source1[0]):\n return most_important_to_source(most_important), total_distance\n elif to_source2[0] == min(total_distance, to_source2[0], to_source1[0]):\n return most_important_to_source(to_source2[1]), to_source2[0]\n else:\n return most_important_to_source(to_source1[1], up=False), to_source1[0]","def get_true_bearing(shot, top):\n tripidx = shot[\"trip\"]\n\n if tripidx != -1:\n decl = top[\"trips\"][tripidx][KEY_DECLINATION]\n else:\n decl = 0\n\n return shot[\"compass\"] + decl","def getBestPath(self):\n if self._bestPathVertex.getNextWaypoint() is None:\n numWaypointsCompleted = len(self._waypoints)\n quality = 2\n if self._vertexQueue.isEmpty():\n quality += 1\n else:\n numWaypointsCompleted = self._bestPathVertex.getNextWaypoint().getIndex()\n quality = 1\n if self._vertexQueue.isEmpty():\n quality -= 1\n \n return outputPath.generatePath(self._bestPathVertex, self._params.waypointAcceptanceRadii, quality, numWaypointsCompleted)","def altitude(press, altimeter=29.92126):\n AS = altimeter*inHg2PA\n print(AS, press**(L*R/g/M))\n h = -(press**(L*R/g/M) - AS**(L*R/g/M))*T0/L/(P0**(L*R/g/M))\n return h/ft2m","def get_altitude(self):\n return self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_GET_ALTITUDE, (), '', 'i')","def GetDurationUntilDeparture(NextConnectionInfo, PathInfo):\r\n\tdeparture_first_station = PathInfo[0][ConnInfoInd['arrival_hour']]*60 + PathInfo[0][ConnInfoInd['arrival_min']]\r\n\tdeparture_next_station = NextConnectionInfo[ConnInfoInd['departure_hour']]*60 + NextConnectionInfo[ConnInfoInd['departure_hour']]\r\n\treturn (departure_next_station - departure_first_station)","def _plunge_distance(self, volume):\n percent = self._volume_percentage(volume)\n top = self._get_plunger_position('top')\n bottom = self._get_plunger_position('bottom')\n travel = bottom - top\n if travel <= 0:\n self.robot.add_warning('Plunger calibrated incorrectly')\n return travel * percent","def get_distance(self):\n values = self.speakers.values()\n values.sort(reverse=True)\n try:\n return abs(values[1]) - abs(values[0])\n except (IndexError, ValueError):\n return -1","def get_air_density(self, altitude):\n\n altitude /= 1000 # convert to kilometers\n\n return self.get_air_density_from_model(altitude)","def _find_fastest_path(self):\n from simulator import Robot\n clone_robot = Robot(exploration_status=self._robot.exploration_status,\n facing=self._robot.facing,\n discovered_map=self._robot.discovered_map,\n real_map=[[0] * 15 for _ in range(20)])\n\n fastest_path_start_way_point = get_shortest_path_moves(clone_robot,\n start=(1, 1),\n goal=self._way_point)\n\n if fastest_path_start_way_point:\n for move in fastest_path_start_way_point:\n clone_robot.move_robot(move)\n\n before_way_point = previous_cell(clone_robot.center, clone_robot.facing)\n\n fastest_path_way_point_goal = get_shortest_path_moves(clone_robot,\n start=self._way_point,\n goal=(18, 13),\n before_start_point=before_way_point)\n\n return fastest_path_start_way_point + fastest_path_way_point_goal","def getDistance(self):\n return sqrt(self.state[0] * self.state[0] + self.state[2] * self.state[2])","def findShortestPath(self):\r\n pass","def h_score(self):\n if self.estimated_moves_to_goal is None:\n self.estimated_moves_to_goal = \\\n max(nx.single_source_shortest_path_length(self.graph, self.head_node).items(), key=lambda x: x[1])[1]\n return self.estimated_moves_to_goal","def GetDurationUntilNextArrival(NextConnectionInfo, PathInfo):\r\n\tdeparture_first_station = PathInfo[0][ConnInfoInd['arrival_hour']]*60 + PathInfo[0][ConnInfoInd['arrival_min']]\r\n\tarrival_next_station = NextConnectionInfo[ConnInfoInd['arrival_hour']]*60 + NextConnectionInfo[ConnInfoInd['arrival_hour']]\r\n\treturn (arrival_next_station - departure_first_station)","def get_closest_waypoint(self, pose):\n if self.kdtree:\n return kdtree_closest_point(self.kdtree,\n (pose.x,\n pose.y))\n else:\n return 0","def get_closest_waypoint(self, pose):\n if self.kdtree:\n return kdtree_closest_point(self.kdtree,\n (pose.position.x,\n pose.position.y))\n else:\n return 0","def path(self):\n return self.alignment.matching_function_bestpath(self.idx)","def find_path(self):\n \n if self.line_num != -1:\n return self.line_num\n\n max_line = self.graph.gps_length - 1\n min_line = 0\n #last_id = dg.normalize(self.graph.lines[-1])[0]\n last_id = normalize_simple(self.graph.lines[-1])[0]\n pivot = int((self.trip_id-1)/float(last_id)*self.graph.gps_length)\n #cur_id = dg.normalize(self.graph.lines[pivot])[0]\n cur_id = normalize_simple(self.graph.lines[pivot])[0]\n while cur_id != self.trip_id:\n if cur_id < self.trip_id:\n min_line = pivot\n else:\n max_line = pivot\n #TODO: could make this run in essentially constant time by hopping predetermined distance\n pivot = (min_line + max_line) / 2\n #cur_id = dg.normalize(self.graph.lines[pivot])[0]\n cur_id = normalize_simple(self.graph.lines[pivot])[0]\n\n #while dg.normalize(self.graph.lines[pivot])[0] == self.trip_id:\n while normalize_simple(self.graph.lines[pivot])[0] == self.trip_id:\n pivot -= 1\n\n pivot += 1\n self.line_num = pivot\n return pivot","def well_diameter_at_top(self):\n return self.radius_from_liquid_depth(self.well_depth) * 2 # a generic impl; subclasses can optimize","def _distance_next(self):\n\n self.distance = 10\n\n # Here a set index to 0 if the car is finishing a lap\n # Also reset the farthest\n if self.index > (len(self.x_trajectory) - 6) and self.closed:\n self.index = 0\n self.farthest = -1\n self.laps += 1\n\n for w in range(self.index, self.index + 20):\n\n self.dist_point = math.sqrt((self.x_trajectory[w] - self.x)**2\n + (self.y_trajectory[w] - self.y)**2)\n\n if self.dist_point < self.distance:\n self.distance = self.dist_point\n self.index = w\n\n if w >= (len(self.x_trajectory) - 1):\n break\n\n self._calc_side()\n\n self.distance = self.distance * self.sign\n\n return self.distance","def set_altitude(self):\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\n print('altitude set to', self.altitude)\n if self.altitude < 0:\n self.altitude = self.altitude + 360.0\n return self.altitude \n else: \n pass\n return self.altitude","def topo_diameter(self):\n import math\n \n Temp = 0\n for i in range(self.nodenum):\n for j in range(self.nodenum):\n pathlist = []\n self.pathij(i, j, pathlist)\n distance = []\n \n for k in range(len(pathlist)):\n distance.append(len(pathlist[k]) - 1)\n \n if(len(distance) == 0):\n continue\n else:\n if(min(distance) >= Temp):\n Temp = min(distance)\n \n self.topodiameter = Temp","def GetEpsilonBeer(Abs, conc, pathLength):\n return Abs / (conc * pathLength)","def get_distance(self) -> int:\n return self.get_measurement_data().distance","def estimated_distance(self, log=False):\n\t\t\n\t\tx0 = GRAVITY - self.thrust*.95 / (self.total_mass - self.fuel_consumption * 0.0)\n\t\tx1 = GRAVITY - self.thrust*.95 / (self.total_mass - self.fuel_consumption * 1.0)\n\n\t\t# Derivative at x=0 and x=1\n\t\tu = x0\n\t\tv = x1\n\t\t# Initial height at x=0\n\t\ty = abs(self.velocity)\n\n\t\tif log:\n\t\t\tprint(f'u: {u}, v: {v}, y: {y}\\nEstimated distance: {get_positive_area(u, v, y)}\\n')\n\t\t\n\t\treturn get_positive_area(u, v, y)","def getDistance(self):\n taBox = (self.thor * self.tvert)/(720*960) #box area as percentage of whole\n if(taBox==None or taBox<=0): return -1\n const = 4 * math.tan(0.471)*math.tan(0.3576)\n return math.sqrt((self.abox)/(const*taBox))","def topographic_altitude(lat, lon):\n global __model\n type_output = type(lat)\n lat = prepare_input_array(lat)\n lon = prepare_input_array(lon)\n lon = np.mod(lon, 360)\n val = __model.topographic_altitude(lat, lon)\n val = np.maximum(val, 1e-7)\n return prepare_output_array(val, type_output) * u.km","def get_distance(self, heuristic=\"\"):\n # If no heuristic is specified, used the default\n if(heuristic == \"\"):\n heuristic = BoardPath._heuristic\n\n if(heuristic == \"manhattan\"):\n return self.calculate_manhattan_dist()\n elif(heuristic == \"euclidean\"):\n return self.calculate_euclidean_dist()\n elif(heuristic == \"made_up\"):\n return self.calculate_made_up_dist()\n else:\n sys.exit()","def get_distance(self):\n\n # Activate trigger\n self.trigger()\n\n # Detect rising edge of echo pin\n channel = GPIO.wait_for_edge(self.echo_pin, GPIO.RISING, timeout=2)\n if channel is None:\n # Timeout on wait of rising interrupt\n return None\n else:\n # Rising edge detected, save pulse start\n pulse_start = time.time()\n\n\n # Detect falling edge of echo pin\n channel = GPIO.wait_for_edge(self.echo_pin, GPIO.FALLING, timeout=2)\n if channel is None:\n # Timeout on wait of falling interrupt\")\n return None\n else:\n # Falling edge detected, save pulse end\n pulse_end = time.time()\n\n # Calculated pulse width in microseconds (x1mln)\n pulse_width = (pulse_end - pulse_start)*1000000\n\n # Return distance in cm\n return pulse_width / 58","def find_hypocenter(self):\n ps_hypo = min(self.pointsources, key=lambda x: x.time_shift)\n self.hypocenter_longitude = ps_hypo.longitude\n self.hypocenter_latitude = ps_hypo.latitude\n self.hypocenter_depth_in_m = ps_hypo.depth_in_m","def diff_of_errors(self):\n self.e_of_e = self.azimuth_error - self.altitude_error\n return self.e_of_e","def alt_index(self) -> Optional[int]:\n if not self.is_hom_alt():\n return None\n return max(self.allele1, self.allele2) - 1","def distance_to_current_waypoint(vehicle):\n nextwaypoint = vehicle.commands.next\n if nextwaypoint==0:\n return None\n missionitem=vehicle.commands[nextwaypoint-1] #commands are zero indexed\n lat = missionitem.x\n lon = missionitem.y\n alt = missionitem.z\n targetWaypointLocation = LocationGlobalRelative(lat,lon,alt)\n distancetopoint = get_distance_metres(vehicle.location.global_frame, targetWaypointLocation)\n return distancetopoint","def path_cost(path):\n # path = [state, (action, total_cost), state, ... ]\n if len(path) < 2:\n return 0\n else:\n return path[-2][-1]","def distance(self):\n return Distance(length_of(self.position.au))","def get_path_distance(self, path):\n length = len(path)\n distance = 0\n for i in range(length):\n distance += self.distances[path[i]][path[(i + 1) % length]]\n return distance","def calcPath(self):\n return None","def getBelowDistance(self):\n return self.__belowDistance","def distanceTo(self, other):\n return math.hypot(abs(self.altitude_msl - other.altitude_msl),\n self.gps_position.distanceTo(other.gps_position))","def player_goal_distance(self) -> float:\n route = self.best_route\n return sum(route.values())","def get_min_distance(self):\n return round(min(self.combined_euclidian_distance))","def _get_distance(self, target): \r\n sensor_transform = self._sensors['rgb_front'].get_transform()\r\n\r\n distance = np.sqrt(\r\n (sensor_transform.location.x - target.x) ** 2 +\r\n (sensor_transform.location.y - target.y) ** 2 +\r\n (sensor_transform.location.z - target.z) ** 2)\r\n\r\n return distance","def get_altitude(self, degrees=True):\n if degrees:\n return math.degrees(self.current_location.al)\n else:\n return self.current_location.al","def shortest_path_distance(self, other):\n if self == other:\n return 0\n\n paths = self.shortest_path(other)\n return None if paths == [] else len(paths[0]) - 1","def _earth_distance(time='now'):\n return get_earth(time).radius","def GetDurationOfTripSinceDeparture(PathInfo):\r\n\tif not PathInfo:\r\n\t\treturn None \r\n\tif len(PathInfo) < 2: return None \r\n\r\n\tdeparture_first_station = PathInfo[1][ConnInfoInd['departure_hour']]*60 + PathInfo[1][ConnInfoInd['departure_min']]\r\n\r\n\tarrival_last_station = PathInfo[-1][ConnInfoInd['arrival_hour']]*60 + PathInfo[-1][ConnInfoInd['arrival_min']]\r\n\tTotalDuration = arrival_last_station - departure_first_station\r\n\treturn TotalDuration","def getPathLength(self, path):\r\n path_nodes = path\r\n # print(path_nodes)\r\n total_length = 0 # km\r\n for i in range(len(path_nodes)-1):\r\n next_edge = None\r\n for edge in self.graph.getAdj(path_nodes[i]):\r\n if edge.getExtremityNode() == path_nodes[i+1]:\r\n next_edge = edge\r\n if next_edge is None: # it means the path is invalid\r\n return None\r\n total_length += next_edge.getWeight()\r\n # print(next_edge.getTravelType(), end=\" \")\r\n return total_length","def calculate_distance_edge(self):\n if self.mu > 0:\n # right interface is intersected next\n dx = self.cell_xr - self.x\n self.next_cell_index = self.cell_index + 1\n else:\n # left interface is intersected next\n dx = self.cell_xl - self.x\n self.next_cell_index = self.cell_index - 1\n\n return dx / self.mu","def compute_direction(self, feats):\n if feats.name == \"ARNC\":\n if feats[\"z-score\"] < -1.5:\n return Directions.long_dir\n elif feats[\"z-score\"] > 1.5:\n return Directions.short_dir\n elif feats.name == \"UNG\":\n if feats[\"z-score\"] < -1.5:\n return Directions.short_dir\n elif feats[\"z-score\"] > 1.5:\n return Directions.long_dir","def test_distance_aed(self):\n railroad = trains.Railroad()\n self.assertEqual(railroad.distance('AED'), 'NO SUCH ROUTE')","def total_cost(path: Path) -> float:\n\t\n\tdistance = calc_total_dist(path)\n\tavg_speed = calc_average_speed(path)\n\t\n\t# Speed is less important, but gets a huge multiplier, because speed and\n\t# \tdistance are in different units. Speed requires a high ratio to have\n\t# \tsimilar amounts of variation.\n\tSPEED_DISTANCE_COST_RATIO = 7865.099\n\t\n\treturn (\n\t\t(distance * 1) +\n\t\t(-avg_speed * SPEED_DISTANCE_COST_RATIO)\n\t)","def _get_distance(reindeer, race_time):\n interval = reindeer.flight_time + reindeer.rest_time\n cycles = race_time // interval\n flight_time = min(reindeer.flight_time, race_time - interval * cycles)\n total_flying_time = reindeer.flight_time * cycles + flight_time\n return total_flying_time * reindeer.flight_speed","def getDepthToTop(self):\n mindep = 9999999\n for quad in self._quadrilaterals:\n P0, P1, P2, P3 = quad\n depths = np.array([P0.depth, P1.depth, P2.depth, P3.depth])\n if np.min(depths) < mindep:\n mindep = np.min(depths)\n return mindep","def distance(self) -> float:\n return self._dist_two_wire() # at this time we only support 2-wire meausre","def get_global_total_distance_on_foot(self):\n return self._get_global_total_distance([ActivityType.Run, ActivityType.Walk])","def diameter(self):\n\n v = self.vertices()\n pairs = [ (v[i],v[j]) for i in range(len(v)-1) for j in range(i+1, len(v))]\n smallest_paths = []\n for (s,e) in pairs:\n paths = self.find_all_path(s,e)\n smallest = sorted(paths, key=len)[0]\n smallest_paths.append(smallest)\n\n smallest_paths.sort(key=len)\n\n # Print the list smallest_paths\n\n # Longest path is at the end of list\n # ie diameter corresponds to length of this path\n\n diameter = len(smallest_paths[-1]) -1\n return diameter","def get(cls, approach):\n return approach.distance","def getAboveDistance(self):\n return self.__aboveDistance","def get_height_of_surface_gate(data, setup={}):\n idx = get_index_of_surface_gate(data, setup)\n nt = range(len(idx))\n return data['alt'][nt, idx]","def y_distance(self):\n return self.get_distance(self.Y_INDEX)","def _get_lsp_frr_path_cost(self):\n return self.__lsp_frr_path_cost","def extract_path(self):\n if self.extracted_path is not None:\n return self.extracted_path\n current = self\n path = []\n while current:\n path.append([current.end, current.path_cost])\n current = current.parent\n return list(reversed(path))","def __get_deccelleration(self):\n slowdown_span = (4.0/ 5.0) * (self.safe_distance - self.critical_distance)\n return (self.speed ** 2.0) / (2.0 * slowdown_span)","def get_distance_over_path(G, path):\r\n node1 = str(path[0])\r\n node2 = str(path[-1])\r\n\r\n pos1 = G.nodes[node1]['pos']\r\n pos2 = G.nodes[node2]['pos']\r\n\r\n return np.sqrt((pos1[0] - pos2[0])**2 + (pos1[1] - pos2[1])**2)","def get_latest_locant(self):\n return self._next_locant - 1","def getOrdinate(self):\n return self.point.y - self.slope * self.point.x"],"string":"[\n \"def closest_cruising_altitude(altitude):\\n return 1000 * ((altitude + 500) // 1000)\",\n \"def top_of_descent_index(self):\\n tod = self.altitudes.argmax()\\n # if the altitude profile is not just a climb\\n # and there is a cruising section\\n if (tod < len(self.altitudes) - 1) and \\\\\\n (self.altitudes[tod] == self.altitudes[tod + 1]):\\n tod += 1\\n\\n return tod\",\n \"def top_distance(self):\\n return self.y\",\n \"def test_triangle_get_shortest_altitude(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)\",\n \"def altitude(self):\\n if self.__altitude:\\n return sum(self.__altitude) / len(self.__altitude)\\n else:\\n return -9999\",\n \"def get_closest_distance_to_path(self, path):\\n min_distance_to_line = float(\\\"inf\\\")\\n for p in path:\\n game_path = p[:]\\n\\n game_path.sort(key = lambda coord: calculate_distance(self, coord))\\n point_A = game_path[0] # Closest point out of all the points on the path to to the tower\\n\\n try:\\n point_after_A = p[p.index(point_A) + 1]\\n point_before_A = p[p.index(point_A) - 1]\\n closest_to_A = min(point_after_A, point_before_A, key = lambda point: calculate_distance(point_A, point))\\n except:\\n if p.index(point_A) == 0:\\n closest_to_A = p[p.index(point_A) + 1]\\n \\n elif p.index(point_A) == len(p) - 1:\\n closest_to_A = p[p.index(point_A) - 1]\\n finally:\\n if closest_to_A[0] != point_A[0]:\\n m = (closest_to_A[1] - point_A[1]) / (closest_to_A[0] - point_A[0])\\n else:\\n m = 2\\n\\n b = point_A[1] - m * point_A[0]\\n\\n closest_distance = abs(-m * self.x + self.y - b) / math.sqrt((-m) ** 2 + 1)\\n min_distance_to_line = min(closest_distance, min_distance_to_line)\\n \\n return min_distance_to_line\",\n \"def altitude(self) -> int:\\n return self._point.altitude\",\n \"def test_triangle_get_longest_altitude(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_longest_altitude(), 9.428090415820634)\",\n \"def find_closest_path(self):\\n\\t\\tclosest_distance = sys.maxint\\n\\t\\tclosest_path = 0\\n\\t\\tbike_position = (self.map_model.bike.xB, self.map_model.bike.yB)\\n\\t\\tfor path_index in range(len(self.map_model.paths)):\\n\\t\\t\\tnearest_point = geometry.nearest_point_on_path(self.map_model.paths[path_index], bike_position)\\n\\t\\t\\tdistance_to_bike = geometry.distance(nearest_point, bike_position)\\n\\t\\t\\tif (closest_distance > distance_to_bike):\\n\\t\\t\\t\\tclosest_distance = distance_to_bike\\n\\t\\t\\t\\tclosest_path = path_index \\n\\t\\tdisp_next = self.displacement_to_turn(target_path = (closest_path+1)%len(self.map_model.paths))\\n\\t\\ttarget_path = (closest_path+1)%len(self.map_model.paths)\\n\\t\\tdistance_next = geometry.distance_from_path(bike_position, self.map_model.paths[target_path])\\n\\t\\tif disp_next - np.abs(distance_next)>-0.01:\\n\\t\\t\\tclosest_path = np.mod(closest_path + 1,len(self.map_model.paths))\\n\\t\\treturn closest_path\",\n \"def top_of_climb_index(self):\\n return self.altitudes.argmax()\",\n \"def getAltitudeAngle(self):\\n return self._altitude\",\n \"def altitude(self):\\r\\n pressure = self.pressure # in Si units for hPascal\\r\\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))\",\n \"def distance_to_current_waypoint(self):\\n next_waypoint = self.vehicle.commands.next\\n if next_waypoint == 1:\\n return None\\n mission_item = self.vehicle.commands[next_waypoint]\\n lat = mission_item.x\\n lon = mission_item.y\\n alt = mission_item.z\\n waypoint_location = Location(lat, lon, alt, is_relative=True)\\n distance = get_distance_meters(self.vehicle.location, waypoint_location)\\n return distance\",\n \"def top_of_climb_distance(self):\\n return self.distances[self.top_of_climb_index()]\",\n \"def get_path_distance(self, path):\\n distance = VectorMath.get_magnitude(self.drone.get_point(), path[0])\\n for index in range(len(path[:-1])):\\n distance += VectorMath.get_magnitude(path[index], path[index + 1])\\n distance += VectorMath.get_magnitude(path[-1], self.drone.get_waypoint_holder().get_current_waypoint())\\n\\n if abs(self.drone.get_point()[2] - path[0][2]) > 1:\\n distance *= Constants.VERTICAL_PATH_WEIGHTING_MULTIPLE\\n\\n return distance\",\n \"def lidar_relative(self):\\n return self.distance\",\n \"def get_altitude(self):\\n self.degrees = self.altitude_encoder.get_degrees()\\n self.tele_altitude = self.Calculations.convert_degrees( self.degrees)\\n return self.tele_altitude\",\n \"def distance_to_current_waypoint():\\n nextwaypoint = vehicle.commands.next\\n if nextwaypoint == 0:\\n return None\\n missionitem = vehicle.commands[nextwaypoint -\\n 1] #commands are zero indexed\\n lat = missionitem.x\\n lon = missionitem.y\\n alt = missionitem.z\\n targetWaypointLocation = LocationGlobalRelative(lat, lon, alt)\\n distancetopoint = get_distance_metres(vehicle.location.global_frame,\\n targetWaypointLocation)\\n return distancetopoint\",\n \"def path(most_important_up, most_important_down, total_distance, to_source2, to_source1):\\n\\n if total_distance == min(total_distance, to_source2[0], to_source1[0]):\\n return source_to_source(most_important_up, most_important_down), total_distance\\n elif to_source2[0] == min(total_distance, to_source2[0], to_source1[0]):\\n return most_important_to_source(to_source2[1]), to_source2[0]\\n else:\\n return most_important_to_source(to_source1[1], up=False), to_source1[0]\",\n \"def evaluatePath(self):\\n pathLength = 0\\n if len(self.path) > 0:\\n previousCity = self.path[0]\\n for ind in range(1, len(self.path)):\\n pathLength += previousCity.distanceWith(self.path[ind].name)\\n previousCity = self.path[ind]\\n return pathLength\",\n \"def topographic_altitude(self, lat_d, lon_d):\\n return self.altitude(lat_d, lon_d)\",\n \"def topographic_altitude(self, lat_d, lon_d):\\n return self.altitude(lat_d, lon_d)\",\n \"def elevation(self):\\n return self.altitude - self.heightAboveGround\",\n \"def GetTotalDurationOfPath(PathInfo):\\r\\n\\tif PathInfo == None: return 0\\r\\n\\tif len(PathInfo) < 2: return 0\\r\\n\\t\\r\\n\\tdeparture_first_station = PathInfo[0][ConnInfoInd['arrival_hour']]*60 + PathInfo[0][ConnInfoInd['arrival_min']]\\r\\n\\t# departure_first_station = PathInfo[1][ConnInfoInd['departure_hour']]*60 + PathInfo[1][ConnInfoInd['departure_min']]\\r\\n\\r\\n\\tarrival_last_station = PathInfo[-1][ConnInfoInd['arrival_hour']]*60 + PathInfo[-1][ConnInfoInd['arrival_min']]\\r\\n\\treturn (arrival_last_station - departure_first_station)\",\n \"def altitude_speed(self, degrees = True):\\n return self.angularSpeed(self.future_location.al, self.old_location.al)\",\n \"def getEdgeDistance():\\n '''\\n a\\n ◿\\n b c\\n\\n hypotenuse\\n ◿ adjacent\\n opposite\\n\\n tan(a) = opposite/adjacent\\n adjacent * tan(a) = opposite\\n '''\\n\\n # An estimated multiplier to take into account the larger infrared dot\\n # observed when further away from as surface - think torch beam onto a\\n # wall getting larger as it gets further away, but only the radius\\n # (center downwards) being relevant.\\n # TODO: Maybe move into infrared sensor code?\\n MULTI = 1.2\\n\\n edgeDistance = BOT_HEIGHT * math.tan(math.radians(getEdgeAngle()))\\n edgeDistance *= MULTI\\n\\n if DEBUG:\\n print \\\"Distance to edge: \\\", int(round(edgeDistance))\\n\\n return edgeDistance\",\n \"def diversion(self) -> Optional[\\\"Flight\\\"]:\\n from ..data import airports\\n\\n # The following cast secures the typing\\n self = cast(\\\"Flight\\\", self)\\n\\n f_above: Optional[\\\"Flight\\\"] = self.query(\\\"altitude > 15000\\\")\\n if (\\n self.destination != self.destination\\n or airports[self.destination] is None # type: ignore\\n or f_above is None\\n ):\\n return None\\n\\n return (\\n f_above.distance(airports[self.destination]) # type: ignore\\n .diff(\\\"distance\\\")\\n .agg_time(\\\"10T\\\", distance_diff=\\\"mean\\\")\\n .query(\\\"distance_diff > 0\\\")\\n )\",\n \"def longest_flight(self):\\r\\n distance = 0\\r\\n for code, _list in self.edges.items():\\r\\n for edge in _list:\\r\\n if edge.distance > distance:\\r\\n distance = edge.distance\\r\\n start = edge.start\\r\\n destination = edge.destination\\r\\n return start, destination, distance\",\n \"def get_last_flight(self):\\n return self.path[len(self.path) - 1]\",\n \"def longest_path_callback(self, data):\\n min_idx = self.find_minimum_distance(data.poses) # closest point index\\n if min_idx is None:\\n return\\n else:\\n # extract 20 points along the closest point\\n # use z position of ego car since z displacement doesn't matter\\n # truncate if encounter head or tail\\n path_points = np.array([\\n (pose.pose.position.x, pose.pose.position.y, self.car_pos[2])\\n for pose in data.poses[max(min_idx-10, 0):min_idx+10]]\\n )\\n # use svd to find the approximate tangent direction of longest path\\n approx_dir = np.linalg.svd(path_points-np.mean(path_points,axis=0))[2][0]\\n self.last_yaw_longestpath = np.arctan2(approx_dir[1], approx_dir[0])\\n # perpendicular distance is then the norm of vector\\n # (car_pos - pos_point) x approx_dir, x is cross product\\n self.last_dist_longestpath = np.linalg.norm(\\n np.cross(path_points[0,:] - self.car_pos, approx_dir)\\n )\\n # publish\\n self.pub_closest_dist_longestpath.publish(self.last_dist_longestpath)\",\n \"def GetAbsBeer(epsilon, conc, pathLength):\\n return epsilon * conc * pathLength\",\n \"def calculate_made_up_dist(self):\\n\\n # Ensure if current state equals goal, cost is only the current cost\\n if self._goal_loc == self._current_loc:\\n return self._current_cost\\n\\n # Distance is at least the Manhattan distance as cannot move diagonal\\n estimated_distance = self.calculate_manhattan_dist()\\n\\n # Assume two board parts in the priority queue have the same weight.\\n # For those board paths with higher actual cost and lower heuristic\\n # cost, there is more assurance in the accuracy of the actual cost\\n # than in the heuristic cost. Give a very small penalty (i.e. less\\n # than one step) to prefer a path with a higher known cost than a\\n # path with a higher heuristic cost.\\n # Extract the number of portion of the move cost from the heuristic\\n heuristic_cost = estimated_distance - self._current_cost\\n # Heuristic cost penalty is normalized to a maximum of 0.1 steps\\n # This is achieved by dividing the heuristic cost by the size of the\\n # board. Since the heuristic cost can never be larger than the board\\n # size, this quotient is less than or equal to 1. To normalize to a\\n # maximum of 0.1, just multiply the number by 0.1. This is than added\\n # to the estimated distance determined so far.\\n heuristic_cost_penalty = 0.1 * heuristic_cost\\n heuristic_cost_penalty /= BoardPath._traversed_board_size\\n # Add what is essentially an \\\"uncertainty penalty\\\"\\n estimated_distance += heuristic_cost_penalty\\n\\n # In case where all neighboring spaces are blocked or already\\n # traversed, then set the path cost prohibitively large so it is\\n # given minimum priority.\\n if not (self.is_move_valid(\\\"d\\\", BoardPath._traversed_board)) \\\\\\n and not (self.is_move_valid(\\\"u\\\", BoardPath._traversed_board)) \\\\\\n and not (self.is_move_valid(\\\"l\\\", BoardPath._traversed_board)) \\\\\\n and not (self.is_move_valid(\\\"r\\\", BoardPath._traversed_board)):\\n # Total board area is sufficient as a prohibitive distance\\n estimated_distance += BoardPath._traversed_board_size\\n return estimated_distance\\n\\n # If all next steps that load directly to the goal are blocked, then\\n # it takes at least two additional moves to get around the blocked\\n # paths it (due to an obstacle or already traversed square) so add\\n # two to the estimated distance to include that cost.\\n if self._is_all_direct_next_moves_blocked(BoardPath._traversed_board):\\n estimated_distance += 2\\n\\n # In a heap, if two nodes have the same cost, the object that was\\n # put into the heap first in many implementations will be on top of the\\n # heap. To make the algorithm more efficient, apply a slight penalty to\\n # a non valid solution to ensure if an invalid solution and a valid\\n # solution have the same cost that the valid solution would always be\\n # on top of the heap. This is done by giving all non-valid solutions a\\n # penalty term that is greater than zero and less than the minimum step\\n # size (e.g. in this case 0 < 0.1 < 1).\\n estimated_distance += 0.1\\n\\n # Return estimated distance\\n return estimated_distance\",\n \"def get_best_move_toward(self, target_ground):\\n options_by_parent, cost_to_reach = self.a_star_search(start=self.ground, goal=target_ground)\\n ground = target_ground\\n\\n # Can't reach it?\\n if ground not in options_by_parent:\\n return None\\n\\n while options_by_parent[ground] is not self.ground:\\n ground = options_by_parent[ground]\\n\\n return ground.x - self.ground.x, ground.y - self.ground.y\",\n \"def _calculate_h(self, end):\\n return PATH_COST * (abs(self.x - end.x) + abs(self.y - end.y))\",\n \"def one_way_path(most_important, total_distance, to_source2, to_source1):\\n\\n if total_distance == min(total_distance, to_source2[0], to_source1[0]):\\n return most_important_to_source(most_important), total_distance\\n elif to_source2[0] == min(total_distance, to_source2[0], to_source1[0]):\\n return most_important_to_source(to_source2[1]), to_source2[0]\\n else:\\n return most_important_to_source(to_source1[1], up=False), to_source1[0]\",\n \"def get_true_bearing(shot, top):\\n tripidx = shot[\\\"trip\\\"]\\n\\n if tripidx != -1:\\n decl = top[\\\"trips\\\"][tripidx][KEY_DECLINATION]\\n else:\\n decl = 0\\n\\n return shot[\\\"compass\\\"] + decl\",\n \"def getBestPath(self):\\n if self._bestPathVertex.getNextWaypoint() is None:\\n numWaypointsCompleted = len(self._waypoints)\\n quality = 2\\n if self._vertexQueue.isEmpty():\\n quality += 1\\n else:\\n numWaypointsCompleted = self._bestPathVertex.getNextWaypoint().getIndex()\\n quality = 1\\n if self._vertexQueue.isEmpty():\\n quality -= 1\\n \\n return outputPath.generatePath(self._bestPathVertex, self._params.waypointAcceptanceRadii, quality, numWaypointsCompleted)\",\n \"def altitude(press, altimeter=29.92126):\\n AS = altimeter*inHg2PA\\n print(AS, press**(L*R/g/M))\\n h = -(press**(L*R/g/M) - AS**(L*R/g/M))*T0/L/(P0**(L*R/g/M))\\n return h/ft2m\",\n \"def get_altitude(self):\\n return self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_GET_ALTITUDE, (), '', 'i')\",\n \"def GetDurationUntilDeparture(NextConnectionInfo, PathInfo):\\r\\n\\tdeparture_first_station = PathInfo[0][ConnInfoInd['arrival_hour']]*60 + PathInfo[0][ConnInfoInd['arrival_min']]\\r\\n\\tdeparture_next_station = NextConnectionInfo[ConnInfoInd['departure_hour']]*60 + NextConnectionInfo[ConnInfoInd['departure_hour']]\\r\\n\\treturn (departure_next_station - departure_first_station)\",\n \"def _plunge_distance(self, volume):\\n percent = self._volume_percentage(volume)\\n top = self._get_plunger_position('top')\\n bottom = self._get_plunger_position('bottom')\\n travel = bottom - top\\n if travel <= 0:\\n self.robot.add_warning('Plunger calibrated incorrectly')\\n return travel * percent\",\n \"def get_distance(self):\\n values = self.speakers.values()\\n values.sort(reverse=True)\\n try:\\n return abs(values[1]) - abs(values[0])\\n except (IndexError, ValueError):\\n return -1\",\n \"def get_air_density(self, altitude):\\n\\n altitude /= 1000 # convert to kilometers\\n\\n return self.get_air_density_from_model(altitude)\",\n \"def _find_fastest_path(self):\\n from simulator import Robot\\n clone_robot = Robot(exploration_status=self._robot.exploration_status,\\n facing=self._robot.facing,\\n discovered_map=self._robot.discovered_map,\\n real_map=[[0] * 15 for _ in range(20)])\\n\\n fastest_path_start_way_point = get_shortest_path_moves(clone_robot,\\n start=(1, 1),\\n goal=self._way_point)\\n\\n if fastest_path_start_way_point:\\n for move in fastest_path_start_way_point:\\n clone_robot.move_robot(move)\\n\\n before_way_point = previous_cell(clone_robot.center, clone_robot.facing)\\n\\n fastest_path_way_point_goal = get_shortest_path_moves(clone_robot,\\n start=self._way_point,\\n goal=(18, 13),\\n before_start_point=before_way_point)\\n\\n return fastest_path_start_way_point + fastest_path_way_point_goal\",\n \"def getDistance(self):\\n return sqrt(self.state[0] * self.state[0] + self.state[2] * self.state[2])\",\n \"def findShortestPath(self):\\r\\n pass\",\n \"def h_score(self):\\n if self.estimated_moves_to_goal is None:\\n self.estimated_moves_to_goal = \\\\\\n max(nx.single_source_shortest_path_length(self.graph, self.head_node).items(), key=lambda x: x[1])[1]\\n return self.estimated_moves_to_goal\",\n \"def GetDurationUntilNextArrival(NextConnectionInfo, PathInfo):\\r\\n\\tdeparture_first_station = PathInfo[0][ConnInfoInd['arrival_hour']]*60 + PathInfo[0][ConnInfoInd['arrival_min']]\\r\\n\\tarrival_next_station = NextConnectionInfo[ConnInfoInd['arrival_hour']]*60 + NextConnectionInfo[ConnInfoInd['arrival_hour']]\\r\\n\\treturn (arrival_next_station - departure_first_station)\",\n \"def get_closest_waypoint(self, pose):\\n if self.kdtree:\\n return kdtree_closest_point(self.kdtree,\\n (pose.x,\\n pose.y))\\n else:\\n return 0\",\n \"def get_closest_waypoint(self, pose):\\n if self.kdtree:\\n return kdtree_closest_point(self.kdtree,\\n (pose.position.x,\\n pose.position.y))\\n else:\\n return 0\",\n \"def path(self):\\n return self.alignment.matching_function_bestpath(self.idx)\",\n \"def find_path(self):\\n \\n if self.line_num != -1:\\n return self.line_num\\n\\n max_line = self.graph.gps_length - 1\\n min_line = 0\\n #last_id = dg.normalize(self.graph.lines[-1])[0]\\n last_id = normalize_simple(self.graph.lines[-1])[0]\\n pivot = int((self.trip_id-1)/float(last_id)*self.graph.gps_length)\\n #cur_id = dg.normalize(self.graph.lines[pivot])[0]\\n cur_id = normalize_simple(self.graph.lines[pivot])[0]\\n while cur_id != self.trip_id:\\n if cur_id < self.trip_id:\\n min_line = pivot\\n else:\\n max_line = pivot\\n #TODO: could make this run in essentially constant time by hopping predetermined distance\\n pivot = (min_line + max_line) / 2\\n #cur_id = dg.normalize(self.graph.lines[pivot])[0]\\n cur_id = normalize_simple(self.graph.lines[pivot])[0]\\n\\n #while dg.normalize(self.graph.lines[pivot])[0] == self.trip_id:\\n while normalize_simple(self.graph.lines[pivot])[0] == self.trip_id:\\n pivot -= 1\\n\\n pivot += 1\\n self.line_num = pivot\\n return pivot\",\n \"def well_diameter_at_top(self):\\n return self.radius_from_liquid_depth(self.well_depth) * 2 # a generic impl; subclasses can optimize\",\n \"def _distance_next(self):\\n\\n self.distance = 10\\n\\n # Here a set index to 0 if the car is finishing a lap\\n # Also reset the farthest\\n if self.index > (len(self.x_trajectory) - 6) and self.closed:\\n self.index = 0\\n self.farthest = -1\\n self.laps += 1\\n\\n for w in range(self.index, self.index + 20):\\n\\n self.dist_point = math.sqrt((self.x_trajectory[w] - self.x)**2\\n + (self.y_trajectory[w] - self.y)**2)\\n\\n if self.dist_point < self.distance:\\n self.distance = self.dist_point\\n self.index = w\\n\\n if w >= (len(self.x_trajectory) - 1):\\n break\\n\\n self._calc_side()\\n\\n self.distance = self.distance * self.sign\\n\\n return self.distance\",\n \"def set_altitude(self):\\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\\n print('altitude set to', self.altitude)\\n if self.altitude < 0:\\n self.altitude = self.altitude + 360.0\\n return self.altitude \\n else: \\n pass\\n return self.altitude\",\n \"def topo_diameter(self):\\n import math\\n \\n Temp = 0\\n for i in range(self.nodenum):\\n for j in range(self.nodenum):\\n pathlist = []\\n self.pathij(i, j, pathlist)\\n distance = []\\n \\n for k in range(len(pathlist)):\\n distance.append(len(pathlist[k]) - 1)\\n \\n if(len(distance) == 0):\\n continue\\n else:\\n if(min(distance) >= Temp):\\n Temp = min(distance)\\n \\n self.topodiameter = Temp\",\n \"def GetEpsilonBeer(Abs, conc, pathLength):\\n return Abs / (conc * pathLength)\",\n \"def get_distance(self) -> int:\\n return self.get_measurement_data().distance\",\n \"def estimated_distance(self, log=False):\\n\\t\\t\\n\\t\\tx0 = GRAVITY - self.thrust*.95 / (self.total_mass - self.fuel_consumption * 0.0)\\n\\t\\tx1 = GRAVITY - self.thrust*.95 / (self.total_mass - self.fuel_consumption * 1.0)\\n\\n\\t\\t# Derivative at x=0 and x=1\\n\\t\\tu = x0\\n\\t\\tv = x1\\n\\t\\t# Initial height at x=0\\n\\t\\ty = abs(self.velocity)\\n\\n\\t\\tif log:\\n\\t\\t\\tprint(f'u: {u}, v: {v}, y: {y}\\\\nEstimated distance: {get_positive_area(u, v, y)}\\\\n')\\n\\t\\t\\n\\t\\treturn get_positive_area(u, v, y)\",\n \"def getDistance(self):\\n taBox = (self.thor * self.tvert)/(720*960) #box area as percentage of whole\\n if(taBox==None or taBox<=0): return -1\\n const = 4 * math.tan(0.471)*math.tan(0.3576)\\n return math.sqrt((self.abox)/(const*taBox))\",\n \"def topographic_altitude(lat, lon):\\n global __model\\n type_output = type(lat)\\n lat = prepare_input_array(lat)\\n lon = prepare_input_array(lon)\\n lon = np.mod(lon, 360)\\n val = __model.topographic_altitude(lat, lon)\\n val = np.maximum(val, 1e-7)\\n return prepare_output_array(val, type_output) * u.km\",\n \"def get_distance(self, heuristic=\\\"\\\"):\\n # If no heuristic is specified, used the default\\n if(heuristic == \\\"\\\"):\\n heuristic = BoardPath._heuristic\\n\\n if(heuristic == \\\"manhattan\\\"):\\n return self.calculate_manhattan_dist()\\n elif(heuristic == \\\"euclidean\\\"):\\n return self.calculate_euclidean_dist()\\n elif(heuristic == \\\"made_up\\\"):\\n return self.calculate_made_up_dist()\\n else:\\n sys.exit()\",\n \"def get_distance(self):\\n\\n # Activate trigger\\n self.trigger()\\n\\n # Detect rising edge of echo pin\\n channel = GPIO.wait_for_edge(self.echo_pin, GPIO.RISING, timeout=2)\\n if channel is None:\\n # Timeout on wait of rising interrupt\\n return None\\n else:\\n # Rising edge detected, save pulse start\\n pulse_start = time.time()\\n\\n\\n # Detect falling edge of echo pin\\n channel = GPIO.wait_for_edge(self.echo_pin, GPIO.FALLING, timeout=2)\\n if channel is None:\\n # Timeout on wait of falling interrupt\\\")\\n return None\\n else:\\n # Falling edge detected, save pulse end\\n pulse_end = time.time()\\n\\n # Calculated pulse width in microseconds (x1mln)\\n pulse_width = (pulse_end - pulse_start)*1000000\\n\\n # Return distance in cm\\n return pulse_width / 58\",\n \"def find_hypocenter(self):\\n ps_hypo = min(self.pointsources, key=lambda x: x.time_shift)\\n self.hypocenter_longitude = ps_hypo.longitude\\n self.hypocenter_latitude = ps_hypo.latitude\\n self.hypocenter_depth_in_m = ps_hypo.depth_in_m\",\n \"def diff_of_errors(self):\\n self.e_of_e = self.azimuth_error - self.altitude_error\\n return self.e_of_e\",\n \"def alt_index(self) -> Optional[int]:\\n if not self.is_hom_alt():\\n return None\\n return max(self.allele1, self.allele2) - 1\",\n \"def distance_to_current_waypoint(vehicle):\\n nextwaypoint = vehicle.commands.next\\n if nextwaypoint==0:\\n return None\\n missionitem=vehicle.commands[nextwaypoint-1] #commands are zero indexed\\n lat = missionitem.x\\n lon = missionitem.y\\n alt = missionitem.z\\n targetWaypointLocation = LocationGlobalRelative(lat,lon,alt)\\n distancetopoint = get_distance_metres(vehicle.location.global_frame, targetWaypointLocation)\\n return distancetopoint\",\n \"def path_cost(path):\\n # path = [state, (action, total_cost), state, ... ]\\n if len(path) < 2:\\n return 0\\n else:\\n return path[-2][-1]\",\n \"def distance(self):\\n return Distance(length_of(self.position.au))\",\n \"def get_path_distance(self, path):\\n length = len(path)\\n distance = 0\\n for i in range(length):\\n distance += self.distances[path[i]][path[(i + 1) % length]]\\n return distance\",\n \"def calcPath(self):\\n return None\",\n \"def getBelowDistance(self):\\n return self.__belowDistance\",\n \"def distanceTo(self, other):\\n return math.hypot(abs(self.altitude_msl - other.altitude_msl),\\n self.gps_position.distanceTo(other.gps_position))\",\n \"def player_goal_distance(self) -> float:\\n route = self.best_route\\n return sum(route.values())\",\n \"def get_min_distance(self):\\n return round(min(self.combined_euclidian_distance))\",\n \"def _get_distance(self, target): \\r\\n sensor_transform = self._sensors['rgb_front'].get_transform()\\r\\n\\r\\n distance = np.sqrt(\\r\\n (sensor_transform.location.x - target.x) ** 2 +\\r\\n (sensor_transform.location.y - target.y) ** 2 +\\r\\n (sensor_transform.location.z - target.z) ** 2)\\r\\n\\r\\n return distance\",\n \"def get_altitude(self, degrees=True):\\n if degrees:\\n return math.degrees(self.current_location.al)\\n else:\\n return self.current_location.al\",\n \"def shortest_path_distance(self, other):\\n if self == other:\\n return 0\\n\\n paths = self.shortest_path(other)\\n return None if paths == [] else len(paths[0]) - 1\",\n \"def _earth_distance(time='now'):\\n return get_earth(time).radius\",\n \"def GetDurationOfTripSinceDeparture(PathInfo):\\r\\n\\tif not PathInfo:\\r\\n\\t\\treturn None \\r\\n\\tif len(PathInfo) < 2: return None \\r\\n\\r\\n\\tdeparture_first_station = PathInfo[1][ConnInfoInd['departure_hour']]*60 + PathInfo[1][ConnInfoInd['departure_min']]\\r\\n\\r\\n\\tarrival_last_station = PathInfo[-1][ConnInfoInd['arrival_hour']]*60 + PathInfo[-1][ConnInfoInd['arrival_min']]\\r\\n\\tTotalDuration = arrival_last_station - departure_first_station\\r\\n\\treturn TotalDuration\",\n \"def getPathLength(self, path):\\r\\n path_nodes = path\\r\\n # print(path_nodes)\\r\\n total_length = 0 # km\\r\\n for i in range(len(path_nodes)-1):\\r\\n next_edge = None\\r\\n for edge in self.graph.getAdj(path_nodes[i]):\\r\\n if edge.getExtremityNode() == path_nodes[i+1]:\\r\\n next_edge = edge\\r\\n if next_edge is None: # it means the path is invalid\\r\\n return None\\r\\n total_length += next_edge.getWeight()\\r\\n # print(next_edge.getTravelType(), end=\\\" \\\")\\r\\n return total_length\",\n \"def calculate_distance_edge(self):\\n if self.mu > 0:\\n # right interface is intersected next\\n dx = self.cell_xr - self.x\\n self.next_cell_index = self.cell_index + 1\\n else:\\n # left interface is intersected next\\n dx = self.cell_xl - self.x\\n self.next_cell_index = self.cell_index - 1\\n\\n return dx / self.mu\",\n \"def compute_direction(self, feats):\\n if feats.name == \\\"ARNC\\\":\\n if feats[\\\"z-score\\\"] < -1.5:\\n return Directions.long_dir\\n elif feats[\\\"z-score\\\"] > 1.5:\\n return Directions.short_dir\\n elif feats.name == \\\"UNG\\\":\\n if feats[\\\"z-score\\\"] < -1.5:\\n return Directions.short_dir\\n elif feats[\\\"z-score\\\"] > 1.5:\\n return Directions.long_dir\",\n \"def test_distance_aed(self):\\n railroad = trains.Railroad()\\n self.assertEqual(railroad.distance('AED'), 'NO SUCH ROUTE')\",\n \"def total_cost(path: Path) -> float:\\n\\t\\n\\tdistance = calc_total_dist(path)\\n\\tavg_speed = calc_average_speed(path)\\n\\t\\n\\t# Speed is less important, but gets a huge multiplier, because speed and\\n\\t# \\tdistance are in different units. Speed requires a high ratio to have\\n\\t# \\tsimilar amounts of variation.\\n\\tSPEED_DISTANCE_COST_RATIO = 7865.099\\n\\t\\n\\treturn (\\n\\t\\t(distance * 1) +\\n\\t\\t(-avg_speed * SPEED_DISTANCE_COST_RATIO)\\n\\t)\",\n \"def _get_distance(reindeer, race_time):\\n interval = reindeer.flight_time + reindeer.rest_time\\n cycles = race_time // interval\\n flight_time = min(reindeer.flight_time, race_time - interval * cycles)\\n total_flying_time = reindeer.flight_time * cycles + flight_time\\n return total_flying_time * reindeer.flight_speed\",\n \"def getDepthToTop(self):\\n mindep = 9999999\\n for quad in self._quadrilaterals:\\n P0, P1, P2, P3 = quad\\n depths = np.array([P0.depth, P1.depth, P2.depth, P3.depth])\\n if np.min(depths) < mindep:\\n mindep = np.min(depths)\\n return mindep\",\n \"def distance(self) -> float:\\n return self._dist_two_wire() # at this time we only support 2-wire meausre\",\n \"def get_global_total_distance_on_foot(self):\\n return self._get_global_total_distance([ActivityType.Run, ActivityType.Walk])\",\n \"def diameter(self):\\n\\n v = self.vertices()\\n pairs = [ (v[i],v[j]) for i in range(len(v)-1) for j in range(i+1, len(v))]\\n smallest_paths = []\\n for (s,e) in pairs:\\n paths = self.find_all_path(s,e)\\n smallest = sorted(paths, key=len)[0]\\n smallest_paths.append(smallest)\\n\\n smallest_paths.sort(key=len)\\n\\n # Print the list smallest_paths\\n\\n # Longest path is at the end of list\\n # ie diameter corresponds to length of this path\\n\\n diameter = len(smallest_paths[-1]) -1\\n return diameter\",\n \"def get(cls, approach):\\n return approach.distance\",\n \"def getAboveDistance(self):\\n return self.__aboveDistance\",\n \"def get_height_of_surface_gate(data, setup={}):\\n idx = get_index_of_surface_gate(data, setup)\\n nt = range(len(idx))\\n return data['alt'][nt, idx]\",\n \"def y_distance(self):\\n return self.get_distance(self.Y_INDEX)\",\n \"def _get_lsp_frr_path_cost(self):\\n return self.__lsp_frr_path_cost\",\n \"def extract_path(self):\\n if self.extracted_path is not None:\\n return self.extracted_path\\n current = self\\n path = []\\n while current:\\n path.append([current.end, current.path_cost])\\n current = current.parent\\n return list(reversed(path))\",\n \"def __get_deccelleration(self):\\n slowdown_span = (4.0/ 5.0) * (self.safe_distance - self.critical_distance)\\n return (self.speed ** 2.0) / (2.0 * slowdown_span)\",\n \"def get_distance_over_path(G, path):\\r\\n node1 = str(path[0])\\r\\n node2 = str(path[-1])\\r\\n\\r\\n pos1 = G.nodes[node1]['pos']\\r\\n pos2 = G.nodes[node2]['pos']\\r\\n\\r\\n return np.sqrt((pos1[0] - pos2[0])**2 + (pos1[1] - pos2[1])**2)\",\n \"def get_latest_locant(self):\\n return self._next_locant - 1\",\n \"def getOrdinate(self):\\n return self.point.y - self.slope * self.point.x\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6641679","0.6360074","0.6237355","0.6115602","0.6089604","0.5971742","0.5874693","0.58288443","0.5771951","0.57360345","0.5729539","0.57193947","0.56928456","0.5685602","0.5612506","0.5589079","0.5577618","0.557536","0.55737656","0.55690765","0.55622447","0.55622447","0.55244386","0.55064934","0.5490767","0.5481767","0.5450192","0.5446867","0.5443306","0.54166096","0.53915393","0.5390512","0.5379755","0.5356898","0.5350685","0.5344671","0.5342929","0.5325399","0.532184","0.5314948","0.5313015","0.53085995","0.53041863","0.53036726","0.52969414","0.52924347","0.5290667","0.5285716","0.52743495","0.52733827","0.52674574","0.5264909","0.5260654","0.5256845","0.52541894","0.52535564","0.52244514","0.52174586","0.520182","0.5189571","0.518925","0.5181919","0.5170002","0.5158927","0.5148811","0.51424664","0.51423144","0.51295507","0.51286423","0.51195544","0.51163685","0.51028776","0.5087049","0.50869995","0.50853974","0.5078612","0.5073763","0.50715405","0.50669074","0.5064","0.5058841","0.50463676","0.50355935","0.50282496","0.50279546","0.50264466","0.5020766","0.5010375","0.50016797","0.49955195","0.49904203","0.4987761","0.49874416","0.49739546","0.49738508","0.4971261","0.4970592","0.49674338","0.49673402","0.49660164"],"string":"[\n \"0.6641679\",\n \"0.6360074\",\n \"0.6237355\",\n \"0.6115602\",\n \"0.6089604\",\n \"0.5971742\",\n \"0.5874693\",\n \"0.58288443\",\n \"0.5771951\",\n \"0.57360345\",\n \"0.5729539\",\n \"0.57193947\",\n \"0.56928456\",\n \"0.5685602\",\n \"0.5612506\",\n \"0.5589079\",\n \"0.5577618\",\n \"0.557536\",\n \"0.55737656\",\n \"0.55690765\",\n \"0.55622447\",\n \"0.55622447\",\n \"0.55244386\",\n \"0.55064934\",\n \"0.5490767\",\n \"0.5481767\",\n \"0.5450192\",\n \"0.5446867\",\n \"0.5443306\",\n \"0.54166096\",\n \"0.53915393\",\n \"0.5390512\",\n \"0.5379755\",\n \"0.5356898\",\n \"0.5350685\",\n \"0.5344671\",\n \"0.5342929\",\n \"0.5325399\",\n \"0.532184\",\n \"0.5314948\",\n \"0.5313015\",\n \"0.53085995\",\n \"0.53041863\",\n \"0.53036726\",\n \"0.52969414\",\n \"0.52924347\",\n \"0.5290667\",\n \"0.5285716\",\n \"0.52743495\",\n \"0.52733827\",\n \"0.52674574\",\n \"0.5264909\",\n \"0.5260654\",\n \"0.5256845\",\n \"0.52541894\",\n \"0.52535564\",\n \"0.52244514\",\n \"0.52174586\",\n \"0.520182\",\n \"0.5189571\",\n \"0.518925\",\n \"0.5181919\",\n \"0.5170002\",\n \"0.5158927\",\n \"0.5148811\",\n \"0.51424664\",\n \"0.51423144\",\n \"0.51295507\",\n \"0.51286423\",\n \"0.51195544\",\n \"0.51163685\",\n \"0.51028776\",\n \"0.5087049\",\n \"0.50869995\",\n \"0.50853974\",\n \"0.5078612\",\n \"0.5073763\",\n \"0.50715405\",\n \"0.50669074\",\n \"0.5064\",\n \"0.5058841\",\n \"0.50463676\",\n \"0.50355935\",\n \"0.50282496\",\n \"0.50279546\",\n \"0.50264466\",\n \"0.5020766\",\n \"0.5010375\",\n \"0.50016797\",\n \"0.49955195\",\n \"0.49904203\",\n \"0.4987761\",\n \"0.49874416\",\n \"0.49739546\",\n \"0.49738508\",\n \"0.4971261\",\n \"0.4970592\",\n \"0.49674338\",\n \"0.49673402\",\n \"0.49660164\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.660244"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":91988,"cells":{"query":{"kind":"string","value":"Calculate distances where the profile is at the given altitude."},"document":{"kind":"string","value":"def intersection_distances(self, altitude, start_distance, finish_distance):\n distances = []\n alt_index, alt_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, alt_index, alt_ratio)\n\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n while alt_index < finish_index:\n next_index = alt_index + 1\n next_ratio = 0.0\n next_alt = calculate_value(self.altitudes, next_index, next_ratio)\n\n # Does this section span the given altitude?\n if (next_alt != start_alt) and \\\n (min(start_alt, next_alt) < altitude < max(start_alt, next_alt)):\n delta = altitude - start_alt\n denom = next_alt - start_alt\n ratio = delta / denom\n distance = calculate_value(self.distances, alt_index, ratio)\n distances.append(distance)\n\n alt_index = next_index\n alt_ratio = next_ratio\n start_alt = next_alt\n\n if finish_ratio:\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n # Does the last section span the given altitude?\n if (start_alt != finish_alt) and \\\n (min(start_alt, finish_alt) < altitude < max(start_alt, finish_alt)):\n # Calculate the altitude at the end of the section to maximimse accuracy\n next_alt = calculate_value(self.altitudes, finish_index, 1.0)\n delta = altitude - start_alt\n denom = next_alt - start_alt\n ratio = delta / denom\n distance = calculate_value(self.distances, alt_index, ratio)\n distances.append(distance)\n\n return distances"},"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 altitude_profile(self, alt):\n # checking if the units entered are km\n if alt.unit == u.km:\n if 150 <= alt.value < 500:\n alt_properties = self._altitude_profile(500)\n else:\n alt_properties = self._altitude_profile(alt.value)\n\n return [last[int(alt.value)] for last in alt_properties]","def getAltitudeProfile(pass_length,terrain,uav_altitude,u,start_v,wind_angle):\n altitude_profile = []\n v = start_v\n for k in range(0,round(pass_length)):\n coord = convertCoords([[u,v]],wind_angle,'xy')\n x = coord[0][0]\n y = coord[0][1]\n x_points = [int(x),int(x),int(x)+1,int(x)+1]\n y_points = [int(y),int(y)+1,int(y)+1,int(y)]\n z_points = [terrain[int(y)][int(x)],terrain[int(y)+1][int(x)],\n terrain[int(y)+1][int(x)+1],terrain[int(y)][int(x)+1]]\n\n # For created terrain ONLY\n z = griddata((x_points,y_points),z_points,(x,y)) # Interpolate \n altitude = z + uav_altitude\n\n altitude_profile.append(altitude)\n v +=1\n return altitude_profile","def closest_cruising_altitude(altitude):\n return 1000 * ((altitude + 500) // 1000)","def altitude(self):\n if self.__altitude:\n return sum(self.__altitude) / len(self.__altitude)\n else:\n return -9999","def get_air_density(self, altitude):\n\n altitude /= 1000 # convert to kilometers\n\n return self.get_air_density_from_model(altitude)","def topographic_altitude(self, lat_d, lon_d):\n return self.altitude(lat_d, lon_d)","def topographic_altitude(self, lat_d, lon_d):\n return self.altitude(lat_d, lon_d)","def get_altitude(points):\n altitudes = np.zeros((len(points),), dtype=\"float64\")\n for i, point in tqdm(enumerate(points), desc=\"GETTING ALTITUDE\"):\n p = Point(point[0], point[1])\n altitudes[i] = alt.NM_COTA.iloc[\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\n ]\n return altitudes","def altitude(self) -> int:\n return self._point.altitude","def get_altitude(self):\n return self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_GET_ALTITUDE, (), '', 'i')","def get_altitude(self):\n self.degrees = self.altitude_encoder.get_degrees()\n self.tele_altitude = self.Calculations.convert_degrees( self.degrees)\n return self.tele_altitude","def topographic_altitude(lat, lon):\n global __model\n type_output = type(lat)\n lat = prepare_input_array(lat)\n lon = prepare_input_array(lon)\n lon = np.mod(lon, 360)\n val = __model.topographic_altitude(lat, lon)\n val = np.maximum(val, 1e-7)\n return prepare_output_array(val, type_output) * u.km","def get_ground_distances(self):\n return np.array([self.get_distance(name) for name in self.ground_distance_sensors])","def getAltitudeAngle(self):\n return self._altitude","def set_altitude(self):\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\n print('altitude set to', self.altitude)\n if self.altitude < 0:\n self.altitude = self.altitude + 360.0\n return self.altitude \n else: \n pass\n return self.altitude","def altitude_range(self, start_distance, finish_distance):\n start_index, start_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\n finish_index, finish_ratio = calculate_value_reference(self.distances,\n finish_distance)\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\n\n min_alt = min(start_alt, finish_alt)\n max_alt = max(start_alt, finish_alt)\n\n if start_index < finish_index:\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\n min_alt = min(min_alt, altitudes.min())\n max_alt = max(max_alt, altitudes.max())\n\n return min_alt, max_alt","def get_user_sector_altitude_range(db_id):\n found, sector = user_sector_finder(\"id\", int(db_id))\n if found:\n return (sector[0]['min_altitude'], sector[0]['max_altitude'])\n else:\n raise NotFoundException(db_id, \"User sector not found.\")","def altitude(self):\r\n pressure = self.pressure # in Si units for hPascal\r\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))","def get_location_offset_meters(self, dNorth, dEast, alt):\n earth_radius=6378137.0 #Radius of \"spherical\" earth\n #Coordinate offsets in radians\n dLat = dNorth/earth_radius\n dLon = dEast/(earth_radius*math.cos(math.pi*self.home.lat/180))\n\n #New position in decimal degrees\n newlat = self.home.lat + (dLat * 180/math.pi)\n newlon = self.home.lon + (dLon * 180/math.pi)\n return LocationGlobal(newlat, newlon,self.home.alt+alt)","def _get_points(self, user: User, elevation: float, distance: float, pace: time) -> int:\n if _get_user_sex(user) == Sex.Female:\n return ceil((distance * (1 + self._get_elevation(elevation,\n distance)) * self._FEMALE_COEFFICIENT) * _get_pace_percentage(\n pace))\n\n return ceil(\n (distance * (1 + self._get_elevation(elevation, distance)) * self._MALE_COEFFICIENT) * _get_pace_percentage(\n pace))","def distance(self, lat: float, long: float) -> float:\n # Initial euclidian formula below\n # diff_lat = self.lat - lat\n # diff_long = self.long - long\n # euclidian = math.sqrt((diff_lat ** 2 + diff_long ** 2 + self.altitude ** 2))\n\n return self._haversine(lat, long) + self.altitude / 1000","def offset_to_altaz(xoff, yoff, azimuth, altitude):\n #Deal with situations where offset = 0?\n\n d = sqrt(xoff*xoff+yoff*yoff)\n pos = np.where(d==0)\n d=1e-12 * u.deg # add a very small offset to prevent math errors\n\n q = arctan(d.to(u.rad).value)\n\n sq = sin(q)\n xp1 = xoff * (sq/d)\n yp1 = yoff * (sq/d)\n zp1 = cos(q)\n\n cx = sin(altitude)\n sx = cos(altitude)\n\n xp0 = cx*xp1 - sx*zp1\n yp0 = yp1\n zp0 = sx*xp1 + cx*zp1\n\n obj_altitude = arcsin(zp0)\n obj_altitude[pos]=altitude\n obj_azimuth = arctan2(yp0,-xp0) + azimuth\n obj_azimuth[pos] = azimuth\n\n #if obj_azimuth.value < 0.:\n # obj_azimuth += 2.*pi\n #elif obj_azimuth.value >= (2.*pi ):\n # obj_azimuth -= 2.*pi\n\n return obj_altitude,obj_azimuth","def altitude_speed(self, degrees = True):\n return self.angularSpeed(self.future_location.al, self.old_location.al)","def haversine_distance_ignore_altitude(loc1_lat, loc1_lon, loc2_lat, loc2_lon):\n R = 6372797.560856 # radius of the earth in meters\n\n lat_arc = math.radians(loc1_lat - loc2_lat)\n lon_arc = math.radians(loc1_lon - loc2_lon)\n\n lat_h = math.sin(lat_arc * 0.5)\n lat_h = lat_h * lat_h\n\n lon_h = math.sin(lon_arc * 0.5)\n lon_h = lon_h * lon_h\n\n tmp = math.cos(math.radians(loc1_lat)) * math.cos(math.radians(loc2_lat))\n rad = 2.0 * math.asin(math.sqrt(lat_h + tmp * lon_h))\n\n return rad * R","def distanceTo(self, other):\n return math.hypot(abs(self.altitude_msl - other.altitude_msl),\n self.gps_position.distanceTo(other.gps_position))","def _get_elevation_percentage(height: float, distance: float) -> float:\n return height / (distance * 1000)","def air_density(altitude):\n p = pressure(altitude) # psf\n t = temperature(altitude) # R\n rho = p/(gas_constant*t) # lb/ft3\n return rho","def get_altitude(self, degrees=True):\n if degrees:\n return math.degrees(self.current_location.al)\n else:\n return self.current_location.al","def altaz_to_offset(obj_azimuth,obj_altitude,azimuth,altitude):\n\n daz = obj_azimuth - azimuth\n coa = cos(obj_altitude)\n\n xp0 = -cos(daz) * coa\n yp0 = sin(daz) * coa\n zp0 = sin(obj_altitude)\n\n cx = sin(altitude)\n sx = cos(altitude)\n\n xp1 = cx*xp0 + sx*zp0\n yp1 = yp0\n zp1 = -sx*xp0 + cx*zp0\n\n q = arccos(zp1)\n d = tan(q)\n alpha = arctan2(yp1,xp1)\n\n xoff = d * cos(alpha)\n yoff = d * sin(alpha)\n\n return xoff,yoff","def sim_altitude(a):\n a.takeoff()\n for i in range(20):\n b = a.refresh()\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() + 3)\n print a.altitude.get_altitudes(), b\n a.land()\n a.motor.set_speed(2000.0)\n for i in range(20):\n b = a.refresh()\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() - 3)\n print a.altitude.get_altitudes(), b","def _euclidian_distances(stop_list):\n e_dists2 = [transitfeed.approximate_distance_between_stops(stop, tail) for\n (stop, tail) in zip(stop_list, stop_list[1:])]\n\n return e_dists2","def _calculate_distance(self, passenger, driver):\n londriver, latdriver = driver['lon'], driver['lat']\n lonpassenger, latpassenger = passenger['lon'], passenger['lat']\n lon_p, lat_p, lon_d, lat_d = map(radians,\n [float(lonpassenger), float(latpassenger), float(londriver), float(latdriver)])\n lon_distance = lon_d - lon_p\n lat_distance = lat_d - lat_p\n a = sin(lat_distance / 2) ** 2 + cos(lat_p) * cos(lat_d) * sin(lon_distance / 2) ** 2\n c = 2 * asin(sqrt(a))\n km = 6367 * c\n return km","def _calculate_distance(self, passenger, driver):\n londriver, latdriver = driver['lon'], driver['lat']\n lonpassenger, latpassenger = passenger['lon'], passenger['lat']\n lon_p, lat_p, lon_d, lat_d = map(radians,\n [float(lonpassenger), float(latpassenger), float(londriver), float(latdriver)])\n lon_distance = lon_d - lon_p\n lat_distance = lat_d - lat_p\n a = sin(lat_distance / 2) ** 2 + cos(lat_p) * cos(lat_d) * sin(lon_distance / 2) ** 2\n c = 2 * asin(sqrt(a))\n km = 6367 * c\n return km","def __calculate_average_distance(self):\n game = self.__game # type: Game\n all_icebergs = game.get_all_icebergs()\n all_icebergs_length = len(all_icebergs)\n sum_distances = 0\n for i in range(all_icebergs_length):\n for j in range(i + 1, all_icebergs_length):\n iceberg1 = all_icebergs[i]\n iceberg2 = all_icebergs[j]\n sum_distances += iceberg1.get_turns_till_arrival(iceberg2)\n\n return sum_distances / (all_icebergs_length * (all_icebergs_length - 1) / 2)","def calculate_vars(data, lat, lon):\n # Keep track of running distance and time calculations\n distance_to_dest = 0.0\n time_estimate = 0.0\n\n # Calculate from starting dest to first point in data\n user_coords = (lat, lon)\n first_path_coords = (data[0][\"lat\"], data[0][\"lon\"])\n first_distance = geopy.distance.distance(user_coords, first_path_coords).miles\n distance_to_dest += first_distance\n time_estimate += first_distance * 20 # 3mph walking speed\n\n # Calculate for all other points\n for i in range(1, len(data) - 1):\n this_coords = (data[i][\"lat\"], data[i][\"lon\"])\n next_coords = (data[i + 1][\"lat\"], data[i + 1][\"lon\"])\n\n distance = geopy.distance.distance(this_coords, next_coords).miles\n distance_to_dest += distance\n time_estimate += distance * 20 # 3mph walking speed\n\n # Round distance and time estimates\n distance_to_dest = round(distance_to_dest, 1)\n time_estimate = round(time_estimate)\n\n return distance_to_dest, time_estimate","def elevation(self):\n return self.altitude - self.heightAboveGround","def getAltitudeFromLatLon(self, lat, lon):\r\n # print \"-----\\nFromLatLon\", lon, lat\r\n lat -= self.lat\r\n lon -= self.lon\r\n # print \"lon, lat\", lon, lat\r\n if lat < 0.0 or lat >= 1.0 or lon < 0.0 or lon >= 1.0:\r\n raise WrongTileError(self.lat, self.lon, self.lat+lat, self.lon+lon)\r\n x = lon * (self.size - 1)\r\n y = lat * (self.size - 1)\r\n # print \"x,y\", x, y\r\n x_int = int(x)\r\n x_frac = x - int(x)\r\n y_int = int(y)\r\n y_frac = y - int(y)\r\n # print \"frac\", x_int, x_frac, y_int, y_frac\r\n value00 = self.getPixelValue(x_int, y_int)\r\n value10 = self.getPixelValue(x_int+1, y_int)\r\n value01 = self.getPixelValue(x_int, y_int+1)\r\n value11 = self.getPixelValue(x_int+1, y_int+1)\r\n value1 = self._avg(value00, value10, x_frac)\r\n value2 = self._avg(value01, value11, x_frac)\r\n value = self._avg(value1, value2, y_frac)\r\n # print \"%4d %4d | %4d\\n%4d %4d | %4d\\n-------------\\n%4d\" % (\r\n # value00, value10, value1, value01, value11, value2, value)\r\n return value","def calculate_distance(pitch):\n # TODO: Use actual values calculated\n target_height = 60\n camera_height = 40\n height_difference = target_height - camera_height\n distance = math.fabs(height_difference / math.tan(math.radians(pitch)))\n\n return distance","def create_altitude_profile(self, max_altitude=32, exponential_constant=0.05, ground_altitude=6, timespan=30,\n timestep=1 / 60):\n x_time = np.arange(0, timespan, timestep)\n y_target_profile = max_altitude * np.exp(-exponential_constant * x_time) + ground_altitude\n return x_time, y_target_profile","def calc_distance(self, observation):\n actual_obs = observation[0]\n scrn_player = actual_obs.observation.feature_screen.player_relative\n scrn_select = actual_obs.observation.feature_screen.selected\n scrn_density = actual_obs.observation.feature_screen.unit_density\n\n state_added = scrn_select + scrn_density\n\n marine_center = np.mean(self.xy_locs(scrn_player == 1), axis=0).round()\n\n # first step\n if np.sum(scrn_select) == 0:\n marine_center = np.mean(self.xy_locs(scrn_player == 1), axis=0).round()\n # marine behind beacon\n if isinstance(marine_center, float):\n marine_center = np.mean(self.xy_locs(state_added == 2), axis=0).round()\n else:\n # normal navigation\n marine_center = np.mean(self.xy_locs(state_added == 2), axis=0).round()\n if isinstance(marine_center, float):\n marine_center = np.mean(self.xy_locs(state_added == 3), axis=0).round()\n\n beacon_center = np.mean(self.xy_locs(scrn_player == 3), axis=0).round()\n #\n # print(state_added)\n # print(\"---- Marine {} | {} Beacon ----\".format(marine_center, beacon_center))\n # time.sleep(0.2)\n distance = math.hypot(beacon_center[0] - marine_center[0],\n beacon_center[1] - marine_center[1])\n\n return beacon_center, marine_center, distance","def test_triangle_get_longest_altitude(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_longest_altitude(), 9.428090415820634)","def get_elementary_airspace_altitude_range(db_id):\n connection = get_geo_db_connection()\n sector = find_sector(db_id, connection)\n if (sector):\n return (sector['min_altitude'], sector['max_altitude'])\n else:\n raise NotFoundException(db_id, \"Elementary sector not found.\")","def altitude_control(self, altitude_cmd,\n vertical_velocity_cmd,\n altitude,\n vertical_velocity,\n attitude,\n acceleration_ff=0.0):\n \n hdot_cmd = self.Kp_alt * (altitude_cmd - altitude) + vertical_velocity_cmd\n \n # Limit the ascent/descent rate\n hdot_cmd = np.clip(hdot_cmd, -self.max_descent_rate, self.max_ascent_rate)\n\n acceleration_cmd = acceleration_ff + self.Kp_hdot*(hdot_cmd - vertical_velocity)\n \n R33 = np.cos(attitude[0]) * np.cos(attitude[1])\n thrust = DRONE_MASS_KG * acceleration_cmd / R33\n \n if thrust > MAX_THRUST:\n thrust = MAX_THRUST\n elif thrust < 0.0:\n thrust = 0.0\n return thrust","def test_triangle_get_shortest_altitude(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)","def ecef2LatLonAlt(x, y, z):\n\n # Calculate the polar eccentricity\n ep = np.sqrt((EARTH.EQUATORIAL_RADIUS**2 - EARTH.POLAR_RADIUS**2)/(EARTH.POLAR_RADIUS**2))\n\n # Calculate the longitude\n lon = np.arctan2(y, x)\n\n p = np.sqrt(x**2 + y**2)\n\n theta = np.arctan2( z*EARTH.EQUATORIAL_RADIUS, p*EARTH.POLAR_RADIUS)\n\n # Calculate the latitude\n lat = np.arctan2(z + (ep**2)*EARTH.POLAR_RADIUS*np.sin(theta)**3, \\\n p - (EARTH.E**2)*EARTH.EQUATORIAL_RADIUS*np.cos(theta)**3)\n\n # Get distance from Earth centre to the position given by geographical coordinates, in WGS84\n N = EARTH.EQUATORIAL_RADIUS/math.sqrt(1.0 - (EARTH.E**2)*math.sin(lat)**2)\n\n \n # Calculate the height in meters\n\n # Correct for numerical instability in altitude near exact poles (and make sure cos(lat) is not 0!)\n if((np.abs(x) < 1000) and (np.abs(y) < 1000)):\n alt = np.abs(z) - EARTH.POLAR_RADIUS\n\n else:\n # Calculate altitude anywhere else\n alt = p/np.cos(lat) - N\n\n\n return lat, lon, alt","def get_distance_between_point(test_long, test_lat, lab_long, lab_lat):\r\n test = (test_lat, test_long)\r\n lab = (lab_lat, lab_long)\r\n return geodesic(test, lab).miles","def haversine_distance(loc1_lat, loc1_lon, loc1_alt, loc2_lat, loc2_lon, loc2_alt):\n R = 6372797.560856 # radius of the earth in meters\n R = R + loc2_alt - loc1_alt\n\n lat_arc = math.radians(loc1_lat - loc2_lat)\n lon_arc = math.radians(loc1_lon - loc2_lon)\n\n lat_h = math.sin(lat_arc * 0.5)\n lat_h = lat_h * lat_h\n\n lon_h = math.sin(lon_arc * 0.5)\n lon_h = lon_h * lon_h\n\n tmp = math.cos(math.radians(loc1_lat)) * math.cos(math.radians(loc2_lat))\n rad = 2.0 * math.asin(math.sqrt(lat_h + tmp * lon_h))\n\n return rad * R","def altitude(press, altimeter=29.92126):\n AS = altimeter*inHg2PA\n print(AS, press**(L*R/g/M))\n h = -(press**(L*R/g/M) - AS**(L*R/g/M))*T0/L/(P0**(L*R/g/M))\n return h/ft2m","def add_altitude():\n\n doc = Metashape.app.document\n if not len(doc.chunks):\n raise Exception(\"No chunks!\")\n\n # alt = Metashape.app.getFloat(\"Please specify the height to be added:\", 100)\n alt = float(sys.argv[1])\n\n\n chunk = doc.chunk\n\n for camera in chunk.cameras:\n if camera.reference.location:\n coord = camera.reference.location\n camera.reference.location = Metashape.Vector([coord.x, coord.y, coord.z + alt])\n print(\"Add : \"+str(sys.argv[1]))","def _plunge_distance(self, volume):\n percent = self._volume_percentage(volume)\n top = self._get_plunger_position('top')\n bottom = self._get_plunger_position('bottom')\n travel = bottom - top\n if travel <= 0:\n self.robot.add_warning('Plunger calibrated incorrectly')\n return travel * percent","def classify_altitude_profile(altitudes):\n max_alt = altitudes.max()\n has_climb = (max_alt > altitudes[0])\n has_descent = (max_alt > altitudes[-1])\n\n if has_climb or has_descent:\n if has_climb != has_descent:\n return AltitudeProfileType.CLIMBING if has_climb \\\n else AltitudeProfileType.DESCENDING\n else:\n return AltitudeProfileType.CLIMBING_AND_DESCENDING\n else:\n return AltitudeProfileType.CRUISING","def pressure_to_altitude(pres):\n for i in range(len(_heights)-1,0,-1):\n P0 = _basepress[i]\n T0 = _basetemps[i]\n if pres < P0:\n if _isotherm[i]:\n dh = _R * T0 / _g * math.log(P0 / pres)\n else:\n l0 = _lapsert[i]\n dh = T0 / l0 * (math.pow(pres / P0, -l0 * _R / _g) - 1)\n return _heights[i] + dh\n l0 = _lapsert[0]\n return _stdtemp / l0 * (math.pow(pres / _stdpres, -l0 * _R / _g) - 1)","def get_distance_metres(aLocation1, aLocation2):\n [dNorth, dEast, dDown] = get_position_error(aLocation1, aLocation2)\n \n return math.sqrt((dNorth*dNorth) + (dEast*dEast))","def temperature(altitude):\n if altitude <= 36152:\n t = 59-0.00356*altitude # deg F\n else:\n t = -70 # deg F\n t = t + 459.7 # R\n return t","def getDistance(angle):\n\n panTilt.pan(angle)\n time.sleep(DELAY)\n wallDistance = getWallDistance()\n edgeDistance = getEdgeDistance() if wallDistance is None else None\n\n return wallDistance, edgeDistance","def get_distance(self) -> int:\n return self.get_measurement_data().distance","def calculate_distance(srcLong, srcLat, dstLong, dstLat):\n return math.sqrt( (srcLong-dstLong) ** 2 + (srcLat - dstLat) ** 2)","def get_distance(restuarant, user):\n lat1 = math.radians(restuarant[1])\n lon1 = math.radians(restuarant[0])\n lat2 = math.radians(user[1])\n lon2 = math.radians(user[0])\n dlon = lon1 - lon2\n dlat = lat1 - lat2\n a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * \\\n math.cos(lat2) * math.sin(dlon / 2) ** 2\n dist = 2 * math.asin(math.sqrt(a))*6371\n return dist","def diff_of_errors(self):\n self.e_of_e = self.azimuth_error - self.altitude_error\n return self.e_of_e","def _get_distance(self, target): \r\n sensor_transform = self._sensors['rgb_front'].get_transform()\r\n\r\n distance = np.sqrt(\r\n (sensor_transform.location.x - target.x) ** 2 +\r\n (sensor_transform.location.y - target.y) ** 2 +\r\n (sensor_transform.location.z - target.z) ** 2)\r\n\r\n return distance","def getSlantRangeElevationHeight(self, groundRange, z):\r\n \r\n lat = self.ctrLat * pi / 180.0\r\n \r\n #figure out earth's radius at radar's lat ... non-spherical earth model\r\n e2 = self.eccen # First eccentricity squared - WGS-84 value = 0.00669437999013\r\n a = self.Requator # Equatorial radius - WGS-84 value = 6378137.0\r\n Rearth = a/sqrt(1-e2*(sin(lat))**2) # radius of curvature\r\n \r\n Rprime = self.effectiveRadiusMultiplier * self.Requator\r\n \r\n h = array(z - self.ctrAlt, dtype='float64')\r\n s = array(groundRange, dtype='float64')\r\n \r\n # Use law of cosines (Side-Angle-Side triangle theorem) with \r\n # R', R'+h as sides and s/R' as the angle to get slant range\r\n r = sqrt(Rprime**2.0 + (Rprime+h)**2.0 - 2*(Rprime+h)*Rprime*cos(s/Rprime))\r\n # Inverse of eq. 2.28c in Doviak and Zrnic 1993\r\n # Will return NaN for r=0\r\n el = arccos((Rprime+h) * sin(s/Rprime) / r) \r\n el *= 180.0 / pi\r\n \r\n return r, el","def comparable_dist(zamg_id):\n station_lat, station_lon = stations[zamg_id]\n return (lat - station_lat) ** 2 + (lon - station_lon) ** 2","def read_altitude(self, meanSeaLevelPressureInBar):\n phPa = self.read_pressure() / 100.0\n\n return float(44330.0 * (1.0 - math.pow((phPa / meanSeaLevelPressureInBar), 0.1903)))","def read_altitude(self, meanSeaLevelPressureInBar):\n phPa = self.read_pressure() / 100.0\n\n return float(44330.0 * (1.0 - math.pow((phPa / meanSeaLevelPressureInBar), 0.1903)))","def calculate_zoom(self):\n distances = [geopy.distance.geodesic(self.centre_location, centroid).km for centroid in self.centroids]\n a = 4 / 20000\n distances = [1 + 4 - a * distance for distance in distances]\n print(min(distances))\n return min(distances)","def _get_admin_distance(self):\n return self.__admin_distance","def point_distances(self, params=None):\n if params is None:\n params = self.collocation_points()\n with self.fix_evaluator():\n pts = np.array([self(la) for la in params])\n deltas = np.diff(pts, axis=0)\n distances = norm(deltas, axis=1)\n return distances","def altitude(self, value: int):\n self._point.altitude = value","def setTargetAltitude(altitude):\n return RoboCaller().call(\"setTargetAltitude\", \"void\", altitude)","def get_distance_meters(aLocation1, aLocation2):\n dlat = aLocation2.lat - aLocation1.lat\n dlong = aLocation2.lon - aLocation1.lon\n return math.sqrt((dlat*dlat) + (dlong*dlong)) * 1.113195e5","def _getDistance(self, source, dest):\n\n lat1 = source[0]\n lat2 = dest[0]\n lon1 = source[1]\n lon2 = dest[1]\n\n # Formula from https://www.movable-type.co.uk/scripts/latlong.html\n R = 6370000\n phi1 = math.radians(lat1)\n phi2 = math.radians(lat2)\n deltaPhi = math.radians(lat2-lat1)\n deltalmb = math.radians(lon2-lon1)\n a = math.sin(deltaPhi/2) * math.sin(deltaPhi/2) + \\\n math.cos(phi1) * math.cos(phi2) * \\\n math.sin(deltalmb/2) * math.sin(deltalmb/2)\n c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a));\n d = (R * c)/1000.\n\n return d","def euclidean_distance(self):\n return sqrt(pow((self.goal_pose.x - self.ground_truth_pose.x), 2) +\n pow((self.goal_pose.y - self.ground_truth_pose.y), 2))","def get_distances_from_center(center_coordinates, p_coordinates):\n \n center_y, center_x = center_coordinates\n p_y, p_x = p_coordinates\n return (p_y - center_y)**2 + (p_x - center_x)**2","def density(self, alt):\n (Z, T, CN2, CO2, CO, CAr, CHe, CH, CM, WM) = self.altitude_profile(alt)\n\n # using eqn(42) of COESA for multiple gases\n M_i = [wmN2, wmO2, wmO, wmAr, wmHe, wmH] << (u.g / u.mol)\n n_i = [\n CN2.to_value(u.m**-3),\n CO2.to_value(u.m**-3),\n CO.to_value(u.m**-3),\n CAr.to_value(u.m**-3),\n CHe.to_value(u.m**-3),\n CH.to_value(u.m**-3),\n ] << (1 / u.m**3)\n rho = (n_i @ M_i) / Na\n return rho.to(u.kg / u.m**3)","def _get_dst(self, df_train, df_test):\n #train NearestNeighbors(Unsupervised learner)\n neigh = NearestNeighbors(1)\n neigh.fit(df_train[['longitude', 'latitude']])\n #find the K-neighbors of points in df_test\n distances, indices = neigh.kneighbors(df_test[['longitude', 'latitude']])\n return distances","def _calc_distance_features(self):\n d = ()\n for dx, dy in DIRECTIONS:\n if dx and dy:\n d += (list(self.__calc_distance(direction_x=dx, direction_y=dy)), )\n elif dx:\n tmp, _, _ = self.__calc_distance(direction_x=dx, direction_y=dy)\n d += (tmp, )\n elif dy:\n _, tmp, _ = self.__calc_distance(direction_x=dx, direction_y=dy)\n d += (tmp, )\n\n self.dist_features = d\n\n self.direc_dist = self.__calc_direc_distance()","def get_distances(self):\n return DistanceSensors(*self.bot_client.send_command(_Command.GetDistances))","def get(cls, approach):\n return approach.distance","def getAltitudeReadings():\n return RoboCaller().call(\"getAltitudeReadings\", \"int\")","def find_distance(start, end, transit_mode=None):\n dis_url = build_url(start, end, transit_mode)[1]\n print(dis_url)\n json_response = json.loads(urllib.request.urlopen(dis_url).read().decode('utf-8'))\n travel_info = json_response[rows_key][0][elements_key][0]\n distance = travel_info[distance_key][text_key]\n if duration_key in json_response:\n duration = travel_info[duration_traf_key][text_key]\n else:\n duration = travel_info[duration_key][text_key]\n cost = None\n if fare_key in travel_info:\n cost = travel_info[fare_key]\n return duration, distance, cost","def getDist(lat1,long1,lat2,long2):\n\tlat1 = math.radians(lat1)\n\tlong1 = math.radians(long1)\n\tlat2 = math.radians(lat2)\n\tlong2 = math.radians(long2)\n\tR = 6371 # km\n\td = cmath.acos(cmath.sin(lat1) * cmath.sin(lat2) + \\\n\tcmath.cos(lat1) * cmath.cos(lat2) *\n\tcmath.cos(long2 - long1)) * R\n\treturn abs(d) # cast to float","def distance_intermediate_formula(lat1, long1, lat2, long2):\n return pow(sin(radians(col(lat1) - col(lat2)) / 2), 2) + (\n pow(sin(radians(col(long1) - col(long2)) / 2), 2)\n * cos(radians(col(lat1)))\n * cos(radians(col(lat2)))\n )","def filter_altitude(self, gps_data, setting=None, threshold=None):\n\n # New filter settings if provided\n if setting is not None:\n self.gps_altitude_filter = setting\n if setting == 'Manual':\n self.gps_altitude_filter_change = threshold\n\n # Set threshold for Auto\n if self.gps_altitude_filter == 'Auto':\n self.gps_altitude_filter_change = 3\n\n # Set all data to valid\n self.valid_data[3, :] = True\n # self.valid_data[5, :] = True\n\n # Manual or Auto is selected, apply filter\n if not self.gps_altitude_filter == 'Off':\n # Initialize variables\n num_valid_old = np.sum(self.valid_data[3, :])\n k = 0\n change = 1\n # Loop until no change in the number of valid ensembles\n while k < 100 and change > 0.1:\n # Compute mean using valid ensembles\n alt_mean = np.nanmean(gps_data.altitude_ens_m[self.valid_data[1, :]])\n\n # Compute difference for each ensemble\n diff = np.abs(gps_data.altitude_ens_m - alt_mean)\n\n # Mark invalid those ensembles with differences greater than the change threshold\n self.valid_data[3, diff > self.gps_altitude_filter_change] = False\n k += 1\n num_valid = np.sum(self.valid_data[3, :])\n change = num_valid_old - num_valid\n\n # Combine all filter data to composite valid data\n self.valid_data[0, :] = np.all(self.valid_data[1:, :], 0)\n self.num_invalid = np.sum(self.valid_data[0, :] == False)","def get_pdistance(distances, leaves, stat='mean'):\n counts = 0\n pdistance = 0\n for i in range(0, len(leaves)-1):\n for j in range(i+1, len(leaves)):\n name = \"\".join([leaves[i], leaves[j]])\n if stat == 'mean':\n pdistance = pdistance + distances[name]\n counts = counts + 1\n elif stat == 'max':\n if (distances[name] > pdistance):\n pdistance = distances[name]\n\n if (stat == 'mean'):\n pdistance = pdistance / counts\n return pdistance","def distance(self, other_pt, is_lla=True):\n return 0.0","def get_distance(start, end):\n\n\t\tloc_start, loc_end, dst_node = create_distance(start, end)\n\t\tdistance = cmds.getAttr(\"%s.distance\" % dst_node)\n\n\t\tcmds.delete([loc_start, loc_end, dst_node])\n\n\t\treturn distance","def distance(self):\n return Distance(length_of(self.position.au))","def predict_qth(self):\n return (self.latitude, -self.longitude, self.altitude)","def calculate_longitude(prior_lat, source_long, distance, heading):\n\n return ((source_long - \\\n math.asin(math.sin(heading)*math.sin(distance)/math.cos(prior_lat))\n + math.pi) % (2*math.pi)) - math.pi","def distance_to_current_waypoint(self):\n next_waypoint = self.vehicle.commands.next\n if next_waypoint == 1:\n return None\n mission_item = self.vehicle.commands[next_waypoint]\n lat = mission_item.x\n lon = mission_item.y\n alt = mission_item.z\n waypoint_location = Location(lat, lon, alt, is_relative=True)\n distance = get_distance_meters(self.vehicle.location, waypoint_location)\n return distance","def lat_lng_approximation(homes, destination, lat_lng_dest, average_speed):\n\n for home in homes:\n # Stores the lat and lng points for the home\n lat_lng_home = (home.home.latitude, home.home.longitude)\n\n # Returns the distance from the two lat lng points in miles\n distance = geopy.distance.geodesic(lat_lng_home, lat_lng_dest).miles\n\n # If the distance is less than a mile then don't add any distance since it is already so close\n if distance > 1:\n # Extra distance is determined by giving more distance to homes farther away\n extra_distance = EXTRA_DISTANCE_LAT_LNG_APPROX * (1 - 1.0/distance)\n # This normalizes the value since walking needs less of a weight than biking since homes\n # are more direct when walking.\n distance += extra_distance * average_speed/AVERAGE_BICYCLING_SPEED\n if average_speed is not 0:\n # If the speed is not zero (to prevent divide by zero, then add the commute time to\n # the home\n commute_time_hours = distance / average_speed\n commute_time = commute_time_hours * 60\n home.approx_commute_times[destination] = commute_time\n else:\n # If there was a divide by zero then just eliminate the home\n home.eliminate_home()","def test_get_distance() -> None:\n meters = location_util.distance(\n COORDINATES_PARIS[0],\n COORDINATES_PARIS[1],\n COORDINATES_NEW_YORK[0],\n COORDINATES_NEW_YORK[1],\n )\n\n assert meters / 1000 - DISTANCE_KM < 0.01","def distances(self):","def calculate_distance(x: float, y: float) -> float:\n # return geopy.distance.vincenty(x, y).km\n R = 6370\n lat1 = radians(x[0]) #insert value\n lon1 = radians(x[1])\n lat2 = radians(y[0])\n lon2 = radians(y[1])\n\n dlon = lon2 - lon1\n dlat = lat2- lat1\n\n a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2\n c = 2 * atan2(sqrt(a), sqrt(1-a))\n distance = R * c\n return distance","def altitude_to_pressure(alt):\n for i in range(len(_heights)-1,0,-1):\n h0 = _heights[i]\n T0 = _basetemps[i]\n if alt > h0:\n if _isotherm[i]:\n rP = math.exp(-_g / _R / T0 * (alt - h0))\n else:\n l0 = _lapsert[i]\n rP = math.pow(1 + (alt - h0) * l0 / T0, -_g / _R / l0)\n return _basepress[i] * rP\n l0 = _lapsert[0]\n return _stdpres * math.pow(1 + alt * l0 / _stdtemp, -_g / _R / l0)","def get_location_meters(original_location, north, east, alt=0):\n # Radius of \"spherical\" earth\n earth_radius = 6378137.0\n # Coordinate offsets in radians\n lat = north / earth_radius\n lon = east / (earth_radius * math.cos(original_location.lat * math.pi/180))\n\n # New position in decimal degrees\n newlat = original_location.lat + (lat * 180/math.pi)\n newlon = original_location.lon + (lon * 180/math.pi)\n return Location(newlat, newlon, original_location.alt + alt, original_location.is_relative)","def distance(acceleration_linX, acceleration_linY, acceleration_linZ, deltat):\n acceleration_linX = abs(acceleration_linX)\n if -0.05 <= acceleration_linX <= 0.05:\n acceleration_linX = 0.0\n velocityX = integrations.getVelocityX(acceleration_linX, deltat)\n else:\n velocityX = integrations.getVelocityX(acceleration_linX, deltat)\n\n positionX, distanceX = integrations.getPositionX(\n velocityX, acceleration_linX, deltat)\n return positionX, distanceX # , positionY, positionZ","def manhatam_distance(self) -> int:\n raise NotImplementedError","def metric(self, eles):\n point = eles.pop()\n dist = edist(point, self.soln)\n return dist","def haversine_distance(df, lat1, long1, lat2, long2):\n r = 6371 # average radius of Earth in kilometers\n phi1 = np.radians(df[lat1])\n phi2 = np.radians(df[lat2])\n\n delta_phi = np.radians(df[lat2] - df[lat1])\n delta_lamda = np.radians(df[long2] - df[long1])\n\n a = np.sin(delta_phi/2) ** 2 + np.cos(phi1) * np.cos(phi2) * \\\n np.sin(delta_lamda / 2) * np.sin(delta_lamda / 2)\n c = 2 * np.arctan2(np.sqrt(a), np.sqrt(1 - a))\n d = (r * c) # in kilometers\n\n return d"],"string":"[\n \"def altitude_profile(self, alt):\\n # checking if the units entered are km\\n if alt.unit == u.km:\\n if 150 <= alt.value < 500:\\n alt_properties = self._altitude_profile(500)\\n else:\\n alt_properties = self._altitude_profile(alt.value)\\n\\n return [last[int(alt.value)] for last in alt_properties]\",\n \"def getAltitudeProfile(pass_length,terrain,uav_altitude,u,start_v,wind_angle):\\n altitude_profile = []\\n v = start_v\\n for k in range(0,round(pass_length)):\\n coord = convertCoords([[u,v]],wind_angle,'xy')\\n x = coord[0][0]\\n y = coord[0][1]\\n x_points = [int(x),int(x),int(x)+1,int(x)+1]\\n y_points = [int(y),int(y)+1,int(y)+1,int(y)]\\n z_points = [terrain[int(y)][int(x)],terrain[int(y)+1][int(x)],\\n terrain[int(y)+1][int(x)+1],terrain[int(y)][int(x)+1]]\\n\\n # For created terrain ONLY\\n z = griddata((x_points,y_points),z_points,(x,y)) # Interpolate \\n altitude = z + uav_altitude\\n\\n altitude_profile.append(altitude)\\n v +=1\\n return altitude_profile\",\n \"def closest_cruising_altitude(altitude):\\n return 1000 * ((altitude + 500) // 1000)\",\n \"def altitude(self):\\n if self.__altitude:\\n return sum(self.__altitude) / len(self.__altitude)\\n else:\\n return -9999\",\n \"def get_air_density(self, altitude):\\n\\n altitude /= 1000 # convert to kilometers\\n\\n return self.get_air_density_from_model(altitude)\",\n \"def topographic_altitude(self, lat_d, lon_d):\\n return self.altitude(lat_d, lon_d)\",\n \"def topographic_altitude(self, lat_d, lon_d):\\n return self.altitude(lat_d, lon_d)\",\n \"def get_altitude(points):\\n altitudes = np.zeros((len(points),), dtype=\\\"float64\\\")\\n for i, point in tqdm(enumerate(points), desc=\\\"GETTING ALTITUDE\\\"):\\n p = Point(point[0], point[1])\\n altitudes[i] = alt.NM_COTA.iloc[\\n np.argmin([p.distance(alt.geometry.iloc[j]) for j in range(alt.shape[0])])\\n ]\\n return altitudes\",\n \"def altitude(self) -> int:\\n return self._point.altitude\",\n \"def get_altitude(self):\\n return self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_GET_ALTITUDE, (), '', 'i')\",\n \"def get_altitude(self):\\n self.degrees = self.altitude_encoder.get_degrees()\\n self.tele_altitude = self.Calculations.convert_degrees( self.degrees)\\n return self.tele_altitude\",\n \"def topographic_altitude(lat, lon):\\n global __model\\n type_output = type(lat)\\n lat = prepare_input_array(lat)\\n lon = prepare_input_array(lon)\\n lon = np.mod(lon, 360)\\n val = __model.topographic_altitude(lat, lon)\\n val = np.maximum(val, 1e-7)\\n return prepare_output_array(val, type_output) * u.km\",\n \"def get_ground_distances(self):\\n return np.array([self.get_distance(name) for name in self.ground_distance_sensors])\",\n \"def getAltitudeAngle(self):\\n return self._altitude\",\n \"def set_altitude(self):\\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\\n print('altitude set to', self.altitude)\\n if self.altitude < 0:\\n self.altitude = self.altitude + 360.0\\n return self.altitude \\n else: \\n pass\\n return self.altitude\",\n \"def altitude_range(self, start_distance, finish_distance):\\n start_index, start_ratio = calculate_value_reference(self.distances,\\n start_distance)\\n start_alt = calculate_value(self.altitudes, start_index, start_ratio)\\n finish_index, finish_ratio = calculate_value_reference(self.distances,\\n finish_distance)\\n finish_alt = calculate_value(self.altitudes, finish_index, finish_ratio)\\n\\n min_alt = min(start_alt, finish_alt)\\n max_alt = max(start_alt, finish_alt)\\n\\n if start_index < finish_index:\\n altitudes = self.altitudes[start_index + 1: finish_index + 1]\\n min_alt = min(min_alt, altitudes.min())\\n max_alt = max(max_alt, altitudes.max())\\n\\n return min_alt, max_alt\",\n \"def get_user_sector_altitude_range(db_id):\\n found, sector = user_sector_finder(\\\"id\\\", int(db_id))\\n if found:\\n return (sector[0]['min_altitude'], sector[0]['max_altitude'])\\n else:\\n raise NotFoundException(db_id, \\\"User sector not found.\\\")\",\n \"def altitude(self):\\r\\n pressure = self.pressure # in Si units for hPascal\\r\\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))\",\n \"def get_location_offset_meters(self, dNorth, dEast, alt):\\n earth_radius=6378137.0 #Radius of \\\"spherical\\\" earth\\n #Coordinate offsets in radians\\n dLat = dNorth/earth_radius\\n dLon = dEast/(earth_radius*math.cos(math.pi*self.home.lat/180))\\n\\n #New position in decimal degrees\\n newlat = self.home.lat + (dLat * 180/math.pi)\\n newlon = self.home.lon + (dLon * 180/math.pi)\\n return LocationGlobal(newlat, newlon,self.home.alt+alt)\",\n \"def _get_points(self, user: User, elevation: float, distance: float, pace: time) -> int:\\n if _get_user_sex(user) == Sex.Female:\\n return ceil((distance * (1 + self._get_elevation(elevation,\\n distance)) * self._FEMALE_COEFFICIENT) * _get_pace_percentage(\\n pace))\\n\\n return ceil(\\n (distance * (1 + self._get_elevation(elevation, distance)) * self._MALE_COEFFICIENT) * _get_pace_percentage(\\n pace))\",\n \"def distance(self, lat: float, long: float) -> float:\\n # Initial euclidian formula below\\n # diff_lat = self.lat - lat\\n # diff_long = self.long - long\\n # euclidian = math.sqrt((diff_lat ** 2 + diff_long ** 2 + self.altitude ** 2))\\n\\n return self._haversine(lat, long) + self.altitude / 1000\",\n \"def offset_to_altaz(xoff, yoff, azimuth, altitude):\\n #Deal with situations where offset = 0?\\n\\n d = sqrt(xoff*xoff+yoff*yoff)\\n pos = np.where(d==0)\\n d=1e-12 * u.deg # add a very small offset to prevent math errors\\n\\n q = arctan(d.to(u.rad).value)\\n\\n sq = sin(q)\\n xp1 = xoff * (sq/d)\\n yp1 = yoff * (sq/d)\\n zp1 = cos(q)\\n\\n cx = sin(altitude)\\n sx = cos(altitude)\\n\\n xp0 = cx*xp1 - sx*zp1\\n yp0 = yp1\\n zp0 = sx*xp1 + cx*zp1\\n\\n obj_altitude = arcsin(zp0)\\n obj_altitude[pos]=altitude\\n obj_azimuth = arctan2(yp0,-xp0) + azimuth\\n obj_azimuth[pos] = azimuth\\n\\n #if obj_azimuth.value < 0.:\\n # obj_azimuth += 2.*pi\\n #elif obj_azimuth.value >= (2.*pi ):\\n # obj_azimuth -= 2.*pi\\n\\n return obj_altitude,obj_azimuth\",\n \"def altitude_speed(self, degrees = True):\\n return self.angularSpeed(self.future_location.al, self.old_location.al)\",\n \"def haversine_distance_ignore_altitude(loc1_lat, loc1_lon, loc2_lat, loc2_lon):\\n R = 6372797.560856 # radius of the earth in meters\\n\\n lat_arc = math.radians(loc1_lat - loc2_lat)\\n lon_arc = math.radians(loc1_lon - loc2_lon)\\n\\n lat_h = math.sin(lat_arc * 0.5)\\n lat_h = lat_h * lat_h\\n\\n lon_h = math.sin(lon_arc * 0.5)\\n lon_h = lon_h * lon_h\\n\\n tmp = math.cos(math.radians(loc1_lat)) * math.cos(math.radians(loc2_lat))\\n rad = 2.0 * math.asin(math.sqrt(lat_h + tmp * lon_h))\\n\\n return rad * R\",\n \"def distanceTo(self, other):\\n return math.hypot(abs(self.altitude_msl - other.altitude_msl),\\n self.gps_position.distanceTo(other.gps_position))\",\n \"def _get_elevation_percentage(height: float, distance: float) -> float:\\n return height / (distance * 1000)\",\n \"def air_density(altitude):\\n p = pressure(altitude) # psf\\n t = temperature(altitude) # R\\n rho = p/(gas_constant*t) # lb/ft3\\n return rho\",\n \"def get_altitude(self, degrees=True):\\n if degrees:\\n return math.degrees(self.current_location.al)\\n else:\\n return self.current_location.al\",\n \"def altaz_to_offset(obj_azimuth,obj_altitude,azimuth,altitude):\\n\\n daz = obj_azimuth - azimuth\\n coa = cos(obj_altitude)\\n\\n xp0 = -cos(daz) * coa\\n yp0 = sin(daz) * coa\\n zp0 = sin(obj_altitude)\\n\\n cx = sin(altitude)\\n sx = cos(altitude)\\n\\n xp1 = cx*xp0 + sx*zp0\\n yp1 = yp0\\n zp1 = -sx*xp0 + cx*zp0\\n\\n q = arccos(zp1)\\n d = tan(q)\\n alpha = arctan2(yp1,xp1)\\n\\n xoff = d * cos(alpha)\\n yoff = d * sin(alpha)\\n\\n return xoff,yoff\",\n \"def sim_altitude(a):\\n a.takeoff()\\n for i in range(20):\\n b = a.refresh()\\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() + 3)\\n print a.altitude.get_altitudes(), b\\n a.land()\\n a.motor.set_speed(2000.0)\\n for i in range(20):\\n b = a.refresh()\\n a.altitude.set_sensor_altitude_current(a.altitude.get_altitude_current() - 3)\\n print a.altitude.get_altitudes(), b\",\n \"def _euclidian_distances(stop_list):\\n e_dists2 = [transitfeed.approximate_distance_between_stops(stop, tail) for\\n (stop, tail) in zip(stop_list, stop_list[1:])]\\n\\n return e_dists2\",\n \"def _calculate_distance(self, passenger, driver):\\n londriver, latdriver = driver['lon'], driver['lat']\\n lonpassenger, latpassenger = passenger['lon'], passenger['lat']\\n lon_p, lat_p, lon_d, lat_d = map(radians,\\n [float(lonpassenger), float(latpassenger), float(londriver), float(latdriver)])\\n lon_distance = lon_d - lon_p\\n lat_distance = lat_d - lat_p\\n a = sin(lat_distance / 2) ** 2 + cos(lat_p) * cos(lat_d) * sin(lon_distance / 2) ** 2\\n c = 2 * asin(sqrt(a))\\n km = 6367 * c\\n return km\",\n \"def _calculate_distance(self, passenger, driver):\\n londriver, latdriver = driver['lon'], driver['lat']\\n lonpassenger, latpassenger = passenger['lon'], passenger['lat']\\n lon_p, lat_p, lon_d, lat_d = map(radians,\\n [float(lonpassenger), float(latpassenger), float(londriver), float(latdriver)])\\n lon_distance = lon_d - lon_p\\n lat_distance = lat_d - lat_p\\n a = sin(lat_distance / 2) ** 2 + cos(lat_p) * cos(lat_d) * sin(lon_distance / 2) ** 2\\n c = 2 * asin(sqrt(a))\\n km = 6367 * c\\n return km\",\n \"def __calculate_average_distance(self):\\n game = self.__game # type: Game\\n all_icebergs = game.get_all_icebergs()\\n all_icebergs_length = len(all_icebergs)\\n sum_distances = 0\\n for i in range(all_icebergs_length):\\n for j in range(i + 1, all_icebergs_length):\\n iceberg1 = all_icebergs[i]\\n iceberg2 = all_icebergs[j]\\n sum_distances += iceberg1.get_turns_till_arrival(iceberg2)\\n\\n return sum_distances / (all_icebergs_length * (all_icebergs_length - 1) / 2)\",\n \"def calculate_vars(data, lat, lon):\\n # Keep track of running distance and time calculations\\n distance_to_dest = 0.0\\n time_estimate = 0.0\\n\\n # Calculate from starting dest to first point in data\\n user_coords = (lat, lon)\\n first_path_coords = (data[0][\\\"lat\\\"], data[0][\\\"lon\\\"])\\n first_distance = geopy.distance.distance(user_coords, first_path_coords).miles\\n distance_to_dest += first_distance\\n time_estimate += first_distance * 20 # 3mph walking speed\\n\\n # Calculate for all other points\\n for i in range(1, len(data) - 1):\\n this_coords = (data[i][\\\"lat\\\"], data[i][\\\"lon\\\"])\\n next_coords = (data[i + 1][\\\"lat\\\"], data[i + 1][\\\"lon\\\"])\\n\\n distance = geopy.distance.distance(this_coords, next_coords).miles\\n distance_to_dest += distance\\n time_estimate += distance * 20 # 3mph walking speed\\n\\n # Round distance and time estimates\\n distance_to_dest = round(distance_to_dest, 1)\\n time_estimate = round(time_estimate)\\n\\n return distance_to_dest, time_estimate\",\n \"def elevation(self):\\n return self.altitude - self.heightAboveGround\",\n \"def getAltitudeFromLatLon(self, lat, lon):\\r\\n # print \\\"-----\\\\nFromLatLon\\\", lon, lat\\r\\n lat -= self.lat\\r\\n lon -= self.lon\\r\\n # print \\\"lon, lat\\\", lon, lat\\r\\n if lat < 0.0 or lat >= 1.0 or lon < 0.0 or lon >= 1.0:\\r\\n raise WrongTileError(self.lat, self.lon, self.lat+lat, self.lon+lon)\\r\\n x = lon * (self.size - 1)\\r\\n y = lat * (self.size - 1)\\r\\n # print \\\"x,y\\\", x, y\\r\\n x_int = int(x)\\r\\n x_frac = x - int(x)\\r\\n y_int = int(y)\\r\\n y_frac = y - int(y)\\r\\n # print \\\"frac\\\", x_int, x_frac, y_int, y_frac\\r\\n value00 = self.getPixelValue(x_int, y_int)\\r\\n value10 = self.getPixelValue(x_int+1, y_int)\\r\\n value01 = self.getPixelValue(x_int, y_int+1)\\r\\n value11 = self.getPixelValue(x_int+1, y_int+1)\\r\\n value1 = self._avg(value00, value10, x_frac)\\r\\n value2 = self._avg(value01, value11, x_frac)\\r\\n value = self._avg(value1, value2, y_frac)\\r\\n # print \\\"%4d %4d | %4d\\\\n%4d %4d | %4d\\\\n-------------\\\\n%4d\\\" % (\\r\\n # value00, value10, value1, value01, value11, value2, value)\\r\\n return value\",\n \"def calculate_distance(pitch):\\n # TODO: Use actual values calculated\\n target_height = 60\\n camera_height = 40\\n height_difference = target_height - camera_height\\n distance = math.fabs(height_difference / math.tan(math.radians(pitch)))\\n\\n return distance\",\n \"def create_altitude_profile(self, max_altitude=32, exponential_constant=0.05, ground_altitude=6, timespan=30,\\n timestep=1 / 60):\\n x_time = np.arange(0, timespan, timestep)\\n y_target_profile = max_altitude * np.exp(-exponential_constant * x_time) + ground_altitude\\n return x_time, y_target_profile\",\n \"def calc_distance(self, observation):\\n actual_obs = observation[0]\\n scrn_player = actual_obs.observation.feature_screen.player_relative\\n scrn_select = actual_obs.observation.feature_screen.selected\\n scrn_density = actual_obs.observation.feature_screen.unit_density\\n\\n state_added = scrn_select + scrn_density\\n\\n marine_center = np.mean(self.xy_locs(scrn_player == 1), axis=0).round()\\n\\n # first step\\n if np.sum(scrn_select) == 0:\\n marine_center = np.mean(self.xy_locs(scrn_player == 1), axis=0).round()\\n # marine behind beacon\\n if isinstance(marine_center, float):\\n marine_center = np.mean(self.xy_locs(state_added == 2), axis=0).round()\\n else:\\n # normal navigation\\n marine_center = np.mean(self.xy_locs(state_added == 2), axis=0).round()\\n if isinstance(marine_center, float):\\n marine_center = np.mean(self.xy_locs(state_added == 3), axis=0).round()\\n\\n beacon_center = np.mean(self.xy_locs(scrn_player == 3), axis=0).round()\\n #\\n # print(state_added)\\n # print(\\\"---- Marine {} | {} Beacon ----\\\".format(marine_center, beacon_center))\\n # time.sleep(0.2)\\n distance = math.hypot(beacon_center[0] - marine_center[0],\\n beacon_center[1] - marine_center[1])\\n\\n return beacon_center, marine_center, distance\",\n \"def test_triangle_get_longest_altitude(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_longest_altitude(), 9.428090415820634)\",\n \"def get_elementary_airspace_altitude_range(db_id):\\n connection = get_geo_db_connection()\\n sector = find_sector(db_id, connection)\\n if (sector):\\n return (sector['min_altitude'], sector['max_altitude'])\\n else:\\n raise NotFoundException(db_id, \\\"Elementary sector not found.\\\")\",\n \"def altitude_control(self, altitude_cmd,\\n vertical_velocity_cmd,\\n altitude,\\n vertical_velocity,\\n attitude,\\n acceleration_ff=0.0):\\n \\n hdot_cmd = self.Kp_alt * (altitude_cmd - altitude) + vertical_velocity_cmd\\n \\n # Limit the ascent/descent rate\\n hdot_cmd = np.clip(hdot_cmd, -self.max_descent_rate, self.max_ascent_rate)\\n\\n acceleration_cmd = acceleration_ff + self.Kp_hdot*(hdot_cmd - vertical_velocity)\\n \\n R33 = np.cos(attitude[0]) * np.cos(attitude[1])\\n thrust = DRONE_MASS_KG * acceleration_cmd / R33\\n \\n if thrust > MAX_THRUST:\\n thrust = MAX_THRUST\\n elif thrust < 0.0:\\n thrust = 0.0\\n return thrust\",\n \"def test_triangle_get_shortest_altitude(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_shortest_altitude(), 7.713892158398701)\",\n \"def ecef2LatLonAlt(x, y, z):\\n\\n # Calculate the polar eccentricity\\n ep = np.sqrt((EARTH.EQUATORIAL_RADIUS**2 - EARTH.POLAR_RADIUS**2)/(EARTH.POLAR_RADIUS**2))\\n\\n # Calculate the longitude\\n lon = np.arctan2(y, x)\\n\\n p = np.sqrt(x**2 + y**2)\\n\\n theta = np.arctan2( z*EARTH.EQUATORIAL_RADIUS, p*EARTH.POLAR_RADIUS)\\n\\n # Calculate the latitude\\n lat = np.arctan2(z + (ep**2)*EARTH.POLAR_RADIUS*np.sin(theta)**3, \\\\\\n p - (EARTH.E**2)*EARTH.EQUATORIAL_RADIUS*np.cos(theta)**3)\\n\\n # Get distance from Earth centre to the position given by geographical coordinates, in WGS84\\n N = EARTH.EQUATORIAL_RADIUS/math.sqrt(1.0 - (EARTH.E**2)*math.sin(lat)**2)\\n\\n \\n # Calculate the height in meters\\n\\n # Correct for numerical instability in altitude near exact poles (and make sure cos(lat) is not 0!)\\n if((np.abs(x) < 1000) and (np.abs(y) < 1000)):\\n alt = np.abs(z) - EARTH.POLAR_RADIUS\\n\\n else:\\n # Calculate altitude anywhere else\\n alt = p/np.cos(lat) - N\\n\\n\\n return lat, lon, alt\",\n \"def get_distance_between_point(test_long, test_lat, lab_long, lab_lat):\\r\\n test = (test_lat, test_long)\\r\\n lab = (lab_lat, lab_long)\\r\\n return geodesic(test, lab).miles\",\n \"def haversine_distance(loc1_lat, loc1_lon, loc1_alt, loc2_lat, loc2_lon, loc2_alt):\\n R = 6372797.560856 # radius of the earth in meters\\n R = R + loc2_alt - loc1_alt\\n\\n lat_arc = math.radians(loc1_lat - loc2_lat)\\n lon_arc = math.radians(loc1_lon - loc2_lon)\\n\\n lat_h = math.sin(lat_arc * 0.5)\\n lat_h = lat_h * lat_h\\n\\n lon_h = math.sin(lon_arc * 0.5)\\n lon_h = lon_h * lon_h\\n\\n tmp = math.cos(math.radians(loc1_lat)) * math.cos(math.radians(loc2_lat))\\n rad = 2.0 * math.asin(math.sqrt(lat_h + tmp * lon_h))\\n\\n return rad * R\",\n \"def altitude(press, altimeter=29.92126):\\n AS = altimeter*inHg2PA\\n print(AS, press**(L*R/g/M))\\n h = -(press**(L*R/g/M) - AS**(L*R/g/M))*T0/L/(P0**(L*R/g/M))\\n return h/ft2m\",\n \"def add_altitude():\\n\\n doc = Metashape.app.document\\n if not len(doc.chunks):\\n raise Exception(\\\"No chunks!\\\")\\n\\n # alt = Metashape.app.getFloat(\\\"Please specify the height to be added:\\\", 100)\\n alt = float(sys.argv[1])\\n\\n\\n chunk = doc.chunk\\n\\n for camera in chunk.cameras:\\n if camera.reference.location:\\n coord = camera.reference.location\\n camera.reference.location = Metashape.Vector([coord.x, coord.y, coord.z + alt])\\n print(\\\"Add : \\\"+str(sys.argv[1]))\",\n \"def _plunge_distance(self, volume):\\n percent = self._volume_percentage(volume)\\n top = self._get_plunger_position('top')\\n bottom = self._get_plunger_position('bottom')\\n travel = bottom - top\\n if travel <= 0:\\n self.robot.add_warning('Plunger calibrated incorrectly')\\n return travel * percent\",\n \"def classify_altitude_profile(altitudes):\\n max_alt = altitudes.max()\\n has_climb = (max_alt > altitudes[0])\\n has_descent = (max_alt > altitudes[-1])\\n\\n if has_climb or has_descent:\\n if has_climb != has_descent:\\n return AltitudeProfileType.CLIMBING if has_climb \\\\\\n else AltitudeProfileType.DESCENDING\\n else:\\n return AltitudeProfileType.CLIMBING_AND_DESCENDING\\n else:\\n return AltitudeProfileType.CRUISING\",\n \"def pressure_to_altitude(pres):\\n for i in range(len(_heights)-1,0,-1):\\n P0 = _basepress[i]\\n T0 = _basetemps[i]\\n if pres < P0:\\n if _isotherm[i]:\\n dh = _R * T0 / _g * math.log(P0 / pres)\\n else:\\n l0 = _lapsert[i]\\n dh = T0 / l0 * (math.pow(pres / P0, -l0 * _R / _g) - 1)\\n return _heights[i] + dh\\n l0 = _lapsert[0]\\n return _stdtemp / l0 * (math.pow(pres / _stdpres, -l0 * _R / _g) - 1)\",\n \"def get_distance_metres(aLocation1, aLocation2):\\n [dNorth, dEast, dDown] = get_position_error(aLocation1, aLocation2)\\n \\n return math.sqrt((dNorth*dNorth) + (dEast*dEast))\",\n \"def temperature(altitude):\\n if altitude <= 36152:\\n t = 59-0.00356*altitude # deg F\\n else:\\n t = -70 # deg F\\n t = t + 459.7 # R\\n return t\",\n \"def getDistance(angle):\\n\\n panTilt.pan(angle)\\n time.sleep(DELAY)\\n wallDistance = getWallDistance()\\n edgeDistance = getEdgeDistance() if wallDistance is None else None\\n\\n return wallDistance, edgeDistance\",\n \"def get_distance(self) -> int:\\n return self.get_measurement_data().distance\",\n \"def calculate_distance(srcLong, srcLat, dstLong, dstLat):\\n return math.sqrt( (srcLong-dstLong) ** 2 + (srcLat - dstLat) ** 2)\",\n \"def get_distance(restuarant, user):\\n lat1 = math.radians(restuarant[1])\\n lon1 = math.radians(restuarant[0])\\n lat2 = math.radians(user[1])\\n lon2 = math.radians(user[0])\\n dlon = lon1 - lon2\\n dlat = lat1 - lat2\\n a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * \\\\\\n math.cos(lat2) * math.sin(dlon / 2) ** 2\\n dist = 2 * math.asin(math.sqrt(a))*6371\\n return dist\",\n \"def diff_of_errors(self):\\n self.e_of_e = self.azimuth_error - self.altitude_error\\n return self.e_of_e\",\n \"def _get_distance(self, target): \\r\\n sensor_transform = self._sensors['rgb_front'].get_transform()\\r\\n\\r\\n distance = np.sqrt(\\r\\n (sensor_transform.location.x - target.x) ** 2 +\\r\\n (sensor_transform.location.y - target.y) ** 2 +\\r\\n (sensor_transform.location.z - target.z) ** 2)\\r\\n\\r\\n return distance\",\n \"def getSlantRangeElevationHeight(self, groundRange, z):\\r\\n \\r\\n lat = self.ctrLat * pi / 180.0\\r\\n \\r\\n #figure out earth's radius at radar's lat ... non-spherical earth model\\r\\n e2 = self.eccen # First eccentricity squared - WGS-84 value = 0.00669437999013\\r\\n a = self.Requator # Equatorial radius - WGS-84 value = 6378137.0\\r\\n Rearth = a/sqrt(1-e2*(sin(lat))**2) # radius of curvature\\r\\n \\r\\n Rprime = self.effectiveRadiusMultiplier * self.Requator\\r\\n \\r\\n h = array(z - self.ctrAlt, dtype='float64')\\r\\n s = array(groundRange, dtype='float64')\\r\\n \\r\\n # Use law of cosines (Side-Angle-Side triangle theorem) with \\r\\n # R', R'+h as sides and s/R' as the angle to get slant range\\r\\n r = sqrt(Rprime**2.0 + (Rprime+h)**2.0 - 2*(Rprime+h)*Rprime*cos(s/Rprime))\\r\\n # Inverse of eq. 2.28c in Doviak and Zrnic 1993\\r\\n # Will return NaN for r=0\\r\\n el = arccos((Rprime+h) * sin(s/Rprime) / r) \\r\\n el *= 180.0 / pi\\r\\n \\r\\n return r, el\",\n \"def comparable_dist(zamg_id):\\n station_lat, station_lon = stations[zamg_id]\\n return (lat - station_lat) ** 2 + (lon - station_lon) ** 2\",\n \"def read_altitude(self, meanSeaLevelPressureInBar):\\n phPa = self.read_pressure() / 100.0\\n\\n return float(44330.0 * (1.0 - math.pow((phPa / meanSeaLevelPressureInBar), 0.1903)))\",\n \"def read_altitude(self, meanSeaLevelPressureInBar):\\n phPa = self.read_pressure() / 100.0\\n\\n return float(44330.0 * (1.0 - math.pow((phPa / meanSeaLevelPressureInBar), 0.1903)))\",\n \"def calculate_zoom(self):\\n distances = [geopy.distance.geodesic(self.centre_location, centroid).km for centroid in self.centroids]\\n a = 4 / 20000\\n distances = [1 + 4 - a * distance for distance in distances]\\n print(min(distances))\\n return min(distances)\",\n \"def _get_admin_distance(self):\\n return self.__admin_distance\",\n \"def point_distances(self, params=None):\\n if params is None:\\n params = self.collocation_points()\\n with self.fix_evaluator():\\n pts = np.array([self(la) for la in params])\\n deltas = np.diff(pts, axis=0)\\n distances = norm(deltas, axis=1)\\n return distances\",\n \"def altitude(self, value: int):\\n self._point.altitude = value\",\n \"def setTargetAltitude(altitude):\\n return RoboCaller().call(\\\"setTargetAltitude\\\", \\\"void\\\", altitude)\",\n \"def get_distance_meters(aLocation1, aLocation2):\\n dlat = aLocation2.lat - aLocation1.lat\\n dlong = aLocation2.lon - aLocation1.lon\\n return math.sqrt((dlat*dlat) + (dlong*dlong)) * 1.113195e5\",\n \"def _getDistance(self, source, dest):\\n\\n lat1 = source[0]\\n lat2 = dest[0]\\n lon1 = source[1]\\n lon2 = dest[1]\\n\\n # Formula from https://www.movable-type.co.uk/scripts/latlong.html\\n R = 6370000\\n phi1 = math.radians(lat1)\\n phi2 = math.radians(lat2)\\n deltaPhi = math.radians(lat2-lat1)\\n deltalmb = math.radians(lon2-lon1)\\n a = math.sin(deltaPhi/2) * math.sin(deltaPhi/2) + \\\\\\n math.cos(phi1) * math.cos(phi2) * \\\\\\n math.sin(deltalmb/2) * math.sin(deltalmb/2)\\n c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a));\\n d = (R * c)/1000.\\n\\n return d\",\n \"def euclidean_distance(self):\\n return sqrt(pow((self.goal_pose.x - self.ground_truth_pose.x), 2) +\\n pow((self.goal_pose.y - self.ground_truth_pose.y), 2))\",\n \"def get_distances_from_center(center_coordinates, p_coordinates):\\n \\n center_y, center_x = center_coordinates\\n p_y, p_x = p_coordinates\\n return (p_y - center_y)**2 + (p_x - center_x)**2\",\n \"def density(self, alt):\\n (Z, T, CN2, CO2, CO, CAr, CHe, CH, CM, WM) = self.altitude_profile(alt)\\n\\n # using eqn(42) of COESA for multiple gases\\n M_i = [wmN2, wmO2, wmO, wmAr, wmHe, wmH] << (u.g / u.mol)\\n n_i = [\\n CN2.to_value(u.m**-3),\\n CO2.to_value(u.m**-3),\\n CO.to_value(u.m**-3),\\n CAr.to_value(u.m**-3),\\n CHe.to_value(u.m**-3),\\n CH.to_value(u.m**-3),\\n ] << (1 / u.m**3)\\n rho = (n_i @ M_i) / Na\\n return rho.to(u.kg / u.m**3)\",\n \"def _get_dst(self, df_train, df_test):\\n #train NearestNeighbors(Unsupervised learner)\\n neigh = NearestNeighbors(1)\\n neigh.fit(df_train[['longitude', 'latitude']])\\n #find the K-neighbors of points in df_test\\n distances, indices = neigh.kneighbors(df_test[['longitude', 'latitude']])\\n return distances\",\n \"def _calc_distance_features(self):\\n d = ()\\n for dx, dy in DIRECTIONS:\\n if dx and dy:\\n d += (list(self.__calc_distance(direction_x=dx, direction_y=dy)), )\\n elif dx:\\n tmp, _, _ = self.__calc_distance(direction_x=dx, direction_y=dy)\\n d += (tmp, )\\n elif dy:\\n _, tmp, _ = self.__calc_distance(direction_x=dx, direction_y=dy)\\n d += (tmp, )\\n\\n self.dist_features = d\\n\\n self.direc_dist = self.__calc_direc_distance()\",\n \"def get_distances(self):\\n return DistanceSensors(*self.bot_client.send_command(_Command.GetDistances))\",\n \"def get(cls, approach):\\n return approach.distance\",\n \"def getAltitudeReadings():\\n return RoboCaller().call(\\\"getAltitudeReadings\\\", \\\"int\\\")\",\n \"def find_distance(start, end, transit_mode=None):\\n dis_url = build_url(start, end, transit_mode)[1]\\n print(dis_url)\\n json_response = json.loads(urllib.request.urlopen(dis_url).read().decode('utf-8'))\\n travel_info = json_response[rows_key][0][elements_key][0]\\n distance = travel_info[distance_key][text_key]\\n if duration_key in json_response:\\n duration = travel_info[duration_traf_key][text_key]\\n else:\\n duration = travel_info[duration_key][text_key]\\n cost = None\\n if fare_key in travel_info:\\n cost = travel_info[fare_key]\\n return duration, distance, cost\",\n \"def getDist(lat1,long1,lat2,long2):\\n\\tlat1 = math.radians(lat1)\\n\\tlong1 = math.radians(long1)\\n\\tlat2 = math.radians(lat2)\\n\\tlong2 = math.radians(long2)\\n\\tR = 6371 # km\\n\\td = cmath.acos(cmath.sin(lat1) * cmath.sin(lat2) + \\\\\\n\\tcmath.cos(lat1) * cmath.cos(lat2) *\\n\\tcmath.cos(long2 - long1)) * R\\n\\treturn abs(d) # cast to float\",\n \"def distance_intermediate_formula(lat1, long1, lat2, long2):\\n return pow(sin(radians(col(lat1) - col(lat2)) / 2), 2) + (\\n pow(sin(radians(col(long1) - col(long2)) / 2), 2)\\n * cos(radians(col(lat1)))\\n * cos(radians(col(lat2)))\\n )\",\n \"def filter_altitude(self, gps_data, setting=None, threshold=None):\\n\\n # New filter settings if provided\\n if setting is not None:\\n self.gps_altitude_filter = setting\\n if setting == 'Manual':\\n self.gps_altitude_filter_change = threshold\\n\\n # Set threshold for Auto\\n if self.gps_altitude_filter == 'Auto':\\n self.gps_altitude_filter_change = 3\\n\\n # Set all data to valid\\n self.valid_data[3, :] = True\\n # self.valid_data[5, :] = True\\n\\n # Manual or Auto is selected, apply filter\\n if not self.gps_altitude_filter == 'Off':\\n # Initialize variables\\n num_valid_old = np.sum(self.valid_data[3, :])\\n k = 0\\n change = 1\\n # Loop until no change in the number of valid ensembles\\n while k < 100 and change > 0.1:\\n # Compute mean using valid ensembles\\n alt_mean = np.nanmean(gps_data.altitude_ens_m[self.valid_data[1, :]])\\n\\n # Compute difference for each ensemble\\n diff = np.abs(gps_data.altitude_ens_m - alt_mean)\\n\\n # Mark invalid those ensembles with differences greater than the change threshold\\n self.valid_data[3, diff > self.gps_altitude_filter_change] = False\\n k += 1\\n num_valid = np.sum(self.valid_data[3, :])\\n change = num_valid_old - num_valid\\n\\n # Combine all filter data to composite valid data\\n self.valid_data[0, :] = np.all(self.valid_data[1:, :], 0)\\n self.num_invalid = np.sum(self.valid_data[0, :] == False)\",\n \"def get_pdistance(distances, leaves, stat='mean'):\\n counts = 0\\n pdistance = 0\\n for i in range(0, len(leaves)-1):\\n for j in range(i+1, len(leaves)):\\n name = \\\"\\\".join([leaves[i], leaves[j]])\\n if stat == 'mean':\\n pdistance = pdistance + distances[name]\\n counts = counts + 1\\n elif stat == 'max':\\n if (distances[name] > pdistance):\\n pdistance = distances[name]\\n\\n if (stat == 'mean'):\\n pdistance = pdistance / counts\\n return pdistance\",\n \"def distance(self, other_pt, is_lla=True):\\n return 0.0\",\n \"def get_distance(start, end):\\n\\n\\t\\tloc_start, loc_end, dst_node = create_distance(start, end)\\n\\t\\tdistance = cmds.getAttr(\\\"%s.distance\\\" % dst_node)\\n\\n\\t\\tcmds.delete([loc_start, loc_end, dst_node])\\n\\n\\t\\treturn distance\",\n \"def distance(self):\\n return Distance(length_of(self.position.au))\",\n \"def predict_qth(self):\\n return (self.latitude, -self.longitude, self.altitude)\",\n \"def calculate_longitude(prior_lat, source_long, distance, heading):\\n\\n return ((source_long - \\\\\\n math.asin(math.sin(heading)*math.sin(distance)/math.cos(prior_lat))\\n + math.pi) % (2*math.pi)) - math.pi\",\n \"def distance_to_current_waypoint(self):\\n next_waypoint = self.vehicle.commands.next\\n if next_waypoint == 1:\\n return None\\n mission_item = self.vehicle.commands[next_waypoint]\\n lat = mission_item.x\\n lon = mission_item.y\\n alt = mission_item.z\\n waypoint_location = Location(lat, lon, alt, is_relative=True)\\n distance = get_distance_meters(self.vehicle.location, waypoint_location)\\n return distance\",\n \"def lat_lng_approximation(homes, destination, lat_lng_dest, average_speed):\\n\\n for home in homes:\\n # Stores the lat and lng points for the home\\n lat_lng_home = (home.home.latitude, home.home.longitude)\\n\\n # Returns the distance from the two lat lng points in miles\\n distance = geopy.distance.geodesic(lat_lng_home, lat_lng_dest).miles\\n\\n # If the distance is less than a mile then don't add any distance since it is already so close\\n if distance > 1:\\n # Extra distance is determined by giving more distance to homes farther away\\n extra_distance = EXTRA_DISTANCE_LAT_LNG_APPROX * (1 - 1.0/distance)\\n # This normalizes the value since walking needs less of a weight than biking since homes\\n # are more direct when walking.\\n distance += extra_distance * average_speed/AVERAGE_BICYCLING_SPEED\\n if average_speed is not 0:\\n # If the speed is not zero (to prevent divide by zero, then add the commute time to\\n # the home\\n commute_time_hours = distance / average_speed\\n commute_time = commute_time_hours * 60\\n home.approx_commute_times[destination] = commute_time\\n else:\\n # If there was a divide by zero then just eliminate the home\\n home.eliminate_home()\",\n \"def test_get_distance() -> None:\\n meters = location_util.distance(\\n COORDINATES_PARIS[0],\\n COORDINATES_PARIS[1],\\n COORDINATES_NEW_YORK[0],\\n COORDINATES_NEW_YORK[1],\\n )\\n\\n assert meters / 1000 - DISTANCE_KM < 0.01\",\n \"def distances(self):\",\n \"def calculate_distance(x: float, y: float) -> float:\\n # return geopy.distance.vincenty(x, y).km\\n R = 6370\\n lat1 = radians(x[0]) #insert value\\n lon1 = radians(x[1])\\n lat2 = radians(y[0])\\n lon2 = radians(y[1])\\n\\n dlon = lon2 - lon1\\n dlat = lat2- lat1\\n\\n a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2\\n c = 2 * atan2(sqrt(a), sqrt(1-a))\\n distance = R * c\\n return distance\",\n \"def altitude_to_pressure(alt):\\n for i in range(len(_heights)-1,0,-1):\\n h0 = _heights[i]\\n T0 = _basetemps[i]\\n if alt > h0:\\n if _isotherm[i]:\\n rP = math.exp(-_g / _R / T0 * (alt - h0))\\n else:\\n l0 = _lapsert[i]\\n rP = math.pow(1 + (alt - h0) * l0 / T0, -_g / _R / l0)\\n return _basepress[i] * rP\\n l0 = _lapsert[0]\\n return _stdpres * math.pow(1 + alt * l0 / _stdtemp, -_g / _R / l0)\",\n \"def get_location_meters(original_location, north, east, alt=0):\\n # Radius of \\\"spherical\\\" earth\\n earth_radius = 6378137.0\\n # Coordinate offsets in radians\\n lat = north / earth_radius\\n lon = east / (earth_radius * math.cos(original_location.lat * math.pi/180))\\n\\n # New position in decimal degrees\\n newlat = original_location.lat + (lat * 180/math.pi)\\n newlon = original_location.lon + (lon * 180/math.pi)\\n return Location(newlat, newlon, original_location.alt + alt, original_location.is_relative)\",\n \"def distance(acceleration_linX, acceleration_linY, acceleration_linZ, deltat):\\n acceleration_linX = abs(acceleration_linX)\\n if -0.05 <= acceleration_linX <= 0.05:\\n acceleration_linX = 0.0\\n velocityX = integrations.getVelocityX(acceleration_linX, deltat)\\n else:\\n velocityX = integrations.getVelocityX(acceleration_linX, deltat)\\n\\n positionX, distanceX = integrations.getPositionX(\\n velocityX, acceleration_linX, deltat)\\n return positionX, distanceX # , positionY, positionZ\",\n \"def manhatam_distance(self) -> int:\\n raise NotImplementedError\",\n \"def metric(self, eles):\\n point = eles.pop()\\n dist = edist(point, self.soln)\\n return dist\",\n \"def haversine_distance(df, lat1, long1, lat2, long2):\\n r = 6371 # average radius of Earth in kilometers\\n phi1 = np.radians(df[lat1])\\n phi2 = np.radians(df[lat2])\\n\\n delta_phi = np.radians(df[lat2] - df[lat1])\\n delta_lamda = np.radians(df[long2] - df[long1])\\n\\n a = np.sin(delta_phi/2) ** 2 + np.cos(phi1) * np.cos(phi2) * \\\\\\n np.sin(delta_lamda / 2) * np.sin(delta_lamda / 2)\\n c = 2 * np.arctan2(np.sqrt(a), np.sqrt(1 - a))\\n d = (r * c) # in kilometers\\n\\n return d\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69530743","0.65202653","0.6478382","0.6396903","0.639056","0.6178385","0.6178385","0.6144988","0.60816115","0.58620787","0.58369505","0.58215445","0.58118826","0.57391644","0.5735804","0.5733575","0.57045203","0.5664503","0.56433076","0.5625876","0.5607506","0.5582593","0.5574494","0.55618894","0.5556996","0.5548116","0.5545993","0.551127","0.5511045","0.5491174","0.5490307","0.54721534","0.54721534","0.54662","0.5447006","0.5434372","0.5410584","0.5409172","0.5408381","0.5403078","0.5379858","0.536897","0.5323173","0.5318024","0.5279386","0.5277172","0.52680093","0.52627623","0.52142686","0.5207172","0.5186061","0.51786953","0.5175208","0.5174657","0.5174197","0.51697326","0.5167767","0.5142288","0.51412874","0.51355165","0.5121447","0.5120317","0.5086932","0.5086932","0.50769424","0.5075061","0.5061361","0.5055459","0.50550544","0.5044154","0.5038759","0.5033986","0.5033495","0.50320715","0.5026256","0.5021534","0.5018618","0.5013712","0.5012262","0.50120157","0.5010144","0.5007305","0.50067997","0.50061715","0.50053847","0.50007844","0.49978232","0.49921507","0.49838975","0.49815592","0.49806774","0.49772167","0.49735883","0.49703336","0.49701","0.4959753","0.49564728","0.49527532","0.49509615","0.49434277"],"string":"[\n \"0.69530743\",\n \"0.65202653\",\n \"0.6478382\",\n \"0.6396903\",\n \"0.639056\",\n \"0.6178385\",\n \"0.6178385\",\n \"0.6144988\",\n \"0.60816115\",\n \"0.58620787\",\n \"0.58369505\",\n \"0.58215445\",\n \"0.58118826\",\n \"0.57391644\",\n \"0.5735804\",\n \"0.5733575\",\n \"0.57045203\",\n \"0.5664503\",\n \"0.56433076\",\n \"0.5625876\",\n \"0.5607506\",\n \"0.5582593\",\n \"0.5574494\",\n \"0.55618894\",\n \"0.5556996\",\n \"0.5548116\",\n \"0.5545993\",\n \"0.551127\",\n \"0.5511045\",\n \"0.5491174\",\n \"0.5490307\",\n \"0.54721534\",\n \"0.54721534\",\n \"0.54662\",\n \"0.5447006\",\n \"0.5434372\",\n \"0.5410584\",\n \"0.5409172\",\n \"0.5408381\",\n \"0.5403078\",\n \"0.5379858\",\n \"0.536897\",\n \"0.5323173\",\n \"0.5318024\",\n \"0.5279386\",\n \"0.5277172\",\n \"0.52680093\",\n \"0.52627623\",\n \"0.52142686\",\n \"0.5207172\",\n \"0.5186061\",\n \"0.51786953\",\n \"0.5175208\",\n \"0.5174657\",\n \"0.5174197\",\n \"0.51697326\",\n \"0.5167767\",\n \"0.5142288\",\n \"0.51412874\",\n \"0.51355165\",\n \"0.5121447\",\n \"0.5120317\",\n \"0.5086932\",\n \"0.5086932\",\n \"0.50769424\",\n \"0.5075061\",\n \"0.5061361\",\n \"0.5055459\",\n \"0.50550544\",\n \"0.5044154\",\n \"0.5038759\",\n \"0.5033986\",\n \"0.5033495\",\n \"0.50320715\",\n \"0.5026256\",\n \"0.5021534\",\n \"0.5018618\",\n \"0.5013712\",\n \"0.5012262\",\n \"0.50120157\",\n \"0.5010144\",\n \"0.5007305\",\n \"0.50067997\",\n \"0.50061715\",\n \"0.50053847\",\n \"0.50007844\",\n \"0.49978232\",\n \"0.49921507\",\n \"0.49838975\",\n \"0.49815592\",\n \"0.49806774\",\n \"0.49772167\",\n \"0.49735883\",\n \"0.49703336\",\n \"0.49701\",\n \"0.4959753\",\n \"0.49564728\",\n \"0.49527532\",\n \"0.49509615\",\n \"0.49434277\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67026734"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":91989,"cells":{"query":{"kind":"string","value":"esta es una funcion que recibe dos parametros y retorna la suma de ellos"},"document":{"kind":"string","value":"def sum(a,v):\n return a+v"},"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_sum(a,b):\n return","def sum(*args):\n result = 0\n for i in args:\n result += i\n return result","def sums(arg1, arg2): # create function sums with arguments arg1 and arg2\n totals = arg1 + arg2 # set the variable totals to equal arg1 + arg2\n print(\"Inside the function : \", totals) # print the totals\n return totals # return the variable totals defined as arg1 + arg2","def calc_sum(a, b, c, d, e):\n return (a + b + c + d + e)","def returnSum(a,b,c):\n return(a+b+c)","def sum(a,b,c):\n return (a+b+c)","def sum(*args):\n return reduce(lambda x, y: x + y, args)","def add(*args):\n #convert args to floats so we can do the maths\n values = list(args)\n for x in range(len(values)):\n values[x] = float(values[x])\n \n summation = str(ft.reduce(oper.add,values))\n return summation","def get(self):\n args = single_parser.parse_args()\n n1 = args.n\n m1 = args.m\n r = summation(n1, m1)\n print(r)\n return {\"add\": r}","def add(self, *args):\n sum = 0\n for arg in args:\n sum += float(arg)\n return sum","def add(farg, *args): # *args can take 0 or more values\n print('Formal argument = ', farg)\n \n sum = 0 \n for i in args:\n sum+=i\n print('Sum of all numbers =', (farg+sum))","def kkAdd(*args):\n if (None in args):\n return None\n total = 0\n for arg in args:\n total += arg\n return total","def add(self,*datas):\n\t\tresult = sum(datas)\n\t\treturn result","def SUM(*args):\n return _group_function(lambda x, y: x + y, *args)","def faltas(f):\n total = sum(f[0][2] + f[1][2] + f[2][2])\n return total","def _generalised_sum(data, func):\n count = len(data)\n if func is None:\n total = math.fsum(data)\n else:\n total = math.fsum(func(x) for x in data)\n return count, total","def find_sum( *my_list):\n # a = len(my_list)- 2\n # i = 0\n # suma=0\n # for i in my_list :\n # suma += my_list[i]\n # i+=1\n # return suma\n return sum(my_list)","def custom_sum(*args):\n return functools.reduce(lambda x, y: x + y, args)","def ll_sum(some_list):\n #This function will return total value of all integers combinded.\n result = 0\n if type(some_list) == list: #Check the element is list or not?\n for i in range(len(some_list)):\n result += ll_sum(some_list[i]) # if it's a list call this function \n #so it will call over and over untill it found element that not a list.\n elif type(some_list) == float or type(some_list) == int: #if it's not list return it value.\n result += some_list\n return result","def custom_sum(*args):\n return functools.reduce(lambda x, y: x + y, args)","def custom_sum(*args):\n return functools.reduce(lambda x, y: x + y, args)","def sum(a,b):\n return a*b","def som(getallenlijst):\r\n total = sum(getallenlijst)\r\n return total","def sum(*nums): \n s=0\n for num in nums:\n s += num\n return s","def getAmount1(*args):","def sum(num_1, num_2):\n return num_1 + num_2","def sum(a, b):\n return a + b","def sum(a, b):\n return a + b","def sum(a,b):\r\n c=a+b\r\n return c","def test_add():\n l = [1, 2, 3, 4]\n assert s7.add(*l) == sum(l)\n assert s7.add(100, 200) == 300\n assert s7.add(1.0, 2.0, 100.0) == 103.0","def sumar(self):\n self.resultado = self.valor_1 + self.valor_2","def sum_value(self, lv, rv):","def MySum( l ):\n\n #checking if arg is a list\n if isinstance(l, list):\n\n #adding all numbs\n result = 0\n\n for numb in l:\n result = result + int(numb)\n\n return result\n\n else:\n return \"Argument is not a list\"","def sum_of(self, names):\n vals = self.get_values(names)\n if vals is None:\n return None\n return sum(vals)","def sum(values):\n total = 0\n for i in values:\n total += i\n return total","def suma(a, b):\n\n\ttotal = a + b\n\treturn total","def sumaPar(self,numSeg,w):\n total=0\n for i in range(2,numSeg-1,2):\n total+=2*self.F(i*w)\n return total","def add(numbers):\n sum1 = 0\n for i in numbers:\n sum1 = sum1+i\n\n return sum1","def sum(inputList):\n sum=0#the sum of the list starts from 0\n for num in inputList:\n sum=sum+num#add all number in the list\n print(\"the sum is\",sum)","def all_numeric_accumulations(request):\n return request.param","def sum_of_numbers(numbers):\r\n return sum(numbers)","def sum(num1, num2):\n return num1 + num2","def sum_values(values):\n return (sum(values))","def sum1(a,b):\n c = a + b\n return c","def sum_series(input,input1=0,input2=1):\n\n if input == 0:\n\n return input1\n\n elif input == 1:\n\n return input2\n\n else:\n return sum_series(input-1,input1,input2) + sum_series(input-2,input1,input2)","def n_suma(a1,nr_wyrazu,r):\n return (2*a1+(nr_wyrazu-1))*nr_wyrazu/2","def sum_nums(a,b,c):\n print(a+b+c)","def suma(x, y):\n return x + y","def addition_homework(data: Iterator[str]) -> int:\n n = final_sum(data)\n return n.magnitude","def add(*args):\n body = ['<h1>Addition Calculator</h1>']\n _sum = sum(map(int, args))\n body.append(f'Total equals: {_sum}')\n return '\\n'.join(body)","def add(*args):\n\n # TODO: Fill sum with the correct value, based on the\n # args provided.\n sum = str(args[0] + args[1])\n return sum","def sumation(cmds):\n numbers = []\n sum = 0\n try: \n for i in cmds[1:]:\n numbers.append(float(i))\n for l in numbers:\n sum = sum + l\n print(sum)\n except TypeError:\n print(\"Hmmm, I guess you haven't only entered valid numbers\")","def sum_items(numbers):\n total = 0\n for item in numbers:\n total += item\n return total","def sum_list_elements(input_list):\n print(f\"Sumatorio de los elementos dela lista: {sum(input_list)}\")","def summation(self):\n return sum(self.read_ints())","def sum(lst):\n total = 0\n for i in lst:\n total += i\n return total","def sum_num(n1=2, n2=4):\n return n1 + n2","def getAmount2(*args):","def add_list_numbers(incoming_list):\n # summation=0\n if incoming_list:\n summation = sum(incoming_list)\n else:\n summation = 0\n return summation","def calculate(self):","def sum_num(a, b):\n return a + b","def calculate_parameters(self, item):","def sum_nums(n1=0, n2=0):\n return n1 + n2","def sum_multiples(num):\n pass","def sum1(num1, num2, *extra): \n \n s = 0\n s = num1 + num2\n \n for n in extra:\n s += n\n # print(n, end=' ')\n return s","def suma_wyrazow(*elementy):\n return sum(elementy)/len(elementy)","def sum_series(n,v1=0,v2=1):\n\tL1=v2\n\tL2=v1\n\tif n<0:\n\t\tprint(\"please enter positive int value\")\n\n\telif n==0:\n\t\treturn v1\n\n\telif n==1:\n\t\treturn v2\n\n\telse:\n\t\tfor i in range(n-1):\n\t\t\tC=L1+L2\n\t\t\tL2=L1\n\t\t\tL1=C\n\t\treturn C","def final_sum(data: Iterator[str]) -> SnailfishNumber:\n return reduce(add, parse_input(data))","def postitionalSum(list1, list2):\r\n\r\n myList = []\r\n\r\n if list1 == []:\r\n return []\r\n else:\r\n myList.append(list1[0]+list2[0])\r\n list1.remove(list1[0]), list2.remove(list2[0])\r\n postitionalSum(list1, list2)\r\n return myList","def power_sum(power, *args):\n total = 0\n for i in args:\n total += pow(i, power)\n return total","def add(num1, num2):\n\n sums = num1 + num2\n return sums","def exercise1(self, param1, param2, param3):\n sum_of_the_squares = self.auxiliar_exercise1(param1, param2, param3)\n print \"the sum of the squares of \", param1, \", \", param2, \", \", param3, \") is \", sum_of_the_squares","def sum_app(*numbers_to_sum: typing.Tuple[int, ...]):\n return sum(numbers_to_sum)","def decimal_sum(*args):\n res = 0\n for numb in args:\n try:\n res += Decimal(str(numb))\n except:\n print(f\"Argument [ {numb} ] is skipped... not a float\")\n return res","def total(num_list):\n num_sum = 0.0\n for item in num_list:\n num_sum += item\n return num_sum","def my_func(a,b,c):\n \n return a + b + c","def calculate_returns(data):\n pass","def add_numbers(a,b):\r\n return a+ b","def myfunc(*args):\n return sum(args) * 0.05","def get_sum(lst):\n _sum=0\n for i in lst:\n _sum+=i\n return _sum","def sum_numbers(numbers):\n sum = 0\n for number in numbers:\n sum += number\n\n return sum","def vector_sum(vectors):\n results = vectors[0]\n for vector in vectors[1:]:\n results = vector_add(results, vector)\n return results","def sum(a,b):\n c = a + b\n print ('Sum is : ', c)","def find_arithmetic_mean( *args):\n sum = 0\n for value in args:\n sum += value\n return sum/len(args)","def fsum(items):\n return math.fsum(items)","def SumM(v:'value', e:'error', w:'weight'=None):\n\n v = np.array(v)\n e = np.array(e)\n\n n = len(v)\n assert len(v) == len(e) \n if w is None:\n w = np.array([1.]*len(v))\n else:\n assert len(w) == len(v)\n w = np.array(w) / e**2\n wt = np.sum(w)\n w2t = np.sum(w**2)\n wti = 1/np.sum(w)\n yw = np.sum(w * v) * wti\n Qw = np.sum(w * (v - yw) ** 2)\n d2 = max(0, (Qw - (n-1)) / (wt - w2t*wti))\n wx = 1 / (e**2 + d2)\n wxti = 1 / np.sum(wx)\n a = np.sum(wx * v) * wxti\n e2 = wxti\n return a, np.sqrt(e2)","def vector_sum(vectors):\n\tresult = vectors[0]\n\tfor vector in vectors:\n\t\tresult = vector_add(result, vector)\n\treturn result","def get_the_sum_of_prices(item_ids):\n\n # your code","def sum_list(input_list: List[float]) -> float:\n return sum(input_list)","def sum_list(input_list: List[float]) -> float:\n return sum(input_list)","def add(a,b):\n return [a[0]+b[0],a[1]+b[1],a[2]+b[2],1.0]","def ADD (self, n1, n2):","def combine_many(*fudge):\n result = sum(fudge)\n print(result)","def test_total(self):\n # a, fpr, n, y\n args_tuples = [\n (100, 0.01, 10000, 30),\n (20, 0.02, 10000, 20),\n (40, 0.03, 200000, 10),\n (3, 0.3, 1000, 7),\n (9, 0.05, 5000, 399),\n (57, 0.09, 4500, 13),\n ]\n\n for a, fpr, n, y in args_tuples:\n py_tot, py_rows = self.py_search.total(a, fpr, n, y)\n cpp_tot, cpp_rows = params.total(self.cpp_search_ptr, a, fpr, n, y)\n print(f\"py: {py_tot}, {py_rows} | cpp: {cpp_tot}, {cpp_rows}\")\n self.assertAlmostEqual(py_tot, cpp_tot)\n self.assertEqual(py_rows, cpp_rows)","def calculate(inp: tuple) -> tuple:\n return (\n (inp[0] * 1) +\n (inp[1] * 2) +\n (inp[2] * 5) +\n (inp[3] * 10) +\n (inp[4] * 20) +\n (inp[5] * 50) +\n (inp[6] * 100) +\n (inp[7] * 200)\n ) / 100, sum(inp)","def calcSum3(data1, data2):\n \n #SxW @high resolution\n data111 = data1[0][0]\n #SxW @low resolution\n data112 = data1[0][1]\n #phi @high resolution\n data121 = data1[1][0]\n #phi @low resolution\n data122 = data1[1][1]\n \n #SxW @high resolution\n data211 = data2[0][0]\n #SxW @low resolution\n data212 = data2[0][1]\n #phi @high resolution\n data221 = data2[1][0]\n #phi @low resolution\n data222 = data2[1][1]\n \n \n \n swh = [data111[i] + data211[i] for i in range(0,len(data111))]\n swl = [data112[i] + data212[i] for i in range(0,len(data112))]\n \n phih = [data121[i] + data221[i] for i in range(0,len(data121))]\n phil = [data122[i] + data222[i] for i in range(0,len(data122))]\n \n \n return [[swh, swl], [phih, phil]]","def make_sum_in_2(a1, *rest):\n def helper(a, alist, acc):\n \"\"\"\n a: first argument\n alist: scheme list; rest of arguments\n acc: sum result so far\n \"\"\"\n if isNull(alist):\n if isNumber(a) and a == 0:\n return acc\n elif isNumber(acc) and acc == 0:\n return a\n elif isNumber(a) and isNumber(acc):\n return a + acc\n elif isList(acc):\n return append(acc, List(plus, a))\n else:\n return append(List(acc), List(plus, a))\n else:\n # more arguments in alist to process\n p = car(alist)\n q = cdr(alist)\n if isNumber(a) and a == 0:\n return helper(p, q, acc)\n elif isNumber(acc) and acc == 0:\n return helper(p, q, a)\n elif isNumber(a) and isNumber(acc):\n return helper(p, q, acc + a)\n else:\n if isList(acc):\n return helper(p, q, append(acc, List(plus, a)))\n else:\n return helper(p, q, append(List(acc), List(plus, a)))\n\n rests = List(*rest)\n return helper(a1, rests, 0)","def SUM(strArg, composList, atomDict):\n accum = 0.0\n for atom, num in composList:\n tStr = strArg.replace('DEADBEEF', atom)\n accum = accum + eval(tStr) * num\n return accum","def sumValues(aList):\r\n sum = 0\r\n for d in aList:\r\n sum += d\r\n return sum","def sum_list(numbers):\n\t\n\tif len(numbers) == 0:\n\t\treturn 0 \n\n\tsum = numbers[0] +sum_list(numbers[1:])\n\treturn sum"],"string":"[\n \"def get_sum(a,b):\\n return\",\n \"def sum(*args):\\n result = 0\\n for i in args:\\n result += i\\n return result\",\n \"def sums(arg1, arg2): # create function sums with arguments arg1 and arg2\\n totals = arg1 + arg2 # set the variable totals to equal arg1 + arg2\\n print(\\\"Inside the function : \\\", totals) # print the totals\\n return totals # return the variable totals defined as arg1 + arg2\",\n \"def calc_sum(a, b, c, d, e):\\n return (a + b + c + d + e)\",\n \"def returnSum(a,b,c):\\n return(a+b+c)\",\n \"def sum(a,b,c):\\n return (a+b+c)\",\n \"def sum(*args):\\n return reduce(lambda x, y: x + y, args)\",\n \"def add(*args):\\n #convert args to floats so we can do the maths\\n values = list(args)\\n for x in range(len(values)):\\n values[x] = float(values[x])\\n \\n summation = str(ft.reduce(oper.add,values))\\n return summation\",\n \"def get(self):\\n args = single_parser.parse_args()\\n n1 = args.n\\n m1 = args.m\\n r = summation(n1, m1)\\n print(r)\\n return {\\\"add\\\": r}\",\n \"def add(self, *args):\\n sum = 0\\n for arg in args:\\n sum += float(arg)\\n return sum\",\n \"def add(farg, *args): # *args can take 0 or more values\\n print('Formal argument = ', farg)\\n \\n sum = 0 \\n for i in args:\\n sum+=i\\n print('Sum of all numbers =', (farg+sum))\",\n \"def kkAdd(*args):\\n if (None in args):\\n return None\\n total = 0\\n for arg in args:\\n total += arg\\n return total\",\n \"def add(self,*datas):\\n\\t\\tresult = sum(datas)\\n\\t\\treturn result\",\n \"def SUM(*args):\\n return _group_function(lambda x, y: x + y, *args)\",\n \"def faltas(f):\\n total = sum(f[0][2] + f[1][2] + f[2][2])\\n return total\",\n \"def _generalised_sum(data, func):\\n count = len(data)\\n if func is None:\\n total = math.fsum(data)\\n else:\\n total = math.fsum(func(x) for x in data)\\n return count, total\",\n \"def find_sum( *my_list):\\n # a = len(my_list)- 2\\n # i = 0\\n # suma=0\\n # for i in my_list :\\n # suma += my_list[i]\\n # i+=1\\n # return suma\\n return sum(my_list)\",\n \"def custom_sum(*args):\\n return functools.reduce(lambda x, y: x + y, args)\",\n \"def ll_sum(some_list):\\n #This function will return total value of all integers combinded.\\n result = 0\\n if type(some_list) == list: #Check the element is list or not?\\n for i in range(len(some_list)):\\n result += ll_sum(some_list[i]) # if it's a list call this function \\n #so it will call over and over untill it found element that not a list.\\n elif type(some_list) == float or type(some_list) == int: #if it's not list return it value.\\n result += some_list\\n return result\",\n \"def custom_sum(*args):\\n return functools.reduce(lambda x, y: x + y, args)\",\n \"def custom_sum(*args):\\n return functools.reduce(lambda x, y: x + y, args)\",\n \"def sum(a,b):\\n return a*b\",\n \"def som(getallenlijst):\\r\\n total = sum(getallenlijst)\\r\\n return total\",\n \"def sum(*nums): \\n s=0\\n for num in nums:\\n s += num\\n return s\",\n \"def getAmount1(*args):\",\n \"def sum(num_1, num_2):\\n return num_1 + num_2\",\n \"def sum(a, b):\\n return a + b\",\n \"def sum(a, b):\\n return a + b\",\n \"def sum(a,b):\\r\\n c=a+b\\r\\n return c\",\n \"def test_add():\\n l = [1, 2, 3, 4]\\n assert s7.add(*l) == sum(l)\\n assert s7.add(100, 200) == 300\\n assert s7.add(1.0, 2.0, 100.0) == 103.0\",\n \"def sumar(self):\\n self.resultado = self.valor_1 + self.valor_2\",\n \"def sum_value(self, lv, rv):\",\n \"def MySum( l ):\\n\\n #checking if arg is a list\\n if isinstance(l, list):\\n\\n #adding all numbs\\n result = 0\\n\\n for numb in l:\\n result = result + int(numb)\\n\\n return result\\n\\n else:\\n return \\\"Argument is not a list\\\"\",\n \"def sum_of(self, names):\\n vals = self.get_values(names)\\n if vals is None:\\n return None\\n return sum(vals)\",\n \"def sum(values):\\n total = 0\\n for i in values:\\n total += i\\n return total\",\n \"def suma(a, b):\\n\\n\\ttotal = a + b\\n\\treturn total\",\n \"def sumaPar(self,numSeg,w):\\n total=0\\n for i in range(2,numSeg-1,2):\\n total+=2*self.F(i*w)\\n return total\",\n \"def add(numbers):\\n sum1 = 0\\n for i in numbers:\\n sum1 = sum1+i\\n\\n return sum1\",\n \"def sum(inputList):\\n sum=0#the sum of the list starts from 0\\n for num in inputList:\\n sum=sum+num#add all number in the list\\n print(\\\"the sum is\\\",sum)\",\n \"def all_numeric_accumulations(request):\\n return request.param\",\n \"def sum_of_numbers(numbers):\\r\\n return sum(numbers)\",\n \"def sum(num1, num2):\\n return num1 + num2\",\n \"def sum_values(values):\\n return (sum(values))\",\n \"def sum1(a,b):\\n c = a + b\\n return c\",\n \"def sum_series(input,input1=0,input2=1):\\n\\n if input == 0:\\n\\n return input1\\n\\n elif input == 1:\\n\\n return input2\\n\\n else:\\n return sum_series(input-1,input1,input2) + sum_series(input-2,input1,input2)\",\n \"def n_suma(a1,nr_wyrazu,r):\\n return (2*a1+(nr_wyrazu-1))*nr_wyrazu/2\",\n \"def sum_nums(a,b,c):\\n print(a+b+c)\",\n \"def suma(x, y):\\n return x + y\",\n \"def addition_homework(data: Iterator[str]) -> int:\\n n = final_sum(data)\\n return n.magnitude\",\n \"def add(*args):\\n body = ['<h1>Addition Calculator</h1>']\\n _sum = sum(map(int, args))\\n body.append(f'Total equals: {_sum}')\\n return '\\\\n'.join(body)\",\n \"def add(*args):\\n\\n # TODO: Fill sum with the correct value, based on the\\n # args provided.\\n sum = str(args[0] + args[1])\\n return sum\",\n \"def sumation(cmds):\\n numbers = []\\n sum = 0\\n try: \\n for i in cmds[1:]:\\n numbers.append(float(i))\\n for l in numbers:\\n sum = sum + l\\n print(sum)\\n except TypeError:\\n print(\\\"Hmmm, I guess you haven't only entered valid numbers\\\")\",\n \"def sum_items(numbers):\\n total = 0\\n for item in numbers:\\n total += item\\n return total\",\n \"def sum_list_elements(input_list):\\n print(f\\\"Sumatorio de los elementos dela lista: {sum(input_list)}\\\")\",\n \"def summation(self):\\n return sum(self.read_ints())\",\n \"def sum(lst):\\n total = 0\\n for i in lst:\\n total += i\\n return total\",\n \"def sum_num(n1=2, n2=4):\\n return n1 + n2\",\n \"def getAmount2(*args):\",\n \"def add_list_numbers(incoming_list):\\n # summation=0\\n if incoming_list:\\n summation = sum(incoming_list)\\n else:\\n summation = 0\\n return summation\",\n \"def calculate(self):\",\n \"def sum_num(a, b):\\n return a + b\",\n \"def calculate_parameters(self, item):\",\n \"def sum_nums(n1=0, n2=0):\\n return n1 + n2\",\n \"def sum_multiples(num):\\n pass\",\n \"def sum1(num1, num2, *extra): \\n \\n s = 0\\n s = num1 + num2\\n \\n for n in extra:\\n s += n\\n # print(n, end=' ')\\n return s\",\n \"def suma_wyrazow(*elementy):\\n return sum(elementy)/len(elementy)\",\n \"def sum_series(n,v1=0,v2=1):\\n\\tL1=v2\\n\\tL2=v1\\n\\tif n<0:\\n\\t\\tprint(\\\"please enter positive int value\\\")\\n\\n\\telif n==0:\\n\\t\\treturn v1\\n\\n\\telif n==1:\\n\\t\\treturn v2\\n\\n\\telse:\\n\\t\\tfor i in range(n-1):\\n\\t\\t\\tC=L1+L2\\n\\t\\t\\tL2=L1\\n\\t\\t\\tL1=C\\n\\t\\treturn C\",\n \"def final_sum(data: Iterator[str]) -> SnailfishNumber:\\n return reduce(add, parse_input(data))\",\n \"def postitionalSum(list1, list2):\\r\\n\\r\\n myList = []\\r\\n\\r\\n if list1 == []:\\r\\n return []\\r\\n else:\\r\\n myList.append(list1[0]+list2[0])\\r\\n list1.remove(list1[0]), list2.remove(list2[0])\\r\\n postitionalSum(list1, list2)\\r\\n return myList\",\n \"def power_sum(power, *args):\\n total = 0\\n for i in args:\\n total += pow(i, power)\\n return total\",\n \"def add(num1, num2):\\n\\n sums = num1 + num2\\n return sums\",\n \"def exercise1(self, param1, param2, param3):\\n sum_of_the_squares = self.auxiliar_exercise1(param1, param2, param3)\\n print \\\"the sum of the squares of \\\", param1, \\\", \\\", param2, \\\", \\\", param3, \\\") is \\\", sum_of_the_squares\",\n \"def sum_app(*numbers_to_sum: typing.Tuple[int, ...]):\\n return sum(numbers_to_sum)\",\n \"def decimal_sum(*args):\\n res = 0\\n for numb in args:\\n try:\\n res += Decimal(str(numb))\\n except:\\n print(f\\\"Argument [ {numb} ] is skipped... not a float\\\")\\n return res\",\n \"def total(num_list):\\n num_sum = 0.0\\n for item in num_list:\\n num_sum += item\\n return num_sum\",\n \"def my_func(a,b,c):\\n \\n return a + b + c\",\n \"def calculate_returns(data):\\n pass\",\n \"def add_numbers(a,b):\\r\\n return a+ b\",\n \"def myfunc(*args):\\n return sum(args) * 0.05\",\n \"def get_sum(lst):\\n _sum=0\\n for i in lst:\\n _sum+=i\\n return _sum\",\n \"def sum_numbers(numbers):\\n sum = 0\\n for number in numbers:\\n sum += number\\n\\n return sum\",\n \"def vector_sum(vectors):\\n results = vectors[0]\\n for vector in vectors[1:]:\\n results = vector_add(results, vector)\\n return results\",\n \"def sum(a,b):\\n c = a + b\\n print ('Sum is : ', c)\",\n \"def find_arithmetic_mean( *args):\\n sum = 0\\n for value in args:\\n sum += value\\n return sum/len(args)\",\n \"def fsum(items):\\n return math.fsum(items)\",\n \"def SumM(v:'value', e:'error', w:'weight'=None):\\n\\n v = np.array(v)\\n e = np.array(e)\\n\\n n = len(v)\\n assert len(v) == len(e) \\n if w is None:\\n w = np.array([1.]*len(v))\\n else:\\n assert len(w) == len(v)\\n w = np.array(w) / e**2\\n wt = np.sum(w)\\n w2t = np.sum(w**2)\\n wti = 1/np.sum(w)\\n yw = np.sum(w * v) * wti\\n Qw = np.sum(w * (v - yw) ** 2)\\n d2 = max(0, (Qw - (n-1)) / (wt - w2t*wti))\\n wx = 1 / (e**2 + d2)\\n wxti = 1 / np.sum(wx)\\n a = np.sum(wx * v) * wxti\\n e2 = wxti\\n return a, np.sqrt(e2)\",\n \"def vector_sum(vectors):\\n\\tresult = vectors[0]\\n\\tfor vector in vectors:\\n\\t\\tresult = vector_add(result, vector)\\n\\treturn result\",\n \"def get_the_sum_of_prices(item_ids):\\n\\n # your code\",\n \"def sum_list(input_list: List[float]) -> float:\\n return sum(input_list)\",\n \"def sum_list(input_list: List[float]) -> float:\\n return sum(input_list)\",\n \"def add(a,b):\\n return [a[0]+b[0],a[1]+b[1],a[2]+b[2],1.0]\",\n \"def ADD (self, n1, n2):\",\n \"def combine_many(*fudge):\\n result = sum(fudge)\\n print(result)\",\n \"def test_total(self):\\n # a, fpr, n, y\\n args_tuples = [\\n (100, 0.01, 10000, 30),\\n (20, 0.02, 10000, 20),\\n (40, 0.03, 200000, 10),\\n (3, 0.3, 1000, 7),\\n (9, 0.05, 5000, 399),\\n (57, 0.09, 4500, 13),\\n ]\\n\\n for a, fpr, n, y in args_tuples:\\n py_tot, py_rows = self.py_search.total(a, fpr, n, y)\\n cpp_tot, cpp_rows = params.total(self.cpp_search_ptr, a, fpr, n, y)\\n print(f\\\"py: {py_tot}, {py_rows} | cpp: {cpp_tot}, {cpp_rows}\\\")\\n self.assertAlmostEqual(py_tot, cpp_tot)\\n self.assertEqual(py_rows, cpp_rows)\",\n \"def calculate(inp: tuple) -> tuple:\\n return (\\n (inp[0] * 1) +\\n (inp[1] * 2) +\\n (inp[2] * 5) +\\n (inp[3] * 10) +\\n (inp[4] * 20) +\\n (inp[5] * 50) +\\n (inp[6] * 100) +\\n (inp[7] * 200)\\n ) / 100, sum(inp)\",\n \"def calcSum3(data1, data2):\\n \\n #SxW @high resolution\\n data111 = data1[0][0]\\n #SxW @low resolution\\n data112 = data1[0][1]\\n #phi @high resolution\\n data121 = data1[1][0]\\n #phi @low resolution\\n data122 = data1[1][1]\\n \\n #SxW @high resolution\\n data211 = data2[0][0]\\n #SxW @low resolution\\n data212 = data2[0][1]\\n #phi @high resolution\\n data221 = data2[1][0]\\n #phi @low resolution\\n data222 = data2[1][1]\\n \\n \\n \\n swh = [data111[i] + data211[i] for i in range(0,len(data111))]\\n swl = [data112[i] + data212[i] for i in range(0,len(data112))]\\n \\n phih = [data121[i] + data221[i] for i in range(0,len(data121))]\\n phil = [data122[i] + data222[i] for i in range(0,len(data122))]\\n \\n \\n return [[swh, swl], [phih, phil]]\",\n \"def make_sum_in_2(a1, *rest):\\n def helper(a, alist, acc):\\n \\\"\\\"\\\"\\n a: first argument\\n alist: scheme list; rest of arguments\\n acc: sum result so far\\n \\\"\\\"\\\"\\n if isNull(alist):\\n if isNumber(a) and a == 0:\\n return acc\\n elif isNumber(acc) and acc == 0:\\n return a\\n elif isNumber(a) and isNumber(acc):\\n return a + acc\\n elif isList(acc):\\n return append(acc, List(plus, a))\\n else:\\n return append(List(acc), List(plus, a))\\n else:\\n # more arguments in alist to process\\n p = car(alist)\\n q = cdr(alist)\\n if isNumber(a) and a == 0:\\n return helper(p, q, acc)\\n elif isNumber(acc) and acc == 0:\\n return helper(p, q, a)\\n elif isNumber(a) and isNumber(acc):\\n return helper(p, q, acc + a)\\n else:\\n if isList(acc):\\n return helper(p, q, append(acc, List(plus, a)))\\n else:\\n return helper(p, q, append(List(acc), List(plus, a)))\\n\\n rests = List(*rest)\\n return helper(a1, rests, 0)\",\n \"def SUM(strArg, composList, atomDict):\\n accum = 0.0\\n for atom, num in composList:\\n tStr = strArg.replace('DEADBEEF', atom)\\n accum = accum + eval(tStr) * num\\n return accum\",\n \"def sumValues(aList):\\r\\n sum = 0\\r\\n for d in aList:\\r\\n sum += d\\r\\n return sum\",\n \"def sum_list(numbers):\\n\\t\\n\\tif len(numbers) == 0:\\n\\t\\treturn 0 \\n\\n\\tsum = numbers[0] +sum_list(numbers[1:])\\n\\treturn sum\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7318327","0.7009012","0.698997","0.6969839","0.6940038","0.6829298","0.6651685","0.6611744","0.6542105","0.6539168","0.6525985","0.6523398","0.6488423","0.6481863","0.6465098","0.64590466","0.6432706","0.64280194","0.63407207","0.6335891","0.6335891","0.6334503","0.63046986","0.62883615","0.6284544","0.6257211","0.62562466","0.62562466","0.6247561","0.6206203","0.62032485","0.6197106","0.6186573","0.6142778","0.6136021","0.6133892","0.61275786","0.6119905","0.61170185","0.6112339","0.61094534","0.60811514","0.60780096","0.6070042","0.6035125","0.60017467","0.5992165","0.5978874","0.59752345","0.59619576","0.5956908","0.5956426","0.5944038","0.5940992","0.5931905","0.593121","0.5930386","0.5920066","0.5906806","0.58979106","0.5897882","0.5896787","0.5895839","0.58944464","0.58929026","0.5890679","0.58600104","0.58549196","0.5852364","0.5849601","0.5832042","0.58303624","0.58261055","0.5824579","0.5822337","0.58139384","0.5812222","0.5804741","0.58003074","0.5800177","0.578855","0.5771083","0.5770855","0.57655185","0.5763601","0.5762721","0.57558966","0.5749532","0.57485294","0.57485294","0.5746822","0.5734477","0.57304263","0.5729825","0.5729519","0.5728109","0.572733","0.572557","0.5699058","0.5693381"],"string":"[\n \"0.7318327\",\n \"0.7009012\",\n \"0.698997\",\n \"0.6969839\",\n \"0.6940038\",\n \"0.6829298\",\n \"0.6651685\",\n \"0.6611744\",\n \"0.6542105\",\n \"0.6539168\",\n \"0.6525985\",\n \"0.6523398\",\n \"0.6488423\",\n \"0.6481863\",\n \"0.6465098\",\n \"0.64590466\",\n \"0.6432706\",\n \"0.64280194\",\n \"0.63407207\",\n \"0.6335891\",\n \"0.6335891\",\n \"0.6334503\",\n \"0.63046986\",\n \"0.62883615\",\n \"0.6284544\",\n \"0.6257211\",\n \"0.62562466\",\n \"0.62562466\",\n \"0.6247561\",\n \"0.6206203\",\n \"0.62032485\",\n \"0.6197106\",\n \"0.6186573\",\n \"0.6142778\",\n \"0.6136021\",\n \"0.6133892\",\n \"0.61275786\",\n \"0.6119905\",\n \"0.61170185\",\n \"0.6112339\",\n \"0.61094534\",\n \"0.60811514\",\n \"0.60780096\",\n \"0.6070042\",\n \"0.6035125\",\n \"0.60017467\",\n \"0.5992165\",\n \"0.5978874\",\n \"0.59752345\",\n \"0.59619576\",\n \"0.5956908\",\n \"0.5956426\",\n \"0.5944038\",\n \"0.5940992\",\n \"0.5931905\",\n \"0.593121\",\n \"0.5930386\",\n \"0.5920066\",\n \"0.5906806\",\n \"0.58979106\",\n \"0.5897882\",\n \"0.5896787\",\n \"0.5895839\",\n \"0.58944464\",\n \"0.58929026\",\n \"0.5890679\",\n \"0.58600104\",\n \"0.58549196\",\n \"0.5852364\",\n \"0.5849601\",\n \"0.5832042\",\n \"0.58303624\",\n \"0.58261055\",\n \"0.5824579\",\n \"0.5822337\",\n \"0.58139384\",\n \"0.5812222\",\n \"0.5804741\",\n \"0.58003074\",\n \"0.5800177\",\n \"0.578855\",\n \"0.5771083\",\n \"0.5770855\",\n \"0.57655185\",\n \"0.5763601\",\n \"0.5762721\",\n \"0.57558966\",\n \"0.5749532\",\n \"0.57485294\",\n \"0.57485294\",\n \"0.5746822\",\n \"0.5734477\",\n \"0.57304263\",\n \"0.5729825\",\n \"0.5729519\",\n \"0.5728109\",\n \"0.572733\",\n \"0.572557\",\n \"0.5699058\",\n \"0.5693381\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6171152"},"document_rank":{"kind":"string","value":"33"}}},{"rowIdx":91990,"cells":{"query":{"kind":"string","value":"Read a population from file and return a list of dictionaries of the relationships and the agents"},"document":{"kind":"string","value":"def read_timestep(root_path: str, time: str):\n path = os.path.join(root_path, time)\n\n agent_file = glob.glob(os.path.join(path, \"*_agents.csv\"))[0]\n rel_file = glob.glob(os.path.join(path, \"*_relationships.csv\"))[0]\n feat_files = glob.glob(os.path.join(path, \"*_feat_*.csv\"))\n exposure_files = glob.glob(os.path.join(path, \"*_exposure_*.csv\"))\n assert os.path.isfile(agent_file), f\"can't find agents.csv in {dir}\"\n assert os.path.isfile(rel_file), f\"can't find relationships.csv in {dir}\"\n\n _, agent_filename = os.path.split(agent_file)\n\n # create agents dict\n agents = {}\n\n # re-create all agents and add to population\n with open(agent_file, newline=\"\") as f:\n reader = csv.DictReader(f)\n for row in reader:\n agents[row[\"id\"]] = row\n agents[row[\"id\"]][\"time\"] = time\n\n def update_agent_extras(files, extra_type):\n pattern = re.compile(f\"^.*_{extra_type}_(.*)\\.csv$\")\n for file in files:\n m = pattern.match(file)\n if m is not None:\n extra = m.group(1)\n with open(file, newline=\"\") as f:\n reader = csv.DictReader(f)\n for row in reader:\n for k, v in row.items():\n if k != \"agent\":\n agents[row[\"agent\"]][f\"{extra}_{k}\"] = v.lower() if v in ('True', 'False') else v\n\n update_agent_extras(feat_files, \"feat\")\n update_agent_extras(exposure_files, \"exposure\")\n\n # re-create all relationships and write to file\n rels = []\n with open(rel_file, newline=\"\") as f:\n reader = csv.DictReader(f)\n for row in reader:\n row[\"time\"] = time\n rels.append(row)\n\n return rels, list(agents.values())"},"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 read(self):\n\t\tentities = dict()\n\t\trelations = set()\n\t\tedges = set()\n\t\twith open(self.file_path, encoding=\"utf-8\") as f:\n\t\t\tfor line in tqdm(f):\n\t\t\t\tif(self.prob == 1.0 or random() < self.prob):\n\t\t\t\t\tsource, relation, target, _ = line.split(\" \", 3)\n\t\t\t\t\tis_dataprop = target.startswith('\"')\n\t\t\t\t\tif source not in entities:\n\t\t\t\t\t\tentities[source] = dict(degree=0, out_degree=0, in_degree=0, data_properties={})\n\t\t\t\t\tentities[source][\"out_degree\"] += 1\n\t\t\t\t\tentities[source][\"degree\"] += 1\n\t\t\t\t\tif not is_dataprop:\n\t\t\t\t\t\tif target not in entities:\n\t\t\t\t\t\t\tentities[target] = dict(degree=0, out_degree=0, in_degree=0, data_properties={})\n\t\t\t\t\t\tentities[target][\"in_degree\"] += 1\n\t\t\t\t\t\tentities[target][\"degree\"] += 1\n\t\t\t\t\t\trelations.add(relation)\n\t\t\t\t\t\tedges.add((relation, source, target))\n\t\t\t\t\telse:\n\t\t\t\t\t\tif(self.include_dataprop):\n\t\t\t\t\t\t\tentities[source][\"data_properties\"][relation] = target\n\n\t\treturn (entities, relations, edges)","def read_relations(db, openfile):\n pass","def read_population_assignation(namefile):\n db = shelve.open(namefile)\n hashes = db['hashes']\n key_firms = db['nif']\n year = db['year']\n population_value = db['population']\n methodvalues = db['methodvalues']\n db.close()\n return hashes, key_firms, year, population_value, methodvalues","def load_personality_adj():\n return json.load(open(personality_adj()))","def read_population_distribution(path_POP, occupancy, verbose=False):\n with open(path_POP, 'r') as f:\n jd = json.load(f)\n\n data = jd[occupancy]\n\n # convert peak population to persons/m2\n data['peak'] = data['peak'] / (1000. * ft2)\n\n if verbose:\n pp.pprint(data)\n\n return data","def read_graph(filename):\n\n print(\"\\n\\n========== Loading graph: \" + filename + '==================')\n edges = {}\n\n inFile = open(filename)\n for line in inFile:\n roadInfo = line.split()\n\n # Skip blank lines, read in contents from non-empty lines.\n if (len(roadInfo) > 0):\n srcCity = roadInfo[0]\n destCity = roadInfo[1]\n\n if srcCity in edges:\n edges[srcCity] = edges[srcCity] + [destCity]\n else:\n edges[srcCity] = [destCity]\n\n if destCity in edges:\n edges[destCity] = edges[destCity] + [srcCity]\n else:\n edges[destCity] = [srcCity]\n\n print(\" done.\\n\")\n return edges","def read_roles():\n roles = defaultdict(list)\n invert_is_a = defaultdict(list)\n with open('relation.tsv','r') as inf:\n for line in inf:\n x = line.strip().split('\\t')\n if x[1] == 'has_role':\n roles[f'CHEBI:{x[3]}'].append(f'CHEBI:{x[2]}')\n elif x[1] == 'is_a':\n child = f'CHEBI:{x[3]}'\n parent = f'CHEBI:{x[2]}'\n invert_is_a[parent].append(child)\n #Now include parents\n ancestors = get_ancestors(invert_is_a)\n for node,noderoles in roles.items():\n if node == 'CHEBI:64663':\n print('hi')\n restroles= []\n for role in noderoles:\n moreroles=ancestors[role]\n restroles += moreroles\n roles[node] += restroles\n return roles","def load_simple_families_file(infile, ped_sep=\"\\t\") -> FamiliesData:\n fam_df = pd.read_csv(\n infile,\n sep=ped_sep,\n index_col=False,\n skipinitialspace=True,\n converters={\n \"role\": Role.from_name,\n \"gender\": Sex.from_name,\n \"sex\": Sex.from_name,\n },\n dtype={\"familyId\": str, \"personId\": str},\n comment=\"#\",\n )\n\n fam_df = fam_df.rename(\n columns={\n \"gender\": \"sex\",\n \"personId\": \"person_id\",\n \"familyId\": \"family_id\",\n \"momId\": \"mom_id\",\n \"dadId\": \"dad_id\",\n \"sampleId\": \"sample_id\",\n },\n )\n\n fam_df[\"status\"] = pd.Series(index=fam_df.index, data=1)\n fam_df.loc[fam_df.role == Role.prb, \"status\"] = 2\n fam_df[\"status\"] = fam_df.status.apply(Status.from_value)\n\n fam_df[\"mom_id\"] = pd.Series(index=fam_df.index, data=\"0\")\n fam_df[\"dad_id\"] = pd.Series(index=fam_df.index, data=\"0\")\n\n if \"sample_id\" not in fam_df.columns:\n sample_ids = pd.Series(data=fam_df[\"person_id\"].values)\n fam_df[\"sample_id\"] = sample_ids\n\n families = defaultdict(list)\n for rec in fam_df.to_dict(orient=\"records\"):\n families[rec[\"family_id\"]].append(rec)\n\n result = defaultdict(list)\n for fam_id, members in families.items():\n mom_id = None\n dad_id = None\n children = []\n for member in members:\n role = member[\"role\"]\n if role == Role.mom:\n mom_id = member[\"person_id\"]\n elif role == Role.dad:\n dad_id = member[\"person_id\"]\n else:\n assert role in set([Role.prb, Role.sib])\n children.append(member)\n for child in children:\n child[\"mom_id\"] = mom_id\n child[\"dad_id\"] = dad_id\n\n result[fam_id] = [\n Person(**member) # type: ignore\n for member in members\n ]\n\n return FamiliesData.from_family_persons(result)","def read_annotations(file):\n\n with open(file) as f:\n lines = f.read().splitlines()\n\n annotations_by_agent = divide_annotations(lines)\n agent_list = []\n for annotation_set in annotations_by_agent:\n agent_list.append(Agent(annotation_set))\n\n return agent_list","def load_data(filename):\n with open(filename, 'r') as f:\n d = json.load(f)\n\n return d['nicknames'], d['relations'], d['directed']","def _load_orgs_and_genes(self):\n organisms = {}\n genes = {}\n for gene in self.gene_ids:\n org_file_path = self._get_organisms_file_path(gene[self.GENE_NAME_IDX], gene[self.GENE_ID_IDX])\n with open(org_file_path, \"r\") as orgs:\n org = orgs.read().splitlines()\n genes[gene[self.GENE_NAME_IDX]] = {}\n # we only care about unique organisms\n for o in org:\n if not o.startswith(\">\"):\n continue\n clean_o = o.replace(\">\", \"\", 1).replace(\"_\", \" \").title()\n # I hate to do this but there's a special case for Canis Familiaris\n # EBI does not recognize it but it does recognize Canis Lupus (Canis Lupus Familiaris)\n if \"Canis Familiaris\" in clean_o:\n clean_o = \"Canis lupus\"\n if not organisms.get(clean_o):\n organisms[clean_o] = {self.FREQ_KEY: 1, self.GENE_IDS_KEY: [gene]}\n else:\n organisms[clean_o][self.FREQ_KEY] = organisms[clean_o][self.FREQ_KEY] + 1\n organisms[clean_o][self.GENE_IDS_KEY].append(gene)\n genes[gene[self.GENE_NAME_IDX]][clean_o] = 1\n return organisms, genes","def _load_genes(self):\n with open(self.gene_file_path, 'r') as gene_file:\n csv_reader = csv.reader(gene_file, delimiter=',')\n for gene in csv_reader:\n yield (gene[self.GENE_NAME_IDX], gene[self.GENE_ID_IDX])","def read_nell_relations():\n\trel=os.walk(\"nell/relations\")\n\trelation=[]\n\tfor i in rel:\n\t\ttrel=i[2]\n\tfor i in trel:\n\t\trelation.append(' '.join(segment(i.split(':')[1])))\n\treturn relation","def read_relationship_map():\n try:\n conn = sqlite3.connect(settings.database_name)\n conn.row_factory = sqlite3.Row\n c = conn.cursor()\n c.execute(\"PRAGMA foreign_keys = ON\")\n c.execute(\"SELECT * FROM relationshipmap\")\n relation_dictionary = {}\n for row in c:\n relation_dictionary[row[\"key\"]] = (row[\"key\"], row[\"value\"], row[\"relationshiptype\"])\n conn.close()\n return relation_dictionary\n except:\n return {}","def read_file(self, reader):\n # Open files to write comments, invalid and ignored entries\n comments = open('genome.comments.gff', 'w')\n invalid = open('genome.invalid.gff', 'w')\n ignored = open('genome.ignored.gff', 'w')\n\n # First pass, pulling out all genes and mRNAs\n # and placing child features if possible\n for line in reader:\n if len(line) == 0 or line[0].startswith('#'):\n comments.write(line)\n continue\n splitline = self.validate_line(line)\n if not splitline:\n invalid.write(line)\n else:\n line_added = self.process_line(splitline)\n if not line_added:\n ignored.write(line)\n\n # Second pass, placing child features which \n # preceded their parents in the first pass\n orphans = copy.deepcopy(self.orphans)\n for splitline in orphans:\n self.process_line(splitline)\n \n # Add mRNAs to their parent genes\n for mrna in self.mrnas.values():\n parent_gene = self.genes[mrna.parent_id]\n parent_gene.mrnas.append(mrna)\n\n if self.skipped_features > 0:\n sys.stderr.write(\"Warning: skipped \"+str(self.skipped_features)+\" uninteresting features.\\n\")\n return self.genes.values()","def test_relationship_edges(self):\n path = os.path.join(get_file_dir(), 'data', 'GO_edges_relationship.json')\n with open(path, 'rt') as json_file:\n json_files = []\n for data in json_file:\n json_files.append(json.loads(data))\n for entry in json_files:\n if entry[\"id\"] == \"GO:0000332__GO:0003720__part_of\":\n self.assertEqual(entry[\"from\"], \"GO_term/GO:0000332\")\n self.assertEqual(entry[\"to\"], \"GO_term/GO:0003720\")\n self.assertEqual(entry[\"relationship_type\"], \"part_of\")\n if entry[\"from\"] == \"GO_term/GO:0000335\":\n self.assertEqual(entry[\"id\"], \"GO:0000335__GO:0006313__negatively_regulates\")\n self.assertEqual(entry[\"to\"], \"GO_term/GO:0006313\")\n self.assertEqual(entry[\"relationship_type\"], \"negatively_regulates\")","def readScenario(fileName):\n \n fp = open(fileName, 'r')\n lines = fp.readlines()\n fp.close()\n for line in lines:\n agents.append(Agent(line.split(','),compiled_besier_curves)) # create an agent and add it to the list\n \n # define the boundaries of the environment\n positions = [a.pos for a in agents]\n goals = [a.goal for a in agents]","def read (path):\n\n with open(path) as f:\n reader = csv.DictReader(f)\n edges, nodes = [], {}\n for row in reader:\n edges.append((row[\"NODE1\"], row[\"NODE2\"]))\n nodes[row[\"NODE1\"]] = [eval(row[\"LONG1\"]), eval(row[\"LAT1\"])]\n nodes[row[\"NODE2\"]] = [eval(row[\"LONG2\"]), eval(row[\"LAT2\"])]\n\n return nodes, edges","def load_graph(file_name):\r\n citizens = []\r\n f = open(file_name, 'r')\r\n number_citizens = int(f.readline())\r\n \r\n # creates the citizen's list.\r\n for i in range(number_citizens):\r\n # creates citizen object\r\n citizen = Citizen(i)\r\n citizens.append(citizen)\r\n\r\n # we need this second loop because we cannot create the list of friends \r\n # if we don't have the whole list of citizens in memory.\r\n for citizen in citizens:\r\n # loads basic infor\r\n inf_list = f.readline().split(';')\r\n citizen.location = int(inf_list[1])\r\n citizen.influence_level = int(inf_list[2])\r\n citizen.proactivity_level = inf_list[3]\r\n \r\n # loads opinions\r\n opinions_list = f.readline().split(';')\r\n opinions = {}\r\n \r\n for op in opinions_list[:-1]:\r\n cat_weight = op.split(':')\r\n cat = int(cat_weight[0])\r\n weight = float(cat_weight[1])\r\n idea = Idea(1,'',cat, weight)\r\n opinions[cat] = idea\r\n\r\n citizen.opinions = opinions\r\n \r\n # loads friends \r\n friends_ids_list = f.readline().split(';')\r\n friends = []\r\n for friend_id in friends_ids_list[:-1]:\r\n # note that we match the position of the citizen in the citizens list with its id.\r\n friends.append(citizens[int(friend_id)])\r\n \r\n citizen.friends = friends\r\n \r\n f.close()\r\n \r\n return citizens","def nrpdbs_from_file(filename, rep_type=None):\n # this is the wrong spec. It should simply return the representative\n # pdb-chain for a given pdb-chain and rep-type.\n \n # we actually want two functions: give ALL the reps for a level, or\n # give a mapping from pdb:chain to representative pdb:chain\n nrpdbs = {}\n groups = {}\n with open(filename, 'r') as nrpdb_file:\n\n # iterate over each record in the NRPDB file\n for line in nrpdb_file:\n\n # strip leading and trailing whitespace\n line = line.strip()\n\n try:\n # skip blank lines and comments\n if len(line) == 0 or line[0] == '#':\n continue\n\n # get all of the fields from the current record\n fields = line.split()\n \n # I THINK we want to always go into this loop, but flag\n # those proteins that are reps\n \n\n # if this protein is a representative (or we don't care)\n # (relies on short-circuiting or operator)\n if (rep_type and rep_type in RepresentativeFields.REPFIELDS \\\n and \\\n int(fields[RepresentativeFields.REPFIELDS[rep_type]]) == 1):\n is_rep = True\n else:\n is_rep = False\n \n if (rep_type and rep_type in RepresentativeFields.GROUPFIELDS):\n group_id = fields[RepresentativeFields.GROUPFIELDS[rep_type]]\n else:\n group_id = None\n \n # if rep_type is None or \\\n # (rep_type in RepresentativeFields.REPFIELDS and\n # int(fields[RepresentativeFields.REPFIELDS[rep_type]]) \\\n # == 1):\n\n # get the pdbid and chain letter of this protein\n pdbid, chain = fields[:2]\n \n\n # ensure pdbid is lowercase, chain is uppercase\n pdbid = pdbid.lower()\n chain = chain.upper()\n full_pdbid = pdbid + ':' + chain\n \n if group_id and group_id in groups:\n groups[group_id].add((full_pdbid, is_rep))\n else:\n groups[group_id] = set(((full_pdbid, is_rep), ))\n \n # \n # \n # # add or update the set of chains\n # if full_pdbid in nrpdbs:\n # nrpdbs[full_pdbid].add((chain, is_rep))\n # else:\n # nrpdbs[full_pdbid] = set(((chain, is_rep), ))\n\n except ValueError:\n logger.warning('Incorrectly formatted NRPDB line ' + line)\n \n # now for each group, we want to add a mapping for each pdb:chain to its rep\n \n for group_id in groups.keys():\n \n redundant_entries = set()\n for nrpdb_entry in groups[group_id]:\n if nrpdb_entry[1]:\n rep = nrpdb_entry[0]\n redundant_entries.add(rep)\n else:\n redundant_entries.add(nrpdb_entry[0])\n \n for redundant_entry in redundant_entries:\n nrpdbs[redundant_entry] = rep\n \n return nrpdbs","def get_yago_medical_relation(path):\n return open(path,\"r\").readlines()","def read_geneset_file():\n geneset_dict = {}\n with open(GENESET_FILENAME) as geneset_file:\n lines = geneset_file.readlines()\n i = 0\n for l in lines:\n i += 1\n entries = l.split()\n geneset_name = entries[0]\n geneset = set(entries[2:])\n geneset_dict[geneset_name] = geneset\n\n return geneset_dict","def load_pokec_data(indirname):\n infilename = \"soc-pokec-relationships.txt.gz\"\n tmpdir = tempfile.mkdtemp()\n try:\n fin = gzip.open(os.path.join(indirname, infilename), 'rb')\n filename = os.path.join(tmpdir, \"soc-pokec-relationships.txt\")\n fout = open(filename, 'w')\n fout.write(fin.read())\n\tfout.close()\n G = snap.LoadEdgeList(snap.PNGraph, filename, 0, 1, '\\t')\n finally:\n cleanup_tmpdir(tmpdir)\n\n # https://snap.stanford.edu/data/soc-pokec-readme.txt\n # but 'user_id' column 0 used as dict key so not included here\n colnames = [ 'public', 'completion_percentage',\n 'gender', 'region', 'last_login', 'registration',\n 'AGE', 'body', 'I_am_working_in_field',\n 'spoken_languages', 'hobbies',\n 'I_most_enjoy_good_food', 'pets', 'body_type',\n 'my_eyesight', 'eye_color', 'hair_color',\n 'hair_type', 'completed_level_of_education',\n 'favourite_color', 'relation_to_smoking',\n 'relation_to_alcohol', 'sign_in_zodiac',\n 'on_pokec_i_am_looking_for', 'love_is_for_me',\n 'relation_to_casual_sex', 'my_partner_should_be',\n 'marital_status', 'children',\n 'relation_to_children', 'I_like_movies',\n 'I_like_watching_movie', 'I_like_music',\n 'I_mostly_like_listening_to_music',\n 'the_idea_of_good_evening',\n 'I_like_specialties_from_kitchen', 'fun',\n 'I_am_going_to_concerts', 'my_active_sports',\n 'my_passive_sports', 'profession', 'I_like_books',\n 'life_style', 'music', 'cars', 'politics',\n 'relationships', 'art_culture',\n 'hobbies_interests', 'science_technologies',\n 'computers_internet', 'education', 'sport',\n 'movies', 'travelling', 'health',\n 'companies_brands', 'more']\n profile_colnames = dict([(name, col) for (col, name) in enumerate(colnames)])\n profilepath = os.path.join(indirname, \"soc-pokec-profiles.txt.gz\")\n profiledata = [ (x[0], x[1:]) for x in csv.reader(gzip.open(profilepath, 'rb'), delimiter='\\t') ]\n profiledict = dict([(int(x[0]), x[1]) for x in profiledata])\n assert(G.GetNodes() == len(profiledict))\n return (G, profiledict, profile_colnames)","def draw_relationships(file_contents, emph=list(), ignore=[\"key_id_org\"],\n title=\"\", font_size=14.0, width=16.54, height=11.69):\n if len(emph) > len(misc.BREWER_SET1):\n raise PyOrganismError(\"number of objects to be emphasized ({0:d}) is\"\\\n \" greater than the number of colours available ({1:d})\",\n len(emph), len(misc.BREWER_SET1))\n pgv = misc.load_module(\"pygraphviz\")\n colour_choice = dict(itertools.izip(emph, misc.BREWER_SET1))\n graph = pgv.AGraph(name=\"RegulonDB File-Relationships\", strict=True,\n directed=False, rankdir=\"TB\")\n graph.graph_attr[\"labelloc\"] = \"t\"\n graph.graph_attr[\"label\"] = title\n graph.graph_attr[\"fontsize\"] = font_size * 1.5\n graph.graph_attr[\"ranksep\"] = \"0.1 equally\"\n graph.graph_attr[\"size\"] = (width, height)\n graph.graph_attr[\"ratio\"] = \"compress\"\n graph.node_attr[\"shape\"] = \"none\"\n graph.node_attr[\"fontsize\"] = font_size\n for (name, attrs) in file_contents.iteritems():\n label = [\"<<TABLE BORDER=\\\"0\\\" CELLBORDER=\\\"1\\\" CELLSPACING=\\\"0\\\"\"\\\n \" CELLPADDING=\\\"4\\\">\"]\n label.append(\"<TR><TD BGCOLOR=\\\"#A4A4A4\\\"><B>{0}</B></TD></TR>\".format(name))\n for (i, attr) in enumerate(attrs):\n if attr in emph:\n label.append(\"<TR><TD PORT=\\\"f{0:d}\\\" BGCOLOR=\\\"{1}\\\">{2}</TD></TR>\".format(i,\n colour_choice[attr], attr))\n else:\n label.append(\"<TR><TD PORT=\\\"f{0:d}\\\">{1}</TD></TR>\".format(i,\n attr))\n label.append(\"</TABLE>>\")\n graph.add_node(name, label=\"\\n\".join(label))\n nodes = file_contents.keys()\n for i in range(len(nodes) - 1):\n node_u = nodes[i]\n attr_u = file_contents[node_u]\n for j in range(i + 1, len(nodes)):\n node_v = nodes[j]\n attr_v = file_contents[node_v]\n shared = set(attr_u).intersection(set(attr_v))\n for attr in shared:\n if attr in ignore:\n continue\n u = attr_u.index(attr)\n v = attr_v.index(attr)\n if attr in emph:\n graph.add_edge(node_u, node_v,\n tailport=\"f{0:d}\".format(u), headport=\"f{0:d}\".format(v),\n color=colour_choice[attr])\n else:\n graph.add_edge(node_u, node_v,\n tailport=\"f{0:d}\".format(u), headport=\"f{0:d}\".format(v))\n sub_attr = dict()\n nodes = graph.nodes()\n nodes.sort(key=lambda n: graph.degree(n))\n maxi = nodes[-1: -len(nodes) / 4]\n nodes = nodes[:-len(nodes) / 4]\n zeros = [node for (node, deg) in graph.degree_iter() if deg == 0]\n for n in zeros:\n nodes.remove(n)\n graph.add_subgraph(maxi, name=\"input\", rank=\"source\", **sub_attr)\n graph.add_subgraph(nodes, name=\"middle\", **sub_attr)\n graph.add_subgraph(zeros, rank=\"sink\", **sub_attr)\n return graph","def get_genes_organisms(self):\n path = os.path.join(self.parent_path, \"genes_organisms.txt\")\n with open(path, \"w\") as f:\n f.write(\"Gene,Organisms\\n\")\n for gene in self.genes.keys():\n f.write(\"{},{}\".format(gene, \"/\".join(self.genes.get(gene).keys()) + \"\\n\"))","def read_gtf_file(gtf_file):\n genes = {}\n transcripts = {}\n exons = {}\n\n with open(gtf_file) as gtf:\n for line in gtf:\n line = line.strip()\n\n # Ignore header\n if line.startswith(\"#\"):\n continue\n\n # Split into constitutive fields on tab\n tab_fields = line.split(\"\\t\")\n chrom = tab_fields[0]\n entry_type = tab_fields[2]\n\n # Entry is a gene\n if entry_type == \"gene\":\n gene = Gene.get_gene_from_gtf(tab_fields)\n native_id = gene.identifier\n genes[native_id] = gene\n\n # Entry is a transcript\n elif entry_type == \"transcript\":\n transcript = Transcript.get_transcript_from_gtf(tab_fields)\n gene_id = transcript.gene_id\n if gene_id in genes:\n genes[gene_id].add_transcript(transcript)\n native_id = transcript.identifier\n transcripts[native_id] = transcript\n \n # Entry is an edge\n elif entry_type == \"exon\":\n exon = Edge.create_edge_from_gtf(tab_fields)\n # This ID is used because of a rare GENCODE bug\n location_exon_id = exon.identifier\n exons[location_exon_id] = exon \n\n transcript_id = list(exon.transcript_ids)[0]\n gene_id = exon.annotations[\"gene_id\"]\n \n if location_exon_id not in exons:\n # Add the new edge to the data structure\n exons[location_exon_id] = exon\n else:\n # Update existing exon entry, including its transcript set\n exon = exons[location_exon_id]\n exon.transcript_ids.add(transcript_id)\n \n if transcript_id in transcripts: \n currTranscript = transcripts[transcript_id]\n currTranscript.add_exon(exon)\n\n return genes, transcripts, exons","def read_cDNA_file_to_dict(filename):\n \n #initialize dictionary\n cDNA_dictionary = {}\n\n #open file\n with open(cDNA_file) as f:\n \n #loop through file line by line\n for line in f:\n\n #remove newline\n line = line.rstrip()\n \n #get gene name\n if line.startswith(\">\"):#If the line starts with the character \">\" then,\n gene_name = line.split(\"|\")[1]#I separate the line by the character \"|\" and assign index 1 to gene_name\n \n #read in sequence in uppercase\n if not line.startswith(\">\"):#If the line does not start with the character \">\" then,\n line = line.upper()#I make all of the characters within the line uppercase\n\n #put name and sequence in dictionary\n cDNA_dictionary[gene_name] = line#I assign the gene_name as the key and the line (sequence) as the value\n\n #return dictionary \n return cDNA_dictionary","def parse_data(self, path_to_file):\n\n line_dict, rel_dict = self.create_dicts(path_to_file)\n \n line_df = self.create_dataframe(line_dict, ['line'])\n rel_df = self.create_dataframe(rel_dict, ['relation'])\n\n line_df['relation'] = rel_df['relation']\n\n return (line_df, rel_df)","def parse_data(path_to_file):\n\n line_dict, rel_dict = create_dicts(path_to_file)\n \n line_df = create_dataframe(line_dict, ['line'])\n rel_df = create_dataframe(rel_dict, ['relation'])\n\n line_df['relation'] = rel_df['relation']\n\n return (line_df, rel_df)","def read_relationships(person_id):\n try:\n conn = sqlite3.connect(settings.database_name)\n conn.row_factory = sqlite3.Row\n c = conn.cursor()\n c.execute(\"PRAGMA foreign_keys = ON\")\n c.execute(relationship_query, (person_id,)) # note a tuple is needed as a parameter value for SQLITE\n\n relation_list = []\n for row in c:\n _relation = Relationship()\n _relation.person_id = row[\"personid\"]\n _relation.person.first_name = row[\"firstname\"]\n _relation.person.last_name = row[\"lastname\"]\n _relation.person.middle_initial = row[\"middleinitial\"]\n _relation.related_person_id = row[\"related_personid\"]\n _relation.relationship_id = row[\"relationshipid\"]\n _relation.relationship_type = row[\"relationshiptype\"]\n _relation.relationship_type_description = row[\"key\"]\n relation_list.append(_relation)\n conn.close()\n return relation_list\n except:\n return []","def load_data(filename):\n data = dict()\n with open(filename) as f:\n reader = csv.DictReader(f)\n for row in reader:\n name = row[\"name\"]\n data[name] = {\n \"name\": name,\n \"mother\": row[\"mother\"] or None,\n \"father\": row[\"father\"] or None,\n \"trait\": (True if row[\"trait\"] == \"1\" else\n False if row[\"trait\"] == \"0\" else None)\n }\n return data","def read_graph(filename):\n return nx.read_edgelist(filename, create_using=nx.DiGraph(), nodetype=str)","def load_data() -> Tuple[Dict, Dict]:\n\n female_dict, male_dict = dict(), dict()\n\n for dfile, g_dict in zip(\n ['data/female.txt', 'data/male.txt'],\n [female_dict, male_dict]):\n\n with open(dfile, 'r') as fh:\n\n for line in fh:\n splits = line.split()\n country = splits[0]\n g_dict[country] = set(splits[1:])\n\n return female_dict, male_dict","def load_data(filename):\n data = dict()\n with open(filename) as f:\n reader = csv.DictReader(f)\n for row in reader:\n name = row[\"name\"]\n data[name] = {\n \"name\": name,\n \"mother\": row[\"mother\"],\n \"father\": row[\"father\"],\n \"trait\": (True if row[\"trait\"] == \"1\" else\n False if row[\"trait\"] == \"0\" else None)\n }\n return data","def load_gene_ontology(self, file_path):\n\t\tpass","def read_fixtures(filename):\n fixtures = []\n f = open(filename, 'r')\n routes = {}\n for line in f:\n parsed = parse_fixture_line(line)\n if parsed is None:\n continue\n strand = parsed[\"strand\"]\n address = parsed[\"address\"]\n panel_number = parsed[\"panel_number\"]\n x, y = parsed[\"grid_loc\"]\n pos1 = map_grid_loc_to_pixel((panel_number, x, y),\n panel_dimensions = langton_panel_dimensions)\n pixels = 1\n route_indices = parsed[\"routes\"]\n data = {\"strand\": strand,\n \"address\": address,\n \"pixels\": pixels,\n \"pos1\": pos1,\n \"pos2\": pos1,\n \"grid_loc\": (x, y)}\n fixtures.append(Fixture(data))\n for route_index in route_indices:\n if route_index in routes:\n routes[route_index].fixtures.append(data)\n else:\n routes[route_index] = Route({\"active\": False,\n \"color\": (1, 0, 0),\n \"fixtures\": [data],\n \"index\": route_index})\n f.close()\n return routes, fixtures","def read_graph():\n return nx.read_edgelist('edges_new.txt', delimiter='\\t')","def read_all():\n # Create the list of people from our data\n return [PEOPLE[key] for key in sorted(PEOPLE.keys())]","def _read_facts(fact_file, relation_embeddings, question_embedding,\n seeds, qId):\n seeds_found = set()\n with open(fact_file) as f:\n entity_map = {}\n relation_map = {}\n all_row_ones, all_col_ones = [], []\n num_entities = 0\n num_facts = 0\n for line in f:\n try:\n e1, rel, e2 = line.strip().split(None, 2)\n except ValueError:\n continue\n if _filter_relation(rel): continue\n if e1 not in entity_map:\n entity_map[e1] = num_entities\n num_entities += 1\n if e2 not in entity_map:\n entity_map[e2] = num_entities\n num_entities += 1\n if rel not in relation_map:\n relation_map[rel] = [[], []]\n if e1 in seeds: seeds_found.add(e1)\n if e2 in seeds: seeds_found.add(e2)\n all_row_ones.append(entity_map[e1])\n all_col_ones.append(entity_map[e2])\n all_row_ones.append(entity_map[e2])\n all_col_ones.append(entity_map[e1])\n relation_map[rel][0].append(entity_map[e1])\n relation_map[rel][1].append(entity_map[e2])\n num_facts += 1\n if num_facts == MAX_FACTS:\n break\n if not relation_map:\n return {}, {}, None\n for rel in relation_map:\n row_ones, col_ones = relation_map[rel]\n m = csr_matrix(\n (np.ones((len(row_ones),)), (np.array(row_ones), np.array(col_ones))),\n shape=(num_entities, num_entities))\n relation_map[rel] = normalize(m, norm=\"l1\", axis=1)\n if RELATION_WEIGHTING:\n if rel not in relation_embeddings:\n score = NOTFOUNDSCORE\n else:\n score = np.dot(question_embedding, relation_embeddings[rel]) / (\n np.linalg.norm(question_embedding) *\n np.linalg.norm(relation_embeddings[rel]))\n relation_map[rel] = relation_map[rel] * np.power(score, EXPONENT)\n if DECOMPOSE_PPV:\n adj_mat = sum(relation_map.values()) / len(relation_map)\n else:\n adj_mat = csr_matrix(\n (np.ones((len(all_row_ones),)), (np.array(all_row_ones), np.array(all_col_ones))),\n shape=(num_entities, num_entities))\n return entity_map, relation_map, normalize(adj_mat, norm=\"l1\", axis=1)","def read_graph():\n return nx.read_edgelist('edges.txt.gz', delimiter='\\t')","def read(self, taxonomy_file, use_canonical_gid=False):\n\n check_file_exists(taxonomy_file)\n\n try:\n d = {}\n for row, line in enumerate(open(taxonomy_file)):\n line_split = line.split('\\t')\n unique_id = line_split[0]\n\n if use_canonical_gid:\n unique_id = canonical_gid(unique_id)\n\n tax_str = line_split[1].rstrip()\n if tax_str[-1] == ';':\n # remove trailing semicolons which sometimes\n # appear in Greengenes-style taxonomy files\n tax_str = tax_str[0:-1]\n\n d[unique_id] = [x.strip() for x in tax_str.split(';')]\n except:\n self.logger.error('Failed to parse taxonomy file on line %d' % (row + 1))\n raise\n\n return d","def xml_to_dict(path):\n with open(path) as xml_file:\n data_dict = xmltodict.parse(xml_file.read())\n xml_file.close()\n if isinstance(data_dict[\"Relationships\"][\"Relationship\"], list):\n data = sorted(data_dict[\"Relationships\"][\"Relationship\"], key=lambda item: int(item['@Id'].split('Id')[1]))\n else:\n data = [data_dict[\"Relationships\"][\"Relationship\"]]\n return data","def load_nodes(filename):\n\n with open(filename) as f:\n reader = csv.DictReader(f)\n return [item for item in reader]","def deserialize(self, filename):\n f = open(filename)\n edges_tails = []\n nodes = []\n # first pass adds incoming edges to nodes\n for line in f:\n if '->' in line: # edge\n edge = self.edge_class()\n tail_ids, head_id = edge.deserialize(line)\n nodes[head_id].add_incoming(edge)\n edges_tails.append((edge, tail_ids))\n else: # node\n node = self.node_class()\n node.deserialize(line)\n assert node.id == len(nodes), 'nodes shall appear in order'\n nodes.append(node)\n # second pass adds tail nodes to edges\n for edge, tail_ids in edges_tails:\n for nid in tail_ids:\n edge.add_tail(nodes[nid])\n f.close()\n # make a toposorted hypergraph\n hg = Hypergraph(nodes[0])\n hg.nodes = nodes\n for node in hg:\n node.hg = hg\n for edge in hg.edges():\n edge.hg = hg\n hg.tasks_done.add('topo_sort')\n return hg","def load_people(self, file_path):\n pass","def person_list(self):\n self.__load_persons_from_file_into_memory()\n return self._person_list","def map_protein_to_go(filename):\n\n try:\n with open(filename) as go_association_file:\n go_association = go_association_file.read()\n split_go_association = re.split(r\"\\n\", go_association)\n\n # Ignore the general file information, which is the line starting\n # with \"!\"\".\n go_association_info = []\n for line in split_go_association:\n if line and not line.startswith(\"!\"):\n go_association_info.append(line)\n\n # Declare the tuple to parse the protein and go term as a pair and\n # store it in the set to avoid duplicate situation\n go_protein_dict = {}\n for column in go_association_info:\n column_info = re.split(r\"\\t\", column)\n protein_id = column_info[1]\n go_term = column_info[4]\n\n if protein_id in go_protein_dict:\n go_protein_dict[protein_id].add(go_term)\n else:\n go_protein_dict[protein_id] = {go_term}\n return go_protein_dict\n\n except FileNotFoundError:\n return {}","def readAdjacencyGraph(self,filename):\n try:\n for line in open(filename,'r'):\n incoming,outgoing=line.strip().split(\":\")\n no_outgoing=outgoing.split(\",\")\n self.adjacencyMetadata[incoming]=dict(zip(no_outgoing,range(len(no_outgoing))))\n if incoming not in self.adjacency.keys():\n self.adjacency[incoming]=None\n for item in no_outgoing:\n if item not in self.adjacency.keys():\n self.adjacency[item]=None\n except Exception as e:\n raise","def readGraphFromYAMLFile(self, filename):\n self.G = nx.read_yaml(filename)\n # TODO: buiild up the indexes !!!","def parse(records):\n # Collect all people.\n people = {}\n for record in records:\n if record.rec_type == \"INDI\":\n assert record.rec_id not in people\n people[record.rec_id] = Person(record)\n # Link parents and children.\n for record in records:\n if record.rec_type == \"FAM\":\n # For this \"family unit\" collect all parents and all children.\n parents = []\n children = []\n for sub_rec in record.sub_recs:\n if sub_rec.rec_type in (\"HUSB\", \"WIFE\"):\n parents.append(sub_rec.data)\n elif sub_rec.rec_type == \"CHIL\":\n children.append(sub_rec.data)\n # Ignore MARR, DATE, PLAC, ...\n # Add parent/child relationships.\n for child_id in children:\n child = people[child_id]\n for parent_id in parents:\n parent = people[parent_id]\n child.parents.append(parent)\n parent.children.append(child)\n return people","def read_file(filename):\n population_list = []\n line_counter = 0\n number_of_columns = 0\n for line in filename:\n line = line.split()\n if line_counter == 0:\n number_of_columns = len(line) #Seeing how long the original line is so if there are more than one words in the state name I can put them together when the time comes\n line_counter += 1\n population_list.append(line)\n else:\n length_check = len(line) - number_of_columns #Checking the length of the other lines \n # If the next line is the same length as the previous one nothing happens but if it's longer you put the first two together\n us_state = \" \".join(line[0:1 + length_check])\n state = [us_state] #creates a list with just the state\n#makes a list of all elements in the line other than the state so if the state has two names we can account for it\n population = [int(elements) for elements in line[length_check + 1:]] \n state.extend(population) # puts together the state and all other elements into one list \n population_list.append(state) #here is the list of all the other lists we made\n return population_list","def load_org_meeting_file():\n nodelist = orgnode.makelist(MEETINGS_ORG_FILE)\n return nodelist","def get_organisms_genes(self):\n path = os.path.join(self.parent_path, \"organisms_genes.txt\")\n with open(path, \"w\") as freqs:\n freqs.write(\"Organism,Genes\\n\")\n for org, data in self.organisms.items():\n genes = \"\"\n for gene in data.get(self.GENE_IDS_KEY):\n genes = genes + \"{} \".format(gene[self.GENE_NAME_IDX])\n freqs.write(\"{},{}\\n\".format(org, genes))","def load_gene_dict(reference_genbank_name=\"data/covid-19-genbank.gb\"):\n recs = [rec for rec in SeqIO.parse(reference_genbank_name, \"genbank\")]\n gene_dict = {}\n for rec in recs:\n feats = [feat for feat in rec.features if feat.type == \"CDS\"]\n for feat in feats:\n content = '{}: {}'.format(feat.qualifiers['protein_id'][0], feat.qualifiers['product'][0])\n if feat.qualifiers['product'][0] == 'ORF1a polyprotein':\n continue\n if feat.location_operator == 'join':\n for item in feat.location.parts:\n key = (item.start.position, item.end.position)\n if 'translation' in feat.qualifiers:\n seq = feat.qualifiers['translation']\n if len(seq) == 1:\n amino_acid_seq = seq[0]\n gene_dict[key] = (content, amino_acid_seq)\n else:\n key = (feat.location.start.position, feat.location.end.position)\n if 'translation' in feat.qualifiers:\n seq = feat.qualifiers['translation']\n if len(seq) == 1:\n amino_acid_seq = seq[0]\n gene_dict[key] = (content, amino_acid_seq)\n return gene_dict","def load_all_data_from_file(self) -> None:\n self.load_gene_data_from_file()\n self.load_ontology_from_file(ontology_type=DataType.GO, ontology_url=self.go_ontology_url,\n ontology_cache_path=self.go_ontology_cache_path,\n config=self.config)\n self.load_associations_from_file(associations_type=DataType.GO, associations_url=self.go_associations_url,\n associations_cache_path=self.go_associations_cache_path, config=self.config)\n self.load_ontology_from_file(ontology_type=DataType.DO, ontology_url=self.do_ontology_url,\n ontology_cache_path=self.do_ontology_cache_path, config=self.config)\n self.load_associations_from_file(associations_type=DataType.DO, associations_url=self.do_associations_url,\n associations_cache_path=self.do_associations_cache_path,\n association_additional_cache_path=self.do_associations_new_cache_path,\n association_additional_url=self.do_associations_new_url, config=self.config)\n self.load_ontology_from_file(ontology_type=DataType.EXPR, ontology_url=self.expression_ontology_url,\n ontology_cache_path=self.expression_ontology_cache_path, config=self.config)\n self.load_associations_from_file(associations_type=DataType.EXPR,\n associations_url=self.expression_associations_url,\n associations_cache_path=self.expression_associations_cache_path,\n config=self.config)\n self.load_orthology_from_file()\n self.load_expression_cluster_data()\n self.load_protein_domain_information()","def read_file(filename):\n with open(filename, 'r') as file:\n # Read the first line containing number of\n # beds and persons\n amount_persons = int(file.readline())\n size_persons1 = int(file.readline())\n size_beds1 = int(file.readline())\n size_persons2 = amount_persons - size_persons1\n size_beds2 = amount_persons - size_beds1\n\n lines = file.readlines()\n\n # Create a list of first set of Person objects storing their\n # x,y coordinates and names\n persons_set1 = lines[:size_persons1]\n persons_set1 = list(map((lambda x: (Person(x.split()[0], float(x.split()[1]), float(x.split()[2])))),\n persons_set1))\n\n # Create a list of first set of Bed objects storing their\n # x,y coordinates and names\n beds_set1 = lines[size_persons1:size_persons1+size_beds1]\n beds_set1 = list(map((lambda x: (Bed(x.split()[0], float(x.split()[1]), float(x.split()[2]), int(x.split()[3])\n ))), beds_set1))\n\n # Create a list of second set of Person objects storing their\n # x,y coordinates and names\n persons_set2 = lines[size_persons1+size_beds1:size_persons1+size_beds1+size_persons2]\n persons_set2 = list(map((lambda x: (Person(x.split()[0], float(x.split()[1]), float(x.split()[2])))),\n persons_set2))\n\n # Create a list of second set of Bed objects storing their\n # x,y coordinates and names\n beds_set2 = lines[size_persons1+size_beds1+size_persons2:size_persons1+size_beds1+size_persons2+size_beds2]\n beds_set2 = list(map((lambda x: (Bed(x.split()[0], float(x.split()[1]), float(x.split()[2]), int(x.split()[3])\n ))), beds_set2))\n\n return persons_set1, beds_set1, persons_set2, beds_set2","def open_overlapping(self, filename):\n\n with open(filename) as overlap:\n overlap_reader = csv.DictReader(overlap)\n\n\n overlap_dict = {}\n dubbels = []\n\n for row in overlap_reader:\n course = row['0']\n for i in row:\n dubbels.append(row[i])\n overlap_dict[course] = dubbels\n dubbels = []\n\n return overlap_dict","def load_profiles(profiles_file: TextIO) -> Tuple[Dict[str, List[str]],\n Dict[str, List[str]]]:\n individuals = [[]]\n sublist = 0\n content = profiles_file.readlines()\n for i in content:\n if i != '\\n':\n individuals[sublist].append(i)\n else:\n sublist += 1\n individuals.append([])\n return sort_profile(individuals)","def _read_population_data(self, dates, population, change_dict=None):\n change_dict = dict() if change_dict is None else change_dict.copy()\n return {\n date: change_dict[date] if date in change_dict.keys(\n ) else population\n for date in dates\n }","def _read_netgen(self, file):\n\n with open(file, 'r') as f:\n\n aid = 0 # current arc ID\n\n # Read the file line-by-line\n for line in f:\n\n # Decide what to do based on the line prefix\n\n # Comment line\n if line[0] == 'c':\n # Skip\n continue\n\n # Problem info\n elif line[0] == 'p':\n # p sense #nodes #arcs #int int_type #defenses #attacks\n # We always assume that the sense is minimization\n\n ls = line.split()\n if ls[5] == 'n':\n self.parent_type = 0\n self.def_limit = int(ls[6])\n self.att_limit = int(ls[7])\n\n # Initialize all nodes as transshipment (in case the NETGEN\n # file lists only nonzero supply values)\n self.nodes = [_Node(i, 0.0) for i in range(int(ls[2]))]\n\n # Node\n elif line[0] == 'n':\n # n ID supply\n\n # All nodes have already been defined, so update existing\n # supply values\n\n ls = line.split()\n self.nodes[int(ls[1])-1].supply = float(ls[2])\n\n # Arc\n elif line[0] == 'a':\n # a tail head LB UB cost\n\n ls = line.split()\n tail = self.nodes[int(ls[1])-1]\n head = self.nodes[int(ls[2])-1]\n if (int(ls[2]) == 0) and (self.parent_type == 0):\n head = None\n\n self.arcs.append(_Arc(aid, tail, head, float(ls[4]),\n float(ls[5])))\n aid += 1\n\n # Interdependency\n elif line[0] == 'i':\n # i parent child\n\n ### We assume for now that arcs are parents.\n\n ls = line.split()\n self.int.append((self.arcs[int(ls[1])-1],\n self.arcs[int(ls[2])-1]))\n\n # Defensible arc\n elif line[0] == 'd':\n # d arc\n\n ls = line.split()\n self.def_arcs.append(self.arcs[int(ls[1])-1])\n\n # All defensible arcs are assumed to be destructible\n self.att_arcs.append(self.arcs[int(ls[1])-1])\n\n # Destructible arc\n elif line[0] == 'r':\n # r arc\n\n ls = line.split()\n self.att_arcs.append(self.arcs[int(ls[1])-1])\n\n # If no defensible or destructible arcs were listed, we assume that\n # all arcs are available\n\n if len(self.def_arcs) == 0:\n self.def_arcs[:] = self.arcs[:]\n\n if len(self.att_arcs) == 0:\n self.att_arcs[:] = self.def_arcs[:]","def ler(self) -> Iterable[Dict[str, str]]:\n with open(self.arquivo) as f:\n for linha in DictReader(f, dialect=self.DialetoCsv):\n yield linha","def GenomeReader(GenomeFile):\n GenomeScaffolds = {}\n key = []\n with open(GenomeFile, 'r') as f:\n for line in f:\n line = line.strip()\n if line.startswith(\">\"):\n NamedSeq = line.replace('>', '')\n key.append(NamedSeq)\n GenomeScaffolds[NamedSeq] = \"\"\n else:\n GenomeScaffolds[NamedSeq] += line\n return GenomeScaffolds # Returns a Dictionary object","def load_rooms(self, filename):\n with open(filename, \"r\") as f:\n roomss = []\n for line in f:\n line = line.strip()\n\n # Add id, name and description to each room object\n if line.isdigit():\n id = line\n line = f.readline()\n line = line.strip()\n name = line\n line = f.readline()\n line = line.strip()\n description = line\n room = Room(id, name, description)\n roomss.append(room)\n\n # Add the connected routes to the room\n elif line.isupper():\n line = line.split()\n direction = line[0]\n room_number = line[1]\n\n # Add multiple routes to a direction if needed\n if not direction in roomss[-1].connection:\n roomss[-1].connection[direction] = [room_number]\n else:\n roomss[-1].connection[direction].append(room_number)\n return roomss","def readNetwork(filename):\r\n\r\n fileIn = open(filename, 'r')\r\n\r\n outputList = []\r\n network = []\r\n\r\n for line in fileIn:\r\n #Placing each individual parameter of the line into a list\r\n lineList = line.replace(\"\\n\",\"\").split(\", \")\r\n #Extracting the list of direct contacts from the lineList\r\n directList = lineList[3:-2]\r\n #Deleting the copy of the direct contacts\r\n del lineList[3:-2]\r\n #Removing < and > from the direct contacts list\r\n for i in range(len(directList)):\r\n directList[i] = directList[i].strip(\"<>\")\r\n #Appending all the direct contacts to the end of the list\r\n lineList.append(directList)\r\n outputList.append(lineList)\r\n \r\n fileIn.close()\r\n\r\n for parameters in outputList:\r\n #Creating a Person object from the parameters given by each line\r\n person = Person(parameters)\r\n #Appending each Person object to the network list\r\n network.append(person)\r\n \r\n return network","def processFile(filename):\n geneDict = {}\n pat = re.compile(r'gene_index (\\d+)')\n gf = open(filename)\n for line in gf:\n line = line.strip()\n if line.startswith('#'):\n continue\n t = line.split('\\t')\n if len(t) != 9 and len(t) !=8:\n continue\n if t[2] not in ['CDS', 'UTR']:\n continue\n s = t[8].split(';')\n m = re.search(pat, s[1])\n if m is None:\n raise RuntimeError('bad regex, unable to pull out gene index for line %s' % line)\n geneIndex = m.group(1)\n if geneIndex not in geneDict:\n g = Gene()\n geneDict[geneIndex] = g\n else:\n g = geneDict[geneIndex]\n if t[2] == 'CDS':\n g.numCds += 1\n elif t[2] == 'UTR':\n g.numUtr += 1\n if g.left > int(t[3]):\n g.left = int(t[3])\n g.updateLength()\n if g.right < int(t[4]):\n g.right = int(t[4])\n g.updateLength()\n return geneDict","def load(filename):\n\n owners = []\n\n address_manager = REGISTRY['address_manager']\n error_manager = REGISTRY['error_manager']\n\n reader = csv.reader(open(filename, 'rU'))\n try:\n headers = reader.next() # Text column headers\n except StopIteration:\n syslog.syslog('merge.py: Empty file %s' % filename)\n return owners\n\n if len(headers) != 11:\n raise InvalidInput('Property Owners file should have ' +\n 'exactly 11 columns. Found %d.' % len(headers))\n\n for line in reader:\n property_owner = PropertyOwner(line)\n if address_manager.is_in_strathcona(property_owner.civic):\n owners.append(property_owner)\n else:\n error_manager.add(property_owner, \n 'Not in Strathcona or invalid address')\n\n owners.sort(key=operator.attrgetter('folio'))\n\n return owners","def parseGrammarFile(fname):\n\n # if anything goes wrong, skip the rest of the block\n # to know more, search for 'python exception handling'\n try:\n fp = open(fname, 'r')\n\n g = {\n 'terms': [], # list of terminals\n 'rnames': [], # list of variables\n 'start': \"\", # starting symbol\n 'rules': {}, # rnames and their lists of productions\n }\n\n g['terms'] = parseTerms(fp)\n g['rnames'] = parseVars(fp)\n g['start'] = parseStart(fp)\n g['rules'] = parseRules(fp)\n\n fp.close()\n return g\n\n # re-raise to __main__\n except:\n raise","def load_gene_data_from_file(self) -> None:\n logger.info(\"Loading genes data from file\")\n if not self.gene_data or len(self.gene_data.items()) == 0:\n self.gene_data = {}\n file_path = self._get_cached_file(cache_path=self.gene_data_cache_path, file_source_url=self.gene_data_url)\n with open(file_path) as file:\n for line in file:\n fields = line.strip().split(',')\n if fields[1].startswith(\"WBGene\"):\n name = fields[2] if fields[2] != '' else fields[3]\n self.gene_data[\"WB:\" + fields[1]] = Gene(\"WB:\" + fields[1], name, fields[4] == \"Dead\", False)","def extract_edges(self,fn):\n new_edges = {}\n with open (fn,'r') as f:\n for line in f:\n new_edges = EdgeParser.line_to_edges(self,line,new_edges)\n return new_edges","def read_file(filepath: str) -> dict:\n if not filepath.endswith(\".csv\"):\n raise RuntimeError(\"File extension must be .csv\")\n\n people = {}\n with open(filepath) as csv:\n for line in csv:\n email, person = Parser.parse_line(line.rstrip(\"\\n\"))\n if email not in people:\n people[email] = person\n else:\n print(\"Ignoring person with duplicate email {}\".format(email))\n return people","def readBridgesFromFile(fileName):\n bridgeDict = { \"NEW\": [], \"RUNNING\": [], \"OLD\": [] } \n \n if not os.path.isfile(fileName):\n print >>sys.stderr, \"Not a file: %s\" % fileName\n return bridgeDict\n\n r = re.compile('[ \\t\\n]+')\n try:\n f = open(fileName, 'r')\n for line in f:\n s = r.split(line)\n status = s[3]\n bridge = BridgeData(s[0], s[1], s[2], status = status)\n bridgeDict[status].append(bridge)\n f.close()\n except IOError:\n print >>sys.stderr, \"IOError while reading %s\" % fileName\n\n return bridgeDict","def read_population_assignation_cp(namefile):\n db = shelve.open(namefile)\n cps = db['cps']\n population_value = db['population_value']\n methodvalues = db['methodvalues']\n db.close()\n return cps, population_value, methodvalues","def read_gene_families(gftxt, protfile = None, cdsfile = None, wrkdir = None):\n gene_families = []\n if protfile is None and cdsfile is None:\n logging.info(\"Gene families need to have sequences!\")\n with open(gftxt, 'r') as f:\n for line in f:\n line = line.rstrip()\n x = line.split()\n gf_id = x.pop(0)[:-1]\n gf_genes = x\n gene_families.append(GeneFamily(gf_id=gf_id, gf_members=gf_genes))\n return gene_families\n \n if protfile is not None:\n prot = SeqIO.to_dict(SeqIO.parse(protfile, \"fasta\"))\n\n if cdsfile is not None:\n cds = SeqIO.to_dict(SeqIO.parse(cdsfile, \"fasta\"))\n \n with open(gftxt, 'r') as handle:\n for line in handle:\n line = line.rstrip()\n x = line.split()\n gf_id = x.pop(0)[:-1]\n gf_genes = x\n gf_prot = {}\n gf_cds = {}\n for gid in x:\n if prot[gid][-1:].seq == '*':\n gf_prot[gid] = prot[gid][:-1]\n else:\n gf_prot[gid] =prot[gid]\n if cds[gid][-3:].seq == \"TAA\" or \\\n cds[gid][-3:].seq == \"TAG\" or \\\n cds[gid][-3:].seq == \"TGA\":\n gf_cds[gid] = cds[gid][:-3]\n else:\n gf_cds[gid] = cds[gid]\n gene_families.append(GeneFamily(gf_id = gf_id, gf_members = gf_genes, \n prot_seqs = gf_prot, cds_seqs = gf_cds, wrkdir=wrkdir))\n return gene_families","def read_graph(filename, directed=True):\n if not directed:\n G = nx.Graph()\n else:\n G = nx.DiGraph()\n with open(filename) as f:\n for line in f:\n d = line.split()\n G.add_edge(int(d[0]), int(d[1]))\n print('Read Graph')\n return G","def read(cls, fam_path, delimiter='\\\\s+') -> 'Pedigree':\n\n trios = []\n missing_sex_count = 0\n missing_sex_values = set()\n with Env.fs().open(fam_path) as file:\n for line in file:\n split_line = re.split(delimiter, line.strip())\n num_fields = len(split_line)\n if num_fields != 6:\n raise FatalError(\"Require 6 fields per line in .fam, but this line has {}: {}\".format(num_fields, line))\n (fam, kid, dad, mom, sex, _) = tuple(split_line)\n # 1 is male, 2 is female, 0 is unknown.\n is_female = sex == \"2\" if sex == \"1\" or sex == \"2\" else None\n\n if is_female is None:\n missing_sex_count += 1\n missing_sex_values.add(kid)\n\n trio = Trio(kid,\n fam if fam != \"0\" else None,\n dad if dad != \"0\" else None,\n mom if mom != \"0\" else None,\n is_female)\n trios.append(trio)\n\n only_ids = [trio.s for trio in trios]\n duplicate_ids = [id for id, count in Counter(only_ids).items() if count > 1]\n if duplicate_ids:\n raise FatalError(\"Invalid pedigree: found duplicate proband IDs\\n{}\".format(duplicate_ids))\n\n if missing_sex_count > 0:\n warning(\"Found {} samples with missing sex information (not 1 or 2).\\n Missing samples: [{}]\".format(missing_sex_count, missing_sex_values))\n\n return Pedigree(trios)","def load_rooms(self, filename):\n # First we parse all the data we need to create the rooms with.\n # All parsed lines of data are saved to rooms_data.\n rooms_data = []\n with open(filename, \"r\") as f:\n room_data = []\n for line in f:\n # When there is no blank newline it means there's still data.\n if not line == \"\\n\":\n room_data.append(line.strip())\n # A blank newline signals all data of a single room is parsed.\n else:\n rooms_data.append(room_data)\n room_data = []\n # Append a final time, because the files do not end on a blank newline.\n rooms_data.append(room_data)\n\n # Create room objects for each set of data we just parsed.\n rooms = {}\n for room_data in rooms_data:\n id = int(room_data[0])\n name = room_data[1]\n description = room_data[2]\n\n # Initialize a room object and put it in a dictionary with its\n # id as key.\n room = Room(id, name, description)\n rooms[id] = room\n\n # Add routes to each room we've created with the data from each set\n # we have parsed earlier.\n for room_data in rooms_data:\n id = int(room_data[0])\n # We split to connections into a direction and a room_id.\n connections = room_data[4:]\n connections = [connection.split() for connection in connections]\n # Here we get the current room object that we'll add routes to.\n room = rooms[id]\n for connection, target_room_id in connections:\n # TODO add routes to a room (hint: use the add route method)\n # split id and item\n idanditem = target_room_id.split('/', 1)\n if len(idanditem) < 2:\n room.add_route(connection, target_room_id)\n else:\n room.add_route(connection, idanditem[0], idanditem[1])\n rooms[id] = room\n\n return rooms","def read_isoforms(isoforms_file):\n gene_to_trans = defaultdict(list)\n f = open(isoforms_file, \"r\")\n for line in f:\n line_data = line.rstrip().split(\"\\t\")\n gene = line_data[GENE_INDEX_ISOF]\n trans = line_data[TRANSCRIPT_INDEX_IFOS]\n gene_to_trans[gene].append(trans)\n f.close()\n return gene_to_trans","def read_drugable_genes(mypath):\n drug = pd.read_csv('data/drugability/interactions.tsv', sep='\\t')\n drug_types = ['inhibitor', 'antagonist', 'blocker', 'channel blocker', 'gating inhibitor', 'negative modulator', 'channel blocker,gating inhibitor',\n 'allosteric modulator,antagonist', 'inhibitor allosteric modulator', 'suppressor', 'antagonist,inhibitor']\n drug = drug[drug.interaction_types.isin(drug_types)]\n cts = drug.groupby(['drug_name', 'interaction_claim_source'])['gene_name'].nunique().sort_values(ascending=True)\n single_drug_impact = cts[cts==1].copy().index.to_series().reset_index()['drug_name'].unique()\n drug = drug[drug['drug_name'].isin(single_drug_impact)].dropna(subset=['gene_name'])\n\n # create a table of gene 2 drug relationships\n gene2drug = drug.groupby('gene_name')['drug_name'].agg(lambda x: ','.join(list(set(x)))).reset_index()\n #gene_names = drug['gene_name'].unique()\n return gene2drug","def import_gene_assembly(infile):\n deserialized = None\n with open(infile, 'r') as file_handle:\n deserialized = json.load(file_handle, object_hook=decode_assembly)\n return deserialized","def __loadFromFile(self):\n try:\n f=open(self.__fileR, \"r\")\n line =f.readline().strip()\n rez=[]\n while line!=\"\":\n attrs=line.split(\",\")\n rt=Rent(attrs[0], attrs[1], attrs[2], attrs[3])\n rez.append(rt)\n line=f.readline().strip()\n f.close()\n return rez\n #the file cannot be reached\n except IOError:\n return None","def read_entities(input_dir: str) -> Tuple[\n Dict[str, Rider],\n Dict[str, Vehicle],\n Dict[str, Depot],\n Params\n]:\n\n riders_file = RIDERS_FILE.format(input_dir=input_dir)\n with open(riders_file) as f:\n logging.info(f'Read riders from {riders_file}.')\n riders_dicts = json.load(f)\n riders = {\n r_dict['rider_id']: Rider.from_dict(r_dict)\n for r_dict in riders_dicts\n }\n logging.info(f'Successfully parsed {len(riders)} riders.')\n\n vehicles_file = VEHICLES_FILE.format(input_dir=input_dir)\n with open(vehicles_file) as f:\n vehicles_dicts = json.load(f)\n logging.info(f'Read vehicles from {vehicles_file}.')\n vehicles = {\n v_dict['vehicle_id']: Vehicle.from_dict(v_dict)\n for v_dict in vehicles_dicts\n }\n logging.info(f'Successfully parsed {len(vehicles)} vehicles.')\n\n depots_file = DEPOTS_FILE.format(input_dir=input_dir)\n with open(depots_file) as f:\n depots_dicts = json.load(f)\n logging.info(f'Read depots from {depots_file}.')\n depots = {\n d_dict['depot_id']: Depot.from_dict(d_dict)\n for d_dict in depots_dicts\n }\n logging.info(f'Successfully parsed {len(depots)} depots.')\n\n params_file = PARAMS_FILE.format(input_dir=input_dir)\n with open(params_file) as f:\n logging.info(f'Read params from {params_file}.')\n params_dict = json.load(f)\n params = Params.from_dict(params_dict)\n logging.info(f'Successfully parsed {len(params_dict)} params.')\n\n return riders, vehicles, depots, params","def get_data_from_films_locations_file(path):\n film_locations_data = {}\n with open(path, encoding='utf-8', errors='ignore') as f:\n for line in f:\n line = line.strip()\n line_values = line.split(',')\n film, year, location = line_values[0], line_values[1],\\\n line_values[-1]\n if year in film_locations_data:\n if location not in film_locations_data[year]:\n film_locations_data[year][location] = {film}\n else:\n film_locations_data[year][location].add(film)\n else:\n film_locations_data[year] = {location: {film}}\n return film_locations_data","def read_file(filename):\n nodes = {}\n try:\n with open(filename, 'r') as f:\n for line in f:\n params = {}\n device_list = line.split()\n router = device_list[0]\n ip = device_list[1]\n platform = device_list[2]\n params[\"ipv4_address\"] = ip\n params[\"platform\"] = platform\n nodes[router] = params\n except IOError:\n print \"File %s does not exist!\" % filename\n return nodes","def add_graph_attributes(G, filename):\n Ef = dict() # feature -> edges\n Nf = dict() # node -> features\n with open(filename) as f:\n for line in f: # for each node, list of features it belongs to\n d = line.split()\n u = int(d[0])\n features = d[1:]\n for f in features:\n Ef.setdefault(f, []).extend(G.in_edges(u)) # add feature-dependent edges\n #G.node[u]['Fu'] = features\n G.nodes[u]['Fu'] = features\n Nf[u] = features\n print('Read graph attributes')\n return Ef, Nf","def _read_genome_location_file(self, file_path):\n self._logger.info('Reading genome location file')\n assert self.validate_file(file_path)\n dict_id_file_path = {}\n metadata_table = MetadataTable(logfile=self._logfile, verbose=self._verbose, separator=self._separator)\n iterator_distributions = metadata_table.parse_file(file_path, as_list=True)\n for genome_id, file_path_genome in iterator_distributions:\n assert genome_id != '', \"Invalid genomid: '{}'\".format(genome_id)\n assert file_path_genome != '', \"Invalid file path: '{}'\".format(genome_id)\n assert self.validate_file(file_path_genome), \"Invalid file path: '{}'\".format(genome_id)\n\n # check uniqueness\n assert genome_id not in dict_id_file_path, \"Genome '{}' not unique in the distribution file!\".format(genome_id)\n dict_id_file_path[genome_id] = file_path_genome\n return dict_id_file_path","def read_file(network_filename, user_by_city_filename=None):\n graph = read_dictlist_from_file(network_filename)\n\n gg = Graph(directed=False) # new Graph object\n\n user_id_map = {} # storing new id info\n new_id = 0\n for user_id in graph:\n temp_users = []\n temp_users.append(user_id)\n for friend in graph[user_id]:\n temp_users.append(friend)\n for id1 in temp_users:\n if id1 not in user_id_map:\n user_id_map[id1] = new_id\n gg.add_vertex() # index for this vertex will be new_id\n new_id += 1\n if id1 > user_id:\n gg.add_edge(gg.vertex(user_id_map[user_id]),\n gg.vertex(user_id_map[id1]))\n print \"Done reading the graph.\"\n if user_by_city_filename is None:\n return (gg, None)\n if user_by_city_filename is not None:\n cities = read_dict_from_file(user_by_city_filename)\n # Adding vertex property as city\n city_prop = gg.new_vertex_property(\"int\")\n for user_id in cities:\n city_prop[gg.vertex(user_id_map[user_id])] = cities[user_id]\n print \"Done reading the city.\"\n return (gg, city_prop)","def build_forest(sped_file_path, record_relations):\n forest = []\n tracker = {}\n\n with open(sped_file_path, encoding='latin-1') as f:\n for line in sped_iterator(f):\n node = SpedNode(line, [])\n tracker[node.record_type] = node\n\n parent_record_type = record_relations[node.record_type]\n\n parent = tracker.get(parent_record_type)\n\n if parent:\n parent.children.append(node)\n node.parent = parent\n else:\n forest.append(node)\n\n return forest","def process_file(self, data, filename):\n\n for relation in data:\n if \"start_date\" in relation[1]:\n start = convert_to_date(relation[1][\"start_date\"])\n end = convert_to_date(relation[1][\"end_date\"])\n\n if start <= START_DATE and end >= START_DATE:\n first = relation[1][\"first\"]\n second = relation[1][\"second\"]\n if first not in self.relations:\n self.add_tag(first)\n if second not in self.relations:\n self.add_tag(second)\n\n if relation[0] == \"vassal\": \n self.relations[first][\"vassal\"].append(second)\n self.relations[second][\"overlord\"].append(first)\n elif relation[0] == \"alliance\":\n self.relations[first][\"alliance\"].append(second)\n self.relations[second][\"alliance\"].append(first)\n elif relation[0] == \"dependency\":\n self.relations[first][\"tributary\"].append(second)\n self.relations[second][\"hegemon\"].append(first)\n elif relation[0] == \"guarantee\":\n self.relations[first][\"guaranteeing\"].append(second)\n self.relations[second][\"guarantor\"].append(first)\n elif relation[0] == \"union\":\n self.relations[first][\"junior\"].append(second)\n self.relations[second][\"senior\"].append(first)\n elif relation[0] == \"royal_marriage\":\n self.relations[first][\"marriage\"].append(second)\n self.relations[second][\"marriage\"].append(first)","def get_data(file_name, referents=False):\n with open(file_name, 'r') as file:\n data = file.readlines()\n data = [line.strip() for line in data if line != '1-----\\n' and line != '1-----']\n scene_mapping = utt_to_scene('gold_lexicon.txt')\n all_utterances = [e.split(\" \")[1:] for e in data[::2]]\n# print(all_utterances)\n scenes = []\n for utt in all_utterances:\n scene = [scene_mapping[word] for word in utt]\n if referents:\n scenes.append(scene)\n else:\n scene = list(itertools.chain.from_iterable(scene))\n scenes.append(scene)\n return all_utterances, scenes","def forges():\n\n forges = {}\n\n for forge_path in sorted(glob.glob(\"/opt/service/forge/*.yaml\")):\n if forge_path.split(\"/\")[-1] not in [\"fields.yaml\", \"values.yaml\"]:\n with open(forge_path, \"r\") as forge_file:\n forges[forge_path.split(\"/\")[-1].split(\".\")[0]] = yaml.safe_load(forge_file)[\"description\"]\n\n return forges","def load(self, filename: str = default_config_file):\n self.config_file.read(filename)\n\n # Population\n self.POPULATION_SIZE = self.config_file.getint('Population', 'POPULATION_SIZE')\n\n # Individuals characteristics\n self.IND_INP_NUMBER = self.config_file.getint('Individual', 'IND_INP_NUMBER')\n self.IND_OUT_NUMBER = self.config_file.getint('Individual', 'IND_OUT_NUMBER')\n self.IND_MAX_NODES = self.config_file.getint('Individual', 'IND_MAX_NODES')\n self.INITIAL_GENERATION = self.config_file.get('Individual', 'INITIAL_GENERATION')\n\n # Genes mutations\n self.ADD_GENE_PROB = self.config_file.getfloat('Mutations', 'ADD_GENE_PROB')\n self.MUT_GENE_PROB = self.config_file.getfloat('Mutations', 'MUT_GENE_PROB')\n self.REM_GENE_PROB = self.config_file.getfloat('Mutations', 'REM_GENE_PROB')\n\n self.ADD_NODE_PROB = self.config_file.getfloat('Mutations', 'ADD_NODE_PROB')\n self.REM_NODE_PROB = self.config_file.getfloat('Mutations', 'REM_NODE_PROB')\n\n self.MUT_GENE_AMP = self.config_file.getfloat('Mutations', 'MUT_GENE_AMP')\n self.WEIGHT_AMP = self.config_file.getfloat('Mutations', 'WEIGHT_AMP')\n\n self.GENE_PROB_FACT = self.config_file.getfloat('Mutations', 'GENE_PROB_FACT')\n self.NODE_PROB_FACT = self.config_file.getfloat('Mutations', 'NODE_PROB_FACT')\n self.AMP_MUT_FACT = self.config_file.getfloat('Mutations', 'AMP_MUT_FACT')\n\n # Elitism and extinction\n self.ELITISM_NUMBER = self.config_file.getint('Crossover', 'ELITISM_NUMBER')\n self.EXTINCTION_NUMBER = self.config_file.getint('Crossover', 'EXTINCTION_NUMBER')\n\n # Training conditions\n self.FITNESS_CRITERION = self.config_file.get('Training', 'FITNESS_CRITERION')\n self.FITNESS_THRESHOLD = self.config_file.getfloat('Training', 'FITNESS_THRESHOLD')\n\n # Check the loaded configuration\n self.__check_config()","def readQrelsDict(fileName):\n result = {}\n for e in readQrels(fileName):\n result.setdefault(e.queryId, {})[e.docId] = int(e.relGrade)\n return result","def read_graph(args):\n dataset = pd.read_csv(args.features_path).values.tolist()\n edges = {}\n edges[\"positive_edges\"] = [edge[0:2] for edge in dataset if edge[2] == 1]\n edges[\"negative_edges\"] = [edge[0:2] for edge in dataset if edge[2] == -1]\n edges[\"ecount\"] = len(dataset)\n edges[\"ncount\"] = len(set([edge[0] for edge in dataset]+[edge[1] for edge in dataset]))\n return edges","def load_graph(path):\r\n \r\n # initialise dictionary\r\n graph_dict = {}\r\n \r\n # open File for reading\r\n graph_file = open(path,'r')\r\n \r\n # initialise list of all the lines\r\n graph_lines = graph_file.readlines() \r\n print (\"Loaded graph has\", len(graph_lines), \"nodes\")\r\n # For all lines get node and edges and put them to SET\r\n for line in graph_lines:\r\n line = line.rstrip('\\n')\r\n neighbors = line.split(' ')\r\n #node = int(neighbors[0])\r\n node = neighbors[0]\r\n graph_dict[node] = set([])\r\n for neighbor in neighbors[1:]:\r\n #graph_dict[node].add(int(neighbor))\r\n graph_dict[node].add(neighbor)\r\n return graph_dict","def retrieve_sequences_pickle(working_directory, genes):\n\n sequences_per_gene = {}\n for gene in genes:\n with open(os.path.join(working_directory, \"sequences\", gene + \".pkl\"), 'rb') as handle:\n sequences = pickle.load(handle) \n sequences_per_gene.update({gene:sequences})\n return sequences_per_gene","def load_in_weights():\n path = os.path.join(\n DATA_RAW, 'intermediate', 'population_weights.csv'\n )\n\n population_data = []\n\n with open(path, 'r') as source:\n reader = csv.DictReader(source)\n for line in reader:\n population_data.append({\n 'id': line['postcode_sector'],\n 'domestic_delivery_points': int(line['domestic_delivery_points']),\n })\n\n return population_data","def read_refgene_file(self, file_path):\n with open(file_path) as fi:\n for line in fi:\n content = line.strip().split()\n refgene = RefGene()\n refgene.bin = int(content[0])\n refgene.name, refgene.chrom, refgene.strand = content[1], content[2].lower(), content[3]\n refgene.tx_start, refgene.tx_end = int(content[4]), int(content[5])\n refgene.cds_start, refgene.cds_end = int(content[6]), int(content[7])\n refgene.exon_count = int(content[8])\n refgene.exon_starts = [int(e) for e in content[9][:-1].split(',')]\n refgene.exon_ends = [int(e) for e in content[10][:-1].split(',')]\n refgene.core, refgene.name2 = int(content[11]), content[12]\n refgene.cds_start_stat, refgene.cds_end_stat = content[13], content[14]\n # refgene.exon_frames = [int(e) for e in content[15][:-1].split(',')]\n self.ref_genes.append(refgene)","def reagent_parser(self, filename, initial_dictlist = dict()):\n results = initial_dictlist\n\n filepath = os.path.join(self.base_dir, filename)\n\n with open(filepath, 'r') as fileobj:\n xml = fileobj.read()\n parsed = BeautifulSoup(xml, \"lxml-xml\")\n\n substances = parsed.find_all(\"substance\")\n\n # iterates for every substance in file\n for substance in substances:\n\n # pulls the Beilstein Registry number\n rn = substance.find(\"IDE.XRN\").text\n\n # finds all molfiles, indicated by \"YY.STR\"\n molfiles = substance.find_all(\"YY.STR\")\n\n # V2000 files always follow V3000 files if V3000 files are available\n # if V3000 files are not available, V2000 files are the first and only file\n # we are only using V2000 files\n try:\n\n # if possible, converts the second file (the V2000 file) to SMILES\n mymol = readstring(\"mol\", molfiles[1].text)\n smi = mymol.write(str(\"smi\")).split()[0]\n\n results[rn] = smi\n except:\n\n # occurs when only zero or one file listed for specific registry number\n try:\n\n # if possible, converts the first file (the V2000 file) to SMILES\n mymol = readstring(\"mol\", molfiles[0].text)\n smi = mymol.write(str(\"smi\")).split()[0]\n\n results[rn] = smi\n except:\n\n # if not file is listed for the registry number, skips that number\n continue\n\n return results","def adjList(self, relations):\n adj = {}\n for agent in self.agents:\n adj[agent] = {}\n for agent in self.agents:\n for relation in relations[agent]:\n if relation[0] not in adj[agent].keys():\n adj[agent][relation[0]] = []\n adj[agent][relation[0]].append(relation[1])\n return adj","def load_fasta(filepath):\n chromosomes = {}\n\n seqs = SeqIO.parse(filepath, format='fasta', \n alphabet=IUPAC.ambiguous_dna)\n\n # iterate over seqs and add to chromosome dictionary\n for seq in seqs:\n # determine chromosome number\n match = re.search('\\d+', seq.name)\n chromosome_number = int(match.group())\n\n chromosomes[chromosome_number] = seq\n\n return chromosomes"],"string":"[\n \"def read(self):\\n\\t\\tentities = dict()\\n\\t\\trelations = set()\\n\\t\\tedges = set()\\n\\t\\twith open(self.file_path, encoding=\\\"utf-8\\\") as f:\\n\\t\\t\\tfor line in tqdm(f):\\n\\t\\t\\t\\tif(self.prob == 1.0 or random() < self.prob):\\n\\t\\t\\t\\t\\tsource, relation, target, _ = line.split(\\\" \\\", 3)\\n\\t\\t\\t\\t\\tis_dataprop = target.startswith('\\\"')\\n\\t\\t\\t\\t\\tif source not in entities:\\n\\t\\t\\t\\t\\t\\tentities[source] = dict(degree=0, out_degree=0, in_degree=0, data_properties={})\\n\\t\\t\\t\\t\\tentities[source][\\\"out_degree\\\"] += 1\\n\\t\\t\\t\\t\\tentities[source][\\\"degree\\\"] += 1\\n\\t\\t\\t\\t\\tif not is_dataprop:\\n\\t\\t\\t\\t\\t\\tif target not in entities:\\n\\t\\t\\t\\t\\t\\t\\tentities[target] = dict(degree=0, out_degree=0, in_degree=0, data_properties={})\\n\\t\\t\\t\\t\\t\\tentities[target][\\\"in_degree\\\"] += 1\\n\\t\\t\\t\\t\\t\\tentities[target][\\\"degree\\\"] += 1\\n\\t\\t\\t\\t\\t\\trelations.add(relation)\\n\\t\\t\\t\\t\\t\\tedges.add((relation, source, target))\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tif(self.include_dataprop):\\n\\t\\t\\t\\t\\t\\t\\tentities[source][\\\"data_properties\\\"][relation] = target\\n\\n\\t\\treturn (entities, relations, edges)\",\n \"def read_relations(db, openfile):\\n pass\",\n \"def read_population_assignation(namefile):\\n db = shelve.open(namefile)\\n hashes = db['hashes']\\n key_firms = db['nif']\\n year = db['year']\\n population_value = db['population']\\n methodvalues = db['methodvalues']\\n db.close()\\n return hashes, key_firms, year, population_value, methodvalues\",\n \"def load_personality_adj():\\n return json.load(open(personality_adj()))\",\n \"def read_population_distribution(path_POP, occupancy, verbose=False):\\n with open(path_POP, 'r') as f:\\n jd = json.load(f)\\n\\n data = jd[occupancy]\\n\\n # convert peak population to persons/m2\\n data['peak'] = data['peak'] / (1000. * ft2)\\n\\n if verbose:\\n pp.pprint(data)\\n\\n return data\",\n \"def read_graph(filename):\\n\\n print(\\\"\\\\n\\\\n========== Loading graph: \\\" + filename + '==================')\\n edges = {}\\n\\n inFile = open(filename)\\n for line in inFile:\\n roadInfo = line.split()\\n\\n # Skip blank lines, read in contents from non-empty lines.\\n if (len(roadInfo) > 0):\\n srcCity = roadInfo[0]\\n destCity = roadInfo[1]\\n\\n if srcCity in edges:\\n edges[srcCity] = edges[srcCity] + [destCity]\\n else:\\n edges[srcCity] = [destCity]\\n\\n if destCity in edges:\\n edges[destCity] = edges[destCity] + [srcCity]\\n else:\\n edges[destCity] = [srcCity]\\n\\n print(\\\" done.\\\\n\\\")\\n return edges\",\n \"def read_roles():\\n roles = defaultdict(list)\\n invert_is_a = defaultdict(list)\\n with open('relation.tsv','r') as inf:\\n for line in inf:\\n x = line.strip().split('\\\\t')\\n if x[1] == 'has_role':\\n roles[f'CHEBI:{x[3]}'].append(f'CHEBI:{x[2]}')\\n elif x[1] == 'is_a':\\n child = f'CHEBI:{x[3]}'\\n parent = f'CHEBI:{x[2]}'\\n invert_is_a[parent].append(child)\\n #Now include parents\\n ancestors = get_ancestors(invert_is_a)\\n for node,noderoles in roles.items():\\n if node == 'CHEBI:64663':\\n print('hi')\\n restroles= []\\n for role in noderoles:\\n moreroles=ancestors[role]\\n restroles += moreroles\\n roles[node] += restroles\\n return roles\",\n \"def load_simple_families_file(infile, ped_sep=\\\"\\\\t\\\") -> FamiliesData:\\n fam_df = pd.read_csv(\\n infile,\\n sep=ped_sep,\\n index_col=False,\\n skipinitialspace=True,\\n converters={\\n \\\"role\\\": Role.from_name,\\n \\\"gender\\\": Sex.from_name,\\n \\\"sex\\\": Sex.from_name,\\n },\\n dtype={\\\"familyId\\\": str, \\\"personId\\\": str},\\n comment=\\\"#\\\",\\n )\\n\\n fam_df = fam_df.rename(\\n columns={\\n \\\"gender\\\": \\\"sex\\\",\\n \\\"personId\\\": \\\"person_id\\\",\\n \\\"familyId\\\": \\\"family_id\\\",\\n \\\"momId\\\": \\\"mom_id\\\",\\n \\\"dadId\\\": \\\"dad_id\\\",\\n \\\"sampleId\\\": \\\"sample_id\\\",\\n },\\n )\\n\\n fam_df[\\\"status\\\"] = pd.Series(index=fam_df.index, data=1)\\n fam_df.loc[fam_df.role == Role.prb, \\\"status\\\"] = 2\\n fam_df[\\\"status\\\"] = fam_df.status.apply(Status.from_value)\\n\\n fam_df[\\\"mom_id\\\"] = pd.Series(index=fam_df.index, data=\\\"0\\\")\\n fam_df[\\\"dad_id\\\"] = pd.Series(index=fam_df.index, data=\\\"0\\\")\\n\\n if \\\"sample_id\\\" not in fam_df.columns:\\n sample_ids = pd.Series(data=fam_df[\\\"person_id\\\"].values)\\n fam_df[\\\"sample_id\\\"] = sample_ids\\n\\n families = defaultdict(list)\\n for rec in fam_df.to_dict(orient=\\\"records\\\"):\\n families[rec[\\\"family_id\\\"]].append(rec)\\n\\n result = defaultdict(list)\\n for fam_id, members in families.items():\\n mom_id = None\\n dad_id = None\\n children = []\\n for member in members:\\n role = member[\\\"role\\\"]\\n if role == Role.mom:\\n mom_id = member[\\\"person_id\\\"]\\n elif role == Role.dad:\\n dad_id = member[\\\"person_id\\\"]\\n else:\\n assert role in set([Role.prb, Role.sib])\\n children.append(member)\\n for child in children:\\n child[\\\"mom_id\\\"] = mom_id\\n child[\\\"dad_id\\\"] = dad_id\\n\\n result[fam_id] = [\\n Person(**member) # type: ignore\\n for member in members\\n ]\\n\\n return FamiliesData.from_family_persons(result)\",\n \"def read_annotations(file):\\n\\n with open(file) as f:\\n lines = f.read().splitlines()\\n\\n annotations_by_agent = divide_annotations(lines)\\n agent_list = []\\n for annotation_set in annotations_by_agent:\\n agent_list.append(Agent(annotation_set))\\n\\n return agent_list\",\n \"def load_data(filename):\\n with open(filename, 'r') as f:\\n d = json.load(f)\\n\\n return d['nicknames'], d['relations'], d['directed']\",\n \"def _load_orgs_and_genes(self):\\n organisms = {}\\n genes = {}\\n for gene in self.gene_ids:\\n org_file_path = self._get_organisms_file_path(gene[self.GENE_NAME_IDX], gene[self.GENE_ID_IDX])\\n with open(org_file_path, \\\"r\\\") as orgs:\\n org = orgs.read().splitlines()\\n genes[gene[self.GENE_NAME_IDX]] = {}\\n # we only care about unique organisms\\n for o in org:\\n if not o.startswith(\\\">\\\"):\\n continue\\n clean_o = o.replace(\\\">\\\", \\\"\\\", 1).replace(\\\"_\\\", \\\" \\\").title()\\n # I hate to do this but there's a special case for Canis Familiaris\\n # EBI does not recognize it but it does recognize Canis Lupus (Canis Lupus Familiaris)\\n if \\\"Canis Familiaris\\\" in clean_o:\\n clean_o = \\\"Canis lupus\\\"\\n if not organisms.get(clean_o):\\n organisms[clean_o] = {self.FREQ_KEY: 1, self.GENE_IDS_KEY: [gene]}\\n else:\\n organisms[clean_o][self.FREQ_KEY] = organisms[clean_o][self.FREQ_KEY] + 1\\n organisms[clean_o][self.GENE_IDS_KEY].append(gene)\\n genes[gene[self.GENE_NAME_IDX]][clean_o] = 1\\n return organisms, genes\",\n \"def _load_genes(self):\\n with open(self.gene_file_path, 'r') as gene_file:\\n csv_reader = csv.reader(gene_file, delimiter=',')\\n for gene in csv_reader:\\n yield (gene[self.GENE_NAME_IDX], gene[self.GENE_ID_IDX])\",\n \"def read_nell_relations():\\n\\trel=os.walk(\\\"nell/relations\\\")\\n\\trelation=[]\\n\\tfor i in rel:\\n\\t\\ttrel=i[2]\\n\\tfor i in trel:\\n\\t\\trelation.append(' '.join(segment(i.split(':')[1])))\\n\\treturn relation\",\n \"def read_relationship_map():\\n try:\\n conn = sqlite3.connect(settings.database_name)\\n conn.row_factory = sqlite3.Row\\n c = conn.cursor()\\n c.execute(\\\"PRAGMA foreign_keys = ON\\\")\\n c.execute(\\\"SELECT * FROM relationshipmap\\\")\\n relation_dictionary = {}\\n for row in c:\\n relation_dictionary[row[\\\"key\\\"]] = (row[\\\"key\\\"], row[\\\"value\\\"], row[\\\"relationshiptype\\\"])\\n conn.close()\\n return relation_dictionary\\n except:\\n return {}\",\n \"def read_file(self, reader):\\n # Open files to write comments, invalid and ignored entries\\n comments = open('genome.comments.gff', 'w')\\n invalid = open('genome.invalid.gff', 'w')\\n ignored = open('genome.ignored.gff', 'w')\\n\\n # First pass, pulling out all genes and mRNAs\\n # and placing child features if possible\\n for line in reader:\\n if len(line) == 0 or line[0].startswith('#'):\\n comments.write(line)\\n continue\\n splitline = self.validate_line(line)\\n if not splitline:\\n invalid.write(line)\\n else:\\n line_added = self.process_line(splitline)\\n if not line_added:\\n ignored.write(line)\\n\\n # Second pass, placing child features which \\n # preceded their parents in the first pass\\n orphans = copy.deepcopy(self.orphans)\\n for splitline in orphans:\\n self.process_line(splitline)\\n \\n # Add mRNAs to their parent genes\\n for mrna in self.mrnas.values():\\n parent_gene = self.genes[mrna.parent_id]\\n parent_gene.mrnas.append(mrna)\\n\\n if self.skipped_features > 0:\\n sys.stderr.write(\\\"Warning: skipped \\\"+str(self.skipped_features)+\\\" uninteresting features.\\\\n\\\")\\n return self.genes.values()\",\n \"def test_relationship_edges(self):\\n path = os.path.join(get_file_dir(), 'data', 'GO_edges_relationship.json')\\n with open(path, 'rt') as json_file:\\n json_files = []\\n for data in json_file:\\n json_files.append(json.loads(data))\\n for entry in json_files:\\n if entry[\\\"id\\\"] == \\\"GO:0000332__GO:0003720__part_of\\\":\\n self.assertEqual(entry[\\\"from\\\"], \\\"GO_term/GO:0000332\\\")\\n self.assertEqual(entry[\\\"to\\\"], \\\"GO_term/GO:0003720\\\")\\n self.assertEqual(entry[\\\"relationship_type\\\"], \\\"part_of\\\")\\n if entry[\\\"from\\\"] == \\\"GO_term/GO:0000335\\\":\\n self.assertEqual(entry[\\\"id\\\"], \\\"GO:0000335__GO:0006313__negatively_regulates\\\")\\n self.assertEqual(entry[\\\"to\\\"], \\\"GO_term/GO:0006313\\\")\\n self.assertEqual(entry[\\\"relationship_type\\\"], \\\"negatively_regulates\\\")\",\n \"def readScenario(fileName):\\n \\n fp = open(fileName, 'r')\\n lines = fp.readlines()\\n fp.close()\\n for line in lines:\\n agents.append(Agent(line.split(','),compiled_besier_curves)) # create an agent and add it to the list\\n \\n # define the boundaries of the environment\\n positions = [a.pos for a in agents]\\n goals = [a.goal for a in agents]\",\n \"def read (path):\\n\\n with open(path) as f:\\n reader = csv.DictReader(f)\\n edges, nodes = [], {}\\n for row in reader:\\n edges.append((row[\\\"NODE1\\\"], row[\\\"NODE2\\\"]))\\n nodes[row[\\\"NODE1\\\"]] = [eval(row[\\\"LONG1\\\"]), eval(row[\\\"LAT1\\\"])]\\n nodes[row[\\\"NODE2\\\"]] = [eval(row[\\\"LONG2\\\"]), eval(row[\\\"LAT2\\\"])]\\n\\n return nodes, edges\",\n \"def load_graph(file_name):\\r\\n citizens = []\\r\\n f = open(file_name, 'r')\\r\\n number_citizens = int(f.readline())\\r\\n \\r\\n # creates the citizen's list.\\r\\n for i in range(number_citizens):\\r\\n # creates citizen object\\r\\n citizen = Citizen(i)\\r\\n citizens.append(citizen)\\r\\n\\r\\n # we need this second loop because we cannot create the list of friends \\r\\n # if we don't have the whole list of citizens in memory.\\r\\n for citizen in citizens:\\r\\n # loads basic infor\\r\\n inf_list = f.readline().split(';')\\r\\n citizen.location = int(inf_list[1])\\r\\n citizen.influence_level = int(inf_list[2])\\r\\n citizen.proactivity_level = inf_list[3]\\r\\n \\r\\n # loads opinions\\r\\n opinions_list = f.readline().split(';')\\r\\n opinions = {}\\r\\n \\r\\n for op in opinions_list[:-1]:\\r\\n cat_weight = op.split(':')\\r\\n cat = int(cat_weight[0])\\r\\n weight = float(cat_weight[1])\\r\\n idea = Idea(1,'',cat, weight)\\r\\n opinions[cat] = idea\\r\\n\\r\\n citizen.opinions = opinions\\r\\n \\r\\n # loads friends \\r\\n friends_ids_list = f.readline().split(';')\\r\\n friends = []\\r\\n for friend_id in friends_ids_list[:-1]:\\r\\n # note that we match the position of the citizen in the citizens list with its id.\\r\\n friends.append(citizens[int(friend_id)])\\r\\n \\r\\n citizen.friends = friends\\r\\n \\r\\n f.close()\\r\\n \\r\\n return citizens\",\n \"def nrpdbs_from_file(filename, rep_type=None):\\n # this is the wrong spec. It should simply return the representative\\n # pdb-chain for a given pdb-chain and rep-type.\\n \\n # we actually want two functions: give ALL the reps for a level, or\\n # give a mapping from pdb:chain to representative pdb:chain\\n nrpdbs = {}\\n groups = {}\\n with open(filename, 'r') as nrpdb_file:\\n\\n # iterate over each record in the NRPDB file\\n for line in nrpdb_file:\\n\\n # strip leading and trailing whitespace\\n line = line.strip()\\n\\n try:\\n # skip blank lines and comments\\n if len(line) == 0 or line[0] == '#':\\n continue\\n\\n # get all of the fields from the current record\\n fields = line.split()\\n \\n # I THINK we want to always go into this loop, but flag\\n # those proteins that are reps\\n \\n\\n # if this protein is a representative (or we don't care)\\n # (relies on short-circuiting or operator)\\n if (rep_type and rep_type in RepresentativeFields.REPFIELDS \\\\\\n and \\\\\\n int(fields[RepresentativeFields.REPFIELDS[rep_type]]) == 1):\\n is_rep = True\\n else:\\n is_rep = False\\n \\n if (rep_type and rep_type in RepresentativeFields.GROUPFIELDS):\\n group_id = fields[RepresentativeFields.GROUPFIELDS[rep_type]]\\n else:\\n group_id = None\\n \\n # if rep_type is None or \\\\\\n # (rep_type in RepresentativeFields.REPFIELDS and\\n # int(fields[RepresentativeFields.REPFIELDS[rep_type]]) \\\\\\n # == 1):\\n\\n # get the pdbid and chain letter of this protein\\n pdbid, chain = fields[:2]\\n \\n\\n # ensure pdbid is lowercase, chain is uppercase\\n pdbid = pdbid.lower()\\n chain = chain.upper()\\n full_pdbid = pdbid + ':' + chain\\n \\n if group_id and group_id in groups:\\n groups[group_id].add((full_pdbid, is_rep))\\n else:\\n groups[group_id] = set(((full_pdbid, is_rep), ))\\n \\n # \\n # \\n # # add or update the set of chains\\n # if full_pdbid in nrpdbs:\\n # nrpdbs[full_pdbid].add((chain, is_rep))\\n # else:\\n # nrpdbs[full_pdbid] = set(((chain, is_rep), ))\\n\\n except ValueError:\\n logger.warning('Incorrectly formatted NRPDB line ' + line)\\n \\n # now for each group, we want to add a mapping for each pdb:chain to its rep\\n \\n for group_id in groups.keys():\\n \\n redundant_entries = set()\\n for nrpdb_entry in groups[group_id]:\\n if nrpdb_entry[1]:\\n rep = nrpdb_entry[0]\\n redundant_entries.add(rep)\\n else:\\n redundant_entries.add(nrpdb_entry[0])\\n \\n for redundant_entry in redundant_entries:\\n nrpdbs[redundant_entry] = rep\\n \\n return nrpdbs\",\n \"def get_yago_medical_relation(path):\\n return open(path,\\\"r\\\").readlines()\",\n \"def read_geneset_file():\\n geneset_dict = {}\\n with open(GENESET_FILENAME) as geneset_file:\\n lines = geneset_file.readlines()\\n i = 0\\n for l in lines:\\n i += 1\\n entries = l.split()\\n geneset_name = entries[0]\\n geneset = set(entries[2:])\\n geneset_dict[geneset_name] = geneset\\n\\n return geneset_dict\",\n \"def load_pokec_data(indirname):\\n infilename = \\\"soc-pokec-relationships.txt.gz\\\"\\n tmpdir = tempfile.mkdtemp()\\n try:\\n fin = gzip.open(os.path.join(indirname, infilename), 'rb')\\n filename = os.path.join(tmpdir, \\\"soc-pokec-relationships.txt\\\")\\n fout = open(filename, 'w')\\n fout.write(fin.read())\\n\\tfout.close()\\n G = snap.LoadEdgeList(snap.PNGraph, filename, 0, 1, '\\\\t')\\n finally:\\n cleanup_tmpdir(tmpdir)\\n\\n # https://snap.stanford.edu/data/soc-pokec-readme.txt\\n # but 'user_id' column 0 used as dict key so not included here\\n colnames = [ 'public', 'completion_percentage',\\n 'gender', 'region', 'last_login', 'registration',\\n 'AGE', 'body', 'I_am_working_in_field',\\n 'spoken_languages', 'hobbies',\\n 'I_most_enjoy_good_food', 'pets', 'body_type',\\n 'my_eyesight', 'eye_color', 'hair_color',\\n 'hair_type', 'completed_level_of_education',\\n 'favourite_color', 'relation_to_smoking',\\n 'relation_to_alcohol', 'sign_in_zodiac',\\n 'on_pokec_i_am_looking_for', 'love_is_for_me',\\n 'relation_to_casual_sex', 'my_partner_should_be',\\n 'marital_status', 'children',\\n 'relation_to_children', 'I_like_movies',\\n 'I_like_watching_movie', 'I_like_music',\\n 'I_mostly_like_listening_to_music',\\n 'the_idea_of_good_evening',\\n 'I_like_specialties_from_kitchen', 'fun',\\n 'I_am_going_to_concerts', 'my_active_sports',\\n 'my_passive_sports', 'profession', 'I_like_books',\\n 'life_style', 'music', 'cars', 'politics',\\n 'relationships', 'art_culture',\\n 'hobbies_interests', 'science_technologies',\\n 'computers_internet', 'education', 'sport',\\n 'movies', 'travelling', 'health',\\n 'companies_brands', 'more']\\n profile_colnames = dict([(name, col) for (col, name) in enumerate(colnames)])\\n profilepath = os.path.join(indirname, \\\"soc-pokec-profiles.txt.gz\\\")\\n profiledata = [ (x[0], x[1:]) for x in csv.reader(gzip.open(profilepath, 'rb'), delimiter='\\\\t') ]\\n profiledict = dict([(int(x[0]), x[1]) for x in profiledata])\\n assert(G.GetNodes() == len(profiledict))\\n return (G, profiledict, profile_colnames)\",\n \"def draw_relationships(file_contents, emph=list(), ignore=[\\\"key_id_org\\\"],\\n title=\\\"\\\", font_size=14.0, width=16.54, height=11.69):\\n if len(emph) > len(misc.BREWER_SET1):\\n raise PyOrganismError(\\\"number of objects to be emphasized ({0:d}) is\\\"\\\\\\n \\\" greater than the number of colours available ({1:d})\\\",\\n len(emph), len(misc.BREWER_SET1))\\n pgv = misc.load_module(\\\"pygraphviz\\\")\\n colour_choice = dict(itertools.izip(emph, misc.BREWER_SET1))\\n graph = pgv.AGraph(name=\\\"RegulonDB File-Relationships\\\", strict=True,\\n directed=False, rankdir=\\\"TB\\\")\\n graph.graph_attr[\\\"labelloc\\\"] = \\\"t\\\"\\n graph.graph_attr[\\\"label\\\"] = title\\n graph.graph_attr[\\\"fontsize\\\"] = font_size * 1.5\\n graph.graph_attr[\\\"ranksep\\\"] = \\\"0.1 equally\\\"\\n graph.graph_attr[\\\"size\\\"] = (width, height)\\n graph.graph_attr[\\\"ratio\\\"] = \\\"compress\\\"\\n graph.node_attr[\\\"shape\\\"] = \\\"none\\\"\\n graph.node_attr[\\\"fontsize\\\"] = font_size\\n for (name, attrs) in file_contents.iteritems():\\n label = [\\\"<<TABLE BORDER=\\\\\\\"0\\\\\\\" CELLBORDER=\\\\\\\"1\\\\\\\" CELLSPACING=\\\\\\\"0\\\\\\\"\\\"\\\\\\n \\\" CELLPADDING=\\\\\\\"4\\\\\\\">\\\"]\\n label.append(\\\"<TR><TD BGCOLOR=\\\\\\\"#A4A4A4\\\\\\\"><B>{0}</B></TD></TR>\\\".format(name))\\n for (i, attr) in enumerate(attrs):\\n if attr in emph:\\n label.append(\\\"<TR><TD PORT=\\\\\\\"f{0:d}\\\\\\\" BGCOLOR=\\\\\\\"{1}\\\\\\\">{2}</TD></TR>\\\".format(i,\\n colour_choice[attr], attr))\\n else:\\n label.append(\\\"<TR><TD PORT=\\\\\\\"f{0:d}\\\\\\\">{1}</TD></TR>\\\".format(i,\\n attr))\\n label.append(\\\"</TABLE>>\\\")\\n graph.add_node(name, label=\\\"\\\\n\\\".join(label))\\n nodes = file_contents.keys()\\n for i in range(len(nodes) - 1):\\n node_u = nodes[i]\\n attr_u = file_contents[node_u]\\n for j in range(i + 1, len(nodes)):\\n node_v = nodes[j]\\n attr_v = file_contents[node_v]\\n shared = set(attr_u).intersection(set(attr_v))\\n for attr in shared:\\n if attr in ignore:\\n continue\\n u = attr_u.index(attr)\\n v = attr_v.index(attr)\\n if attr in emph:\\n graph.add_edge(node_u, node_v,\\n tailport=\\\"f{0:d}\\\".format(u), headport=\\\"f{0:d}\\\".format(v),\\n color=colour_choice[attr])\\n else:\\n graph.add_edge(node_u, node_v,\\n tailport=\\\"f{0:d}\\\".format(u), headport=\\\"f{0:d}\\\".format(v))\\n sub_attr = dict()\\n nodes = graph.nodes()\\n nodes.sort(key=lambda n: graph.degree(n))\\n maxi = nodes[-1: -len(nodes) / 4]\\n nodes = nodes[:-len(nodes) / 4]\\n zeros = [node for (node, deg) in graph.degree_iter() if deg == 0]\\n for n in zeros:\\n nodes.remove(n)\\n graph.add_subgraph(maxi, name=\\\"input\\\", rank=\\\"source\\\", **sub_attr)\\n graph.add_subgraph(nodes, name=\\\"middle\\\", **sub_attr)\\n graph.add_subgraph(zeros, rank=\\\"sink\\\", **sub_attr)\\n return graph\",\n \"def get_genes_organisms(self):\\n path = os.path.join(self.parent_path, \\\"genes_organisms.txt\\\")\\n with open(path, \\\"w\\\") as f:\\n f.write(\\\"Gene,Organisms\\\\n\\\")\\n for gene in self.genes.keys():\\n f.write(\\\"{},{}\\\".format(gene, \\\"/\\\".join(self.genes.get(gene).keys()) + \\\"\\\\n\\\"))\",\n \"def read_gtf_file(gtf_file):\\n genes = {}\\n transcripts = {}\\n exons = {}\\n\\n with open(gtf_file) as gtf:\\n for line in gtf:\\n line = line.strip()\\n\\n # Ignore header\\n if line.startswith(\\\"#\\\"):\\n continue\\n\\n # Split into constitutive fields on tab\\n tab_fields = line.split(\\\"\\\\t\\\")\\n chrom = tab_fields[0]\\n entry_type = tab_fields[2]\\n\\n # Entry is a gene\\n if entry_type == \\\"gene\\\":\\n gene = Gene.get_gene_from_gtf(tab_fields)\\n native_id = gene.identifier\\n genes[native_id] = gene\\n\\n # Entry is a transcript\\n elif entry_type == \\\"transcript\\\":\\n transcript = Transcript.get_transcript_from_gtf(tab_fields)\\n gene_id = transcript.gene_id\\n if gene_id in genes:\\n genes[gene_id].add_transcript(transcript)\\n native_id = transcript.identifier\\n transcripts[native_id] = transcript\\n \\n # Entry is an edge\\n elif entry_type == \\\"exon\\\":\\n exon = Edge.create_edge_from_gtf(tab_fields)\\n # This ID is used because of a rare GENCODE bug\\n location_exon_id = exon.identifier\\n exons[location_exon_id] = exon \\n\\n transcript_id = list(exon.transcript_ids)[0]\\n gene_id = exon.annotations[\\\"gene_id\\\"]\\n \\n if location_exon_id not in exons:\\n # Add the new edge to the data structure\\n exons[location_exon_id] = exon\\n else:\\n # Update existing exon entry, including its transcript set\\n exon = exons[location_exon_id]\\n exon.transcript_ids.add(transcript_id)\\n \\n if transcript_id in transcripts: \\n currTranscript = transcripts[transcript_id]\\n currTranscript.add_exon(exon)\\n\\n return genes, transcripts, exons\",\n \"def read_cDNA_file_to_dict(filename):\\n \\n #initialize dictionary\\n cDNA_dictionary = {}\\n\\n #open file\\n with open(cDNA_file) as f:\\n \\n #loop through file line by line\\n for line in f:\\n\\n #remove newline\\n line = line.rstrip()\\n \\n #get gene name\\n if line.startswith(\\\">\\\"):#If the line starts with the character \\\">\\\" then,\\n gene_name = line.split(\\\"|\\\")[1]#I separate the line by the character \\\"|\\\" and assign index 1 to gene_name\\n \\n #read in sequence in uppercase\\n if not line.startswith(\\\">\\\"):#If the line does not start with the character \\\">\\\" then,\\n line = line.upper()#I make all of the characters within the line uppercase\\n\\n #put name and sequence in dictionary\\n cDNA_dictionary[gene_name] = line#I assign the gene_name as the key and the line (sequence) as the value\\n\\n #return dictionary \\n return cDNA_dictionary\",\n \"def parse_data(self, path_to_file):\\n\\n line_dict, rel_dict = self.create_dicts(path_to_file)\\n \\n line_df = self.create_dataframe(line_dict, ['line'])\\n rel_df = self.create_dataframe(rel_dict, ['relation'])\\n\\n line_df['relation'] = rel_df['relation']\\n\\n return (line_df, rel_df)\",\n \"def parse_data(path_to_file):\\n\\n line_dict, rel_dict = create_dicts(path_to_file)\\n \\n line_df = create_dataframe(line_dict, ['line'])\\n rel_df = create_dataframe(rel_dict, ['relation'])\\n\\n line_df['relation'] = rel_df['relation']\\n\\n return (line_df, rel_df)\",\n \"def read_relationships(person_id):\\n try:\\n conn = sqlite3.connect(settings.database_name)\\n conn.row_factory = sqlite3.Row\\n c = conn.cursor()\\n c.execute(\\\"PRAGMA foreign_keys = ON\\\")\\n c.execute(relationship_query, (person_id,)) # note a tuple is needed as a parameter value for SQLITE\\n\\n relation_list = []\\n for row in c:\\n _relation = Relationship()\\n _relation.person_id = row[\\\"personid\\\"]\\n _relation.person.first_name = row[\\\"firstname\\\"]\\n _relation.person.last_name = row[\\\"lastname\\\"]\\n _relation.person.middle_initial = row[\\\"middleinitial\\\"]\\n _relation.related_person_id = row[\\\"related_personid\\\"]\\n _relation.relationship_id = row[\\\"relationshipid\\\"]\\n _relation.relationship_type = row[\\\"relationshiptype\\\"]\\n _relation.relationship_type_description = row[\\\"key\\\"]\\n relation_list.append(_relation)\\n conn.close()\\n return relation_list\\n except:\\n return []\",\n \"def load_data(filename):\\n data = dict()\\n with open(filename) as f:\\n reader = csv.DictReader(f)\\n for row in reader:\\n name = row[\\\"name\\\"]\\n data[name] = {\\n \\\"name\\\": name,\\n \\\"mother\\\": row[\\\"mother\\\"] or None,\\n \\\"father\\\": row[\\\"father\\\"] or None,\\n \\\"trait\\\": (True if row[\\\"trait\\\"] == \\\"1\\\" else\\n False if row[\\\"trait\\\"] == \\\"0\\\" else None)\\n }\\n return data\",\n \"def read_graph(filename):\\n return nx.read_edgelist(filename, create_using=nx.DiGraph(), nodetype=str)\",\n \"def load_data() -> Tuple[Dict, Dict]:\\n\\n female_dict, male_dict = dict(), dict()\\n\\n for dfile, g_dict in zip(\\n ['data/female.txt', 'data/male.txt'],\\n [female_dict, male_dict]):\\n\\n with open(dfile, 'r') as fh:\\n\\n for line in fh:\\n splits = line.split()\\n country = splits[0]\\n g_dict[country] = set(splits[1:])\\n\\n return female_dict, male_dict\",\n \"def load_data(filename):\\n data = dict()\\n with open(filename) as f:\\n reader = csv.DictReader(f)\\n for row in reader:\\n name = row[\\\"name\\\"]\\n data[name] = {\\n \\\"name\\\": name,\\n \\\"mother\\\": row[\\\"mother\\\"],\\n \\\"father\\\": row[\\\"father\\\"],\\n \\\"trait\\\": (True if row[\\\"trait\\\"] == \\\"1\\\" else\\n False if row[\\\"trait\\\"] == \\\"0\\\" else None)\\n }\\n return data\",\n \"def load_gene_ontology(self, file_path):\\n\\t\\tpass\",\n \"def read_fixtures(filename):\\n fixtures = []\\n f = open(filename, 'r')\\n routes = {}\\n for line in f:\\n parsed = parse_fixture_line(line)\\n if parsed is None:\\n continue\\n strand = parsed[\\\"strand\\\"]\\n address = parsed[\\\"address\\\"]\\n panel_number = parsed[\\\"panel_number\\\"]\\n x, y = parsed[\\\"grid_loc\\\"]\\n pos1 = map_grid_loc_to_pixel((panel_number, x, y),\\n panel_dimensions = langton_panel_dimensions)\\n pixels = 1\\n route_indices = parsed[\\\"routes\\\"]\\n data = {\\\"strand\\\": strand,\\n \\\"address\\\": address,\\n \\\"pixels\\\": pixels,\\n \\\"pos1\\\": pos1,\\n \\\"pos2\\\": pos1,\\n \\\"grid_loc\\\": (x, y)}\\n fixtures.append(Fixture(data))\\n for route_index in route_indices:\\n if route_index in routes:\\n routes[route_index].fixtures.append(data)\\n else:\\n routes[route_index] = Route({\\\"active\\\": False,\\n \\\"color\\\": (1, 0, 0),\\n \\\"fixtures\\\": [data],\\n \\\"index\\\": route_index})\\n f.close()\\n return routes, fixtures\",\n \"def read_graph():\\n return nx.read_edgelist('edges_new.txt', delimiter='\\\\t')\",\n \"def read_all():\\n # Create the list of people from our data\\n return [PEOPLE[key] for key in sorted(PEOPLE.keys())]\",\n \"def _read_facts(fact_file, relation_embeddings, question_embedding,\\n seeds, qId):\\n seeds_found = set()\\n with open(fact_file) as f:\\n entity_map = {}\\n relation_map = {}\\n all_row_ones, all_col_ones = [], []\\n num_entities = 0\\n num_facts = 0\\n for line in f:\\n try:\\n e1, rel, e2 = line.strip().split(None, 2)\\n except ValueError:\\n continue\\n if _filter_relation(rel): continue\\n if e1 not in entity_map:\\n entity_map[e1] = num_entities\\n num_entities += 1\\n if e2 not in entity_map:\\n entity_map[e2] = num_entities\\n num_entities += 1\\n if rel not in relation_map:\\n relation_map[rel] = [[], []]\\n if e1 in seeds: seeds_found.add(e1)\\n if e2 in seeds: seeds_found.add(e2)\\n all_row_ones.append(entity_map[e1])\\n all_col_ones.append(entity_map[e2])\\n all_row_ones.append(entity_map[e2])\\n all_col_ones.append(entity_map[e1])\\n relation_map[rel][0].append(entity_map[e1])\\n relation_map[rel][1].append(entity_map[e2])\\n num_facts += 1\\n if num_facts == MAX_FACTS:\\n break\\n if not relation_map:\\n return {}, {}, None\\n for rel in relation_map:\\n row_ones, col_ones = relation_map[rel]\\n m = csr_matrix(\\n (np.ones((len(row_ones),)), (np.array(row_ones), np.array(col_ones))),\\n shape=(num_entities, num_entities))\\n relation_map[rel] = normalize(m, norm=\\\"l1\\\", axis=1)\\n if RELATION_WEIGHTING:\\n if rel not in relation_embeddings:\\n score = NOTFOUNDSCORE\\n else:\\n score = np.dot(question_embedding, relation_embeddings[rel]) / (\\n np.linalg.norm(question_embedding) *\\n np.linalg.norm(relation_embeddings[rel]))\\n relation_map[rel] = relation_map[rel] * np.power(score, EXPONENT)\\n if DECOMPOSE_PPV:\\n adj_mat = sum(relation_map.values()) / len(relation_map)\\n else:\\n adj_mat = csr_matrix(\\n (np.ones((len(all_row_ones),)), (np.array(all_row_ones), np.array(all_col_ones))),\\n shape=(num_entities, num_entities))\\n return entity_map, relation_map, normalize(adj_mat, norm=\\\"l1\\\", axis=1)\",\n \"def read_graph():\\n return nx.read_edgelist('edges.txt.gz', delimiter='\\\\t')\",\n \"def read(self, taxonomy_file, use_canonical_gid=False):\\n\\n check_file_exists(taxonomy_file)\\n\\n try:\\n d = {}\\n for row, line in enumerate(open(taxonomy_file)):\\n line_split = line.split('\\\\t')\\n unique_id = line_split[0]\\n\\n if use_canonical_gid:\\n unique_id = canonical_gid(unique_id)\\n\\n tax_str = line_split[1].rstrip()\\n if tax_str[-1] == ';':\\n # remove trailing semicolons which sometimes\\n # appear in Greengenes-style taxonomy files\\n tax_str = tax_str[0:-1]\\n\\n d[unique_id] = [x.strip() for x in tax_str.split(';')]\\n except:\\n self.logger.error('Failed to parse taxonomy file on line %d' % (row + 1))\\n raise\\n\\n return d\",\n \"def xml_to_dict(path):\\n with open(path) as xml_file:\\n data_dict = xmltodict.parse(xml_file.read())\\n xml_file.close()\\n if isinstance(data_dict[\\\"Relationships\\\"][\\\"Relationship\\\"], list):\\n data = sorted(data_dict[\\\"Relationships\\\"][\\\"Relationship\\\"], key=lambda item: int(item['@Id'].split('Id')[1]))\\n else:\\n data = [data_dict[\\\"Relationships\\\"][\\\"Relationship\\\"]]\\n return data\",\n \"def load_nodes(filename):\\n\\n with open(filename) as f:\\n reader = csv.DictReader(f)\\n return [item for item in reader]\",\n \"def deserialize(self, filename):\\n f = open(filename)\\n edges_tails = []\\n nodes = []\\n # first pass adds incoming edges to nodes\\n for line in f:\\n if '->' in line: # edge\\n edge = self.edge_class()\\n tail_ids, head_id = edge.deserialize(line)\\n nodes[head_id].add_incoming(edge)\\n edges_tails.append((edge, tail_ids))\\n else: # node\\n node = self.node_class()\\n node.deserialize(line)\\n assert node.id == len(nodes), 'nodes shall appear in order'\\n nodes.append(node)\\n # second pass adds tail nodes to edges\\n for edge, tail_ids in edges_tails:\\n for nid in tail_ids:\\n edge.add_tail(nodes[nid])\\n f.close()\\n # make a toposorted hypergraph\\n hg = Hypergraph(nodes[0])\\n hg.nodes = nodes\\n for node in hg:\\n node.hg = hg\\n for edge in hg.edges():\\n edge.hg = hg\\n hg.tasks_done.add('topo_sort')\\n return hg\",\n \"def load_people(self, file_path):\\n pass\",\n \"def person_list(self):\\n self.__load_persons_from_file_into_memory()\\n return self._person_list\",\n \"def map_protein_to_go(filename):\\n\\n try:\\n with open(filename) as go_association_file:\\n go_association = go_association_file.read()\\n split_go_association = re.split(r\\\"\\\\n\\\", go_association)\\n\\n # Ignore the general file information, which is the line starting\\n # with \\\"!\\\"\\\".\\n go_association_info = []\\n for line in split_go_association:\\n if line and not line.startswith(\\\"!\\\"):\\n go_association_info.append(line)\\n\\n # Declare the tuple to parse the protein and go term as a pair and\\n # store it in the set to avoid duplicate situation\\n go_protein_dict = {}\\n for column in go_association_info:\\n column_info = re.split(r\\\"\\\\t\\\", column)\\n protein_id = column_info[1]\\n go_term = column_info[4]\\n\\n if protein_id in go_protein_dict:\\n go_protein_dict[protein_id].add(go_term)\\n else:\\n go_protein_dict[protein_id] = {go_term}\\n return go_protein_dict\\n\\n except FileNotFoundError:\\n return {}\",\n \"def readAdjacencyGraph(self,filename):\\n try:\\n for line in open(filename,'r'):\\n incoming,outgoing=line.strip().split(\\\":\\\")\\n no_outgoing=outgoing.split(\\\",\\\")\\n self.adjacencyMetadata[incoming]=dict(zip(no_outgoing,range(len(no_outgoing))))\\n if incoming not in self.adjacency.keys():\\n self.adjacency[incoming]=None\\n for item in no_outgoing:\\n if item not in self.adjacency.keys():\\n self.adjacency[item]=None\\n except Exception as e:\\n raise\",\n \"def readGraphFromYAMLFile(self, filename):\\n self.G = nx.read_yaml(filename)\\n # TODO: buiild up the indexes !!!\",\n \"def parse(records):\\n # Collect all people.\\n people = {}\\n for record in records:\\n if record.rec_type == \\\"INDI\\\":\\n assert record.rec_id not in people\\n people[record.rec_id] = Person(record)\\n # Link parents and children.\\n for record in records:\\n if record.rec_type == \\\"FAM\\\":\\n # For this \\\"family unit\\\" collect all parents and all children.\\n parents = []\\n children = []\\n for sub_rec in record.sub_recs:\\n if sub_rec.rec_type in (\\\"HUSB\\\", \\\"WIFE\\\"):\\n parents.append(sub_rec.data)\\n elif sub_rec.rec_type == \\\"CHIL\\\":\\n children.append(sub_rec.data)\\n # Ignore MARR, DATE, PLAC, ...\\n # Add parent/child relationships.\\n for child_id in children:\\n child = people[child_id]\\n for parent_id in parents:\\n parent = people[parent_id]\\n child.parents.append(parent)\\n parent.children.append(child)\\n return people\",\n \"def read_file(filename):\\n population_list = []\\n line_counter = 0\\n number_of_columns = 0\\n for line in filename:\\n line = line.split()\\n if line_counter == 0:\\n number_of_columns = len(line) #Seeing how long the original line is so if there are more than one words in the state name I can put them together when the time comes\\n line_counter += 1\\n population_list.append(line)\\n else:\\n length_check = len(line) - number_of_columns #Checking the length of the other lines \\n # If the next line is the same length as the previous one nothing happens but if it's longer you put the first two together\\n us_state = \\\" \\\".join(line[0:1 + length_check])\\n state = [us_state] #creates a list with just the state\\n#makes a list of all elements in the line other than the state so if the state has two names we can account for it\\n population = [int(elements) for elements in line[length_check + 1:]] \\n state.extend(population) # puts together the state and all other elements into one list \\n population_list.append(state) #here is the list of all the other lists we made\\n return population_list\",\n \"def load_org_meeting_file():\\n nodelist = orgnode.makelist(MEETINGS_ORG_FILE)\\n return nodelist\",\n \"def get_organisms_genes(self):\\n path = os.path.join(self.parent_path, \\\"organisms_genes.txt\\\")\\n with open(path, \\\"w\\\") as freqs:\\n freqs.write(\\\"Organism,Genes\\\\n\\\")\\n for org, data in self.organisms.items():\\n genes = \\\"\\\"\\n for gene in data.get(self.GENE_IDS_KEY):\\n genes = genes + \\\"{} \\\".format(gene[self.GENE_NAME_IDX])\\n freqs.write(\\\"{},{}\\\\n\\\".format(org, genes))\",\n \"def load_gene_dict(reference_genbank_name=\\\"data/covid-19-genbank.gb\\\"):\\n recs = [rec for rec in SeqIO.parse(reference_genbank_name, \\\"genbank\\\")]\\n gene_dict = {}\\n for rec in recs:\\n feats = [feat for feat in rec.features if feat.type == \\\"CDS\\\"]\\n for feat in feats:\\n content = '{}: {}'.format(feat.qualifiers['protein_id'][0], feat.qualifiers['product'][0])\\n if feat.qualifiers['product'][0] == 'ORF1a polyprotein':\\n continue\\n if feat.location_operator == 'join':\\n for item in feat.location.parts:\\n key = (item.start.position, item.end.position)\\n if 'translation' in feat.qualifiers:\\n seq = feat.qualifiers['translation']\\n if len(seq) == 1:\\n amino_acid_seq = seq[0]\\n gene_dict[key] = (content, amino_acid_seq)\\n else:\\n key = (feat.location.start.position, feat.location.end.position)\\n if 'translation' in feat.qualifiers:\\n seq = feat.qualifiers['translation']\\n if len(seq) == 1:\\n amino_acid_seq = seq[0]\\n gene_dict[key] = (content, amino_acid_seq)\\n return gene_dict\",\n \"def load_all_data_from_file(self) -> None:\\n self.load_gene_data_from_file()\\n self.load_ontology_from_file(ontology_type=DataType.GO, ontology_url=self.go_ontology_url,\\n ontology_cache_path=self.go_ontology_cache_path,\\n config=self.config)\\n self.load_associations_from_file(associations_type=DataType.GO, associations_url=self.go_associations_url,\\n associations_cache_path=self.go_associations_cache_path, config=self.config)\\n self.load_ontology_from_file(ontology_type=DataType.DO, ontology_url=self.do_ontology_url,\\n ontology_cache_path=self.do_ontology_cache_path, config=self.config)\\n self.load_associations_from_file(associations_type=DataType.DO, associations_url=self.do_associations_url,\\n associations_cache_path=self.do_associations_cache_path,\\n association_additional_cache_path=self.do_associations_new_cache_path,\\n association_additional_url=self.do_associations_new_url, config=self.config)\\n self.load_ontology_from_file(ontology_type=DataType.EXPR, ontology_url=self.expression_ontology_url,\\n ontology_cache_path=self.expression_ontology_cache_path, config=self.config)\\n self.load_associations_from_file(associations_type=DataType.EXPR,\\n associations_url=self.expression_associations_url,\\n associations_cache_path=self.expression_associations_cache_path,\\n config=self.config)\\n self.load_orthology_from_file()\\n self.load_expression_cluster_data()\\n self.load_protein_domain_information()\",\n \"def read_file(filename):\\n with open(filename, 'r') as file:\\n # Read the first line containing number of\\n # beds and persons\\n amount_persons = int(file.readline())\\n size_persons1 = int(file.readline())\\n size_beds1 = int(file.readline())\\n size_persons2 = amount_persons - size_persons1\\n size_beds2 = amount_persons - size_beds1\\n\\n lines = file.readlines()\\n\\n # Create a list of first set of Person objects storing their\\n # x,y coordinates and names\\n persons_set1 = lines[:size_persons1]\\n persons_set1 = list(map((lambda x: (Person(x.split()[0], float(x.split()[1]), float(x.split()[2])))),\\n persons_set1))\\n\\n # Create a list of first set of Bed objects storing their\\n # x,y coordinates and names\\n beds_set1 = lines[size_persons1:size_persons1+size_beds1]\\n beds_set1 = list(map((lambda x: (Bed(x.split()[0], float(x.split()[1]), float(x.split()[2]), int(x.split()[3])\\n ))), beds_set1))\\n\\n # Create a list of second set of Person objects storing their\\n # x,y coordinates and names\\n persons_set2 = lines[size_persons1+size_beds1:size_persons1+size_beds1+size_persons2]\\n persons_set2 = list(map((lambda x: (Person(x.split()[0], float(x.split()[1]), float(x.split()[2])))),\\n persons_set2))\\n\\n # Create a list of second set of Bed objects storing their\\n # x,y coordinates and names\\n beds_set2 = lines[size_persons1+size_beds1+size_persons2:size_persons1+size_beds1+size_persons2+size_beds2]\\n beds_set2 = list(map((lambda x: (Bed(x.split()[0], float(x.split()[1]), float(x.split()[2]), int(x.split()[3])\\n ))), beds_set2))\\n\\n return persons_set1, beds_set1, persons_set2, beds_set2\",\n \"def open_overlapping(self, filename):\\n\\n with open(filename) as overlap:\\n overlap_reader = csv.DictReader(overlap)\\n\\n\\n overlap_dict = {}\\n dubbels = []\\n\\n for row in overlap_reader:\\n course = row['0']\\n for i in row:\\n dubbels.append(row[i])\\n overlap_dict[course] = dubbels\\n dubbels = []\\n\\n return overlap_dict\",\n \"def load_profiles(profiles_file: TextIO) -> Tuple[Dict[str, List[str]],\\n Dict[str, List[str]]]:\\n individuals = [[]]\\n sublist = 0\\n content = profiles_file.readlines()\\n for i in content:\\n if i != '\\\\n':\\n individuals[sublist].append(i)\\n else:\\n sublist += 1\\n individuals.append([])\\n return sort_profile(individuals)\",\n \"def _read_population_data(self, dates, population, change_dict=None):\\n change_dict = dict() if change_dict is None else change_dict.copy()\\n return {\\n date: change_dict[date] if date in change_dict.keys(\\n ) else population\\n for date in dates\\n }\",\n \"def _read_netgen(self, file):\\n\\n with open(file, 'r') as f:\\n\\n aid = 0 # current arc ID\\n\\n # Read the file line-by-line\\n for line in f:\\n\\n # Decide what to do based on the line prefix\\n\\n # Comment line\\n if line[0] == 'c':\\n # Skip\\n continue\\n\\n # Problem info\\n elif line[0] == 'p':\\n # p sense #nodes #arcs #int int_type #defenses #attacks\\n # We always assume that the sense is minimization\\n\\n ls = line.split()\\n if ls[5] == 'n':\\n self.parent_type = 0\\n self.def_limit = int(ls[6])\\n self.att_limit = int(ls[7])\\n\\n # Initialize all nodes as transshipment (in case the NETGEN\\n # file lists only nonzero supply values)\\n self.nodes = [_Node(i, 0.0) for i in range(int(ls[2]))]\\n\\n # Node\\n elif line[0] == 'n':\\n # n ID supply\\n\\n # All nodes have already been defined, so update existing\\n # supply values\\n\\n ls = line.split()\\n self.nodes[int(ls[1])-1].supply = float(ls[2])\\n\\n # Arc\\n elif line[0] == 'a':\\n # a tail head LB UB cost\\n\\n ls = line.split()\\n tail = self.nodes[int(ls[1])-1]\\n head = self.nodes[int(ls[2])-1]\\n if (int(ls[2]) == 0) and (self.parent_type == 0):\\n head = None\\n\\n self.arcs.append(_Arc(aid, tail, head, float(ls[4]),\\n float(ls[5])))\\n aid += 1\\n\\n # Interdependency\\n elif line[0] == 'i':\\n # i parent child\\n\\n ### We assume for now that arcs are parents.\\n\\n ls = line.split()\\n self.int.append((self.arcs[int(ls[1])-1],\\n self.arcs[int(ls[2])-1]))\\n\\n # Defensible arc\\n elif line[0] == 'd':\\n # d arc\\n\\n ls = line.split()\\n self.def_arcs.append(self.arcs[int(ls[1])-1])\\n\\n # All defensible arcs are assumed to be destructible\\n self.att_arcs.append(self.arcs[int(ls[1])-1])\\n\\n # Destructible arc\\n elif line[0] == 'r':\\n # r arc\\n\\n ls = line.split()\\n self.att_arcs.append(self.arcs[int(ls[1])-1])\\n\\n # If no defensible or destructible arcs were listed, we assume that\\n # all arcs are available\\n\\n if len(self.def_arcs) == 0:\\n self.def_arcs[:] = self.arcs[:]\\n\\n if len(self.att_arcs) == 0:\\n self.att_arcs[:] = self.def_arcs[:]\",\n \"def ler(self) -> Iterable[Dict[str, str]]:\\n with open(self.arquivo) as f:\\n for linha in DictReader(f, dialect=self.DialetoCsv):\\n yield linha\",\n \"def GenomeReader(GenomeFile):\\n GenomeScaffolds = {}\\n key = []\\n with open(GenomeFile, 'r') as f:\\n for line in f:\\n line = line.strip()\\n if line.startswith(\\\">\\\"):\\n NamedSeq = line.replace('>', '')\\n key.append(NamedSeq)\\n GenomeScaffolds[NamedSeq] = \\\"\\\"\\n else:\\n GenomeScaffolds[NamedSeq] += line\\n return GenomeScaffolds # Returns a Dictionary object\",\n \"def load_rooms(self, filename):\\n with open(filename, \\\"r\\\") as f:\\n roomss = []\\n for line in f:\\n line = line.strip()\\n\\n # Add id, name and description to each room object\\n if line.isdigit():\\n id = line\\n line = f.readline()\\n line = line.strip()\\n name = line\\n line = f.readline()\\n line = line.strip()\\n description = line\\n room = Room(id, name, description)\\n roomss.append(room)\\n\\n # Add the connected routes to the room\\n elif line.isupper():\\n line = line.split()\\n direction = line[0]\\n room_number = line[1]\\n\\n # Add multiple routes to a direction if needed\\n if not direction in roomss[-1].connection:\\n roomss[-1].connection[direction] = [room_number]\\n else:\\n roomss[-1].connection[direction].append(room_number)\\n return roomss\",\n \"def readNetwork(filename):\\r\\n\\r\\n fileIn = open(filename, 'r')\\r\\n\\r\\n outputList = []\\r\\n network = []\\r\\n\\r\\n for line in fileIn:\\r\\n #Placing each individual parameter of the line into a list\\r\\n lineList = line.replace(\\\"\\\\n\\\",\\\"\\\").split(\\\", \\\")\\r\\n #Extracting the list of direct contacts from the lineList\\r\\n directList = lineList[3:-2]\\r\\n #Deleting the copy of the direct contacts\\r\\n del lineList[3:-2]\\r\\n #Removing < and > from the direct contacts list\\r\\n for i in range(len(directList)):\\r\\n directList[i] = directList[i].strip(\\\"<>\\\")\\r\\n #Appending all the direct contacts to the end of the list\\r\\n lineList.append(directList)\\r\\n outputList.append(lineList)\\r\\n \\r\\n fileIn.close()\\r\\n\\r\\n for parameters in outputList:\\r\\n #Creating a Person object from the parameters given by each line\\r\\n person = Person(parameters)\\r\\n #Appending each Person object to the network list\\r\\n network.append(person)\\r\\n \\r\\n return network\",\n \"def processFile(filename):\\n geneDict = {}\\n pat = re.compile(r'gene_index (\\\\d+)')\\n gf = open(filename)\\n for line in gf:\\n line = line.strip()\\n if line.startswith('#'):\\n continue\\n t = line.split('\\\\t')\\n if len(t) != 9 and len(t) !=8:\\n continue\\n if t[2] not in ['CDS', 'UTR']:\\n continue\\n s = t[8].split(';')\\n m = re.search(pat, s[1])\\n if m is None:\\n raise RuntimeError('bad regex, unable to pull out gene index for line %s' % line)\\n geneIndex = m.group(1)\\n if geneIndex not in geneDict:\\n g = Gene()\\n geneDict[geneIndex] = g\\n else:\\n g = geneDict[geneIndex]\\n if t[2] == 'CDS':\\n g.numCds += 1\\n elif t[2] == 'UTR':\\n g.numUtr += 1\\n if g.left > int(t[3]):\\n g.left = int(t[3])\\n g.updateLength()\\n if g.right < int(t[4]):\\n g.right = int(t[4])\\n g.updateLength()\\n return geneDict\",\n \"def load(filename):\\n\\n owners = []\\n\\n address_manager = REGISTRY['address_manager']\\n error_manager = REGISTRY['error_manager']\\n\\n reader = csv.reader(open(filename, 'rU'))\\n try:\\n headers = reader.next() # Text column headers\\n except StopIteration:\\n syslog.syslog('merge.py: Empty file %s' % filename)\\n return owners\\n\\n if len(headers) != 11:\\n raise InvalidInput('Property Owners file should have ' +\\n 'exactly 11 columns. Found %d.' % len(headers))\\n\\n for line in reader:\\n property_owner = PropertyOwner(line)\\n if address_manager.is_in_strathcona(property_owner.civic):\\n owners.append(property_owner)\\n else:\\n error_manager.add(property_owner, \\n 'Not in Strathcona or invalid address')\\n\\n owners.sort(key=operator.attrgetter('folio'))\\n\\n return owners\",\n \"def parseGrammarFile(fname):\\n\\n # if anything goes wrong, skip the rest of the block\\n # to know more, search for 'python exception handling'\\n try:\\n fp = open(fname, 'r')\\n\\n g = {\\n 'terms': [], # list of terminals\\n 'rnames': [], # list of variables\\n 'start': \\\"\\\", # starting symbol\\n 'rules': {}, # rnames and their lists of productions\\n }\\n\\n g['terms'] = parseTerms(fp)\\n g['rnames'] = parseVars(fp)\\n g['start'] = parseStart(fp)\\n g['rules'] = parseRules(fp)\\n\\n fp.close()\\n return g\\n\\n # re-raise to __main__\\n except:\\n raise\",\n \"def load_gene_data_from_file(self) -> None:\\n logger.info(\\\"Loading genes data from file\\\")\\n if not self.gene_data or len(self.gene_data.items()) == 0:\\n self.gene_data = {}\\n file_path = self._get_cached_file(cache_path=self.gene_data_cache_path, file_source_url=self.gene_data_url)\\n with open(file_path) as file:\\n for line in file:\\n fields = line.strip().split(',')\\n if fields[1].startswith(\\\"WBGene\\\"):\\n name = fields[2] if fields[2] != '' else fields[3]\\n self.gene_data[\\\"WB:\\\" + fields[1]] = Gene(\\\"WB:\\\" + fields[1], name, fields[4] == \\\"Dead\\\", False)\",\n \"def extract_edges(self,fn):\\n new_edges = {}\\n with open (fn,'r') as f:\\n for line in f:\\n new_edges = EdgeParser.line_to_edges(self,line,new_edges)\\n return new_edges\",\n \"def read_file(filepath: str) -> dict:\\n if not filepath.endswith(\\\".csv\\\"):\\n raise RuntimeError(\\\"File extension must be .csv\\\")\\n\\n people = {}\\n with open(filepath) as csv:\\n for line in csv:\\n email, person = Parser.parse_line(line.rstrip(\\\"\\\\n\\\"))\\n if email not in people:\\n people[email] = person\\n else:\\n print(\\\"Ignoring person with duplicate email {}\\\".format(email))\\n return people\",\n \"def readBridgesFromFile(fileName):\\n bridgeDict = { \\\"NEW\\\": [], \\\"RUNNING\\\": [], \\\"OLD\\\": [] } \\n \\n if not os.path.isfile(fileName):\\n print >>sys.stderr, \\\"Not a file: %s\\\" % fileName\\n return bridgeDict\\n\\n r = re.compile('[ \\\\t\\\\n]+')\\n try:\\n f = open(fileName, 'r')\\n for line in f:\\n s = r.split(line)\\n status = s[3]\\n bridge = BridgeData(s[0], s[1], s[2], status = status)\\n bridgeDict[status].append(bridge)\\n f.close()\\n except IOError:\\n print >>sys.stderr, \\\"IOError while reading %s\\\" % fileName\\n\\n return bridgeDict\",\n \"def read_population_assignation_cp(namefile):\\n db = shelve.open(namefile)\\n cps = db['cps']\\n population_value = db['population_value']\\n methodvalues = db['methodvalues']\\n db.close()\\n return cps, population_value, methodvalues\",\n \"def read_gene_families(gftxt, protfile = None, cdsfile = None, wrkdir = None):\\n gene_families = []\\n if protfile is None and cdsfile is None:\\n logging.info(\\\"Gene families need to have sequences!\\\")\\n with open(gftxt, 'r') as f:\\n for line in f:\\n line = line.rstrip()\\n x = line.split()\\n gf_id = x.pop(0)[:-1]\\n gf_genes = x\\n gene_families.append(GeneFamily(gf_id=gf_id, gf_members=gf_genes))\\n return gene_families\\n \\n if protfile is not None:\\n prot = SeqIO.to_dict(SeqIO.parse(protfile, \\\"fasta\\\"))\\n\\n if cdsfile is not None:\\n cds = SeqIO.to_dict(SeqIO.parse(cdsfile, \\\"fasta\\\"))\\n \\n with open(gftxt, 'r') as handle:\\n for line in handle:\\n line = line.rstrip()\\n x = line.split()\\n gf_id = x.pop(0)[:-1]\\n gf_genes = x\\n gf_prot = {}\\n gf_cds = {}\\n for gid in x:\\n if prot[gid][-1:].seq == '*':\\n gf_prot[gid] = prot[gid][:-1]\\n else:\\n gf_prot[gid] =prot[gid]\\n if cds[gid][-3:].seq == \\\"TAA\\\" or \\\\\\n cds[gid][-3:].seq == \\\"TAG\\\" or \\\\\\n cds[gid][-3:].seq == \\\"TGA\\\":\\n gf_cds[gid] = cds[gid][:-3]\\n else:\\n gf_cds[gid] = cds[gid]\\n gene_families.append(GeneFamily(gf_id = gf_id, gf_members = gf_genes, \\n prot_seqs = gf_prot, cds_seqs = gf_cds, wrkdir=wrkdir))\\n return gene_families\",\n \"def read_graph(filename, directed=True):\\n if not directed:\\n G = nx.Graph()\\n else:\\n G = nx.DiGraph()\\n with open(filename) as f:\\n for line in f:\\n d = line.split()\\n G.add_edge(int(d[0]), int(d[1]))\\n print('Read Graph')\\n return G\",\n \"def read(cls, fam_path, delimiter='\\\\\\\\s+') -> 'Pedigree':\\n\\n trios = []\\n missing_sex_count = 0\\n missing_sex_values = set()\\n with Env.fs().open(fam_path) as file:\\n for line in file:\\n split_line = re.split(delimiter, line.strip())\\n num_fields = len(split_line)\\n if num_fields != 6:\\n raise FatalError(\\\"Require 6 fields per line in .fam, but this line has {}: {}\\\".format(num_fields, line))\\n (fam, kid, dad, mom, sex, _) = tuple(split_line)\\n # 1 is male, 2 is female, 0 is unknown.\\n is_female = sex == \\\"2\\\" if sex == \\\"1\\\" or sex == \\\"2\\\" else None\\n\\n if is_female is None:\\n missing_sex_count += 1\\n missing_sex_values.add(kid)\\n\\n trio = Trio(kid,\\n fam if fam != \\\"0\\\" else None,\\n dad if dad != \\\"0\\\" else None,\\n mom if mom != \\\"0\\\" else None,\\n is_female)\\n trios.append(trio)\\n\\n only_ids = [trio.s for trio in trios]\\n duplicate_ids = [id for id, count in Counter(only_ids).items() if count > 1]\\n if duplicate_ids:\\n raise FatalError(\\\"Invalid pedigree: found duplicate proband IDs\\\\n{}\\\".format(duplicate_ids))\\n\\n if missing_sex_count > 0:\\n warning(\\\"Found {} samples with missing sex information (not 1 or 2).\\\\n Missing samples: [{}]\\\".format(missing_sex_count, missing_sex_values))\\n\\n return Pedigree(trios)\",\n \"def load_rooms(self, filename):\\n # First we parse all the data we need to create the rooms with.\\n # All parsed lines of data are saved to rooms_data.\\n rooms_data = []\\n with open(filename, \\\"r\\\") as f:\\n room_data = []\\n for line in f:\\n # When there is no blank newline it means there's still data.\\n if not line == \\\"\\\\n\\\":\\n room_data.append(line.strip())\\n # A blank newline signals all data of a single room is parsed.\\n else:\\n rooms_data.append(room_data)\\n room_data = []\\n # Append a final time, because the files do not end on a blank newline.\\n rooms_data.append(room_data)\\n\\n # Create room objects for each set of data we just parsed.\\n rooms = {}\\n for room_data in rooms_data:\\n id = int(room_data[0])\\n name = room_data[1]\\n description = room_data[2]\\n\\n # Initialize a room object and put it in a dictionary with its\\n # id as key.\\n room = Room(id, name, description)\\n rooms[id] = room\\n\\n # Add routes to each room we've created with the data from each set\\n # we have parsed earlier.\\n for room_data in rooms_data:\\n id = int(room_data[0])\\n # We split to connections into a direction and a room_id.\\n connections = room_data[4:]\\n connections = [connection.split() for connection in connections]\\n # Here we get the current room object that we'll add routes to.\\n room = rooms[id]\\n for connection, target_room_id in connections:\\n # TODO add routes to a room (hint: use the add route method)\\n # split id and item\\n idanditem = target_room_id.split('/', 1)\\n if len(idanditem) < 2:\\n room.add_route(connection, target_room_id)\\n else:\\n room.add_route(connection, idanditem[0], idanditem[1])\\n rooms[id] = room\\n\\n return rooms\",\n \"def read_isoforms(isoforms_file):\\n gene_to_trans = defaultdict(list)\\n f = open(isoforms_file, \\\"r\\\")\\n for line in f:\\n line_data = line.rstrip().split(\\\"\\\\t\\\")\\n gene = line_data[GENE_INDEX_ISOF]\\n trans = line_data[TRANSCRIPT_INDEX_IFOS]\\n gene_to_trans[gene].append(trans)\\n f.close()\\n return gene_to_trans\",\n \"def read_drugable_genes(mypath):\\n drug = pd.read_csv('data/drugability/interactions.tsv', sep='\\\\t')\\n drug_types = ['inhibitor', 'antagonist', 'blocker', 'channel blocker', 'gating inhibitor', 'negative modulator', 'channel blocker,gating inhibitor',\\n 'allosteric modulator,antagonist', 'inhibitor allosteric modulator', 'suppressor', 'antagonist,inhibitor']\\n drug = drug[drug.interaction_types.isin(drug_types)]\\n cts = drug.groupby(['drug_name', 'interaction_claim_source'])['gene_name'].nunique().sort_values(ascending=True)\\n single_drug_impact = cts[cts==1].copy().index.to_series().reset_index()['drug_name'].unique()\\n drug = drug[drug['drug_name'].isin(single_drug_impact)].dropna(subset=['gene_name'])\\n\\n # create a table of gene 2 drug relationships\\n gene2drug = drug.groupby('gene_name')['drug_name'].agg(lambda x: ','.join(list(set(x)))).reset_index()\\n #gene_names = drug['gene_name'].unique()\\n return gene2drug\",\n \"def import_gene_assembly(infile):\\n deserialized = None\\n with open(infile, 'r') as file_handle:\\n deserialized = json.load(file_handle, object_hook=decode_assembly)\\n return deserialized\",\n \"def __loadFromFile(self):\\n try:\\n f=open(self.__fileR, \\\"r\\\")\\n line =f.readline().strip()\\n rez=[]\\n while line!=\\\"\\\":\\n attrs=line.split(\\\",\\\")\\n rt=Rent(attrs[0], attrs[1], attrs[2], attrs[3])\\n rez.append(rt)\\n line=f.readline().strip()\\n f.close()\\n return rez\\n #the file cannot be reached\\n except IOError:\\n return None\",\n \"def read_entities(input_dir: str) -> Tuple[\\n Dict[str, Rider],\\n Dict[str, Vehicle],\\n Dict[str, Depot],\\n Params\\n]:\\n\\n riders_file = RIDERS_FILE.format(input_dir=input_dir)\\n with open(riders_file) as f:\\n logging.info(f'Read riders from {riders_file}.')\\n riders_dicts = json.load(f)\\n riders = {\\n r_dict['rider_id']: Rider.from_dict(r_dict)\\n for r_dict in riders_dicts\\n }\\n logging.info(f'Successfully parsed {len(riders)} riders.')\\n\\n vehicles_file = VEHICLES_FILE.format(input_dir=input_dir)\\n with open(vehicles_file) as f:\\n vehicles_dicts = json.load(f)\\n logging.info(f'Read vehicles from {vehicles_file}.')\\n vehicles = {\\n v_dict['vehicle_id']: Vehicle.from_dict(v_dict)\\n for v_dict in vehicles_dicts\\n }\\n logging.info(f'Successfully parsed {len(vehicles)} vehicles.')\\n\\n depots_file = DEPOTS_FILE.format(input_dir=input_dir)\\n with open(depots_file) as f:\\n depots_dicts = json.load(f)\\n logging.info(f'Read depots from {depots_file}.')\\n depots = {\\n d_dict['depot_id']: Depot.from_dict(d_dict)\\n for d_dict in depots_dicts\\n }\\n logging.info(f'Successfully parsed {len(depots)} depots.')\\n\\n params_file = PARAMS_FILE.format(input_dir=input_dir)\\n with open(params_file) as f:\\n logging.info(f'Read params from {params_file}.')\\n params_dict = json.load(f)\\n params = Params.from_dict(params_dict)\\n logging.info(f'Successfully parsed {len(params_dict)} params.')\\n\\n return riders, vehicles, depots, params\",\n \"def get_data_from_films_locations_file(path):\\n film_locations_data = {}\\n with open(path, encoding='utf-8', errors='ignore') as f:\\n for line in f:\\n line = line.strip()\\n line_values = line.split(',')\\n film, year, location = line_values[0], line_values[1],\\\\\\n line_values[-1]\\n if year in film_locations_data:\\n if location not in film_locations_data[year]:\\n film_locations_data[year][location] = {film}\\n else:\\n film_locations_data[year][location].add(film)\\n else:\\n film_locations_data[year] = {location: {film}}\\n return film_locations_data\",\n \"def read_file(filename):\\n nodes = {}\\n try:\\n with open(filename, 'r') as f:\\n for line in f:\\n params = {}\\n device_list = line.split()\\n router = device_list[0]\\n ip = device_list[1]\\n platform = device_list[2]\\n params[\\\"ipv4_address\\\"] = ip\\n params[\\\"platform\\\"] = platform\\n nodes[router] = params\\n except IOError:\\n print \\\"File %s does not exist!\\\" % filename\\n return nodes\",\n \"def add_graph_attributes(G, filename):\\n Ef = dict() # feature -> edges\\n Nf = dict() # node -> features\\n with open(filename) as f:\\n for line in f: # for each node, list of features it belongs to\\n d = line.split()\\n u = int(d[0])\\n features = d[1:]\\n for f in features:\\n Ef.setdefault(f, []).extend(G.in_edges(u)) # add feature-dependent edges\\n #G.node[u]['Fu'] = features\\n G.nodes[u]['Fu'] = features\\n Nf[u] = features\\n print('Read graph attributes')\\n return Ef, Nf\",\n \"def _read_genome_location_file(self, file_path):\\n self._logger.info('Reading genome location file')\\n assert self.validate_file(file_path)\\n dict_id_file_path = {}\\n metadata_table = MetadataTable(logfile=self._logfile, verbose=self._verbose, separator=self._separator)\\n iterator_distributions = metadata_table.parse_file(file_path, as_list=True)\\n for genome_id, file_path_genome in iterator_distributions:\\n assert genome_id != '', \\\"Invalid genomid: '{}'\\\".format(genome_id)\\n assert file_path_genome != '', \\\"Invalid file path: '{}'\\\".format(genome_id)\\n assert self.validate_file(file_path_genome), \\\"Invalid file path: '{}'\\\".format(genome_id)\\n\\n # check uniqueness\\n assert genome_id not in dict_id_file_path, \\\"Genome '{}' not unique in the distribution file!\\\".format(genome_id)\\n dict_id_file_path[genome_id] = file_path_genome\\n return dict_id_file_path\",\n \"def read_file(network_filename, user_by_city_filename=None):\\n graph = read_dictlist_from_file(network_filename)\\n\\n gg = Graph(directed=False) # new Graph object\\n\\n user_id_map = {} # storing new id info\\n new_id = 0\\n for user_id in graph:\\n temp_users = []\\n temp_users.append(user_id)\\n for friend in graph[user_id]:\\n temp_users.append(friend)\\n for id1 in temp_users:\\n if id1 not in user_id_map:\\n user_id_map[id1] = new_id\\n gg.add_vertex() # index for this vertex will be new_id\\n new_id += 1\\n if id1 > user_id:\\n gg.add_edge(gg.vertex(user_id_map[user_id]),\\n gg.vertex(user_id_map[id1]))\\n print \\\"Done reading the graph.\\\"\\n if user_by_city_filename is None:\\n return (gg, None)\\n if user_by_city_filename is not None:\\n cities = read_dict_from_file(user_by_city_filename)\\n # Adding vertex property as city\\n city_prop = gg.new_vertex_property(\\\"int\\\")\\n for user_id in cities:\\n city_prop[gg.vertex(user_id_map[user_id])] = cities[user_id]\\n print \\\"Done reading the city.\\\"\\n return (gg, city_prop)\",\n \"def build_forest(sped_file_path, record_relations):\\n forest = []\\n tracker = {}\\n\\n with open(sped_file_path, encoding='latin-1') as f:\\n for line in sped_iterator(f):\\n node = SpedNode(line, [])\\n tracker[node.record_type] = node\\n\\n parent_record_type = record_relations[node.record_type]\\n\\n parent = tracker.get(parent_record_type)\\n\\n if parent:\\n parent.children.append(node)\\n node.parent = parent\\n else:\\n forest.append(node)\\n\\n return forest\",\n \"def process_file(self, data, filename):\\n\\n for relation in data:\\n if \\\"start_date\\\" in relation[1]:\\n start = convert_to_date(relation[1][\\\"start_date\\\"])\\n end = convert_to_date(relation[1][\\\"end_date\\\"])\\n\\n if start <= START_DATE and end >= START_DATE:\\n first = relation[1][\\\"first\\\"]\\n second = relation[1][\\\"second\\\"]\\n if first not in self.relations:\\n self.add_tag(first)\\n if second not in self.relations:\\n self.add_tag(second)\\n\\n if relation[0] == \\\"vassal\\\": \\n self.relations[first][\\\"vassal\\\"].append(second)\\n self.relations[second][\\\"overlord\\\"].append(first)\\n elif relation[0] == \\\"alliance\\\":\\n self.relations[first][\\\"alliance\\\"].append(second)\\n self.relations[second][\\\"alliance\\\"].append(first)\\n elif relation[0] == \\\"dependency\\\":\\n self.relations[first][\\\"tributary\\\"].append(second)\\n self.relations[second][\\\"hegemon\\\"].append(first)\\n elif relation[0] == \\\"guarantee\\\":\\n self.relations[first][\\\"guaranteeing\\\"].append(second)\\n self.relations[second][\\\"guarantor\\\"].append(first)\\n elif relation[0] == \\\"union\\\":\\n self.relations[first][\\\"junior\\\"].append(second)\\n self.relations[second][\\\"senior\\\"].append(first)\\n elif relation[0] == \\\"royal_marriage\\\":\\n self.relations[first][\\\"marriage\\\"].append(second)\\n self.relations[second][\\\"marriage\\\"].append(first)\",\n \"def get_data(file_name, referents=False):\\n with open(file_name, 'r') as file:\\n data = file.readlines()\\n data = [line.strip() for line in data if line != '1-----\\\\n' and line != '1-----']\\n scene_mapping = utt_to_scene('gold_lexicon.txt')\\n all_utterances = [e.split(\\\" \\\")[1:] for e in data[::2]]\\n# print(all_utterances)\\n scenes = []\\n for utt in all_utterances:\\n scene = [scene_mapping[word] for word in utt]\\n if referents:\\n scenes.append(scene)\\n else:\\n scene = list(itertools.chain.from_iterable(scene))\\n scenes.append(scene)\\n return all_utterances, scenes\",\n \"def forges():\\n\\n forges = {}\\n\\n for forge_path in sorted(glob.glob(\\\"/opt/service/forge/*.yaml\\\")):\\n if forge_path.split(\\\"/\\\")[-1] not in [\\\"fields.yaml\\\", \\\"values.yaml\\\"]:\\n with open(forge_path, \\\"r\\\") as forge_file:\\n forges[forge_path.split(\\\"/\\\")[-1].split(\\\".\\\")[0]] = yaml.safe_load(forge_file)[\\\"description\\\"]\\n\\n return forges\",\n \"def load(self, filename: str = default_config_file):\\n self.config_file.read(filename)\\n\\n # Population\\n self.POPULATION_SIZE = self.config_file.getint('Population', 'POPULATION_SIZE')\\n\\n # Individuals characteristics\\n self.IND_INP_NUMBER = self.config_file.getint('Individual', 'IND_INP_NUMBER')\\n self.IND_OUT_NUMBER = self.config_file.getint('Individual', 'IND_OUT_NUMBER')\\n self.IND_MAX_NODES = self.config_file.getint('Individual', 'IND_MAX_NODES')\\n self.INITIAL_GENERATION = self.config_file.get('Individual', 'INITIAL_GENERATION')\\n\\n # Genes mutations\\n self.ADD_GENE_PROB = self.config_file.getfloat('Mutations', 'ADD_GENE_PROB')\\n self.MUT_GENE_PROB = self.config_file.getfloat('Mutations', 'MUT_GENE_PROB')\\n self.REM_GENE_PROB = self.config_file.getfloat('Mutations', 'REM_GENE_PROB')\\n\\n self.ADD_NODE_PROB = self.config_file.getfloat('Mutations', 'ADD_NODE_PROB')\\n self.REM_NODE_PROB = self.config_file.getfloat('Mutations', 'REM_NODE_PROB')\\n\\n self.MUT_GENE_AMP = self.config_file.getfloat('Mutations', 'MUT_GENE_AMP')\\n self.WEIGHT_AMP = self.config_file.getfloat('Mutations', 'WEIGHT_AMP')\\n\\n self.GENE_PROB_FACT = self.config_file.getfloat('Mutations', 'GENE_PROB_FACT')\\n self.NODE_PROB_FACT = self.config_file.getfloat('Mutations', 'NODE_PROB_FACT')\\n self.AMP_MUT_FACT = self.config_file.getfloat('Mutations', 'AMP_MUT_FACT')\\n\\n # Elitism and extinction\\n self.ELITISM_NUMBER = self.config_file.getint('Crossover', 'ELITISM_NUMBER')\\n self.EXTINCTION_NUMBER = self.config_file.getint('Crossover', 'EXTINCTION_NUMBER')\\n\\n # Training conditions\\n self.FITNESS_CRITERION = self.config_file.get('Training', 'FITNESS_CRITERION')\\n self.FITNESS_THRESHOLD = self.config_file.getfloat('Training', 'FITNESS_THRESHOLD')\\n\\n # Check the loaded configuration\\n self.__check_config()\",\n \"def readQrelsDict(fileName):\\n result = {}\\n for e in readQrels(fileName):\\n result.setdefault(e.queryId, {})[e.docId] = int(e.relGrade)\\n return result\",\n \"def read_graph(args):\\n dataset = pd.read_csv(args.features_path).values.tolist()\\n edges = {}\\n edges[\\\"positive_edges\\\"] = [edge[0:2] for edge in dataset if edge[2] == 1]\\n edges[\\\"negative_edges\\\"] = [edge[0:2] for edge in dataset if edge[2] == -1]\\n edges[\\\"ecount\\\"] = len(dataset)\\n edges[\\\"ncount\\\"] = len(set([edge[0] for edge in dataset]+[edge[1] for edge in dataset]))\\n return edges\",\n \"def load_graph(path):\\r\\n \\r\\n # initialise dictionary\\r\\n graph_dict = {}\\r\\n \\r\\n # open File for reading\\r\\n graph_file = open(path,'r')\\r\\n \\r\\n # initialise list of all the lines\\r\\n graph_lines = graph_file.readlines() \\r\\n print (\\\"Loaded graph has\\\", len(graph_lines), \\\"nodes\\\")\\r\\n # For all lines get node and edges and put them to SET\\r\\n for line in graph_lines:\\r\\n line = line.rstrip('\\\\n')\\r\\n neighbors = line.split(' ')\\r\\n #node = int(neighbors[0])\\r\\n node = neighbors[0]\\r\\n graph_dict[node] = set([])\\r\\n for neighbor in neighbors[1:]:\\r\\n #graph_dict[node].add(int(neighbor))\\r\\n graph_dict[node].add(neighbor)\\r\\n return graph_dict\",\n \"def retrieve_sequences_pickle(working_directory, genes):\\n\\n sequences_per_gene = {}\\n for gene in genes:\\n with open(os.path.join(working_directory, \\\"sequences\\\", gene + \\\".pkl\\\"), 'rb') as handle:\\n sequences = pickle.load(handle) \\n sequences_per_gene.update({gene:sequences})\\n return sequences_per_gene\",\n \"def load_in_weights():\\n path = os.path.join(\\n DATA_RAW, 'intermediate', 'population_weights.csv'\\n )\\n\\n population_data = []\\n\\n with open(path, 'r') as source:\\n reader = csv.DictReader(source)\\n for line in reader:\\n population_data.append({\\n 'id': line['postcode_sector'],\\n 'domestic_delivery_points': int(line['domestic_delivery_points']),\\n })\\n\\n return population_data\",\n \"def read_refgene_file(self, file_path):\\n with open(file_path) as fi:\\n for line in fi:\\n content = line.strip().split()\\n refgene = RefGene()\\n refgene.bin = int(content[0])\\n refgene.name, refgene.chrom, refgene.strand = content[1], content[2].lower(), content[3]\\n refgene.tx_start, refgene.tx_end = int(content[4]), int(content[5])\\n refgene.cds_start, refgene.cds_end = int(content[6]), int(content[7])\\n refgene.exon_count = int(content[8])\\n refgene.exon_starts = [int(e) for e in content[9][:-1].split(',')]\\n refgene.exon_ends = [int(e) for e in content[10][:-1].split(',')]\\n refgene.core, refgene.name2 = int(content[11]), content[12]\\n refgene.cds_start_stat, refgene.cds_end_stat = content[13], content[14]\\n # refgene.exon_frames = [int(e) for e in content[15][:-1].split(',')]\\n self.ref_genes.append(refgene)\",\n \"def reagent_parser(self, filename, initial_dictlist = dict()):\\n results = initial_dictlist\\n\\n filepath = os.path.join(self.base_dir, filename)\\n\\n with open(filepath, 'r') as fileobj:\\n xml = fileobj.read()\\n parsed = BeautifulSoup(xml, \\\"lxml-xml\\\")\\n\\n substances = parsed.find_all(\\\"substance\\\")\\n\\n # iterates for every substance in file\\n for substance in substances:\\n\\n # pulls the Beilstein Registry number\\n rn = substance.find(\\\"IDE.XRN\\\").text\\n\\n # finds all molfiles, indicated by \\\"YY.STR\\\"\\n molfiles = substance.find_all(\\\"YY.STR\\\")\\n\\n # V2000 files always follow V3000 files if V3000 files are available\\n # if V3000 files are not available, V2000 files are the first and only file\\n # we are only using V2000 files\\n try:\\n\\n # if possible, converts the second file (the V2000 file) to SMILES\\n mymol = readstring(\\\"mol\\\", molfiles[1].text)\\n smi = mymol.write(str(\\\"smi\\\")).split()[0]\\n\\n results[rn] = smi\\n except:\\n\\n # occurs when only zero or one file listed for specific registry number\\n try:\\n\\n # if possible, converts the first file (the V2000 file) to SMILES\\n mymol = readstring(\\\"mol\\\", molfiles[0].text)\\n smi = mymol.write(str(\\\"smi\\\")).split()[0]\\n\\n results[rn] = smi\\n except:\\n\\n # if not file is listed for the registry number, skips that number\\n continue\\n\\n return results\",\n \"def adjList(self, relations):\\n adj = {}\\n for agent in self.agents:\\n adj[agent] = {}\\n for agent in self.agents:\\n for relation in relations[agent]:\\n if relation[0] not in adj[agent].keys():\\n adj[agent][relation[0]] = []\\n adj[agent][relation[0]].append(relation[1])\\n return adj\",\n \"def load_fasta(filepath):\\n chromosomes = {}\\n\\n seqs = SeqIO.parse(filepath, format='fasta', \\n alphabet=IUPAC.ambiguous_dna)\\n\\n # iterate over seqs and add to chromosome dictionary\\n for seq in seqs:\\n # determine chromosome number\\n match = re.search('\\\\d+', seq.name)\\n chromosome_number = int(match.group())\\n\\n chromosomes[chromosome_number] = seq\\n\\n return chromosomes\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67748284","0.6408295","0.61751515","0.5888248","0.58689374","0.58549124","0.583973","0.58324826","0.5831974","0.5760128","0.5753357","0.57407457","0.5708623","0.56422573","0.5570306","0.555868","0.55579597","0.5540641","0.5510702","0.5494685","0.54943776","0.5435264","0.5432302","0.54095805","0.53876793","0.5375351","0.5359419","0.535692","0.5339561","0.5333317","0.53261656","0.53189653","0.5314712","0.5311413","0.53073496","0.52967685","0.5296221","0.52895284","0.5284479","0.52594185","0.5248324","0.5247529","0.524254","0.5240922","0.5238178","0.5233637","0.5229005","0.52242655","0.5224137","0.5212894","0.5208631","0.5193043","0.51867014","0.5185889","0.51839256","0.5183518","0.51714534","0.51690435","0.51654756","0.51597244","0.51513356","0.514221","0.5141715","0.5135344","0.51299316","0.51260024","0.51216054","0.5120641","0.51177853","0.51171213","0.5113064","0.51114357","0.5104566","0.51018167","0.50916064","0.5088589","0.50867087","0.50809795","0.5078697","0.5057527","0.5056745","0.50543773","0.504736","0.5045891","0.50417554","0.50391746","0.5030884","0.5029677","0.502274","0.5020437","0.50201964","0.50194067","0.5018816","0.50180024","0.50064266","0.5006179","0.50018066","0.50015837","0.49929062","0.49849498"],"string":"[\n \"0.67748284\",\n \"0.6408295\",\n \"0.61751515\",\n \"0.5888248\",\n \"0.58689374\",\n \"0.58549124\",\n \"0.583973\",\n \"0.58324826\",\n \"0.5831974\",\n \"0.5760128\",\n \"0.5753357\",\n \"0.57407457\",\n \"0.5708623\",\n \"0.56422573\",\n \"0.5570306\",\n \"0.555868\",\n \"0.55579597\",\n \"0.5540641\",\n \"0.5510702\",\n \"0.5494685\",\n \"0.54943776\",\n \"0.5435264\",\n \"0.5432302\",\n \"0.54095805\",\n \"0.53876793\",\n \"0.5375351\",\n \"0.5359419\",\n \"0.535692\",\n \"0.5339561\",\n \"0.5333317\",\n \"0.53261656\",\n \"0.53189653\",\n \"0.5314712\",\n \"0.5311413\",\n \"0.53073496\",\n \"0.52967685\",\n \"0.5296221\",\n \"0.52895284\",\n \"0.5284479\",\n \"0.52594185\",\n \"0.5248324\",\n \"0.5247529\",\n \"0.524254\",\n \"0.5240922\",\n \"0.5238178\",\n \"0.5233637\",\n \"0.5229005\",\n \"0.52242655\",\n \"0.5224137\",\n \"0.5212894\",\n \"0.5208631\",\n \"0.5193043\",\n \"0.51867014\",\n \"0.5185889\",\n \"0.51839256\",\n \"0.5183518\",\n \"0.51714534\",\n \"0.51690435\",\n \"0.51654756\",\n \"0.51597244\",\n \"0.51513356\",\n \"0.514221\",\n \"0.5141715\",\n \"0.5135344\",\n \"0.51299316\",\n \"0.51260024\",\n \"0.51216054\",\n \"0.5120641\",\n \"0.51177853\",\n \"0.51171213\",\n \"0.5113064\",\n \"0.51114357\",\n \"0.5104566\",\n \"0.51018167\",\n \"0.50916064\",\n \"0.5088589\",\n \"0.50867087\",\n \"0.50809795\",\n \"0.5078697\",\n \"0.5057527\",\n \"0.5056745\",\n \"0.50543773\",\n \"0.504736\",\n \"0.5045891\",\n \"0.50417554\",\n \"0.50391746\",\n \"0.5030884\",\n \"0.5029677\",\n \"0.502274\",\n \"0.5020437\",\n \"0.50201964\",\n \"0.50194067\",\n \"0.5018816\",\n \"0.50180024\",\n \"0.50064266\",\n \"0.5006179\",\n \"0.50018066\",\n \"0.50015837\",\n \"0.49929062\",\n \"0.49849498\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.51426554"},"document_rank":{"kind":"string","value":"61"}}},{"rowIdx":91991,"cells":{"query":{"kind":"string","value":"Return pandas dataframe with annual, quarterly, monthly or daily data."},"document":{"kind":"string","value":"def get_frame(freq: str):\n url = 'http://minikep-db.herokuapp.com/api/frame?freq={}'.format(freq)\n return pd.read_csv(url, converters={0: pd.to_datetime}, index_col=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 get_time_series_data():\r\n # Grab the requested years and columns from the query arguments\r\n ls_year = [int(year) for year in request.args.getlist(\"n\")]\r\n ls_col = request.args.getlist(\"m\")\r\n\r\n # Generate a list of all the months we need to get\r\n all_years = [str(year) for year in range(min(ls_year), max(ls_year) + 1)]\r\n\r\n # Grab all of the wanted months by filtering for the ones we want\r\n wanted_months = reduce(\r\n lambda a, b: a | b, (app.df[\"month\"].str.contains(year) for year in all_years)\r\n )\r\n\r\n # Create a new dataframe from the one that\r\n df_new = app.df[wanted_months][[\"month\"] + ls_col]\r\n\r\n # Convert all string dates into datetime objects and then sort them\r\n df_new[\"month\"] = pd.to_datetime(df_new[\"month\"])\r\n df_new = df_new.sort_values(by=[\"month\"])\r\n\r\n # Return the dataframe as json\r\n return df_new.to_json(), 200","def to_DataFrame(cls, qs):\n dates = [pd.to_datetime(x[0]) for x in qs.values_list('date')]\n data = qs.values('open', 'close', 'high', 'low', 'volume')\n df = pd.DataFrame.from_records(data, index=dates)\n return df","def to_dataframe(self, include_metadata: bool = True) -> pd.DataFrame:\n # Get all our data first with async\n # Note that all our pandas work will tax CPU so we wouldn't expect any\n # performance gains from doing the data parsing as a callback\n records = self.to_dict()\n data = []\n for series in records:\n df = pd.DataFrame(series.pop(\"data\"), columns=[\"period\", \"value\"])\n if include_metadata:\n df = df.assign(**series)\n data.append(df)\n return pd.concat(data, ignore_index=True)","def all_data(self):\n return pd.concat([self.historic_data, self.dayahead_data])","def __get_all_data(self,tickr):\n self.__csvurl=f\"https://query1.finance.yahoo.com/v7/finance/download/{tickr}?period1=1092873600&period2={int(datetime.now().timestamp())}&interval=1d&events=history&includeAdjustedClose=true\"\n s=get_historic_data(self.__csvurl)\n\n \"\"\"you should not be able to access dataframe from outside the class\"\"\"\n df=pd.read_csv(io.StringIO(s.decode('utf-8')))\n df=df.dropna()\n df_columns=['Date','High','Low','Close','Adj Close']\n\n if not set(df_columns).issubset(df.columns):\n raise ValueError(f\"One or more columns are missing {df_columns}\")\n\n if len(df.index)<5:\n raise ValueError(f\"Cannot calculate EMA 5\")\n\n if len(df.index)<20:\n raise ValueError(f\"Cannot calculate SMA 20\")\n\n \"\"\"set date as index (required for filtering,sorting,grouping etc etc\"\"\"\n df['Date'] = pd.to_datetime(df['Date'], format = '%Y-%m-%d')\n\n df.set_index(['Date'], inplace=True)\n\n\n return df","def TimeFrame(*args, **kwargs):\n underride(kwargs, dtype=float)\n return pd.DataFrame(*args, **kwargs)","def get_alpaca_data(self,ticker_list,start,end, timeframe = \"1D\"):\n s = pd.Timestamp(start,tz = \"America/New_York\").isoformat()\n e = pd.Timestamp(end,tz = \"America/New_York\").isoformat()\n \n df = api.get_barset(\n ticker_list,\n timeframe,\n start = s,\n end = e\n\n ).df\n return df","def data(self):\n dfdata = pd.concat([self.weights, self.returns, self.category], axis=1)\n dfdata.columns = ['weights', 'returns', self.category_name]\n if self.period is not None:\n dfdata['date'] = self.period\n return dfdata","def get_daily_historic_data(self, ticker, start_date, end_date):\n av_url = self._construct_alpha_vantage_symbol_call(ticker)\n\n try:\n av_data_js = requests.get(av_url)\n data = json.loads(av_data_js.text)['Time Series (Daily)']\n except Exception as e:\n print(\n \"Could not download AlphaVantage data for %s ticker \"\n \"(%s)...stopping.\" % (ticker, e)\n )\n return pd.DataFrame(columns=COLUMNS).set_index('Date')\n else:\n prices = []\n for date_str in sorted(data.keys()):\n date = dt.strptime(date_str, '%Y-%m-%d')\n if date < start_date or date > end_date:\n continue\n\n bar = data[date_str]\n prices.append(\n (\n date, \n float(bar['1. open']),\n float(bar['2. high']),\n float(bar['3. low']),\n float(bar['4. close']),\n int(bar['6. volume']),\n float(bar['5. adjusted close'])\n )\n )\n price_df = pd.DataFrame(prices, columns=COLUMNS).set_index('Date').sort_index()\n self._correct_back_adjusted_prices(price_df)\n return price_df","def timeseries_dataframe(self):\n return","def setup_df(ticker):\n stock = yf.Ticker(ticker)\n df = stock.history(period=\"max\")\n del df['Dividends']\n del df['Stock Splits']\n return df","def _get_annualData(self, dataType):\n\n if dataType == \"financials\":\n if self._financials is not None:\n return\n url = self._url_financials\n else:\n if self._keyRatios is not None:\n return\n url = self._url_keyRatios\n\n # Credit to Andrej Kesely\n # https://stackoverflow.com/users/10035985/andrej-kesely\n # https://stackoverflow.com/questions/56691753/cant-find-table-using-beautiful-soup-on-morningstar\n\n soup = BeautifulSoup(json.loads(re.findall(\n r'xxx\\((.*)\\)', requests.get(url).text)[0])['componentData'], 'lxml'\n )\n\n table = utils.get_table(soup)\n df = pd.DataFrame(table[1:], columns=table[0])\n df = df.replace(\"—\", nan)\n\n index_col = df.columns[0]\n df = df.set_index(index_col)\n\n # only financials contain currency\n if dataType == \"financials\":\n self.currency_financials = self._get_currency(df)\n df = df.rename_axis(index={\"X\": f\"Financials {self.currency_financials}\"})\n \n df = df.T\n\n # TODO: convert dtypes\n\n if dataType == \"financials\":\n self._financials = df\n else:\n self._keyRatios = df","def get_data(symbols, dates, base_dir=\"../data/\"):\n df = pd.DataFrame(index=dates)\n if 'SPY' not in symbols:\n symbols.insert(0, 'SPY')\n\n for symbol in symbols:\n temp_df = pd.read_csv(symbol_to_path(symbol, base_dir), index_col='Date',\n parse_dates=True, usecols=['Date', 'Close'],\n na_values=['nan'])\n temp_df = temp_df.rename(columns={'Close': symbol})\n df = df.join(temp_df, how='inner')\n return df","def get_equal_dataframe() -> pandas.DataFrame:\n data = {\n 'InvoiceDate': ['2009-01', '2012-01'],\n 'Count': [4, 4],\n 'Total': [8198.79, 5323.15]\n }\n return pandas.DataFrame(data, columns=['InvoiceDate', 'Count', 'Total'])","def get_data(symbols, dates):\n df = pd.DataFrame(index=dates)\n if \"SPY\" not in symbols:\n symbols.insert(0, \"SPY\")\n for symbol in symbols:\n temp = pd.read_csv(symbol_to_path(symbol, base_dir=\"data\"), \n index_col=\"Date\", \n parse_dates=True, \n usecols=[\"Date\", \"Adj Close\"])\n \n temp = temp.rename(columns={\"Adj Close\": symbol})\n \n df = df.join(temp, how=\"inner\")\n df = df.sort_index(axis=0, ascending=[1])\n \n return df","def stock_data(ticker, start,today=date.today()):\n df= web.DataReader(ticker,'yahoo',start,today)\n return df","def chart_data(indicator, start, period, centre='all', lim=2020):\r\n x = pd.DataFrame()\r\n logging.info((indicator, centre))\r\n d = [t.strftime(\"%Y%m\") for t in pd.date_range(start=start, periods=period/3, freq='-3M')]\r\n for date in d:\r\n x = x.append(met(indicator, date, cent=centre, lim=lim))\r\n print('.', end='')\r\n return x","def get_date_df():\n dt_df = pd.read_csv('data/date.csv')\n dt_df['from'] = pd.to_datetime(dt_df['from'])\n dt_df['from_year'] = dt_df['from'].apply(lambda x: x.year)\n dt_df['from_month'] = dt_df['from'].apply(lambda x: x.month)\n dt_df['to'] = pd.to_datetime(dt_df['to'])\n dt_df['to_year'] = dt_df['from'].apply(lambda x: x.year)\n dt_df['to_month'] = dt_df['from'].apply(lambda x: x.month)\n return dt_df","def read_and_prepare_dataframe(start_date='1980-01-01'):\n \n # Read the dataset and rename 'dt' to 'Date'\n df = pd.read_csv('Data/GlobalLandTemperaturesByCountry.csv', parse_dates=['dt'])\n df.rename(columns={'dt':'Date'}, inplace=True)\n \n # Filter for Canada\n df = df[df['Country']=='Canada']\n \n # Filter out data prior to start date\n df = df[df['Date'] >= start_date]\n \n # To ensure data is sorted\n df = df.sort_values('Date')\n \n # Set index to Date and return the final dataframe\n return df.set_index('Date')","def test_df_contents(self):\n df_out = annualize(dat, period_label=\"fqtr\", period_val=4)\n\n assert all(df_out['fqtr'] == 4), \"Error, the DataFrame has data from the wrong period.\"","def get_dataframe(self,tickers = None,variable = \"close\",normalization = True):\n if tickers is not None:\n companies = self[tickers]\n else:\n companies = self.data \n\n data = pd.concat([company.data[[variable]].rename(columns = {variable:company.ticker}) for company in companies],axis = 1)\n \n if normalization:\n data /= data.max(axis = 0)\n \n return data","def get_data(symbols, dates):\n df = pd.DataFrame(index=dates)\n if 'SPY' not in symbols: # add SPY for reference, if absent\n symbols.insert(0, 'SPY')\n\n for symbol in symbols:\n # TODO: Read and join data for each symbol\n df_temp = pd.read_csv(symbol_to_path(symbol),\n index_col=\"Date\",\n parse_dates=True,\n usecols=['Date', 'Adj Close'],\n na_values=['nan'])\n df_temp = df_temp.rename(columns={'Adj Close': symbol})\n df = df.join(df_temp)\n\n df = df.dropna()\n return df","def _year_days(year):\n return pd.DataFrame({'time': pd.date_range(f'{year}-01-01', f'{year}-12-31')})","def get_data(symbols, dates):\r\n df = pd.DataFrame(index=dates)\r\n if 'SPY' not in symbols: # add SPY for reference, if absent\r\n symbols.insert(0, 'SPY')\r\n\r\n for symbol in symbols:\r\n df_temp = pd.read_csv(symbol_to_path(symbol), index_col=\"Date\", parse_dates=True,\r\n usecols=['Date', 'Adj Close'], na_values=['nan'])\r\n\r\n # rename to prevent clash\r\n df_temp = df_temp.rename(columns={'Adj Close': symbol})\r\n df = df.join(df_temp)\r\n if symbol == 'SPY': #drop dates SPY did not trade\r\n df = df.dropna(subset=[\"SPY\"])\r\n\r\n return df","def get_data(symbols, dates):\n df = pd.DataFrame(index=dates)\n if 'SPY' not in symbols: # add SPY for reference, if absent\n symbols.insert(0, 'SPY')\n\n for symbol in symbols:\n # TODO: Read and join data for each symbol\n path = symbol_to_path(symbol)\n df_tmp = pd.read_csv(path, index_col=\"Date\", parse_dates=True,\n usecols=['Date', 'Adj Close'], na_values=['nan'])\n df_tmp = df_tmp.rename(columns={'Adj Close':symbol})\n # or use inner join to drop the NaN values\n df = df.join(df_tmp, how='inner')\n return df","def get_weather(latitude: float, longitude: float, year: int) -> DataFrame:\n # Set time period\n start = datetime(year, 1, 1)\n end = datetime(year, 12, 31)\n\n # Create Point for NYC\n location = Point(latitude, longitude)\n\n # Get daily data for the year\n data = Daily(location, start, end)\n return data.fetch()","def create_dataframe():\r\n\r\n df = pd.read_csv('data/data.csv', header=0)\r\n return df","def extract_and_append_year_month_quarter(self, data_frame, column_name):\n columns = self.extract_year_month_quarter(data_frame[column_name])\n periods_df = pd.DataFrame({\"Year\":columns[0],\"Monthly\": columns[1], \"Quarterly\": columns[2]})\n return pd.concat([data_frame.reset_index(), periods_df], axis='columns', join=\"inner\")","def get_dataframe(start_date=INITIAL_DATE, end_date=None) -> pd.DataFrame:\n\n end_date = (\n end_date\n if end_date is not None\n else dt.datetime.utcnow() - dt.timedelta(days=1)\n ).date()\n\n dates = pd.date_range(start_date, end_date)\n\n with futures.ThreadPoolExecutor() as ex:\n\n df = pd.concat(ex.map(get_dataframe_for_date, dates))\n\n df.rename(columns=str.lower, inplace=True)\n\n df.drop(columns=[c for c in df.columns if \"/\" in c], inplace=True)\n\n df[\"datetime\"] = pd.to_datetime(df[\"last_update\"])\n\n df[\"date\"] = df.datetime.map(lambda d: d.date())\n\n # df[\"county\"] = df.admin2\n renames = {\n \"country_region\": \"country\",\n \"province_state\": \"state\",\n \"admin2\": \"county\",\n }\n\n df.rename(columns=renames, inplace=True)\n\n df.drop(\n columns=[\"last update\", \"last_update\", \"lat\", \"long_\", \"combined_key\"],\n inplace=True,\n )\n\n return df","def dataframe(self):\n df = pd.DataFrame({'x':self.x, 'y':self.y, 'd':self.d})\n\n if self.z is not None:\n for k, v in self.z.items():\n df[k] = v\n\n return df","def get_data(symbols, dates):\n \n df = pd.DataFrame(index=dates)\n if 'SPY' not in symbols:\n symbols.insert(0,'SPY')\n for symbol in symbols:\n \n df1 = pd.read_csv(symbol_to_path(symbol),usecols=['Date','Adj Close'],\n index_col='Date',na_values =['nan'] )\n df1 = df1.rename(columns ={\"Adj Close\": symbol}) \n #print df1\n df = df.join(df1,how='inner')\n \n return df.sort_index()","def get_dataframe(self):\n self.logger.info('Fetching movie records...')\n session = connect()\n\n cols = [\n Movie.movie_id,\n Movie.title,\n Movie.start_year,\n Movie.genres,\n Movie.description,\n Movie.kind,\n ]\n\n filters = [\n Movie.description.isnot(None),\n Movie.genres.isnot(None),\n ]\n\n query = session.query(*cols).filter(*filters).order_by(Movie.start_year.desc())\n\n try:\n return pd.read_sql(query.statement, session.bind)\n finally:\n session.close()","def get_data(symbols, dates):\n df = pd.DataFrame(index=dates)\n if 'SPY' not in symbols: # add SPY for reference, if absent\n symbols.insert(0, 'SPY')\n\n for symbol in symbols:\n # TODO: Read and join data for each symbol\n df_temp = pd.read_csv(symbol_to_path(symbol), index_col='Date',\n parse_dates=True, usecols=['Date', 'Adj Close'],\n na_values=['nan'])\n df_temp = df_temp.rename(columns={'Adj Close' : symbol})\n df = df.join(df_temp)\n if symbol == 'SPY':\n df = df.dropna(subset=['SPY'])\n\n return df","def _get_exog_data(cls, exog_start, exog_end, index):\n import pandas as pd\n\n holiday_calendar = LADHolidays()\n holiday_series = holiday_calendar.holidays(start=exog_start, end=exog_end, return_name=True)\n return (pd.DataFrame({'Holiday': holiday_series, 'Ones': 1})\n .pivot(columns='Holiday', values='Ones')\n .reindex(index)\n .fillna(0)\n )","def get_dataframes(symbols=(\"sne\", \"goog\", \"tsla\"), source='yahoo', refresh=False):\n symbols = util.make_symbols(list(symbols))\n if refresh:\n symbols_to_refresh = symbols\n else:\n symbols_to_refresh = [sym for sym in symbols if not Equity.objects.filter(symbol=sym).exists()]\n source = source.lower().strip()\n if source in ('yahoo', 'google'):\n source += '_finance'\n if source[:3] == 'fed':\n source = 'federal_reserve_economic_data'\n ccpanda = ccp.ConcurrentPandas()\n # set the data source\n getattr(ccpanda, \"set_source_\" + source)()\n if symbols_to_refresh:\n # tell concurrent pandas which keys/symbols to retrieve\n ccpanda.insert_keys(symbols_to_refresh)\n # start concurrentpandas threads\n ccpanda.consume_keys_asynchronous_threads()\n # FIXME: is there a better/faster iterator to use like `ccpanda.output_map` attribute?\n pseudodict = ccpanda.return_map()\n else:\n pseudodict = {}\n table = {}\n for sym in symbols:\n e, created = None, False\n if not sym in symbols_to_refresh:\n e, created = Equity.objects.get_or_create(symbol=sym)\n if created or not e or not e.time_series or sym in symbols_to_refresh:\n e, created = Equity.objects.get_or_create(\n symbol=sym,\n name=sym, # FIXME: use data source to find equity name!\n time_series=pseudodict[sym].to_json(),\n )\n table[sym] = pd.io.json.read_json(path_or_buf=e.time_series, orient='columns', typ='frame', convert_dates=True)\n return table","def dataframe(self):\n if not self.all_records:\n print('No rows cached.')\n return\n dict_list = [row.as_dict() for row in self.all_records]\n columns = self.all_records[0].keys\n dataframe = pd.DataFrame(dict_list, columns=columns)\n return dataframe","def asfreq(self, **kwargs): # noqa: PR01\n return DataFrameDefault.register(pandas.DataFrame.asfreq)(self, **kwargs)","def get_dummy_data(num_days, low, high, end_date='1970-01-01'):\n step = (high - low) / (num_days - 1)\n ref = datetime.strptime(end_date, '%Y-%m-%d').date()\n start_dt = ref - timedelta(days=(num_days - 1))\n end_dt = ref + timedelta(days=1)\n ts = np.arange(start_dt, end_dt, timedelta(days=1)).astype(date)\n df = pd.DataFrame(data={'price': np.arange(low, high + 1, step)}, index=pd.DatetimeIndex(ts))\n df.index.name = 'date'\n return df","def dataframe(self):\n\n if self._dataframe is None:\n try:\n import pandas as pd\n except ImportError:\n raise RuntimeError('To enable dataframe support, '\n 'run \\'pip install datadotworld[pandas]\\'')\n\n self._dataframe = pd.DataFrame.from_records(self._iter_rows(),\n coerce_float=True)\n\n return self._dataframe","def as_dataframe(self) -> \"pd.DataFrame\":\n import pandas as pd\n\n df = pd.DataFrame([row.as_series() for row in self.rows])\n return df","def read_historical_data():\n pull_dir = \"/common/quidel-historical-raw\"\n columns = ['SofiaSerNum', 'TestDate', 'Facility', 'ZipCode',\n 'FluA', 'FluB', 'StorageDate']\n df = pd.DataFrame(columns=columns)\n\n for fn in os.listdir(pull_dir):\n if \"xlsx\" in fn:\n newdf = pd.read_excel(\"/\".join([pull_dir, fn]))\n df = df.append(newdf[columns])\n return df","def technicalIndicatorsDf(daily_data):\n o = daily_data['Open'].values\n c = daily_data['Close'].values\n h = daily_data['High'].values\n l = daily_data['Low'].values\n v = daily_data['Volume'].astype(float).values\n # define the technical analysis matrix\n\n # Most data series are normalized by their series' mean\n ta = {} #pd.DataFrame()\n ta['MA5'] = talib.MA(c, timeperiod=5)\n ta['MA10'] = talib.MA(c, timeperiod=10)\n ta['MA20'] = talib.MA(c, timeperiod=20)\n ta['MA60'] = talib.MA(c, timeperiod=60)\n ta['MA120'] = talib.MA(c, timeperiod=120)\n ta['MA5'] = talib.MA(v, timeperiod=5)\n ta['MA10'] = talib.MA(v, timeperiod=10)\n ta['MA20'] = talib.MA(v, timeperiod=20)\n ta['ADX'] = talib.ADX(h, l, c, timeperiod=14)\n ta['ADXR'] = talib.ADXR(h, l, c, timeperiod=14)\n ta['MACD'] = talib.MACD(c, fastperiod=12, slowperiod=26, signalperiod=9)[0]\n ta['RSI'] = talib.RSI(c, timeperiod=14)\n ta['BBANDS_U'] = talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[0]\n ta['BBANDS_M'] = talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[1]\n ta['BBANDS_L'] = talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[2]\n ta['AD'] = talib.AD(h, l, c, v) \n ta['ATR'] = talib.ATR(h, l, c, timeperiod=14) \n ta['HT_DC'] = talib.HT_DCPERIOD(c) \n ta[\"High/Open\"] = h / o\n ta[\"Low/Open\"] = l / o\n ta[\"Close/Open\"] = c / o\n ta['Open'] = o\n ta['Close'] = c\n ta['High'] = h\n ta['Low'] = l\n ta['Volume'] = v\n\n # Normalized values\n ta['MA5-normalized'] = talib.MA(c, timeperiod=5) / np.nanmean(talib.MA(c, timeperiod=5))\n ta['MA10-normalized'] = talib.MA(c, timeperiod=10) / np.nanmean(talib.MA(c, timeperiod=10))\n ta['MA20-normalized'] = talib.MA(c, timeperiod=20) / np.nanmean(talib.MA(c, timeperiod=20))\n ta['MA60-normalized'] = talib.MA(c, timeperiod=60) / np.nanmean(talib.MA(c, timeperiod=60))\n ta['MA120-normalized'] = talib.MA(c, timeperiod=120) / np.nanmean(talib.MA(c, timeperiod=120))\n ta['MA5-normalized'] = talib.MA(v, timeperiod=5) / np.nanmean(talib.MA(v, timeperiod=5))\n ta['MA10-normalized'] = talib.MA(v, timeperiod=10) / np.nanmean(talib.MA(v, timeperiod=10))\n ta['MA20-normalized'] = talib.MA(v, timeperiod=20) / np.nanmean(talib.MA(v, timeperiod=20))\n ta['ADX-normalized'] = talib.ADX(h, l, c, timeperiod=14) / np.nanmean(talib.ADX(h, l, c, timeperiod=14))\n ta['ADXR-normalized'] = talib.ADXR(h, l, c, timeperiod=14) / np.nanmean(talib.ADXR(h, l, c, timeperiod=14))\n ta['MACD-normalized'] = talib.MACD(c, fastperiod=12, slowperiod=26, signalperiod=9)[0] / \\\n np.nanmean(talib.MACD(c, fastperiod=12, slowperiod=26, signalperiod=9)[0])\n ta['RSI-normalized'] = talib.RSI(c, timeperiod=14) / np.nanmean(talib.RSI(c, timeperiod=14))\n ta['BBANDS_U-normalized'] = talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[0] / \\\n np.nanmean(talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[0])\n ta['BBANDS_M-normalized'] = talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[1] / \\\n np.nanmean(talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[1])\n ta['BBANDS_L-normalized'] = talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[2] / \\\n np.nanmean(talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[2])\n ta['AD-normalized'] = talib.AD(h, l, c, v) / np.nanmean(talib.AD(h, l, c, v))\n ta['ATR-normalized'] = talib.ATR(h, l, c, timeperiod=14) / np.nanmean(talib.ATR(h, l, c, timeperiod=14))\n ta['HT_DC-normalized'] = talib.HT_DCPERIOD(c) / np.nanmean(talib.HT_DCPERIOD(c))\n return ta","def time_series_daily(symbol: str, outputsize: str = 'compact') -> Tuple[pd.DataFrame, dict]:\n response = _fetch(symbol=symbol, function='TIME_SERIES_DAILY', outputsize=outputsize)\n\n response_dict = json.loads(response.content)\n\n df = pd.DataFrame.from_dict(response_dict[f'Time Series (Daily)'], orient='index', dtype=np.float64)\n df.index = pd.to_datetime(df.index)\n df = df.rename(columns=_string_map(df.columns))\n\n metadata = response_dict['Meta Data']\n _rename_dict_keys(metadata)\n\n metadata['begin_datetime'] = df.index.min()\n metadata['end_datetime'] = df.index.max()\n\n return df, metadata","def fetchOHLC(ticker,interval,duration):\r\n instrument = instrumentLookup(instrument_df,ticker)\r\n data = pd.DataFrame(kite.historical_data(instrument,dt.date.today()-dt.timedelta(duration), dt.date.today(),interval))\r\n data.set_index(\"date\",inplace=True)\r\n return data","def price_dataframe(symbols=('sne',),\n start=datetime.datetime(2008, 1, 1),\n end=datetime.datetime(2009, 12, 31),\n price_type='actual_close',\n cleaner=util.clean_dataframe,\n ):\n if isinstance(price_type, basestring):\n price_type = [price_type]\n start = nlp.util.normalize_date(start or datetime.date(2008, 1, 1))\n end = nlp.util.normalize_date(end or datetime.date(2009, 12, 31))\n symbols = util.make_symbols(symbols)\n df = get_dataframes(symbols)\n # t = du.getNYSEdays(start, end, datetime.timedelta(hours=16))\n # df = clean_dataframes(dataobj.get_data(t, symbols, price_type))\n if not df or len(df) > 1:\n return cleaner(df)\n else:\n return cleaner(df[0])","def dataframe(self, *args, **kwargs):\n\n from pandas import DataFrame\n\n # Just normal data, so use the iterator in this object.\n headers = next(islice(self, 0, 1))\n data = islice(self, 1, None)\n\n return DataFrame(list(data), columns=headers)","def data_frame_creator(self):\n\n return pd.DataFrame()","def to_pandas_df(self):\n data = self._get_data(pd=True)\n return data","def get_dataframe(self, index=0):\n import pandas\n data = self.get_data(index)\n columns = self.get_legend(index)\n df = pandas.DataFrame(data, columns=columns)\n return df","def all(self, **kwargs): # noqa: PR02\n return DataFrameDefault.register(pandas.DataFrame.all)(self, **kwargs)","def fetchOHLC(ticker,interval,duration):\n instrument = instrumentLookup(instrument_df,ticker)\n data = pd.DataFrame(kite.historical_data(instrument,dt.date.today()-dt.timedelta(duration), dt.date.today(),interval))\n data.set_index(\"date\",inplace=True)\n return data","def gen_SMA_df(ticker=None):\n if ticker is None or not isinstance(ticker, str):\n return None\n \n data = yf.Ticker(ticker)\n data = data.history(period='360d')\n data = data[DESIRED_COLUMNS]\n \n SMA_LONG_data = data.rolling(window=WINDOW_LONG).mean()\n SMA_LONG_data = SMA_LONG_data.rename(columns={'Close': 'SMA_LONG_Close'})\n SMA_LONG_data = SMA_LONG_data.dropna()\n\n SMA_SHORT_data = data.rolling(window=WINDOW_SHORT).mean()\n SMA_SHORT_data = SMA_SHORT_data.rename(columns={'Close': 'SMA_SHORT_Close'})\n SMA_SHORT_data = SMA_SHORT_data.dropna()\n\n EWA_data = data.ewm(span=WINDOW_SHORT, min_periods=WINDOW_SHORT).mean()\n EWA_data = EWA_data.rename(columns={'Close': 'EWA_Close'})\n\n \n SMA_join = SMA_LONG_data.join(SMA_SHORT_data).join(EWA_data).join(data)\n SMA_join = SMA_join.rename(columns={'Close': 'Single_Day_Close'})\n return SMA_join","def taxa_data_frame(self):\n cols = list(self._taxa.keys())\n cols.remove(\"uid\")\n cols.remove(\"object\")\n df = DataFrame(self._taxa, columns=cols, index=self._taxa[\"uid\"])\n df.index.name = \"uid\"\n\n return df","def select_data(data=pd.DataFrame(), date_initial=\"2005-01-01\", date_final=\"2019-12-31\"):\n data = data[data.index >= date_initial]\n data = data[data.index <= date_final]\n return data","def create_pandas_dataframe(data, index, columns):\n return pd.DataFrame(data, index, columns)","def get_stock_data(company, start_date_inc, stop_date_inc):\n\n api_key = 'Bo9P_cJnmf5EsQPp1Bdp'\n desired_cols = 'date,close'\n\n# ticker = 'FB'\n# start_date_inc = '20170801'\n# end_date_inc = '20170831'\n\n # format and send the request\n payload = {\n 'date.gte': start_date_inc,\n 'date.lte': stop_date_inc,\n 'ticker': company,\n 'qopts.columns': desired_cols,\n 'api_key': api_key\n }\n meta_url = r'https://www.quandl.com/api/v3/datatables/WIKI/PRICES'\n r = requests.get(meta_url, params=payload)\n\n # convert to a pandas dataframe\n df = pd.DataFrame(r.json()['datatable']['data'])\n if not df.empty:\n df.columns = ['date', 'price']\n df['date'] = pd.to_datetime(df['date'])\n\n return df","def get_dataframe_for_date(date: dt.date = INITIAL_DATE) -> pd.DataFrame:\n\n url = (\n \"https://raw.githubusercontent.com/\"\n \"CSSEGISandData/COVID-19/master/\"\n \"csse_covid_19_data/\"\n \"csse_covid_19_daily_reports/\"\n \"{date}.csv\"\n ).format(date=date.strftime(\"%m-%d-%Y\"))\n\n resp = requests.get(url)\n\n with io.StringIO(resp.text) as fp:\n return pd.read_csv(fp)","def time_series_daily_adj(symbol: str, outputsize: str ='compact') -> Tuple[pd.DataFrame, dict]:\n response = _fetch(symbol=symbol, function='TIME_SERIES_DAILY_ADJUSTED', outputsize=outputsize)\n\n response_dict = json.loads(response.content)\n\n df = pd.DataFrame.from_dict(response_dict[f'Time Series (Daily)'], orient='index', dtype=np.float64)\n df.index = pd.to_datetime(df.index)\n df = df.rename(columns=_string_map(df.columns))\n\n metadata = response_dict['Meta Data']\n _rename_dict_keys(metadata)\n\n metadata['begin_datetime'] = df.index.min()\n metadata['end_datetime'] = df.index.max()\n\n return df, metadata","def get_gas_for_dates(self, dates, deseasonalize=False, as_dataframe=False):\n # Make inputs consistent: we expect dates to be a Pandas DatetimeIndex, but it may be a single timestamp or\n # datetime. For now, we will not allow collections of datetimes, such inputs must be converted to DatetimeIndex\n # instances before being passed in.\n if not isinstance(dates, pd.DatetimeIndex):\n try:\n timestamp_in = pd.Timestamp(dates)\n except (ValueError, TypeError):\n raise ValueError('dates must be a Pandas DatetimeIndex or an object convertible to a Pandas Timestamp. '\n 'Objects of type {} are not supported'.format(type(dates).__name__))\n else:\n dates = pd.DatetimeIndex([timestamp_in])\n\n start_date = dates.min()\n end_date = dates.max()\n\n # Need to make sure we get data that bracket the start and end date, so set them the first days of month\n start_date_subset = mod_utils.start_of_month(start_date, out_type=pd.Timestamp)\n end_date_subset = mod_utils.start_of_month(end_date + relativedelta(months=1), out_type=pd.Timestamp)\n\n # First get just monthly data. freq='MS' gives us monthly data at the start of the month. Use the existing logic\n # to extrapolate the record for a given month if needed.\n monthly_idx = pd.date_range(start_date_subset, end_date_subset, freq='MS')\n monthly_df = pd.DataFrame(index=monthly_idx, columns=['dmf_mean', 'latency'], dtype=float)\n for timestamp in monthly_df.index:\n monthly_df.dmf_mean[timestamp], info_dict = self.get_gas_by_month(timestamp.year, timestamp.month, deseasonalize=deseasonalize)\n monthly_df.latency[timestamp] = info_dict['latency']\n\n # Now we resample to the dates requested, making sure to keep the values at the start of each month on either\n # end of the record to ensure interpolation is successful\n sample_date_idx = dates.copy()\n sample_date_idx = sample_date_idx.append(monthly_idx)\n sample_date_idx = sample_date_idx.sort_values() # is needed for successful interpolation\n sample_date_idx = pd.unique(sample_date_idx) # deal with the possibility that one of the requested dates was a month start\n df_resampled = monthly_df.reindex(sample_date_idx)\n\n # Verify we have non-NaN values for all monthly reference points\n if df_resampled['dmf_mean'][monthly_idx].isna().any():\n raise RuntimeError('Failed to resample concentrations for date range {} to {}; first and/or last point is NA'\n .format(start_date_subset, end_date_subset))\n\n df_resampled.interpolate(method='index', inplace=True)\n\n # Return with just the originally requested dates\n df_resampled = df_resampled.reindex(dates)\n if as_dataframe:\n return df_resampled\n else:\n return df_resampled['dmf_mean'].values","def get_data_extended(self, inception_date, interval):\n instrument = self.instrumentLookup()\n from_date = dt.datetime.strptime(inception_date, \"%Y-%m-%d\")\n to_date = dt.date.today()\n data = pd.DataFrame(columns=[\"date\", \"open\", \"high\", \"low\", \"close\", \"volume\"])\n while True:\n if from_date.date() >= (dt.date.today() - dt.timedelta(100)):\n data = data.append(\n pd.DataFrame(\n self.kite.historical_data(\n instrument, from_date, dt.date.today(), interval\n )\n ),\n ignore_index=True,\n )\n break\n else:\n to_date = from_date + dt.timedelta(100)\n data = data.append(\n pd.DataFrame(\n self.kite.historical_data(\n instrument, from_date, to_date, interval\n )\n ),\n ignore_index=True,\n )\n from_date = to_date\n data.set_index(\"date\", inplace=True)\n self.data_df = data","def create_df():\n df = load_df_from_files()\n df = clean_df(df)\n df = expand_df_dates(df)\n df[\"age_at_t\"] = ((df[\"date\"] - df[\"birthday\"]) / 365).dt.days # Yeah, this is weird.\n return df","def get_time_series(rics: list, fields: list, start_date: str, end_date: str) -> pd.DataFrame:\n # Check date formats are YYYY-MM-DD.\n try:\n dt.datetime.strptime(start_date, '%Y-%m-%d')\n except ValueError:\n raise ValueError('\"start_date\" has incorrect format.')\n try:\n dt.datetime.strptime(end_date, '%Y-%m-%d')\n except ValueError:\n raise ValueError('\"end_date\" has incorrect format.')\n\n data = ek.get_timeseries(rics, fields, start_date=start_date, end_date=end_date)\n return data","def get_stock_historical_data(symbol, config):\n start_date_dt = datetime.datetime.strptime(config['start_date'], '%Y%m%d').date()\n end_date_dt = datetime.datetime.strptime(config['end_date'], '%Y%m%d').date()\n\n filename = '{}.csv'.format(symbol)\n dir_path = DATA_DIR / 'nasdaq_historical' / '{}_{}'.format(config['start_date'], config['end_date'])\n if not os.path.exists(dir_path):\n os.mkdir(dir_path)\n\n full_path = dir_path / filename\n if os.path.exists(full_path):\n df = pd.read_csv(full_path, header=0, index_col='Date', parse_dates=True)\n else:\n df = web.get_data_yahoo(symbol, config['start_date'], config['end_date'])\n if df.index[0].date() == start_date_dt and df.index[-1].date() == end_date_dt:\n df.to_csv(full_path)\n\n df.attrs.update(config)\n df.attrs['stock_symbol'] = symbol\n df.attrs['start_date_dt'] = datetime.datetime.strptime(config['start_date'], '%Y%m%d').date()\n df.attrs['end_date_dt'] = datetime.datetime.strptime(config['end_date'], '%Y%m%d').date()\n df.attrs['date_dir'] = '{}_{}'.format(config['start_date'], config['end_date']) # for building paths\n return df","def load_daily_data():\n return pd.read_csv(os.path.join('data', 'raw', 'full_grouped.csv'))","def obtain_monthly_mean(data=pd.DataFrame()):\n return data.resample(\"MS\").mean()","def to_dataframe(\n self, *, unit_in_name: bool = False, round_time: str | bool = \"ms\"\n ) -> pd.DataFrame:\n if self.ndim > 1:\n raise ValueError(\n \"Only data with a single dimension can be converted to a dataframe. Hint: use `squeeze` to remove singleton dimensions or `isel` to create a subset.\"\n )\n\n if unit_in_name:\n data = {\n f\"{item.name} ({item.unit.name})\": item.to_numpy().ravel()\n for item in self\n }\n else:\n data = {item.name: item.to_numpy().ravel() for item in self}\n df = pd.DataFrame(data, index=self.time)\n\n if round_time:\n rounded_idx = pd.DatetimeIndex(self.time).round(round_time) # type: ignore\n df.index = pd.DatetimeIndex(rounded_idx, freq=\"infer\")\n else:\n df.index = pd.DatetimeIndex(self.time, freq=\"infer\")\n\n return df","def to_dataframe(self):\n \n #Try importing pandas\n try:\n import pandas as pd\n except ImportError as e:\n raise RuntimeError(\"Error: pandas is not available. Install pandas in order to use this function.\") from e\n \n #Get season info\n season_info = self.annual_summary()\n season_info_keys = season_info['id']\n \n #Set up empty dict for dataframe\n ds = {'id':[],'name':[],'vmax':[],'mslp':[],'category':[],'ace':[],'start_time':[],'end_time':[]}\n \n #Add every key containing a list into the dict\n keys = [k for k in self.dict.keys()]\n for key in keys:\n if key in season_info_keys:\n sidx = season_info_keys.index(key)\n ds['id'].append(key)\n ds['name'].append(self.dict[key]['name'])\n ds['vmax'].append(season_info['max_wspd'][sidx])\n ds['mslp'].append(season_info['min_mslp'][sidx])\n ds['category'].append(season_info['category'][sidx])\n ds['start_time'].append(self.dict[key]['date'][0])\n ds['end_time'].append(self.dict[key]['date'][-1])\n ds['ace'].append(np.round(season_info['ace'][sidx],1))\n \n #Convert entire dict to a DataFrame\n ds = pd.DataFrame(ds)\n\n #Return dataset\n return ds","def generate_df(\n self,\n size: Optional[int] = 90 * 24, # 90 days worth of data\n start_date: Optional[str] = \"2018-01-01\",\n hourly_seasonality: float = 1.0,\n hourly_seasonality_params: Optional[List[Tuple[float, float]]] = None,\n trend_params: Optional[List[TrendParams]] = None,\n weekday_dummy_params: Optional[List[float]] = None,\n annual_seasonality_params: Optional[List[Tuple[float, float]]] = None,\n holiday_alpha: float = 3.5,\n outlier_alpha: float = 2.5,\n noise_scale: float = 1.0,\n ) -> pd.DataFrame:\n\n return pd.DataFrame(\n {\n \"ds\": pd.date_range(start_date, periods=size, freq=\"60min\"),\n \"y\": self._generate_hourly_time_series(\n size=size,\n hourly_seasonality=hourly_seasonality,\n hourly_seasonality_params=hourly_seasonality_params,\n trend_params=trend_params,\n weekday_dummy_params=weekday_dummy_params,\n annual_seasonality_params=annual_seasonality_params,\n holiday_alpha=holiday_alpha,\n outlier_alpha=outlier_alpha,\n noise_scale=noise_scale,\n ),\n }\n )","def get_df(self) -> pd.DataFrame:\n return pd.DataFrame(self.fetchall(), columns=self.headers())","def date_features(s: pd.Series, result: Optional[pd.DataFrame] = None) -> pd.DataFrame:\n if result is None:\n result = pd.DataFrame(s, copy=False)\n index = cast(pd.DatetimeIndex, s.index)\n\n result[\"year\"] = index.year\n result[\"month\"] = index.month\n result[\"day\"] = index.day\n result[\"dayofweek\"] = index.dayofweek\n result[\"dayofyear\"] = index.dayofyear\n result[\"quarter\"] = index.quarter\n result[\"season\"] = _map(index.month, _SEASON_MAP)\n result[\"weekofyear\"] = index.weekofyear\n try:\n # Work around numpy Deprecation Warning about parsing timezones\n # by converting to UTC and removing the tz info.\n dates = index.tz_convert(None).to_numpy()\n except TypeError:\n # No timezone.\n dates = index.to_numpy()\n first_of_month = pd.to_datetime(dates.astype(\"datetime64[M]\"))\n week_of_month = np.ceil((first_of_month.dayofweek + index.day) / 7.0)\n result[\"weekofmonth\"] = week_of_month.astype(int)\n # result[\"is_holiday\"] = ?\n # result[\"holiday_types\"] = ?\n result[\"is_weekend\"] = index.dayofweek >= 5\n result[\"is_leap_year\"] = index.is_leap_year\n result[\"is_leap_day\"] = (index.month == 2) & (index.day == 29)\n result[\"is_month_end\"] = index.is_month_end\n result[\"is_quarter_end\"] = index.is_month_end & (index.month % 4 == 3)\n\n return result","def get_data(self)->pd.DataFrame:\n pass","def to_pandas( # type: ignore [override]\n self,\n column_names: Literal[\"id\", \"external_id\"] = \"external_id\",\n include_aggregate_name: bool = True,\n include_granularity_name: bool = False,\n ) -> pandas.DataFrame:\n pd = cast(Any, local_import(\"pandas\"))\n if column_names == \"id\":\n if self.id is None:\n raise ValueError(\"Unable to use `id` as column name(s), not set on object\")\n identifier = str(self.id)\n\n elif column_names == \"external_id\":\n if self.external_id is not None:\n identifier = self.external_id\n elif self.id is not None:\n # Time series are not required to have an external_id unfortunately...\n identifier = str(self.id)\n warnings.warn(\n f\"Time series does not have an external ID, so its ID ({self.id}) was used instead as \"\n 'the column name in the DataFrame. If this is expected, consider passing `column_names=\"id\"` '\n \"to silence this warning.\",\n UserWarning,\n )\n else:\n raise ValueError(\"Object missing both `id` and `external_id` attributes\")\n else:\n raise ValueError(\"Argument `column_names` must be either 'external_id' or 'id'\")\n\n if self.value is not None:\n return pd.DataFrame({identifier: self.value}, index=self.timestamp, copy=False)\n\n (_, *agg_names), (_, *arrays) = self._data_fields()\n columns = [\n str(identifier) + include_aggregate_name * f\"|{agg}\" + include_granularity_name * f\"|{self.granularity}\"\n for agg in agg_names\n ]\n # Since columns might contain duplicates, we can't instantiate from dict as only the\n # last key (array/column) would be kept:\n (df := pd.DataFrame(dict(enumerate(arrays)), index=self.timestamp, copy=False)).columns = columns\n return df","def to_pandas( # type: ignore [override]\n self,\n column_names: Literal[\"id\", \"external_id\"] = \"external_id\",\n include_aggregate_name: bool = True,\n include_granularity_name: bool = False,\n ) -> pandas.DataFrame:\n pd = cast(Any, local_import(\"pandas\"))\n dfs = [dps.to_pandas(column_names, include_aggregate_name, include_granularity_name) for dps in self]\n if not dfs:\n return pd.DataFrame(index=pd.to_datetime([]))\n\n return concat_dataframes_with_nullable_int_cols(dfs)","def to_pandas( # type: ignore [override]\n self,\n column_names: Literal[\"id\", \"external_id\"] = \"external_id\",\n include_aggregate_name: bool = True,\n include_granularity_name: bool = False,\n ) -> pandas.DataFrame:\n pd = cast(Any, local_import(\"pandas\"))\n dfs = [dps.to_pandas(column_names, include_aggregate_name, include_granularity_name) for dps in self]\n if not dfs:\n return pd.DataFrame(index=pd.to_datetime([]))\n\n return concat_dataframes_with_nullable_int_cols(dfs)","def sql_return_df(query, params, date_cols):\n conn = sqlite3.connect(db_filepath)\n df = pd.read_sql(query, conn, params=params, parse_dates=date_cols)\n conn.close()\n return df","def get_cpi_rates():\n\n df = pd.read_csv('cpi_usa.csv', index_col=0)\n df.index = pd.to_datetime(df.index)\n\n df = df.resample('BAS').mean() # change sampling to business year start\n df.index = df.index.year # datetime to year\n df.columns = ['cpi_rate']\n\n return df","def _read(**kwargs) -> DataFrame:\n Engine.subscribe(_update_engine)\n\n try:\n pd_obj = FactoryDispatcher.read_csv_glob(**kwargs)\n except AttributeError:\n raise AttributeError(\"read_csv_glob() is only implemented for pandas on Ray.\")\n\n # This happens when `read_csv` returns a TextFileReader object for iterating through\n if isinstance(pd_obj, pandas.io.parsers.TextFileReader):\n reader = pd_obj.read\n pd_obj.read = lambda *args, **kwargs: DataFrame(\n query_compiler=reader(*args, **kwargs)\n )\n return pd_obj\n\n return DataFrame(query_compiler=pd_obj)","def create_quanti_df(df: pd.DataFrame) -> pd.DataFrame:\n\n # create a dictionary that contains datatype of each column\n dtypeDict = dict(df.dtypes)\n # create a list of column names that contains only quantitative data\n quanti_cols = [\n key\n for key, value in dtypeDict.items()\n if value == \"float64\" or value == \"int64\" or value == \"uint8\"\n ]\n df = df[quanti_cols]\n return df","def get_weather_timeseries_2017():\n weather_df = pd.read_csv(\"src/kumpula-weather-2017.csv\")\n\n # -1 value in columns \"Precipitation amount (mm)\" and \"Snow depth (cm)\" mean\n # that there was no absolutely no rain or snow that day, whereas 0 can mean\n # a little of either. Let's convert the -1 values to 0 to make the dataset\n # more logical to read.\n weather_df.loc[weather_df[\"Precipitation amount (mm)\"] == -1,\n \"Precipitation amount (mm)\"] = 0\n weather_df.loc[weather_df[\"Snow depth (cm)\"] == -1, \"Snow depth (cm)\"] = 0\n\n # Create datetime index\n weather_df[\"Month\"] = weather_df[\"m\"]\n weather_df[\"Day\"] = weather_df[\"d\"]\n weather_df[\"Date\"] = pd.to_datetime(weather_df[[\"Year\", \"Month\", \"Day\"]])\n\n # Reindex dataset\n weather_df = weather_df.set_index(\"Date\")\n\n # Drop redundant columns\n weather_df.drop([\"Time\", \"Time zone\", \"m\", \"d\", \"Year\",\n \"Month\", \"Day\"], axis=\"columns\", inplace=True)\n\n return weather_df","def get_data(symbols, dates):\n df = pd.DataFrame(index=dates)\n \n if 'SPY' not in symbols: #add SPY for reference\n symbols.insert(0,'SPY')\n \n # This for loop will loop through all the desired\n # symbols in the symbol list and create a dataframe\n # containing all the required data\n for symbol in symbols:\n # Get path for .csv file for symbol\n sym_path = symbol_to_path(symbol)\n # Load data from csv and create dataframe\n if symbol == 'SPY':\n dfSPY = pd.read_csv(sym_path,\n index_col=\"Date\",\n parse_dates=True,\n usecols=[\"Date\",\"Adj Close\"],\n na_values=['nan'])\n \n dfSPY = dfSPY.rename(columns={\"Adj Close\": str(symbol)})\n df = df.join(dfSPY,how='inner') # inner joins and drops NaN\n else:\n df_temp = pd.read_csv(sym_path,\n index_col=\"Date\",\n parse_dates=True,\n usecols=[\"Date\",\"Adj Close\"],\n na_values=['nan'])\n df_temp = df_temp.rename(columns={\"Adj Close\": str(symbol)})\n df = df.join(df_temp,how='inner')\n df = df.sort_index(ascending=True)\n return df","def pd(self, *args, **kwargs):\n return pd.DataFrame.from_records(self.aslist(), *args, **kwargs)","def getEPADailyData(dateint, dt_ind, month, epa_df, yr):\n\n try:\n start = dateint + dt_ind * 10000\n end = start + 10001\n dly_epa_df = epa_df[(epa_df.created >= start) & (epa_df.created < end)]\n dly_epa_df.reset_index(inplace=True, drop=True)\n\n new_df = pd.DataFrame(columns=['lat', 'lon', 'utc', 'parameter', 'epa_pm25_unit', 'epa_pm25_value', 'raw_concentration', 'aqi', 'category', 'site_name', 'agency_name', 'full_aqs_code', 'intl_aqs_code', 'created'])\n for sitenm in dly_epa_df.site_name.unique():\n indx_ct = 0\n site_df = dly_epa_df[dly_epa_df.site_name == sitenm]\n for i in site_df.created.unique():\n indx_ct += 1\n new_df = pd.concat([new_df,site_df.iloc[indx_ct - 1:indx_ct]],ignore_index=True)\n\n if i != site_df.created.max(): # Don't interpolate the last record\n tmp_df = site_df.iloc[indx_ct - 1:indx_ct][['lat', 'lon', 'utc', 'parameter', 'epa_pm25_unit', 'category', 'site_name', 'agency_name', 'full_aqs_code', 'intl_aqs_code']]\n for j in range(1,6):\n new_dt = i + j * 10\n tmp_df['created'] = int(new_dt)\n tmp_df['epa_pm25_value'] = np.nan\n tmp_df['raw_concentration'] = np.nan\n tmp_df['aqi'] = np.nan\n new_df = pd.concat([new_df,tmp_df],ignore_index=True)\n\n # Convert aqi to numerica for so that it gets interpolated\n new_df[['aqi']] = new_df[['aqi']].replace(\"nan\", np.nan, regex=True)\n new_df[['aqi']] = new_df[['aqi']].apply(pd.to_numeric)\n\n new_df = new_df.interpolate(method='linear', limit_direction='forward', axis=0)\n\n int_epa_df = new_df[(new_df.created >= start) & (new_df.created < (end - 1))]\n int_epa_df.reset_index(inplace=True, drop=True)\n \n # Write to S3\n s3 = s3fs.S3FileSystem()\n myopen = s3.open\n write('midscapstone-whos-polluting-my-air/EpaDaily/epa_20{2}{0}{1:02}.parquet'.format(month, dt_ind, yr), int_epa_df, compression='GZIP', open_with=myopen)\n s3_resource = boto3.resource('s3')\n s3_resource.Object('midscapstone-whos-polluting-my-air', 'EpaDaily/epa_20{2}{0}{1:02}.parquet'.format(month, dt_ind, yr)).Acl().put(ACL='public-read')\n\n except Exception as e:\n print(\"*** EXCEPTION IN GET EPA DAILY DATA *** {}\".format(e))\n return int_epa_df","def yearly(self):\r\n return RecordsYearly(self)","def get_historic_data(end_date = datetime.now(), \n start_date = datetime.now() + timedelta(-365),\n ticker=[],\n close_only=True):\n #checks if the parameters provided through \"ticker\" is not an empty list\n #if it is, the function won't go forward after this point. returns explanatory message.\n if ticker == []:\n return \"Empty list of tickers\"\n \n #if a string is provided as \"ticker\" parameter, then it splits the string by \n #spaces and store the outcome in a list.\n elif type(ticker) is str:\n ticker = ticker.split(\" \")\n \n iex_token = os.getenv(\"IEX_TOKEN\")#not necessary anymore.\n if type(iex_token) == str: print(\"IEX Key found successfully ...getting data\")\n else: return \"Error: IEX Key NOT found\"\n \n \n #Gets historical data with the parameters provided.\n #Gets only \"close\" and \"volume\" value for efficiency.\n prices = get_historical_data(ticker, start_date, end_date,\n output_format='pandas', \n token=iex_token, \n close_only=close_only\n )\n \n #If only one ticker is provided, then it adds another indexing level to the column\n #with the ticker. This is done for two reasons: 1) To visualize the ticker downloaded \n #as a confirmation that I am working with correct data. 2) To mimic the format of the\n #dataframe obtained when getting 2 or more tickers data (2-level column indexing).\n if len(ticker) == 1:\n new_columns = pd.MultiIndex.from_product([ [ticker[0]],prices.columns ] )\n prices.columns = new_columns\n \n return prices","def to_stock_dataframe_range(self, start_date=None, end_date=None):\n if end_date is None:\n end_date = self.dates[-2]\n if type(end_date) is pd.tslib.Timestamp:\n end_date = end_date.strftime(\"%Y-%m-%d\")\n if type(end_date) is not datetime.datetime and type(end_date) is not pd.tslib.Timestamp:\n end_date = datetime.datetime.strptime(end_date, \"%Y-%m-%d\")\n try:\n end_date = self.dates[list(self.dates).index(end_date) + 1]\n except:\n end_date = \"Last\"\n if start_date is None:\n start_date = self.dates[0]\n\n if type(start_date) is not datetime.datetime and type(start_date) is not pd.tslib.Timestamp:\n start_date = datetime.datetime.strptime(start_date, \"%Y-%m-%d\")\n\n class_data = [i for i in dir(self) if not callable(getattr(self, i)) and not i.startswith(\"__\") and\n type(getattr(self, i)) is pd.DataFrame]\n df = pd.DataFrame()\n for i in class_data:\n df = join_features(df, getattr(self, i), fill_method=FillMethod.FUTURE_KROGH)\n if end_date is \"Last\":\n print(df.ix[start_date:, :])\n return df.ix[start_date:, :]\n return df.ix[start_date:end_date, :]","def get_price_df(url):\n df = pd.read_csv(url).dropna()\n df.index = pd.to_datetime(df['Date'])\n df = df.drop(columns=['Date'])\n return df","def get_data(symbols, dates):\n df = pd.DataFrame(index=dates)\n if 'SPY' not in symbols: # add SPY for reference, if absent\n symbols.insert(0, 'SPY')\n\n for symbol in symbols:\n # TODO: Read and join data for each symbol\n if os.path.isfile(symbol_to_path(symbol)): \n df_temp = pd.read_csv(symbol_to_path(symbol), index_col='Date', \n parse_dates = True, usecols=['Date', 'Adj Close'], na_values=['nan'])\n df_temp = df_temp.rename(columns = {'Adj Close': symbol})\n df = df.join(df_temp)\n if symbol == 'SPY': #drop dates SPY did not trade\n df = df.dropna(subset=[\"SPY\"])\n# else:\n# download_symbol(symbol) \n return df","def load_data(fpath: str, station: Dict[str, Any]) -> pd.DataFrame:\n df = pd.read_csv(\n fpath,\n skiprows=station['header_line_num']-1,\n usecols=['date', 'rain'],\n )\n\n # format the date from a string to a proper datetime object\n df['date'] = pd.to_datetime(df['date'])\n\n # extract year, month, week, and day to separate columns\n df['year'] = df['date'].dt.year\n df['month'] = df['date'].dt.month\n df['day'] = df['date'].dt.dayofyear\n df['week'] = df['date'].dt.weekofyear\n df['year_month'] = df['date'].dt.to_period('M')\n\n return df","def get_dataframe() -> pandas.DataFrame:\n database_connection = processing.establish_connection(database_path)\n dataframe = database_connection.to_dataframe(['CustomerId', 'InvoiceDate', 'Total'], table_name)\n database_connection.close()\n dataframe = processing.get_invoice_date_fixed(dataframe)\n analyze_dataframe = dataframe.copy()\n total_sum_dataframe = processing.get_column_sum(analyze_dataframe)\n\n customer_count_dataframe = processing.drop_duplicates(analyze_dataframe)\n customer_count_dataframe = processing.get_column_count(customer_count_dataframe)\n return customer_count_dataframe.merge(total_sum_dataframe, how='inner', on='InvoiceDate')","def _get_data(*, from_web: bool) -> pd.DataFrame:\n\n df = read_in_data.SaveFormats.CSV.read(from_web=from_web)\n return df","def get_stock_data_yf(stock_name, past_years, interval) -> pd.DataFrame:\n data = yf.download(stock_name, period=f'{past_years}y', interval=interval)\n data = to_numeric_and_downcast_data(data)\n return data","def _get_data(self):\n \n print(\"Getting Data...\")\n self.data = sgs.dataframe(self.serie_name, \n start = self.start_date, \n end = self.end_date)\n\n print(f\"Done! {self.data.shape[0]} rows were collected\")\n \n self.data.reset_index(inplace=True)\n self.data.columns = ['date', 'cdi']\n\n return self.data","def get_real_gdp(interval: str = \"a\") -> pd.DataFrame:\n s_interval = \"quarterly\" if interval == \"q\" else \"annual\"\n url = f\"https://www.alphavantage.co/query?function=REAL_GDP&interval={s_interval}&apikey={cfg.API_KEY_ALPHAVANTAGE}\"\n r = requests.get(url, headers={\"User-Agent\": get_user_agent()})\n\n if r.status_code != 200:\n return pd.DataFrame()\n\n data = pd.DataFrame(r.json()[\"data\"])\n data[\"date\"] = pd.to_datetime(data[\"date\"])\n data[\"GDP\"] = data[\"value\"].astype(float)\n data = data.drop(columns=[\"value\"])\n return data","def get_df(\n self,\n response: Response,\n parse_dates: Optional[Union[List[int], bool]] = False,\n sort_values: Optional[List[str]] = None,\n reindex_columns: Optional[List[str]] = None,\n ) -> pd.DataFrame:\n\n with io.BytesIO() as buffer:\n try:\n buffer.write(response.content)\n buffer.seek(0)\n z: zipfile.ZipFile = zipfile.ZipFile(buffer)\n\n except zipfile.BadZipFile as e:\n print(\"Bad zip file\", e)\n\n else: # TODO need to annotate csv\n csv = z.open(z.namelist()[0]) # ignores all but first file in zip\n df: pd.DataFrame = pd.read_csv(csv, parse_dates=parse_dates)\n\n df = df.rename(columns={\"PRC\": \"MW\"})\n\n if sort_values:\n df = df.sort_values(sort_values).reset_index(drop=True)\n\n if reindex_columns:\n df = df.reindex(columns=reindex_columns)\n\n return df","def data(self):\n if self._data.empty:\n self._data = super().data\n\n max_data_year = self._data[\"year\"].max()\n\n # If the date range of the data doesn't line up with the year filters\n # for train/test data, we risk getting empty data sets\n if self.max_year != max_data_year:\n max_year_diff = pd.to_timedelta(\n [(YEAR_IN_DAYS * (self.max_year - max_data_year))]\n * len(self._data),\n unit=\"days\",\n )\n\n self._data.loc[:, \"date\"] = self._data[\"date\"] + max_year_diff\n self._data.loc[:, \"year\"] = self._data[\"date\"].dt.year\n self._data.set_index(\n [\"team\", \"year\", \"round_number\"], drop=False, inplace=True\n )\n\n return self._data","def pandaData():\r\n tweets = pd.DataFrame()\r\n return tweets","def get_unemployment() -> pd.DataFrame:\n url = f\"https://www.alphavantage.co/query?function=UNEMPLOYMENT&apikey={cfg.API_KEY_ALPHAVANTAGE}\"\n r = requests.get(url, headers={\"User-Agent\": get_user_agent()})\n if r.status_code != 200:\n return pd.DataFrame()\n data = pd.DataFrame(r.json()[\"data\"])\n data[\"date\"] = pd.to_datetime(data[\"date\"])\n data[\"unemp\"] = data[\"value\"].astype(float)\n data = data.drop(columns=[\"value\"])\n return data","def YahooFinancials_Data(Ticker=[],Start='',End ='',Frequency ='daily'):\n\n\n \n import pandas as pd\n from yahoofinancials import YahooFinancials\n import datetime as dt \n \n Ticker = Ticker or input(\"Enter Tcikers separated by',': \").split(',')\n Start = Start or input(\"Enter Start Date separated by '-': \") or (dt.date.today()-\n dt.timedelta(1825)).strftime(\"%Y-%m-%d\")\n End = End or input(\"Enter End Date separated by '-': \") or (dt.date.today()).strftime(\"%Y-%m-%d\")\n Frequency = Frequency or input(\"Enter Frequency like 'daily','weekly': \") or 'daily'\n \n data = pd.DataFrame()\n for i in range(len(Ticker)):\n try:\n yahoo_financials = YahooFinancials(Ticker[i])\n Json_obj = yahoo_financials.get_historical_price_data(Start, End, Frequency)\n Ohlv = Json_obj[Ticker[i]]['prices']\n temp = pd.DataFrame(Ohlv)[[\"formatted_date\",\"adjclose\"]]\n temp.set_index(\"formatted_date\", inplace = True)\n temp = temp[~temp.index.duplicated(keep = 'first')]\n data[Ticker[i]] = temp['adjclose']\n \n except:\n print(f\"Unable to get the Data for: {Ticker[i]}\")\n continue\n \n return data","def df(x):\n raise NotImplementedError","def _to_dataframe(self, dataset_name):\n values = self[dataset_name][:]\n columns = self.get_columns(dataset_name)\n timestamps = self.get_timestamps(dataset_name)[...]\n if len(columns) < values.shape[1]:\n columns.resize(values.shape[1])\n\n # transform missing data into NaNs\n mask = missing_values(values) != 0\n try:\n values[mask] = numpy.nan\n except ValueError: # ValueError: cannot convert float NaN to integer\n # don't bother converting non-float arrays' -0.0 into NaNs\n pass\n\n dataframe = pandas.DataFrame(data=values,\n index=[datetime.datetime.fromtimestamp(t) for t in timestamps],\n columns=columns)\n return dataframe","def get_inflation() -> pd.DataFrame:\n url = f\"https://www.alphavantage.co/query?function=INFLATION&apikey={cfg.API_KEY_ALPHAVANTAGE}\"\n r = requests.get(url, headers={\"User-Agent\": get_user_agent()})\n if r.status_code != 200:\n return pd.DataFrame()\n data = pd.DataFrame(r.json()[\"data\"])\n data[\"date\"] = pd.to_datetime(data[\"date\"])\n data[\"Inflation\"] = data[\"value\"].astype(float)\n data = data.drop(columns=[\"value\"])\n\n return data"],"string":"[\n \"def get_time_series_data():\\r\\n # Grab the requested years and columns from the query arguments\\r\\n ls_year = [int(year) for year in request.args.getlist(\\\"n\\\")]\\r\\n ls_col = request.args.getlist(\\\"m\\\")\\r\\n\\r\\n # Generate a list of all the months we need to get\\r\\n all_years = [str(year) for year in range(min(ls_year), max(ls_year) + 1)]\\r\\n\\r\\n # Grab all of the wanted months by filtering for the ones we want\\r\\n wanted_months = reduce(\\r\\n lambda a, b: a | b, (app.df[\\\"month\\\"].str.contains(year) for year in all_years)\\r\\n )\\r\\n\\r\\n # Create a new dataframe from the one that\\r\\n df_new = app.df[wanted_months][[\\\"month\\\"] + ls_col]\\r\\n\\r\\n # Convert all string dates into datetime objects and then sort them\\r\\n df_new[\\\"month\\\"] = pd.to_datetime(df_new[\\\"month\\\"])\\r\\n df_new = df_new.sort_values(by=[\\\"month\\\"])\\r\\n\\r\\n # Return the dataframe as json\\r\\n return df_new.to_json(), 200\",\n \"def to_DataFrame(cls, qs):\\n dates = [pd.to_datetime(x[0]) for x in qs.values_list('date')]\\n data = qs.values('open', 'close', 'high', 'low', 'volume')\\n df = pd.DataFrame.from_records(data, index=dates)\\n return df\",\n \"def to_dataframe(self, include_metadata: bool = True) -> pd.DataFrame:\\n # Get all our data first with async\\n # Note that all our pandas work will tax CPU so we wouldn't expect any\\n # performance gains from doing the data parsing as a callback\\n records = self.to_dict()\\n data = []\\n for series in records:\\n df = pd.DataFrame(series.pop(\\\"data\\\"), columns=[\\\"period\\\", \\\"value\\\"])\\n if include_metadata:\\n df = df.assign(**series)\\n data.append(df)\\n return pd.concat(data, ignore_index=True)\",\n \"def all_data(self):\\n return pd.concat([self.historic_data, self.dayahead_data])\",\n \"def __get_all_data(self,tickr):\\n self.__csvurl=f\\\"https://query1.finance.yahoo.com/v7/finance/download/{tickr}?period1=1092873600&period2={int(datetime.now().timestamp())}&interval=1d&events=history&includeAdjustedClose=true\\\"\\n s=get_historic_data(self.__csvurl)\\n\\n \\\"\\\"\\\"you should not be able to access dataframe from outside the class\\\"\\\"\\\"\\n df=pd.read_csv(io.StringIO(s.decode('utf-8')))\\n df=df.dropna()\\n df_columns=['Date','High','Low','Close','Adj Close']\\n\\n if not set(df_columns).issubset(df.columns):\\n raise ValueError(f\\\"One or more columns are missing {df_columns}\\\")\\n\\n if len(df.index)<5:\\n raise ValueError(f\\\"Cannot calculate EMA 5\\\")\\n\\n if len(df.index)<20:\\n raise ValueError(f\\\"Cannot calculate SMA 20\\\")\\n\\n \\\"\\\"\\\"set date as index (required for filtering,sorting,grouping etc etc\\\"\\\"\\\"\\n df['Date'] = pd.to_datetime(df['Date'], format = '%Y-%m-%d')\\n\\n df.set_index(['Date'], inplace=True)\\n\\n\\n return df\",\n \"def TimeFrame(*args, **kwargs):\\n underride(kwargs, dtype=float)\\n return pd.DataFrame(*args, **kwargs)\",\n \"def get_alpaca_data(self,ticker_list,start,end, timeframe = \\\"1D\\\"):\\n s = pd.Timestamp(start,tz = \\\"America/New_York\\\").isoformat()\\n e = pd.Timestamp(end,tz = \\\"America/New_York\\\").isoformat()\\n \\n df = api.get_barset(\\n ticker_list,\\n timeframe,\\n start = s,\\n end = e\\n\\n ).df\\n return df\",\n \"def data(self):\\n dfdata = pd.concat([self.weights, self.returns, self.category], axis=1)\\n dfdata.columns = ['weights', 'returns', self.category_name]\\n if self.period is not None:\\n dfdata['date'] = self.period\\n return dfdata\",\n \"def get_daily_historic_data(self, ticker, start_date, end_date):\\n av_url = self._construct_alpha_vantage_symbol_call(ticker)\\n\\n try:\\n av_data_js = requests.get(av_url)\\n data = json.loads(av_data_js.text)['Time Series (Daily)']\\n except Exception as e:\\n print(\\n \\\"Could not download AlphaVantage data for %s ticker \\\"\\n \\\"(%s)...stopping.\\\" % (ticker, e)\\n )\\n return pd.DataFrame(columns=COLUMNS).set_index('Date')\\n else:\\n prices = []\\n for date_str in sorted(data.keys()):\\n date = dt.strptime(date_str, '%Y-%m-%d')\\n if date < start_date or date > end_date:\\n continue\\n\\n bar = data[date_str]\\n prices.append(\\n (\\n date, \\n float(bar['1. open']),\\n float(bar['2. high']),\\n float(bar['3. low']),\\n float(bar['4. close']),\\n int(bar['6. volume']),\\n float(bar['5. adjusted close'])\\n )\\n )\\n price_df = pd.DataFrame(prices, columns=COLUMNS).set_index('Date').sort_index()\\n self._correct_back_adjusted_prices(price_df)\\n return price_df\",\n \"def timeseries_dataframe(self):\\n return\",\n \"def setup_df(ticker):\\n stock = yf.Ticker(ticker)\\n df = stock.history(period=\\\"max\\\")\\n del df['Dividends']\\n del df['Stock Splits']\\n return df\",\n \"def _get_annualData(self, dataType):\\n\\n if dataType == \\\"financials\\\":\\n if self._financials is not None:\\n return\\n url = self._url_financials\\n else:\\n if self._keyRatios is not None:\\n return\\n url = self._url_keyRatios\\n\\n # Credit to Andrej Kesely\\n # https://stackoverflow.com/users/10035985/andrej-kesely\\n # https://stackoverflow.com/questions/56691753/cant-find-table-using-beautiful-soup-on-morningstar\\n\\n soup = BeautifulSoup(json.loads(re.findall(\\n r'xxx\\\\((.*)\\\\)', requests.get(url).text)[0])['componentData'], 'lxml'\\n )\\n\\n table = utils.get_table(soup)\\n df = pd.DataFrame(table[1:], columns=table[0])\\n df = df.replace(\\\"—\\\", nan)\\n\\n index_col = df.columns[0]\\n df = df.set_index(index_col)\\n\\n # only financials contain currency\\n if dataType == \\\"financials\\\":\\n self.currency_financials = self._get_currency(df)\\n df = df.rename_axis(index={\\\"X\\\": f\\\"Financials {self.currency_financials}\\\"})\\n \\n df = df.T\\n\\n # TODO: convert dtypes\\n\\n if dataType == \\\"financials\\\":\\n self._financials = df\\n else:\\n self._keyRatios = df\",\n \"def get_data(symbols, dates, base_dir=\\\"../data/\\\"):\\n df = pd.DataFrame(index=dates)\\n if 'SPY' not in symbols:\\n symbols.insert(0, 'SPY')\\n\\n for symbol in symbols:\\n temp_df = pd.read_csv(symbol_to_path(symbol, base_dir), index_col='Date',\\n parse_dates=True, usecols=['Date', 'Close'],\\n na_values=['nan'])\\n temp_df = temp_df.rename(columns={'Close': symbol})\\n df = df.join(temp_df, how='inner')\\n return df\",\n \"def get_equal_dataframe() -> pandas.DataFrame:\\n data = {\\n 'InvoiceDate': ['2009-01', '2012-01'],\\n 'Count': [4, 4],\\n 'Total': [8198.79, 5323.15]\\n }\\n return pandas.DataFrame(data, columns=['InvoiceDate', 'Count', 'Total'])\",\n \"def get_data(symbols, dates):\\n df = pd.DataFrame(index=dates)\\n if \\\"SPY\\\" not in symbols:\\n symbols.insert(0, \\\"SPY\\\")\\n for symbol in symbols:\\n temp = pd.read_csv(symbol_to_path(symbol, base_dir=\\\"data\\\"), \\n index_col=\\\"Date\\\", \\n parse_dates=True, \\n usecols=[\\\"Date\\\", \\\"Adj Close\\\"])\\n \\n temp = temp.rename(columns={\\\"Adj Close\\\": symbol})\\n \\n df = df.join(temp, how=\\\"inner\\\")\\n df = df.sort_index(axis=0, ascending=[1])\\n \\n return df\",\n \"def stock_data(ticker, start,today=date.today()):\\n df= web.DataReader(ticker,'yahoo',start,today)\\n return df\",\n \"def chart_data(indicator, start, period, centre='all', lim=2020):\\r\\n x = pd.DataFrame()\\r\\n logging.info((indicator, centre))\\r\\n d = [t.strftime(\\\"%Y%m\\\") for t in pd.date_range(start=start, periods=period/3, freq='-3M')]\\r\\n for date in d:\\r\\n x = x.append(met(indicator, date, cent=centre, lim=lim))\\r\\n print('.', end='')\\r\\n return x\",\n \"def get_date_df():\\n dt_df = pd.read_csv('data/date.csv')\\n dt_df['from'] = pd.to_datetime(dt_df['from'])\\n dt_df['from_year'] = dt_df['from'].apply(lambda x: x.year)\\n dt_df['from_month'] = dt_df['from'].apply(lambda x: x.month)\\n dt_df['to'] = pd.to_datetime(dt_df['to'])\\n dt_df['to_year'] = dt_df['from'].apply(lambda x: x.year)\\n dt_df['to_month'] = dt_df['from'].apply(lambda x: x.month)\\n return dt_df\",\n \"def read_and_prepare_dataframe(start_date='1980-01-01'):\\n \\n # Read the dataset and rename 'dt' to 'Date'\\n df = pd.read_csv('Data/GlobalLandTemperaturesByCountry.csv', parse_dates=['dt'])\\n df.rename(columns={'dt':'Date'}, inplace=True)\\n \\n # Filter for Canada\\n df = df[df['Country']=='Canada']\\n \\n # Filter out data prior to start date\\n df = df[df['Date'] >= start_date]\\n \\n # To ensure data is sorted\\n df = df.sort_values('Date')\\n \\n # Set index to Date and return the final dataframe\\n return df.set_index('Date')\",\n \"def test_df_contents(self):\\n df_out = annualize(dat, period_label=\\\"fqtr\\\", period_val=4)\\n\\n assert all(df_out['fqtr'] == 4), \\\"Error, the DataFrame has data from the wrong period.\\\"\",\n \"def get_dataframe(self,tickers = None,variable = \\\"close\\\",normalization = True):\\n if tickers is not None:\\n companies = self[tickers]\\n else:\\n companies = self.data \\n\\n data = pd.concat([company.data[[variable]].rename(columns = {variable:company.ticker}) for company in companies],axis = 1)\\n \\n if normalization:\\n data /= data.max(axis = 0)\\n \\n return data\",\n \"def get_data(symbols, dates):\\n df = pd.DataFrame(index=dates)\\n if 'SPY' not in symbols: # add SPY for reference, if absent\\n symbols.insert(0, 'SPY')\\n\\n for symbol in symbols:\\n # TODO: Read and join data for each symbol\\n df_temp = pd.read_csv(symbol_to_path(symbol),\\n index_col=\\\"Date\\\",\\n parse_dates=True,\\n usecols=['Date', 'Adj Close'],\\n na_values=['nan'])\\n df_temp = df_temp.rename(columns={'Adj Close': symbol})\\n df = df.join(df_temp)\\n\\n df = df.dropna()\\n return df\",\n \"def _year_days(year):\\n return pd.DataFrame({'time': pd.date_range(f'{year}-01-01', f'{year}-12-31')})\",\n \"def get_data(symbols, dates):\\r\\n df = pd.DataFrame(index=dates)\\r\\n if 'SPY' not in symbols: # add SPY for reference, if absent\\r\\n symbols.insert(0, 'SPY')\\r\\n\\r\\n for symbol in symbols:\\r\\n df_temp = pd.read_csv(symbol_to_path(symbol), index_col=\\\"Date\\\", parse_dates=True,\\r\\n usecols=['Date', 'Adj Close'], na_values=['nan'])\\r\\n\\r\\n # rename to prevent clash\\r\\n df_temp = df_temp.rename(columns={'Adj Close': symbol})\\r\\n df = df.join(df_temp)\\r\\n if symbol == 'SPY': #drop dates SPY did not trade\\r\\n df = df.dropna(subset=[\\\"SPY\\\"])\\r\\n\\r\\n return df\",\n \"def get_data(symbols, dates):\\n df = pd.DataFrame(index=dates)\\n if 'SPY' not in symbols: # add SPY for reference, if absent\\n symbols.insert(0, 'SPY')\\n\\n for symbol in symbols:\\n # TODO: Read and join data for each symbol\\n path = symbol_to_path(symbol)\\n df_tmp = pd.read_csv(path, index_col=\\\"Date\\\", parse_dates=True,\\n usecols=['Date', 'Adj Close'], na_values=['nan'])\\n df_tmp = df_tmp.rename(columns={'Adj Close':symbol})\\n # or use inner join to drop the NaN values\\n df = df.join(df_tmp, how='inner')\\n return df\",\n \"def get_weather(latitude: float, longitude: float, year: int) -> DataFrame:\\n # Set time period\\n start = datetime(year, 1, 1)\\n end = datetime(year, 12, 31)\\n\\n # Create Point for NYC\\n location = Point(latitude, longitude)\\n\\n # Get daily data for the year\\n data = Daily(location, start, end)\\n return data.fetch()\",\n \"def create_dataframe():\\r\\n\\r\\n df = pd.read_csv('data/data.csv', header=0)\\r\\n return df\",\n \"def extract_and_append_year_month_quarter(self, data_frame, column_name):\\n columns = self.extract_year_month_quarter(data_frame[column_name])\\n periods_df = pd.DataFrame({\\\"Year\\\":columns[0],\\\"Monthly\\\": columns[1], \\\"Quarterly\\\": columns[2]})\\n return pd.concat([data_frame.reset_index(), periods_df], axis='columns', join=\\\"inner\\\")\",\n \"def get_dataframe(start_date=INITIAL_DATE, end_date=None) -> pd.DataFrame:\\n\\n end_date = (\\n end_date\\n if end_date is not None\\n else dt.datetime.utcnow() - dt.timedelta(days=1)\\n ).date()\\n\\n dates = pd.date_range(start_date, end_date)\\n\\n with futures.ThreadPoolExecutor() as ex:\\n\\n df = pd.concat(ex.map(get_dataframe_for_date, dates))\\n\\n df.rename(columns=str.lower, inplace=True)\\n\\n df.drop(columns=[c for c in df.columns if \\\"/\\\" in c], inplace=True)\\n\\n df[\\\"datetime\\\"] = pd.to_datetime(df[\\\"last_update\\\"])\\n\\n df[\\\"date\\\"] = df.datetime.map(lambda d: d.date())\\n\\n # df[\\\"county\\\"] = df.admin2\\n renames = {\\n \\\"country_region\\\": \\\"country\\\",\\n \\\"province_state\\\": \\\"state\\\",\\n \\\"admin2\\\": \\\"county\\\",\\n }\\n\\n df.rename(columns=renames, inplace=True)\\n\\n df.drop(\\n columns=[\\\"last update\\\", \\\"last_update\\\", \\\"lat\\\", \\\"long_\\\", \\\"combined_key\\\"],\\n inplace=True,\\n )\\n\\n return df\",\n \"def dataframe(self):\\n df = pd.DataFrame({'x':self.x, 'y':self.y, 'd':self.d})\\n\\n if self.z is not None:\\n for k, v in self.z.items():\\n df[k] = v\\n\\n return df\",\n \"def get_data(symbols, dates):\\n \\n df = pd.DataFrame(index=dates)\\n if 'SPY' not in symbols:\\n symbols.insert(0,'SPY')\\n for symbol in symbols:\\n \\n df1 = pd.read_csv(symbol_to_path(symbol),usecols=['Date','Adj Close'],\\n index_col='Date',na_values =['nan'] )\\n df1 = df1.rename(columns ={\\\"Adj Close\\\": symbol}) \\n #print df1\\n df = df.join(df1,how='inner')\\n \\n return df.sort_index()\",\n \"def get_dataframe(self):\\n self.logger.info('Fetching movie records...')\\n session = connect()\\n\\n cols = [\\n Movie.movie_id,\\n Movie.title,\\n Movie.start_year,\\n Movie.genres,\\n Movie.description,\\n Movie.kind,\\n ]\\n\\n filters = [\\n Movie.description.isnot(None),\\n Movie.genres.isnot(None),\\n ]\\n\\n query = session.query(*cols).filter(*filters).order_by(Movie.start_year.desc())\\n\\n try:\\n return pd.read_sql(query.statement, session.bind)\\n finally:\\n session.close()\",\n \"def get_data(symbols, dates):\\n df = pd.DataFrame(index=dates)\\n if 'SPY' not in symbols: # add SPY for reference, if absent\\n symbols.insert(0, 'SPY')\\n\\n for symbol in symbols:\\n # TODO: Read and join data for each symbol\\n df_temp = pd.read_csv(symbol_to_path(symbol), index_col='Date',\\n parse_dates=True, usecols=['Date', 'Adj Close'],\\n na_values=['nan'])\\n df_temp = df_temp.rename(columns={'Adj Close' : symbol})\\n df = df.join(df_temp)\\n if symbol == 'SPY':\\n df = df.dropna(subset=['SPY'])\\n\\n return df\",\n \"def _get_exog_data(cls, exog_start, exog_end, index):\\n import pandas as pd\\n\\n holiday_calendar = LADHolidays()\\n holiday_series = holiday_calendar.holidays(start=exog_start, end=exog_end, return_name=True)\\n return (pd.DataFrame({'Holiday': holiday_series, 'Ones': 1})\\n .pivot(columns='Holiday', values='Ones')\\n .reindex(index)\\n .fillna(0)\\n )\",\n \"def get_dataframes(symbols=(\\\"sne\\\", \\\"goog\\\", \\\"tsla\\\"), source='yahoo', refresh=False):\\n symbols = util.make_symbols(list(symbols))\\n if refresh:\\n symbols_to_refresh = symbols\\n else:\\n symbols_to_refresh = [sym for sym in symbols if not Equity.objects.filter(symbol=sym).exists()]\\n source = source.lower().strip()\\n if source in ('yahoo', 'google'):\\n source += '_finance'\\n if source[:3] == 'fed':\\n source = 'federal_reserve_economic_data'\\n ccpanda = ccp.ConcurrentPandas()\\n # set the data source\\n getattr(ccpanda, \\\"set_source_\\\" + source)()\\n if symbols_to_refresh:\\n # tell concurrent pandas which keys/symbols to retrieve\\n ccpanda.insert_keys(symbols_to_refresh)\\n # start concurrentpandas threads\\n ccpanda.consume_keys_asynchronous_threads()\\n # FIXME: is there a better/faster iterator to use like `ccpanda.output_map` attribute?\\n pseudodict = ccpanda.return_map()\\n else:\\n pseudodict = {}\\n table = {}\\n for sym in symbols:\\n e, created = None, False\\n if not sym in symbols_to_refresh:\\n e, created = Equity.objects.get_or_create(symbol=sym)\\n if created or not e or not e.time_series or sym in symbols_to_refresh:\\n e, created = Equity.objects.get_or_create(\\n symbol=sym,\\n name=sym, # FIXME: use data source to find equity name!\\n time_series=pseudodict[sym].to_json(),\\n )\\n table[sym] = pd.io.json.read_json(path_or_buf=e.time_series, orient='columns', typ='frame', convert_dates=True)\\n return table\",\n \"def dataframe(self):\\n if not self.all_records:\\n print('No rows cached.')\\n return\\n dict_list = [row.as_dict() for row in self.all_records]\\n columns = self.all_records[0].keys\\n dataframe = pd.DataFrame(dict_list, columns=columns)\\n return dataframe\",\n \"def asfreq(self, **kwargs): # noqa: PR01\\n return DataFrameDefault.register(pandas.DataFrame.asfreq)(self, **kwargs)\",\n \"def get_dummy_data(num_days, low, high, end_date='1970-01-01'):\\n step = (high - low) / (num_days - 1)\\n ref = datetime.strptime(end_date, '%Y-%m-%d').date()\\n start_dt = ref - timedelta(days=(num_days - 1))\\n end_dt = ref + timedelta(days=1)\\n ts = np.arange(start_dt, end_dt, timedelta(days=1)).astype(date)\\n df = pd.DataFrame(data={'price': np.arange(low, high + 1, step)}, index=pd.DatetimeIndex(ts))\\n df.index.name = 'date'\\n return df\",\n \"def dataframe(self):\\n\\n if self._dataframe is None:\\n try:\\n import pandas as pd\\n except ImportError:\\n raise RuntimeError('To enable dataframe support, '\\n 'run \\\\'pip install datadotworld[pandas]\\\\'')\\n\\n self._dataframe = pd.DataFrame.from_records(self._iter_rows(),\\n coerce_float=True)\\n\\n return self._dataframe\",\n \"def as_dataframe(self) -> \\\"pd.DataFrame\\\":\\n import pandas as pd\\n\\n df = pd.DataFrame([row.as_series() for row in self.rows])\\n return df\",\n \"def read_historical_data():\\n pull_dir = \\\"/common/quidel-historical-raw\\\"\\n columns = ['SofiaSerNum', 'TestDate', 'Facility', 'ZipCode',\\n 'FluA', 'FluB', 'StorageDate']\\n df = pd.DataFrame(columns=columns)\\n\\n for fn in os.listdir(pull_dir):\\n if \\\"xlsx\\\" in fn:\\n newdf = pd.read_excel(\\\"/\\\".join([pull_dir, fn]))\\n df = df.append(newdf[columns])\\n return df\",\n \"def technicalIndicatorsDf(daily_data):\\n o = daily_data['Open'].values\\n c = daily_data['Close'].values\\n h = daily_data['High'].values\\n l = daily_data['Low'].values\\n v = daily_data['Volume'].astype(float).values\\n # define the technical analysis matrix\\n\\n # Most data series are normalized by their series' mean\\n ta = {} #pd.DataFrame()\\n ta['MA5'] = talib.MA(c, timeperiod=5)\\n ta['MA10'] = talib.MA(c, timeperiod=10)\\n ta['MA20'] = talib.MA(c, timeperiod=20)\\n ta['MA60'] = talib.MA(c, timeperiod=60)\\n ta['MA120'] = talib.MA(c, timeperiod=120)\\n ta['MA5'] = talib.MA(v, timeperiod=5)\\n ta['MA10'] = talib.MA(v, timeperiod=10)\\n ta['MA20'] = talib.MA(v, timeperiod=20)\\n ta['ADX'] = talib.ADX(h, l, c, timeperiod=14)\\n ta['ADXR'] = talib.ADXR(h, l, c, timeperiod=14)\\n ta['MACD'] = talib.MACD(c, fastperiod=12, slowperiod=26, signalperiod=9)[0]\\n ta['RSI'] = talib.RSI(c, timeperiod=14)\\n ta['BBANDS_U'] = talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[0]\\n ta['BBANDS_M'] = talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[1]\\n ta['BBANDS_L'] = talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[2]\\n ta['AD'] = talib.AD(h, l, c, v) \\n ta['ATR'] = talib.ATR(h, l, c, timeperiod=14) \\n ta['HT_DC'] = talib.HT_DCPERIOD(c) \\n ta[\\\"High/Open\\\"] = h / o\\n ta[\\\"Low/Open\\\"] = l / o\\n ta[\\\"Close/Open\\\"] = c / o\\n ta['Open'] = o\\n ta['Close'] = c\\n ta['High'] = h\\n ta['Low'] = l\\n ta['Volume'] = v\\n\\n # Normalized values\\n ta['MA5-normalized'] = talib.MA(c, timeperiod=5) / np.nanmean(talib.MA(c, timeperiod=5))\\n ta['MA10-normalized'] = talib.MA(c, timeperiod=10) / np.nanmean(talib.MA(c, timeperiod=10))\\n ta['MA20-normalized'] = talib.MA(c, timeperiod=20) / np.nanmean(talib.MA(c, timeperiod=20))\\n ta['MA60-normalized'] = talib.MA(c, timeperiod=60) / np.nanmean(talib.MA(c, timeperiod=60))\\n ta['MA120-normalized'] = talib.MA(c, timeperiod=120) / np.nanmean(talib.MA(c, timeperiod=120))\\n ta['MA5-normalized'] = talib.MA(v, timeperiod=5) / np.nanmean(talib.MA(v, timeperiod=5))\\n ta['MA10-normalized'] = talib.MA(v, timeperiod=10) / np.nanmean(talib.MA(v, timeperiod=10))\\n ta['MA20-normalized'] = talib.MA(v, timeperiod=20) / np.nanmean(talib.MA(v, timeperiod=20))\\n ta['ADX-normalized'] = talib.ADX(h, l, c, timeperiod=14) / np.nanmean(talib.ADX(h, l, c, timeperiod=14))\\n ta['ADXR-normalized'] = talib.ADXR(h, l, c, timeperiod=14) / np.nanmean(talib.ADXR(h, l, c, timeperiod=14))\\n ta['MACD-normalized'] = talib.MACD(c, fastperiod=12, slowperiod=26, signalperiod=9)[0] / \\\\\\n np.nanmean(talib.MACD(c, fastperiod=12, slowperiod=26, signalperiod=9)[0])\\n ta['RSI-normalized'] = talib.RSI(c, timeperiod=14) / np.nanmean(talib.RSI(c, timeperiod=14))\\n ta['BBANDS_U-normalized'] = talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[0] / \\\\\\n np.nanmean(talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[0])\\n ta['BBANDS_M-normalized'] = talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[1] / \\\\\\n np.nanmean(talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[1])\\n ta['BBANDS_L-normalized'] = talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[2] / \\\\\\n np.nanmean(talib.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[2])\\n ta['AD-normalized'] = talib.AD(h, l, c, v) / np.nanmean(talib.AD(h, l, c, v))\\n ta['ATR-normalized'] = talib.ATR(h, l, c, timeperiod=14) / np.nanmean(talib.ATR(h, l, c, timeperiod=14))\\n ta['HT_DC-normalized'] = talib.HT_DCPERIOD(c) / np.nanmean(talib.HT_DCPERIOD(c))\\n return ta\",\n \"def time_series_daily(symbol: str, outputsize: str = 'compact') -> Tuple[pd.DataFrame, dict]:\\n response = _fetch(symbol=symbol, function='TIME_SERIES_DAILY', outputsize=outputsize)\\n\\n response_dict = json.loads(response.content)\\n\\n df = pd.DataFrame.from_dict(response_dict[f'Time Series (Daily)'], orient='index', dtype=np.float64)\\n df.index = pd.to_datetime(df.index)\\n df = df.rename(columns=_string_map(df.columns))\\n\\n metadata = response_dict['Meta Data']\\n _rename_dict_keys(metadata)\\n\\n metadata['begin_datetime'] = df.index.min()\\n metadata['end_datetime'] = df.index.max()\\n\\n return df, metadata\",\n \"def fetchOHLC(ticker,interval,duration):\\r\\n instrument = instrumentLookup(instrument_df,ticker)\\r\\n data = pd.DataFrame(kite.historical_data(instrument,dt.date.today()-dt.timedelta(duration), dt.date.today(),interval))\\r\\n data.set_index(\\\"date\\\",inplace=True)\\r\\n return data\",\n \"def price_dataframe(symbols=('sne',),\\n start=datetime.datetime(2008, 1, 1),\\n end=datetime.datetime(2009, 12, 31),\\n price_type='actual_close',\\n cleaner=util.clean_dataframe,\\n ):\\n if isinstance(price_type, basestring):\\n price_type = [price_type]\\n start = nlp.util.normalize_date(start or datetime.date(2008, 1, 1))\\n end = nlp.util.normalize_date(end or datetime.date(2009, 12, 31))\\n symbols = util.make_symbols(symbols)\\n df = get_dataframes(symbols)\\n # t = du.getNYSEdays(start, end, datetime.timedelta(hours=16))\\n # df = clean_dataframes(dataobj.get_data(t, symbols, price_type))\\n if not df or len(df) > 1:\\n return cleaner(df)\\n else:\\n return cleaner(df[0])\",\n \"def dataframe(self, *args, **kwargs):\\n\\n from pandas import DataFrame\\n\\n # Just normal data, so use the iterator in this object.\\n headers = next(islice(self, 0, 1))\\n data = islice(self, 1, None)\\n\\n return DataFrame(list(data), columns=headers)\",\n \"def data_frame_creator(self):\\n\\n return pd.DataFrame()\",\n \"def to_pandas_df(self):\\n data = self._get_data(pd=True)\\n return data\",\n \"def get_dataframe(self, index=0):\\n import pandas\\n data = self.get_data(index)\\n columns = self.get_legend(index)\\n df = pandas.DataFrame(data, columns=columns)\\n return df\",\n \"def all(self, **kwargs): # noqa: PR02\\n return DataFrameDefault.register(pandas.DataFrame.all)(self, **kwargs)\",\n \"def fetchOHLC(ticker,interval,duration):\\n instrument = instrumentLookup(instrument_df,ticker)\\n data = pd.DataFrame(kite.historical_data(instrument,dt.date.today()-dt.timedelta(duration), dt.date.today(),interval))\\n data.set_index(\\\"date\\\",inplace=True)\\n return data\",\n \"def gen_SMA_df(ticker=None):\\n if ticker is None or not isinstance(ticker, str):\\n return None\\n \\n data = yf.Ticker(ticker)\\n data = data.history(period='360d')\\n data = data[DESIRED_COLUMNS]\\n \\n SMA_LONG_data = data.rolling(window=WINDOW_LONG).mean()\\n SMA_LONG_data = SMA_LONG_data.rename(columns={'Close': 'SMA_LONG_Close'})\\n SMA_LONG_data = SMA_LONG_data.dropna()\\n\\n SMA_SHORT_data = data.rolling(window=WINDOW_SHORT).mean()\\n SMA_SHORT_data = SMA_SHORT_data.rename(columns={'Close': 'SMA_SHORT_Close'})\\n SMA_SHORT_data = SMA_SHORT_data.dropna()\\n\\n EWA_data = data.ewm(span=WINDOW_SHORT, min_periods=WINDOW_SHORT).mean()\\n EWA_data = EWA_data.rename(columns={'Close': 'EWA_Close'})\\n\\n \\n SMA_join = SMA_LONG_data.join(SMA_SHORT_data).join(EWA_data).join(data)\\n SMA_join = SMA_join.rename(columns={'Close': 'Single_Day_Close'})\\n return SMA_join\",\n \"def taxa_data_frame(self):\\n cols = list(self._taxa.keys())\\n cols.remove(\\\"uid\\\")\\n cols.remove(\\\"object\\\")\\n df = DataFrame(self._taxa, columns=cols, index=self._taxa[\\\"uid\\\"])\\n df.index.name = \\\"uid\\\"\\n\\n return df\",\n \"def select_data(data=pd.DataFrame(), date_initial=\\\"2005-01-01\\\", date_final=\\\"2019-12-31\\\"):\\n data = data[data.index >= date_initial]\\n data = data[data.index <= date_final]\\n return data\",\n \"def create_pandas_dataframe(data, index, columns):\\n return pd.DataFrame(data, index, columns)\",\n \"def get_stock_data(company, start_date_inc, stop_date_inc):\\n\\n api_key = 'Bo9P_cJnmf5EsQPp1Bdp'\\n desired_cols = 'date,close'\\n\\n# ticker = 'FB'\\n# start_date_inc = '20170801'\\n# end_date_inc = '20170831'\\n\\n # format and send the request\\n payload = {\\n 'date.gte': start_date_inc,\\n 'date.lte': stop_date_inc,\\n 'ticker': company,\\n 'qopts.columns': desired_cols,\\n 'api_key': api_key\\n }\\n meta_url = r'https://www.quandl.com/api/v3/datatables/WIKI/PRICES'\\n r = requests.get(meta_url, params=payload)\\n\\n # convert to a pandas dataframe\\n df = pd.DataFrame(r.json()['datatable']['data'])\\n if not df.empty:\\n df.columns = ['date', 'price']\\n df['date'] = pd.to_datetime(df['date'])\\n\\n return df\",\n \"def get_dataframe_for_date(date: dt.date = INITIAL_DATE) -> pd.DataFrame:\\n\\n url = (\\n \\\"https://raw.githubusercontent.com/\\\"\\n \\\"CSSEGISandData/COVID-19/master/\\\"\\n \\\"csse_covid_19_data/\\\"\\n \\\"csse_covid_19_daily_reports/\\\"\\n \\\"{date}.csv\\\"\\n ).format(date=date.strftime(\\\"%m-%d-%Y\\\"))\\n\\n resp = requests.get(url)\\n\\n with io.StringIO(resp.text) as fp:\\n return pd.read_csv(fp)\",\n \"def time_series_daily_adj(symbol: str, outputsize: str ='compact') -> Tuple[pd.DataFrame, dict]:\\n response = _fetch(symbol=symbol, function='TIME_SERIES_DAILY_ADJUSTED', outputsize=outputsize)\\n\\n response_dict = json.loads(response.content)\\n\\n df = pd.DataFrame.from_dict(response_dict[f'Time Series (Daily)'], orient='index', dtype=np.float64)\\n df.index = pd.to_datetime(df.index)\\n df = df.rename(columns=_string_map(df.columns))\\n\\n metadata = response_dict['Meta Data']\\n _rename_dict_keys(metadata)\\n\\n metadata['begin_datetime'] = df.index.min()\\n metadata['end_datetime'] = df.index.max()\\n\\n return df, metadata\",\n \"def get_gas_for_dates(self, dates, deseasonalize=False, as_dataframe=False):\\n # Make inputs consistent: we expect dates to be a Pandas DatetimeIndex, but it may be a single timestamp or\\n # datetime. For now, we will not allow collections of datetimes, such inputs must be converted to DatetimeIndex\\n # instances before being passed in.\\n if not isinstance(dates, pd.DatetimeIndex):\\n try:\\n timestamp_in = pd.Timestamp(dates)\\n except (ValueError, TypeError):\\n raise ValueError('dates must be a Pandas DatetimeIndex or an object convertible to a Pandas Timestamp. '\\n 'Objects of type {} are not supported'.format(type(dates).__name__))\\n else:\\n dates = pd.DatetimeIndex([timestamp_in])\\n\\n start_date = dates.min()\\n end_date = dates.max()\\n\\n # Need to make sure we get data that bracket the start and end date, so set them the first days of month\\n start_date_subset = mod_utils.start_of_month(start_date, out_type=pd.Timestamp)\\n end_date_subset = mod_utils.start_of_month(end_date + relativedelta(months=1), out_type=pd.Timestamp)\\n\\n # First get just monthly data. freq='MS' gives us monthly data at the start of the month. Use the existing logic\\n # to extrapolate the record for a given month if needed.\\n monthly_idx = pd.date_range(start_date_subset, end_date_subset, freq='MS')\\n monthly_df = pd.DataFrame(index=monthly_idx, columns=['dmf_mean', 'latency'], dtype=float)\\n for timestamp in monthly_df.index:\\n monthly_df.dmf_mean[timestamp], info_dict = self.get_gas_by_month(timestamp.year, timestamp.month, deseasonalize=deseasonalize)\\n monthly_df.latency[timestamp] = info_dict['latency']\\n\\n # Now we resample to the dates requested, making sure to keep the values at the start of each month on either\\n # end of the record to ensure interpolation is successful\\n sample_date_idx = dates.copy()\\n sample_date_idx = sample_date_idx.append(monthly_idx)\\n sample_date_idx = sample_date_idx.sort_values() # is needed for successful interpolation\\n sample_date_idx = pd.unique(sample_date_idx) # deal with the possibility that one of the requested dates was a month start\\n df_resampled = monthly_df.reindex(sample_date_idx)\\n\\n # Verify we have non-NaN values for all monthly reference points\\n if df_resampled['dmf_mean'][monthly_idx].isna().any():\\n raise RuntimeError('Failed to resample concentrations for date range {} to {}; first and/or last point is NA'\\n .format(start_date_subset, end_date_subset))\\n\\n df_resampled.interpolate(method='index', inplace=True)\\n\\n # Return with just the originally requested dates\\n df_resampled = df_resampled.reindex(dates)\\n if as_dataframe:\\n return df_resampled\\n else:\\n return df_resampled['dmf_mean'].values\",\n \"def get_data_extended(self, inception_date, interval):\\n instrument = self.instrumentLookup()\\n from_date = dt.datetime.strptime(inception_date, \\\"%Y-%m-%d\\\")\\n to_date = dt.date.today()\\n data = pd.DataFrame(columns=[\\\"date\\\", \\\"open\\\", \\\"high\\\", \\\"low\\\", \\\"close\\\", \\\"volume\\\"])\\n while True:\\n if from_date.date() >= (dt.date.today() - dt.timedelta(100)):\\n data = data.append(\\n pd.DataFrame(\\n self.kite.historical_data(\\n instrument, from_date, dt.date.today(), interval\\n )\\n ),\\n ignore_index=True,\\n )\\n break\\n else:\\n to_date = from_date + dt.timedelta(100)\\n data = data.append(\\n pd.DataFrame(\\n self.kite.historical_data(\\n instrument, from_date, to_date, interval\\n )\\n ),\\n ignore_index=True,\\n )\\n from_date = to_date\\n data.set_index(\\\"date\\\", inplace=True)\\n self.data_df = data\",\n \"def create_df():\\n df = load_df_from_files()\\n df = clean_df(df)\\n df = expand_df_dates(df)\\n df[\\\"age_at_t\\\"] = ((df[\\\"date\\\"] - df[\\\"birthday\\\"]) / 365).dt.days # Yeah, this is weird.\\n return df\",\n \"def get_time_series(rics: list, fields: list, start_date: str, end_date: str) -> pd.DataFrame:\\n # Check date formats are YYYY-MM-DD.\\n try:\\n dt.datetime.strptime(start_date, '%Y-%m-%d')\\n except ValueError:\\n raise ValueError('\\\"start_date\\\" has incorrect format.')\\n try:\\n dt.datetime.strptime(end_date, '%Y-%m-%d')\\n except ValueError:\\n raise ValueError('\\\"end_date\\\" has incorrect format.')\\n\\n data = ek.get_timeseries(rics, fields, start_date=start_date, end_date=end_date)\\n return data\",\n \"def get_stock_historical_data(symbol, config):\\n start_date_dt = datetime.datetime.strptime(config['start_date'], '%Y%m%d').date()\\n end_date_dt = datetime.datetime.strptime(config['end_date'], '%Y%m%d').date()\\n\\n filename = '{}.csv'.format(symbol)\\n dir_path = DATA_DIR / 'nasdaq_historical' / '{}_{}'.format(config['start_date'], config['end_date'])\\n if not os.path.exists(dir_path):\\n os.mkdir(dir_path)\\n\\n full_path = dir_path / filename\\n if os.path.exists(full_path):\\n df = pd.read_csv(full_path, header=0, index_col='Date', parse_dates=True)\\n else:\\n df = web.get_data_yahoo(symbol, config['start_date'], config['end_date'])\\n if df.index[0].date() == start_date_dt and df.index[-1].date() == end_date_dt:\\n df.to_csv(full_path)\\n\\n df.attrs.update(config)\\n df.attrs['stock_symbol'] = symbol\\n df.attrs['start_date_dt'] = datetime.datetime.strptime(config['start_date'], '%Y%m%d').date()\\n df.attrs['end_date_dt'] = datetime.datetime.strptime(config['end_date'], '%Y%m%d').date()\\n df.attrs['date_dir'] = '{}_{}'.format(config['start_date'], config['end_date']) # for building paths\\n return df\",\n \"def load_daily_data():\\n return pd.read_csv(os.path.join('data', 'raw', 'full_grouped.csv'))\",\n \"def obtain_monthly_mean(data=pd.DataFrame()):\\n return data.resample(\\\"MS\\\").mean()\",\n \"def to_dataframe(\\n self, *, unit_in_name: bool = False, round_time: str | bool = \\\"ms\\\"\\n ) -> pd.DataFrame:\\n if self.ndim > 1:\\n raise ValueError(\\n \\\"Only data with a single dimension can be converted to a dataframe. Hint: use `squeeze` to remove singleton dimensions or `isel` to create a subset.\\\"\\n )\\n\\n if unit_in_name:\\n data = {\\n f\\\"{item.name} ({item.unit.name})\\\": item.to_numpy().ravel()\\n for item in self\\n }\\n else:\\n data = {item.name: item.to_numpy().ravel() for item in self}\\n df = pd.DataFrame(data, index=self.time)\\n\\n if round_time:\\n rounded_idx = pd.DatetimeIndex(self.time).round(round_time) # type: ignore\\n df.index = pd.DatetimeIndex(rounded_idx, freq=\\\"infer\\\")\\n else:\\n df.index = pd.DatetimeIndex(self.time, freq=\\\"infer\\\")\\n\\n return df\",\n \"def to_dataframe(self):\\n \\n #Try importing pandas\\n try:\\n import pandas as pd\\n except ImportError as e:\\n raise RuntimeError(\\\"Error: pandas is not available. Install pandas in order to use this function.\\\") from e\\n \\n #Get season info\\n season_info = self.annual_summary()\\n season_info_keys = season_info['id']\\n \\n #Set up empty dict for dataframe\\n ds = {'id':[],'name':[],'vmax':[],'mslp':[],'category':[],'ace':[],'start_time':[],'end_time':[]}\\n \\n #Add every key containing a list into the dict\\n keys = [k for k in self.dict.keys()]\\n for key in keys:\\n if key in season_info_keys:\\n sidx = season_info_keys.index(key)\\n ds['id'].append(key)\\n ds['name'].append(self.dict[key]['name'])\\n ds['vmax'].append(season_info['max_wspd'][sidx])\\n ds['mslp'].append(season_info['min_mslp'][sidx])\\n ds['category'].append(season_info['category'][sidx])\\n ds['start_time'].append(self.dict[key]['date'][0])\\n ds['end_time'].append(self.dict[key]['date'][-1])\\n ds['ace'].append(np.round(season_info['ace'][sidx],1))\\n \\n #Convert entire dict to a DataFrame\\n ds = pd.DataFrame(ds)\\n\\n #Return dataset\\n return ds\",\n \"def generate_df(\\n self,\\n size: Optional[int] = 90 * 24, # 90 days worth of data\\n start_date: Optional[str] = \\\"2018-01-01\\\",\\n hourly_seasonality: float = 1.0,\\n hourly_seasonality_params: Optional[List[Tuple[float, float]]] = None,\\n trend_params: Optional[List[TrendParams]] = None,\\n weekday_dummy_params: Optional[List[float]] = None,\\n annual_seasonality_params: Optional[List[Tuple[float, float]]] = None,\\n holiday_alpha: float = 3.5,\\n outlier_alpha: float = 2.5,\\n noise_scale: float = 1.0,\\n ) -> pd.DataFrame:\\n\\n return pd.DataFrame(\\n {\\n \\\"ds\\\": pd.date_range(start_date, periods=size, freq=\\\"60min\\\"),\\n \\\"y\\\": self._generate_hourly_time_series(\\n size=size,\\n hourly_seasonality=hourly_seasonality,\\n hourly_seasonality_params=hourly_seasonality_params,\\n trend_params=trend_params,\\n weekday_dummy_params=weekday_dummy_params,\\n annual_seasonality_params=annual_seasonality_params,\\n holiday_alpha=holiday_alpha,\\n outlier_alpha=outlier_alpha,\\n noise_scale=noise_scale,\\n ),\\n }\\n )\",\n \"def get_df(self) -> pd.DataFrame:\\n return pd.DataFrame(self.fetchall(), columns=self.headers())\",\n \"def date_features(s: pd.Series, result: Optional[pd.DataFrame] = None) -> pd.DataFrame:\\n if result is None:\\n result = pd.DataFrame(s, copy=False)\\n index = cast(pd.DatetimeIndex, s.index)\\n\\n result[\\\"year\\\"] = index.year\\n result[\\\"month\\\"] = index.month\\n result[\\\"day\\\"] = index.day\\n result[\\\"dayofweek\\\"] = index.dayofweek\\n result[\\\"dayofyear\\\"] = index.dayofyear\\n result[\\\"quarter\\\"] = index.quarter\\n result[\\\"season\\\"] = _map(index.month, _SEASON_MAP)\\n result[\\\"weekofyear\\\"] = index.weekofyear\\n try:\\n # Work around numpy Deprecation Warning about parsing timezones\\n # by converting to UTC and removing the tz info.\\n dates = index.tz_convert(None).to_numpy()\\n except TypeError:\\n # No timezone.\\n dates = index.to_numpy()\\n first_of_month = pd.to_datetime(dates.astype(\\\"datetime64[M]\\\"))\\n week_of_month = np.ceil((first_of_month.dayofweek + index.day) / 7.0)\\n result[\\\"weekofmonth\\\"] = week_of_month.astype(int)\\n # result[\\\"is_holiday\\\"] = ?\\n # result[\\\"holiday_types\\\"] = ?\\n result[\\\"is_weekend\\\"] = index.dayofweek >= 5\\n result[\\\"is_leap_year\\\"] = index.is_leap_year\\n result[\\\"is_leap_day\\\"] = (index.month == 2) & (index.day == 29)\\n result[\\\"is_month_end\\\"] = index.is_month_end\\n result[\\\"is_quarter_end\\\"] = index.is_month_end & (index.month % 4 == 3)\\n\\n return result\",\n \"def get_data(self)->pd.DataFrame:\\n pass\",\n \"def to_pandas( # type: ignore [override]\\n self,\\n column_names: Literal[\\\"id\\\", \\\"external_id\\\"] = \\\"external_id\\\",\\n include_aggregate_name: bool = True,\\n include_granularity_name: bool = False,\\n ) -> pandas.DataFrame:\\n pd = cast(Any, local_import(\\\"pandas\\\"))\\n if column_names == \\\"id\\\":\\n if self.id is None:\\n raise ValueError(\\\"Unable to use `id` as column name(s), not set on object\\\")\\n identifier = str(self.id)\\n\\n elif column_names == \\\"external_id\\\":\\n if self.external_id is not None:\\n identifier = self.external_id\\n elif self.id is not None:\\n # Time series are not required to have an external_id unfortunately...\\n identifier = str(self.id)\\n warnings.warn(\\n f\\\"Time series does not have an external ID, so its ID ({self.id}) was used instead as \\\"\\n 'the column name in the DataFrame. If this is expected, consider passing `column_names=\\\"id\\\"` '\\n \\\"to silence this warning.\\\",\\n UserWarning,\\n )\\n else:\\n raise ValueError(\\\"Object missing both `id` and `external_id` attributes\\\")\\n else:\\n raise ValueError(\\\"Argument `column_names` must be either 'external_id' or 'id'\\\")\\n\\n if self.value is not None:\\n return pd.DataFrame({identifier: self.value}, index=self.timestamp, copy=False)\\n\\n (_, *agg_names), (_, *arrays) = self._data_fields()\\n columns = [\\n str(identifier) + include_aggregate_name * f\\\"|{agg}\\\" + include_granularity_name * f\\\"|{self.granularity}\\\"\\n for agg in agg_names\\n ]\\n # Since columns might contain duplicates, we can't instantiate from dict as only the\\n # last key (array/column) would be kept:\\n (df := pd.DataFrame(dict(enumerate(arrays)), index=self.timestamp, copy=False)).columns = columns\\n return df\",\n \"def to_pandas( # type: ignore [override]\\n self,\\n column_names: Literal[\\\"id\\\", \\\"external_id\\\"] = \\\"external_id\\\",\\n include_aggregate_name: bool = True,\\n include_granularity_name: bool = False,\\n ) -> pandas.DataFrame:\\n pd = cast(Any, local_import(\\\"pandas\\\"))\\n dfs = [dps.to_pandas(column_names, include_aggregate_name, include_granularity_name) for dps in self]\\n if not dfs:\\n return pd.DataFrame(index=pd.to_datetime([]))\\n\\n return concat_dataframes_with_nullable_int_cols(dfs)\",\n \"def to_pandas( # type: ignore [override]\\n self,\\n column_names: Literal[\\\"id\\\", \\\"external_id\\\"] = \\\"external_id\\\",\\n include_aggregate_name: bool = True,\\n include_granularity_name: bool = False,\\n ) -> pandas.DataFrame:\\n pd = cast(Any, local_import(\\\"pandas\\\"))\\n dfs = [dps.to_pandas(column_names, include_aggregate_name, include_granularity_name) for dps in self]\\n if not dfs:\\n return pd.DataFrame(index=pd.to_datetime([]))\\n\\n return concat_dataframes_with_nullable_int_cols(dfs)\",\n \"def sql_return_df(query, params, date_cols):\\n conn = sqlite3.connect(db_filepath)\\n df = pd.read_sql(query, conn, params=params, parse_dates=date_cols)\\n conn.close()\\n return df\",\n \"def get_cpi_rates():\\n\\n df = pd.read_csv('cpi_usa.csv', index_col=0)\\n df.index = pd.to_datetime(df.index)\\n\\n df = df.resample('BAS').mean() # change sampling to business year start\\n df.index = df.index.year # datetime to year\\n df.columns = ['cpi_rate']\\n\\n return df\",\n \"def _read(**kwargs) -> DataFrame:\\n Engine.subscribe(_update_engine)\\n\\n try:\\n pd_obj = FactoryDispatcher.read_csv_glob(**kwargs)\\n except AttributeError:\\n raise AttributeError(\\\"read_csv_glob() is only implemented for pandas on Ray.\\\")\\n\\n # This happens when `read_csv` returns a TextFileReader object for iterating through\\n if isinstance(pd_obj, pandas.io.parsers.TextFileReader):\\n reader = pd_obj.read\\n pd_obj.read = lambda *args, **kwargs: DataFrame(\\n query_compiler=reader(*args, **kwargs)\\n )\\n return pd_obj\\n\\n return DataFrame(query_compiler=pd_obj)\",\n \"def create_quanti_df(df: pd.DataFrame) -> pd.DataFrame:\\n\\n # create a dictionary that contains datatype of each column\\n dtypeDict = dict(df.dtypes)\\n # create a list of column names that contains only quantitative data\\n quanti_cols = [\\n key\\n for key, value in dtypeDict.items()\\n if value == \\\"float64\\\" or value == \\\"int64\\\" or value == \\\"uint8\\\"\\n ]\\n df = df[quanti_cols]\\n return df\",\n \"def get_weather_timeseries_2017():\\n weather_df = pd.read_csv(\\\"src/kumpula-weather-2017.csv\\\")\\n\\n # -1 value in columns \\\"Precipitation amount (mm)\\\" and \\\"Snow depth (cm)\\\" mean\\n # that there was no absolutely no rain or snow that day, whereas 0 can mean\\n # a little of either. Let's convert the -1 values to 0 to make the dataset\\n # more logical to read.\\n weather_df.loc[weather_df[\\\"Precipitation amount (mm)\\\"] == -1,\\n \\\"Precipitation amount (mm)\\\"] = 0\\n weather_df.loc[weather_df[\\\"Snow depth (cm)\\\"] == -1, \\\"Snow depth (cm)\\\"] = 0\\n\\n # Create datetime index\\n weather_df[\\\"Month\\\"] = weather_df[\\\"m\\\"]\\n weather_df[\\\"Day\\\"] = weather_df[\\\"d\\\"]\\n weather_df[\\\"Date\\\"] = pd.to_datetime(weather_df[[\\\"Year\\\", \\\"Month\\\", \\\"Day\\\"]])\\n\\n # Reindex dataset\\n weather_df = weather_df.set_index(\\\"Date\\\")\\n\\n # Drop redundant columns\\n weather_df.drop([\\\"Time\\\", \\\"Time zone\\\", \\\"m\\\", \\\"d\\\", \\\"Year\\\",\\n \\\"Month\\\", \\\"Day\\\"], axis=\\\"columns\\\", inplace=True)\\n\\n return weather_df\",\n \"def get_data(symbols, dates):\\n df = pd.DataFrame(index=dates)\\n \\n if 'SPY' not in symbols: #add SPY for reference\\n symbols.insert(0,'SPY')\\n \\n # This for loop will loop through all the desired\\n # symbols in the symbol list and create a dataframe\\n # containing all the required data\\n for symbol in symbols:\\n # Get path for .csv file for symbol\\n sym_path = symbol_to_path(symbol)\\n # Load data from csv and create dataframe\\n if symbol == 'SPY':\\n dfSPY = pd.read_csv(sym_path,\\n index_col=\\\"Date\\\",\\n parse_dates=True,\\n usecols=[\\\"Date\\\",\\\"Adj Close\\\"],\\n na_values=['nan'])\\n \\n dfSPY = dfSPY.rename(columns={\\\"Adj Close\\\": str(symbol)})\\n df = df.join(dfSPY,how='inner') # inner joins and drops NaN\\n else:\\n df_temp = pd.read_csv(sym_path,\\n index_col=\\\"Date\\\",\\n parse_dates=True,\\n usecols=[\\\"Date\\\",\\\"Adj Close\\\"],\\n na_values=['nan'])\\n df_temp = df_temp.rename(columns={\\\"Adj Close\\\": str(symbol)})\\n df = df.join(df_temp,how='inner')\\n df = df.sort_index(ascending=True)\\n return df\",\n \"def pd(self, *args, **kwargs):\\n return pd.DataFrame.from_records(self.aslist(), *args, **kwargs)\",\n \"def getEPADailyData(dateint, dt_ind, month, epa_df, yr):\\n\\n try:\\n start = dateint + dt_ind * 10000\\n end = start + 10001\\n dly_epa_df = epa_df[(epa_df.created >= start) & (epa_df.created < end)]\\n dly_epa_df.reset_index(inplace=True, drop=True)\\n\\n new_df = pd.DataFrame(columns=['lat', 'lon', 'utc', 'parameter', 'epa_pm25_unit', 'epa_pm25_value', 'raw_concentration', 'aqi', 'category', 'site_name', 'agency_name', 'full_aqs_code', 'intl_aqs_code', 'created'])\\n for sitenm in dly_epa_df.site_name.unique():\\n indx_ct = 0\\n site_df = dly_epa_df[dly_epa_df.site_name == sitenm]\\n for i in site_df.created.unique():\\n indx_ct += 1\\n new_df = pd.concat([new_df,site_df.iloc[indx_ct - 1:indx_ct]],ignore_index=True)\\n\\n if i != site_df.created.max(): # Don't interpolate the last record\\n tmp_df = site_df.iloc[indx_ct - 1:indx_ct][['lat', 'lon', 'utc', 'parameter', 'epa_pm25_unit', 'category', 'site_name', 'agency_name', 'full_aqs_code', 'intl_aqs_code']]\\n for j in range(1,6):\\n new_dt = i + j * 10\\n tmp_df['created'] = int(new_dt)\\n tmp_df['epa_pm25_value'] = np.nan\\n tmp_df['raw_concentration'] = np.nan\\n tmp_df['aqi'] = np.nan\\n new_df = pd.concat([new_df,tmp_df],ignore_index=True)\\n\\n # Convert aqi to numerica for so that it gets interpolated\\n new_df[['aqi']] = new_df[['aqi']].replace(\\\"nan\\\", np.nan, regex=True)\\n new_df[['aqi']] = new_df[['aqi']].apply(pd.to_numeric)\\n\\n new_df = new_df.interpolate(method='linear', limit_direction='forward', axis=0)\\n\\n int_epa_df = new_df[(new_df.created >= start) & (new_df.created < (end - 1))]\\n int_epa_df.reset_index(inplace=True, drop=True)\\n \\n # Write to S3\\n s3 = s3fs.S3FileSystem()\\n myopen = s3.open\\n write('midscapstone-whos-polluting-my-air/EpaDaily/epa_20{2}{0}{1:02}.parquet'.format(month, dt_ind, yr), int_epa_df, compression='GZIP', open_with=myopen)\\n s3_resource = boto3.resource('s3')\\n s3_resource.Object('midscapstone-whos-polluting-my-air', 'EpaDaily/epa_20{2}{0}{1:02}.parquet'.format(month, dt_ind, yr)).Acl().put(ACL='public-read')\\n\\n except Exception as e:\\n print(\\\"*** EXCEPTION IN GET EPA DAILY DATA *** {}\\\".format(e))\\n return int_epa_df\",\n \"def yearly(self):\\r\\n return RecordsYearly(self)\",\n \"def get_historic_data(end_date = datetime.now(), \\n start_date = datetime.now() + timedelta(-365),\\n ticker=[],\\n close_only=True):\\n #checks if the parameters provided through \\\"ticker\\\" is not an empty list\\n #if it is, the function won't go forward after this point. returns explanatory message.\\n if ticker == []:\\n return \\\"Empty list of tickers\\\"\\n \\n #if a string is provided as \\\"ticker\\\" parameter, then it splits the string by \\n #spaces and store the outcome in a list.\\n elif type(ticker) is str:\\n ticker = ticker.split(\\\" \\\")\\n \\n iex_token = os.getenv(\\\"IEX_TOKEN\\\")#not necessary anymore.\\n if type(iex_token) == str: print(\\\"IEX Key found successfully ...getting data\\\")\\n else: return \\\"Error: IEX Key NOT found\\\"\\n \\n \\n #Gets historical data with the parameters provided.\\n #Gets only \\\"close\\\" and \\\"volume\\\" value for efficiency.\\n prices = get_historical_data(ticker, start_date, end_date,\\n output_format='pandas', \\n token=iex_token, \\n close_only=close_only\\n )\\n \\n #If only one ticker is provided, then it adds another indexing level to the column\\n #with the ticker. This is done for two reasons: 1) To visualize the ticker downloaded \\n #as a confirmation that I am working with correct data. 2) To mimic the format of the\\n #dataframe obtained when getting 2 or more tickers data (2-level column indexing).\\n if len(ticker) == 1:\\n new_columns = pd.MultiIndex.from_product([ [ticker[0]],prices.columns ] )\\n prices.columns = new_columns\\n \\n return prices\",\n \"def to_stock_dataframe_range(self, start_date=None, end_date=None):\\n if end_date is None:\\n end_date = self.dates[-2]\\n if type(end_date) is pd.tslib.Timestamp:\\n end_date = end_date.strftime(\\\"%Y-%m-%d\\\")\\n if type(end_date) is not datetime.datetime and type(end_date) is not pd.tslib.Timestamp:\\n end_date = datetime.datetime.strptime(end_date, \\\"%Y-%m-%d\\\")\\n try:\\n end_date = self.dates[list(self.dates).index(end_date) + 1]\\n except:\\n end_date = \\\"Last\\\"\\n if start_date is None:\\n start_date = self.dates[0]\\n\\n if type(start_date) is not datetime.datetime and type(start_date) is not pd.tslib.Timestamp:\\n start_date = datetime.datetime.strptime(start_date, \\\"%Y-%m-%d\\\")\\n\\n class_data = [i for i in dir(self) if not callable(getattr(self, i)) and not i.startswith(\\\"__\\\") and\\n type(getattr(self, i)) is pd.DataFrame]\\n df = pd.DataFrame()\\n for i in class_data:\\n df = join_features(df, getattr(self, i), fill_method=FillMethod.FUTURE_KROGH)\\n if end_date is \\\"Last\\\":\\n print(df.ix[start_date:, :])\\n return df.ix[start_date:, :]\\n return df.ix[start_date:end_date, :]\",\n \"def get_price_df(url):\\n df = pd.read_csv(url).dropna()\\n df.index = pd.to_datetime(df['Date'])\\n df = df.drop(columns=['Date'])\\n return df\",\n \"def get_data(symbols, dates):\\n df = pd.DataFrame(index=dates)\\n if 'SPY' not in symbols: # add SPY for reference, if absent\\n symbols.insert(0, 'SPY')\\n\\n for symbol in symbols:\\n # TODO: Read and join data for each symbol\\n if os.path.isfile(symbol_to_path(symbol)): \\n df_temp = pd.read_csv(symbol_to_path(symbol), index_col='Date', \\n parse_dates = True, usecols=['Date', 'Adj Close'], na_values=['nan'])\\n df_temp = df_temp.rename(columns = {'Adj Close': symbol})\\n df = df.join(df_temp)\\n if symbol == 'SPY': #drop dates SPY did not trade\\n df = df.dropna(subset=[\\\"SPY\\\"])\\n# else:\\n# download_symbol(symbol) \\n return df\",\n \"def load_data(fpath: str, station: Dict[str, Any]) -> pd.DataFrame:\\n df = pd.read_csv(\\n fpath,\\n skiprows=station['header_line_num']-1,\\n usecols=['date', 'rain'],\\n )\\n\\n # format the date from a string to a proper datetime object\\n df['date'] = pd.to_datetime(df['date'])\\n\\n # extract year, month, week, and day to separate columns\\n df['year'] = df['date'].dt.year\\n df['month'] = df['date'].dt.month\\n df['day'] = df['date'].dt.dayofyear\\n df['week'] = df['date'].dt.weekofyear\\n df['year_month'] = df['date'].dt.to_period('M')\\n\\n return df\",\n \"def get_dataframe() -> pandas.DataFrame:\\n database_connection = processing.establish_connection(database_path)\\n dataframe = database_connection.to_dataframe(['CustomerId', 'InvoiceDate', 'Total'], table_name)\\n database_connection.close()\\n dataframe = processing.get_invoice_date_fixed(dataframe)\\n analyze_dataframe = dataframe.copy()\\n total_sum_dataframe = processing.get_column_sum(analyze_dataframe)\\n\\n customer_count_dataframe = processing.drop_duplicates(analyze_dataframe)\\n customer_count_dataframe = processing.get_column_count(customer_count_dataframe)\\n return customer_count_dataframe.merge(total_sum_dataframe, how='inner', on='InvoiceDate')\",\n \"def _get_data(*, from_web: bool) -> pd.DataFrame:\\n\\n df = read_in_data.SaveFormats.CSV.read(from_web=from_web)\\n return df\",\n \"def get_stock_data_yf(stock_name, past_years, interval) -> pd.DataFrame:\\n data = yf.download(stock_name, period=f'{past_years}y', interval=interval)\\n data = to_numeric_and_downcast_data(data)\\n return data\",\n \"def _get_data(self):\\n \\n print(\\\"Getting Data...\\\")\\n self.data = sgs.dataframe(self.serie_name, \\n start = self.start_date, \\n end = self.end_date)\\n\\n print(f\\\"Done! {self.data.shape[0]} rows were collected\\\")\\n \\n self.data.reset_index(inplace=True)\\n self.data.columns = ['date', 'cdi']\\n\\n return self.data\",\n \"def get_real_gdp(interval: str = \\\"a\\\") -> pd.DataFrame:\\n s_interval = \\\"quarterly\\\" if interval == \\\"q\\\" else \\\"annual\\\"\\n url = f\\\"https://www.alphavantage.co/query?function=REAL_GDP&interval={s_interval}&apikey={cfg.API_KEY_ALPHAVANTAGE}\\\"\\n r = requests.get(url, headers={\\\"User-Agent\\\": get_user_agent()})\\n\\n if r.status_code != 200:\\n return pd.DataFrame()\\n\\n data = pd.DataFrame(r.json()[\\\"data\\\"])\\n data[\\\"date\\\"] = pd.to_datetime(data[\\\"date\\\"])\\n data[\\\"GDP\\\"] = data[\\\"value\\\"].astype(float)\\n data = data.drop(columns=[\\\"value\\\"])\\n return data\",\n \"def get_df(\\n self,\\n response: Response,\\n parse_dates: Optional[Union[List[int], bool]] = False,\\n sort_values: Optional[List[str]] = None,\\n reindex_columns: Optional[List[str]] = None,\\n ) -> pd.DataFrame:\\n\\n with io.BytesIO() as buffer:\\n try:\\n buffer.write(response.content)\\n buffer.seek(0)\\n z: zipfile.ZipFile = zipfile.ZipFile(buffer)\\n\\n except zipfile.BadZipFile as e:\\n print(\\\"Bad zip file\\\", e)\\n\\n else: # TODO need to annotate csv\\n csv = z.open(z.namelist()[0]) # ignores all but first file in zip\\n df: pd.DataFrame = pd.read_csv(csv, parse_dates=parse_dates)\\n\\n df = df.rename(columns={\\\"PRC\\\": \\\"MW\\\"})\\n\\n if sort_values:\\n df = df.sort_values(sort_values).reset_index(drop=True)\\n\\n if reindex_columns:\\n df = df.reindex(columns=reindex_columns)\\n\\n return df\",\n \"def data(self):\\n if self._data.empty:\\n self._data = super().data\\n\\n max_data_year = self._data[\\\"year\\\"].max()\\n\\n # If the date range of the data doesn't line up with the year filters\\n # for train/test data, we risk getting empty data sets\\n if self.max_year != max_data_year:\\n max_year_diff = pd.to_timedelta(\\n [(YEAR_IN_DAYS * (self.max_year - max_data_year))]\\n * len(self._data),\\n unit=\\\"days\\\",\\n )\\n\\n self._data.loc[:, \\\"date\\\"] = self._data[\\\"date\\\"] + max_year_diff\\n self._data.loc[:, \\\"year\\\"] = self._data[\\\"date\\\"].dt.year\\n self._data.set_index(\\n [\\\"team\\\", \\\"year\\\", \\\"round_number\\\"], drop=False, inplace=True\\n )\\n\\n return self._data\",\n \"def pandaData():\\r\\n tweets = pd.DataFrame()\\r\\n return tweets\",\n \"def get_unemployment() -> pd.DataFrame:\\n url = f\\\"https://www.alphavantage.co/query?function=UNEMPLOYMENT&apikey={cfg.API_KEY_ALPHAVANTAGE}\\\"\\n r = requests.get(url, headers={\\\"User-Agent\\\": get_user_agent()})\\n if r.status_code != 200:\\n return pd.DataFrame()\\n data = pd.DataFrame(r.json()[\\\"data\\\"])\\n data[\\\"date\\\"] = pd.to_datetime(data[\\\"date\\\"])\\n data[\\\"unemp\\\"] = data[\\\"value\\\"].astype(float)\\n data = data.drop(columns=[\\\"value\\\"])\\n return data\",\n \"def YahooFinancials_Data(Ticker=[],Start='',End ='',Frequency ='daily'):\\n\\n\\n \\n import pandas as pd\\n from yahoofinancials import YahooFinancials\\n import datetime as dt \\n \\n Ticker = Ticker or input(\\\"Enter Tcikers separated by',': \\\").split(',')\\n Start = Start or input(\\\"Enter Start Date separated by '-': \\\") or (dt.date.today()-\\n dt.timedelta(1825)).strftime(\\\"%Y-%m-%d\\\")\\n End = End or input(\\\"Enter End Date separated by '-': \\\") or (dt.date.today()).strftime(\\\"%Y-%m-%d\\\")\\n Frequency = Frequency or input(\\\"Enter Frequency like 'daily','weekly': \\\") or 'daily'\\n \\n data = pd.DataFrame()\\n for i in range(len(Ticker)):\\n try:\\n yahoo_financials = YahooFinancials(Ticker[i])\\n Json_obj = yahoo_financials.get_historical_price_data(Start, End, Frequency)\\n Ohlv = Json_obj[Ticker[i]]['prices']\\n temp = pd.DataFrame(Ohlv)[[\\\"formatted_date\\\",\\\"adjclose\\\"]]\\n temp.set_index(\\\"formatted_date\\\", inplace = True)\\n temp = temp[~temp.index.duplicated(keep = 'first')]\\n data[Ticker[i]] = temp['adjclose']\\n \\n except:\\n print(f\\\"Unable to get the Data for: {Ticker[i]}\\\")\\n continue\\n \\n return data\",\n \"def df(x):\\n raise NotImplementedError\",\n \"def _to_dataframe(self, dataset_name):\\n values = self[dataset_name][:]\\n columns = self.get_columns(dataset_name)\\n timestamps = self.get_timestamps(dataset_name)[...]\\n if len(columns) < values.shape[1]:\\n columns.resize(values.shape[1])\\n\\n # transform missing data into NaNs\\n mask = missing_values(values) != 0\\n try:\\n values[mask] = numpy.nan\\n except ValueError: # ValueError: cannot convert float NaN to integer\\n # don't bother converting non-float arrays' -0.0 into NaNs\\n pass\\n\\n dataframe = pandas.DataFrame(data=values,\\n index=[datetime.datetime.fromtimestamp(t) for t in timestamps],\\n columns=columns)\\n return dataframe\",\n \"def get_inflation() -> pd.DataFrame:\\n url = f\\\"https://www.alphavantage.co/query?function=INFLATION&apikey={cfg.API_KEY_ALPHAVANTAGE}\\\"\\n r = requests.get(url, headers={\\\"User-Agent\\\": get_user_agent()})\\n if r.status_code != 200:\\n return pd.DataFrame()\\n data = pd.DataFrame(r.json()[\\\"data\\\"])\\n data[\\\"date\\\"] = pd.to_datetime(data[\\\"date\\\"])\\n data[\\\"Inflation\\\"] = data[\\\"value\\\"].astype(float)\\n data = data.drop(columns=[\\\"value\\\"])\\n\\n return data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61230016","0.6044962","0.59703547","0.5963478","0.5958542","0.59389883","0.5922768","0.5885662","0.58801645","0.58436364","0.5840979","0.58044046","0.57593805","0.57528985","0.5697548","0.5684046","0.5673133","0.564309","0.56324506","0.56079215","0.5598907","0.5579664","0.5569034","0.5568811","0.5559146","0.5541506","0.55341667","0.55244845","0.5500571","0.54699713","0.5469139","0.5447476","0.5447181","0.5444752","0.544333","0.5439571","0.54387766","0.54380983","0.5433666","0.54296905","0.5429442","0.5429364","0.54272646","0.54251486","0.5424973","0.541178","0.53958726","0.5388784","0.5385328","0.5382333","0.538151","0.5369862","0.5355705","0.535017","0.5349524","0.5340357","0.53281283","0.5327318","0.5326298","0.5325381","0.53217393","0.5319495","0.53169453","0.5316167","0.52906406","0.5290474","0.5289394","0.5283946","0.5281019","0.5280355","0.5278526","0.5269878","0.52588284","0.52588284","0.52574867","0.52555776","0.5254279","0.5253765","0.52472603","0.52462184","0.52453667","0.52450234","0.5244465","0.523904","0.52340555","0.5231207","0.52265316","0.521864","0.5212125","0.5204317","0.5195578","0.5194346","0.5193059","0.51926607","0.51906717","0.5181825","0.5174384","0.5172338","0.5171663","0.51603574","0.51546276"],"string":"[\n \"0.61230016\",\n \"0.6044962\",\n \"0.59703547\",\n \"0.5963478\",\n \"0.5958542\",\n \"0.59389883\",\n \"0.5922768\",\n \"0.5885662\",\n \"0.58801645\",\n \"0.58436364\",\n \"0.5840979\",\n \"0.58044046\",\n \"0.57593805\",\n \"0.57528985\",\n \"0.5697548\",\n \"0.5684046\",\n \"0.5673133\",\n \"0.564309\",\n \"0.56324506\",\n \"0.56079215\",\n \"0.5598907\",\n \"0.5579664\",\n \"0.5569034\",\n \"0.5568811\",\n \"0.5559146\",\n \"0.5541506\",\n \"0.55341667\",\n \"0.55244845\",\n \"0.5500571\",\n \"0.54699713\",\n \"0.5469139\",\n \"0.5447476\",\n \"0.5447181\",\n \"0.5444752\",\n \"0.544333\",\n \"0.5439571\",\n \"0.54387766\",\n \"0.54380983\",\n \"0.5433666\",\n \"0.54296905\",\n \"0.5429442\",\n \"0.5429364\",\n \"0.54272646\",\n \"0.54251486\",\n \"0.5424973\",\n \"0.541178\",\n \"0.53958726\",\n \"0.5388784\",\n \"0.5385328\",\n \"0.5382333\",\n \"0.538151\",\n \"0.5369862\",\n \"0.5355705\",\n \"0.535017\",\n \"0.5349524\",\n \"0.5340357\",\n \"0.53281283\",\n \"0.5327318\",\n \"0.5326298\",\n \"0.5325381\",\n \"0.53217393\",\n \"0.5319495\",\n \"0.53169453\",\n \"0.5316167\",\n \"0.52906406\",\n \"0.5290474\",\n \"0.5289394\",\n \"0.5283946\",\n \"0.5281019\",\n \"0.5280355\",\n \"0.5278526\",\n \"0.5269878\",\n \"0.52588284\",\n \"0.52588284\",\n \"0.52574867\",\n \"0.52555776\",\n \"0.5254279\",\n \"0.5253765\",\n \"0.52472603\",\n \"0.52462184\",\n \"0.52453667\",\n \"0.52450234\",\n \"0.5244465\",\n \"0.523904\",\n \"0.52340555\",\n \"0.5231207\",\n \"0.52265316\",\n \"0.521864\",\n \"0.5212125\",\n \"0.5204317\",\n \"0.5195578\",\n \"0.5194346\",\n \"0.5193059\",\n \"0.51926607\",\n \"0.51906717\",\n \"0.5181825\",\n \"0.5174384\",\n \"0.5172338\",\n \"0.5171663\",\n \"0.51603574\",\n \"0.51546276\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":91992,"cells":{"query":{"kind":"string","value":"Run a simulation with the standard and Galilean scheme respectively and check that the first one is unstable while the second one is stable"},"document":{"kind":"string","value":"def test_cherenkov_instability( show=False ):\n # Dictionary to record the final value of E\n slope_Erms = {}\n\n for scheme in [ 'standard', 'galilean', 'pseudo-galilean']:\n\n # Choose the correct parameters for the scheme\n if scheme == 'standard':\n v_comoving = 0.\n use_galilean = False\n else:\n v_comoving = 0.9999*c\n if scheme == 'galilean':\n use_galilean = True\n else:\n use_galilean = False\n\n # Initialize the simulation object\n sim = Simulation( Nz, zmax, Nr, rmax, Nm, dt,\n p_zmin, p_zmax, p_rmin, p_rmax, p_nz, p_nr, p_nt, n_e,\n zmin=zmin, initialize_ions=True,\n v_comoving=v_comoving, use_galilean=use_galilean,\n boundaries={'z':'periodic', 'r':'reflective'}, use_cuda=use_cuda )\n\n # Give a relativistic velocity to the particle, with some noise\n sim.ptcl[0].uz[:] = uz_m\n sim.ptcl[0].inv_gamma[:] = 1./np.sqrt( 1 + sim.ptcl[0].uz**2 )\n sim.ptcl[1].uz[:] = uz_m\n sim.ptcl[1].inv_gamma[:] = 1./np.sqrt( 1 + sim.ptcl[1].uz**2 )\n\n # Perform the simulation;\n # record the rms electric field every 50 timestep\n Er_rms = np.zeros(int(N_step/30)+1)\n t = np.zeros(int(N_step/30+1))\n Er_rms[0] = get_Er_rms(sim)\n t[0] += sim.time\n for i in range(int(N_step/30)):\n sim.step( 30, show_progress=False )\n print('Checkpoint %d' %i)\n Er_rms[i+1] = get_Er_rms(sim)\n t[i+1] += sim.time\n print('Calculated RMS')\n\n # Check/plot the results\n if show:\n import matplotlib.pyplot as plt\n # Add a plot\n plt.semilogy( t, Er_rms, '-', label=scheme )\n plt.ylabel('RMS(Er)')\n plt.xlabel('Time')\n else:\n # Registed the final value of the slope of the electric field\n slope_Erms[scheme] = np.log( Er_rms[-1] ) - np.log(Er_rms[-2] )\n\n if show:\n # Show the plot\n plt.legend(loc=0)\n plt.show()\n else:\n # Check that, in the standard case, the electric field is\n # growing much faster, due to the Cherenkov instability\n assert slope_Erms['standard'] > 3.5*slope_Erms['galilean']\n assert slope_Erms['standard'] > 3.5*slope_Erms['pseudo-galilean']"},"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 test_1_do_valid_sim(self) :\n self.banner(\"Testing if simulation gives the right percentages.\")\n filename = self.find_file('project9.py')\n self.assertIsNotNone(filename, \"I can't find your project file (project9.py)\")\n\n with open('logs/test_1_valid_sim.out', 'a') as log :\n test = pexpect.spawnu('python \"' + filename.as_posix() + '\"', logfile=log, encoding='utf-8')\n turns = random.randrange(100, 100000)\n test.sendline(str(turns))\n try : \n got = test.expect(['(\\d+\\.\\d+)\\s*%'], timeout=5)\n switch_percent = float(test.match.group(1))\n got = test.expect(['(\\d+\\.\\d+)\\s*%'], timeout=5)\n stay_percent = float(test.match.group(1))\n except :\n self.fail(\"The grader program failed to parse the output of your project.\")\n\n if not (64 < switch_percent < 68) :\n self.fail('Your switch percentage ({}) is out of range.'.format(switch_percent))\n if not (31 < stay_percent < 35) :\n self.fail('Your stay percentage ({}) is out of range.'.format(stay_percent))\n test.close()","def test_run_sim_1():\n rnd = rand.Arrivals(36, 41)\n sim.run_sim(3, 2, 5, 6, 22, rnd)","def run(): \n learning_rate = 0.42\n discount_rate = 0.15\n initial_q_hat = 4\n \n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent, learning_rate, discount_rate, initial_q_hat) # create agent\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\n\n # Now simulate it\n sim = Simulator(e, update_delay=0, display=False) # create simulator (uses pygame when display=True, if available)\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\n\n sim.run(n_trials=100) # run for a specified number of trials\n print \"Failed trials: \"\n print a.get_failed_trials()\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line","def test_single_game_works(self):\n sim = ss.Simulation(seed=154)\n game1 = sim.single_game()\n sim = ss.Simulation(seed=79)\n game2 = sim.single_game()\n assert game1 != game2, 'Your method single_game is not working.'","def testSimCompletes(self):\n sim = Simulation()\n self.assertEqual(25, sim.run_simple(1, 11, \"output\", 0.1, 2, 10))","def test_run_sim():\n rnd = rand.Arrivals(31, 40)\n sim.run_sim(2, 1, 3, 4, 24, rnd)","def test_simulation(self):\n\t\tprint \"Simulation is being tested\"\n\n\t\tif toggles.DEBUG_FLAG:\n\t\t\tprint \"Debug Flag Set!\"\n\t\t\tprint self.getConfig()\n\n\t\tif toggles.PACKING:\n\t\t\ttoggles.OUTPUT_PATH = toggles.OUTPUT_PATH+toggles.RUN_NAME+'/'\n\t\t\tpackageMaker(toggles.OUTPUT_PATH,self.getConfig())\n\t\tif toggles.IDEAL_GRID:\n\t\t\tself.consensusGrid()\n\n\t\tif toggles.REAL_DATA:\n\t\t\tsampleData = self.load_data()\n\t\t\tif toggles.RUN_DATA_STATS:\n\t\t\t\tself.output_data_stats(sampleData)\n\t\t\t\tself.reset_database()\n\t\t\tif toggles.RUN_AVERAGE_COST:\n\t\t\t\tself.sim_average_cost(sampleData)\n\t\t\t\tself.reset_database()\n\t\t\tif toggles.RUN_SINGLE_PAIR:\n\t\t\t\tself.sim_single_pair_cost(sampleData, pending_eddy(self.pick_worker([0], [0])))\n\t\t\t\tself.reset_database()\n\t\telse:\n\t\t\tsampleData = {}\n\t\t\tsyn_load_data()\n\n\t\tif toggles.RUN_ITEM_ROUTING and not (toggles.RUN_TASKS_COUNT or toggles.RUN_MULTI_ROUTING):\n\t\t\tif toggles.DEBUG_FLAG:\n\t\t\t\tprint \"Running: item Routing\"\n\t\t\tself.run_sim(deepcopy(sampleData))\n\t\t\tself.reset_database()\n\n\t\tif PRED_SCORE_COUNT and not (RUN_TASKS_COUNT or RUN_MULTI_ROUTING):\n\t\t\tif DEBUG_FLAG:\n\t\t\t\tprint \"Running: Pred Score count\"\n\t\t\tself.run_sim(sampleData)\n\t\t\tself.reset_database()\n\n\n\n\t\tif toggles.COUNT_TICKETS and not (toggles.RUN_TASKS_COUNT or toggles.RUN_MULTI_ROUTING):\n\t\t\tif toggles.DEBUG_FLAG:\n\t\t\t\tprint \"Running: ticket counting\"\n\t\t\tself.run_sim(deepcopy(sampleData))\n\t\t\tself.reset_database()\n\n\t\tif toggles.SELECTIVITY_GRAPH and not (toggles.RUN_TASKS_COUNT or toggles.RUN_MULTI_ROUTING):\n\t\t\tif toggles.DEBUG_FLAG:\n\t\t\t\tprint \"Running: selectivity amounts over time\"\n\t\t\tself.run_sim(sampleData)\n\t\t\tself.reset_database()\n\n\t\t#____FOR LOOKING AT ACCURACY OF RUNS___#\n\t\tif toggles.TEST_ACCURACY and toggles.REAL_DATA:\n\t\t\tcorrectAnswers = self.get_correct_answers(toggles.INPUT_PATH + toggles.ITEM_TYPE + '_correct_answers.csv')\n\t\t\tpassedItems = self.get_passed_items(correctAnswers)\n\n\n\t\tif toggles.RUN_OPTIMAL_SIM:\n\t\t\tcountingArr=[]\n\t\t\tself.reset_database()\n\t\t\tfor i in range(toggles.NUM_SIM):\n\t\t\t\tprint \"running optimal_sim \" +str(i)\n\t\t\t\tself.num_tasks = self.optimal_sim(sampleData)\n\t\t\t\tcountingArr.append(self.num_tasks)\n\t\t\t\tself.reset_database()\n\t\t\tdest = toggles.OUTPUT_PATH+toggles.RUN_NAME+'_optimal_tasks'\n\t\t\tgeneric_csv_write(dest+'.csv',[countingArr])\n\t\t\tif toggles.DEBUG_FLAG:\n\t\t\t\tprint \"Wrote File: \" + dest+'.csv'\n\n\n\n\t\tif toggles.RUN_TASKS_COUNT or toggles.RUN_MULTI_ROUTING or toggles.RUN_CONSENSUS_COUNT:\n\t\t\tif toggles.RUN_TASKS_COUNT:\n\t\t\t\t#print \"Running: task_count\"\n\t\t\t\t#f = open(toggles.OUTPUT_PATH + toggles.RUN_NAME + '_tasks_count.csv', 'a')\n\t\t\t\t#f1 = open(toggles.OUTPUT_PATH + toggles.RUN_NAME + '_incorrect_count.csv', 'a')\n\n\t\t\t\tif toggles.GEN_GRAPHS:\n\t\t\t\t\toutputArray = []\n\n\t\t\trunTasksArray = []\n\t\t\tgoodArray, badArray = [], []\n\t\t\tgoodPoints, badPoints = [], []\n\t\t\taccCount = []\n\t\t\tlocArray = [[],[],[],[]]\n\n\t\t\tfor i in range(toggles.NUM_SIM):\n\t\t\t\tprint \"running simulation \" + str(i+1)\n\t\t\t\tself.run_sim(deepcopy(sampleData))\n\t\t\t\trunTasksArray.append(self.num_tasks)\n\n\t\t\t\t#____FOR LOOKING AT ACCURACY OF RUNS___#\n\t\t\t\tif toggles.TEST_ACCURACY and toggles.REAL_DATA:\n\t\t\t\t\tnum_incorrect = self.final_item_mismatch(passedItems)\n\t\t\t\t\taccCount.append(num_incorrect)\n\t\t\t\tif toggles.RUN_CONSENSUS_COUNT or toggles.VOTE_GRID:\n\t\t\t\t\tdonePairs = IP_Pair.objects.filter(Q(num_no__gt=0)|Q(num_yes__gt=0))\n\t\t\t\t\tif toggles.TEST_ACCURACY:\n\t\t\t\t\t\tgoodPairs, badPairs = [], []\n\t\t\t\t\t\tfor pair in donePairs:\n\t\t\t\t\t\t\tval = bool((pair.num_yes-pair.num_no)>0)\n\t\t\t\t\t\t\tif toggles.REAL_DATA:\n\t\t\t\t\t\t\t\tcorrect = ((correctAnswers[(pair.item,pair.predicate)]) == val)\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tcorrect = (pair.true_answer == val)\n\t\t\t\t\t\t\tif correct:\n\t\t\t\t\t\t\t\tgoodArray.append(pair.num_no+pair.num_yes)\n\t\t\t\t\t\t\t\tgoodPoints.append((pair.num_no,pair.num_yes))\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tbadArray.append(pair.num_no+pair.num_yes)\n\t\t\t\t\t\t\t\tbadPoints.append((pair.num_no,pair.num_yes))\n\t\t\t\t\telse:\n\t\t\t\t\t\tfor pair in donePairs:\n\t\t\t\t\t\t\tgoodArray.append(pair.num_no + pair.num_yes)\n\t\t\t\t\t\t\tgoodPoints.append((pair.num_no,pair.num_yes))\n\n\t\t\t\t\t#print \"This is number of incorrect items: \", num_incorrect\n\n\t\t\t\tself.reset_database()\n\n\t\t\tif toggles.RUN_TASKS_COUNT:\n\t\t\t\tgeneric_csv_write(toggles.OUTPUT_PATH+toggles.RUN_NAME+'_tasks_count.csv',[runTasksArray])\n\t\t\t\tif toggles.DEBUG_FLAG:\n\t\t\t\t\tprint \"Wrote File: \" + toggles.OUTPUT_PATH + toggles.RUN_NAME + '_tasks_count.csv'\n\t\t\t\tif toggles.GEN_GRAPHS:\n\t\t\t\t\tif len(runTasksArray)>1:\n\t\t\t\t\t\tdest = toggles.OUTPUT_PATH + toggles.RUN_NAME + '_tasks_count.png'\n\t\t\t\t\t\ttitle = toggles.RUN_NAME + ' Cost distribution'\n\t\t\t\t\t\thist_gen(runTasksArray, dest, labels = ('Cost','Frequency'), title = title)\n\t\t\t\t\t\tif toggles.DEBUG_FLAG:\n\t\t\t\t\t\t\tprint \"Wrote File: \" + dest\n\t\t\t\t\telif toggles.DEBUG_FLAG:\n\t\t\t\t\t\tprint \"only ran one sim, not running hist_gen\"\n\n\t\t\tif toggles.RUN_MULTI_ROUTING:\n\t\t\t\t\tdest = toggles.OUTPUT_PATH + toggles.RUN_NAME + '_Eddy_sys_' + str(toggles.EDDY_SYS) + '_multi_routing.png'\n\t\t\t\t\ttitle = toggles.RUN_NAME + ' Average Predicate Routing'\n\t\t\t\t\tquestions = toggles.CHOSEN_PREDS\n\t\t\t\t\tarrayData = []\n\t\t\t\t\tfor i in range(len(questions)):\n\t\t\t\t\t\tarrayData.append([])\n\t\t\t\t\tfor routingL in ROUTING_ARRAY:\n\t\t\t\t\t\tfor i in range(len(questions)):\n\t\t\t\t\t\t\tarrayData[i].append(routingL[i])\n\t\t\t\t\tmrsavefile = open(toggles.OUTPUT_PATH+toggles.RUN_NAME+'_multi_routing.csv','w')\n\t\t\t\t\tmrwriter = csv.writer(mrsavefile)\n\t\t\t\t\tmrwriter.writerow(questions)\n\t\t\t\t\tfor row in arrayData:\n\t\t\t\t\t\tmrwriter.writerow(row)\n\t\t\t\t\tmrsavefile.close()\n\t\t\t\t\tif toggles.DEBUG_FLAG:\n\t\t\t\t\t\tprint \"Wrote File: \"+toggles.OUTPUT_PATH+toggles.RUN_NAME+'_multi_routing.csv'\n\t\t\t\t\tif toggles.GEN_GRAPHS:\n\t\t\t\t\t\tstats_bar_graph_gen(arrayData, questions, dest, labels = ('Predicate','# of Items Routed'), title = title)\n\t\t\t\t\t\tif toggles.DEBUG_FLAG:\n\t\t\t\t\t\t\tprint \"Wrote File: \" + toggles.OUTPUT_PATH+toggles.RUN_NAME+'_multi_routing.png'\n\t\t\tif toggles.ACCURACY_COUNT:\n\t\t\t\tdest = toggles.OUTPUT_PATH+toggles.RUN_NAME+'_acc_count'\n\t\t\t\tgeneric_csv_write(dest+'.csv',[accCount])\n\t\t\t\tif toggles.GEN_GRAPHS:\n\t\t\t\t\thist_gen(accCount, dest+'.png')\n\n\t\t\tif toggles.RUN_CONSENSUS_COUNT:\n\t\t\t\tdest = toggles.OUTPUT_PATH + toggles.RUN_NAME+'_consensus_count'\n\t\t\t\tif len(goodArray)>1:\n\t\t\t\t\tif len(badArray) == 0:\n\t\t\t\t\t\tgeneric_csv_write(dest+'.csv',[goodArray])\n\t\t\t\t\t\t#print goodArray\n\t\t\t\t\telse:\n\t\t\t\t\t\tgeneric_csv_write(dest+'.csv',[goodArray,badArray])\n\t\t\t\t\t\t#print goodArray,badArray\n\t\t\t\t\tif toggles.DEBUG_FLAG:\n\t\t\t\t\t\tprint \"Wrote File: \" + dest + '.csv'\n\t\t\t\t\tif toggles.GEN_GRAPHS:\n\t\t\t\t\t\ttitle = 'Normalized Distribution of Tasks before Consensus'\n\t\t\t\t\t\tlabels = ('Number of Tasks', 'Frequency')\n\t\t\t\t\t\tif len(badArray) < 2:\n\t\t\t\t\t\t\thist_gen(goodArray, dest+'.png',labels=labels,title=title)\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tleg = ('Correctly Evaluated IP pairs','Incorrectly Evaluated IP pairs')\n\t\t\t\t\t\t\tmulti_hist_gen([goodArray,badArray],leg,dest+'.png',labels=labels,title=title)\n\t\t\t\telif toggles.DEBUG_FLAG:\n\t\t\t\t\tprint \"only ran one sim, ignoring results\"\n\t\t\tif toggles.VOTE_GRID:\n\t\t\t\tdest = toggles.OUTPUT_PATH + toggles.RUN_NAME+'_vote_grid'\n\t\t\t\tif len(goodPoints)>1:\n\t\t\t\t\tif len(badPoints)==0:\n\t\t\t\t\t\tgeneric_csv_write(dest+'.csv',goodPoints)\n\t\t\t\t\telse:\n\t\t\t\t\t\tgeneric_csv_write(dest+'_good.csv',goodPoints)\n\t\t\t\t\t\tgeneric_csv_write(dest+'_bad.csv',badPoints)\n\t\t\t\t\tif toggles.GEN_GRAPHS:\n\t\t\t\t\t\ttitle = \"Vote Grid Graph\"\n\t\t\t\t\t\tlabels = (\"Number of No Votes\",\"Number of Yes Votes\")\n\t\t\t\t\t\tif len(badPoints)==0:\n\t\t\t\t\t\t\txL,yL=zip(*goodPoints)\n\t\t\t\t\t\t\tline_graph_gen(xL,yL,dest+'.png',title=title,labels=labels,scatter=True,square=True)\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tgX,gY = zip(*goodPoints)\n\t\t\t\t\t\t\tbX,bY = zip(*badPoints)\n\t\t\t\t\t\t\tmulti_line_graph_gen((gX,bX),(gY,bY),('Correct','Incorrect'),dest+'_both.png',title=title,labels=labels,scatter=True,square=True)\n\t\t\t\t\t\t\tline_graph_gen(gX,gY,dest+'_good.png',title=title+\" goodPoints\",labels=labels,scatter=True,square=True)\n\t\t\t\t\t\t\tline_graph_gen(bX,bY,dest+'_bad.png',title=title+\" badPoints\",labels=labels,scatter=True,square=True)\n\t\tif toggles.TIME_SIMS:\n\t\t\tself.timeRun(sampleData)\n\n\t\tif toggles.RUN_ABSTRACT_SIM:\n\t\t\tself.abstract_sim(sampleData, toggles.ABSTRACT_VARIABLE, toggles.ABSTRACT_VALUES)","def main():\n run_simulation(spectral=False, ml=False, num_procs=1)\n run_simulation(spectral=True, ml=False, num_procs=1)\n run_simulation(spectral=False, ml=True, num_procs=1)\n run_simulation(spectral=True, ml=True, num_procs=1)\n run_simulation(spectral=False, ml=True, num_procs=10)\n run_simulation(spectral=True, ml=True, num_procs=10)","def scenario3(sim):\n\n init_logging(logfile=None, debug=True)\n second = 1000.0\n duration = 10\n tau_m = 20 # ms\n cm = 1.0 # nF\n v_reset = -60\n cell_parameters = dict(\n tau_m=tau_m,\n cm=cm,\n v_rest=-70,\n e_rev_E=0,\n e_rev_I=-70,\n v_thresh=-54,\n v_reset=v_reset,\n tau_syn_E=5,\n tau_syn_I=5,\n )\n g_leak = cm / tau_m # µS\n\n w_min = 0.0 * g_leak\n w_max = 0.05 * g_leak\n\n r1 = 5.0\n r2 = 40.0\n\n sim.setup()\n pre = sim.Population(100, sim.SpikeSourcePoisson())\n post = sim.Population(10, sim.IF_cond_exp())\n\n pre.set(duration=duration * second)\n pre.set(start=0.0)\n pre[:50].set(rate=r1)\n pre[50:].set(rate=r2)\n assert_equal(pre[49].rate, r1)\n assert_equal(pre[50].rate, r2)\n post.set(**cell_parameters)\n post.initialize(v=RandomDistribution('normal', mu=v_reset, sigma=5.0))\n\n stdp = sim.STDPMechanism(\n sim.SpikePairRule(tau_plus=20.0, tau_minus=20.0,\n A_plus=0.01, A_minus=0.01),\n sim.AdditiveWeightDependence(w_min=w_min, w_max=w_max),\n #dendritic_delay_fraction=0.5))\n dendritic_delay_fraction=1)\n\n connections = sim.Projection(pre, post, sim.AllToAllConnector(),\n synapse_type=stdp,\n receptor_type='excitatory')\n\n initial_weight_distr = RandomDistribution('uniform', low=w_min, high=w_max)\n connections.randomizeWeights(initial_weight_distr)\n initial_weights = connections.get('weight', format='array', gather=False)\n # assert initial_weights.min() >= w_min\n # assert initial_weights.max() < w_max\n # assert initial_weights[0, 0] != initial_weights[1, 0]\n\n pre.record('spikes')\n post.record('spikes')\n post[0:1].record('v')\n\n sim.run(duration * second)\n\n actual_rate = pre.mean_spike_count() / duration\n expected_rate = (r1 + r2) / 2\n errmsg = \"actual rate: %g expected rate: %g\" % (actual_rate, expected_rate)\n assert abs(actual_rate - expected_rate) < 1, errmsg\n #assert abs(pre[:50].mean_spike_count()/duration - r1) < 1\n #assert abs(pre[50:].mean_spike_count()/duration- r2) < 1\n final_weights = connections.get('weight', format='array', gather=False)\n assert initial_weights[0, 0] != final_weights[0, 0]\n\n try:\n import scipy.stats\n except ImportError:\n raise SkipTest\n t, p = scipy.stats.ttest_ind(initial_weights[:50, :].flat, initial_weights[50:, :].flat)\n assert p > 0.05, p\n t, p = scipy.stats.ttest_ind(final_weights[:50, :].flat, final_weights[50:, :].flat)\n assert p < 0.01, p\n assert final_weights[:50, :].mean() < final_weights[50:, :].mean()\n sim.end()\n return initial_weights, final_weights, pre, post, connections","def Main():\n numberOfPopulation = 350\n numberOfDays = 60\n \n simulation = Simulation(Covid19(), numberOfPopulation, numberOfDays, \"Covid 19 Simulation\")\n simulation.run() \n simulation = Simulation(Ebola(), numberOfPopulation, numberOfDays, \"Ebola Simulation\")\n simulation.run()","def test_1_xc_run(self) :\n self.banner(\"Testing if extra credit simulation gives the right percentages.\")\n filename = self.find_file('project9_xc.py')\n doors = random.randrange(10, 100)\n switch_target = 100 * ((doors - 1) / doors)\n stay_target = 100 * (1 / doors)\n target_range = 2\n \n with open('logs/test_extra_credit.out', 'a') as log :\n test = pexpect.spawnu('python ' + filename.as_posix() + ' {}'.format(doors), logfile=log, encoding='utf-8')\n turns = random.randrange(200, 500)\n test.sendline(str(turns))\n try : \n got = test.expect([pexpect.EOF, '(\\d+\\.\\d+)\\s*%'], timeout=5)\n switch_percent = float(test.match.group(1))\n got = test.expect([pexpect.EOF, '(\\d+\\.\\d+)\\s*%'], timeout=5)\n stay_percent = float(test.match.group(1))\n except :\n self.fail(\"The grader program failed to parse the output of your project.\")\n\n if not (switch_target-target_range < switch_percent < switch_target+target_range) :\n self.fail('Your switch percentage ({}) is out of range. It should be between {} and {}'.format(switch_percent, switch_target-target_range, switch_target+target_range))\n if not (stay_target-target_range < stay_percent < stay_target+target_range) :\n self.fail('Your stay percentage ({}) is out of range. It should be between {} and {}'.format(stay_percent, stay_target-target_range, stay_target+target_range))\n test.close()","def run_tests():\n good_car = UnreliableCar(\"Good Car\", 100, 90)\n bad_car = UnreliableCar(\"Bad Car\", 100, 10)\n\n for i in range(1, 15):\n print(\"Attempting to drive {}km:\".format(i))\n print(\"{:12} drove {:2}km\".format(good_car.name, good_car.drive(i)))\n print(\"{:12} drove {:2}km\".format(bad_car.name, bad_car.drive(i)))\n\n \"\"\"final states of the cars\"\"\"\n print(good_car)\n print(bad_car)","def run():\n\n for simulation in range(0, N_SIMULATIONS):\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\n # TODO: Change later enforce_deadline=True\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.001, display=False) # create simulator (uses pygame when display=True, if available)\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\n\n sim.run(n_trials=N_TRIALS) # run for a specified number of trials\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\n\n if simulation == N_SIMULATIONS - 1:\n\n with open('results.csv', 'a') as csvfile:\n fieldnames = ['alpha', 'gamma', 'epsilon', 'success_rate', 'last_failure']\n writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\n\n for index in range(0,len(simulation_rates)):\n writer.writerow({\n 'alpha': get_simulation_params(0)[0],\n 'gamma': get_simulation_params(0)[1],\n 'epsilon': get_simulation_params(0)[2],\n 'success_rate': simulation_rates[index],\n 'last_failure': last_errors[index]})\n\n\n if N_SIMULATIONS > 1: #multiple simulation AND last simulation\n\n plt.figure(1)\n\n plt.subplot(211)\n plt.plot(simulation_rates)\n plt.title('Success Rate/Simulation')\n plt.xlabel('# Simulation')\n plt.ylabel('Success Rate')\n\n plt.subplot(212)\n plt.plot(last_errors)\n plt.title('Last failed trial per simulation')\n plt.xlabel('# Simulation')\n plt.ylabel('Last failed trial')\n\n plt.show()","def run():\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline=False) # specify agent to track\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.0000001, display=False) # create simulator (uses pygame when display=True, if available)\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\n\n sim.run(n_trials=100) # run for a specified number of trials\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\n\n print 'alpha, gamma:', a.alpha, a.gamma\n print 'penalties:', a.total_penalties\n print 'total rewards:', a.total_rewards","def main(m1=1.4, m2=0.3, r1=10, a0=100, eta=110, rel=\"off\",\n max_time=1, out1_path=out1_path_default, out2_path=out2_path_default):\n\n if not (rel in (\"on\", \"off\")):\n er(\"wrong rel\")\n\n if m1 < m2:\n er('m1 must be more than m2!')\n\n if eta > 200:\n er('error: eta must be less than 200!')\n\n if eta < 60:\n er(\"error: eta must be more than 60!\")\n\n if not (m2 > 0.1 and m2 < 0.8):\n er('error: m2 must be in (0.1, 0.8)!')\n\n if m2 < 0: \n er('error: m2 must be positive!')\n\n if m2 > 1: \n er('warning, mass of m1 is more than 1 M_sol so approximation of Sotani may be not valid!')\n \n if m1 > 2.3:\n print('Warning, m1 have a mass of BH!')\n\n \n with open(out1_path, 'w') as out1:\n with open(out2_path, 'w') as out2:\n res1, res2 = run(m1=m1, m2=m2, r1=r1, a0=a0, eta=eta, rel=rel, max_time=max_time)\n write_res(res1, out1)\n write_res(res2, out2)","def test_variability(self):\n # some reproducible arbitrariness\n np.random.seed(343143)\n\n n = 10\n t_max = 20.0\n dt = 0.1\n G = RandomLayer(n)\n\n M1 = simulation.EventMonitor(G)\n\n sim1 = simulation.Simulation(G, M1, dt=dt)\n sim1.run(t_max)\n \n M2 = simulation.EventMonitor(G)\n sim2 = simulation.Simulation(G, M2, dt=dt)\n sim2.run(t_max)\n\n self.assertNotEqual(len(M1.t), 0)\n self.assertNotEqual(len(M2.t), 0)\n self.assertNotEqual(M1.t, M2.t)","def simulationTwoDrugsDelayedTreatment():\n\n # TODO","def test_tuple_synapses(self):\n # reproducible arbitrariness\n np.random.seed(5003)\n\n self.conductor.out_step = np.random.randn(self.Nc)\n self.tutor.out_step = np.random.randn(self.Ns)\n\n self.rule.alpha = 1.0\n self.rule.beta = 1.5\n\n tmax = 10*self.dt\n\n W0 = np.copy(self.syns.W)\n\n sim1 = simulation.Simulation(self.conductor, self.student, self.tutor,\n self.syns, self.rule, dt=self.dt)\n sim1.run(tmax)\n\n final1 = np.copy(self.syns.W)\n\n self.syns.W = np.copy(W0)\n\n rule2 = SuperExponentialPlasticity(\n (self.syns.source, self.syns.target, self.syns.W),\n self.tutor, constrain_positive=False, rate=1-6)\n rule2.alpha = 1.0\n rule2.beta = 1.5\n\n sim2 = simulation.Simulation(self.conductor, self.student, self.tutor,\n self.syns, rule2, dt=self.dt)\n sim2.run(tmax)\n\n final2 = np.copy(self.syns.W)\n\n self.assertTrue(np.allclose(final1, final2))","def test_single_game_seed_works(self):\n sim = ss.Simulation(seed=23)\n game1 = sim.single_game()\n sim = ss.Simulation(seed=23)\n game2 = sim.single_game()\n assert game1 == game2, 'Your seed in Simulation class is not working.'","def test_run_simplega():\n WRFga_winner = run_simplega(pop_size=100, n_generations=1, testing=True)\n assert WRFga_winner.Fitness >= 0","def testSimpleErrorsTimeCompletion(self):\n sim = Simulation()\n with self.assertRaises(RuntimeError):\n sim.run_simple(30, 11, \"output\", 0.1, 2, 10)","def test_tuple_synapses(self):\n # reproducible arbitrariness\n np.random.seed(5003)\n\n self.conductor.out_step = np.random.randn(self.Nc)\n self.tutor.out_step = np.random.randn(self.Ns)\n\n self.rule.alpha = 1.0\n self.rule.beta = 1.5\n\n tmax = 10*self.dt\n\n W0 = np.copy(self.syns.W)\n\n sim1 = simulation.Simulation(self.conductor, self.student, self.tutor,\n self.syns, self.rule, dt=self.dt)\n sim1.run(tmax)\n\n final1 = np.copy(self.syns.W)\n\n self.syns.W = np.copy(W0)\n\n rule2 = TwoExponentialsPlasticity(\n (self.syns.source, self.syns.target, self.syns.W),\n self.tutor, constrain_positive=False, rate=1-6)\n rule2.alpha = 1.0\n rule2.beta = 1.5\n\n sim2 = simulation.Simulation(self.conductor, self.student, self.tutor,\n self.syns, rule2, dt=self.dt)\n sim2.run(tmax)\n\n final2 = np.copy(self.syns.W)\n\n self.assertTrue(np.allclose(final1, final2))","def run():\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.001, display=True) # create simulator (uses pygame when display=True, if available)\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\n\n sim.run(n_trials=100) # run for a specified number of trials\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line","def test_MasterEquation_simulateDynamicSloution(self,\n plot_figures=False,\n verbose=False,\n ):\n\n do_test_1 = True\n do_test_2 = True\n do_test_3 = True\n do_test_4 = True\n do_test_5 = True\n do_test_6 = True\n\n if do_test_1:\n print(\"Test 1 running\")\n ## test 1:\n\n # instanciate a MasterEquationSolver\n mes = HaPPPy.MasterEquation.MasterEquationSolver()\n # parameters of this tets:\n ε = mes.getε()\n δ = 1E-2\n a = 1 # > 0\n p0 = 0.1 # > 0\n p1 = 0.7 # > 0\n p2 = 0.2 # > 0, p0 + p1 + p2 = 1\n Δt = 1\n t_max = 100 # >= plot_stop, plot_start\n plot_start = 0\n plot_stop = 20\n plot_step = 1\n # set-up a reasonable Γ-matrix\n Γ_L = np.array([[0, a, 0], [0, 0, 0], [0, 0, 0]])\n Γ_R = np.array([[0, 0, 0], [0, 0, 0], [0, 0, 0]])\n ns = [1, 2]\n # choose a legitimate start value for P_0 (P_0 = P(t=0))\n P_0 = np.array([p0, p1, p2])\n # simulate\n sim_tdp, sim_cur = mes.simulateDynamicSloution(\n Δt, t_max, P_0, Γ_L, Γ_R, ns, verbose=verbose\n )\n stat_ps, stat_curs = mes.calculateStationarySolutions(\n Γ_L, Γ_R, ns, verbose=verbose\n )\n # plot result\n if plot_figures:\n sim_tdp.quickPlot(x_symbol=\"t\", y_symbol=\"P\",\n start=plot_start,\n stop=plot_stop,\n step=plot_step,\n )\n sim_cur.quickPlot(x_symbol=\"t\", y_symbol=\"I\",\n legend=[\"$I^L$\",\"$I^R$\"],\n start=plot_start,\n stop=plot_stop,\n step=plot_step,\n )\n # check validity\n self.assertTrue(sim_tdp.valid())\n self.assertTrue(sim_cur.valid())\n # check development of porpabilities\n Ps = sim_tdp.getValues()\n # a. check conservation of total probability\n for P in Ps:\n self.assertTrue(1 - ε <= sum(P) <= 1 + ε)\n # b. check values after a 'long' time period\n # expected: propability of state 1 'shifts' to state 2\n # state 3 is constant\n self.assertTrue(abs(Ps[t_max][0] - (p0 + p1)) <= δ)\n self.assertTrue(abs(Ps[t_max][1]) <= δ)\n self.assertTrue(abs(Ps[t_max][2] - p2) <= ε)\n print(\"Test 1 OK\")\n\n if do_test_2:\n print(\"Test 2 running\")\n ## test 2:\n\n # instanciate a MasterEquationSolver\n mes = HaPPPy.MasterEquation.MasterEquationSolver()\n # parameters of this tets:\n ε = mes.getε()\n δ = 1E-2\n f = 2.0 # fraction of P_1 to P_0 in equilibrium\n a = 0.5 # > 0\n p0 = 0.3 # > 0\n p1 = 0.7 # > 0, p0 + p1 = 1\n Δt = 1\n t_max = 100\n # set-up a reasonable Γ-matrix\n Γ_L = np.array([[0, a], [0, 0]])\n Γ_R = f * Γ_L.transpose()\n ns = [1, 1]\n # choose a legitimate start value for P_0 (P_0 = P(t=0))\n P_0 = np.array([p0, p1])\n # simulate\n sim_tdp, sim_cur = mes.simulateDynamicSloution(\n Δt, t_max, P_0, Γ_L, Γ_R, ns, verbose=verbose\n )\n stat_ps, stat_curs = mes.calculateStationarySolutions(\n Γ_L, Γ_R, ns, verbose=verbose\n )\n # plot result\n if plot_figures:\n sim_tdp.quickPlot(x_symbol=\"t\", y_symbol=\"P\",\n title=(\"P_stat = \" + str(stat_ps)),\n )\n sim_cur.quickPlot(x_symbol=\"t\", y_symbol=\"I\",\n title=(\"I_stat = \" + str(stat_curs)),\n legend=[\"$I^L$\",\"$I^R$\"],\n )\n # check validity\n self.assertTrue(sim_tdp.valid())\n self.assertTrue(sim_cur.valid())\n # check development of porpabilities\n Ps = sim_tdp.getValues()\n # a. check conservation of total probability\n for P in Ps:\n self.assertTrue(1 - ε <= sum(P) <= 1 + ε)\n # b. check values after a 'long' time period\n # expected: propability of state 1 'shifts' to state 2\n # state 3 is constant\n self.assertTrue(abs(f * Ps[t_max][0] - Ps[t_max][1]) <= δ)\n print(\"Test 2 OK\")\n\n if do_test_3:\n print(\"Test 3 running\")\n ## test 3:\n # symmetric Γ = Γ_L - Γ_R --> uniform distibution of propability\n\n # instanciate a MasterEquationSolver\n mes = HaPPPy.MasterEquation.MasterEquationSolver()\n # parameters of this tets:\n ε = mes.getε()\n Δt = 1\n t_max = 100\n n = 50\n # set-up a reasonable Γ-matrix\n Γ_L = np.array([[(i + j)/n**2 for j in range(n)] for i in range(n)])\n Γ_R = 2 * Γ_L\n ns = [1] * n\n # choose a legitimate start value for P_0 (P_0 = P(t=0))\n P_0 = np.array([i for i in range(n)])\n P_0 = P_0 / sum(P_0)\n # simulate\n sim_tdp, sim_cur = mes.simulateDynamicSloution(\n Δt, t_max, P_0, Γ_L, Γ_R, ns, verbose=verbose\n )\n stat_ps, stat_curs = mes.calculateStationarySolutions(\n Γ_L, Γ_R, ns, verbose=verbose\n )\n # plot result\n if plot_figures:\n sim_tdp.quickPlot(x_symbol=\"t\", y_symbol=\"P\")\n sim_cur.quickPlot(x_symbol=\"t\", y_symbol=\"I\",\n legend=[\"$I^L$\",\"$I^R$\"],\n )\n # check validity\n self.assertTrue(sim_tdp.valid())\n self.assertTrue(sim_cur.valid())\n # check development of porpabilities\n Ps = sim_tdp.getValues()\n # a. check conservation of total probability\n for P in Ps:\n self.assertTrue(1 - ε <= sum(P) <= 1 + ε)\n # b. check values after a 'long' time period\n # expected: uniform distribution\n for P_i in Ps[t_max]:\n self.assertTrue(1/n - ε <= P_i <= 1/n + ε)\n print(\"Test 3 OK\")\n\n if do_test_4:\n print(\"Test 4 running\")\n ## test 4:\n\n # instanciate a MasterEquationSolver\n mes = HaPPPy.MasterEquation.MasterEquationSolver()\n # parameters of this tets:\n ε = mes.getε()\n Δt = 1\n t_max = 10\n n = 3\n # set-up a reasonable Γ-matrix\n Γ_L = np.zeros((n, n))\n Γ_R = np.zeros((n, n))\n ns = [1] * n\n # choose a legitimate start value for P_0 (P_0 = P(t=0))\n P_0 = np.array([i for i in range(n)])\n P_0 = P_0 / sum(P_0)\n # simulate\n sim_tdp, sim_cur = mes.simulateDynamicSloution(\n Δt, t_max, P_0, Γ_L, Γ_R, ns, verbose=verbose\n )\n stat_ps, stat_curs = mes.calculateStationarySolutions(\n Γ_L, Γ_R, ns, verbose=verbose\n )\n # plot result\n if plot_figures:\n sim_tdp.quickPlot(x_symbol=\"t\", y_symbol=\"P\")\n sim_cur.quickPlot(x_symbol=\"t\", y_symbol=\"I\",\n legend=[\"$I^L$\",\"$I^R$\"],\n )\n # check validity\n self.assertTrue(sim_tdp.valid())\n self.assertTrue(sim_cur.valid())\n # check development of porpabilities\n Ps = sim_tdp.getValues()\n # a. check conservation of individual probabilities\n for P in Ps:\n self.assertTrue(-ε <= sum(abs(P - P_0)) <= ε)\n # check current\n Is = sim_cur.getValues()\n # a. check if current is constntly 0\n for I in Is:\n self.assertTrue((abs(I) <= ε).all())\n print(\"Test 4 OK\")\n\n if do_test_5:\n print(\"Test 5 running\")\n ## test 5:\n # test tolerance behaviour\n\n # parameters of this tets:\n ε = 1E-100 # ridiculously precise\n Δt = 1\n t_max = 100\n n = 10\n # set-up a reasonable Γ-matrix\n Γ_L = np.array([[(i + j)/n**2 for j in range(n)] for i in range(n)])\n Γ_R = 2 * Γ_L\n ns = [1] * n\n # choose a legitimate start value for P_0 (P_0 = P(t=0))\n P_0 = np.array([i for i in range(n)])\n P_0 = P_0 / sum(P_0)\n # instanciate a MasterEquationSolver\n mes = HaPPPy.MasterEquation.MasterEquationSolver(ε=ε)\n # simulate\n sim_tdp, sim_cur = mes.simulateDynamicSloution(\n Δt, t_max, P_0, Γ_L, Γ_R, ns, verbose=verbose\n )\n stat_ps, stat_curs = mes.calculateStationarySolutions(\n Γ_L, Γ_R, ns, verbose=verbose\n )\n # plot result\n if plot_figures:\n sim_tdp.quickPlot(x_symbol=\"t\", y_symbol=\"P\")\n sim_cur.quickPlot(x_symbol=\"t\", y_symbol=\"I\",\n legend=[\"$I^L$\",\"$I^R$\"],\n )\n # check validity\n self.assertTrue(not sim_tdp.valid())\n self.assertTrue(not sim_cur.valid())\n print(\"Test 5 OK\")\n\n if do_test_6:\n print(\"Test 6 running\")\n ## test 6:\n # test if algorith can handle large inputs\n # (like test 2 but with large n to test accuracy)\n\n # instanciate a MasterEquationSolver\n mes = HaPPPy.MasterEquation.MasterEquationSolver()\n # parameters of this tets:\n ε = mes.getε()\n Δt = 1\n t_max = 100\n n = 100\n # set-up a reasonable Γ-matrix\n Γ_L = np.array([[(i + j)/n**2 for j in range(n)] for i in range(n)])\n Γ_R = 2 * Γ_L\n ns = [1] * n\n # choose a legitimate start value for P_0 (P_0 = P(t=0))\n P_0 = np.array([i for i in range(n)])\n P_0 = P_0 / sum(P_0)\n # simulate\n sim_tdp, sim_cur = mes.simulateDynamicSloution(\n Δt, t_max, P_0, Γ_L, Γ_R, ns, verbose=verbose\n )\n stat_ps, stat_curs = mes.calculateStationarySolutions(\n Γ_L, Γ_R, ns, verbose=verbose\n )\n # check validity\n self.assertTrue(sim_tdp.valid())\n self.assertTrue(sim_cur.valid())\n # check development of porpabilities\n Ps = sim_tdp.getValues()\n # a. check conservation of total probability\n for P in Ps:\n self.assertTrue(1 - ε <= sum(P) <= 1 + ε)\n # b. check values after a 'long' time period\n # expected: uniform distribution\n for P_i in Ps[t_max]:\n self.assertTrue(1/n - ε <= P_i <= 1/n + ε)\n print(\"Test 6 OK\")","def run():\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.00000001, display=False) # create simulator (uses pygame when display=True, if available)\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\n\n sim.run(n_trials=100) # run for a specified number of trials\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line","def generate_scenario_1(seed=1996, permanent_save=True, sigma_process=0.01, sigma_meas_radar=3, sigma_meas_ais=1):\n # specify seed to be able repeat example\n start_time = datetime.now()\n\n np.random.seed(seed)\n\n # combine two 1-D CV models to create a 2-D CV model\n transition_model = CombinedLinearGaussianTransitionModel([ConstantVelocity(sigma_process),\n ConstantVelocity(sigma_process)])\n\n # starting at 0,0 and moving NE\n truth = GroundTruthPath([GroundTruthState([0, 1, 0, 1], timestamp=start_time)])\n\n # generate truth using transition_model and noise\n for k in range(1, 21):\n truth.append(GroundTruthState(\n transition_model.function(truth[k - 1], noise=True, time_interval=timedelta(seconds=1)),\n timestamp=start_time + timedelta(seconds=k)))\n\n # Simulate measurements\n # Specify measurement model for radar\n measurement_model_radar = LinearGaussian(\n ndim_state=4, # number of state dimensions\n mapping=(0, 2), # mapping measurement vector index to state index\n noise_covar=np.array([[sigma_meas_radar, 0], # covariance matrix for Gaussian PDF\n [0, sigma_meas_radar]])\n )\n\n # Specify measurement model for AIS\n measurement_model_ais = LinearGaussian(\n ndim_state=4,\n mapping=(0, 2),\n noise_covar=np.array([[sigma_meas_ais, 0],\n [0, sigma_meas_ais]])\n )\n\n # generate \"radar\" measurements\n measurements_radar = []\n for state in truth:\n measurement = measurement_model_radar.function(state, noise=True)\n measurements_radar.append(Detection(measurement, timestamp=state.timestamp))\n\n # generate \"AIS\" measurements\n measurements_ais = []\n state_num = 0\n for state in truth:\n state_num += 1\n if not state_num % 2: # measurement every second time step\n measurement = measurement_model_ais.function(state, noise=True)\n measurements_ais.append(Detection(measurement, timestamp=state.timestamp))\n\n if permanent_save:\n save_folder_name = seed.__str__()\n else:\n save_folder_name = \"temp\"\n\n save_folder = \"../scenarios/scenario1/\" + save_folder_name + \"/\"\n\n # save the ground truth and the measurements for the radar and the AIS\n store_object.store_object(truth, save_folder, \"ground_truth.pk1\")\n store_object.store_object(measurements_radar, save_folder, \"measurements_radar.pk1\")\n store_object.store_object(measurements_ais, save_folder, \"measurements_ais.pk1\")\n store_object.store_object(start_time, save_folder, \"start_time.pk1\")\n store_object.store_object(measurement_model_radar, save_folder, \"measurement_model_radar.pk1\")\n store_object.store_object(measurement_model_ais, save_folder, \"measurement_model_ais.pk1\")\n store_object.store_object(transition_model, save_folder, \"transition_model.pk1\")","def run():\n trials = 100\n\n multipliers = [0.25, 0.3, 0.35, 0.5, 0.75, 1, 1.25, 1.45, 1.5, 1.55, 1.6] # Coefficients for learning rate\n\n mean_penalty = []\n median_penalty = []\n std_penalty = []\n\n mean_trial_time = []\n median_trial_time = []\n std_trial_time = []\n\n mean_success_rate = []\n median_success_rate = []\n std_success_rate = []\n\n for m in multipliers:\n all_penalties = [] # All penalties from trail sets\n all_average_trial_time = []\n all_success_rates = []\n\n for i in range(0, 20):\n # print \"Trial set:\", i\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n agent = e.create_agent(LearnerAgent) # create agent\n agent.mult = m\n e.set_primary_agent(agent, enforce_deadline=True) # specify agent to track\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.0, display=False) # create simulator (uses pygame when display=True, if available)\n\n sim.run(n_trials=trials) # run for a specified number of trials\n\n all_penalties.append(agent.all_trails_penalties)\n all_average_trial_time.append(agent.time/float(trials))\n all_success_rates.append(float(trials-agent.aborted_trials)/trials)\n\n mean_penalty.append(np.mean(all_penalties))\n median_penalty.append(np.median(all_penalties))\n std_penalty.append(np.std(all_penalties))\n\n mean_trial_time.append(np.mean(all_average_trial_time))\n median_trial_time.append(np.median(all_average_trial_time))\n std_trial_time.append(np.std(all_average_trial_time))\n\n mean_success_rate.append(np.mean(all_success_rates))\n median_success_rate.append(np.median(all_success_rates))\n std_success_rate.append(np.std(all_success_rates))\n\n for i in range(0, len(multipliers)):\n print \"\"\n print \"Multiplier:\", multipliers[i]\n print \"\"\n print \"Mean penalty per {} trials:\".format(trials), mean_penalty[i]\n print \"Median penalty per {} trials:\".format(trials), median_penalty[i]\n print \"Std.Dev. penalty per {} trials:\".format(trials), std_penalty[i]\n\n print \"\"\n print \"Mean trial time:\", mean_trial_time[i]\n print \"Median trial time:\", median_trial_time[i]\n print \"Std.Dev. trial time:\", std_trial_time[i]\n\n print \"\"\n print \"Mean success rate per {} trials:\".format(trials), mean_success_rate[i]\n print \"Median success rate per {} trials:\".format(trials), median_success_rate[i]\n print \"Std.Dev. success rate per {} trials:\".format(trials), std_success_rate[i]","def test(simulation=False):\n\tsimulation = False\n\tif simulation:\n\t\tdyn.enable_vrep()\n\t\n\tctrl = init_ctrl()\n\n\tif simulation:\n\t\tpeter = SymbiotSpidey(ctrl)\n\telse:\n\t\tpeter = Spidey(ctrl)\n\n\tif simulation:\n\t\tctrl.start_sim()\n\n\tpeter.compliant = False\n\tprint peter.legs_references\n\n\tleg = peter.legs[0]\n\tpos = leg.position()\n\tpos = Vector3D(pos.x+6, pos.y, pos.z)\n\tleg.move(pos)\n\tctrl.wait(200)\n\tprint pos.x, leg.position().x, pos.x == leg.position().x\n\n\tpeter.compliant = True\n\n\tif simulation:\n\t\tctrl.stop_sim()","def run():\n step = 0\n while traci.simulation.getMinExpectedNumber() > 0:\n traci.simulationStep()\n step+=1\n traci.close()\n sys.stdout.flush()","def run():\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline=True) # set agent to track\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.5) # reduce update_delay to speed up simulation\n sim.run(n_trials=100) # press Esc or close pygame window to quit","def main():\n\tresults = []\n\n\tconfig = configparser.ConfigParser()\n\tconfig.read(\"simulation.ini\")\n\tsettings = config['sim']\n\n\tcompleted_obj_hw = int(settings[\"ClientsPerCampaign\"]) * float(settings[\"CompletedPctgHW\"])\n\texceeded_obj_hw = float(settings[\"ExceededPctgHW\"])\n\tsignificance_level = float(settings[\"SignificanceLevel\"])\n\tz_val_two_tails = scipy.stats.norm.ppf(1 - (significance_level / 2))\n\n\tprint(\"Completed Target HW: \" + str(completed_obj_hw))\n\tprint(\"Exceeded Target HW: \" + str(exceeded_obj_hw))\n\n\tcompleted_vals = []\n\texceeded_vals = []\n\tdone = False\n\n\tcompleted_avg = 0\n\texceeded_avg = 0\n\tcompleted_hw = 0\n\texceeded_hw = 0\n\n\ti = 0\n\twhile not done:\n\t\tprint(\"RUN: \" + str(i + 1))\n\t\tenv = simpy.Environment()\n\t\tsim = Simulation(env, settings, i == 0)\n\t\tsim.run()\n\t\tresults.append(sim.results)\n\t\ti += 1\n\n\t\tif settings['RunOnce'] == 'yes':\n\t\t\tprint(\"RUN ONCE\")\n\t\t\tsys.exit()\n\n\t\tcompleted_vals.append(sim.results['completed_count'])\n\t\texceeded_vals.append(sim.results['exceeded_proportion'])\n\n\t\tif i < 2:\n\t\t\tprint(\"---------------\")\n\t\t\tcontinue\n\n\t\tcompleted_avg = sum(completed_vals) / len(completed_vals)\n\t\tcompleted_S = sum([(v - completed_avg) ** 2 for v in completed_vals]) / (i - 1)\n\t\tcompleted_S = math.sqrt(completed_S)\n\t\tcompleted_hw = (z_val_two_tails * completed_S) / math.sqrt(i)\n\t\tprint(\"runs: \" + str(i) + \" completed HW: \" + str(completed_hw))\n\n\t\texceeded_avg = sum(exceeded_vals) / len(exceeded_vals)\n\t\texceeded_S = math.sqrt(exceeded_avg * (1 - exceeded_avg))\n\t\texceeded_hw = (z_val_two_tails * exceeded_S) / math.sqrt(i)\n\t\tprint(\"runs: \" + str(i) + \" exceeded HW: \" + str(exceeded_hw))\n\n\t\tif completed_hw < completed_obj_hw and exceeded_hw < exceeded_obj_hw:\n\t\t\tprint(\"END ITERATIONS\")\n\t\t\tdone = True\n\n\t\tprint(\"---------------\")\n\n\n\tfilename = 'results/Results_' + settings['FileSizeGB'] + '_' + settings['TorrentThreshold'] + '_' + settings['HTTPDownThreshold'] \\\n\t\t+ '_' + settings['HTTPUp'] + '_' + str(random.randint(0,10000)) + '.xlsx'\n\n\tprint(\"Saving XLSX to: \" + filename)\n\twb = xs.Workbook(filename)\n\n\tws = wb.add_worksheet()\n\n\tws.write(0, 1, 'Exceded')\n\tws.write(0, 2, 'Completed')\n\n\ti = 1\n\tfor result in results:\n\t\tws.write(i, 0, i)\n\t\tws.write(i, 1, result['exceeded_proportion'])\n\t\tws.write(i, 2, result['completed_count'])\n\t\ti += 1\n\n\tws.write(i, 0, 'average')\n\tws.write(i, 1, exceeded_avg)\n\tws.write(i, 2, completed_avg)\n\ti += 1\n\tws.write(i, 0, 'half width')\n\tws.write(i, 1, exceeded_hw)\n\tws.write(i, 2, completed_hw)\n\n\twb.close()","def run():\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline=False) # set agent to track\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.0) # reduce update_delay to speed up simulation\n sim.run(n_trials=num_of_experiments) # press Esc or close pygame window to quit\n \n pd.Series(a.success).to_pickle('success_' + exp_id + '.pickle')\n a.Q_table.to_pickle('qtable_' + exp_id + '.pickle')\n pd.Series(a.q_delta_avg).to_pickle('convergence_' + exp_id + '.pickle')\n pd.Series(a.t_total).to_pickle('steps_' + exp_id + '.pickle')","def run():\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline= True ) # set agent to track\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.5) # reduce update_delay to speed up simulation\n sim.run(n_trials=100) # press Esc or close pygame window to quit","def generate_scenario_2(seed=1996, permanent_save=True, sigma_process=0.01, sigma_meas_radar=3, sigma_meas_ais=1,\n timesteps=20):\n start_time = datetime.now()\n\n # specify seed to be able repeat example\n np.random.seed(seed)\n\n # combine two 1-D CV models to create a 2-D CV model\n transition_model = CombinedLinearGaussianTransitionModel(\n [ConstantVelocity(sigma_process), ConstantVelocity(sigma_process)])\n\n # starting at 0,0 and moving NE\n truth = GroundTruthPath([GroundTruthState([0, 1, 0, 1], timestamp=start_time)])\n\n # generate truth using transition_model and noise\n for k in range(1, timesteps):\n truth.append(GroundTruthState(\n transition_model.function(truth[k - 1], noise=True, time_interval=timedelta(seconds=1)),\n timestamp=start_time + timedelta(seconds=k)))\n\n # Simulate measurements\n # Specify measurement model for radar\n measurement_model_radar = LinearGaussian(\n ndim_state=4, # number of state dimensions\n mapping=(0, 2), # mapping measurement vector index to state index\n noise_covar=np.array([[sigma_meas_radar, 0], # covariance matrix for Gaussian PDF\n [0, sigma_meas_radar]])\n )\n\n # Specify measurement model for AIS (Same as for radar)\n measurement_model_ais = LinearGaussian(\n ndim_state=4,\n mapping=(0, 2),\n noise_covar=np.array([[sigma_meas_ais, 0],\n [0, sigma_meas_ais]])\n )\n\n # generate \"radar\" measurements\n measurements_radar = []\n for state in truth:\n measurement = measurement_model_radar.function(state, noise=True)\n measurements_radar.append(Detection(measurement, timestamp=state.timestamp))\n\n # generate \"AIS\" measurements\n measurements_ais = []\n for state in truth:\n measurement = measurement_model_ais.function(state, noise=True)\n measurements_ais.append(Detection(measurement, timestamp=state.timestamp))\n\n if permanent_save:\n save_folder_name = seed.__str__()\n else:\n save_folder_name = \"temp\"\n\n save_folder = \"../scenarios/scenario2/\" + save_folder_name + \"/\"\n\n # save the ground truth and the measurements for the radar and the AIS\n store_object.store_object(truth, save_folder, \"ground_truth.pk1\")\n store_object.store_object(measurements_radar, save_folder, \"measurements_radar.pk1\")\n store_object.store_object(measurements_ais, save_folder, \"measurements_ais.pk1\")\n store_object.store_object(start_time, save_folder, \"start_time.pk1\")\n store_object.store_object(measurement_model_radar, save_folder, \"measurement_model_radar.pk1\")\n store_object.store_object(measurement_model_ais, save_folder, \"measurement_model_ais.pk1\")\n store_object.store_object(transition_model, save_folder, \"transition_model.pk1\")","def run_tests():\n \n test_constructor_positive()\n test_constructor_negative()\n test_game_move_positive()\n test_game_move_negative()\n test_game_move_edge()\n print(\"Congratulations ! You passed all the game test cases.\")","def simulate(): \n \n # Create tmpdir to hold all steerfiles and log files \n SimObj = Simulation(steerfiles=steerfiles, name=os.path.splitext(os.path.basename(rawfile_alu))[0] + '-sim' )\n\n # Set Beam energy\n SimObj.set_beam_momentum(beamenergy)\n\n # Create steerfiles for processing\n simpath = create_sim_path_air(SimObj)\n\n # Get gearfile\n localgearfile = SimObj.get_filename('gear.xml')\n\n # Misalign gear file\n randomize_telescope(gearfile=localgearfile, mean_list=mean_list, sigma_list=sigma_list, sensorexception_list=sensorexception_list, modeexception_list=modeexception_list)\n\n localtruthdb_filename=SimObj.create_dbfilename(truthdb_filename)\n\n # Convert gear file to alignmentDB root file, which will be stored in the sim folder\n Create_AlignmentDBFile_From_Gear(gearfile=SimObj.get_filename('gear.xml'), truthdbfilename=localtruthdb_filename)\n\n # Copy gearfile\n SimObj.copy_file('gear.xml','gear_air.xml')\n\n # Get air gearfile\n gearfile_air = SimObj.get_filename('gear_air.xml')\n\n # Change DUT in copied gearfile\n set_parameter(gearfile=gearfile_air, sensorID=11, parametername='thickness', value=0.0001)\n set_parameter(gearfile=gearfile_air, sensorID=11, parametername='radLength', value=304000.0)\n\n\n # Create caltag for the truthdb\n localcaltag = os.path.splitext(os.path.basename(rawfile_air))[0] + '-test'\n simcaltag=localcaltag+ '-truthdb'\n\n # Run simulation to create rawfile with simulated digits \n SimObj.simulate(path=simpath,caltag=simcaltag)","def main():\n moons = initialize_moons()\n\n # Do it again, to get a stable initial set of values to compare against.\n initial_state = initialize_moons()\n needed_cycles = [0] * 3\n\n # Because in the mechanics of this fake universe gravity and velocity in\n # one dimension do not affect anything in the other two dimensions, we\n # can loop altering one dimension at a time until\n for dimension in (Position3d.X, Position3d.Y, Position3d.Z):\n Position3d.set_dimension(dimension)\n cycled = False\n cycle_count = 0\n while not cycled:\n if cycle_count > 30000000000:\n print(\"bailing!\")\n break\n cycle_count += 1\n for moon in moons:\n for other_moon in moons:\n if moon is other_moon:\n continue\n moon.apply_gravity(other_moon)\n for moon in moons:\n moon.apply_velocity()\n match = True\n for idx, moon in enumerate(moons):\n if moon != initial_state[idx]:\n # Didn't complete a cycle back to original state for this\n # dimension. Try again.\n match = False\n break\n if match:\n # Yea! Done with this dimension\n needed_cycles[dimension] = cycle_count\n cycled = True\n\n print(lcm(needed_cycles[2], lcm(needed_cycles[0], needed_cycles[1])),\n \"cycles needed to loop.\")\n print(\"Hawking would be proud.\")","def simulationTwoDrugsVirusPopulations():\n #TODO","def run_delayed_ssa(system):\n \n #vars used in the simulation\n time = 0 #unitless\n end_time = system['sim-time']\n species = system['participants']\n parameters = system['parameters']\n events = system['events']\n prop_funcs = {}\n exec_funcs = {}\n props = {}\n delays = {}\n last_exec_time = {}\n \n #return values\n time_array = []\n species_array = []\n \n #populate results array\n time_array = [time]\n row = [0]*len(species)\n species_names = [''] * len(species)\n \n #create species vars so that rate code can be executed\n i = 0\n for name in species:\n species_names[i] = name\n exec( name + '=' + str(species[name]) )\n row[i] = species[name]\n i += 1\n species_array.append(row)\n \n #create parameter vars so that rate code can be executed\n for name in parameters:\n exec( name + '=' + str(parameters[name]) )\n\n #create (compile) functions from input strings for rates and events\n for name in events:\n if events[name].get('delay'):\n delays[name] = events[name]['delay']\n else:\n delays[name] = 0.0\n last_exec_time[name] = -1\n props[name] = 0.0\n prop_funcs[name] = compile(\"props['\" + name + \"'] = \" + str(events[name]['propensity']), 'prop_funcs_'+name, 'exec')\n exec_funcs[name] = compile(events[name]['consequence'], 'exec_funcs_'+name, 'exec')\n \n #MAIN LOOP\n while time < end_time:\n \n #calculate propensities\n for name in props:\n exec(prop_funcs[name])\n if delays[name] > 0 and delays[name] + last_exec_time[name] < time:\n print(name)\n props[name] = 0.0\n \n #calculate total of all propensities\n total_prop = 0\n for name in props:\n total_prop += props[name]\n \n \n u = random.uniform(0,total_prop)\n usum = 0\n lucky = None\n for name in props:\n usum += props[name]\n if usum > u:\n lucky = name\n break\n\n #fire that reaction\n if lucky:\n last_exec_time[lucky] = time\n exec(exec_funcs[lucky])\n \n \n row = [0]*len(species)\n i = 0\n for name in species:\n row[i] = eval(name)\n i += 1\n time_array.append(time)\n species_array.append(row)\n \n #update next time using exp distrib\n if total_prop == 0.0: #jump to next delay\n lowest_delay = inf\n for name in props:\n if delays[name] > 0 and delays[name] < lowest_delay:\n lowest_delay = delays[name]\n time += lowest_delay\n else:\n dt = random.exponential(1.0/total_prop)\n time += dt\n\n #END MAIN LOOP\n\n result = {'time':time_array, 'participants':species_array, 'headers': species_names}\n return result","def testSanity(self):\n\t\tga = GA.GA(2,3)\n\t\tgenomes = ga.seedGenomes()\n\t\tself.assertEqual(len(genomes), 2, \n\t\t \"Wrong number of genomes\")\n\t\tself.assertEqual(len(genomes[0]), 3, \n\t\t \"Wrong size in genomes\")\n\t\t#print genomes\n\t\t#live and learn\n\t\tfitnesses = [23, 45]\n\t\tga.fitnessUpdate(fitnesses)\n\t\tgenomes2 = ga.createNextGeneration()\n\t\tself.assertEqual(len(genomes2), 2, \n \"Wrong number of genomes\")\n\t\tself.assertEqual(len(genomes2[0]), 3, \n \"Wrong size in genomes\")","def run():\n\n Number_repetitions = 1\n Rate = np.zeros((Number_repetitions,1))\n Rate20 = np.zeros((Number_repetitions,1))\n Penalty20 = np.zeros((Number_repetitions, 1))\n\n # Loop to average\n for idx in np.arange(0,Number_repetitions,1):\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.0000001, display=True) # create simulator (uses pygame when display=True, if available)\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\n\n sim.run(n_trials=100) # run for a specified number of trials\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\n\n # I've edited the enviroment variable to do the plot creating an completions array\n completions = np.array(e.completions)\n rate = float(completions.sum())/float((len(completions)))\n rate20 = float(completions[-20:].sum())/20\n\n Rate[idx] = rate\n Rate20[idx] = rate20\n\n Wrong = np.array(a.wrong_moves_per_run[-20:]).mean()\n Penalty20[idx] = Wrong\n\n plt.scatter(np.arange(0,len(completions)),completions)\n plt.plot(Wrong)\n plt.xlabel('Trial')\n plt.ylabel('1 = Get in the destination, 0 = did not get')\n plt.title('Reiforcement learning progress')\n plt.legend(['Rate of completion: ' + str(rate) + '. Rate last 20: ' + str(rate20) + '.Mean penalty last 20: ' + str(Wrong)])\n plt.show()\n\n #print 'Accuracy: ' + str(Rate) + '. Mean: ' + str(np.mean(Rate))\n #print 'Mean 20: ' + str(np.mean(Rate20))#'Accuracy 20: ' + str(Rate20) + '. Mean 20: ' + str(np.mean(Rate20))\n #print 'Mean_penalty: ' + str(np.mean(Penalty20))\n\n # Print state table with actions\n #t = 0\n #for state in a.states:\n #print 'State ' + str(state) + '. Best action: ' + str((str(np.argmax(a.QTable[t][:]))))\n #t += 1","def test_2nd_scenario():\n start_entered_scenario(config.MERAKI_CAMERAS[0][\"serial\"])\n return \"ok\"","def run_experiments():\r\n result = eval_strategy_range(always_roll, 1, 10)\r\n print('Best always_roll strategy:', result)\r\n\r\n if True: # Change to True when ready to test make_comeback_strategy\r\n result = eval_strategy_range(make_comeback_strategy, 5, 15)\r\n print('Best comeback strategy:', result)\r\n\r\n if True: # Change to True when ready to test make_mean_strategy\r\n result = eval_strategy_range(make_mean_strategy, 1, 10)\r\n print('Best mean strategy:', result)\r\n\r\n \"*** You may add additional experiments here if you wish ***\"","def run(self,step=2,\n sizePop=100,\n infoFields=['migrate_to','fitness'],\n recombination_rate = 0.00375,\n migration_rate = 0.01,\n mutation_rate = [0.00000001],\n subPopNames = ['x','y','z','w'],\n alleleNames = ['A','B'],\n s1 = 0.1,\n burnin=50,\n **kargs):\n\n self.reset()\n pop=sim.Population(size=[sizePop]*self.numPop, loci=self.loci, lociPos=list(range(self.dist, (self.dist*self.loci)+1,self.dist)), subPopNames=subPopNames, infoFields=infoFields)\n \n simu = sim.Simulator(pop)\n print(\"The simulation has started\")\n t1 = time.time()\n\n\n mutate_snps=range(0,50)+range(51,101)\n\n # define the initialization of each loci based the beta distribution where a and b parameters are allele frequencies from noncoding human regions\n snps=[0.14, 0.11, 0.17, 0.11, 0.32, 0.33, 0.21, 0.11, 0.11, 0.28, 0.11, 0.12, 0.8, 0.66, 0.74, 0.68, 0.66, 0.77, 0.77, 0.76, 0.77, 0.74, 0.72, 0.11, 0.73, 0.72, 0.72, 0.72, 0.54, 0.17, 0.78, 0.64, 0.78, 0.2, 0.24, 0.25, 0.78, 0.66, 0.2, 0.14, 0.75, 0.16, 0.72, 0.18, 0.77, 0.42, 0.34, 0.7, 0.17, 0.14, 0.2, 0.46, 0.13, 0.26, 0.16, 0.13, 0.14, 0.24, 0.18, 0.36, 0.71, 0.27, 0.28, 0.25, 0.25, 0.3, 0.19, 0.14, 0.16, 0.3, 0.39, 0.16, 0.24, 0.32, 0.11, 0.18, 0.48, 0.31, 0.21, 0.15, 0.34, 0.71, 0.33, 0.18, 0.71, 0.13, 0.23, 0.2, 0.22, 0.23, 0.16, 0.23, 0.23, 0.22, 0.24, 0.82, 0.36, 0.37, 0.72, 0.16, 0.14]\n self.initFreq=[]\n\n \n for i in range(len(snps)):\n alpha=float(4*sizePop*migration_rate*snps[i])\n bhta=float(4*sizePop*migration_rate*(1-snps[i])) \n p=numpy.random.beta(alpha,bhta)\n while (p>=0.9 or p<=0.1):\n p=numpy.random.beta(alpha,bhta)\n \n print \" SNP {snp} with alpha {alpha}, bhta {bhta} and frequency {p}\".format(snp=i, alpha=alpha, bhta=bhta, p=p)\n self.initFreq.append(p)\n\n simu.evolve(\n \n initOps=[sim.InitGenotype(freq=[self.initFreq[i], 1-self.initFreq[i]], loci=i) for i in range(len(snps))],\n \n\n # initialize the sex and select the 50 loci (parents)\n preOps = [sim.InitSex(maleProp=0.5,at=[0]),\n\n # initialize the genotype of locus 50 at generation 0 (in the beginning of the simulation)\n sim.PyOperator(self.genotypeBegin,at=[0]),\n \n # Wait 50 generations for the system to reach equilibrium\n # Then, change the the genotype of locus 50 at generation 50 by inserting a single copy of allele 0 in one individual \n sim.PyOperator(self.genotypeAfter,at=[50]),\n\n # function that carries out the selection proccess\n sim.MaSelector(loci=50,wildtype=0,fitness=[1+s1, 1+s1/2, 1],begin=50, end=-1,subPops=1)],\n\n # recombination\n matingScheme=sim.RandomMating(ops=[\n sim.Recombinator(rates=recombination_rate)]),\n \n # mutation and migration of offsprings\n postOps = [\n\n \n sim.SNPMutator(u=mutation_rate,loci=mutate_snps),\n \n # call function to calculate Fst and check for equilibrium state\n sim.PyOperator(self.calcFst,step=step),\n\n #migration\n # Here we define an island model, but this can easily be changed.\n # For more information about the migration models, please look in the documentation of SimuPOP here http://simupop.sourceforge.net/manual_svn/build/userGuide_ch7_sec3.html\n sim.Migrator(sim.utils.migrIslandRates(migration_rate,self.numPop)),\n \n # call function to save the allele frequencies\n sim.PyOperator(self.checkAlleles, step=step, param = subPopNames),\n \n \n # check if locus 50 is lost due to genetic drift. If yes, we terminate the simulation\n sim.Stat(alleleFreq=50,step=step,subPops=1,begin=50,end=-1),\n sim.TerminateIf('alleleFreq[50][0] == 0',step=step,begin=50,end=-1),\n \n # check the progress of the simulation\n sim.PyEval('\"Gen: %d\" % gen',step=step),\n sim.PyOutput('\\n',step=step),\n \n ],\n gen=self.Gen\n \n )\n \n \n t2 = time.time()\n print \"simulation took\", t2-t1, \"seconds.\"","def test_simulate(self, scml_system):\n\n # Reset the system and take a random action\n scml_system.reset()\n action = scml_system.action_space.sample()\n # Set a defined intitial state\n ode_state = np.array([3, 4, 5, 6])\n scml_system._ode_solver.set_initial_value(ode_state)\n # Perform the action on the system\n next_state = scml_system.simulate(action)\n solver_state_me = scml_system._ode_solver.y[:len(DummyLoad.state_names)]\n solver_state_el = scml_system._ode_solver.y[len(DummyLoad.state_names):]\n torque = [scml_system.electrical_motor.torque(solver_state_el)]\n u_sup = [scml_system.supply.u_nominal]\n u_in = [u * u_sup[0] for u in scml_system.converter.u_in]\n # Calculate the next state\n desired_next_state = (\n np.concatenate((solver_state_me, torque, solver_state_el, u_in, u_sup))\n ) / scml_system.limits\n\n # Assertions for correct simulation\n assert all(desired_next_state == next_state), 'The calculated next state differs from the expected one'\n assert scml_system.converter.action == action, 'The action was not passed correctly to the converter'\n assert scml_system.converter.action_set_time == 0, 'The action start time was passed incorrect to the converter'\n assert scml_system.converter.last_i_out == scml_system.electrical_motor.i_in(scml_system._ode_solver.last_y[2:])","def test(self):\n img_gen, self.loss_reg, self.parsav = self.net_G(self.input_P1, self.input_P2, self.input_BP1, self.input_BP2, self.input_SPL1, self.input_SPL2)\n ## test flow ##\n\n self.save_results(img_gen, data_name='vis')\n if self.opt.save_input or self.opt.phase == 'val':\n self.save_results(self.input_P1, data_name='ref')\n self.save_results(self.input_P2, data_name='gt')\n result = torch.cat([self.input_P1, img_gen, self.input_P2], 3)\n self.save_results(result, data_name='all')","def main(self) -> None:\n if LOG[\"Experiment\"]:\n print(\"[Experiment] Advancing to 1st Generation\")\n\n # Mandatory first generation advancement\n self.neat.advance_generation()\n\n # Metrics are initialized\n max_fitness = self.neat.get_best_fitness()\n max_fitnesses = [max_fitness]\n\n if LOG[\"Experiment\"]:\n print(\"[Experiment] Entering Main Loop\")\n\n # The main loop is entered\n stop = 0.0\n while max_fitness <= TARGET_SCORE:\n # Metrics of the last generation are checked and shared\n if LOG[\"Experiment\"]:\n print(\"\\n[Experiment] Generation = \" + str(self.neat.get_generation()))\n print(\"[Experiment] Maximum Fitness of the Generation = \" + str(max_fitness))\n print(\"[Experiment] Compared the Previous Recorded Maximum = \" + str(stop))\n print(\"[Experiment] Maximum Innovation of the Generation = \" + str(self.neat.get_maximum_innovation()))\n print(\"[Experiment] Amount of Species = \", len(self.neat.get_shared_fitness_sums()))\n print(\"[Experiment] Total Shared Fitness = \", self.neat.get_total_shared_fitness(), \"\\n\")\n\n # If an improvement is found, the game may be simulated\n if max_fitness > stop:\n stop = max_fitness\n if LOG[\"FrequentSimulations\"] and input(\"[Experiment] Show Simulation? (y/n)\\n\") == \"y\":\n n = self.neat.get_population()[-1]\n self.snake_game.show(Snake(11, Experiment.ExperimentAI(n)), self.last_used_seed,\n \"Generation = \" + str(self.neat.get_generation()),\n fps=max(4, int(max_fitness / 4)))\n\n # Generation advancement\n self.neat.advance_generation()\n max_fitness = self.neat.get_best_fitness()\n max_fitnesses.append(max_fitness)\n\n # If the target was passed, metrics are consulted\n if LOG[\"Experiment\"]:\n print(\"\\n[Experiment] Generation = \" + str(self.neat.get_generation()))\n print(\"[Experiment] Maximum Fitness of the Generation = \" + str(max_fitness))\n print(\"[Experiment] Compared to a 'stop' value of = \" + str(stop))\n print(\"[Experiment] Maximum Innovation of the Generation = \" + str(self.neat.get_maximum_innovation()))\n print(\"[Experiment] Shared fitness sums = \", self.neat.get_shared_fitness_sums())\n print(\"[Experiment] Total shared fitness = \", self.neat.get_total_shared_fitness(), \"\\n\")\n\n # Metrics are updated again\n max_fitness = self.neat.get_best_fitness()\n max_fitnesses.append(max_fitness)\n\n # A simulation of the result can be shown if the user wants to\n sim = input(\"[Experiment] Show Simulation? (y/n)\\n\")\n while sim == \"y\":\n n = self.neat.get_population()[-1]\n self.snake_game.show(Snake(11, Experiment.ExperimentAI(n)), self.last_used_seed,\n \"Generation = \" + str(self.neat.get_generation()),\n fps=max(4, int(max_fitness / 4)))\n sim = input(\"[Experiment] Show Simulation? (y/n)\\n\")\n\n # The resulting network may be printed\n if SHOW_RESULT:\n print(\"The best network generated is specified as:\\n\", str(self.neat.get_best_network_details()))\n\n # The resulting network may be saved\n if SAVE_RESULT:\n if LOG[\"Experiment\"]:\n print(\"[Experiment] Saving Resulting Network\")\n\n # Previous saves are removed\n dm.clear_dir(networks_saving_directory)\n\n # A .txt is generated\n with open(networks_saving_directory+\"/best_network.txt\", \"w\") as text_file:\n text_file.write(str(self.neat.get_best_network_details()))\n\n if LOG[\"Experiment\"]:\n print(\"[Experiment] Resulting Network Saved\")\n\n # A plot of fitnesses may be created\n if PLOT:\n if LOG[\"Experiment\"]:\n print(\"[Experiment] Generating Fitness Plot\")\n\n # The plot is generated in matplotlib\n _, ax = plt.subplots()\n\n ax.plot(range(1, len(max_fitnesses)+1), max_fitnesses)\n ax.set_xlim([0, len(max_fitnesses)+2])\n ax.set_ylim([max(min(min(max_fitnesses), TARGET_SCORE - 100), 0), TARGET_SCORE+5])\n\n plt.title(\"Generational fitness for board size \" + str(BOARD_SIZE) +\n \" using seed \" + str(SEED))\n plt.xlabel(\"Generation\")\n plt.ylabel(\"Fitness\")\n ax.grid(True)\n\n # The plot may be saved to memory\n if SAVE_PLOTS:\n if LOG[\"Experiment\"]:\n print(\"[Experiment] Saving Fitness Plot\")\n\n # Previous saves are removed\n dm.clear_dir(plots_saving_directory)\n\n name = plots_saving_directory + \"/plot_board\" + str(BOARD_SIZE)\n name += \".png\"\n\n # A new .png is saved\n plt.savefig(name, bbox_inches='tight')\n\n if LOG[\"Experiment\"]:\n print(\"[Experiment] Fitness Plot Saved\")\n # Otherwise the plot is displayed\n else:\n if LOG[\"Experiment\"]:\n print(\"[Experiment] Showing Fitness Plot\")\n\n plt.show()\n\n plt.close()\n\n if LOG[\"Experiment\"]:\n print(\"[Experiment] Quitting Experiment\")\n\n # The experiment ends\n self.snake_game.quit()","def test_no_jitter(self):\n n = 10\n t_max = 25\n dt = 0.1\n G = RateHVCLayer(n)\n G.burst_noise = 0.0\n\n M1 = simulation.StateMonitor(G, 'out')\n\n sim1 = simulation.Simulation(G, M1, dt=dt)\n sim1.run(t_max)\n \n M2 = simulation.StateMonitor(G, 'out')\n sim2 = simulation.Simulation(G, M2, dt=dt)\n sim2.run(t_max)\n\n self.assertTrue(np.allclose(M1.out, M2.out))","def test_SetMultipleMovingLoadsWithVelocityFunctionConfigurationPositive(self):\n\n # create nodes\n second_coord = [1, 0, 0.0]\n self.mp.CreateNewNode(1,0.0,0.0,0.0)\n self.mp.CreateNewNode(2,second_coord[0],second_coord[1],0.0)\n\n # create condition\n self.mp.CreateNewCondition(\"MovingLoadCondition2D2N\", 1, [1,2], self.mp.GetProperties()[1])\n\n parameters = self.base_parameters\n parameters[\"velocity\"]=KratosMultiphysics.Parameters(self.time_dependent_velocity)\n parameters.AddVector(\"configuration\", [0.5])\n\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0)\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.DELTA_TIME, 0.25)\n\n process = GMA.SetMultipleMovingLoadsProcess(self.mp, parameters)\n cond = self.cmp.GetCondition(2)\n\n # initialise and set load\n process.ExecuteInitialize()\n process.ExecuteInitializeSolutionStep()\n\n # initialise matrices\n lhs = KratosMultiphysics.Matrix(0, 0)\n rhs = KratosMultiphysics.Vector(0)\n\n # set load on node\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\n\n self.checkRHS(rhs, [0.0, -1.0, 0.0, -1.0])\n\n # change time and recalculate load\n process.ExecuteFinalizeSolutionStep()\n process.ExecuteInitializeSolutionStep()\n\n # check if interpolation is done correctly\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\n\n self.checkRHS(rhs, [0.0, -1.0, 0.0, -1.0])\n\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0.5)\n\n process.ExecuteFinalizeSolutionStep()\n process.ExecuteInitializeSolutionStep()\n\n # check if interpolation is done correctly\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\n\n self.checkRHS(rhs, [0.0, -0.5, 0.0, -1.5])","def test_simulationRun(self):\n self.opt = { 'temperature' : 300.0, 'friction' : 1, 'dt' : 0.00002,\n 'nIter' : 2, 'nstepsNC' : 2, 'nstepsMD' : 1, 'nprop' : 1,\n 'nonbondedMethod' : 'NoCutoff', 'constraints': 'HBonds',\n 'trajectory_interval' : 1, 'reporter_interval' : 1,\n 'outfname' : 'mc-test',\n 'platform' : None,\n 'constraints' : 'HBonds',\n 'mc_per_iter' : 2 }\n\n structure = self.full_struct\n class SetRotationMove(RandomLigandRotationMove):\n def __init__(self, structure, resname='LIG'):\n super(SetRotationMove, self).__init__(structure, resname)\n\n def move(self, context):\n \"\"\"Function that performs a random rotation about the\n center of mass of the ligand.\n \"\"\"\n #TODO: check if we need to deepcopy\n positions = context.getState(getPositions=True).getPositions(asNumpy=True)\n\n self.positions = positions[self.atom_indices]\n self.center_of_mass = self.getCenterOfMass(self.positions, self.masses)\n reduced_pos = self.positions - self.center_of_mass\n\n # Define random rotational move on the ligand\n #set rotation so that test is reproducible\n set_rotation_matrix = np.array([[-0.62297988, -0.17349253, 0.7627558 ],\n [ 0.55082352, -0.78964857, 0.27027502],\n [ 0.55541834, 0.58851973, 0.58749893]])\n\n\n #set_rotation_matrix = np.array([[1, 0, 0],\n # [0, 1, 0],\n # [0, 0, 1]])\n\n #multiply lig coordinates by rot matrix and add back COM translation from origin\n rot_move = np.dot(reduced_pos, set_rotation_matrix) * positions.unit + self.center_of_mass\n\n # Update ligand positions in nc_sim\n for index, atomidx in enumerate(self.atom_indices):\n positions[atomidx] = rot_move[index]\n context.setPositions(positions)\n positions = context.getState(getPositions=True).getPositions(asNumpy=True)\n self.positions = positions[self.atom_indices]\n return context\n\n\n self.model = SetRotationMove(structure, resname='ALA')\n #self.model = RandomLigandRotationMove(structure, resname='ALA')\n\n self.model.atom_indices = range(22)\n self.model.topology = structure[self.model.atom_indices].topology\n self.model.positions = structure[self.model.atom_indices].positions\n self.model.calculateProperties()\n\n self.mover = MoveEngine(self.model)\n #Initialize the SimulationFactory object\n sims = SimulationFactory(structure, self.mover, **self.opt)\n #print(sims)\n system = sims.generateSystem(structure, **self.opt)\n simdict = sims.createSimulationSet()\n alch_system = sims.generateAlchSystem(system, self.model.atom_indices)\n self.nc_sim = sims.generateSimFromStruct(structure, self.mover, alch_system, ncmc=True, **self.opt)\n self.model.calculateProperties()\n self.initial_positions = self.nc_sim.context.getState(getPositions=True).getPositions(asNumpy=True)\n mc_sim = Simulation(sims, self.mover, **self.opt)\n #monkeypatch to access acceptance value\n def nacceptRejectMC(self, temperature=300, **opt):\n \"\"\"Function that chooses to accept or reject the proposed move.\n \"\"\"\n md_state0 = self.current_state['md']['state0']\n md_state1 = self.current_state['md']['state1']\n log_mc = (md_state1['potential_energy'] - md_state0['potential_energy']) * (-1.0/self.nc_sim.context._integrator.kT)\n randnum = math.log(np.random.random())\n\n if log_mc > randnum:\n self.accept += 1\n print('MC MOVE ACCEPTED: log_mc {} > randnum {}'.format(log_mc, randnum) )\n self.md_sim.context.setPositions(md_state1['positions'])\n else:\n self.reject += 1\n print('MC MOVE REJECTED: log_mc {} < {}'.format(log_mc, randnum) )\n self.md_sim.context.setPositions(md_state0['positions'])\n self.log_mc = log_mc\n self.md_sim.context.setVelocitiesToTemperature(self.opt['temperature'])\n mc_sim.acceptRejectMC = nacceptRejectMC\n nacceptRejectMC.__get__(mc_sim)\n mc_sim.acceptRejectMC = types.MethodType(nacceptRejectMC, mc_sim)\n mc_sim.runMC(self.opt['nIter'])\n #get log acceptance\n print(mc_sim.log_mc)\n #if mc is working, should be around -24.1\n assert mc_sim.log_mc <= -23.8 and mc_sim.log_mc >= -24.3","def test_simulation():\n # Get the ambient profile data\n profile = get_profile()\n\n # Initialize a Model object\n sbm = single_bubble_model.Model(profile)\n\n # Set up the initial conditions\n composition = ['methane', 'ethane', 'propane', 'oxygen']\n bub = dbm.FluidParticle(composition)\n mol_frac = np.array([0.90, 0.07, 0.03, 0.0])\n de = 0.005\n z0 = 1000.\n T0 = 273.15 + 30.\n\n # Run the simulation\n sbm.simulate(bub, np.array([0., 0., z0]), de, mol_frac, T0, K_T=1,\n fdis=1e-8, delta_t=10.)\n \n # Check the solution\n assert sbm.y.shape[0] == 1117\n assert sbm.y.shape[1] == 8\n assert sbm.t.shape[0] == 1117\n assert_approx_equal(sbm.t[-20], 10826.039364358305, significant = 6)\n assert_array_almost_equal(sbm.y[-20,:], np.array([ 0.00000000e+00, \n 0.00000000e+00, 3.36954175e+02, 4.31708836e-14, 6.66317168e-15,\n 1.05065563e-11, 0.00000000e+00, 5.98799637e-06]), decimal = 6)\n \n # Write the output files\n sbm.save_sim(os.path.join(OUTPUT_DIR, 'sbm_data.nc'),\n './test_BM54.nc',\n 'Results of ./test_sbm.py script')\n\n sbm.save_txt(os.path.join(OUTPUT_DIR, 'sbm_data'),\n './test_BM54.nc',\n 'Results of ./test_sbm.py script')\n\n # Reload the simulation\n sbm_f = single_bubble_model.Model(simfile = os.path.join(OUTPUT_DIR,\n 'sbm_data.nc'))\n\n # Check that the attributes are loaded correctly\n assert sbm_f.y[0,0] == sbm.y[0,0] # x0\n assert sbm_f.y[0,1] == sbm.y[0,1] # y0\n assert sbm_f.y[0,2] == sbm.y[0,2] # z0\n\n assert_array_almost_equal(sbm_f.particle.m0, sbm.particle.m0, decimal = 6)\n assert sbm_f.particle.T0 == sbm.particle.T0\n print(sbm_f.particle.K_T, sbm.particle.K_T)\n assert sbm_f.particle.K == sbm.particle.K\n assert sbm_f.particle.K_T == sbm.particle.K_T\n assert sbm_f.particle.fdis == sbm.particle.fdis\n assert sbm_f.K_T0 == sbm.K_T0\n assert sbm_f.delta_t == sbm.delta_t\n (T, S, P) = profile.get_values(1000., ['temperature', 'salinity',\n 'pressure'])\n (Tp, Sp, Pp) = sbm_f.profile.get_values(1000., ['temperature', 'salinity',\n 'pressure'])\n assert Tp == T\n assert Sp == S\n assert Pp == P\n\n # Check that the results are still correct\n assert sbm.y.shape[0] == 1117\n assert sbm.y.shape[1] == 8\n assert sbm.t.shape[0] == 1117\n assert_approx_equal(sbm.t[-20], 10826.039364358305, significant = 6)\n assert_array_almost_equal(sbm.y[-20,:], np.array([ 0.00000000e+00, \n 0.00000000e+00, 3.36954175e+02, 4.31708836e-14, 6.66317168e-15,\n 1.05065563e-11, 0.00000000e+00, 5.98799637e-06]), decimal = 6)\n\n # Load the data in the txt file and check the solution\n data = np.loadtxt(os.path.join(OUTPUT_DIR, 'sbm_data.txt'))\n assert sbm.y.shape[0] == 1117\n assert sbm.y.shape[1] == 8\n assert sbm.t.shape[0] == 1117\n assert_approx_equal(sbm.t[-20], 10826.039364358305, significant = 6)\n assert_array_almost_equal(sbm.y[-20,:], np.array([ 0.00000000e+00, \n 0.00000000e+00, 3.36954175e+02, 4.31708836e-14, 6.66317168e-15,\n 1.05065563e-11, 0.00000000e+00, 5.98799637e-06]), decimal = 6)\n\n # Create an inert particle that is compressible\n oil = dbm.InsolubleParticle(True, True, rho_p=840.)\n mol_frac = np.array([1.])\n\n # Specify the remaining particle initial conditions\n de = 0.03\n z0 = 1000.\n T0 = 273.15 + 30.\n\n # Simulate the trajectory through the water column and plot the results\n sbm.simulate(oil, np.array([0., 0., z0]), de, mol_frac, T0, K_T=1,\n delta_t=10.)\n ans = np.array([00.00000000e+00, 0.00000000e+00, 1.16067764e-01, \n 1.26136097e-02, 7.57374681e+03])\n for i in range(5):\n assert_approx_equal(sbm.y[-1,i], ans[i], significant = 6)","def test_run():\n argv = [\"py.test\", \"100\", \"-potential\", \"potentials/bump.cfg\"]\n args = get_sargs(argv)\n from basis.basis_solve import run\n assert run(args) == 0","def test_compare_genomes_2(self):\n self.pmr_gnm.annotation_status = \"final\"\n self.pmr_gnm.name = \"Trixie\"\n import_genome.compare_genomes(self.genome_pair, self.eval_flags)\n count = count_status(self.genome_pair, \"error\", \"warning\")\n with self.subTest():\n self.assertEqual(len(self.genome_pair.evaluations), 13)\n with self.subTest():\n self.assertEqual(count, 0)","def run(sim_attr_generator):\n#TODO: clean\n#TODO: integrate analyses\n def analyze_and_save(simulation,simulation_attributes):\n#? Ugly conf file analyses integration.\n if simulation_attributes.analyses and Args.output_file != None:\n verbose_print(\"Saving analyses for {0}.\".format(simulation_attributes.id_name),2)\n results = analyze_datas(\n simulation.result,\n simulation_attributes.analyses\n )\n plotables = ana_results_to_plotables(\n results,\n simulation_attributes.analyses\n )\n#TODO error handling for save\n analysis_save_dm(\n results,\n plotables,\n simulation_attributes.analyses,\n simulation_attributes.id_name\n )\n\n def save_simulation(simulation,simulation_attributes):\n if not simulation_attributes.analyses and Args.output_file != None:\n verbose_print(\"Saving simulation datas of {0}.\".format(\n simulation_attributes.id_name\n ),2) \n try:\n np.save(\n simulation_attributes.id_name,\n simulation.result\n )\n except:\n raise EnvironmentError(\"Can't save data to {}.\".format(\n simulation_attributes.id_name\n ))\n\n verbose_print(\"Starting simulation run.\",1)\n for i,simulation_attributes in enumerate(sim_attr_generator):\n verbose_print(\"Starting simulation number {0}: {1}\".format(\n i,\n simulation_attributes.id_name\n ),2)\n simulation = Simulation(\n SimulationVariables(simulation_attributes)\n )\n simulation.start()\n save_simulation(simulation,simulation_attributes)\n analyze_and_save(simulation,simulation_attributes)","def run():\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create learning agent\n # a = e.create_agent(RandomAgent) # create random agent\n e.set_primary_agent(a, enforce_deadline=True) # set agent to track\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.01)\n # reduce update_delay to speed up simulation\n sys.stdout = open(\"./output.txt\", \"w\")\n tic = time()\n sim.run(n_trials=100) # press Esc or close pygame window to quit\n toc = time()\n sys.stdout = sys.__stdout__\n\n print \"Totoal time used: {}.\".format(toc - tic)\n parse(\"./output.txt\")","def run_scenario(self):\n self.initialize_random_map()\n self.visualize_environment('initial')\n self.get_tower_target_coverages()\n self.solve_environment()\n self.visualize_environment('solved')","def run():\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline=True) # set agent to track\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.01) # reduce update_delay to speed up simulation\n sim.run(n_trials=100) # press Esc or close pygame window to quit\n return [a.state_action_table, a.reward_hist]","def test_ns_ok2():\n env = NsSimPyEnvironment()\n env.process(some_process(env, env.to_time('10.1')))\n env.run()\n env.process(some_process(env, env.to_time('0.9')))\n env.run()\n assert env.now == 11","def test_evolution(self):\n class Mock(object):\n def __init__(self):\n self.t = 0.0\n\n def evolve(self1, t, dt):\n self.assertEqual(self1.t, t)\n self1.t += dt\n\n G1 = Mock()\n G2 = Mock()\n sim = simulation.Simulation(G1, G2)\n sim.run(100.0)\n\n self.assertAlmostEqual(G1.t, 100.0)","def scenario():\n LOCAL_HOST = \"http://127.0.0.1\"\n\n # import functions\n from . import genesis_block\n from . import create_block\n from . import connect_peer\n from . import stop_server\n from . import block_crosscheck\n\n total_cnt = 0\n pass_cnt = 0\n\n # 1. Check each peer's genesis block\n try:\n assert genesis_block.check(LOCAL_HOST, 3001)\n assert genesis_block.check(LOCAL_HOST, 3002)\n assert genesis_block.check(LOCAL_HOST, 3003)\n\n print(\"pass\", end=' ')\n pass_cnt += 1\n\n except:\n print(\"FAIL\", end=' ')\n\n finally:\n print(\"test1/genesis_block\")\n total_cnt += 1\n\n # 2. Generate new blocks\n # 2.1. 2 blocks on peer #1\n # 2.2. 4 blocks on peer #2\n # 2.3. 2 blocks on peer #3\n try:\n assert create_block.addBlocks(LOCAL_HOST, 3001, num=2)\n assert create_block.check(LOCAL_HOST, 3001, num=2)\n\n assert create_block.addBlocks(LOCAL_HOST, 3002, num=4)\n assert create_block.check(LOCAL_HOST, 3002, num=4)\n\n assert create_block.addBlocks(LOCAL_HOST, 3003, num=2)\n assert create_block.check(LOCAL_HOST, 3003, num=2)\n\n print(\"pass\", end=' ')\n pass_cnt += 1\n\n except:\n print(\"FAIL\", end=' ')\n\n finally:\n print(\"test1/create_block\")\n total_cnt += 1\n\n # 3. Connect peers\n # 3.1. peer #1 with #2 (1->2)\n # 3.2. peer #1 with #3 (1->(2 and 3))\n try:\n assert connect_peer.connectPeer(LOCAL_HOST, 3001, \"ws://127.0.0.1:6002\")\n assert connect_peer.connectPeer(LOCAL_HOST, 3001, \"ws://127.0.0.1:6003\")\n\n print(\"pass\", end=' ')\n pass_cnt += 1\n\n except:\n print(\"FAIL\", end=' ')\n\n finally:\n print(\"test1/connect_peer\")\n total_cnt += 1\n\n # 4. Generate new blocks\n # 4.1. 3 blocks on peer #1\n # 4.2. 5 blocks on peer #3\n try:\n isPass, newBlocks = block_crosscheck.addBlocks(LOCAL_HOST, 3001, num=3)\n assert isPass\n assert block_crosscheck.check(LOCAL_HOST, 3002, newBlocks, num=3)\n assert block_crosscheck.check(LOCAL_HOST, 3003, newBlocks, num=3)\n\n isPass, newBlocks = block_crosscheck.addBlocks(LOCAL_HOST, 3003, num=5)\n assert isPass\n assert block_crosscheck.check(LOCAL_HOST, 3001, newBlocks, num=5)\n assert block_crosscheck.check(LOCAL_HOST, 3002, newBlocks, num=5)\n\n print(\"pass\", end=' ')\n pass_cnt += 1\n\n except:\n print(\"FAIL\", end=' ')\n\n finally:\n print(\"test1/block_crosscheck\")\n total_cnt += 1\n\n # 5. Stop all peers\n try:\n assert stop_server.stopServer(LOCAL_HOST, 3001)\n assert stop_server.stopServer(LOCAL_HOST, 3002)\n assert stop_server.stopServer(LOCAL_HOST, 3003)\n\n print(\"pass\", end=' ')\n pass_cnt += 1\n\n except:\n print(\"FAIL\", end=' ')\n\n finally:\n print(\"test1/stop_server\")\n total_cnt += 1\n\n # return pass_cnt_per_test and total_cnt_per_test\n return pass_cnt, total_cnt","def compare(numberOfSimulations, initialValue, sigma, T, strike, r = 0):\n \n numberOfTests = 100\n \n \n #the two lists that will contain our average errors for the different tests\n errorsStandardMonteCarlo = []\n errorsMonteCarloWithAV = []\n \n #our benchmark: the analytic price of the call option\n analyticPriceBS = blackScholesPriceCall(initialValue, r, sigma, T, initialValue)\n\n #look at how lambda functions are defined in Python \n payoff = lambda x : max(x - initialValue, 0)\n \n #alternatively:\n #def payoff(x):\n # return max(x - initialValue, 0)\n \n #note how to construct an object of a class\n \n blackScholesGenerator = GenerateBlackScholes(numberOfSimulations, T, initialValue, sigma, r)\n #k=0,..,numberOfTests - 1\n for k in range(numberOfTests):\n \n \n\n #first, the valuation with the standard Monte-Carlo:\n realizationsOfTheProcessWithStandardMC = blackScholesGenerator.generateRealizations()\n \n priceCalculatorWithStandardMC = SimpleEuropeanOption(realizationsOfTheProcessWithStandardMC, r)\n priceStandardMC = priceCalculatorWithStandardMC.getPrice(payoff, T) \n errorWithStandardMC= abs(priceStandardMC - analyticPriceBS)/analyticPriceBS\n #note how to append new values to a list\n errorsStandardMonteCarlo.append(errorWithStandardMC)\n \n #then, the one with Antithetic Variables:\n realizationsOfTheProcessWithAV = blackScholesGenerator.generateRealizationsAntitheticVariables()\n \n priceCalculatorWithAV = SimpleEuropeanOption(realizationsOfTheProcessWithAV, r)\n priceWithAV = priceCalculatorWithAV.getPrice(payoff, T) \n errorWithAV= abs(priceWithAV - analyticPriceBS)/analyticPriceBS\n #note how to append new values to a list\n errorsMonteCarloWithAV.append(errorWithAV)\n\n #we get and return the respective average errors: mean is imported from\n #statistics\n averageErrorStandardMC = mean(errorsStandardMonteCarlo)\n #you can also use numpy\n averageErrorAV = np.mean(errorsMonteCarloWithAV)\n \n return averageErrorStandardMC, averageErrorAV","def test_grovers_default_basis_gates(self):\n shots = 2000\n circuits = ref_algorithms.grovers_circuit(final_measure=True,\n allow_sampling=True)\n targets = ref_algorithms.grovers_counts(shots)\n job = execute(circuits, QasmSimulator(), shots=shots)\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)","def test_SetMultipleMovingLoadsWithVelocityFunction(self):\n\n # create nodes\n second_coord = [1, 0, 0.0]\n self.mp.CreateNewNode(1, 0.0, 0.0, 0.0)\n self.mp.CreateNewNode(2, second_coord[0], second_coord[1], 0.0)\n\n # create condition\n self.mp.CreateNewCondition(\"MovingLoadCondition2D2N\", 1, [1,2], self.mp.GetProperties()[1])\n\n parameters = self.base_parameters\n parameters[\"velocity\"]=KratosMultiphysics.Parameters(self.time_dependent_velocity)\n\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0)\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.DELTA_TIME, 0.25)\n\n process = GMA.SetMultipleMovingLoadsProcess(self.mp, parameters)\n cond = self.cmp.GetCondition(2)\n\n # initialise and set load\n process.ExecuteInitialize()\n process.ExecuteInitializeSolutionStep()\n\n # initialise matrices\n lhs = KratosMultiphysics.Matrix(0, 0)\n rhs = KratosMultiphysics.Vector(0)\n\n # set load on node\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\n\n self.checkRHS(rhs, [0.0, -2.0, 0.0, 0.0])\n\n # change time and recalculate load\n process.ExecuteFinalizeSolutionStep()\n process.ExecuteInitializeSolutionStep()\n\n # check if interpolation is done correctly\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\n\n self.checkRHS(rhs, [0.0, -2.0, 0.0, 0.0])\n\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0.5)\n\n process.ExecuteFinalizeSolutionStep()\n process.ExecuteInitializeSolutionStep()\n\n # check if interpolation is done correctly\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\n\n self.checkRHS(rhs, [0.0, -1.5, 0.0, -0.5])","def run(self, steps):\n if not self.skip_reference:\n self.reference_sim.run(steps)\n self.compare_sim.run(steps)","def test_run_jackknifed_beta_diversity(self):\r\n\r\n run_jackknifed_beta_diversity(\r\n self.test_data['biom'][0],\r\n self.test_data['tree'][0],\r\n 20,\r\n self.test_out,\r\n call_commands_serially,\r\n self.params,\r\n self.qiime_config,\r\n self.test_data['map'][0],\r\n parallel=False,\r\n status_update_callback=no_status_updates)\r\n\r\n weighted_unifrac_upgma_tree_fp = join(self.test_out,\r\n 'weighted_unifrac',\r\n 'upgma_cmp', 'jackknife_named_nodes.tre')\r\n unweighted_unifrac_upgma_tree_fp = join(\r\n self.test_out, 'unweighted_unifrac', 'upgma_cmp',\r\n 'jackknife_named_nodes.tre')\r\n weighted_unifrac_emperor_index_fp = join(\r\n self.test_out, 'weighted_unifrac', 'emperor_pcoa_plots',\r\n 'index.html')\r\n unweighted_unifrac_emperor_index_fp = join(\r\n self.test_out, 'unweighted_unifrac', 'emperor_pcoa_plots',\r\n 'index.html')\r\n\r\n input_file_basename = splitext(split(self.test_data['biom'][0])[1])[0]\r\n unweighted_unifrac_dm_fp = join(self.test_out,\r\n 'unweighted_unifrac_%s.txt' % input_file_basename)\r\n weighted_unifrac_dm_fp = join(self.test_out,\r\n 'weighted_unifrac_%s.txt' % input_file_basename)\r\n\r\n # check for expected relations between values in the unweighted unifrac\r\n # distance matrix\r\n dm = parse_distmat_to_dict(open(unweighted_unifrac_dm_fp))\r\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\r\n \"Distance between pair of fecal samples is larger than distance\"\r\n \" between fecal and palm sample (unweighted unifrac).\")\r\n self.assertEqual(dm['f1']['f1'], 0)\r\n # check for expected relations between values in the weighted unifrac\r\n # distance matrix\r\n dm = parse_distmat_to_dict(open(weighted_unifrac_dm_fp))\r\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\r\n \"Distance between pair of fecal samples is larger than distance\"\r\n \" between fecal and palm sample (unweighted unifrac).\")\r\n self.assertEqual(dm['f1']['f1'], 0)\r\n\r\n # check that final output files have non-zero size\r\n self.assertTrue(getsize(weighted_unifrac_upgma_tree_fp) > 0)\r\n self.assertTrue(getsize(unweighted_unifrac_upgma_tree_fp) > 0)\r\n self.assertTrue(getsize(weighted_unifrac_emperor_index_fp) > 0)\r\n self.assertTrue(getsize(unweighted_unifrac_emperor_index_fp) > 0)\r\n\r\n # Check that the log file is created and has size > 0\r\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\r\n self.assertTrue(getsize(log_fp) > 0)","def test_basic_usecases():\n net = create_test_net()\n eq_types = [\"rei\", \"ward\", \"xward\"]\n for eq_type in eq_types:\n net1, net2, net3 = run_basic_usecases(eq_type)\n\n if eq_type == \"rei\":\n check_elements_amount(net1, {\"bus\": 5, \"load\": 3, \"sgen\": 2, \"shunt\": 3, \"ext_grid\": 1,\n \"line\": 3, \"impedance\": 3}, check_all_pp_elements=True)\n check_res_bus(net, net1)\n assert np.allclose(net1.bus.min_vm_pu.values,\n np.array([0.9, 0.91, np.nan, np.nan, 0.93]), equal_nan=True)\n check_elements_amount(net2, {\"bus\": 3, \"load\": 3, \"sgen\": 0, \"shunt\": 3, \"ext_grid\": 0,\n \"line\": 0, \"impedance\": 3}, check_all_pp_elements=True)\n check_res_bus(net, net2)\n assert np.allclose(net2.bus.min_vm_pu.values,\n net.bus.min_vm_pu.loc[[2, 4, 3]].values, equal_nan=True)\n check_elements_amount(net3, {\"bus\": 5, \"load\": 3, \"sgen\": 2, \"shunt\": 3, \"ext_grid\": 1,\n \"line\": 3, \"impedance\": 3}, check_all_pp_elements=True)\n check_res_bus(net, net3)\n assert np.allclose(net1.bus.min_vm_pu.values,\n np.array([0.9, 0.91, np.nan, np.nan, 0.93]), equal_nan=True)\n\n elif \"ward\" in eq_type:\n check_elements_amount(net1, {\"bus\": 4, \"load\": 2, \"sgen\": 2, \"ext_grid\": 1, \"line\": 3,\n eq_type: 2, \"impedance\": 1}, check_all_pp_elements=True)\n check_res_bus(net, net1)\n check_elements_amount(net2, {\"bus\": 2, \"load\": 2, \"sgen\": 0, \"ext_grid\": 0, \"line\": 0,\n eq_type: 2, \"impedance\": 1}, check_all_pp_elements=True)\n check_res_bus(net, net2)\n check_elements_amount(net3, {\"bus\": 4, \"load\": 2, \"sgen\": 2, \"ext_grid\": 1, \"line\": 3,\n eq_type: 2, \"impedance\": 1}, check_all_pp_elements=True)\n check_res_bus(net, net3)","def test_SetMultipleMovingLoadsConfigurationCombined(self):\n\n # create nodes\n second_coord = [1, 0, 0.0]\n self.mp.CreateNewNode(1,0.0,0.0,0.0)\n self.mp.CreateNewNode(2,second_coord[0],second_coord[1],0.0)\n\n # create condition\n self.mp.CreateNewCondition(\"MovingLoadCondition2D2N\", 1, [1,2], self.mp.GetProperties()[1])\n\n parameters = self.base_parameters\n parameters.AddVector(\"configuration\", [-0.25, 0, 0.25])\n\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0)\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.DELTA_TIME, 0.25)\n\n process = GMA.SetMultipleMovingLoadsProcess(self.mp, parameters)\n conditions = []\n conditions.append(self.cmp.GetCondition(2))\n conditions.append(self.cmp.GetCondition(3))\n conditions.append(self.cmp.GetCondition(4))\n\n # initialise and set load\n process.ExecuteInitialize()\n process.ExecuteInitializeSolutionStep()\n\n\n # set load on node\n all_rhs = []\n for cond in conditions:\n # initialise matrices\n lhs = KratosMultiphysics.Matrix(0, 0)\n rhs = KratosMultiphysics.Vector(0)\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\n all_rhs.append(list(rhs))\n\n\n self.checkRHS(all_rhs[0], [0.0, 0.0, 0.0, 0.0])\n self.checkRHS(all_rhs[1], [0.0, -2.0, 0.0, 0.0])\n self.checkRHS(all_rhs[2], [0.0, -1.5, 0.0, -0.5])\n\n # move load within first element\n process.ExecuteFinalizeSolutionStep()\n process.ExecuteInitializeSolutionStep()\n\n # check if interpolation is done correctly\n all_rhs = []\n for cond in conditions:\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\n all_rhs.append(list(rhs))\n\n self.checkRHS(all_rhs[0], [0.0, -2.0, 0.0, 0.0])\n self.checkRHS(all_rhs[1], [0.0, -1.5, 0.0, -0.5])\n self.checkRHS(all_rhs[2], [0.0, -1.0, 0.0, -1.0])","def test_2(self):\n for _ in range(33):\n\n # Create grid of admissible state space values.\n num_edu_start = np.random.choice(range(1, 3))\n num_periods = np.random.randint(1, 15)\n num_types = np.random.randint(1, 3)\n\n edu_spec = {}\n edu_spec[\"start\"] = np.random.choice(\n range(1, 10), size=num_edu_start, replace=False\n ).tolist()\n edu_spec[\"max\"] = max(edu_spec[\"start\"]) + np.random.randint(1, 5)\n min_idx = edu_spec[\"max\"] + 1\n\n # FORTRAN\n base_args = (num_periods, num_types)\n\n state_space = StateSpace(*base_args, edu_spec[\"start\"], edu_spec[\"max\"])\n\n py_a, py_c, _, _ = state_space._get_fortran_counterparts()\n py_b = state_space.states_per_period\n py_d = py_b.max()\n\n fort_a, fort_b, fort_c, fort_d = fort_debug.wrapper_create_state_space(\n *base_args, edu_spec[\"start\"], edu_spec[\"max\"], min_idx\n )\n\n # Ensure equivalence\n rslts = [[fort_a, py_a], [fort_b, py_b], [fort_c, py_c], [fort_d, py_d]]\n for obj in rslts:\n # Slice Fortran output to shape of Python output.\n if isinstance(obj[0], np.ndarray):\n obj[0] = obj[0][tuple(map(slice, obj[1].shape))]\n\n assert_allclose(obj[0], obj[1])\n\n for _ in range(100):\n\n # Draw random request for testing purposes\n num_covars = np.random.randint(2, 10)\n num_agents = np.random.randint(100, 1000)\n tiny = np.random.normal(size=num_agents)\n beta = np.random.normal(size=num_covars)\n\n # Generate sample\n exog = np.random.sample((num_agents, num_covars))\n exog[:, 0] = 1\n endog = np.dot(exog, beta) + tiny\n\n # Run OLS\n beta_result = ols(y=endog, x=exog)\n\n # Check parameters\n py = beta_result\n f90 = fort_debug.wrapper_get_coefficients(\n endog, exog, num_covars, num_agents\n )\n assert_almost_equal(py, f90)\n\n # Check prediction\n py = exog.dot(beta_result)\n f90 = fort_debug.wrapper_point_predictions(exog, f90, num_agents)\n assert_almost_equal(py, f90)","def test_execute_non_gates(new_network):\n network = new_network\n devices = network.devices\n names = devices.names\n\n LOW = devices.LOW\n HIGH = devices.HIGH\n\n # Make different devices\n [SW1_ID, SW2_ID, SW3_ID, CL_ID, D_ID] = names.lookup([\"Sw1\", \"Sw2\", \"Sw3\",\n \"Clock1\", \"D1\"])\n devices.make_device(SW1_ID, devices.SWITCH, 1)\n devices.make_device(SW2_ID, devices.SWITCH, 0)\n devices.make_device(SW3_ID, devices.SWITCH, 0)\n devices.make_device(CL_ID, devices.CLOCK, 1)\n devices.make_device(D_ID, devices.D_TYPE)\n\n # Make connections\n network.make_connection(SW1_ID, None, D_ID, devices.DATA_ID)\n network.make_connection(CL_ID, None, D_ID, devices.CLK_ID)\n network.make_connection(SW2_ID, None, D_ID, devices.SET_ID)\n network.make_connection(SW3_ID, None, D_ID, devices.CLEAR_ID)\n\n # Get device outputs, the expression is in a string here so that it\n # can be re-evaluated again after executing devices\n sw1_output = \"network.get_output_signal(SW1_ID, None)\"\n sw2_output = \"network.get_output_signal(SW2_ID, None)\"\n sw3_output = \"network.get_output_signal(SW3_ID, None)\"\n clock_output = \"network.get_output_signal(CL_ID, None)\"\n dtype_Q = \"network.get_output_signal(D_ID, devices.Q_ID)\"\n dtype_QBAR = \"network.get_output_signal(D_ID, devices.QBAR_ID)\"\n\n # Execute devices until the clock is LOW at the start of its\n # period\n clock_device = devices.get_device(CL_ID)\n network.execute_network()\n while clock_device.clock_counter != 1 or eval(clock_output) != LOW:\n network.execute_network()\n\n # The clock is not rising yet, Q could be (randomly) HIGH or LOW\n assert [eval(sw1_output), eval(sw2_output), eval(sw3_output),\n eval(clock_output)] == [HIGH, LOW, LOW, LOW]\n\n assert eval(dtype_Q) in [HIGH, LOW]\n assert eval(dtype_QBAR) == network.invert_signal(eval(dtype_Q))\n\n network.execute_network() # the clock has risen\n # While sw1(DATA) is high, Q has now changed to HIGH\n assert [eval(sw1_output), eval(sw2_output), eval(sw3_output),\n eval(clock_output), eval(dtype_Q), eval(dtype_QBAR)] == [\n HIGH, LOW, LOW, HIGH, HIGH, LOW]\n\n devices.set_switch(SW1_ID, LOW) # Sw1 is connected to DATA\n devices.set_switch(SW2_ID, HIGH) # Sw2 is connected to SET\n network.execute_network() # the clock is not rising yet\n network.execute_network() # the clock has risen\n # Even if sw1(DATA) is LOW, and the clock is rising,\n # sw2(SET) is HIGH, so Q is HIGH\n assert [eval(sw1_output), eval(sw2_output), eval(sw3_output),\n eval(clock_output), eval(dtype_Q), eval(dtype_QBAR)] == [\n LOW, HIGH, LOW, HIGH, HIGH, LOW]\n\n devices.set_switch(SW1_ID, HIGH) # Sw1 is connected to DATA\n devices.set_switch(SW2_ID, LOW) # Sw2 is connected to SET\n devices.set_switch(SW3_ID, HIGH) # Sw3 is connected to CLEAR\n network.execute_network() # the clock is not rising yet\n network.execute_network() # the clock has risen\n # Even if sw1(DATA) is HIGH, and the clock is rising,\n # sw3(CLEAR) is HIGH, so Q is LOW\n assert [eval(sw1_output), eval(sw2_output), eval(sw3_output),\n eval(clock_output), eval(dtype_Q), eval(dtype_QBAR)] == [\n HIGH, LOW, HIGH, HIGH, LOW, HIGH]","def test_iterations(self):\n grover = Grover(oracle=self._oracle, good_state=['111'], iterations=2)\n ret = grover.run(self._sv)\n self.assertTrue(Operator(ret['circuit']).equiv(Operator(self._expected)))\n\n grover = Grover(oracle=self._oracle, good_state=['111'], iterations=[1, 2, 3])\n ret = grover.run(self._sv)\n self.assertTrue(ret.oracle_evaluation)\n self.assertIn(ret.top_measurement, ['111'])","def test_SetMultipleMovingLoadsWithVelocityFunctionConfigurationNegative(self):\n\n # create nodes\n second_coord = [1, 0, 0.0]\n self.mp.CreateNewNode(1,0.0,0.0,0.0)\n self.mp.CreateNewNode(2,second_coord[0],second_coord[1],0.0)\n\n # create condition\n self.mp.CreateNewCondition(\"MovingLoadCondition2D2N\", 1, [1,2], self.mp.GetProperties()[1])\n\n parameters = self.base_parameters\n parameters[\"velocity\"]=KratosMultiphysics.Parameters(self.time_dependent_velocity)\n parameters.AddVector(\"configuration\", [-0.25])\n\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0)\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.DELTA_TIME, 0.25)\n\n process = GMA.SetMultipleMovingLoadsProcess(self.mp, parameters)\n cond = self.cmp.GetCondition(2)\n\n # initialise and set load\n process.ExecuteInitialize()\n process.ExecuteInitializeSolutionStep()\n\n # initialise matrices\n lhs = KratosMultiphysics.Matrix(0, 0)\n rhs = KratosMultiphysics.Vector(0)\n\n # set load on node\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\n\n self.checkRHS(rhs, [0.0, 0.0, 0.0, 0.0])\n\n # change time and recalculate load\n process.ExecuteFinalizeSolutionStep()\n process.ExecuteInitializeSolutionStep()\n\n # check if interpolation is done correctly\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\n\n self.checkRHS(rhs, [0.0, 0.0, 0.0, 0.0])\n\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0.5)\n\n process.ExecuteFinalizeSolutionStep()\n process.ExecuteInitializeSolutionStep()\n\n # check if interpolation is done correctly\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\n\n self.checkRHS(rhs, [0.0, -2.0, 0.0, 0.0])","def simulate_run(run, maker, all_data, train_mask, test_mask, instances, independent, mixture):\n\n train_data = all_data.masked(train_mask)\n test_data = all_data.masked(test_mask)\n\n if instances is not None:\n ids = sorted(train_data.run_lists, key = lambda _: numpy.random.rand())[:instances]\n train_data = train_data.filter(*ids)\n\n if independent:\n train_data = train_data.collect_independent(mixture).only_nonempty()\n else:\n train_data = train_data.collect_systematic(mixture).only_nonempty()\n\n budget = test_data.common_budget\n #budget = test_data.common_budget / 2 # XXX\n suite = borg.fake.FakeSuite(test_data)\n\n if maker.subname == \"preplanning-dir\":\n model_kwargs = {\"K\": 64}\n\n if \"set_alpha\" in maker.variants:\n model_kwargs[\"alpha\"] = 1e-2\n else:\n model_kwargs = {}\n\n solver = maker(suite, train_data, model_kwargs = model_kwargs)\n successes = []\n\n for (i, instance_id) in enumerate(test_data.run_lists):\n logger.info(\"simulating run %i/%i on %s\", i, len(test_data), instance_id)\n\n with suite.domain.task_from_path(instance_id) as instance:\n with borg.accounting() as accountant:\n answer = solver.start(instance).run_then_stop(budget)\n\n succeeded = suite.domain.is_final(instance, answer)\n\n logger.info(\n \"%s %s on %s (%.2f CPU s)\",\n maker.name,\n \"succeeded\" if succeeded else \"failed\",\n os.path.basename(instance),\n accountant.total.cpu_seconds,\n )\n\n if succeeded:\n successes.append(accountant.total.cpu_seconds)\n\n logger.info(\n \"%s had %i successes over %i instances\",\n maker.name,\n len(successes),\n len(test_data),\n )\n\n description = \"{0} ({1})\".format(mixture, \"Sep.\" if independent else \"Sys.\")\n\n return (\n description,\n maker.name,\n instances,\n len(successes),\n numpy.mean(successes),\n numpy.median(successes),\n )","def generate_scenario_3(seed=1996, permanent_save=True, radar_meas_rate=1, ais_meas_rate=5, sigma_process=0.01,\n sigma_meas_radar=3, sigma_meas_ais=1, timesteps=20):\n start_time = datetime.now()\n\n # specify seed to be able to repeat the example\n np.random.seed(seed)\n\n # combine two 1-D CV models to create a 2-D CV model\n transition_model = CombinedLinearGaussianTransitionModel(\n [ConstantVelocity(sigma_process), ConstantVelocity(sigma_process)])\n\n # starting at 0,0 and moving NE\n truth = GroundTruthPath([GroundTruthState([0, 1, 0, 1], timestamp=start_time)])\n\n # generate truth using transition_model and noise\n end_time = start_time + timedelta(seconds=timesteps * max(radar_meas_rate, ais_meas_rate))\n time = start_time + timedelta(seconds=1)\n while time < end_time:\n truth.append(GroundTruthState(\n transition_model.function(truth[-1], noise=True, time_interval=timedelta(seconds=1)),\n timestamp=time))\n time += timedelta(seconds=1)\n\n # Simulate measurements\n # Specify measurement model for radar\n measurement_model_radar = LinearGaussian(\n ndim_state=4, # number of state dimensions\n mapping=(0, 2), # mapping measurement vector index to state index\n noise_covar=np.array([[sigma_meas_radar, 0], # covariance matrix for Gaussian PDF\n [0, sigma_meas_radar]])\n )\n\n # Specify measurement model for AIS (Same as for radar)\n measurement_model_ais = LinearGaussian(\n ndim_state=4,\n mapping=(0, 2),\n noise_covar=np.array([[sigma_meas_ais, 0],\n [0, sigma_meas_ais]])\n )\n\n # generate \"radar\" measurements\n measurements_radar = []\n measurements_ais = []\n next_radar_meas_time = start_time\n next_ais_meas_time = start_time\n for state in truth:\n # check whether we want to generate a measurement from this gt\n if state.timestamp == next_radar_meas_time:\n measurement = measurement_model_radar.function(state, noise=True)\n measurements_radar.append(Detection(measurement, timestamp=state.timestamp))\n next_radar_meas_time += timedelta(seconds=radar_meas_rate)\n\n if state.timestamp == next_ais_meas_time:\n measurement = measurement_model_ais.function(state, noise=True)\n measurements_ais.append(Detection(measurement, timestamp=state.timestamp))\n next_ais_meas_time += timedelta(seconds=ais_meas_rate)\n\n if permanent_save:\n save_folder_name = seed.__str__()\n else:\n save_folder_name = \"temp\"\n\n save_folder = \"../scenarios/scenario3/\" + save_folder_name + \"/\"\n\n # save the ground truth and the measurements for the radar and the AIS\n store_object.store_object(truth, save_folder, \"ground_truth.pk1\")\n store_object.store_object(measurements_radar, save_folder, \"measurements_radar.pk1\")\n store_object.store_object(measurements_ais, save_folder, \"measurements_ais.pk1\")\n store_object.store_object(start_time, save_folder, \"start_time.pk1\")\n store_object.store_object(measurement_model_radar, save_folder, \"measurement_model_radar.pk1\")\n store_object.store_object(measurement_model_ais, save_folder, \"measurement_model_ais.pk1\")\n store_object.store_object(transition_model, save_folder, \"transition_model.pk1\")","def main():\n dirPath = \"./tests/\"\n score = 0\n\n # Run test files to check correctness\n print(\"\\n======================= TEST CORRECTNESS =======================\\n\")\n\n print(\"\\n------- There are no Euler circuits in the first two tests -----\\n\")\n\n score += 4 - testInput(dirPath + \"disconnected\", 0)\n print(\"Score so far: \" + str(score))\n\n score += 5 - testInput(dirPath + \"noEuler\", 0)\n print(\"Score so far: \" + str(score))\n\n print(\"\\n------- From now on all test graphs have Euler circuits -------\\n\")\n\n score += testInput(dirPath + \"small\", 6)\n print(\"Score so far: \" + str(score))\n\n score += testInput(dirPath + \"medium\", 5)\n print(\"Score so far: \" + str(score))\n\n score += testInput(dirPath + \"large\", 6)\n print(\"Score so far: \" + str(score))\n\n score += 4 * testInput(dirPath + \"verylarge\", 1)\n print(\"Correctness score: \" + str(score) + \" out of 30.\")\n\n # Test very large graphs\n print(\"\\n======================= TEST EFFICIENCY =======================\\n\")\n\n score += 2 * testInput(dirPath + \"huge1\", 1)\n print(\"Score so far: \" + str(score) + \" out of 40.\")\n\n score += 2 * testInput(dirPath + \"huge2\", 1)\n print(\"Score so far: \" + str(score) + \" out of 40.\")\n\n score += 2 * testInput(dirPath + \"huge3\", 1)\n print(\"Score so far: \" + str(score) + \" out of 40.\")\n\n score += 2 * testInput(dirPath + \"huge4\", 1)\n print(\"Score so far: \" + str(score) + \" out of 40.\")\n\n score += 2 * testInput(dirPath + \"huge5\", 1)\n print(\"Final score: \" + str(score) + \" out of 40.\")","def test_run():\n # Only few steps for test\n timesteps = 128\n\n # Compute all sub testing conf\n envs = ['CartPole-v0']\n ml_platforms = ['torch', 'tf']\n agents = ['dqn', 'a2c']\n\n test_combinations = list(it.product(\n envs,\n ml_platforms,\n agents\n )\n )\n\n # Finally test them all\n for conf in test_combinations:\n env_str, ml_platform_str, agent_str = conf\n run(\n agent_str,\n ml_platform_str,\n env_str,\n 'dense',\n timesteps,\n './target/')","def standardRun(\n\tnIterations=3000000, gridLength=40, alloyFraction=50, Eam=0.1, T=300,\n\tdimensions=2, showMatrixImages=True):\n\talloyGrid = srf.initializeGrid(gridLength, alloyFraction, dimensions)\n\t# Sets up list list to take current system energy as simulation progresses\n\tenergyList = [0] * (nIterations + 1)\n\tenergyList[0] = sref.getTotalEnergy(alloyGrid, Eam, dimensions)\n\n\tif showMatrixImages and dimensions == 2:\n\t\t# Display initial matrix\n\t\tpyplot.figure(num=\"Initial config\")\n\t\timg1 = pyplot.imshow(alloyGrid, interpolation='nearest')\n\t\tpyplot.colorbar(img1)\n\n\torderMeasure1, actualList, binList = sref.getOrder(\n\t\talloyGrid, alloyFraction, dimensions)\n\tprint(\"Initial order is: {}\".format(str(orderMeasure1)))\n\talloyGrid, energyList = srf.runSim(\n\t\talloyGrid, energyList, T, Eam, nIterations, gridLength, dimensions)\n\n\tif showMatrixImages and dimensions == 2:\n\t\t# Display matrix in prettier form, as a coloured graph\n\t\tpyplot.figure(num=\"Final config\")\n\t\timg2 = pyplot.imshow(alloyGrid, interpolation='nearest')\n\t\tpyplot.colorbar(img2)\n\t\tpyplot.show()\n\n\torderMeasure2, actualList, binList = sref.getOrder(\n\t\talloyGrid, alloyFraction, dimensions)\n\tprint(\"Final order is: {}\".format(str(orderMeasure2)))","def test_cli_simulation(self):\n self.run_owtf('-s')\n self.assert_is_in_logs(\n 'All jobs have been done. Exiting.',\n name='MainProcess',\n msg='OWTF did not finish properly!')\n plugin_handler = ServiceLocator.get_component(\"plugin_handler\")\n self.assertTrue(\n plugin_handler.Simulation,\n msg='OWTF should have been run in simulation mode!')","def test(self, num_decisions=1000):\n all_grid_states = []\n all_grid_rewards = []\n\n all_grid_states_cluster = []\n all_surrounding_states_cluster = []\n\n all_system_rewards = []\n all_system_states = []\n all_system_states_cluster = []\n\n all_actions = []\n all_dissipation = []\n\n os.system(\"mkdir \" + self.folder_name + \"Test/\")\n filename = self.folder_name + \"Test/\" + \"TEST.h5\"\n self.system.reset_context(filename)\n tag = \"_test_init\"\n self.system.run_decorrelation(20)\n\n grid_dist, surrounding_dist, _, _, _, _ = self.system.get_state_reward()\n state = self._get_state(grid_dist, surrounding_dist)\n\n all_dissipation.append(self.system.get_dissipation())\n for i in range(num_decisions):\n action_index = self._get_action(state, episode=10000)\n tag = \"_test_\" + str(i)\n actions = [self.all_actions[i] for i in action_index]\n all_actions.append(actions)\n self.system.update_action(actions)\n system_states, system_rewards, system_states_cluster = self.system.run_step(\n is_detailed=True, tag=tag)\n\n grid_dist, surrounding_dist, grid_reward, surrounding_reward, grid_states_cluster, surrounding_states_cluster = self.system.get_state_reward()\n\n # The \"grid states\" and dissipation are recorded at the end of a decision\n # Dissipation here is total entropy production (not epr)\n # Actions are recorded at the beginning of the decision\n\n state = self._get_state(grid_dist, surrounding_dist)\n reward = self._get_reward(grid_reward, surrounding_reward)\n\n all_grid_states.append(state)\n all_grid_rewards.append(reward)\n\n all_grid_states_cluster.append(grid_states_cluster)\n all_surrounding_states_cluster.append(surrounding_states_cluster)\n\n all_dissipation.append(self.system.get_dissipation())\n\n # The \"System States\" are recorded every 0.25 seconds. Excludes 0th second\n all_system_states.append(system_states)\n # Just to have a 1D array use extend\n all_system_rewards.append(system_rewards)\n all_system_states_cluster.append(system_states_cluster)\n\n if (i % 100 == 99):\n np.save(self.folder_name + \"grid_rewards\",\n np.array(all_grid_rewards))\n np.save(self.folder_name + \"grid_states\",\n np.array(all_grid_states, dtype=object))\n np.save(self.folder_name + \"grid_states_cluster\",\n np.array(all_grid_states_cluster, dtype=object))\n\n np.save(self.folder_name + \"surrounding_states_cluster\",\n np.array(all_surrounding_states_cluster))\n\n np.save(self.folder_name + \"actions\", np.array(all_actions))\n\n np.save(self.folder_name + \"dissipation\",\n np.array(all_dissipation))\n np.save(self.folder_name + \"system_states\",\n np.array(all_system_states))\n np.save(self.folder_name + \"system_states_cluster\",\n np.array(all_system_states_cluster))\n np.save(self.folder_name + \"system_rewards\",\n np.array(all_system_rewards))","def test(args):\n brain_name = env.brain_names[0]\n brain = env.brains[brain_name]\n env_info = env.reset(train_mode=True)[brain_name]\n\n num_agents = len(env_info.agents)\n print('Number of agents:', num_agents)\n\n # dim of each action\n action_size = brain.vector_action_space_size\n print('Size of each action:', action_size)\n\n # dim of the state space\n states = env_info.vector_observations\n state_size = states.shape[1]\n\n agent = MADDPG(state_size, action_size, actor_layer_dim_1=args.actor_layer_dim_1,\n actor_layer_dim_2=args.actor_layer_dim_2,\n actor_layer_dim_3=args.actor_layer_dim_3,\n critic_layer_dim_1=args.critic_layer_dim_1,\n critic_layer_dim_2=args.critic_layer_dim_2,\n critic_layer_dim_3=args.critic_layer_dim_3)\n\n agent.load(\n \"chkpts/{}/{:02d}_best_model.checkpoint\".format(args.model_path, args.loop_counter))\n\n test_scores = []\n for i_episode in tqdm(range(1, 1+args.test_n_run)):\n # initialize the scores\n scores = np.zeros(num_agents)\n env_info = env.reset(train_mode=True)[\n brain_name] # reset the environment\n states = env_info.vector_observations # get the current states\n dones = [False]*num_agents\n while not np.any(dones):\n actions = agent.act(states) # select actions\n # send the actions to the environment\n env_info = env.step(actions)[brain_name]\n next_states = env_info.vector_observations # get the next states\n rewards = env_info.rewards # get the rewards\n dones = env_info.local_done # see if episode has finished\n scores += rewards # update the scores\n # roll over the states to next time step\n states = next_states\n\n test_scores.append(np.max(scores))\n\n avg_score = sum(test_scores)/len(test_scores)\n print(\"Test Score: {}\".format(avg_score))\n\n return avg_score","def test_scenario_2(scenario):\n nt_server, nt_client, nt_client2, st, ct1, ct2 = scenario\n\n nt_client.disconnect()\n nt_client2.disconnect()\n\n ct1.putString(\"Client1Only\", \"11\")\n ct1.putString(\"SC1Shared\", \"11\")\n ct1.putString(\"ClientShared\", \"11\")\n\n ct2.putString(\"Client2Only\", \"12\")\n ct2.putString(\"SC2Shared\", \"12\")\n ct2.putString(\"ClientShared\", \"12\")\n\n st.putString(\"ServerOnly\", \"10\")\n st.putString(\"SC1Shared\", \"10\")\n st.putString(\"SC2Shared\", \"10\")\n\n with nt_server.expect_changes(3):\n with nt_client.expect_changes(3):\n nt_client.start_test()\n\n with nt_server.expect_changes(3):\n with nt_client.expect_changes(3):\n with nt_client2.expect_changes(3):\n nt_client2.start_test()\n\n check_results(\n st,\n ct1,\n ct2,\n ServerOnly=10,\n Client1Only=11,\n Client2Only=12,\n SC1Shared=11,\n SC2Shared=12,\n ClientShared=12,\n )","def exercise1d():\n\n # Defination of muscles\n muscle_parameters = MuscleParameters()\n print(muscle_parameters.showParameters())\n\n mass_parameters = MassParameters()\n print(mass_parameters.showParameters())\n\n # Create muscle object\n muscle = Muscle(muscle_parameters)\n\n # Create mass object\n mass = Mass(mass_parameters)\n\n pylog.warning(\"Isotonic muscle contraction to be implemented\")\n\n # Instatiate isotonic muscle system\n sys = IsotonicMuscleSystem()\n\n # Add the muscle to the system\n sys.add_muscle(muscle)\n\n # Add the mass to the system\n sys.add_mass(mass)\n\n # You can still access the muscle inside the system by doing\n # >>> sys.muscle.L_OPT # To get the muscle optimal length\n\n # Evalute for a single load\n load = 100.\n\n # Evalute for a single muscle stimulation\n muscle_stimulation = 1.\n\n # Set the initial condition\n x0 = [0.0, sys.muscle.L_OPT,\n sys.muscle.L_OPT + sys.muscle.L_SLACK, 0.0]\n \n # x0[0] - -> activation\n # x0[1] - -> contractile length(l_ce)\n # x0[2] - -> position of the mass/load\n # x0[3] - -> velocity of the mass/load\n \n\n # Set the time for integration\n t_start = 0.0\n t_stop = 0.5\n time_step = 0.001\n time_stabilize = 0.2\n\n time = np.arange(t_start, t_stop, time_step)\n \n loads = np.arange(20, 351, 10)\n \n velocities = []\n\n for index, load in enumerate(loads):\n \n # Run the integration\n result = sys.integrate(x0=x0,\n time=time,\n time_step=time_step,\n time_stabilize=time_stabilize,\n stimulation=muscle_stimulation,\n load=load) \n\n if (result.l_mtc[-1] < sys.muscle.L_OPT + sys.muscle.L_SLACK):\n velocities.append(np.max(result.v_ce))\n print('max')\n else:\n velocities.append(np.min(result.v_ce))\n print('min')\n\n\n #Muscle contracile Velocity - Tension (load) relationship\n \n plt.figure('Isotonic muscle experiment')\n plt.title('Isotonic muscle experiment')\n plt.xlabel('Muscle Contractile Velocity [m/s]')\n plt.ylabel('Tension (load) [N]')\n plt.plot(velocities, loads)\n plt.grid()\n \n #For different stimulations 1.f\n \n muscle_stimulation = np.arange(0,1.1,0.2)\n plt.figure('Isotonic muscle exp with different stimulations')\n plt.title('Isotonic muscle experiment with different stimulations')\n\n for stim in muscle_stimulation:\n velocities = []\n for index, load in enumerate(loads):\n # Run the integration\n result = sys.integrate(x0=x0,\n time=time,\n time_step=time_step,\n time_stabilize=time_stabilize,\n stimulation=stim,\n load=load) \n\n if (result.l_mtc[-1] < sys.muscle.L_OPT + sys.muscle.L_SLACK):\n velocities.append(np.max(result.v_ce))\n else:\n velocities.append(np.min(result.v_ce))\n plt.xlabel('Muscle Contractile Velocity [m/s]')\n plt.ylabel('Tension (load) [N]')\n plt.plot(velocities, loads)\n \n plt.legend(('0','0.2','0.4','0.6','0.8','1.0'))\n plt.grid()","def test_teleport_default_basis_gates(self):\n shots = 2000\n circuits = ref_algorithms.teleport_circuit()\n targets = ref_algorithms.teleport_counts(shots)\n job = execute(circuits, QasmSimulator(), shots=shots)\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)","def test_minimise_reentrant():\n # Set parameters for number of iterations and evaluation frequency\n n_iters_1 = 23\n eval_every_1 = 5\n n_iters_2 = 31\n eval_every_2 = 3\n # Create model and data\n np.random.seed(6307)\n model = get_random_network(input_dim=1, output_dim=1)\n sin_data = data.Sinusoidal(input_dim=1, output_dim=1, freq=1)\n # Open result file\n results_filename = \"Test AbstractOptimiser.optimise method re-entrant.txt\"\n results_path = os.path.join(output_dir, results_filename)\n with open(results_path, \"w\") as results_file:\n # Create Result object\n result = optimisers.Result(\n name=\"SGD without line search\", \n verbose=True,\n file=results_file\n )\n # Call gradient descent function twice\n result_ls = optimisers.gradient_descent(\n model,\n sin_data,\n terminator=optimisers.Terminator(i_lim=n_iters_1),\n evaluator=optimisers.Evaluator(i_interval=eval_every_1),\n result=result,\n display_summary=False\n )\n result_ls = optimisers.gradient_descent(\n model,\n sin_data,\n terminator=optimisers.Terminator(i_lim=n_iters_2),\n evaluator=optimisers.Evaluator(i_interval=eval_every_2),\n result=result\n )\n # Check values in time column are monotonically increasing\n time_values = result.get_values(optimisers.results.columns.Time)\n for i in range(1, len(time_values)):\n assert time_values[i] > time_values[i - 1]\n # Check values in iteration column are monotonically increasing\n iteration_values = result.get_values(optimisers.results.columns.Iteration)\n for i in range(1, len(iteration_values)):\n assert iteration_values[i] > iteration_values[i - 1]\n # Assert that the list of iteration values is exactly what we expect\n all_iter_vals = (\n list(range(0, n_iters_1, eval_every_1)) +\n list(range(n_iters_1, n_iters_1 + n_iters_2, eval_every_2)) +\n [n_iters_1 + n_iters_2]\n )\n assert all_iter_vals == iteration_values","def test_sdg_gate_deterministic_default_basis_gates(self):\n shots = 100\n circuits = ref_1q_clifford.sdg_gate_circuits_deterministic(final_measure=True)\n targets = ref_1q_clifford.sdg_gate_counts_deterministic(shots)\n job = execute(circuits, QasmSimulator(), shots=shots)\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0)","def test_GA_sanity():\n\tga = GA.GA(2,3)\n\tgenomes = ga.seedGenomes()\n\tif len(genomes) != 2:\n\t\tprint \"Wrong number of genomes\"\n\tif len(genomes[0]) != 3:\n\t\tprint \"Wrong size in genomes\"\n\t#print genomes\n\t#live and learn\n\tfitnesses = [23, 45]\n\tga.fitnessUpdate(fitnesses)\n\tgenomes2 = ga.createNextGeneration()\n\tif len(genomes2) != 2:\n\t\tprint \"Wrong number of genomes\"\n\tif len(genomes2[0]) != 3:\n\t\tprint \"Wrong size in genomes\"\n\t#print genomes2","def main(self) -> tuple[bool, bool]:\n self.simulation_parameters, running, reset, back_to_main_menu = self.show_start_screen()\n if back_to_main_menu:\n return reset, True\n if running:\n self.initialize()\n while running:\n running, reset = self.do_simulation_loop()\n return reset, False","def setUpClass(cls):\n cls.sim1 = Simulation(logging_level=50)\n cls.sim1.set_simulation_parameters(\n seed=1, task=47, output_directory=\"output\", min_speciation_rate=0.01, sigma=2, deme=1, sample_size=0.01\n )\n cls.sim1.set_map_files(\n \"null\", fine_file=\"sample/SA_sample_fine.tif\", reproduction_map=\"sample/SA_sample_reproduction.tif\"\n )\n cls.sim1.run()\n cls.sim2 = Simulation(logging_level=50)\n cls.sim2.set_simulation_parameters(\n seed=1, task=48, output_directory=\"output\", min_speciation_rate=0.01, sigma=2, deme=1, sample_size=0.01\n )\n cls.sim2.set_map_files(\"null\", fine_file=\"sample/SA_sample_fine.tif\")\n cls.sim2.run()\n cls.sim3 = Simulation(logging_level=50)\n cls.sim3.set_simulation_parameters(\n seed=2, task=47, output_directory=\"output\", min_speciation_rate=0.01, sigma=2, deme=1, sample_size=0.01\n )\n cls.sim3.set_map_files(\n \"null\",\n fine_file=\"sample/SA_sample_fine.tif\",\n death_map=\"sample/SA_sample_reproduction.tif\",\n reproduction_map=\"sample/SA_sample_reproduction.tif\",\n )\n cls.sim3.run()\n cls.sim4 = Simulation(logging_level=50)\n cls.sim4.set_simulation_parameters(\n seed=4, task=47, output_directory=\"output\", min_speciation_rate=0.01, sigma=2, deme=1, sample_size=0.01\n )\n cls.sim4.set_map_files(\"null\", fine_file=\"sample/SA_sample_coarse_pristine.tif\")\n cls.sim4.add_reproduction_map(reproduction_map=\"sample/SA_reproduction_coarse.tif\")\n cls.sim4.add_death_map(death_map=\"sample/SA_death.tif\")\n cls.sim4.add_dispersal_map(dispersal_map=\"sample/dispersal_fine2.tif\")\n cls.sim4.run()\n cls.coal1 = CoalescenceTree(cls.sim1)\n cls.coal2 = CoalescenceTree(cls.sim2)\n cls.coal3 = CoalescenceTree(cls.sim3)\n cls.coal4 = CoalescenceTree(cls.sim4)","def test_marketsim(description, group, inputs, outputs, grader):\n\n points_earned = 0.0 # initialize points for this test case\n try:\n # Try to import student code (only once)\n if not main_code in globals():\n import importlib\n # * Import module\n mod = importlib.import_module(main_code)\n globals()[main_code] = mod\n # * Import methods to test\n for m in ['compute_portvals']:\n globals()[m] = getattr(mod, m)\n\n incorrect = False\n msgs = []\n\n if group == 'author':\n try:\n # globals()['author'] = getattr(marketsim, 'author')\n auth_string = run_with_timeout(marketsim.author,seconds_per_test_case,(),{})\n if auth_string == 'tb34':\n incorrect = True\n msgs.append(\" Incorrect author name (tb34)\")\n points_earned = -20\n elif auth_string == '':\n incorrect = True\n msgs.append(\" Empty author name\")\n points_earned = -20\n except Exception as e:\n incorrect = True\n msgs.append(\" Exception occured when calling author() method: {}\".format(e))\n points_earned = -20\n else:\n # Unpack test case\n orders_file = inputs['orders_file']\n start_val = inputs['start_val']\n\n portvals = None\n fullpath_orders_file = orders_file#get_orders_data_file(orders_file)\n portvals = run_with_timeout(compute_portvals,seconds_per_test_case,(fullpath_orders_file,start_val),{})\n # Verify against expected outputs and assign points\n\n # * Check return type is correct, coax into Series\n assert (type(portvals) == pd.Series) or (type(portvals) == pd.DataFrame and len(portvals.columns) == 1), \"You must return a Series or single-column DataFrame!\"\n if type(portvals) == pd.DataFrame:\n portvals = portvals[portvals.columns[0]] # convert single-column DataFrame to Series\n if group == 'basic':\n if len(portvals) != outputs['num_days']:\n incorrect=True\n msgs.append(\" Incorrect number of days: {}, expected {}\".format(len(portvals), outputs['num_days']))\n else:\n points_earned += 2.0\n if abs(portvals[-1]-outputs['last_day_portval']) > (0.001*outputs['last_day_portval']):\n incorrect=True\n msgs.append(\" Incorrect final value: {}, expected {}\".format(portvals[-1],outputs['last_day_portval']))\n else:\n points_earned += 5.0\n adr,sr = get_stats(portvals)\n if abs(sr-outputs['sharpe_ratio']) > abs(0.001*outputs['sharpe_ratio']):\n incorrect=True\n msgs.append(\" Incorrect sharpe ratio: {}, expected {}\".format(sr,outputs['sharpe_ratio']))\n else:\n points_earned += 1.5\n if abs(adr-outputs['avg_daily_ret']) > abs(0.001*outputs['avg_daily_ret']):\n incorrect=True\n msgs.append(\" Incorrect avg daily return: {}, expected {}\".format(adr,outputs['avg_daily_ret']))\n else:\n points_earned += 1.0\n elif group=='leverage':\n if abs(portvals[-1]-outputs['last_day_portval']) > (0.001*outputs['last_day_portval']):\n incorrect = True\n msgs.append(\" Incorrect final value: {}, expected {}\".format(portvals[-1],outputs['last_day_portval']))\n else:\n points_earned += 1.0\n if incorrect:\n # inputs_str = \" orders_file: {}\\n\" \\\n # \" start_val: {}\\n\".format(orders_file, start_val)\n raise IncorrectOutput, \"Test failed on one or more output criteria.\\n Inputs:\\n{}\\n Failures:\\n{}\".format(inputs, \"\\n\".join(msgs))\n except Exception as e:\n # Test result: failed\n msg = \"Test case description: {}\\n\".format(description)\n \n # Generate a filtered stacktrace, only showing erroneous lines in student file(s)\n \n tb_list = tb.extract_tb(sys.exc_info()[2])\n if 'grading_traceback' in dir(e):\n tb_list = e.grading_traceback\n for i in xrange(len(tb_list)):\n row = tb_list[i]\n tb_list[i] = (os.path.basename(row[0]), row[1], row[2], row[3]) # show only filename instead of long absolute path\n tb_list = [row for row in tb_list if row[0] == 'marketsim.py']\n if tb_list:\n msg += \"Traceback:\\n\"\n msg += ''.join(tb.format_list(tb_list)) # contains newlines\n msg += \"{}: {}\".format(e.__class__.__name__, e.message)\n\n # Report failure result to grader, with stacktrace\n grader.add_result(GradeResult(outcome='failed', points=points_earned, msg=msg))\n raise\n else:\n # Test result: passed (no exceptions)\n grader.add_result(GradeResult(outcome='passed', points=points_earned, msg=None))","def run(num_trials):\n\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.1, display=True) \n # create simulator (uses pygame when display=True, if available)\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\n\n sim.run(n_trials=num_trials) # run for a specified number of trials\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\n\n a.performace_report(num_trials)","def run_test0():\r\n \r\n ndia, nadi, nnucl, ntraj = 1, 1, 2, 500\r\n\r\n # ======= Hierarchy of Hamiltonians =======\r\n ham = nHamiltonian(ndia, nadi, nnucl)\r\n ham.init_all(2)\r\n print \"id=\", ham.id, \" level=\", ham.level\r\n\r\n ham1 = [] \r\n for tr in xrange(ntraj):\r\n ham1.append( nHamiltonian(ndia, nadi, nnucl) ) \r\n print ham1[tr].id, ham1[tr].level\r\n ham1[tr].init_all(2)\r\n ham.add_child(ham1[tr])\r\n print Cpp2Py(ham1[tr].get_full_id())\r\n\r\n # Set up the models and compute internal variables\r\n # Initialization\r\n # Model parameters \r\n params = { \"model\":1 }\r\n\r\n # Simulation parameters\r\n dt = 1.0\r\n\r\n # Dynamical variables and system-specific properties\r\n mean_q = MATRIX(nnucl,1); \r\n sigma_q = MATRIX(nnucl,1); \r\n mean_p = MATRIX(nnucl,1); \r\n sigma_p = MATRIX(nnucl,1); \r\n iM = MATRIX(nnucl,1);\r\n\r\n for i in xrange(nnucl):\r\n mean_q.set(i,0, -1.0) \r\n sigma_q.set(i,0, 0.05) \r\n mean_p.set(i,0, 0.0) \r\n sigma_p.set(i,0, 0.0)\r\n iM.set(i,0, 1.0/2000.0)\r\n\r\n rnd = Random()\r\n q = MATRIX(nnucl,ntraj); aux_functs.sample(q, mean_q, sigma_q, rnd)\r\n p = MATRIX(nnucl,ntraj); aux_functs.sample(p, mean_p, sigma_p, rnd) \r\n\r\n # Initial calculations\r\n q.show_matrix()\r\n\r\n # Compute Initial trajectory probability distributions for all dof\r\n #bin(q, -2.0, 2.0, 0.01)\r\n\r\n ham.compute_diabatic(compute_model, q, params, 1)\r\n ham.compute_adiabatic(1, 1);\r\n ham.add_ethd_adi(q, iM, 1)\r\n\r\n os.system(\"mkdir _2D_dist\")\r\n out1 = open(\"_output.txt\", \"w\"); out1.close() \r\n\r\n # Do the propagation\r\n for i in xrange(100):\r\n\r\n aux_functs.bin2(q, -2.0, 2.0, 0.1, -2.0, 2.0, 0.1, \"_2D_dist/_2D_distrib_\"+str(i)+\"_.txt\")\r\n\r\n Verlet1(dt, q, p, iM, ham, compute_model, params, 1)\r\n\r\n #=========== Properties ==========\r\n\r\n Ekin, Epot, Etot = aux_functs.compute_etot(ham, p, iM)\r\n\r\n # Print the ensemble average - kinetic, potential, and total energies\r\n # Print the tunneling information. Here, we count each trajectory across the barrier.\r\n out1 = open(\"_output.txt\", \"a\")\r\n out1.write( \" %8.5f %8.5f %8.5f %8.5f\\n\" % ( i*dt, Ekin, Epot, Etot ) )\r\n out1.close()","def test_compare_solver():\n # initialize all solver\n solver_1 = EulerSolver()\n solver_2 = ScipyOdeSolver('dopri5')\n solver_3 = ScipySolveIvpSolver(method='Radau')\n solver_4 = ScipyOdeIntSolver()\n solver = [solver_1, solver_2, solver_3, solver_4]\n # define the integration steps\n time_step = [g_initial_time + step for step in g_time_steps]\n u = 0.0 # initial input\n # set the system equation and jacobian\n system_equation = lambda t, state, u: system(t, state, u)\n system_jacobian = lambda t, state, u: jacobian(t, state, u)\n [solve.set_system_equation(system_equation, system_jacobian) for solve in solver]\n # set initial values of the solver\n [solve.set_initial_value(g_initial_value, g_initial_time) for solve in solver]\n # integrate for given steps\n for steps in time_step:\n u += 0.8 # increase the input in each step\n [solve.set_f_params(u) for solve in solver]\n [solve.integrate(steps) for solve in solver]\n # test if all solver integrated for the same time\n assert solver_1.t == solver_2.t == solver_3.t == solver_4.t\n # test if the relative difference between the states is small\n abs_values = [sum(abs(solver_1.y)), sum(abs(solver_2.y)), sum(abs(solver_3.y)), sum(abs(solver_4.y))]\n assert max(abs_values) / min(abs_values) - 1 < 1E-4, \"Time step at the error: \" + str(steps)","def test_basic():\n\n\ttransmissions_1 = compute_transmissions(cal_directory)\n\ttransmissions_2 = compute_transmissions(cal_directory, \n\t\tlines = [\"ha\", \"nii\"], calibrator = [\"G300_0\"], plot = True)\n\n\tassert np.allclose(transmissions_1[\"ha\"][\"g300_0\"][\"SLOPE_THEIL\"], \n\t\ttransmissions_2[\"ha\"][\"G300_0\"][\"SLOPE_THEIL\"])","def test_griewank_works_fine(self):\n\n ba_griewank = BatAlgorithm(NP=10, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, seed=self.seed)\n ba_griewankc = BatAlgorithm(NP=10, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, seed=self.seed)\n AlgorithmTestCase.algorithm_run_test(self, ba_griewank, ba_griewankc)","def test_scenario_1(scenario):\n nt_server, nt_client, nt_client2, st, ct1, ct2 = scenario\n\n nt_client.disconnect()\n\n ct1.putString(\"Client1Only\", \"11\")\n ct1.putString(\"SC1Shared\", \"11\")\n ct1.putString(\"ClientShared\", \"11\")\n\n with nt_client2.expect_changes(3):\n st.putString(\"ServerOnly\", \"10\")\n st.putString(\"SC1Shared\", \"10\")\n st.putString(\"SC2Shared\", \"10\")\n\n with nt_server.expect_changes(3):\n ct2.putString(\"Client2Only\", \"12\")\n ct2.putString(\"SC2Shared\", \"12\")\n ct2.putString(\"ClientShared\", \"12\")\n\n with nt_server.expect_changes(3):\n with nt_client.expect_changes(3):\n with nt_client2.expect_changes(3):\n nt_client.start_test()\n\n check_results(\n st,\n ct1,\n ct2,\n ServerOnly=10,\n Client1Only=11,\n Client2Only=12,\n SC1Shared=11,\n SC2Shared=12,\n ClientShared=11,\n )","def test_setup_multiple_parameters_system():\n with mmtools.utils.temporary_directory() as tmp_dir:\n yaml_script = get_template_script(tmp_dir)\n\n # Force antechamber parametrization of benzene to output frcmod file\n exp_builder = ExperimentBuilder(yaml_script)\n exp_builder._db._setup_molecules('benzene')\n benzene_dir = exp_builder._db.get_molecule_dir('benzene')\n frcmod_path = os.path.join(benzene_dir, 'benzene.frcmod')\n benzene_path = os.path.join(benzene_dir, 'benzene.gaff.mol2')\n\n # Redefine benzene to use leaprc.gaff and benzene.frcmod\n # and set up system for hydration free energy calculation\n yaml_script['molecules'] = {\n 'benzene-frcmod': {'filepath': benzene_path,\n 'leap': {'parameters': ['leaprc.gaff', frcmod_path]}}}\n yaml_script['systems'] = {\n 'system':\n {'solute': 'benzene-frcmod', 'solvent1': 'PME', 'solvent2': 'vacuum',\n 'leap': {'parameters': 'oldff/leaprc.ff14SB'}}\n }\n del yaml_script['experiments']\n\n exp_builder = ExperimentBuilder(yaml_script)\n system_files_path = exp_builder._db.get_system('system')\n\n # Check that output exist:\n for phase in system_files_path:\n assert os.path.exists(phase.parameters_path)\n assert os.path.exists(phase.position_path)\n assert os.path.getsize(phase.parameters_path) > 0\n assert os.path.getsize(phase.position_path) > 0","def main():\n graph_alg_eq()\n graph_points()\n graph_smooth_from_pts()\n\n return GOOD_RET # success","def runAnalyticalSim(self, sim_rounds = 10**7, factor=\"mu\"):\n # create simulation agents\n M = self.getPopulationSize()\n N = self.getSampleSize()\n\n available_strategies = self.getAvailableStrategies()\n sim_agents = [Agent(available_strategies) for i in range(M)]\n tot_count = [0 for strategy in available_strategies]\n\n # count strategies in current population\n strat_count = [0 for strategy in available_strategies]\n for sim_agent in sim_agents:\n strat_count[available_strategies.index(sim_agent.getStrategy())] += 1\n\n # repeat 10 million times\n for i in range(sim_rounds):\n\n # handle each agent\n for focal_player in sim_agents:\n\n # update frequencies for avg payoffs\n self.clearFrequencies()\n for i, strategy in enumerate(available_strategies):\n self.setFrequency(strategy, strat_count[i])\n\n # option 1: random switch strategy\n mu_proba = np.random.random()\n if mu_proba <= self.getExplorationRate():\n strat_count[available_strategies.index(focal_player.getStrategy())] -= 1\n focal_player.switchToOtherAvailableStrategy()\n strat_count[available_strategies.index(focal_player.getStrategy())] += 1\n\n # option 2: choose model to (maybe) imitate\n else:\n # select model player\n model_player_index = np.random.randint(0, M-1)\n while model_player_index == sim_agents.index(focal_player):\n model_player_index = np.random.randint(0, M-1)\n model_player = sim_agents[model_player_index]\n\n # define imitation outcome\n proba_copy = self.Fermi(self.getPayoff(model_player.getStrategy()), self.getPayoff(focal_player.getStrategy()))\n proba_event = np.random.random()\n if proba_event <= proba_copy:\n strat_count[available_strategies.index(focal_player.getStrategy())] -= 1\n focal_player.setStrategy(model_player.getStrategy())\n strat_count[available_strategies.index(focal_player.getStrategy())] += 1\n\n # remember population strategies\n for i in range(len(tot_count)):\n tot_count[i] += strat_count[i]\n\n # obtain final frequency\n for i in range(len(strat_count)):\n strat_count[i] = strat_count[i] / M\n\n # obtain total frequency\n for i, strategy in enumerate(available_strategies):\n tot_count[i] = tot_count[i] / (sim_rounds * M)\n\n # export to file: strat_count (enables comparison of both results)\n self.saveResults(tot_count, \"{}\".format(self.getCase()), factor)","def test_compare_genomes_1(self):\n import_genome.compare_genomes(self.genome_pair, self.eval_flags)\n count = count_status(self.genome_pair, \"error\", \"warning\")\n with self.subTest():\n self.assertEqual(len(self.genome_pair.evaluations), 12)\n with self.subTest():\n self.assertEqual(count, 0)","def run1():\n #Reseting motors\n ResetRobot.reset_wheel_motors()\n ResetRobot.reset_attachment_motors()\n CalibrateRobot.calibrate_gyro()\n\n #mission M01 and M02 - space travel and solar panel\n M01_M02()\n \n #Mission M05- Extraction \n M05_M14()\n\n #Back to base before Gerhard (Remove comment if necessary)\n return_to_base1()\n\n # Must delete for competition.. This is to set up forklift to repeat run.\n Robot.attachment_left.on_for_rotations(-100, 8) #Raises Forklift ","def turbsim_example(): \n # run TurbSim\n from runTurbSim import runTurbSim\n\n ts = runTurbSim()\n ts.ts_exe = \"/Users/pgraf/opt/windcode-7.31.13/TurbSim/build/TurbSim_glin64\"\n ts.run_dir = \"turbsim_test_run\"\n tscase = 2\n if (tscase == 1):\n ts.ts_dir = \"TurbSimTest\"\n ts.ts_file = \"turbsim_template.inp\"\n else:\n ts.ts_dir = \"/Users/pgraf/work/wese/fatigue12-13/from_gordie/SparFAST3.orig/TurbSim\"\n ts.ts_file = \"TurbSim.inp\"\n \n tmax = 12\n ws=20.0 # wind speed\n\n ts.set_dict({\"URef\": ws, \"AnalysisTime\":tmax, \"UsableTime\":tmax})\n ts.execute()\n\n # then run FAST\n fast = runFAST()\n fast.fst_exe = \"/Users/pgraf/opt/windcode-7.31.13/build/FAST_glin64\"\n case = 2\n if (case==1):\n fast.fst_dir = \"FAST_VT/OC3_Files/\"\n fast.fst_file = \"NRELOffshrBsline5MW_Monopile_RF.fst\" \n elif case ==2:\n fast.fst_dir = \"/Users/pgraf/work/wese/fatigue12-13/from_gordie/SparFAST3.orig\"\n fast.fst_file = \"NRELOffshrBsline5MW_Floating_OC3Hywind.fst\"\n else:\n fast.fst_dir = \"InputFilesToWrite/\"\n fast.fst_file = \"NREL5MW_Monopile_Rigid.v7.02.fst\"\n\n fast.run_dir = \"tsfast_test_run_dir\" ## either abs or rel path ok\n\n # here we link turbsim -> fast\n tswind_file = os.path.join(ts.ts_dir, \"%s.wnd\" % ts.run_name)\n fast.set_wind_file(os.path.abspath(tswind_file))\n\n fast.fstDict['Vhub']=ws\n fast.fstDict['RotSpeed'] = 12.03\n fast.fstDict[\"TMax\"] = tmax\n fast.fstDict['TStart'] = 0.0\n\n fast.setOutputs(['RotPwr'])\n\n fast.execute()\n\n out = fast.getOutputValue(\"RotPwr\")\n\n print \"TurbSim example complete:\"\n print \"max power\"\n print max(out)"],"string":"[\n \"def test_1_do_valid_sim(self) :\\n self.banner(\\\"Testing if simulation gives the right percentages.\\\")\\n filename = self.find_file('project9.py')\\n self.assertIsNotNone(filename, \\\"I can't find your project file (project9.py)\\\")\\n\\n with open('logs/test_1_valid_sim.out', 'a') as log :\\n test = pexpect.spawnu('python \\\"' + filename.as_posix() + '\\\"', logfile=log, encoding='utf-8')\\n turns = random.randrange(100, 100000)\\n test.sendline(str(turns))\\n try : \\n got = test.expect(['(\\\\d+\\\\.\\\\d+)\\\\s*%'], timeout=5)\\n switch_percent = float(test.match.group(1))\\n got = test.expect(['(\\\\d+\\\\.\\\\d+)\\\\s*%'], timeout=5)\\n stay_percent = float(test.match.group(1))\\n except :\\n self.fail(\\\"The grader program failed to parse the output of your project.\\\")\\n\\n if not (64 < switch_percent < 68) :\\n self.fail('Your switch percentage ({}) is out of range.'.format(switch_percent))\\n if not (31 < stay_percent < 35) :\\n self.fail('Your stay percentage ({}) is out of range.'.format(stay_percent))\\n test.close()\",\n \"def test_run_sim_1():\\n rnd = rand.Arrivals(36, 41)\\n sim.run_sim(3, 2, 5, 6, 22, rnd)\",\n \"def run(): \\n learning_rate = 0.42\\n discount_rate = 0.15\\n initial_q_hat = 4\\n \\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n a = e.create_agent(LearningAgent, learning_rate, discount_rate, initial_q_hat) # create agent\\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0, display=False) # create simulator (uses pygame when display=True, if available)\\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\\n\\n sim.run(n_trials=100) # run for a specified number of trials\\n print \\\"Failed trials: \\\"\\n print a.get_failed_trials()\\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\",\n \"def test_single_game_works(self):\\n sim = ss.Simulation(seed=154)\\n game1 = sim.single_game()\\n sim = ss.Simulation(seed=79)\\n game2 = sim.single_game()\\n assert game1 != game2, 'Your method single_game is not working.'\",\n \"def testSimCompletes(self):\\n sim = Simulation()\\n self.assertEqual(25, sim.run_simple(1, 11, \\\"output\\\", 0.1, 2, 10))\",\n \"def test_run_sim():\\n rnd = rand.Arrivals(31, 40)\\n sim.run_sim(2, 1, 3, 4, 24, rnd)\",\n \"def test_simulation(self):\\n\\t\\tprint \\\"Simulation is being tested\\\"\\n\\n\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\tprint \\\"Debug Flag Set!\\\"\\n\\t\\t\\tprint self.getConfig()\\n\\n\\t\\tif toggles.PACKING:\\n\\t\\t\\ttoggles.OUTPUT_PATH = toggles.OUTPUT_PATH+toggles.RUN_NAME+'/'\\n\\t\\t\\tpackageMaker(toggles.OUTPUT_PATH,self.getConfig())\\n\\t\\tif toggles.IDEAL_GRID:\\n\\t\\t\\tself.consensusGrid()\\n\\n\\t\\tif toggles.REAL_DATA:\\n\\t\\t\\tsampleData = self.load_data()\\n\\t\\t\\tif toggles.RUN_DATA_STATS:\\n\\t\\t\\t\\tself.output_data_stats(sampleData)\\n\\t\\t\\t\\tself.reset_database()\\n\\t\\t\\tif toggles.RUN_AVERAGE_COST:\\n\\t\\t\\t\\tself.sim_average_cost(sampleData)\\n\\t\\t\\t\\tself.reset_database()\\n\\t\\t\\tif toggles.RUN_SINGLE_PAIR:\\n\\t\\t\\t\\tself.sim_single_pair_cost(sampleData, pending_eddy(self.pick_worker([0], [0])))\\n\\t\\t\\t\\tself.reset_database()\\n\\t\\telse:\\n\\t\\t\\tsampleData = {}\\n\\t\\t\\tsyn_load_data()\\n\\n\\t\\tif toggles.RUN_ITEM_ROUTING and not (toggles.RUN_TASKS_COUNT or toggles.RUN_MULTI_ROUTING):\\n\\t\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\t\\tprint \\\"Running: item Routing\\\"\\n\\t\\t\\tself.run_sim(deepcopy(sampleData))\\n\\t\\t\\tself.reset_database()\\n\\n\\t\\tif PRED_SCORE_COUNT and not (RUN_TASKS_COUNT or RUN_MULTI_ROUTING):\\n\\t\\t\\tif DEBUG_FLAG:\\n\\t\\t\\t\\tprint \\\"Running: Pred Score count\\\"\\n\\t\\t\\tself.run_sim(sampleData)\\n\\t\\t\\tself.reset_database()\\n\\n\\n\\n\\t\\tif toggles.COUNT_TICKETS and not (toggles.RUN_TASKS_COUNT or toggles.RUN_MULTI_ROUTING):\\n\\t\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\t\\tprint \\\"Running: ticket counting\\\"\\n\\t\\t\\tself.run_sim(deepcopy(sampleData))\\n\\t\\t\\tself.reset_database()\\n\\n\\t\\tif toggles.SELECTIVITY_GRAPH and not (toggles.RUN_TASKS_COUNT or toggles.RUN_MULTI_ROUTING):\\n\\t\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\t\\tprint \\\"Running: selectivity amounts over time\\\"\\n\\t\\t\\tself.run_sim(sampleData)\\n\\t\\t\\tself.reset_database()\\n\\n\\t\\t#____FOR LOOKING AT ACCURACY OF RUNS___#\\n\\t\\tif toggles.TEST_ACCURACY and toggles.REAL_DATA:\\n\\t\\t\\tcorrectAnswers = self.get_correct_answers(toggles.INPUT_PATH + toggles.ITEM_TYPE + '_correct_answers.csv')\\n\\t\\t\\tpassedItems = self.get_passed_items(correctAnswers)\\n\\n\\n\\t\\tif toggles.RUN_OPTIMAL_SIM:\\n\\t\\t\\tcountingArr=[]\\n\\t\\t\\tself.reset_database()\\n\\t\\t\\tfor i in range(toggles.NUM_SIM):\\n\\t\\t\\t\\tprint \\\"running optimal_sim \\\" +str(i)\\n\\t\\t\\t\\tself.num_tasks = self.optimal_sim(sampleData)\\n\\t\\t\\t\\tcountingArr.append(self.num_tasks)\\n\\t\\t\\t\\tself.reset_database()\\n\\t\\t\\tdest = toggles.OUTPUT_PATH+toggles.RUN_NAME+'_optimal_tasks'\\n\\t\\t\\tgeneric_csv_write(dest+'.csv',[countingArr])\\n\\t\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\t\\tprint \\\"Wrote File: \\\" + dest+'.csv'\\n\\n\\n\\n\\t\\tif toggles.RUN_TASKS_COUNT or toggles.RUN_MULTI_ROUTING or toggles.RUN_CONSENSUS_COUNT:\\n\\t\\t\\tif toggles.RUN_TASKS_COUNT:\\n\\t\\t\\t\\t#print \\\"Running: task_count\\\"\\n\\t\\t\\t\\t#f = open(toggles.OUTPUT_PATH + toggles.RUN_NAME + '_tasks_count.csv', 'a')\\n\\t\\t\\t\\t#f1 = open(toggles.OUTPUT_PATH + toggles.RUN_NAME + '_incorrect_count.csv', 'a')\\n\\n\\t\\t\\t\\tif toggles.GEN_GRAPHS:\\n\\t\\t\\t\\t\\toutputArray = []\\n\\n\\t\\t\\trunTasksArray = []\\n\\t\\t\\tgoodArray, badArray = [], []\\n\\t\\t\\tgoodPoints, badPoints = [], []\\n\\t\\t\\taccCount = []\\n\\t\\t\\tlocArray = [[],[],[],[]]\\n\\n\\t\\t\\tfor i in range(toggles.NUM_SIM):\\n\\t\\t\\t\\tprint \\\"running simulation \\\" + str(i+1)\\n\\t\\t\\t\\tself.run_sim(deepcopy(sampleData))\\n\\t\\t\\t\\trunTasksArray.append(self.num_tasks)\\n\\n\\t\\t\\t\\t#____FOR LOOKING AT ACCURACY OF RUNS___#\\n\\t\\t\\t\\tif toggles.TEST_ACCURACY and toggles.REAL_DATA:\\n\\t\\t\\t\\t\\tnum_incorrect = self.final_item_mismatch(passedItems)\\n\\t\\t\\t\\t\\taccCount.append(num_incorrect)\\n\\t\\t\\t\\tif toggles.RUN_CONSENSUS_COUNT or toggles.VOTE_GRID:\\n\\t\\t\\t\\t\\tdonePairs = IP_Pair.objects.filter(Q(num_no__gt=0)|Q(num_yes__gt=0))\\n\\t\\t\\t\\t\\tif toggles.TEST_ACCURACY:\\n\\t\\t\\t\\t\\t\\tgoodPairs, badPairs = [], []\\n\\t\\t\\t\\t\\t\\tfor pair in donePairs:\\n\\t\\t\\t\\t\\t\\t\\tval = bool((pair.num_yes-pair.num_no)>0)\\n\\t\\t\\t\\t\\t\\t\\tif toggles.REAL_DATA:\\n\\t\\t\\t\\t\\t\\t\\t\\tcorrect = ((correctAnswers[(pair.item,pair.predicate)]) == val)\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tcorrect = (pair.true_answer == val)\\n\\t\\t\\t\\t\\t\\t\\tif correct:\\n\\t\\t\\t\\t\\t\\t\\t\\tgoodArray.append(pair.num_no+pair.num_yes)\\n\\t\\t\\t\\t\\t\\t\\t\\tgoodPoints.append((pair.num_no,pair.num_yes))\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tbadArray.append(pair.num_no+pair.num_yes)\\n\\t\\t\\t\\t\\t\\t\\t\\tbadPoints.append((pair.num_no,pair.num_yes))\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tfor pair in donePairs:\\n\\t\\t\\t\\t\\t\\t\\tgoodArray.append(pair.num_no + pair.num_yes)\\n\\t\\t\\t\\t\\t\\t\\tgoodPoints.append((pair.num_no,pair.num_yes))\\n\\n\\t\\t\\t\\t\\t#print \\\"This is number of incorrect items: \\\", num_incorrect\\n\\n\\t\\t\\t\\tself.reset_database()\\n\\n\\t\\t\\tif toggles.RUN_TASKS_COUNT:\\n\\t\\t\\t\\tgeneric_csv_write(toggles.OUTPUT_PATH+toggles.RUN_NAME+'_tasks_count.csv',[runTasksArray])\\n\\t\\t\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\t\\t\\tprint \\\"Wrote File: \\\" + toggles.OUTPUT_PATH + toggles.RUN_NAME + '_tasks_count.csv'\\n\\t\\t\\t\\tif toggles.GEN_GRAPHS:\\n\\t\\t\\t\\t\\tif len(runTasksArray)>1:\\n\\t\\t\\t\\t\\t\\tdest = toggles.OUTPUT_PATH + toggles.RUN_NAME + '_tasks_count.png'\\n\\t\\t\\t\\t\\t\\ttitle = toggles.RUN_NAME + ' Cost distribution'\\n\\t\\t\\t\\t\\t\\thist_gen(runTasksArray, dest, labels = ('Cost','Frequency'), title = title)\\n\\t\\t\\t\\t\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\t\\t\\t\\t\\tprint \\\"Wrote File: \\\" + dest\\n\\t\\t\\t\\t\\telif toggles.DEBUG_FLAG:\\n\\t\\t\\t\\t\\t\\tprint \\\"only ran one sim, not running hist_gen\\\"\\n\\n\\t\\t\\tif toggles.RUN_MULTI_ROUTING:\\n\\t\\t\\t\\t\\tdest = toggles.OUTPUT_PATH + toggles.RUN_NAME + '_Eddy_sys_' + str(toggles.EDDY_SYS) + '_multi_routing.png'\\n\\t\\t\\t\\t\\ttitle = toggles.RUN_NAME + ' Average Predicate Routing'\\n\\t\\t\\t\\t\\tquestions = toggles.CHOSEN_PREDS\\n\\t\\t\\t\\t\\tarrayData = []\\n\\t\\t\\t\\t\\tfor i in range(len(questions)):\\n\\t\\t\\t\\t\\t\\tarrayData.append([])\\n\\t\\t\\t\\t\\tfor routingL in ROUTING_ARRAY:\\n\\t\\t\\t\\t\\t\\tfor i in range(len(questions)):\\n\\t\\t\\t\\t\\t\\t\\tarrayData[i].append(routingL[i])\\n\\t\\t\\t\\t\\tmrsavefile = open(toggles.OUTPUT_PATH+toggles.RUN_NAME+'_multi_routing.csv','w')\\n\\t\\t\\t\\t\\tmrwriter = csv.writer(mrsavefile)\\n\\t\\t\\t\\t\\tmrwriter.writerow(questions)\\n\\t\\t\\t\\t\\tfor row in arrayData:\\n\\t\\t\\t\\t\\t\\tmrwriter.writerow(row)\\n\\t\\t\\t\\t\\tmrsavefile.close()\\n\\t\\t\\t\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\t\\t\\t\\tprint \\\"Wrote File: \\\"+toggles.OUTPUT_PATH+toggles.RUN_NAME+'_multi_routing.csv'\\n\\t\\t\\t\\t\\tif toggles.GEN_GRAPHS:\\n\\t\\t\\t\\t\\t\\tstats_bar_graph_gen(arrayData, questions, dest, labels = ('Predicate','# of Items Routed'), title = title)\\n\\t\\t\\t\\t\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\t\\t\\t\\t\\tprint \\\"Wrote File: \\\" + toggles.OUTPUT_PATH+toggles.RUN_NAME+'_multi_routing.png'\\n\\t\\t\\tif toggles.ACCURACY_COUNT:\\n\\t\\t\\t\\tdest = toggles.OUTPUT_PATH+toggles.RUN_NAME+'_acc_count'\\n\\t\\t\\t\\tgeneric_csv_write(dest+'.csv',[accCount])\\n\\t\\t\\t\\tif toggles.GEN_GRAPHS:\\n\\t\\t\\t\\t\\thist_gen(accCount, dest+'.png')\\n\\n\\t\\t\\tif toggles.RUN_CONSENSUS_COUNT:\\n\\t\\t\\t\\tdest = toggles.OUTPUT_PATH + toggles.RUN_NAME+'_consensus_count'\\n\\t\\t\\t\\tif len(goodArray)>1:\\n\\t\\t\\t\\t\\tif len(badArray) == 0:\\n\\t\\t\\t\\t\\t\\tgeneric_csv_write(dest+'.csv',[goodArray])\\n\\t\\t\\t\\t\\t\\t#print goodArray\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tgeneric_csv_write(dest+'.csv',[goodArray,badArray])\\n\\t\\t\\t\\t\\t\\t#print goodArray,badArray\\n\\t\\t\\t\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\t\\t\\t\\tprint \\\"Wrote File: \\\" + dest + '.csv'\\n\\t\\t\\t\\t\\tif toggles.GEN_GRAPHS:\\n\\t\\t\\t\\t\\t\\ttitle = 'Normalized Distribution of Tasks before Consensus'\\n\\t\\t\\t\\t\\t\\tlabels = ('Number of Tasks', 'Frequency')\\n\\t\\t\\t\\t\\t\\tif len(badArray) < 2:\\n\\t\\t\\t\\t\\t\\t\\thist_gen(goodArray, dest+'.png',labels=labels,title=title)\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tleg = ('Correctly Evaluated IP pairs','Incorrectly Evaluated IP pairs')\\n\\t\\t\\t\\t\\t\\t\\tmulti_hist_gen([goodArray,badArray],leg,dest+'.png',labels=labels,title=title)\\n\\t\\t\\t\\telif toggles.DEBUG_FLAG:\\n\\t\\t\\t\\t\\tprint \\\"only ran one sim, ignoring results\\\"\\n\\t\\t\\tif toggles.VOTE_GRID:\\n\\t\\t\\t\\tdest = toggles.OUTPUT_PATH + toggles.RUN_NAME+'_vote_grid'\\n\\t\\t\\t\\tif len(goodPoints)>1:\\n\\t\\t\\t\\t\\tif len(badPoints)==0:\\n\\t\\t\\t\\t\\t\\tgeneric_csv_write(dest+'.csv',goodPoints)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tgeneric_csv_write(dest+'_good.csv',goodPoints)\\n\\t\\t\\t\\t\\t\\tgeneric_csv_write(dest+'_bad.csv',badPoints)\\n\\t\\t\\t\\t\\tif toggles.GEN_GRAPHS:\\n\\t\\t\\t\\t\\t\\ttitle = \\\"Vote Grid Graph\\\"\\n\\t\\t\\t\\t\\t\\tlabels = (\\\"Number of No Votes\\\",\\\"Number of Yes Votes\\\")\\n\\t\\t\\t\\t\\t\\tif len(badPoints)==0:\\n\\t\\t\\t\\t\\t\\t\\txL,yL=zip(*goodPoints)\\n\\t\\t\\t\\t\\t\\t\\tline_graph_gen(xL,yL,dest+'.png',title=title,labels=labels,scatter=True,square=True)\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tgX,gY = zip(*goodPoints)\\n\\t\\t\\t\\t\\t\\t\\tbX,bY = zip(*badPoints)\\n\\t\\t\\t\\t\\t\\t\\tmulti_line_graph_gen((gX,bX),(gY,bY),('Correct','Incorrect'),dest+'_both.png',title=title,labels=labels,scatter=True,square=True)\\n\\t\\t\\t\\t\\t\\t\\tline_graph_gen(gX,gY,dest+'_good.png',title=title+\\\" goodPoints\\\",labels=labels,scatter=True,square=True)\\n\\t\\t\\t\\t\\t\\t\\tline_graph_gen(bX,bY,dest+'_bad.png',title=title+\\\" badPoints\\\",labels=labels,scatter=True,square=True)\\n\\t\\tif toggles.TIME_SIMS:\\n\\t\\t\\tself.timeRun(sampleData)\\n\\n\\t\\tif toggles.RUN_ABSTRACT_SIM:\\n\\t\\t\\tself.abstract_sim(sampleData, toggles.ABSTRACT_VARIABLE, toggles.ABSTRACT_VALUES)\",\n \"def main():\\n run_simulation(spectral=False, ml=False, num_procs=1)\\n run_simulation(spectral=True, ml=False, num_procs=1)\\n run_simulation(spectral=False, ml=True, num_procs=1)\\n run_simulation(spectral=True, ml=True, num_procs=1)\\n run_simulation(spectral=False, ml=True, num_procs=10)\\n run_simulation(spectral=True, ml=True, num_procs=10)\",\n \"def scenario3(sim):\\n\\n init_logging(logfile=None, debug=True)\\n second = 1000.0\\n duration = 10\\n tau_m = 20 # ms\\n cm = 1.0 # nF\\n v_reset = -60\\n cell_parameters = dict(\\n tau_m=tau_m,\\n cm=cm,\\n v_rest=-70,\\n e_rev_E=0,\\n e_rev_I=-70,\\n v_thresh=-54,\\n v_reset=v_reset,\\n tau_syn_E=5,\\n tau_syn_I=5,\\n )\\n g_leak = cm / tau_m # µS\\n\\n w_min = 0.0 * g_leak\\n w_max = 0.05 * g_leak\\n\\n r1 = 5.0\\n r2 = 40.0\\n\\n sim.setup()\\n pre = sim.Population(100, sim.SpikeSourcePoisson())\\n post = sim.Population(10, sim.IF_cond_exp())\\n\\n pre.set(duration=duration * second)\\n pre.set(start=0.0)\\n pre[:50].set(rate=r1)\\n pre[50:].set(rate=r2)\\n assert_equal(pre[49].rate, r1)\\n assert_equal(pre[50].rate, r2)\\n post.set(**cell_parameters)\\n post.initialize(v=RandomDistribution('normal', mu=v_reset, sigma=5.0))\\n\\n stdp = sim.STDPMechanism(\\n sim.SpikePairRule(tau_plus=20.0, tau_minus=20.0,\\n A_plus=0.01, A_minus=0.01),\\n sim.AdditiveWeightDependence(w_min=w_min, w_max=w_max),\\n #dendritic_delay_fraction=0.5))\\n dendritic_delay_fraction=1)\\n\\n connections = sim.Projection(pre, post, sim.AllToAllConnector(),\\n synapse_type=stdp,\\n receptor_type='excitatory')\\n\\n initial_weight_distr = RandomDistribution('uniform', low=w_min, high=w_max)\\n connections.randomizeWeights(initial_weight_distr)\\n initial_weights = connections.get('weight', format='array', gather=False)\\n # assert initial_weights.min() >= w_min\\n # assert initial_weights.max() < w_max\\n # assert initial_weights[0, 0] != initial_weights[1, 0]\\n\\n pre.record('spikes')\\n post.record('spikes')\\n post[0:1].record('v')\\n\\n sim.run(duration * second)\\n\\n actual_rate = pre.mean_spike_count() / duration\\n expected_rate = (r1 + r2) / 2\\n errmsg = \\\"actual rate: %g expected rate: %g\\\" % (actual_rate, expected_rate)\\n assert abs(actual_rate - expected_rate) < 1, errmsg\\n #assert abs(pre[:50].mean_spike_count()/duration - r1) < 1\\n #assert abs(pre[50:].mean_spike_count()/duration- r2) < 1\\n final_weights = connections.get('weight', format='array', gather=False)\\n assert initial_weights[0, 0] != final_weights[0, 0]\\n\\n try:\\n import scipy.stats\\n except ImportError:\\n raise SkipTest\\n t, p = scipy.stats.ttest_ind(initial_weights[:50, :].flat, initial_weights[50:, :].flat)\\n assert p > 0.05, p\\n t, p = scipy.stats.ttest_ind(final_weights[:50, :].flat, final_weights[50:, :].flat)\\n assert p < 0.01, p\\n assert final_weights[:50, :].mean() < final_weights[50:, :].mean()\\n sim.end()\\n return initial_weights, final_weights, pre, post, connections\",\n \"def Main():\\n numberOfPopulation = 350\\n numberOfDays = 60\\n \\n simulation = Simulation(Covid19(), numberOfPopulation, numberOfDays, \\\"Covid 19 Simulation\\\")\\n simulation.run() \\n simulation = Simulation(Ebola(), numberOfPopulation, numberOfDays, \\\"Ebola Simulation\\\")\\n simulation.run()\",\n \"def test_1_xc_run(self) :\\n self.banner(\\\"Testing if extra credit simulation gives the right percentages.\\\")\\n filename = self.find_file('project9_xc.py')\\n doors = random.randrange(10, 100)\\n switch_target = 100 * ((doors - 1) / doors)\\n stay_target = 100 * (1 / doors)\\n target_range = 2\\n \\n with open('logs/test_extra_credit.out', 'a') as log :\\n test = pexpect.spawnu('python ' + filename.as_posix() + ' {}'.format(doors), logfile=log, encoding='utf-8')\\n turns = random.randrange(200, 500)\\n test.sendline(str(turns))\\n try : \\n got = test.expect([pexpect.EOF, '(\\\\d+\\\\.\\\\d+)\\\\s*%'], timeout=5)\\n switch_percent = float(test.match.group(1))\\n got = test.expect([pexpect.EOF, '(\\\\d+\\\\.\\\\d+)\\\\s*%'], timeout=5)\\n stay_percent = float(test.match.group(1))\\n except :\\n self.fail(\\\"The grader program failed to parse the output of your project.\\\")\\n\\n if not (switch_target-target_range < switch_percent < switch_target+target_range) :\\n self.fail('Your switch percentage ({}) is out of range. It should be between {} and {}'.format(switch_percent, switch_target-target_range, switch_target+target_range))\\n if not (stay_target-target_range < stay_percent < stay_target+target_range) :\\n self.fail('Your stay percentage ({}) is out of range. It should be between {} and {}'.format(stay_percent, stay_target-target_range, stay_target+target_range))\\n test.close()\",\n \"def run_tests():\\n good_car = UnreliableCar(\\\"Good Car\\\", 100, 90)\\n bad_car = UnreliableCar(\\\"Bad Car\\\", 100, 10)\\n\\n for i in range(1, 15):\\n print(\\\"Attempting to drive {}km:\\\".format(i))\\n print(\\\"{:12} drove {:2}km\\\".format(good_car.name, good_car.drive(i)))\\n print(\\\"{:12} drove {:2}km\\\".format(bad_car.name, bad_car.drive(i)))\\n\\n \\\"\\\"\\\"final states of the cars\\\"\\\"\\\"\\n print(good_car)\\n print(bad_car)\",\n \"def run():\\n\\n for simulation in range(0, N_SIMULATIONS):\\n\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n a = e.create_agent(LearningAgent) # create agent\\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\\n # TODO: Change later enforce_deadline=True\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.001, display=False) # create simulator (uses pygame when display=True, if available)\\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\\n\\n sim.run(n_trials=N_TRIALS) # run for a specified number of trials\\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\\n\\n if simulation == N_SIMULATIONS - 1:\\n\\n with open('results.csv', 'a') as csvfile:\\n fieldnames = ['alpha', 'gamma', 'epsilon', 'success_rate', 'last_failure']\\n writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\\n\\n for index in range(0,len(simulation_rates)):\\n writer.writerow({\\n 'alpha': get_simulation_params(0)[0],\\n 'gamma': get_simulation_params(0)[1],\\n 'epsilon': get_simulation_params(0)[2],\\n 'success_rate': simulation_rates[index],\\n 'last_failure': last_errors[index]})\\n\\n\\n if N_SIMULATIONS > 1: #multiple simulation AND last simulation\\n\\n plt.figure(1)\\n\\n plt.subplot(211)\\n plt.plot(simulation_rates)\\n plt.title('Success Rate/Simulation')\\n plt.xlabel('# Simulation')\\n plt.ylabel('Success Rate')\\n\\n plt.subplot(212)\\n plt.plot(last_errors)\\n plt.title('Last failed trial per simulation')\\n plt.xlabel('# Simulation')\\n plt.ylabel('Last failed trial')\\n\\n plt.show()\",\n \"def run():\\n\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n a = e.create_agent(LearningAgent) # create agent\\n e.set_primary_agent(a, enforce_deadline=False) # specify agent to track\\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.0000001, display=False) # create simulator (uses pygame when display=True, if available)\\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\\n\\n sim.run(n_trials=100) # run for a specified number of trials\\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\\n\\n print 'alpha, gamma:', a.alpha, a.gamma\\n print 'penalties:', a.total_penalties\\n print 'total rewards:', a.total_rewards\",\n \"def main(m1=1.4, m2=0.3, r1=10, a0=100, eta=110, rel=\\\"off\\\",\\n max_time=1, out1_path=out1_path_default, out2_path=out2_path_default):\\n\\n if not (rel in (\\\"on\\\", \\\"off\\\")):\\n er(\\\"wrong rel\\\")\\n\\n if m1 < m2:\\n er('m1 must be more than m2!')\\n\\n if eta > 200:\\n er('error: eta must be less than 200!')\\n\\n if eta < 60:\\n er(\\\"error: eta must be more than 60!\\\")\\n\\n if not (m2 > 0.1 and m2 < 0.8):\\n er('error: m2 must be in (0.1, 0.8)!')\\n\\n if m2 < 0: \\n er('error: m2 must be positive!')\\n\\n if m2 > 1: \\n er('warning, mass of m1 is more than 1 M_sol so approximation of Sotani may be not valid!')\\n \\n if m1 > 2.3:\\n print('Warning, m1 have a mass of BH!')\\n\\n \\n with open(out1_path, 'w') as out1:\\n with open(out2_path, 'w') as out2:\\n res1, res2 = run(m1=m1, m2=m2, r1=r1, a0=a0, eta=eta, rel=rel, max_time=max_time)\\n write_res(res1, out1)\\n write_res(res2, out2)\",\n \"def test_variability(self):\\n # some reproducible arbitrariness\\n np.random.seed(343143)\\n\\n n = 10\\n t_max = 20.0\\n dt = 0.1\\n G = RandomLayer(n)\\n\\n M1 = simulation.EventMonitor(G)\\n\\n sim1 = simulation.Simulation(G, M1, dt=dt)\\n sim1.run(t_max)\\n \\n M2 = simulation.EventMonitor(G)\\n sim2 = simulation.Simulation(G, M2, dt=dt)\\n sim2.run(t_max)\\n\\n self.assertNotEqual(len(M1.t), 0)\\n self.assertNotEqual(len(M2.t), 0)\\n self.assertNotEqual(M1.t, M2.t)\",\n \"def simulationTwoDrugsDelayedTreatment():\\n\\n # TODO\",\n \"def test_tuple_synapses(self):\\n # reproducible arbitrariness\\n np.random.seed(5003)\\n\\n self.conductor.out_step = np.random.randn(self.Nc)\\n self.tutor.out_step = np.random.randn(self.Ns)\\n\\n self.rule.alpha = 1.0\\n self.rule.beta = 1.5\\n\\n tmax = 10*self.dt\\n\\n W0 = np.copy(self.syns.W)\\n\\n sim1 = simulation.Simulation(self.conductor, self.student, self.tutor,\\n self.syns, self.rule, dt=self.dt)\\n sim1.run(tmax)\\n\\n final1 = np.copy(self.syns.W)\\n\\n self.syns.W = np.copy(W0)\\n\\n rule2 = SuperExponentialPlasticity(\\n (self.syns.source, self.syns.target, self.syns.W),\\n self.tutor, constrain_positive=False, rate=1-6)\\n rule2.alpha = 1.0\\n rule2.beta = 1.5\\n\\n sim2 = simulation.Simulation(self.conductor, self.student, self.tutor,\\n self.syns, rule2, dt=self.dt)\\n sim2.run(tmax)\\n\\n final2 = np.copy(self.syns.W)\\n\\n self.assertTrue(np.allclose(final1, final2))\",\n \"def test_single_game_seed_works(self):\\n sim = ss.Simulation(seed=23)\\n game1 = sim.single_game()\\n sim = ss.Simulation(seed=23)\\n game2 = sim.single_game()\\n assert game1 == game2, 'Your seed in Simulation class is not working.'\",\n \"def test_run_simplega():\\n WRFga_winner = run_simplega(pop_size=100, n_generations=1, testing=True)\\n assert WRFga_winner.Fitness >= 0\",\n \"def testSimpleErrorsTimeCompletion(self):\\n sim = Simulation()\\n with self.assertRaises(RuntimeError):\\n sim.run_simple(30, 11, \\\"output\\\", 0.1, 2, 10)\",\n \"def test_tuple_synapses(self):\\n # reproducible arbitrariness\\n np.random.seed(5003)\\n\\n self.conductor.out_step = np.random.randn(self.Nc)\\n self.tutor.out_step = np.random.randn(self.Ns)\\n\\n self.rule.alpha = 1.0\\n self.rule.beta = 1.5\\n\\n tmax = 10*self.dt\\n\\n W0 = np.copy(self.syns.W)\\n\\n sim1 = simulation.Simulation(self.conductor, self.student, self.tutor,\\n self.syns, self.rule, dt=self.dt)\\n sim1.run(tmax)\\n\\n final1 = np.copy(self.syns.W)\\n\\n self.syns.W = np.copy(W0)\\n\\n rule2 = TwoExponentialsPlasticity(\\n (self.syns.source, self.syns.target, self.syns.W),\\n self.tutor, constrain_positive=False, rate=1-6)\\n rule2.alpha = 1.0\\n rule2.beta = 1.5\\n\\n sim2 = simulation.Simulation(self.conductor, self.student, self.tutor,\\n self.syns, rule2, dt=self.dt)\\n sim2.run(tmax)\\n\\n final2 = np.copy(self.syns.W)\\n\\n self.assertTrue(np.allclose(final1, final2))\",\n \"def run():\\n\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n a = e.create_agent(LearningAgent) # create agent\\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.001, display=True) # create simulator (uses pygame when display=True, if available)\\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\\n\\n sim.run(n_trials=100) # run for a specified number of trials\\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\",\n \"def test_MasterEquation_simulateDynamicSloution(self,\\n plot_figures=False,\\n verbose=False,\\n ):\\n\\n do_test_1 = True\\n do_test_2 = True\\n do_test_3 = True\\n do_test_4 = True\\n do_test_5 = True\\n do_test_6 = True\\n\\n if do_test_1:\\n print(\\\"Test 1 running\\\")\\n ## test 1:\\n\\n # instanciate a MasterEquationSolver\\n mes = HaPPPy.MasterEquation.MasterEquationSolver()\\n # parameters of this tets:\\n ε = mes.getε()\\n δ = 1E-2\\n a = 1 # > 0\\n p0 = 0.1 # > 0\\n p1 = 0.7 # > 0\\n p2 = 0.2 # > 0, p0 + p1 + p2 = 1\\n Δt = 1\\n t_max = 100 # >= plot_stop, plot_start\\n plot_start = 0\\n plot_stop = 20\\n plot_step = 1\\n # set-up a reasonable Γ-matrix\\n Γ_L = np.array([[0, a, 0], [0, 0, 0], [0, 0, 0]])\\n Γ_R = np.array([[0, 0, 0], [0, 0, 0], [0, 0, 0]])\\n ns = [1, 2]\\n # choose a legitimate start value for P_0 (P_0 = P(t=0))\\n P_0 = np.array([p0, p1, p2])\\n # simulate\\n sim_tdp, sim_cur = mes.simulateDynamicSloution(\\n Δt, t_max, P_0, Γ_L, Γ_R, ns, verbose=verbose\\n )\\n stat_ps, stat_curs = mes.calculateStationarySolutions(\\n Γ_L, Γ_R, ns, verbose=verbose\\n )\\n # plot result\\n if plot_figures:\\n sim_tdp.quickPlot(x_symbol=\\\"t\\\", y_symbol=\\\"P\\\",\\n start=plot_start,\\n stop=plot_stop,\\n step=plot_step,\\n )\\n sim_cur.quickPlot(x_symbol=\\\"t\\\", y_symbol=\\\"I\\\",\\n legend=[\\\"$I^L$\\\",\\\"$I^R$\\\"],\\n start=plot_start,\\n stop=plot_stop,\\n step=plot_step,\\n )\\n # check validity\\n self.assertTrue(sim_tdp.valid())\\n self.assertTrue(sim_cur.valid())\\n # check development of porpabilities\\n Ps = sim_tdp.getValues()\\n # a. check conservation of total probability\\n for P in Ps:\\n self.assertTrue(1 - ε <= sum(P) <= 1 + ε)\\n # b. check values after a 'long' time period\\n # expected: propability of state 1 'shifts' to state 2\\n # state 3 is constant\\n self.assertTrue(abs(Ps[t_max][0] - (p0 + p1)) <= δ)\\n self.assertTrue(abs(Ps[t_max][1]) <= δ)\\n self.assertTrue(abs(Ps[t_max][2] - p2) <= ε)\\n print(\\\"Test 1 OK\\\")\\n\\n if do_test_2:\\n print(\\\"Test 2 running\\\")\\n ## test 2:\\n\\n # instanciate a MasterEquationSolver\\n mes = HaPPPy.MasterEquation.MasterEquationSolver()\\n # parameters of this tets:\\n ε = mes.getε()\\n δ = 1E-2\\n f = 2.0 # fraction of P_1 to P_0 in equilibrium\\n a = 0.5 # > 0\\n p0 = 0.3 # > 0\\n p1 = 0.7 # > 0, p0 + p1 = 1\\n Δt = 1\\n t_max = 100\\n # set-up a reasonable Γ-matrix\\n Γ_L = np.array([[0, a], [0, 0]])\\n Γ_R = f * Γ_L.transpose()\\n ns = [1, 1]\\n # choose a legitimate start value for P_0 (P_0 = P(t=0))\\n P_0 = np.array([p0, p1])\\n # simulate\\n sim_tdp, sim_cur = mes.simulateDynamicSloution(\\n Δt, t_max, P_0, Γ_L, Γ_R, ns, verbose=verbose\\n )\\n stat_ps, stat_curs = mes.calculateStationarySolutions(\\n Γ_L, Γ_R, ns, verbose=verbose\\n )\\n # plot result\\n if plot_figures:\\n sim_tdp.quickPlot(x_symbol=\\\"t\\\", y_symbol=\\\"P\\\",\\n title=(\\\"P_stat = \\\" + str(stat_ps)),\\n )\\n sim_cur.quickPlot(x_symbol=\\\"t\\\", y_symbol=\\\"I\\\",\\n title=(\\\"I_stat = \\\" + str(stat_curs)),\\n legend=[\\\"$I^L$\\\",\\\"$I^R$\\\"],\\n )\\n # check validity\\n self.assertTrue(sim_tdp.valid())\\n self.assertTrue(sim_cur.valid())\\n # check development of porpabilities\\n Ps = sim_tdp.getValues()\\n # a. check conservation of total probability\\n for P in Ps:\\n self.assertTrue(1 - ε <= sum(P) <= 1 + ε)\\n # b. check values after a 'long' time period\\n # expected: propability of state 1 'shifts' to state 2\\n # state 3 is constant\\n self.assertTrue(abs(f * Ps[t_max][0] - Ps[t_max][1]) <= δ)\\n print(\\\"Test 2 OK\\\")\\n\\n if do_test_3:\\n print(\\\"Test 3 running\\\")\\n ## test 3:\\n # symmetric Γ = Γ_L - Γ_R --> uniform distibution of propability\\n\\n # instanciate a MasterEquationSolver\\n mes = HaPPPy.MasterEquation.MasterEquationSolver()\\n # parameters of this tets:\\n ε = mes.getε()\\n Δt = 1\\n t_max = 100\\n n = 50\\n # set-up a reasonable Γ-matrix\\n Γ_L = np.array([[(i + j)/n**2 for j in range(n)] for i in range(n)])\\n Γ_R = 2 * Γ_L\\n ns = [1] * n\\n # choose a legitimate start value for P_0 (P_0 = P(t=0))\\n P_0 = np.array([i for i in range(n)])\\n P_0 = P_0 / sum(P_0)\\n # simulate\\n sim_tdp, sim_cur = mes.simulateDynamicSloution(\\n Δt, t_max, P_0, Γ_L, Γ_R, ns, verbose=verbose\\n )\\n stat_ps, stat_curs = mes.calculateStationarySolutions(\\n Γ_L, Γ_R, ns, verbose=verbose\\n )\\n # plot result\\n if plot_figures:\\n sim_tdp.quickPlot(x_symbol=\\\"t\\\", y_symbol=\\\"P\\\")\\n sim_cur.quickPlot(x_symbol=\\\"t\\\", y_symbol=\\\"I\\\",\\n legend=[\\\"$I^L$\\\",\\\"$I^R$\\\"],\\n )\\n # check validity\\n self.assertTrue(sim_tdp.valid())\\n self.assertTrue(sim_cur.valid())\\n # check development of porpabilities\\n Ps = sim_tdp.getValues()\\n # a. check conservation of total probability\\n for P in Ps:\\n self.assertTrue(1 - ε <= sum(P) <= 1 + ε)\\n # b. check values after a 'long' time period\\n # expected: uniform distribution\\n for P_i in Ps[t_max]:\\n self.assertTrue(1/n - ε <= P_i <= 1/n + ε)\\n print(\\\"Test 3 OK\\\")\\n\\n if do_test_4:\\n print(\\\"Test 4 running\\\")\\n ## test 4:\\n\\n # instanciate a MasterEquationSolver\\n mes = HaPPPy.MasterEquation.MasterEquationSolver()\\n # parameters of this tets:\\n ε = mes.getε()\\n Δt = 1\\n t_max = 10\\n n = 3\\n # set-up a reasonable Γ-matrix\\n Γ_L = np.zeros((n, n))\\n Γ_R = np.zeros((n, n))\\n ns = [1] * n\\n # choose a legitimate start value for P_0 (P_0 = P(t=0))\\n P_0 = np.array([i for i in range(n)])\\n P_0 = P_0 / sum(P_0)\\n # simulate\\n sim_tdp, sim_cur = mes.simulateDynamicSloution(\\n Δt, t_max, P_0, Γ_L, Γ_R, ns, verbose=verbose\\n )\\n stat_ps, stat_curs = mes.calculateStationarySolutions(\\n Γ_L, Γ_R, ns, verbose=verbose\\n )\\n # plot result\\n if plot_figures:\\n sim_tdp.quickPlot(x_symbol=\\\"t\\\", y_symbol=\\\"P\\\")\\n sim_cur.quickPlot(x_symbol=\\\"t\\\", y_symbol=\\\"I\\\",\\n legend=[\\\"$I^L$\\\",\\\"$I^R$\\\"],\\n )\\n # check validity\\n self.assertTrue(sim_tdp.valid())\\n self.assertTrue(sim_cur.valid())\\n # check development of porpabilities\\n Ps = sim_tdp.getValues()\\n # a. check conservation of individual probabilities\\n for P in Ps:\\n self.assertTrue(-ε <= sum(abs(P - P_0)) <= ε)\\n # check current\\n Is = sim_cur.getValues()\\n # a. check if current is constntly 0\\n for I in Is:\\n self.assertTrue((abs(I) <= ε).all())\\n print(\\\"Test 4 OK\\\")\\n\\n if do_test_5:\\n print(\\\"Test 5 running\\\")\\n ## test 5:\\n # test tolerance behaviour\\n\\n # parameters of this tets:\\n ε = 1E-100 # ridiculously precise\\n Δt = 1\\n t_max = 100\\n n = 10\\n # set-up a reasonable Γ-matrix\\n Γ_L = np.array([[(i + j)/n**2 for j in range(n)] for i in range(n)])\\n Γ_R = 2 * Γ_L\\n ns = [1] * n\\n # choose a legitimate start value for P_0 (P_0 = P(t=0))\\n P_0 = np.array([i for i in range(n)])\\n P_0 = P_0 / sum(P_0)\\n # instanciate a MasterEquationSolver\\n mes = HaPPPy.MasterEquation.MasterEquationSolver(ε=ε)\\n # simulate\\n sim_tdp, sim_cur = mes.simulateDynamicSloution(\\n Δt, t_max, P_0, Γ_L, Γ_R, ns, verbose=verbose\\n )\\n stat_ps, stat_curs = mes.calculateStationarySolutions(\\n Γ_L, Γ_R, ns, verbose=verbose\\n )\\n # plot result\\n if plot_figures:\\n sim_tdp.quickPlot(x_symbol=\\\"t\\\", y_symbol=\\\"P\\\")\\n sim_cur.quickPlot(x_symbol=\\\"t\\\", y_symbol=\\\"I\\\",\\n legend=[\\\"$I^L$\\\",\\\"$I^R$\\\"],\\n )\\n # check validity\\n self.assertTrue(not sim_tdp.valid())\\n self.assertTrue(not sim_cur.valid())\\n print(\\\"Test 5 OK\\\")\\n\\n if do_test_6:\\n print(\\\"Test 6 running\\\")\\n ## test 6:\\n # test if algorith can handle large inputs\\n # (like test 2 but with large n to test accuracy)\\n\\n # instanciate a MasterEquationSolver\\n mes = HaPPPy.MasterEquation.MasterEquationSolver()\\n # parameters of this tets:\\n ε = mes.getε()\\n Δt = 1\\n t_max = 100\\n n = 100\\n # set-up a reasonable Γ-matrix\\n Γ_L = np.array([[(i + j)/n**2 for j in range(n)] for i in range(n)])\\n Γ_R = 2 * Γ_L\\n ns = [1] * n\\n # choose a legitimate start value for P_0 (P_0 = P(t=0))\\n P_0 = np.array([i for i in range(n)])\\n P_0 = P_0 / sum(P_0)\\n # simulate\\n sim_tdp, sim_cur = mes.simulateDynamicSloution(\\n Δt, t_max, P_0, Γ_L, Γ_R, ns, verbose=verbose\\n )\\n stat_ps, stat_curs = mes.calculateStationarySolutions(\\n Γ_L, Γ_R, ns, verbose=verbose\\n )\\n # check validity\\n self.assertTrue(sim_tdp.valid())\\n self.assertTrue(sim_cur.valid())\\n # check development of porpabilities\\n Ps = sim_tdp.getValues()\\n # a. check conservation of total probability\\n for P in Ps:\\n self.assertTrue(1 - ε <= sum(P) <= 1 + ε)\\n # b. check values after a 'long' time period\\n # expected: uniform distribution\\n for P_i in Ps[t_max]:\\n self.assertTrue(1/n - ε <= P_i <= 1/n + ε)\\n print(\\\"Test 6 OK\\\")\",\n \"def run():\\n\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n a = e.create_agent(LearningAgent) # create agent\\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.00000001, display=False) # create simulator (uses pygame when display=True, if available)\\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\\n\\n sim.run(n_trials=100) # run for a specified number of trials\\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\",\n \"def generate_scenario_1(seed=1996, permanent_save=True, sigma_process=0.01, sigma_meas_radar=3, sigma_meas_ais=1):\\n # specify seed to be able repeat example\\n start_time = datetime.now()\\n\\n np.random.seed(seed)\\n\\n # combine two 1-D CV models to create a 2-D CV model\\n transition_model = CombinedLinearGaussianTransitionModel([ConstantVelocity(sigma_process),\\n ConstantVelocity(sigma_process)])\\n\\n # starting at 0,0 and moving NE\\n truth = GroundTruthPath([GroundTruthState([0, 1, 0, 1], timestamp=start_time)])\\n\\n # generate truth using transition_model and noise\\n for k in range(1, 21):\\n truth.append(GroundTruthState(\\n transition_model.function(truth[k - 1], noise=True, time_interval=timedelta(seconds=1)),\\n timestamp=start_time + timedelta(seconds=k)))\\n\\n # Simulate measurements\\n # Specify measurement model for radar\\n measurement_model_radar = LinearGaussian(\\n ndim_state=4, # number of state dimensions\\n mapping=(0, 2), # mapping measurement vector index to state index\\n noise_covar=np.array([[sigma_meas_radar, 0], # covariance matrix for Gaussian PDF\\n [0, sigma_meas_radar]])\\n )\\n\\n # Specify measurement model for AIS\\n measurement_model_ais = LinearGaussian(\\n ndim_state=4,\\n mapping=(0, 2),\\n noise_covar=np.array([[sigma_meas_ais, 0],\\n [0, sigma_meas_ais]])\\n )\\n\\n # generate \\\"radar\\\" measurements\\n measurements_radar = []\\n for state in truth:\\n measurement = measurement_model_radar.function(state, noise=True)\\n measurements_radar.append(Detection(measurement, timestamp=state.timestamp))\\n\\n # generate \\\"AIS\\\" measurements\\n measurements_ais = []\\n state_num = 0\\n for state in truth:\\n state_num += 1\\n if not state_num % 2: # measurement every second time step\\n measurement = measurement_model_ais.function(state, noise=True)\\n measurements_ais.append(Detection(measurement, timestamp=state.timestamp))\\n\\n if permanent_save:\\n save_folder_name = seed.__str__()\\n else:\\n save_folder_name = \\\"temp\\\"\\n\\n save_folder = \\\"../scenarios/scenario1/\\\" + save_folder_name + \\\"/\\\"\\n\\n # save the ground truth and the measurements for the radar and the AIS\\n store_object.store_object(truth, save_folder, \\\"ground_truth.pk1\\\")\\n store_object.store_object(measurements_radar, save_folder, \\\"measurements_radar.pk1\\\")\\n store_object.store_object(measurements_ais, save_folder, \\\"measurements_ais.pk1\\\")\\n store_object.store_object(start_time, save_folder, \\\"start_time.pk1\\\")\\n store_object.store_object(measurement_model_radar, save_folder, \\\"measurement_model_radar.pk1\\\")\\n store_object.store_object(measurement_model_ais, save_folder, \\\"measurement_model_ais.pk1\\\")\\n store_object.store_object(transition_model, save_folder, \\\"transition_model.pk1\\\")\",\n \"def run():\\n trials = 100\\n\\n multipliers = [0.25, 0.3, 0.35, 0.5, 0.75, 1, 1.25, 1.45, 1.5, 1.55, 1.6] # Coefficients for learning rate\\n\\n mean_penalty = []\\n median_penalty = []\\n std_penalty = []\\n\\n mean_trial_time = []\\n median_trial_time = []\\n std_trial_time = []\\n\\n mean_success_rate = []\\n median_success_rate = []\\n std_success_rate = []\\n\\n for m in multipliers:\\n all_penalties = [] # All penalties from trail sets\\n all_average_trial_time = []\\n all_success_rates = []\\n\\n for i in range(0, 20):\\n # print \\\"Trial set:\\\", i\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n agent = e.create_agent(LearnerAgent) # create agent\\n agent.mult = m\\n e.set_primary_agent(agent, enforce_deadline=True) # specify agent to track\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.0, display=False) # create simulator (uses pygame when display=True, if available)\\n\\n sim.run(n_trials=trials) # run for a specified number of trials\\n\\n all_penalties.append(agent.all_trails_penalties)\\n all_average_trial_time.append(agent.time/float(trials))\\n all_success_rates.append(float(trials-agent.aborted_trials)/trials)\\n\\n mean_penalty.append(np.mean(all_penalties))\\n median_penalty.append(np.median(all_penalties))\\n std_penalty.append(np.std(all_penalties))\\n\\n mean_trial_time.append(np.mean(all_average_trial_time))\\n median_trial_time.append(np.median(all_average_trial_time))\\n std_trial_time.append(np.std(all_average_trial_time))\\n\\n mean_success_rate.append(np.mean(all_success_rates))\\n median_success_rate.append(np.median(all_success_rates))\\n std_success_rate.append(np.std(all_success_rates))\\n\\n for i in range(0, len(multipliers)):\\n print \\\"\\\"\\n print \\\"Multiplier:\\\", multipliers[i]\\n print \\\"\\\"\\n print \\\"Mean penalty per {} trials:\\\".format(trials), mean_penalty[i]\\n print \\\"Median penalty per {} trials:\\\".format(trials), median_penalty[i]\\n print \\\"Std.Dev. penalty per {} trials:\\\".format(trials), std_penalty[i]\\n\\n print \\\"\\\"\\n print \\\"Mean trial time:\\\", mean_trial_time[i]\\n print \\\"Median trial time:\\\", median_trial_time[i]\\n print \\\"Std.Dev. trial time:\\\", std_trial_time[i]\\n\\n print \\\"\\\"\\n print \\\"Mean success rate per {} trials:\\\".format(trials), mean_success_rate[i]\\n print \\\"Median success rate per {} trials:\\\".format(trials), median_success_rate[i]\\n print \\\"Std.Dev. success rate per {} trials:\\\".format(trials), std_success_rate[i]\",\n \"def test(simulation=False):\\n\\tsimulation = False\\n\\tif simulation:\\n\\t\\tdyn.enable_vrep()\\n\\t\\n\\tctrl = init_ctrl()\\n\\n\\tif simulation:\\n\\t\\tpeter = SymbiotSpidey(ctrl)\\n\\telse:\\n\\t\\tpeter = Spidey(ctrl)\\n\\n\\tif simulation:\\n\\t\\tctrl.start_sim()\\n\\n\\tpeter.compliant = False\\n\\tprint peter.legs_references\\n\\n\\tleg = peter.legs[0]\\n\\tpos = leg.position()\\n\\tpos = Vector3D(pos.x+6, pos.y, pos.z)\\n\\tleg.move(pos)\\n\\tctrl.wait(200)\\n\\tprint pos.x, leg.position().x, pos.x == leg.position().x\\n\\n\\tpeter.compliant = True\\n\\n\\tif simulation:\\n\\t\\tctrl.stop_sim()\",\n \"def run():\\n step = 0\\n while traci.simulation.getMinExpectedNumber() > 0:\\n traci.simulationStep()\\n step+=1\\n traci.close()\\n sys.stdout.flush()\",\n \"def run():\\n\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n a = e.create_agent(LearningAgent) # create agent\\n e.set_primary_agent(a, enforce_deadline=True) # set agent to track\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.5) # reduce update_delay to speed up simulation\\n sim.run(n_trials=100) # press Esc or close pygame window to quit\",\n \"def main():\\n\\tresults = []\\n\\n\\tconfig = configparser.ConfigParser()\\n\\tconfig.read(\\\"simulation.ini\\\")\\n\\tsettings = config['sim']\\n\\n\\tcompleted_obj_hw = int(settings[\\\"ClientsPerCampaign\\\"]) * float(settings[\\\"CompletedPctgHW\\\"])\\n\\texceeded_obj_hw = float(settings[\\\"ExceededPctgHW\\\"])\\n\\tsignificance_level = float(settings[\\\"SignificanceLevel\\\"])\\n\\tz_val_two_tails = scipy.stats.norm.ppf(1 - (significance_level / 2))\\n\\n\\tprint(\\\"Completed Target HW: \\\" + str(completed_obj_hw))\\n\\tprint(\\\"Exceeded Target HW: \\\" + str(exceeded_obj_hw))\\n\\n\\tcompleted_vals = []\\n\\texceeded_vals = []\\n\\tdone = False\\n\\n\\tcompleted_avg = 0\\n\\texceeded_avg = 0\\n\\tcompleted_hw = 0\\n\\texceeded_hw = 0\\n\\n\\ti = 0\\n\\twhile not done:\\n\\t\\tprint(\\\"RUN: \\\" + str(i + 1))\\n\\t\\tenv = simpy.Environment()\\n\\t\\tsim = Simulation(env, settings, i == 0)\\n\\t\\tsim.run()\\n\\t\\tresults.append(sim.results)\\n\\t\\ti += 1\\n\\n\\t\\tif settings['RunOnce'] == 'yes':\\n\\t\\t\\tprint(\\\"RUN ONCE\\\")\\n\\t\\t\\tsys.exit()\\n\\n\\t\\tcompleted_vals.append(sim.results['completed_count'])\\n\\t\\texceeded_vals.append(sim.results['exceeded_proportion'])\\n\\n\\t\\tif i < 2:\\n\\t\\t\\tprint(\\\"---------------\\\")\\n\\t\\t\\tcontinue\\n\\n\\t\\tcompleted_avg = sum(completed_vals) / len(completed_vals)\\n\\t\\tcompleted_S = sum([(v - completed_avg) ** 2 for v in completed_vals]) / (i - 1)\\n\\t\\tcompleted_S = math.sqrt(completed_S)\\n\\t\\tcompleted_hw = (z_val_two_tails * completed_S) / math.sqrt(i)\\n\\t\\tprint(\\\"runs: \\\" + str(i) + \\\" completed HW: \\\" + str(completed_hw))\\n\\n\\t\\texceeded_avg = sum(exceeded_vals) / len(exceeded_vals)\\n\\t\\texceeded_S = math.sqrt(exceeded_avg * (1 - exceeded_avg))\\n\\t\\texceeded_hw = (z_val_two_tails * exceeded_S) / math.sqrt(i)\\n\\t\\tprint(\\\"runs: \\\" + str(i) + \\\" exceeded HW: \\\" + str(exceeded_hw))\\n\\n\\t\\tif completed_hw < completed_obj_hw and exceeded_hw < exceeded_obj_hw:\\n\\t\\t\\tprint(\\\"END ITERATIONS\\\")\\n\\t\\t\\tdone = True\\n\\n\\t\\tprint(\\\"---------------\\\")\\n\\n\\n\\tfilename = 'results/Results_' + settings['FileSizeGB'] + '_' + settings['TorrentThreshold'] + '_' + settings['HTTPDownThreshold'] \\\\\\n\\t\\t+ '_' + settings['HTTPUp'] + '_' + str(random.randint(0,10000)) + '.xlsx'\\n\\n\\tprint(\\\"Saving XLSX to: \\\" + filename)\\n\\twb = xs.Workbook(filename)\\n\\n\\tws = wb.add_worksheet()\\n\\n\\tws.write(0, 1, 'Exceded')\\n\\tws.write(0, 2, 'Completed')\\n\\n\\ti = 1\\n\\tfor result in results:\\n\\t\\tws.write(i, 0, i)\\n\\t\\tws.write(i, 1, result['exceeded_proportion'])\\n\\t\\tws.write(i, 2, result['completed_count'])\\n\\t\\ti += 1\\n\\n\\tws.write(i, 0, 'average')\\n\\tws.write(i, 1, exceeded_avg)\\n\\tws.write(i, 2, completed_avg)\\n\\ti += 1\\n\\tws.write(i, 0, 'half width')\\n\\tws.write(i, 1, exceeded_hw)\\n\\tws.write(i, 2, completed_hw)\\n\\n\\twb.close()\",\n \"def run():\\n\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n a = e.create_agent(LearningAgent) # create agent\\n e.set_primary_agent(a, enforce_deadline=False) # set agent to track\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.0) # reduce update_delay to speed up simulation\\n sim.run(n_trials=num_of_experiments) # press Esc or close pygame window to quit\\n \\n pd.Series(a.success).to_pickle('success_' + exp_id + '.pickle')\\n a.Q_table.to_pickle('qtable_' + exp_id + '.pickle')\\n pd.Series(a.q_delta_avg).to_pickle('convergence_' + exp_id + '.pickle')\\n pd.Series(a.t_total).to_pickle('steps_' + exp_id + '.pickle')\",\n \"def run():\\n\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n a = e.create_agent(LearningAgent) # create agent\\n e.set_primary_agent(a, enforce_deadline= True ) # set agent to track\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.5) # reduce update_delay to speed up simulation\\n sim.run(n_trials=100) # press Esc or close pygame window to quit\",\n \"def generate_scenario_2(seed=1996, permanent_save=True, sigma_process=0.01, sigma_meas_radar=3, sigma_meas_ais=1,\\n timesteps=20):\\n start_time = datetime.now()\\n\\n # specify seed to be able repeat example\\n np.random.seed(seed)\\n\\n # combine two 1-D CV models to create a 2-D CV model\\n transition_model = CombinedLinearGaussianTransitionModel(\\n [ConstantVelocity(sigma_process), ConstantVelocity(sigma_process)])\\n\\n # starting at 0,0 and moving NE\\n truth = GroundTruthPath([GroundTruthState([0, 1, 0, 1], timestamp=start_time)])\\n\\n # generate truth using transition_model and noise\\n for k in range(1, timesteps):\\n truth.append(GroundTruthState(\\n transition_model.function(truth[k - 1], noise=True, time_interval=timedelta(seconds=1)),\\n timestamp=start_time + timedelta(seconds=k)))\\n\\n # Simulate measurements\\n # Specify measurement model for radar\\n measurement_model_radar = LinearGaussian(\\n ndim_state=4, # number of state dimensions\\n mapping=(0, 2), # mapping measurement vector index to state index\\n noise_covar=np.array([[sigma_meas_radar, 0], # covariance matrix for Gaussian PDF\\n [0, sigma_meas_radar]])\\n )\\n\\n # Specify measurement model for AIS (Same as for radar)\\n measurement_model_ais = LinearGaussian(\\n ndim_state=4,\\n mapping=(0, 2),\\n noise_covar=np.array([[sigma_meas_ais, 0],\\n [0, sigma_meas_ais]])\\n )\\n\\n # generate \\\"radar\\\" measurements\\n measurements_radar = []\\n for state in truth:\\n measurement = measurement_model_radar.function(state, noise=True)\\n measurements_radar.append(Detection(measurement, timestamp=state.timestamp))\\n\\n # generate \\\"AIS\\\" measurements\\n measurements_ais = []\\n for state in truth:\\n measurement = measurement_model_ais.function(state, noise=True)\\n measurements_ais.append(Detection(measurement, timestamp=state.timestamp))\\n\\n if permanent_save:\\n save_folder_name = seed.__str__()\\n else:\\n save_folder_name = \\\"temp\\\"\\n\\n save_folder = \\\"../scenarios/scenario2/\\\" + save_folder_name + \\\"/\\\"\\n\\n # save the ground truth and the measurements for the radar and the AIS\\n store_object.store_object(truth, save_folder, \\\"ground_truth.pk1\\\")\\n store_object.store_object(measurements_radar, save_folder, \\\"measurements_radar.pk1\\\")\\n store_object.store_object(measurements_ais, save_folder, \\\"measurements_ais.pk1\\\")\\n store_object.store_object(start_time, save_folder, \\\"start_time.pk1\\\")\\n store_object.store_object(measurement_model_radar, save_folder, \\\"measurement_model_radar.pk1\\\")\\n store_object.store_object(measurement_model_ais, save_folder, \\\"measurement_model_ais.pk1\\\")\\n store_object.store_object(transition_model, save_folder, \\\"transition_model.pk1\\\")\",\n \"def run_tests():\\n \\n test_constructor_positive()\\n test_constructor_negative()\\n test_game_move_positive()\\n test_game_move_negative()\\n test_game_move_edge()\\n print(\\\"Congratulations ! You passed all the game test cases.\\\")\",\n \"def simulate(): \\n \\n # Create tmpdir to hold all steerfiles and log files \\n SimObj = Simulation(steerfiles=steerfiles, name=os.path.splitext(os.path.basename(rawfile_alu))[0] + '-sim' )\\n\\n # Set Beam energy\\n SimObj.set_beam_momentum(beamenergy)\\n\\n # Create steerfiles for processing\\n simpath = create_sim_path_air(SimObj)\\n\\n # Get gearfile\\n localgearfile = SimObj.get_filename('gear.xml')\\n\\n # Misalign gear file\\n randomize_telescope(gearfile=localgearfile, mean_list=mean_list, sigma_list=sigma_list, sensorexception_list=sensorexception_list, modeexception_list=modeexception_list)\\n\\n localtruthdb_filename=SimObj.create_dbfilename(truthdb_filename)\\n\\n # Convert gear file to alignmentDB root file, which will be stored in the sim folder\\n Create_AlignmentDBFile_From_Gear(gearfile=SimObj.get_filename('gear.xml'), truthdbfilename=localtruthdb_filename)\\n\\n # Copy gearfile\\n SimObj.copy_file('gear.xml','gear_air.xml')\\n\\n # Get air gearfile\\n gearfile_air = SimObj.get_filename('gear_air.xml')\\n\\n # Change DUT in copied gearfile\\n set_parameter(gearfile=gearfile_air, sensorID=11, parametername='thickness', value=0.0001)\\n set_parameter(gearfile=gearfile_air, sensorID=11, parametername='radLength', value=304000.0)\\n\\n\\n # Create caltag for the truthdb\\n localcaltag = os.path.splitext(os.path.basename(rawfile_air))[0] + '-test'\\n simcaltag=localcaltag+ '-truthdb'\\n\\n # Run simulation to create rawfile with simulated digits \\n SimObj.simulate(path=simpath,caltag=simcaltag)\",\n \"def main():\\n moons = initialize_moons()\\n\\n # Do it again, to get a stable initial set of values to compare against.\\n initial_state = initialize_moons()\\n needed_cycles = [0] * 3\\n\\n # Because in the mechanics of this fake universe gravity and velocity in\\n # one dimension do not affect anything in the other two dimensions, we\\n # can loop altering one dimension at a time until\\n for dimension in (Position3d.X, Position3d.Y, Position3d.Z):\\n Position3d.set_dimension(dimension)\\n cycled = False\\n cycle_count = 0\\n while not cycled:\\n if cycle_count > 30000000000:\\n print(\\\"bailing!\\\")\\n break\\n cycle_count += 1\\n for moon in moons:\\n for other_moon in moons:\\n if moon is other_moon:\\n continue\\n moon.apply_gravity(other_moon)\\n for moon in moons:\\n moon.apply_velocity()\\n match = True\\n for idx, moon in enumerate(moons):\\n if moon != initial_state[idx]:\\n # Didn't complete a cycle back to original state for this\\n # dimension. Try again.\\n match = False\\n break\\n if match:\\n # Yea! Done with this dimension\\n needed_cycles[dimension] = cycle_count\\n cycled = True\\n\\n print(lcm(needed_cycles[2], lcm(needed_cycles[0], needed_cycles[1])),\\n \\\"cycles needed to loop.\\\")\\n print(\\\"Hawking would be proud.\\\")\",\n \"def simulationTwoDrugsVirusPopulations():\\n #TODO\",\n \"def run_delayed_ssa(system):\\n \\n #vars used in the simulation\\n time = 0 #unitless\\n end_time = system['sim-time']\\n species = system['participants']\\n parameters = system['parameters']\\n events = system['events']\\n prop_funcs = {}\\n exec_funcs = {}\\n props = {}\\n delays = {}\\n last_exec_time = {}\\n \\n #return values\\n time_array = []\\n species_array = []\\n \\n #populate results array\\n time_array = [time]\\n row = [0]*len(species)\\n species_names = [''] * len(species)\\n \\n #create species vars so that rate code can be executed\\n i = 0\\n for name in species:\\n species_names[i] = name\\n exec( name + '=' + str(species[name]) )\\n row[i] = species[name]\\n i += 1\\n species_array.append(row)\\n \\n #create parameter vars so that rate code can be executed\\n for name in parameters:\\n exec( name + '=' + str(parameters[name]) )\\n\\n #create (compile) functions from input strings for rates and events\\n for name in events:\\n if events[name].get('delay'):\\n delays[name] = events[name]['delay']\\n else:\\n delays[name] = 0.0\\n last_exec_time[name] = -1\\n props[name] = 0.0\\n prop_funcs[name] = compile(\\\"props['\\\" + name + \\\"'] = \\\" + str(events[name]['propensity']), 'prop_funcs_'+name, 'exec')\\n exec_funcs[name] = compile(events[name]['consequence'], 'exec_funcs_'+name, 'exec')\\n \\n #MAIN LOOP\\n while time < end_time:\\n \\n #calculate propensities\\n for name in props:\\n exec(prop_funcs[name])\\n if delays[name] > 0 and delays[name] + last_exec_time[name] < time:\\n print(name)\\n props[name] = 0.0\\n \\n #calculate total of all propensities\\n total_prop = 0\\n for name in props:\\n total_prop += props[name]\\n \\n \\n u = random.uniform(0,total_prop)\\n usum = 0\\n lucky = None\\n for name in props:\\n usum += props[name]\\n if usum > u:\\n lucky = name\\n break\\n\\n #fire that reaction\\n if lucky:\\n last_exec_time[lucky] = time\\n exec(exec_funcs[lucky])\\n \\n \\n row = [0]*len(species)\\n i = 0\\n for name in species:\\n row[i] = eval(name)\\n i += 1\\n time_array.append(time)\\n species_array.append(row)\\n \\n #update next time using exp distrib\\n if total_prop == 0.0: #jump to next delay\\n lowest_delay = inf\\n for name in props:\\n if delays[name] > 0 and delays[name] < lowest_delay:\\n lowest_delay = delays[name]\\n time += lowest_delay\\n else:\\n dt = random.exponential(1.0/total_prop)\\n time += dt\\n\\n #END MAIN LOOP\\n\\n result = {'time':time_array, 'participants':species_array, 'headers': species_names}\\n return result\",\n \"def testSanity(self):\\n\\t\\tga = GA.GA(2,3)\\n\\t\\tgenomes = ga.seedGenomes()\\n\\t\\tself.assertEqual(len(genomes), 2, \\n\\t\\t \\\"Wrong number of genomes\\\")\\n\\t\\tself.assertEqual(len(genomes[0]), 3, \\n\\t\\t \\\"Wrong size in genomes\\\")\\n\\t\\t#print genomes\\n\\t\\t#live and learn\\n\\t\\tfitnesses = [23, 45]\\n\\t\\tga.fitnessUpdate(fitnesses)\\n\\t\\tgenomes2 = ga.createNextGeneration()\\n\\t\\tself.assertEqual(len(genomes2), 2, \\n \\\"Wrong number of genomes\\\")\\n\\t\\tself.assertEqual(len(genomes2[0]), 3, \\n \\\"Wrong size in genomes\\\")\",\n \"def run():\\n\\n Number_repetitions = 1\\n Rate = np.zeros((Number_repetitions,1))\\n Rate20 = np.zeros((Number_repetitions,1))\\n Penalty20 = np.zeros((Number_repetitions, 1))\\n\\n # Loop to average\\n for idx in np.arange(0,Number_repetitions,1):\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n a = e.create_agent(LearningAgent) # create agent\\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.0000001, display=True) # create simulator (uses pygame when display=True, if available)\\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\\n\\n sim.run(n_trials=100) # run for a specified number of trials\\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\\n\\n # I've edited the enviroment variable to do the plot creating an completions array\\n completions = np.array(e.completions)\\n rate = float(completions.sum())/float((len(completions)))\\n rate20 = float(completions[-20:].sum())/20\\n\\n Rate[idx] = rate\\n Rate20[idx] = rate20\\n\\n Wrong = np.array(a.wrong_moves_per_run[-20:]).mean()\\n Penalty20[idx] = Wrong\\n\\n plt.scatter(np.arange(0,len(completions)),completions)\\n plt.plot(Wrong)\\n plt.xlabel('Trial')\\n plt.ylabel('1 = Get in the destination, 0 = did not get')\\n plt.title('Reiforcement learning progress')\\n plt.legend(['Rate of completion: ' + str(rate) + '. Rate last 20: ' + str(rate20) + '.Mean penalty last 20: ' + str(Wrong)])\\n plt.show()\\n\\n #print 'Accuracy: ' + str(Rate) + '. Mean: ' + str(np.mean(Rate))\\n #print 'Mean 20: ' + str(np.mean(Rate20))#'Accuracy 20: ' + str(Rate20) + '. Mean 20: ' + str(np.mean(Rate20))\\n #print 'Mean_penalty: ' + str(np.mean(Penalty20))\\n\\n # Print state table with actions\\n #t = 0\\n #for state in a.states:\\n #print 'State ' + str(state) + '. Best action: ' + str((str(np.argmax(a.QTable[t][:]))))\\n #t += 1\",\n \"def test_2nd_scenario():\\n start_entered_scenario(config.MERAKI_CAMERAS[0][\\\"serial\\\"])\\n return \\\"ok\\\"\",\n \"def run_experiments():\\r\\n result = eval_strategy_range(always_roll, 1, 10)\\r\\n print('Best always_roll strategy:', result)\\r\\n\\r\\n if True: # Change to True when ready to test make_comeback_strategy\\r\\n result = eval_strategy_range(make_comeback_strategy, 5, 15)\\r\\n print('Best comeback strategy:', result)\\r\\n\\r\\n if True: # Change to True when ready to test make_mean_strategy\\r\\n result = eval_strategy_range(make_mean_strategy, 1, 10)\\r\\n print('Best mean strategy:', result)\\r\\n\\r\\n \\\"*** You may add additional experiments here if you wish ***\\\"\",\n \"def run(self,step=2,\\n sizePop=100,\\n infoFields=['migrate_to','fitness'],\\n recombination_rate = 0.00375,\\n migration_rate = 0.01,\\n mutation_rate = [0.00000001],\\n subPopNames = ['x','y','z','w'],\\n alleleNames = ['A','B'],\\n s1 = 0.1,\\n burnin=50,\\n **kargs):\\n\\n self.reset()\\n pop=sim.Population(size=[sizePop]*self.numPop, loci=self.loci, lociPos=list(range(self.dist, (self.dist*self.loci)+1,self.dist)), subPopNames=subPopNames, infoFields=infoFields)\\n \\n simu = sim.Simulator(pop)\\n print(\\\"The simulation has started\\\")\\n t1 = time.time()\\n\\n\\n mutate_snps=range(0,50)+range(51,101)\\n\\n # define the initialization of each loci based the beta distribution where a and b parameters are allele frequencies from noncoding human regions\\n snps=[0.14, 0.11, 0.17, 0.11, 0.32, 0.33, 0.21, 0.11, 0.11, 0.28, 0.11, 0.12, 0.8, 0.66, 0.74, 0.68, 0.66, 0.77, 0.77, 0.76, 0.77, 0.74, 0.72, 0.11, 0.73, 0.72, 0.72, 0.72, 0.54, 0.17, 0.78, 0.64, 0.78, 0.2, 0.24, 0.25, 0.78, 0.66, 0.2, 0.14, 0.75, 0.16, 0.72, 0.18, 0.77, 0.42, 0.34, 0.7, 0.17, 0.14, 0.2, 0.46, 0.13, 0.26, 0.16, 0.13, 0.14, 0.24, 0.18, 0.36, 0.71, 0.27, 0.28, 0.25, 0.25, 0.3, 0.19, 0.14, 0.16, 0.3, 0.39, 0.16, 0.24, 0.32, 0.11, 0.18, 0.48, 0.31, 0.21, 0.15, 0.34, 0.71, 0.33, 0.18, 0.71, 0.13, 0.23, 0.2, 0.22, 0.23, 0.16, 0.23, 0.23, 0.22, 0.24, 0.82, 0.36, 0.37, 0.72, 0.16, 0.14]\\n self.initFreq=[]\\n\\n \\n for i in range(len(snps)):\\n alpha=float(4*sizePop*migration_rate*snps[i])\\n bhta=float(4*sizePop*migration_rate*(1-snps[i])) \\n p=numpy.random.beta(alpha,bhta)\\n while (p>=0.9 or p<=0.1):\\n p=numpy.random.beta(alpha,bhta)\\n \\n print \\\" SNP {snp} with alpha {alpha}, bhta {bhta} and frequency {p}\\\".format(snp=i, alpha=alpha, bhta=bhta, p=p)\\n self.initFreq.append(p)\\n\\n simu.evolve(\\n \\n initOps=[sim.InitGenotype(freq=[self.initFreq[i], 1-self.initFreq[i]], loci=i) for i in range(len(snps))],\\n \\n\\n # initialize the sex and select the 50 loci (parents)\\n preOps = [sim.InitSex(maleProp=0.5,at=[0]),\\n\\n # initialize the genotype of locus 50 at generation 0 (in the beginning of the simulation)\\n sim.PyOperator(self.genotypeBegin,at=[0]),\\n \\n # Wait 50 generations for the system to reach equilibrium\\n # Then, change the the genotype of locus 50 at generation 50 by inserting a single copy of allele 0 in one individual \\n sim.PyOperator(self.genotypeAfter,at=[50]),\\n\\n # function that carries out the selection proccess\\n sim.MaSelector(loci=50,wildtype=0,fitness=[1+s1, 1+s1/2, 1],begin=50, end=-1,subPops=1)],\\n\\n # recombination\\n matingScheme=sim.RandomMating(ops=[\\n sim.Recombinator(rates=recombination_rate)]),\\n \\n # mutation and migration of offsprings\\n postOps = [\\n\\n \\n sim.SNPMutator(u=mutation_rate,loci=mutate_snps),\\n \\n # call function to calculate Fst and check for equilibrium state\\n sim.PyOperator(self.calcFst,step=step),\\n\\n #migration\\n # Here we define an island model, but this can easily be changed.\\n # For more information about the migration models, please look in the documentation of SimuPOP here http://simupop.sourceforge.net/manual_svn/build/userGuide_ch7_sec3.html\\n sim.Migrator(sim.utils.migrIslandRates(migration_rate,self.numPop)),\\n \\n # call function to save the allele frequencies\\n sim.PyOperator(self.checkAlleles, step=step, param = subPopNames),\\n \\n \\n # check if locus 50 is lost due to genetic drift. If yes, we terminate the simulation\\n sim.Stat(alleleFreq=50,step=step,subPops=1,begin=50,end=-1),\\n sim.TerminateIf('alleleFreq[50][0] == 0',step=step,begin=50,end=-1),\\n \\n # check the progress of the simulation\\n sim.PyEval('\\\"Gen: %d\\\" % gen',step=step),\\n sim.PyOutput('\\\\n',step=step),\\n \\n ],\\n gen=self.Gen\\n \\n )\\n \\n \\n t2 = time.time()\\n print \\\"simulation took\\\", t2-t1, \\\"seconds.\\\"\",\n \"def test_simulate(self, scml_system):\\n\\n # Reset the system and take a random action\\n scml_system.reset()\\n action = scml_system.action_space.sample()\\n # Set a defined intitial state\\n ode_state = np.array([3, 4, 5, 6])\\n scml_system._ode_solver.set_initial_value(ode_state)\\n # Perform the action on the system\\n next_state = scml_system.simulate(action)\\n solver_state_me = scml_system._ode_solver.y[:len(DummyLoad.state_names)]\\n solver_state_el = scml_system._ode_solver.y[len(DummyLoad.state_names):]\\n torque = [scml_system.electrical_motor.torque(solver_state_el)]\\n u_sup = [scml_system.supply.u_nominal]\\n u_in = [u * u_sup[0] for u in scml_system.converter.u_in]\\n # Calculate the next state\\n desired_next_state = (\\n np.concatenate((solver_state_me, torque, solver_state_el, u_in, u_sup))\\n ) / scml_system.limits\\n\\n # Assertions for correct simulation\\n assert all(desired_next_state == next_state), 'The calculated next state differs from the expected one'\\n assert scml_system.converter.action == action, 'The action was not passed correctly to the converter'\\n assert scml_system.converter.action_set_time == 0, 'The action start time was passed incorrect to the converter'\\n assert scml_system.converter.last_i_out == scml_system.electrical_motor.i_in(scml_system._ode_solver.last_y[2:])\",\n \"def test(self):\\n img_gen, self.loss_reg, self.parsav = self.net_G(self.input_P1, self.input_P2, self.input_BP1, self.input_BP2, self.input_SPL1, self.input_SPL2)\\n ## test flow ##\\n\\n self.save_results(img_gen, data_name='vis')\\n if self.opt.save_input or self.opt.phase == 'val':\\n self.save_results(self.input_P1, data_name='ref')\\n self.save_results(self.input_P2, data_name='gt')\\n result = torch.cat([self.input_P1, img_gen, self.input_P2], 3)\\n self.save_results(result, data_name='all')\",\n \"def main(self) -> None:\\n if LOG[\\\"Experiment\\\"]:\\n print(\\\"[Experiment] Advancing to 1st Generation\\\")\\n\\n # Mandatory first generation advancement\\n self.neat.advance_generation()\\n\\n # Metrics are initialized\\n max_fitness = self.neat.get_best_fitness()\\n max_fitnesses = [max_fitness]\\n\\n if LOG[\\\"Experiment\\\"]:\\n print(\\\"[Experiment] Entering Main Loop\\\")\\n\\n # The main loop is entered\\n stop = 0.0\\n while max_fitness <= TARGET_SCORE:\\n # Metrics of the last generation are checked and shared\\n if LOG[\\\"Experiment\\\"]:\\n print(\\\"\\\\n[Experiment] Generation = \\\" + str(self.neat.get_generation()))\\n print(\\\"[Experiment] Maximum Fitness of the Generation = \\\" + str(max_fitness))\\n print(\\\"[Experiment] Compared the Previous Recorded Maximum = \\\" + str(stop))\\n print(\\\"[Experiment] Maximum Innovation of the Generation = \\\" + str(self.neat.get_maximum_innovation()))\\n print(\\\"[Experiment] Amount of Species = \\\", len(self.neat.get_shared_fitness_sums()))\\n print(\\\"[Experiment] Total Shared Fitness = \\\", self.neat.get_total_shared_fitness(), \\\"\\\\n\\\")\\n\\n # If an improvement is found, the game may be simulated\\n if max_fitness > stop:\\n stop = max_fitness\\n if LOG[\\\"FrequentSimulations\\\"] and input(\\\"[Experiment] Show Simulation? (y/n)\\\\n\\\") == \\\"y\\\":\\n n = self.neat.get_population()[-1]\\n self.snake_game.show(Snake(11, Experiment.ExperimentAI(n)), self.last_used_seed,\\n \\\"Generation = \\\" + str(self.neat.get_generation()),\\n fps=max(4, int(max_fitness / 4)))\\n\\n # Generation advancement\\n self.neat.advance_generation()\\n max_fitness = self.neat.get_best_fitness()\\n max_fitnesses.append(max_fitness)\\n\\n # If the target was passed, metrics are consulted\\n if LOG[\\\"Experiment\\\"]:\\n print(\\\"\\\\n[Experiment] Generation = \\\" + str(self.neat.get_generation()))\\n print(\\\"[Experiment] Maximum Fitness of the Generation = \\\" + str(max_fitness))\\n print(\\\"[Experiment] Compared to a 'stop' value of = \\\" + str(stop))\\n print(\\\"[Experiment] Maximum Innovation of the Generation = \\\" + str(self.neat.get_maximum_innovation()))\\n print(\\\"[Experiment] Shared fitness sums = \\\", self.neat.get_shared_fitness_sums())\\n print(\\\"[Experiment] Total shared fitness = \\\", self.neat.get_total_shared_fitness(), \\\"\\\\n\\\")\\n\\n # Metrics are updated again\\n max_fitness = self.neat.get_best_fitness()\\n max_fitnesses.append(max_fitness)\\n\\n # A simulation of the result can be shown if the user wants to\\n sim = input(\\\"[Experiment] Show Simulation? (y/n)\\\\n\\\")\\n while sim == \\\"y\\\":\\n n = self.neat.get_population()[-1]\\n self.snake_game.show(Snake(11, Experiment.ExperimentAI(n)), self.last_used_seed,\\n \\\"Generation = \\\" + str(self.neat.get_generation()),\\n fps=max(4, int(max_fitness / 4)))\\n sim = input(\\\"[Experiment] Show Simulation? (y/n)\\\\n\\\")\\n\\n # The resulting network may be printed\\n if SHOW_RESULT:\\n print(\\\"The best network generated is specified as:\\\\n\\\", str(self.neat.get_best_network_details()))\\n\\n # The resulting network may be saved\\n if SAVE_RESULT:\\n if LOG[\\\"Experiment\\\"]:\\n print(\\\"[Experiment] Saving Resulting Network\\\")\\n\\n # Previous saves are removed\\n dm.clear_dir(networks_saving_directory)\\n\\n # A .txt is generated\\n with open(networks_saving_directory+\\\"/best_network.txt\\\", \\\"w\\\") as text_file:\\n text_file.write(str(self.neat.get_best_network_details()))\\n\\n if LOG[\\\"Experiment\\\"]:\\n print(\\\"[Experiment] Resulting Network Saved\\\")\\n\\n # A plot of fitnesses may be created\\n if PLOT:\\n if LOG[\\\"Experiment\\\"]:\\n print(\\\"[Experiment] Generating Fitness Plot\\\")\\n\\n # The plot is generated in matplotlib\\n _, ax = plt.subplots()\\n\\n ax.plot(range(1, len(max_fitnesses)+1), max_fitnesses)\\n ax.set_xlim([0, len(max_fitnesses)+2])\\n ax.set_ylim([max(min(min(max_fitnesses), TARGET_SCORE - 100), 0), TARGET_SCORE+5])\\n\\n plt.title(\\\"Generational fitness for board size \\\" + str(BOARD_SIZE) +\\n \\\" using seed \\\" + str(SEED))\\n plt.xlabel(\\\"Generation\\\")\\n plt.ylabel(\\\"Fitness\\\")\\n ax.grid(True)\\n\\n # The plot may be saved to memory\\n if SAVE_PLOTS:\\n if LOG[\\\"Experiment\\\"]:\\n print(\\\"[Experiment] Saving Fitness Plot\\\")\\n\\n # Previous saves are removed\\n dm.clear_dir(plots_saving_directory)\\n\\n name = plots_saving_directory + \\\"/plot_board\\\" + str(BOARD_SIZE)\\n name += \\\".png\\\"\\n\\n # A new .png is saved\\n plt.savefig(name, bbox_inches='tight')\\n\\n if LOG[\\\"Experiment\\\"]:\\n print(\\\"[Experiment] Fitness Plot Saved\\\")\\n # Otherwise the plot is displayed\\n else:\\n if LOG[\\\"Experiment\\\"]:\\n print(\\\"[Experiment] Showing Fitness Plot\\\")\\n\\n plt.show()\\n\\n plt.close()\\n\\n if LOG[\\\"Experiment\\\"]:\\n print(\\\"[Experiment] Quitting Experiment\\\")\\n\\n # The experiment ends\\n self.snake_game.quit()\",\n \"def test_no_jitter(self):\\n n = 10\\n t_max = 25\\n dt = 0.1\\n G = RateHVCLayer(n)\\n G.burst_noise = 0.0\\n\\n M1 = simulation.StateMonitor(G, 'out')\\n\\n sim1 = simulation.Simulation(G, M1, dt=dt)\\n sim1.run(t_max)\\n \\n M2 = simulation.StateMonitor(G, 'out')\\n sim2 = simulation.Simulation(G, M2, dt=dt)\\n sim2.run(t_max)\\n\\n self.assertTrue(np.allclose(M1.out, M2.out))\",\n \"def test_SetMultipleMovingLoadsWithVelocityFunctionConfigurationPositive(self):\\n\\n # create nodes\\n second_coord = [1, 0, 0.0]\\n self.mp.CreateNewNode(1,0.0,0.0,0.0)\\n self.mp.CreateNewNode(2,second_coord[0],second_coord[1],0.0)\\n\\n # create condition\\n self.mp.CreateNewCondition(\\\"MovingLoadCondition2D2N\\\", 1, [1,2], self.mp.GetProperties()[1])\\n\\n parameters = self.base_parameters\\n parameters[\\\"velocity\\\"]=KratosMultiphysics.Parameters(self.time_dependent_velocity)\\n parameters.AddVector(\\\"configuration\\\", [0.5])\\n\\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0)\\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.DELTA_TIME, 0.25)\\n\\n process = GMA.SetMultipleMovingLoadsProcess(self.mp, parameters)\\n cond = self.cmp.GetCondition(2)\\n\\n # initialise and set load\\n process.ExecuteInitialize()\\n process.ExecuteInitializeSolutionStep()\\n\\n # initialise matrices\\n lhs = KratosMultiphysics.Matrix(0, 0)\\n rhs = KratosMultiphysics.Vector(0)\\n\\n # set load on node\\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\\n\\n self.checkRHS(rhs, [0.0, -1.0, 0.0, -1.0])\\n\\n # change time and recalculate load\\n process.ExecuteFinalizeSolutionStep()\\n process.ExecuteInitializeSolutionStep()\\n\\n # check if interpolation is done correctly\\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\\n\\n self.checkRHS(rhs, [0.0, -1.0, 0.0, -1.0])\\n\\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0.5)\\n\\n process.ExecuteFinalizeSolutionStep()\\n process.ExecuteInitializeSolutionStep()\\n\\n # check if interpolation is done correctly\\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\\n\\n self.checkRHS(rhs, [0.0, -0.5, 0.0, -1.5])\",\n \"def test_simulationRun(self):\\n self.opt = { 'temperature' : 300.0, 'friction' : 1, 'dt' : 0.00002,\\n 'nIter' : 2, 'nstepsNC' : 2, 'nstepsMD' : 1, 'nprop' : 1,\\n 'nonbondedMethod' : 'NoCutoff', 'constraints': 'HBonds',\\n 'trajectory_interval' : 1, 'reporter_interval' : 1,\\n 'outfname' : 'mc-test',\\n 'platform' : None,\\n 'constraints' : 'HBonds',\\n 'mc_per_iter' : 2 }\\n\\n structure = self.full_struct\\n class SetRotationMove(RandomLigandRotationMove):\\n def __init__(self, structure, resname='LIG'):\\n super(SetRotationMove, self).__init__(structure, resname)\\n\\n def move(self, context):\\n \\\"\\\"\\\"Function that performs a random rotation about the\\n center of mass of the ligand.\\n \\\"\\\"\\\"\\n #TODO: check if we need to deepcopy\\n positions = context.getState(getPositions=True).getPositions(asNumpy=True)\\n\\n self.positions = positions[self.atom_indices]\\n self.center_of_mass = self.getCenterOfMass(self.positions, self.masses)\\n reduced_pos = self.positions - self.center_of_mass\\n\\n # Define random rotational move on the ligand\\n #set rotation so that test is reproducible\\n set_rotation_matrix = np.array([[-0.62297988, -0.17349253, 0.7627558 ],\\n [ 0.55082352, -0.78964857, 0.27027502],\\n [ 0.55541834, 0.58851973, 0.58749893]])\\n\\n\\n #set_rotation_matrix = np.array([[1, 0, 0],\\n # [0, 1, 0],\\n # [0, 0, 1]])\\n\\n #multiply lig coordinates by rot matrix and add back COM translation from origin\\n rot_move = np.dot(reduced_pos, set_rotation_matrix) * positions.unit + self.center_of_mass\\n\\n # Update ligand positions in nc_sim\\n for index, atomidx in enumerate(self.atom_indices):\\n positions[atomidx] = rot_move[index]\\n context.setPositions(positions)\\n positions = context.getState(getPositions=True).getPositions(asNumpy=True)\\n self.positions = positions[self.atom_indices]\\n return context\\n\\n\\n self.model = SetRotationMove(structure, resname='ALA')\\n #self.model = RandomLigandRotationMove(structure, resname='ALA')\\n\\n self.model.atom_indices = range(22)\\n self.model.topology = structure[self.model.atom_indices].topology\\n self.model.positions = structure[self.model.atom_indices].positions\\n self.model.calculateProperties()\\n\\n self.mover = MoveEngine(self.model)\\n #Initialize the SimulationFactory object\\n sims = SimulationFactory(structure, self.mover, **self.opt)\\n #print(sims)\\n system = sims.generateSystem(structure, **self.opt)\\n simdict = sims.createSimulationSet()\\n alch_system = sims.generateAlchSystem(system, self.model.atom_indices)\\n self.nc_sim = sims.generateSimFromStruct(structure, self.mover, alch_system, ncmc=True, **self.opt)\\n self.model.calculateProperties()\\n self.initial_positions = self.nc_sim.context.getState(getPositions=True).getPositions(asNumpy=True)\\n mc_sim = Simulation(sims, self.mover, **self.opt)\\n #monkeypatch to access acceptance value\\n def nacceptRejectMC(self, temperature=300, **opt):\\n \\\"\\\"\\\"Function that chooses to accept or reject the proposed move.\\n \\\"\\\"\\\"\\n md_state0 = self.current_state['md']['state0']\\n md_state1 = self.current_state['md']['state1']\\n log_mc = (md_state1['potential_energy'] - md_state0['potential_energy']) * (-1.0/self.nc_sim.context._integrator.kT)\\n randnum = math.log(np.random.random())\\n\\n if log_mc > randnum:\\n self.accept += 1\\n print('MC MOVE ACCEPTED: log_mc {} > randnum {}'.format(log_mc, randnum) )\\n self.md_sim.context.setPositions(md_state1['positions'])\\n else:\\n self.reject += 1\\n print('MC MOVE REJECTED: log_mc {} < {}'.format(log_mc, randnum) )\\n self.md_sim.context.setPositions(md_state0['positions'])\\n self.log_mc = log_mc\\n self.md_sim.context.setVelocitiesToTemperature(self.opt['temperature'])\\n mc_sim.acceptRejectMC = nacceptRejectMC\\n nacceptRejectMC.__get__(mc_sim)\\n mc_sim.acceptRejectMC = types.MethodType(nacceptRejectMC, mc_sim)\\n mc_sim.runMC(self.opt['nIter'])\\n #get log acceptance\\n print(mc_sim.log_mc)\\n #if mc is working, should be around -24.1\\n assert mc_sim.log_mc <= -23.8 and mc_sim.log_mc >= -24.3\",\n \"def test_simulation():\\n # Get the ambient profile data\\n profile = get_profile()\\n\\n # Initialize a Model object\\n sbm = single_bubble_model.Model(profile)\\n\\n # Set up the initial conditions\\n composition = ['methane', 'ethane', 'propane', 'oxygen']\\n bub = dbm.FluidParticle(composition)\\n mol_frac = np.array([0.90, 0.07, 0.03, 0.0])\\n de = 0.005\\n z0 = 1000.\\n T0 = 273.15 + 30.\\n\\n # Run the simulation\\n sbm.simulate(bub, np.array([0., 0., z0]), de, mol_frac, T0, K_T=1,\\n fdis=1e-8, delta_t=10.)\\n \\n # Check the solution\\n assert sbm.y.shape[0] == 1117\\n assert sbm.y.shape[1] == 8\\n assert sbm.t.shape[0] == 1117\\n assert_approx_equal(sbm.t[-20], 10826.039364358305, significant = 6)\\n assert_array_almost_equal(sbm.y[-20,:], np.array([ 0.00000000e+00, \\n 0.00000000e+00, 3.36954175e+02, 4.31708836e-14, 6.66317168e-15,\\n 1.05065563e-11, 0.00000000e+00, 5.98799637e-06]), decimal = 6)\\n \\n # Write the output files\\n sbm.save_sim(os.path.join(OUTPUT_DIR, 'sbm_data.nc'),\\n './test_BM54.nc',\\n 'Results of ./test_sbm.py script')\\n\\n sbm.save_txt(os.path.join(OUTPUT_DIR, 'sbm_data'),\\n './test_BM54.nc',\\n 'Results of ./test_sbm.py script')\\n\\n # Reload the simulation\\n sbm_f = single_bubble_model.Model(simfile = os.path.join(OUTPUT_DIR,\\n 'sbm_data.nc'))\\n\\n # Check that the attributes are loaded correctly\\n assert sbm_f.y[0,0] == sbm.y[0,0] # x0\\n assert sbm_f.y[0,1] == sbm.y[0,1] # y0\\n assert sbm_f.y[0,2] == sbm.y[0,2] # z0\\n\\n assert_array_almost_equal(sbm_f.particle.m0, sbm.particle.m0, decimal = 6)\\n assert sbm_f.particle.T0 == sbm.particle.T0\\n print(sbm_f.particle.K_T, sbm.particle.K_T)\\n assert sbm_f.particle.K == sbm.particle.K\\n assert sbm_f.particle.K_T == sbm.particle.K_T\\n assert sbm_f.particle.fdis == sbm.particle.fdis\\n assert sbm_f.K_T0 == sbm.K_T0\\n assert sbm_f.delta_t == sbm.delta_t\\n (T, S, P) = profile.get_values(1000., ['temperature', 'salinity',\\n 'pressure'])\\n (Tp, Sp, Pp) = sbm_f.profile.get_values(1000., ['temperature', 'salinity',\\n 'pressure'])\\n assert Tp == T\\n assert Sp == S\\n assert Pp == P\\n\\n # Check that the results are still correct\\n assert sbm.y.shape[0] == 1117\\n assert sbm.y.shape[1] == 8\\n assert sbm.t.shape[0] == 1117\\n assert_approx_equal(sbm.t[-20], 10826.039364358305, significant = 6)\\n assert_array_almost_equal(sbm.y[-20,:], np.array([ 0.00000000e+00, \\n 0.00000000e+00, 3.36954175e+02, 4.31708836e-14, 6.66317168e-15,\\n 1.05065563e-11, 0.00000000e+00, 5.98799637e-06]), decimal = 6)\\n\\n # Load the data in the txt file and check the solution\\n data = np.loadtxt(os.path.join(OUTPUT_DIR, 'sbm_data.txt'))\\n assert sbm.y.shape[0] == 1117\\n assert sbm.y.shape[1] == 8\\n assert sbm.t.shape[0] == 1117\\n assert_approx_equal(sbm.t[-20], 10826.039364358305, significant = 6)\\n assert_array_almost_equal(sbm.y[-20,:], np.array([ 0.00000000e+00, \\n 0.00000000e+00, 3.36954175e+02, 4.31708836e-14, 6.66317168e-15,\\n 1.05065563e-11, 0.00000000e+00, 5.98799637e-06]), decimal = 6)\\n\\n # Create an inert particle that is compressible\\n oil = dbm.InsolubleParticle(True, True, rho_p=840.)\\n mol_frac = np.array([1.])\\n\\n # Specify the remaining particle initial conditions\\n de = 0.03\\n z0 = 1000.\\n T0 = 273.15 + 30.\\n\\n # Simulate the trajectory through the water column and plot the results\\n sbm.simulate(oil, np.array([0., 0., z0]), de, mol_frac, T0, K_T=1,\\n delta_t=10.)\\n ans = np.array([00.00000000e+00, 0.00000000e+00, 1.16067764e-01, \\n 1.26136097e-02, 7.57374681e+03])\\n for i in range(5):\\n assert_approx_equal(sbm.y[-1,i], ans[i], significant = 6)\",\n \"def test_run():\\n argv = [\\\"py.test\\\", \\\"100\\\", \\\"-potential\\\", \\\"potentials/bump.cfg\\\"]\\n args = get_sargs(argv)\\n from basis.basis_solve import run\\n assert run(args) == 0\",\n \"def test_compare_genomes_2(self):\\n self.pmr_gnm.annotation_status = \\\"final\\\"\\n self.pmr_gnm.name = \\\"Trixie\\\"\\n import_genome.compare_genomes(self.genome_pair, self.eval_flags)\\n count = count_status(self.genome_pair, \\\"error\\\", \\\"warning\\\")\\n with self.subTest():\\n self.assertEqual(len(self.genome_pair.evaluations), 13)\\n with self.subTest():\\n self.assertEqual(count, 0)\",\n \"def run(sim_attr_generator):\\n#TODO: clean\\n#TODO: integrate analyses\\n def analyze_and_save(simulation,simulation_attributes):\\n#? Ugly conf file analyses integration.\\n if simulation_attributes.analyses and Args.output_file != None:\\n verbose_print(\\\"Saving analyses for {0}.\\\".format(simulation_attributes.id_name),2)\\n results = analyze_datas(\\n simulation.result,\\n simulation_attributes.analyses\\n )\\n plotables = ana_results_to_plotables(\\n results,\\n simulation_attributes.analyses\\n )\\n#TODO error handling for save\\n analysis_save_dm(\\n results,\\n plotables,\\n simulation_attributes.analyses,\\n simulation_attributes.id_name\\n )\\n\\n def save_simulation(simulation,simulation_attributes):\\n if not simulation_attributes.analyses and Args.output_file != None:\\n verbose_print(\\\"Saving simulation datas of {0}.\\\".format(\\n simulation_attributes.id_name\\n ),2) \\n try:\\n np.save(\\n simulation_attributes.id_name,\\n simulation.result\\n )\\n except:\\n raise EnvironmentError(\\\"Can't save data to {}.\\\".format(\\n simulation_attributes.id_name\\n ))\\n\\n verbose_print(\\\"Starting simulation run.\\\",1)\\n for i,simulation_attributes in enumerate(sim_attr_generator):\\n verbose_print(\\\"Starting simulation number {0}: {1}\\\".format(\\n i,\\n simulation_attributes.id_name\\n ),2)\\n simulation = Simulation(\\n SimulationVariables(simulation_attributes)\\n )\\n simulation.start()\\n save_simulation(simulation,simulation_attributes)\\n analyze_and_save(simulation,simulation_attributes)\",\n \"def run():\\n\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n a = e.create_agent(LearningAgent) # create learning agent\\n # a = e.create_agent(RandomAgent) # create random agent\\n e.set_primary_agent(a, enforce_deadline=True) # set agent to track\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.01)\\n # reduce update_delay to speed up simulation\\n sys.stdout = open(\\\"./output.txt\\\", \\\"w\\\")\\n tic = time()\\n sim.run(n_trials=100) # press Esc or close pygame window to quit\\n toc = time()\\n sys.stdout = sys.__stdout__\\n\\n print \\\"Totoal time used: {}.\\\".format(toc - tic)\\n parse(\\\"./output.txt\\\")\",\n \"def run_scenario(self):\\n self.initialize_random_map()\\n self.visualize_environment('initial')\\n self.get_tower_target_coverages()\\n self.solve_environment()\\n self.visualize_environment('solved')\",\n \"def run():\\n\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n a = e.create_agent(LearningAgent) # create agent\\n e.set_primary_agent(a, enforce_deadline=True) # set agent to track\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.01) # reduce update_delay to speed up simulation\\n sim.run(n_trials=100) # press Esc or close pygame window to quit\\n return [a.state_action_table, a.reward_hist]\",\n \"def test_ns_ok2():\\n env = NsSimPyEnvironment()\\n env.process(some_process(env, env.to_time('10.1')))\\n env.run()\\n env.process(some_process(env, env.to_time('0.9')))\\n env.run()\\n assert env.now == 11\",\n \"def test_evolution(self):\\n class Mock(object):\\n def __init__(self):\\n self.t = 0.0\\n\\n def evolve(self1, t, dt):\\n self.assertEqual(self1.t, t)\\n self1.t += dt\\n\\n G1 = Mock()\\n G2 = Mock()\\n sim = simulation.Simulation(G1, G2)\\n sim.run(100.0)\\n\\n self.assertAlmostEqual(G1.t, 100.0)\",\n \"def scenario():\\n LOCAL_HOST = \\\"http://127.0.0.1\\\"\\n\\n # import functions\\n from . import genesis_block\\n from . import create_block\\n from . import connect_peer\\n from . import stop_server\\n from . import block_crosscheck\\n\\n total_cnt = 0\\n pass_cnt = 0\\n\\n # 1. Check each peer's genesis block\\n try:\\n assert genesis_block.check(LOCAL_HOST, 3001)\\n assert genesis_block.check(LOCAL_HOST, 3002)\\n assert genesis_block.check(LOCAL_HOST, 3003)\\n\\n print(\\\"pass\\\", end=' ')\\n pass_cnt += 1\\n\\n except:\\n print(\\\"FAIL\\\", end=' ')\\n\\n finally:\\n print(\\\"test1/genesis_block\\\")\\n total_cnt += 1\\n\\n # 2. Generate new blocks\\n # 2.1. 2 blocks on peer #1\\n # 2.2. 4 blocks on peer #2\\n # 2.3. 2 blocks on peer #3\\n try:\\n assert create_block.addBlocks(LOCAL_HOST, 3001, num=2)\\n assert create_block.check(LOCAL_HOST, 3001, num=2)\\n\\n assert create_block.addBlocks(LOCAL_HOST, 3002, num=4)\\n assert create_block.check(LOCAL_HOST, 3002, num=4)\\n\\n assert create_block.addBlocks(LOCAL_HOST, 3003, num=2)\\n assert create_block.check(LOCAL_HOST, 3003, num=2)\\n\\n print(\\\"pass\\\", end=' ')\\n pass_cnt += 1\\n\\n except:\\n print(\\\"FAIL\\\", end=' ')\\n\\n finally:\\n print(\\\"test1/create_block\\\")\\n total_cnt += 1\\n\\n # 3. Connect peers\\n # 3.1. peer #1 with #2 (1->2)\\n # 3.2. peer #1 with #3 (1->(2 and 3))\\n try:\\n assert connect_peer.connectPeer(LOCAL_HOST, 3001, \\\"ws://127.0.0.1:6002\\\")\\n assert connect_peer.connectPeer(LOCAL_HOST, 3001, \\\"ws://127.0.0.1:6003\\\")\\n\\n print(\\\"pass\\\", end=' ')\\n pass_cnt += 1\\n\\n except:\\n print(\\\"FAIL\\\", end=' ')\\n\\n finally:\\n print(\\\"test1/connect_peer\\\")\\n total_cnt += 1\\n\\n # 4. Generate new blocks\\n # 4.1. 3 blocks on peer #1\\n # 4.2. 5 blocks on peer #3\\n try:\\n isPass, newBlocks = block_crosscheck.addBlocks(LOCAL_HOST, 3001, num=3)\\n assert isPass\\n assert block_crosscheck.check(LOCAL_HOST, 3002, newBlocks, num=3)\\n assert block_crosscheck.check(LOCAL_HOST, 3003, newBlocks, num=3)\\n\\n isPass, newBlocks = block_crosscheck.addBlocks(LOCAL_HOST, 3003, num=5)\\n assert isPass\\n assert block_crosscheck.check(LOCAL_HOST, 3001, newBlocks, num=5)\\n assert block_crosscheck.check(LOCAL_HOST, 3002, newBlocks, num=5)\\n\\n print(\\\"pass\\\", end=' ')\\n pass_cnt += 1\\n\\n except:\\n print(\\\"FAIL\\\", end=' ')\\n\\n finally:\\n print(\\\"test1/block_crosscheck\\\")\\n total_cnt += 1\\n\\n # 5. Stop all peers\\n try:\\n assert stop_server.stopServer(LOCAL_HOST, 3001)\\n assert stop_server.stopServer(LOCAL_HOST, 3002)\\n assert stop_server.stopServer(LOCAL_HOST, 3003)\\n\\n print(\\\"pass\\\", end=' ')\\n pass_cnt += 1\\n\\n except:\\n print(\\\"FAIL\\\", end=' ')\\n\\n finally:\\n print(\\\"test1/stop_server\\\")\\n total_cnt += 1\\n\\n # return pass_cnt_per_test and total_cnt_per_test\\n return pass_cnt, total_cnt\",\n \"def compare(numberOfSimulations, initialValue, sigma, T, strike, r = 0):\\n \\n numberOfTests = 100\\n \\n \\n #the two lists that will contain our average errors for the different tests\\n errorsStandardMonteCarlo = []\\n errorsMonteCarloWithAV = []\\n \\n #our benchmark: the analytic price of the call option\\n analyticPriceBS = blackScholesPriceCall(initialValue, r, sigma, T, initialValue)\\n\\n #look at how lambda functions are defined in Python \\n payoff = lambda x : max(x - initialValue, 0)\\n \\n #alternatively:\\n #def payoff(x):\\n # return max(x - initialValue, 0)\\n \\n #note how to construct an object of a class\\n \\n blackScholesGenerator = GenerateBlackScholes(numberOfSimulations, T, initialValue, sigma, r)\\n #k=0,..,numberOfTests - 1\\n for k in range(numberOfTests):\\n \\n \\n\\n #first, the valuation with the standard Monte-Carlo:\\n realizationsOfTheProcessWithStandardMC = blackScholesGenerator.generateRealizations()\\n \\n priceCalculatorWithStandardMC = SimpleEuropeanOption(realizationsOfTheProcessWithStandardMC, r)\\n priceStandardMC = priceCalculatorWithStandardMC.getPrice(payoff, T) \\n errorWithStandardMC= abs(priceStandardMC - analyticPriceBS)/analyticPriceBS\\n #note how to append new values to a list\\n errorsStandardMonteCarlo.append(errorWithStandardMC)\\n \\n #then, the one with Antithetic Variables:\\n realizationsOfTheProcessWithAV = blackScholesGenerator.generateRealizationsAntitheticVariables()\\n \\n priceCalculatorWithAV = SimpleEuropeanOption(realizationsOfTheProcessWithAV, r)\\n priceWithAV = priceCalculatorWithAV.getPrice(payoff, T) \\n errorWithAV= abs(priceWithAV - analyticPriceBS)/analyticPriceBS\\n #note how to append new values to a list\\n errorsMonteCarloWithAV.append(errorWithAV)\\n\\n #we get and return the respective average errors: mean is imported from\\n #statistics\\n averageErrorStandardMC = mean(errorsStandardMonteCarlo)\\n #you can also use numpy\\n averageErrorAV = np.mean(errorsMonteCarloWithAV)\\n \\n return averageErrorStandardMC, averageErrorAV\",\n \"def test_grovers_default_basis_gates(self):\\n shots = 2000\\n circuits = ref_algorithms.grovers_circuit(final_measure=True,\\n allow_sampling=True)\\n targets = ref_algorithms.grovers_counts(shots)\\n job = execute(circuits, QasmSimulator(), shots=shots)\\n result = job.result()\\n self.is_completed(result)\\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)\",\n \"def test_SetMultipleMovingLoadsWithVelocityFunction(self):\\n\\n # create nodes\\n second_coord = [1, 0, 0.0]\\n self.mp.CreateNewNode(1, 0.0, 0.0, 0.0)\\n self.mp.CreateNewNode(2, second_coord[0], second_coord[1], 0.0)\\n\\n # create condition\\n self.mp.CreateNewCondition(\\\"MovingLoadCondition2D2N\\\", 1, [1,2], self.mp.GetProperties()[1])\\n\\n parameters = self.base_parameters\\n parameters[\\\"velocity\\\"]=KratosMultiphysics.Parameters(self.time_dependent_velocity)\\n\\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0)\\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.DELTA_TIME, 0.25)\\n\\n process = GMA.SetMultipleMovingLoadsProcess(self.mp, parameters)\\n cond = self.cmp.GetCondition(2)\\n\\n # initialise and set load\\n process.ExecuteInitialize()\\n process.ExecuteInitializeSolutionStep()\\n\\n # initialise matrices\\n lhs = KratosMultiphysics.Matrix(0, 0)\\n rhs = KratosMultiphysics.Vector(0)\\n\\n # set load on node\\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\\n\\n self.checkRHS(rhs, [0.0, -2.0, 0.0, 0.0])\\n\\n # change time and recalculate load\\n process.ExecuteFinalizeSolutionStep()\\n process.ExecuteInitializeSolutionStep()\\n\\n # check if interpolation is done correctly\\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\\n\\n self.checkRHS(rhs, [0.0, -2.0, 0.0, 0.0])\\n\\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0.5)\\n\\n process.ExecuteFinalizeSolutionStep()\\n process.ExecuteInitializeSolutionStep()\\n\\n # check if interpolation is done correctly\\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\\n\\n self.checkRHS(rhs, [0.0, -1.5, 0.0, -0.5])\",\n \"def run(self, steps):\\n if not self.skip_reference:\\n self.reference_sim.run(steps)\\n self.compare_sim.run(steps)\",\n \"def test_run_jackknifed_beta_diversity(self):\\r\\n\\r\\n run_jackknifed_beta_diversity(\\r\\n self.test_data['biom'][0],\\r\\n self.test_data['tree'][0],\\r\\n 20,\\r\\n self.test_out,\\r\\n call_commands_serially,\\r\\n self.params,\\r\\n self.qiime_config,\\r\\n self.test_data['map'][0],\\r\\n parallel=False,\\r\\n status_update_callback=no_status_updates)\\r\\n\\r\\n weighted_unifrac_upgma_tree_fp = join(self.test_out,\\r\\n 'weighted_unifrac',\\r\\n 'upgma_cmp', 'jackknife_named_nodes.tre')\\r\\n unweighted_unifrac_upgma_tree_fp = join(\\r\\n self.test_out, 'unweighted_unifrac', 'upgma_cmp',\\r\\n 'jackknife_named_nodes.tre')\\r\\n weighted_unifrac_emperor_index_fp = join(\\r\\n self.test_out, 'weighted_unifrac', 'emperor_pcoa_plots',\\r\\n 'index.html')\\r\\n unweighted_unifrac_emperor_index_fp = join(\\r\\n self.test_out, 'unweighted_unifrac', 'emperor_pcoa_plots',\\r\\n 'index.html')\\r\\n\\r\\n input_file_basename = splitext(split(self.test_data['biom'][0])[1])[0]\\r\\n unweighted_unifrac_dm_fp = join(self.test_out,\\r\\n 'unweighted_unifrac_%s.txt' % input_file_basename)\\r\\n weighted_unifrac_dm_fp = join(self.test_out,\\r\\n 'weighted_unifrac_%s.txt' % input_file_basename)\\r\\n\\r\\n # check for expected relations between values in the unweighted unifrac\\r\\n # distance matrix\\r\\n dm = parse_distmat_to_dict(open(unweighted_unifrac_dm_fp))\\r\\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\\r\\n \\\"Distance between pair of fecal samples is larger than distance\\\"\\r\\n \\\" between fecal and palm sample (unweighted unifrac).\\\")\\r\\n self.assertEqual(dm['f1']['f1'], 0)\\r\\n # check for expected relations between values in the weighted unifrac\\r\\n # distance matrix\\r\\n dm = parse_distmat_to_dict(open(weighted_unifrac_dm_fp))\\r\\n self.assertTrue(dm['f1']['f2'] < dm['f1']['p1'],\\r\\n \\\"Distance between pair of fecal samples is larger than distance\\\"\\r\\n \\\" between fecal and palm sample (unweighted unifrac).\\\")\\r\\n self.assertEqual(dm['f1']['f1'], 0)\\r\\n\\r\\n # check that final output files have non-zero size\\r\\n self.assertTrue(getsize(weighted_unifrac_upgma_tree_fp) > 0)\\r\\n self.assertTrue(getsize(unweighted_unifrac_upgma_tree_fp) > 0)\\r\\n self.assertTrue(getsize(weighted_unifrac_emperor_index_fp) > 0)\\r\\n self.assertTrue(getsize(unweighted_unifrac_emperor_index_fp) > 0)\\r\\n\\r\\n # Check that the log file is created and has size > 0\\r\\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\\r\\n self.assertTrue(getsize(log_fp) > 0)\",\n \"def test_basic_usecases():\\n net = create_test_net()\\n eq_types = [\\\"rei\\\", \\\"ward\\\", \\\"xward\\\"]\\n for eq_type in eq_types:\\n net1, net2, net3 = run_basic_usecases(eq_type)\\n\\n if eq_type == \\\"rei\\\":\\n check_elements_amount(net1, {\\\"bus\\\": 5, \\\"load\\\": 3, \\\"sgen\\\": 2, \\\"shunt\\\": 3, \\\"ext_grid\\\": 1,\\n \\\"line\\\": 3, \\\"impedance\\\": 3}, check_all_pp_elements=True)\\n check_res_bus(net, net1)\\n assert np.allclose(net1.bus.min_vm_pu.values,\\n np.array([0.9, 0.91, np.nan, np.nan, 0.93]), equal_nan=True)\\n check_elements_amount(net2, {\\\"bus\\\": 3, \\\"load\\\": 3, \\\"sgen\\\": 0, \\\"shunt\\\": 3, \\\"ext_grid\\\": 0,\\n \\\"line\\\": 0, \\\"impedance\\\": 3}, check_all_pp_elements=True)\\n check_res_bus(net, net2)\\n assert np.allclose(net2.bus.min_vm_pu.values,\\n net.bus.min_vm_pu.loc[[2, 4, 3]].values, equal_nan=True)\\n check_elements_amount(net3, {\\\"bus\\\": 5, \\\"load\\\": 3, \\\"sgen\\\": 2, \\\"shunt\\\": 3, \\\"ext_grid\\\": 1,\\n \\\"line\\\": 3, \\\"impedance\\\": 3}, check_all_pp_elements=True)\\n check_res_bus(net, net3)\\n assert np.allclose(net1.bus.min_vm_pu.values,\\n np.array([0.9, 0.91, np.nan, np.nan, 0.93]), equal_nan=True)\\n\\n elif \\\"ward\\\" in eq_type:\\n check_elements_amount(net1, {\\\"bus\\\": 4, \\\"load\\\": 2, \\\"sgen\\\": 2, \\\"ext_grid\\\": 1, \\\"line\\\": 3,\\n eq_type: 2, \\\"impedance\\\": 1}, check_all_pp_elements=True)\\n check_res_bus(net, net1)\\n check_elements_amount(net2, {\\\"bus\\\": 2, \\\"load\\\": 2, \\\"sgen\\\": 0, \\\"ext_grid\\\": 0, \\\"line\\\": 0,\\n eq_type: 2, \\\"impedance\\\": 1}, check_all_pp_elements=True)\\n check_res_bus(net, net2)\\n check_elements_amount(net3, {\\\"bus\\\": 4, \\\"load\\\": 2, \\\"sgen\\\": 2, \\\"ext_grid\\\": 1, \\\"line\\\": 3,\\n eq_type: 2, \\\"impedance\\\": 1}, check_all_pp_elements=True)\\n check_res_bus(net, net3)\",\n \"def test_SetMultipleMovingLoadsConfigurationCombined(self):\\n\\n # create nodes\\n second_coord = [1, 0, 0.0]\\n self.mp.CreateNewNode(1,0.0,0.0,0.0)\\n self.mp.CreateNewNode(2,second_coord[0],second_coord[1],0.0)\\n\\n # create condition\\n self.mp.CreateNewCondition(\\\"MovingLoadCondition2D2N\\\", 1, [1,2], self.mp.GetProperties()[1])\\n\\n parameters = self.base_parameters\\n parameters.AddVector(\\\"configuration\\\", [-0.25, 0, 0.25])\\n\\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0)\\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.DELTA_TIME, 0.25)\\n\\n process = GMA.SetMultipleMovingLoadsProcess(self.mp, parameters)\\n conditions = []\\n conditions.append(self.cmp.GetCondition(2))\\n conditions.append(self.cmp.GetCondition(3))\\n conditions.append(self.cmp.GetCondition(4))\\n\\n # initialise and set load\\n process.ExecuteInitialize()\\n process.ExecuteInitializeSolutionStep()\\n\\n\\n # set load on node\\n all_rhs = []\\n for cond in conditions:\\n # initialise matrices\\n lhs = KratosMultiphysics.Matrix(0, 0)\\n rhs = KratosMultiphysics.Vector(0)\\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\\n all_rhs.append(list(rhs))\\n\\n\\n self.checkRHS(all_rhs[0], [0.0, 0.0, 0.0, 0.0])\\n self.checkRHS(all_rhs[1], [0.0, -2.0, 0.0, 0.0])\\n self.checkRHS(all_rhs[2], [0.0, -1.5, 0.0, -0.5])\\n\\n # move load within first element\\n process.ExecuteFinalizeSolutionStep()\\n process.ExecuteInitializeSolutionStep()\\n\\n # check if interpolation is done correctly\\n all_rhs = []\\n for cond in conditions:\\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\\n all_rhs.append(list(rhs))\\n\\n self.checkRHS(all_rhs[0], [0.0, -2.0, 0.0, 0.0])\\n self.checkRHS(all_rhs[1], [0.0, -1.5, 0.0, -0.5])\\n self.checkRHS(all_rhs[2], [0.0, -1.0, 0.0, -1.0])\",\n \"def test_2(self):\\n for _ in range(33):\\n\\n # Create grid of admissible state space values.\\n num_edu_start = np.random.choice(range(1, 3))\\n num_periods = np.random.randint(1, 15)\\n num_types = np.random.randint(1, 3)\\n\\n edu_spec = {}\\n edu_spec[\\\"start\\\"] = np.random.choice(\\n range(1, 10), size=num_edu_start, replace=False\\n ).tolist()\\n edu_spec[\\\"max\\\"] = max(edu_spec[\\\"start\\\"]) + np.random.randint(1, 5)\\n min_idx = edu_spec[\\\"max\\\"] + 1\\n\\n # FORTRAN\\n base_args = (num_periods, num_types)\\n\\n state_space = StateSpace(*base_args, edu_spec[\\\"start\\\"], edu_spec[\\\"max\\\"])\\n\\n py_a, py_c, _, _ = state_space._get_fortran_counterparts()\\n py_b = state_space.states_per_period\\n py_d = py_b.max()\\n\\n fort_a, fort_b, fort_c, fort_d = fort_debug.wrapper_create_state_space(\\n *base_args, edu_spec[\\\"start\\\"], edu_spec[\\\"max\\\"], min_idx\\n )\\n\\n # Ensure equivalence\\n rslts = [[fort_a, py_a], [fort_b, py_b], [fort_c, py_c], [fort_d, py_d]]\\n for obj in rslts:\\n # Slice Fortran output to shape of Python output.\\n if isinstance(obj[0], np.ndarray):\\n obj[0] = obj[0][tuple(map(slice, obj[1].shape))]\\n\\n assert_allclose(obj[0], obj[1])\\n\\n for _ in range(100):\\n\\n # Draw random request for testing purposes\\n num_covars = np.random.randint(2, 10)\\n num_agents = np.random.randint(100, 1000)\\n tiny = np.random.normal(size=num_agents)\\n beta = np.random.normal(size=num_covars)\\n\\n # Generate sample\\n exog = np.random.sample((num_agents, num_covars))\\n exog[:, 0] = 1\\n endog = np.dot(exog, beta) + tiny\\n\\n # Run OLS\\n beta_result = ols(y=endog, x=exog)\\n\\n # Check parameters\\n py = beta_result\\n f90 = fort_debug.wrapper_get_coefficients(\\n endog, exog, num_covars, num_agents\\n )\\n assert_almost_equal(py, f90)\\n\\n # Check prediction\\n py = exog.dot(beta_result)\\n f90 = fort_debug.wrapper_point_predictions(exog, f90, num_agents)\\n assert_almost_equal(py, f90)\",\n \"def test_execute_non_gates(new_network):\\n network = new_network\\n devices = network.devices\\n names = devices.names\\n\\n LOW = devices.LOW\\n HIGH = devices.HIGH\\n\\n # Make different devices\\n [SW1_ID, SW2_ID, SW3_ID, CL_ID, D_ID] = names.lookup([\\\"Sw1\\\", \\\"Sw2\\\", \\\"Sw3\\\",\\n \\\"Clock1\\\", \\\"D1\\\"])\\n devices.make_device(SW1_ID, devices.SWITCH, 1)\\n devices.make_device(SW2_ID, devices.SWITCH, 0)\\n devices.make_device(SW3_ID, devices.SWITCH, 0)\\n devices.make_device(CL_ID, devices.CLOCK, 1)\\n devices.make_device(D_ID, devices.D_TYPE)\\n\\n # Make connections\\n network.make_connection(SW1_ID, None, D_ID, devices.DATA_ID)\\n network.make_connection(CL_ID, None, D_ID, devices.CLK_ID)\\n network.make_connection(SW2_ID, None, D_ID, devices.SET_ID)\\n network.make_connection(SW3_ID, None, D_ID, devices.CLEAR_ID)\\n\\n # Get device outputs, the expression is in a string here so that it\\n # can be re-evaluated again after executing devices\\n sw1_output = \\\"network.get_output_signal(SW1_ID, None)\\\"\\n sw2_output = \\\"network.get_output_signal(SW2_ID, None)\\\"\\n sw3_output = \\\"network.get_output_signal(SW3_ID, None)\\\"\\n clock_output = \\\"network.get_output_signal(CL_ID, None)\\\"\\n dtype_Q = \\\"network.get_output_signal(D_ID, devices.Q_ID)\\\"\\n dtype_QBAR = \\\"network.get_output_signal(D_ID, devices.QBAR_ID)\\\"\\n\\n # Execute devices until the clock is LOW at the start of its\\n # period\\n clock_device = devices.get_device(CL_ID)\\n network.execute_network()\\n while clock_device.clock_counter != 1 or eval(clock_output) != LOW:\\n network.execute_network()\\n\\n # The clock is not rising yet, Q could be (randomly) HIGH or LOW\\n assert [eval(sw1_output), eval(sw2_output), eval(sw3_output),\\n eval(clock_output)] == [HIGH, LOW, LOW, LOW]\\n\\n assert eval(dtype_Q) in [HIGH, LOW]\\n assert eval(dtype_QBAR) == network.invert_signal(eval(dtype_Q))\\n\\n network.execute_network() # the clock has risen\\n # While sw1(DATA) is high, Q has now changed to HIGH\\n assert [eval(sw1_output), eval(sw2_output), eval(sw3_output),\\n eval(clock_output), eval(dtype_Q), eval(dtype_QBAR)] == [\\n HIGH, LOW, LOW, HIGH, HIGH, LOW]\\n\\n devices.set_switch(SW1_ID, LOW) # Sw1 is connected to DATA\\n devices.set_switch(SW2_ID, HIGH) # Sw2 is connected to SET\\n network.execute_network() # the clock is not rising yet\\n network.execute_network() # the clock has risen\\n # Even if sw1(DATA) is LOW, and the clock is rising,\\n # sw2(SET) is HIGH, so Q is HIGH\\n assert [eval(sw1_output), eval(sw2_output), eval(sw3_output),\\n eval(clock_output), eval(dtype_Q), eval(dtype_QBAR)] == [\\n LOW, HIGH, LOW, HIGH, HIGH, LOW]\\n\\n devices.set_switch(SW1_ID, HIGH) # Sw1 is connected to DATA\\n devices.set_switch(SW2_ID, LOW) # Sw2 is connected to SET\\n devices.set_switch(SW3_ID, HIGH) # Sw3 is connected to CLEAR\\n network.execute_network() # the clock is not rising yet\\n network.execute_network() # the clock has risen\\n # Even if sw1(DATA) is HIGH, and the clock is rising,\\n # sw3(CLEAR) is HIGH, so Q is LOW\\n assert [eval(sw1_output), eval(sw2_output), eval(sw3_output),\\n eval(clock_output), eval(dtype_Q), eval(dtype_QBAR)] == [\\n HIGH, LOW, HIGH, HIGH, LOW, HIGH]\",\n \"def test_iterations(self):\\n grover = Grover(oracle=self._oracle, good_state=['111'], iterations=2)\\n ret = grover.run(self._sv)\\n self.assertTrue(Operator(ret['circuit']).equiv(Operator(self._expected)))\\n\\n grover = Grover(oracle=self._oracle, good_state=['111'], iterations=[1, 2, 3])\\n ret = grover.run(self._sv)\\n self.assertTrue(ret.oracle_evaluation)\\n self.assertIn(ret.top_measurement, ['111'])\",\n \"def test_SetMultipleMovingLoadsWithVelocityFunctionConfigurationNegative(self):\\n\\n # create nodes\\n second_coord = [1, 0, 0.0]\\n self.mp.CreateNewNode(1,0.0,0.0,0.0)\\n self.mp.CreateNewNode(2,second_coord[0],second_coord[1],0.0)\\n\\n # create condition\\n self.mp.CreateNewCondition(\\\"MovingLoadCondition2D2N\\\", 1, [1,2], self.mp.GetProperties()[1])\\n\\n parameters = self.base_parameters\\n parameters[\\\"velocity\\\"]=KratosMultiphysics.Parameters(self.time_dependent_velocity)\\n parameters.AddVector(\\\"configuration\\\", [-0.25])\\n\\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0)\\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.DELTA_TIME, 0.25)\\n\\n process = GMA.SetMultipleMovingLoadsProcess(self.mp, parameters)\\n cond = self.cmp.GetCondition(2)\\n\\n # initialise and set load\\n process.ExecuteInitialize()\\n process.ExecuteInitializeSolutionStep()\\n\\n # initialise matrices\\n lhs = KratosMultiphysics.Matrix(0, 0)\\n rhs = KratosMultiphysics.Vector(0)\\n\\n # set load on node\\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\\n\\n self.checkRHS(rhs, [0.0, 0.0, 0.0, 0.0])\\n\\n # change time and recalculate load\\n process.ExecuteFinalizeSolutionStep()\\n process.ExecuteInitializeSolutionStep()\\n\\n # check if interpolation is done correctly\\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\\n\\n self.checkRHS(rhs, [0.0, 0.0, 0.0, 0.0])\\n\\n self.mp.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0.5)\\n\\n process.ExecuteFinalizeSolutionStep()\\n process.ExecuteInitializeSolutionStep()\\n\\n # check if interpolation is done correctly\\n cond.CalculateLocalSystem(lhs, rhs, self.mp.ProcessInfo)\\n\\n self.checkRHS(rhs, [0.0, -2.0, 0.0, 0.0])\",\n \"def simulate_run(run, maker, all_data, train_mask, test_mask, instances, independent, mixture):\\n\\n train_data = all_data.masked(train_mask)\\n test_data = all_data.masked(test_mask)\\n\\n if instances is not None:\\n ids = sorted(train_data.run_lists, key = lambda _: numpy.random.rand())[:instances]\\n train_data = train_data.filter(*ids)\\n\\n if independent:\\n train_data = train_data.collect_independent(mixture).only_nonempty()\\n else:\\n train_data = train_data.collect_systematic(mixture).only_nonempty()\\n\\n budget = test_data.common_budget\\n #budget = test_data.common_budget / 2 # XXX\\n suite = borg.fake.FakeSuite(test_data)\\n\\n if maker.subname == \\\"preplanning-dir\\\":\\n model_kwargs = {\\\"K\\\": 64}\\n\\n if \\\"set_alpha\\\" in maker.variants:\\n model_kwargs[\\\"alpha\\\"] = 1e-2\\n else:\\n model_kwargs = {}\\n\\n solver = maker(suite, train_data, model_kwargs = model_kwargs)\\n successes = []\\n\\n for (i, instance_id) in enumerate(test_data.run_lists):\\n logger.info(\\\"simulating run %i/%i on %s\\\", i, len(test_data), instance_id)\\n\\n with suite.domain.task_from_path(instance_id) as instance:\\n with borg.accounting() as accountant:\\n answer = solver.start(instance).run_then_stop(budget)\\n\\n succeeded = suite.domain.is_final(instance, answer)\\n\\n logger.info(\\n \\\"%s %s on %s (%.2f CPU s)\\\",\\n maker.name,\\n \\\"succeeded\\\" if succeeded else \\\"failed\\\",\\n os.path.basename(instance),\\n accountant.total.cpu_seconds,\\n )\\n\\n if succeeded:\\n successes.append(accountant.total.cpu_seconds)\\n\\n logger.info(\\n \\\"%s had %i successes over %i instances\\\",\\n maker.name,\\n len(successes),\\n len(test_data),\\n )\\n\\n description = \\\"{0} ({1})\\\".format(mixture, \\\"Sep.\\\" if independent else \\\"Sys.\\\")\\n\\n return (\\n description,\\n maker.name,\\n instances,\\n len(successes),\\n numpy.mean(successes),\\n numpy.median(successes),\\n )\",\n \"def generate_scenario_3(seed=1996, permanent_save=True, radar_meas_rate=1, ais_meas_rate=5, sigma_process=0.01,\\n sigma_meas_radar=3, sigma_meas_ais=1, timesteps=20):\\n start_time = datetime.now()\\n\\n # specify seed to be able to repeat the example\\n np.random.seed(seed)\\n\\n # combine two 1-D CV models to create a 2-D CV model\\n transition_model = CombinedLinearGaussianTransitionModel(\\n [ConstantVelocity(sigma_process), ConstantVelocity(sigma_process)])\\n\\n # starting at 0,0 and moving NE\\n truth = GroundTruthPath([GroundTruthState([0, 1, 0, 1], timestamp=start_time)])\\n\\n # generate truth using transition_model and noise\\n end_time = start_time + timedelta(seconds=timesteps * max(radar_meas_rate, ais_meas_rate))\\n time = start_time + timedelta(seconds=1)\\n while time < end_time:\\n truth.append(GroundTruthState(\\n transition_model.function(truth[-1], noise=True, time_interval=timedelta(seconds=1)),\\n timestamp=time))\\n time += timedelta(seconds=1)\\n\\n # Simulate measurements\\n # Specify measurement model for radar\\n measurement_model_radar = LinearGaussian(\\n ndim_state=4, # number of state dimensions\\n mapping=(0, 2), # mapping measurement vector index to state index\\n noise_covar=np.array([[sigma_meas_radar, 0], # covariance matrix for Gaussian PDF\\n [0, sigma_meas_radar]])\\n )\\n\\n # Specify measurement model for AIS (Same as for radar)\\n measurement_model_ais = LinearGaussian(\\n ndim_state=4,\\n mapping=(0, 2),\\n noise_covar=np.array([[sigma_meas_ais, 0],\\n [0, sigma_meas_ais]])\\n )\\n\\n # generate \\\"radar\\\" measurements\\n measurements_radar = []\\n measurements_ais = []\\n next_radar_meas_time = start_time\\n next_ais_meas_time = start_time\\n for state in truth:\\n # check whether we want to generate a measurement from this gt\\n if state.timestamp == next_radar_meas_time:\\n measurement = measurement_model_radar.function(state, noise=True)\\n measurements_radar.append(Detection(measurement, timestamp=state.timestamp))\\n next_radar_meas_time += timedelta(seconds=radar_meas_rate)\\n\\n if state.timestamp == next_ais_meas_time:\\n measurement = measurement_model_ais.function(state, noise=True)\\n measurements_ais.append(Detection(measurement, timestamp=state.timestamp))\\n next_ais_meas_time += timedelta(seconds=ais_meas_rate)\\n\\n if permanent_save:\\n save_folder_name = seed.__str__()\\n else:\\n save_folder_name = \\\"temp\\\"\\n\\n save_folder = \\\"../scenarios/scenario3/\\\" + save_folder_name + \\\"/\\\"\\n\\n # save the ground truth and the measurements for the radar and the AIS\\n store_object.store_object(truth, save_folder, \\\"ground_truth.pk1\\\")\\n store_object.store_object(measurements_radar, save_folder, \\\"measurements_radar.pk1\\\")\\n store_object.store_object(measurements_ais, save_folder, \\\"measurements_ais.pk1\\\")\\n store_object.store_object(start_time, save_folder, \\\"start_time.pk1\\\")\\n store_object.store_object(measurement_model_radar, save_folder, \\\"measurement_model_radar.pk1\\\")\\n store_object.store_object(measurement_model_ais, save_folder, \\\"measurement_model_ais.pk1\\\")\\n store_object.store_object(transition_model, save_folder, \\\"transition_model.pk1\\\")\",\n \"def main():\\n dirPath = \\\"./tests/\\\"\\n score = 0\\n\\n # Run test files to check correctness\\n print(\\\"\\\\n======================= TEST CORRECTNESS =======================\\\\n\\\")\\n\\n print(\\\"\\\\n------- There are no Euler circuits in the first two tests -----\\\\n\\\")\\n\\n score += 4 - testInput(dirPath + \\\"disconnected\\\", 0)\\n print(\\\"Score so far: \\\" + str(score))\\n\\n score += 5 - testInput(dirPath + \\\"noEuler\\\", 0)\\n print(\\\"Score so far: \\\" + str(score))\\n\\n print(\\\"\\\\n------- From now on all test graphs have Euler circuits -------\\\\n\\\")\\n\\n score += testInput(dirPath + \\\"small\\\", 6)\\n print(\\\"Score so far: \\\" + str(score))\\n\\n score += testInput(dirPath + \\\"medium\\\", 5)\\n print(\\\"Score so far: \\\" + str(score))\\n\\n score += testInput(dirPath + \\\"large\\\", 6)\\n print(\\\"Score so far: \\\" + str(score))\\n\\n score += 4 * testInput(dirPath + \\\"verylarge\\\", 1)\\n print(\\\"Correctness score: \\\" + str(score) + \\\" out of 30.\\\")\\n\\n # Test very large graphs\\n print(\\\"\\\\n======================= TEST EFFICIENCY =======================\\\\n\\\")\\n\\n score += 2 * testInput(dirPath + \\\"huge1\\\", 1)\\n print(\\\"Score so far: \\\" + str(score) + \\\" out of 40.\\\")\\n\\n score += 2 * testInput(dirPath + \\\"huge2\\\", 1)\\n print(\\\"Score so far: \\\" + str(score) + \\\" out of 40.\\\")\\n\\n score += 2 * testInput(dirPath + \\\"huge3\\\", 1)\\n print(\\\"Score so far: \\\" + str(score) + \\\" out of 40.\\\")\\n\\n score += 2 * testInput(dirPath + \\\"huge4\\\", 1)\\n print(\\\"Score so far: \\\" + str(score) + \\\" out of 40.\\\")\\n\\n score += 2 * testInput(dirPath + \\\"huge5\\\", 1)\\n print(\\\"Final score: \\\" + str(score) + \\\" out of 40.\\\")\",\n \"def test_run():\\n # Only few steps for test\\n timesteps = 128\\n\\n # Compute all sub testing conf\\n envs = ['CartPole-v0']\\n ml_platforms = ['torch', 'tf']\\n agents = ['dqn', 'a2c']\\n\\n test_combinations = list(it.product(\\n envs,\\n ml_platforms,\\n agents\\n )\\n )\\n\\n # Finally test them all\\n for conf in test_combinations:\\n env_str, ml_platform_str, agent_str = conf\\n run(\\n agent_str,\\n ml_platform_str,\\n env_str,\\n 'dense',\\n timesteps,\\n './target/')\",\n \"def standardRun(\\n\\tnIterations=3000000, gridLength=40, alloyFraction=50, Eam=0.1, T=300,\\n\\tdimensions=2, showMatrixImages=True):\\n\\talloyGrid = srf.initializeGrid(gridLength, alloyFraction, dimensions)\\n\\t# Sets up list list to take current system energy as simulation progresses\\n\\tenergyList = [0] * (nIterations + 1)\\n\\tenergyList[0] = sref.getTotalEnergy(alloyGrid, Eam, dimensions)\\n\\n\\tif showMatrixImages and dimensions == 2:\\n\\t\\t# Display initial matrix\\n\\t\\tpyplot.figure(num=\\\"Initial config\\\")\\n\\t\\timg1 = pyplot.imshow(alloyGrid, interpolation='nearest')\\n\\t\\tpyplot.colorbar(img1)\\n\\n\\torderMeasure1, actualList, binList = sref.getOrder(\\n\\t\\talloyGrid, alloyFraction, dimensions)\\n\\tprint(\\\"Initial order is: {}\\\".format(str(orderMeasure1)))\\n\\talloyGrid, energyList = srf.runSim(\\n\\t\\talloyGrid, energyList, T, Eam, nIterations, gridLength, dimensions)\\n\\n\\tif showMatrixImages and dimensions == 2:\\n\\t\\t# Display matrix in prettier form, as a coloured graph\\n\\t\\tpyplot.figure(num=\\\"Final config\\\")\\n\\t\\timg2 = pyplot.imshow(alloyGrid, interpolation='nearest')\\n\\t\\tpyplot.colorbar(img2)\\n\\t\\tpyplot.show()\\n\\n\\torderMeasure2, actualList, binList = sref.getOrder(\\n\\t\\talloyGrid, alloyFraction, dimensions)\\n\\tprint(\\\"Final order is: {}\\\".format(str(orderMeasure2)))\",\n \"def test_cli_simulation(self):\\n self.run_owtf('-s')\\n self.assert_is_in_logs(\\n 'All jobs have been done. Exiting.',\\n name='MainProcess',\\n msg='OWTF did not finish properly!')\\n plugin_handler = ServiceLocator.get_component(\\\"plugin_handler\\\")\\n self.assertTrue(\\n plugin_handler.Simulation,\\n msg='OWTF should have been run in simulation mode!')\",\n \"def test(self, num_decisions=1000):\\n all_grid_states = []\\n all_grid_rewards = []\\n\\n all_grid_states_cluster = []\\n all_surrounding_states_cluster = []\\n\\n all_system_rewards = []\\n all_system_states = []\\n all_system_states_cluster = []\\n\\n all_actions = []\\n all_dissipation = []\\n\\n os.system(\\\"mkdir \\\" + self.folder_name + \\\"Test/\\\")\\n filename = self.folder_name + \\\"Test/\\\" + \\\"TEST.h5\\\"\\n self.system.reset_context(filename)\\n tag = \\\"_test_init\\\"\\n self.system.run_decorrelation(20)\\n\\n grid_dist, surrounding_dist, _, _, _, _ = self.system.get_state_reward()\\n state = self._get_state(grid_dist, surrounding_dist)\\n\\n all_dissipation.append(self.system.get_dissipation())\\n for i in range(num_decisions):\\n action_index = self._get_action(state, episode=10000)\\n tag = \\\"_test_\\\" + str(i)\\n actions = [self.all_actions[i] for i in action_index]\\n all_actions.append(actions)\\n self.system.update_action(actions)\\n system_states, system_rewards, system_states_cluster = self.system.run_step(\\n is_detailed=True, tag=tag)\\n\\n grid_dist, surrounding_dist, grid_reward, surrounding_reward, grid_states_cluster, surrounding_states_cluster = self.system.get_state_reward()\\n\\n # The \\\"grid states\\\" and dissipation are recorded at the end of a decision\\n # Dissipation here is total entropy production (not epr)\\n # Actions are recorded at the beginning of the decision\\n\\n state = self._get_state(grid_dist, surrounding_dist)\\n reward = self._get_reward(grid_reward, surrounding_reward)\\n\\n all_grid_states.append(state)\\n all_grid_rewards.append(reward)\\n\\n all_grid_states_cluster.append(grid_states_cluster)\\n all_surrounding_states_cluster.append(surrounding_states_cluster)\\n\\n all_dissipation.append(self.system.get_dissipation())\\n\\n # The \\\"System States\\\" are recorded every 0.25 seconds. Excludes 0th second\\n all_system_states.append(system_states)\\n # Just to have a 1D array use extend\\n all_system_rewards.append(system_rewards)\\n all_system_states_cluster.append(system_states_cluster)\\n\\n if (i % 100 == 99):\\n np.save(self.folder_name + \\\"grid_rewards\\\",\\n np.array(all_grid_rewards))\\n np.save(self.folder_name + \\\"grid_states\\\",\\n np.array(all_grid_states, dtype=object))\\n np.save(self.folder_name + \\\"grid_states_cluster\\\",\\n np.array(all_grid_states_cluster, dtype=object))\\n\\n np.save(self.folder_name + \\\"surrounding_states_cluster\\\",\\n np.array(all_surrounding_states_cluster))\\n\\n np.save(self.folder_name + \\\"actions\\\", np.array(all_actions))\\n\\n np.save(self.folder_name + \\\"dissipation\\\",\\n np.array(all_dissipation))\\n np.save(self.folder_name + \\\"system_states\\\",\\n np.array(all_system_states))\\n np.save(self.folder_name + \\\"system_states_cluster\\\",\\n np.array(all_system_states_cluster))\\n np.save(self.folder_name + \\\"system_rewards\\\",\\n np.array(all_system_rewards))\",\n \"def test(args):\\n brain_name = env.brain_names[0]\\n brain = env.brains[brain_name]\\n env_info = env.reset(train_mode=True)[brain_name]\\n\\n num_agents = len(env_info.agents)\\n print('Number of agents:', num_agents)\\n\\n # dim of each action\\n action_size = brain.vector_action_space_size\\n print('Size of each action:', action_size)\\n\\n # dim of the state space\\n states = env_info.vector_observations\\n state_size = states.shape[1]\\n\\n agent = MADDPG(state_size, action_size, actor_layer_dim_1=args.actor_layer_dim_1,\\n actor_layer_dim_2=args.actor_layer_dim_2,\\n actor_layer_dim_3=args.actor_layer_dim_3,\\n critic_layer_dim_1=args.critic_layer_dim_1,\\n critic_layer_dim_2=args.critic_layer_dim_2,\\n critic_layer_dim_3=args.critic_layer_dim_3)\\n\\n agent.load(\\n \\\"chkpts/{}/{:02d}_best_model.checkpoint\\\".format(args.model_path, args.loop_counter))\\n\\n test_scores = []\\n for i_episode in tqdm(range(1, 1+args.test_n_run)):\\n # initialize the scores\\n scores = np.zeros(num_agents)\\n env_info = env.reset(train_mode=True)[\\n brain_name] # reset the environment\\n states = env_info.vector_observations # get the current states\\n dones = [False]*num_agents\\n while not np.any(dones):\\n actions = agent.act(states) # select actions\\n # send the actions to the environment\\n env_info = env.step(actions)[brain_name]\\n next_states = env_info.vector_observations # get the next states\\n rewards = env_info.rewards # get the rewards\\n dones = env_info.local_done # see if episode has finished\\n scores += rewards # update the scores\\n # roll over the states to next time step\\n states = next_states\\n\\n test_scores.append(np.max(scores))\\n\\n avg_score = sum(test_scores)/len(test_scores)\\n print(\\\"Test Score: {}\\\".format(avg_score))\\n\\n return avg_score\",\n \"def test_scenario_2(scenario):\\n nt_server, nt_client, nt_client2, st, ct1, ct2 = scenario\\n\\n nt_client.disconnect()\\n nt_client2.disconnect()\\n\\n ct1.putString(\\\"Client1Only\\\", \\\"11\\\")\\n ct1.putString(\\\"SC1Shared\\\", \\\"11\\\")\\n ct1.putString(\\\"ClientShared\\\", \\\"11\\\")\\n\\n ct2.putString(\\\"Client2Only\\\", \\\"12\\\")\\n ct2.putString(\\\"SC2Shared\\\", \\\"12\\\")\\n ct2.putString(\\\"ClientShared\\\", \\\"12\\\")\\n\\n st.putString(\\\"ServerOnly\\\", \\\"10\\\")\\n st.putString(\\\"SC1Shared\\\", \\\"10\\\")\\n st.putString(\\\"SC2Shared\\\", \\\"10\\\")\\n\\n with nt_server.expect_changes(3):\\n with nt_client.expect_changes(3):\\n nt_client.start_test()\\n\\n with nt_server.expect_changes(3):\\n with nt_client.expect_changes(3):\\n with nt_client2.expect_changes(3):\\n nt_client2.start_test()\\n\\n check_results(\\n st,\\n ct1,\\n ct2,\\n ServerOnly=10,\\n Client1Only=11,\\n Client2Only=12,\\n SC1Shared=11,\\n SC2Shared=12,\\n ClientShared=12,\\n )\",\n \"def exercise1d():\\n\\n # Defination of muscles\\n muscle_parameters = MuscleParameters()\\n print(muscle_parameters.showParameters())\\n\\n mass_parameters = MassParameters()\\n print(mass_parameters.showParameters())\\n\\n # Create muscle object\\n muscle = Muscle(muscle_parameters)\\n\\n # Create mass object\\n mass = Mass(mass_parameters)\\n\\n pylog.warning(\\\"Isotonic muscle contraction to be implemented\\\")\\n\\n # Instatiate isotonic muscle system\\n sys = IsotonicMuscleSystem()\\n\\n # Add the muscle to the system\\n sys.add_muscle(muscle)\\n\\n # Add the mass to the system\\n sys.add_mass(mass)\\n\\n # You can still access the muscle inside the system by doing\\n # >>> sys.muscle.L_OPT # To get the muscle optimal length\\n\\n # Evalute for a single load\\n load = 100.\\n\\n # Evalute for a single muscle stimulation\\n muscle_stimulation = 1.\\n\\n # Set the initial condition\\n x0 = [0.0, sys.muscle.L_OPT,\\n sys.muscle.L_OPT + sys.muscle.L_SLACK, 0.0]\\n \\n # x0[0] - -> activation\\n # x0[1] - -> contractile length(l_ce)\\n # x0[2] - -> position of the mass/load\\n # x0[3] - -> velocity of the mass/load\\n \\n\\n # Set the time for integration\\n t_start = 0.0\\n t_stop = 0.5\\n time_step = 0.001\\n time_stabilize = 0.2\\n\\n time = np.arange(t_start, t_stop, time_step)\\n \\n loads = np.arange(20, 351, 10)\\n \\n velocities = []\\n\\n for index, load in enumerate(loads):\\n \\n # Run the integration\\n result = sys.integrate(x0=x0,\\n time=time,\\n time_step=time_step,\\n time_stabilize=time_stabilize,\\n stimulation=muscle_stimulation,\\n load=load) \\n\\n if (result.l_mtc[-1] < sys.muscle.L_OPT + sys.muscle.L_SLACK):\\n velocities.append(np.max(result.v_ce))\\n print('max')\\n else:\\n velocities.append(np.min(result.v_ce))\\n print('min')\\n\\n\\n #Muscle contracile Velocity - Tension (load) relationship\\n \\n plt.figure('Isotonic muscle experiment')\\n plt.title('Isotonic muscle experiment')\\n plt.xlabel('Muscle Contractile Velocity [m/s]')\\n plt.ylabel('Tension (load) [N]')\\n plt.plot(velocities, loads)\\n plt.grid()\\n \\n #For different stimulations 1.f\\n \\n muscle_stimulation = np.arange(0,1.1,0.2)\\n plt.figure('Isotonic muscle exp with different stimulations')\\n plt.title('Isotonic muscle experiment with different stimulations')\\n\\n for stim in muscle_stimulation:\\n velocities = []\\n for index, load in enumerate(loads):\\n # Run the integration\\n result = sys.integrate(x0=x0,\\n time=time,\\n time_step=time_step,\\n time_stabilize=time_stabilize,\\n stimulation=stim,\\n load=load) \\n\\n if (result.l_mtc[-1] < sys.muscle.L_OPT + sys.muscle.L_SLACK):\\n velocities.append(np.max(result.v_ce))\\n else:\\n velocities.append(np.min(result.v_ce))\\n plt.xlabel('Muscle Contractile Velocity [m/s]')\\n plt.ylabel('Tension (load) [N]')\\n plt.plot(velocities, loads)\\n \\n plt.legend(('0','0.2','0.4','0.6','0.8','1.0'))\\n plt.grid()\",\n \"def test_teleport_default_basis_gates(self):\\n shots = 2000\\n circuits = ref_algorithms.teleport_circuit()\\n targets = ref_algorithms.teleport_counts(shots)\\n job = execute(circuits, QasmSimulator(), shots=shots)\\n result = job.result()\\n self.is_completed(result)\\n self.compare_counts(result, circuits, targets, delta=0.05 * shots)\",\n \"def test_minimise_reentrant():\\n # Set parameters for number of iterations and evaluation frequency\\n n_iters_1 = 23\\n eval_every_1 = 5\\n n_iters_2 = 31\\n eval_every_2 = 3\\n # Create model and data\\n np.random.seed(6307)\\n model = get_random_network(input_dim=1, output_dim=1)\\n sin_data = data.Sinusoidal(input_dim=1, output_dim=1, freq=1)\\n # Open result file\\n results_filename = \\\"Test AbstractOptimiser.optimise method re-entrant.txt\\\"\\n results_path = os.path.join(output_dir, results_filename)\\n with open(results_path, \\\"w\\\") as results_file:\\n # Create Result object\\n result = optimisers.Result(\\n name=\\\"SGD without line search\\\", \\n verbose=True,\\n file=results_file\\n )\\n # Call gradient descent function twice\\n result_ls = optimisers.gradient_descent(\\n model,\\n sin_data,\\n terminator=optimisers.Terminator(i_lim=n_iters_1),\\n evaluator=optimisers.Evaluator(i_interval=eval_every_1),\\n result=result,\\n display_summary=False\\n )\\n result_ls = optimisers.gradient_descent(\\n model,\\n sin_data,\\n terminator=optimisers.Terminator(i_lim=n_iters_2),\\n evaluator=optimisers.Evaluator(i_interval=eval_every_2),\\n result=result\\n )\\n # Check values in time column are monotonically increasing\\n time_values = result.get_values(optimisers.results.columns.Time)\\n for i in range(1, len(time_values)):\\n assert time_values[i] > time_values[i - 1]\\n # Check values in iteration column are monotonically increasing\\n iteration_values = result.get_values(optimisers.results.columns.Iteration)\\n for i in range(1, len(iteration_values)):\\n assert iteration_values[i] > iteration_values[i - 1]\\n # Assert that the list of iteration values is exactly what we expect\\n all_iter_vals = (\\n list(range(0, n_iters_1, eval_every_1)) +\\n list(range(n_iters_1, n_iters_1 + n_iters_2, eval_every_2)) +\\n [n_iters_1 + n_iters_2]\\n )\\n assert all_iter_vals == iteration_values\",\n \"def test_sdg_gate_deterministic_default_basis_gates(self):\\n shots = 100\\n circuits = ref_1q_clifford.sdg_gate_circuits_deterministic(final_measure=True)\\n targets = ref_1q_clifford.sdg_gate_counts_deterministic(shots)\\n job = execute(circuits, QasmSimulator(), shots=shots)\\n result = job.result()\\n self.is_completed(result)\\n self.compare_counts(result, circuits, targets, delta=0)\",\n \"def test_GA_sanity():\\n\\tga = GA.GA(2,3)\\n\\tgenomes = ga.seedGenomes()\\n\\tif len(genomes) != 2:\\n\\t\\tprint \\\"Wrong number of genomes\\\"\\n\\tif len(genomes[0]) != 3:\\n\\t\\tprint \\\"Wrong size in genomes\\\"\\n\\t#print genomes\\n\\t#live and learn\\n\\tfitnesses = [23, 45]\\n\\tga.fitnessUpdate(fitnesses)\\n\\tgenomes2 = ga.createNextGeneration()\\n\\tif len(genomes2) != 2:\\n\\t\\tprint \\\"Wrong number of genomes\\\"\\n\\tif len(genomes2[0]) != 3:\\n\\t\\tprint \\\"Wrong size in genomes\\\"\\n\\t#print genomes2\",\n \"def main(self) -> tuple[bool, bool]:\\n self.simulation_parameters, running, reset, back_to_main_menu = self.show_start_screen()\\n if back_to_main_menu:\\n return reset, True\\n if running:\\n self.initialize()\\n while running:\\n running, reset = self.do_simulation_loop()\\n return reset, False\",\n \"def setUpClass(cls):\\n cls.sim1 = Simulation(logging_level=50)\\n cls.sim1.set_simulation_parameters(\\n seed=1, task=47, output_directory=\\\"output\\\", min_speciation_rate=0.01, sigma=2, deme=1, sample_size=0.01\\n )\\n cls.sim1.set_map_files(\\n \\\"null\\\", fine_file=\\\"sample/SA_sample_fine.tif\\\", reproduction_map=\\\"sample/SA_sample_reproduction.tif\\\"\\n )\\n cls.sim1.run()\\n cls.sim2 = Simulation(logging_level=50)\\n cls.sim2.set_simulation_parameters(\\n seed=1, task=48, output_directory=\\\"output\\\", min_speciation_rate=0.01, sigma=2, deme=1, sample_size=0.01\\n )\\n cls.sim2.set_map_files(\\\"null\\\", fine_file=\\\"sample/SA_sample_fine.tif\\\")\\n cls.sim2.run()\\n cls.sim3 = Simulation(logging_level=50)\\n cls.sim3.set_simulation_parameters(\\n seed=2, task=47, output_directory=\\\"output\\\", min_speciation_rate=0.01, sigma=2, deme=1, sample_size=0.01\\n )\\n cls.sim3.set_map_files(\\n \\\"null\\\",\\n fine_file=\\\"sample/SA_sample_fine.tif\\\",\\n death_map=\\\"sample/SA_sample_reproduction.tif\\\",\\n reproduction_map=\\\"sample/SA_sample_reproduction.tif\\\",\\n )\\n cls.sim3.run()\\n cls.sim4 = Simulation(logging_level=50)\\n cls.sim4.set_simulation_parameters(\\n seed=4, task=47, output_directory=\\\"output\\\", min_speciation_rate=0.01, sigma=2, deme=1, sample_size=0.01\\n )\\n cls.sim4.set_map_files(\\\"null\\\", fine_file=\\\"sample/SA_sample_coarse_pristine.tif\\\")\\n cls.sim4.add_reproduction_map(reproduction_map=\\\"sample/SA_reproduction_coarse.tif\\\")\\n cls.sim4.add_death_map(death_map=\\\"sample/SA_death.tif\\\")\\n cls.sim4.add_dispersal_map(dispersal_map=\\\"sample/dispersal_fine2.tif\\\")\\n cls.sim4.run()\\n cls.coal1 = CoalescenceTree(cls.sim1)\\n cls.coal2 = CoalescenceTree(cls.sim2)\\n cls.coal3 = CoalescenceTree(cls.sim3)\\n cls.coal4 = CoalescenceTree(cls.sim4)\",\n \"def test_marketsim(description, group, inputs, outputs, grader):\\n\\n points_earned = 0.0 # initialize points for this test case\\n try:\\n # Try to import student code (only once)\\n if not main_code in globals():\\n import importlib\\n # * Import module\\n mod = importlib.import_module(main_code)\\n globals()[main_code] = mod\\n # * Import methods to test\\n for m in ['compute_portvals']:\\n globals()[m] = getattr(mod, m)\\n\\n incorrect = False\\n msgs = []\\n\\n if group == 'author':\\n try:\\n # globals()['author'] = getattr(marketsim, 'author')\\n auth_string = run_with_timeout(marketsim.author,seconds_per_test_case,(),{})\\n if auth_string == 'tb34':\\n incorrect = True\\n msgs.append(\\\" Incorrect author name (tb34)\\\")\\n points_earned = -20\\n elif auth_string == '':\\n incorrect = True\\n msgs.append(\\\" Empty author name\\\")\\n points_earned = -20\\n except Exception as e:\\n incorrect = True\\n msgs.append(\\\" Exception occured when calling author() method: {}\\\".format(e))\\n points_earned = -20\\n else:\\n # Unpack test case\\n orders_file = inputs['orders_file']\\n start_val = inputs['start_val']\\n\\n portvals = None\\n fullpath_orders_file = orders_file#get_orders_data_file(orders_file)\\n portvals = run_with_timeout(compute_portvals,seconds_per_test_case,(fullpath_orders_file,start_val),{})\\n # Verify against expected outputs and assign points\\n\\n # * Check return type is correct, coax into Series\\n assert (type(portvals) == pd.Series) or (type(portvals) == pd.DataFrame and len(portvals.columns) == 1), \\\"You must return a Series or single-column DataFrame!\\\"\\n if type(portvals) == pd.DataFrame:\\n portvals = portvals[portvals.columns[0]] # convert single-column DataFrame to Series\\n if group == 'basic':\\n if len(portvals) != outputs['num_days']:\\n incorrect=True\\n msgs.append(\\\" Incorrect number of days: {}, expected {}\\\".format(len(portvals), outputs['num_days']))\\n else:\\n points_earned += 2.0\\n if abs(portvals[-1]-outputs['last_day_portval']) > (0.001*outputs['last_day_portval']):\\n incorrect=True\\n msgs.append(\\\" Incorrect final value: {}, expected {}\\\".format(portvals[-1],outputs['last_day_portval']))\\n else:\\n points_earned += 5.0\\n adr,sr = get_stats(portvals)\\n if abs(sr-outputs['sharpe_ratio']) > abs(0.001*outputs['sharpe_ratio']):\\n incorrect=True\\n msgs.append(\\\" Incorrect sharpe ratio: {}, expected {}\\\".format(sr,outputs['sharpe_ratio']))\\n else:\\n points_earned += 1.5\\n if abs(adr-outputs['avg_daily_ret']) > abs(0.001*outputs['avg_daily_ret']):\\n incorrect=True\\n msgs.append(\\\" Incorrect avg daily return: {}, expected {}\\\".format(adr,outputs['avg_daily_ret']))\\n else:\\n points_earned += 1.0\\n elif group=='leverage':\\n if abs(portvals[-1]-outputs['last_day_portval']) > (0.001*outputs['last_day_portval']):\\n incorrect = True\\n msgs.append(\\\" Incorrect final value: {}, expected {}\\\".format(portvals[-1],outputs['last_day_portval']))\\n else:\\n points_earned += 1.0\\n if incorrect:\\n # inputs_str = \\\" orders_file: {}\\\\n\\\" \\\\\\n # \\\" start_val: {}\\\\n\\\".format(orders_file, start_val)\\n raise IncorrectOutput, \\\"Test failed on one or more output criteria.\\\\n Inputs:\\\\n{}\\\\n Failures:\\\\n{}\\\".format(inputs, \\\"\\\\n\\\".join(msgs))\\n except Exception as e:\\n # Test result: failed\\n msg = \\\"Test case description: {}\\\\n\\\".format(description)\\n \\n # Generate a filtered stacktrace, only showing erroneous lines in student file(s)\\n \\n tb_list = tb.extract_tb(sys.exc_info()[2])\\n if 'grading_traceback' in dir(e):\\n tb_list = e.grading_traceback\\n for i in xrange(len(tb_list)):\\n row = tb_list[i]\\n tb_list[i] = (os.path.basename(row[0]), row[1], row[2], row[3]) # show only filename instead of long absolute path\\n tb_list = [row for row in tb_list if row[0] == 'marketsim.py']\\n if tb_list:\\n msg += \\\"Traceback:\\\\n\\\"\\n msg += ''.join(tb.format_list(tb_list)) # contains newlines\\n msg += \\\"{}: {}\\\".format(e.__class__.__name__, e.message)\\n\\n # Report failure result to grader, with stacktrace\\n grader.add_result(GradeResult(outcome='failed', points=points_earned, msg=msg))\\n raise\\n else:\\n # Test result: passed (no exceptions)\\n grader.add_result(GradeResult(outcome='passed', points=points_earned, msg=None))\",\n \"def run(num_trials):\\n\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n a = e.create_agent(LearningAgent) # create agent\\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.1, display=True) \\n # create simulator (uses pygame when display=True, if available)\\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\\n\\n sim.run(n_trials=num_trials) # run for a specified number of trials\\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\\n\\n a.performace_report(num_trials)\",\n \"def run_test0():\\r\\n \\r\\n ndia, nadi, nnucl, ntraj = 1, 1, 2, 500\\r\\n\\r\\n # ======= Hierarchy of Hamiltonians =======\\r\\n ham = nHamiltonian(ndia, nadi, nnucl)\\r\\n ham.init_all(2)\\r\\n print \\\"id=\\\", ham.id, \\\" level=\\\", ham.level\\r\\n\\r\\n ham1 = [] \\r\\n for tr in xrange(ntraj):\\r\\n ham1.append( nHamiltonian(ndia, nadi, nnucl) ) \\r\\n print ham1[tr].id, ham1[tr].level\\r\\n ham1[tr].init_all(2)\\r\\n ham.add_child(ham1[tr])\\r\\n print Cpp2Py(ham1[tr].get_full_id())\\r\\n\\r\\n # Set up the models and compute internal variables\\r\\n # Initialization\\r\\n # Model parameters \\r\\n params = { \\\"model\\\":1 }\\r\\n\\r\\n # Simulation parameters\\r\\n dt = 1.0\\r\\n\\r\\n # Dynamical variables and system-specific properties\\r\\n mean_q = MATRIX(nnucl,1); \\r\\n sigma_q = MATRIX(nnucl,1); \\r\\n mean_p = MATRIX(nnucl,1); \\r\\n sigma_p = MATRIX(nnucl,1); \\r\\n iM = MATRIX(nnucl,1);\\r\\n\\r\\n for i in xrange(nnucl):\\r\\n mean_q.set(i,0, -1.0) \\r\\n sigma_q.set(i,0, 0.05) \\r\\n mean_p.set(i,0, 0.0) \\r\\n sigma_p.set(i,0, 0.0)\\r\\n iM.set(i,0, 1.0/2000.0)\\r\\n\\r\\n rnd = Random()\\r\\n q = MATRIX(nnucl,ntraj); aux_functs.sample(q, mean_q, sigma_q, rnd)\\r\\n p = MATRIX(nnucl,ntraj); aux_functs.sample(p, mean_p, sigma_p, rnd) \\r\\n\\r\\n # Initial calculations\\r\\n q.show_matrix()\\r\\n\\r\\n # Compute Initial trajectory probability distributions for all dof\\r\\n #bin(q, -2.0, 2.0, 0.01)\\r\\n\\r\\n ham.compute_diabatic(compute_model, q, params, 1)\\r\\n ham.compute_adiabatic(1, 1);\\r\\n ham.add_ethd_adi(q, iM, 1)\\r\\n\\r\\n os.system(\\\"mkdir _2D_dist\\\")\\r\\n out1 = open(\\\"_output.txt\\\", \\\"w\\\"); out1.close() \\r\\n\\r\\n # Do the propagation\\r\\n for i in xrange(100):\\r\\n\\r\\n aux_functs.bin2(q, -2.0, 2.0, 0.1, -2.0, 2.0, 0.1, \\\"_2D_dist/_2D_distrib_\\\"+str(i)+\\\"_.txt\\\")\\r\\n\\r\\n Verlet1(dt, q, p, iM, ham, compute_model, params, 1)\\r\\n\\r\\n #=========== Properties ==========\\r\\n\\r\\n Ekin, Epot, Etot = aux_functs.compute_etot(ham, p, iM)\\r\\n\\r\\n # Print the ensemble average - kinetic, potential, and total energies\\r\\n # Print the tunneling information. Here, we count each trajectory across the barrier.\\r\\n out1 = open(\\\"_output.txt\\\", \\\"a\\\")\\r\\n out1.write( \\\" %8.5f %8.5f %8.5f %8.5f\\\\n\\\" % ( i*dt, Ekin, Epot, Etot ) )\\r\\n out1.close()\",\n \"def test_compare_solver():\\n # initialize all solver\\n solver_1 = EulerSolver()\\n solver_2 = ScipyOdeSolver('dopri5')\\n solver_3 = ScipySolveIvpSolver(method='Radau')\\n solver_4 = ScipyOdeIntSolver()\\n solver = [solver_1, solver_2, solver_3, solver_4]\\n # define the integration steps\\n time_step = [g_initial_time + step for step in g_time_steps]\\n u = 0.0 # initial input\\n # set the system equation and jacobian\\n system_equation = lambda t, state, u: system(t, state, u)\\n system_jacobian = lambda t, state, u: jacobian(t, state, u)\\n [solve.set_system_equation(system_equation, system_jacobian) for solve in solver]\\n # set initial values of the solver\\n [solve.set_initial_value(g_initial_value, g_initial_time) for solve in solver]\\n # integrate for given steps\\n for steps in time_step:\\n u += 0.8 # increase the input in each step\\n [solve.set_f_params(u) for solve in solver]\\n [solve.integrate(steps) for solve in solver]\\n # test if all solver integrated for the same time\\n assert solver_1.t == solver_2.t == solver_3.t == solver_4.t\\n # test if the relative difference between the states is small\\n abs_values = [sum(abs(solver_1.y)), sum(abs(solver_2.y)), sum(abs(solver_3.y)), sum(abs(solver_4.y))]\\n assert max(abs_values) / min(abs_values) - 1 < 1E-4, \\\"Time step at the error: \\\" + str(steps)\",\n \"def test_basic():\\n\\n\\ttransmissions_1 = compute_transmissions(cal_directory)\\n\\ttransmissions_2 = compute_transmissions(cal_directory, \\n\\t\\tlines = [\\\"ha\\\", \\\"nii\\\"], calibrator = [\\\"G300_0\\\"], plot = True)\\n\\n\\tassert np.allclose(transmissions_1[\\\"ha\\\"][\\\"g300_0\\\"][\\\"SLOPE_THEIL\\\"], \\n\\t\\ttransmissions_2[\\\"ha\\\"][\\\"G300_0\\\"][\\\"SLOPE_THEIL\\\"])\",\n \"def test_griewank_works_fine(self):\\n\\n ba_griewank = BatAlgorithm(NP=10, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, seed=self.seed)\\n ba_griewankc = BatAlgorithm(NP=10, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, seed=self.seed)\\n AlgorithmTestCase.algorithm_run_test(self, ba_griewank, ba_griewankc)\",\n \"def test_scenario_1(scenario):\\n nt_server, nt_client, nt_client2, st, ct1, ct2 = scenario\\n\\n nt_client.disconnect()\\n\\n ct1.putString(\\\"Client1Only\\\", \\\"11\\\")\\n ct1.putString(\\\"SC1Shared\\\", \\\"11\\\")\\n ct1.putString(\\\"ClientShared\\\", \\\"11\\\")\\n\\n with nt_client2.expect_changes(3):\\n st.putString(\\\"ServerOnly\\\", \\\"10\\\")\\n st.putString(\\\"SC1Shared\\\", \\\"10\\\")\\n st.putString(\\\"SC2Shared\\\", \\\"10\\\")\\n\\n with nt_server.expect_changes(3):\\n ct2.putString(\\\"Client2Only\\\", \\\"12\\\")\\n ct2.putString(\\\"SC2Shared\\\", \\\"12\\\")\\n ct2.putString(\\\"ClientShared\\\", \\\"12\\\")\\n\\n with nt_server.expect_changes(3):\\n with nt_client.expect_changes(3):\\n with nt_client2.expect_changes(3):\\n nt_client.start_test()\\n\\n check_results(\\n st,\\n ct1,\\n ct2,\\n ServerOnly=10,\\n Client1Only=11,\\n Client2Only=12,\\n SC1Shared=11,\\n SC2Shared=12,\\n ClientShared=11,\\n )\",\n \"def test_setup_multiple_parameters_system():\\n with mmtools.utils.temporary_directory() as tmp_dir:\\n yaml_script = get_template_script(tmp_dir)\\n\\n # Force antechamber parametrization of benzene to output frcmod file\\n exp_builder = ExperimentBuilder(yaml_script)\\n exp_builder._db._setup_molecules('benzene')\\n benzene_dir = exp_builder._db.get_molecule_dir('benzene')\\n frcmod_path = os.path.join(benzene_dir, 'benzene.frcmod')\\n benzene_path = os.path.join(benzene_dir, 'benzene.gaff.mol2')\\n\\n # Redefine benzene to use leaprc.gaff and benzene.frcmod\\n # and set up system for hydration free energy calculation\\n yaml_script['molecules'] = {\\n 'benzene-frcmod': {'filepath': benzene_path,\\n 'leap': {'parameters': ['leaprc.gaff', frcmod_path]}}}\\n yaml_script['systems'] = {\\n 'system':\\n {'solute': 'benzene-frcmod', 'solvent1': 'PME', 'solvent2': 'vacuum',\\n 'leap': {'parameters': 'oldff/leaprc.ff14SB'}}\\n }\\n del yaml_script['experiments']\\n\\n exp_builder = ExperimentBuilder(yaml_script)\\n system_files_path = exp_builder._db.get_system('system')\\n\\n # Check that output exist:\\n for phase in system_files_path:\\n assert os.path.exists(phase.parameters_path)\\n assert os.path.exists(phase.position_path)\\n assert os.path.getsize(phase.parameters_path) > 0\\n assert os.path.getsize(phase.position_path) > 0\",\n \"def main():\\n graph_alg_eq()\\n graph_points()\\n graph_smooth_from_pts()\\n\\n return GOOD_RET # success\",\n \"def runAnalyticalSim(self, sim_rounds = 10**7, factor=\\\"mu\\\"):\\n # create simulation agents\\n M = self.getPopulationSize()\\n N = self.getSampleSize()\\n\\n available_strategies = self.getAvailableStrategies()\\n sim_agents = [Agent(available_strategies) for i in range(M)]\\n tot_count = [0 for strategy in available_strategies]\\n\\n # count strategies in current population\\n strat_count = [0 for strategy in available_strategies]\\n for sim_agent in sim_agents:\\n strat_count[available_strategies.index(sim_agent.getStrategy())] += 1\\n\\n # repeat 10 million times\\n for i in range(sim_rounds):\\n\\n # handle each agent\\n for focal_player in sim_agents:\\n\\n # update frequencies for avg payoffs\\n self.clearFrequencies()\\n for i, strategy in enumerate(available_strategies):\\n self.setFrequency(strategy, strat_count[i])\\n\\n # option 1: random switch strategy\\n mu_proba = np.random.random()\\n if mu_proba <= self.getExplorationRate():\\n strat_count[available_strategies.index(focal_player.getStrategy())] -= 1\\n focal_player.switchToOtherAvailableStrategy()\\n strat_count[available_strategies.index(focal_player.getStrategy())] += 1\\n\\n # option 2: choose model to (maybe) imitate\\n else:\\n # select model player\\n model_player_index = np.random.randint(0, M-1)\\n while model_player_index == sim_agents.index(focal_player):\\n model_player_index = np.random.randint(0, M-1)\\n model_player = sim_agents[model_player_index]\\n\\n # define imitation outcome\\n proba_copy = self.Fermi(self.getPayoff(model_player.getStrategy()), self.getPayoff(focal_player.getStrategy()))\\n proba_event = np.random.random()\\n if proba_event <= proba_copy:\\n strat_count[available_strategies.index(focal_player.getStrategy())] -= 1\\n focal_player.setStrategy(model_player.getStrategy())\\n strat_count[available_strategies.index(focal_player.getStrategy())] += 1\\n\\n # remember population strategies\\n for i in range(len(tot_count)):\\n tot_count[i] += strat_count[i]\\n\\n # obtain final frequency\\n for i in range(len(strat_count)):\\n strat_count[i] = strat_count[i] / M\\n\\n # obtain total frequency\\n for i, strategy in enumerate(available_strategies):\\n tot_count[i] = tot_count[i] / (sim_rounds * M)\\n\\n # export to file: strat_count (enables comparison of both results)\\n self.saveResults(tot_count, \\\"{}\\\".format(self.getCase()), factor)\",\n \"def test_compare_genomes_1(self):\\n import_genome.compare_genomes(self.genome_pair, self.eval_flags)\\n count = count_status(self.genome_pair, \\\"error\\\", \\\"warning\\\")\\n with self.subTest():\\n self.assertEqual(len(self.genome_pair.evaluations), 12)\\n with self.subTest():\\n self.assertEqual(count, 0)\",\n \"def run1():\\n #Reseting motors\\n ResetRobot.reset_wheel_motors()\\n ResetRobot.reset_attachment_motors()\\n CalibrateRobot.calibrate_gyro()\\n\\n #mission M01 and M02 - space travel and solar panel\\n M01_M02()\\n \\n #Mission M05- Extraction \\n M05_M14()\\n\\n #Back to base before Gerhard (Remove comment if necessary)\\n return_to_base1()\\n\\n # Must delete for competition.. This is to set up forklift to repeat run.\\n Robot.attachment_left.on_for_rotations(-100, 8) #Raises Forklift \",\n \"def turbsim_example(): \\n # run TurbSim\\n from runTurbSim import runTurbSim\\n\\n ts = runTurbSim()\\n ts.ts_exe = \\\"/Users/pgraf/opt/windcode-7.31.13/TurbSim/build/TurbSim_glin64\\\"\\n ts.run_dir = \\\"turbsim_test_run\\\"\\n tscase = 2\\n if (tscase == 1):\\n ts.ts_dir = \\\"TurbSimTest\\\"\\n ts.ts_file = \\\"turbsim_template.inp\\\"\\n else:\\n ts.ts_dir = \\\"/Users/pgraf/work/wese/fatigue12-13/from_gordie/SparFAST3.orig/TurbSim\\\"\\n ts.ts_file = \\\"TurbSim.inp\\\"\\n \\n tmax = 12\\n ws=20.0 # wind speed\\n\\n ts.set_dict({\\\"URef\\\": ws, \\\"AnalysisTime\\\":tmax, \\\"UsableTime\\\":tmax})\\n ts.execute()\\n\\n # then run FAST\\n fast = runFAST()\\n fast.fst_exe = \\\"/Users/pgraf/opt/windcode-7.31.13/build/FAST_glin64\\\"\\n case = 2\\n if (case==1):\\n fast.fst_dir = \\\"FAST_VT/OC3_Files/\\\"\\n fast.fst_file = \\\"NRELOffshrBsline5MW_Monopile_RF.fst\\\" \\n elif case ==2:\\n fast.fst_dir = \\\"/Users/pgraf/work/wese/fatigue12-13/from_gordie/SparFAST3.orig\\\"\\n fast.fst_file = \\\"NRELOffshrBsline5MW_Floating_OC3Hywind.fst\\\"\\n else:\\n fast.fst_dir = \\\"InputFilesToWrite/\\\"\\n fast.fst_file = \\\"NREL5MW_Monopile_Rigid.v7.02.fst\\\"\\n\\n fast.run_dir = \\\"tsfast_test_run_dir\\\" ## either abs or rel path ok\\n\\n # here we link turbsim -> fast\\n tswind_file = os.path.join(ts.ts_dir, \\\"%s.wnd\\\" % ts.run_name)\\n fast.set_wind_file(os.path.abspath(tswind_file))\\n\\n fast.fstDict['Vhub']=ws\\n fast.fstDict['RotSpeed'] = 12.03\\n fast.fstDict[\\\"TMax\\\"] = tmax\\n fast.fstDict['TStart'] = 0.0\\n\\n fast.setOutputs(['RotPwr'])\\n\\n fast.execute()\\n\\n out = fast.getOutputValue(\\\"RotPwr\\\")\\n\\n print \\\"TurbSim example complete:\\\"\\n print \\\"max power\\\"\\n print max(out)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68798894","0.67589664","0.6691962","0.6658642","0.66065735","0.6502654","0.6430964","0.6405235","0.62871385","0.6238632","0.6205848","0.62035537","0.6201428","0.6168178","0.61394686","0.611758","0.60966617","0.6089579","0.6072231","0.60561776","0.6034974","0.60341024","0.6032304","0.60305923","0.60304815","0.60153383","0.60018766","0.6000136","0.5985351","0.59699845","0.59613746","0.59569323","0.59517807","0.59424317","0.5939603","0.5922129","0.59166455","0.5916625","0.58874726","0.5865174","0.5838841","0.58326006","0.5794914","0.57893103","0.57892364","0.5785932","0.57797414","0.57720983","0.57666224","0.576627","0.5763437","0.5762418","0.5744055","0.5740548","0.5740269","0.57308996","0.5726823","0.5726763","0.57239974","0.5723212","0.5721643","0.5719699","0.57092845","0.5689461","0.5681971","0.56672525","0.5665521","0.5661765","0.5660505","0.5659583","0.5642613","0.56395936","0.5636037","0.5634302","0.563205","0.5630549","0.56252617","0.56236345","0.5621542","0.5609044","0.56059426","0.56033385","0.5603097","0.56012636","0.56011707","0.5600483","0.56003505","0.55995566","0.55974793","0.5595227","0.5595037","0.5592258","0.5590001","0.55862266","0.55840695","0.5583339","0.5583287","0.55827564","0.556811","0.5567696"],"string":"[\n \"0.68798894\",\n \"0.67589664\",\n \"0.6691962\",\n \"0.6658642\",\n \"0.66065735\",\n \"0.6502654\",\n \"0.6430964\",\n \"0.6405235\",\n \"0.62871385\",\n \"0.6238632\",\n \"0.6205848\",\n \"0.62035537\",\n \"0.6201428\",\n \"0.6168178\",\n \"0.61394686\",\n \"0.611758\",\n \"0.60966617\",\n \"0.6089579\",\n \"0.6072231\",\n \"0.60561776\",\n \"0.6034974\",\n \"0.60341024\",\n \"0.6032304\",\n \"0.60305923\",\n \"0.60304815\",\n \"0.60153383\",\n \"0.60018766\",\n \"0.6000136\",\n \"0.5985351\",\n \"0.59699845\",\n \"0.59613746\",\n \"0.59569323\",\n \"0.59517807\",\n \"0.59424317\",\n \"0.5939603\",\n \"0.5922129\",\n \"0.59166455\",\n \"0.5916625\",\n \"0.58874726\",\n \"0.5865174\",\n \"0.5838841\",\n \"0.58326006\",\n \"0.5794914\",\n \"0.57893103\",\n \"0.57892364\",\n \"0.5785932\",\n \"0.57797414\",\n \"0.57720983\",\n \"0.57666224\",\n \"0.576627\",\n \"0.5763437\",\n \"0.5762418\",\n \"0.5744055\",\n \"0.5740548\",\n \"0.5740269\",\n \"0.57308996\",\n \"0.5726823\",\n \"0.5726763\",\n \"0.57239974\",\n \"0.5723212\",\n \"0.5721643\",\n \"0.5719699\",\n \"0.57092845\",\n \"0.5689461\",\n \"0.5681971\",\n \"0.56672525\",\n \"0.5665521\",\n \"0.5661765\",\n \"0.5660505\",\n \"0.5659583\",\n \"0.5642613\",\n \"0.56395936\",\n \"0.5636037\",\n \"0.5634302\",\n \"0.563205\",\n \"0.5630549\",\n \"0.56252617\",\n \"0.56236345\",\n \"0.5621542\",\n \"0.5609044\",\n \"0.56059426\",\n \"0.56033385\",\n \"0.5603097\",\n \"0.56012636\",\n \"0.56011707\",\n \"0.5600483\",\n \"0.56003505\",\n \"0.55995566\",\n \"0.55974793\",\n \"0.5595227\",\n \"0.5595037\",\n \"0.5592258\",\n \"0.5590001\",\n \"0.55862266\",\n \"0.55840695\",\n \"0.5583339\",\n \"0.5583287\",\n \"0.55827564\",\n \"0.556811\",\n \"0.5567696\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5700753"},"document_rank":{"kind":"string","value":"63"}}},{"rowIdx":91993,"cells":{"query":{"kind":"string","value":"Return a string representation of the config."},"document":{"kind":"string","value":"def __str__(self):\n \n # top row\n result = ' '\n result = '\\n ' + '-' * (self.DIM*2+5) + '\\n'\n \n # board rows\n for row in range(self.DIM):\n if row is 3 or row is 6:\n result += '|' + '-' * (self.DIM*2+5) + '|' + '\\n'\n # result += '|-------+-------+-------|\\n'\n result += '| '\n for col in range(self.DIM):\n if col is 3 or col is 6:\n result += '| '\n if self.board[row][col] == SudokuConfig.EMPTY:\n result += '.'\n else:\n result += str(str(self.board[row][col]))\n if col != self.DIM-1:\n result += ' '\n result += ' |' + '\\n'\n \n # bottom row\n result += ' ' + '-' * (self.DIM*2+5) + '\\n'\n result += ' '\n result += '\\n'\n \n return result"},"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 __str__():\n return str(_config)","def __str__(self):\n config_str = 'Configurations\\n'\n config_str += pprint.pformat(self.__dict__)\n return config_str","def __repr__(self) -> str:\n return json.dumps(self._config)","def str(self):\n\n list_of_entries = ['{0} name={1}'.format(self.layer_type, self.name)]\n for key, value in sorted(self.config.items()):\n if isinstance(value, str) and re.search('=', value):\n # the value is a string that contains an '=' sign, so we need to\n # enclose it in double-quotes, otherwise we woudldn't be able to\n # parse from that output.\n if re.search('\"', value):\n print(\"Warning: config '{0}={1}' contains both double-quotes \"\n \"and equals sign; it will not be possible to parse it \"\n \"from the file.\".format(key, value), file=sys.stderr)\n list_of_entries.append('{0}=\"{1}\"'.format(key, value))\n else:\n list_of_entries.append('{0}={1}'.format(key, value))\n\n return ' '.join(list_of_entries)","def __str__(self):\n return \"%s #config from: %s\" % (self._config, self._realpath)","def prettify(self):\n return self._config_dict","def __repr__(self):\n string = ''\n for key, val in self.setting().items():\n string += '{}({})\\n'.format(key, val)\n return string","def serialize(self):\n return json.dumps(self._config, default=lambda o: o.__dict__, sort_keys=True, indent=4)","def serialize(self):\n return json.dumps(self._config, default=lambda o: o.__dict__, sort_keys=True, indent=4)","def __str__(self):\n return str(self._config.name)","def config(self):\n return \"\\n\".join([ c.config(True) for p, c in self.configs_ ])","def config(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"config\")","def __str__(self):\n return (\"{{'global_config' : {0._global}, \"\n \"'local_config' : {0._local}, \"\n \"'on_demand_config': {0._on_demand}, \"\n \"'recent_caller' : '{0._recent_caller}'}}\".format(self))","def __repr__(self) -> str:\n view = {\n \"server\": self.server,\n \"access-token\": 'yes' if self.token is not None else 'no',\n \"insecure\": self.insecure,\n \"output\": self.output,\n \"verbose\": self.verbose,\n }\n\n return \"<Configuration({})\".format(view)","def showConf(self):\n\n return json.dumps(\n self.config, sort_keys=True, indent=4, separators=(',', ': '))","def _config_str(config: Config) -> str:\n _C = config\n\n __C: CN = CN({\"RANDOM_SEED\": _C.random_seed})\n common_string: str = str(__C) + \"\\n\"\n\n return common_string","def config_debug():\n config_str = request.args.get('config')\n config = pickle.loads(b64decode(config_str))\n return str(config)","def serialize_config(config):\n return dumps(config)","def __repr__(self) -> str:\n dump_conf = copy.deepcopy(self)\n string = \"\"\n for k in dump_conf:\n v = dump_conf[k]\n if k == \"wpscan_args\":\n v = safe_log_wpscan_args(v)\n if k == \"smtp_pass\" and v != \"\":\n v = \"***\"\n if isinstance(v, (list, dict)):\n v = json.dumps(v)\n else:\n v = str(v)\n string += f\"\\n{k:<25}\\t=\\t{v}\"\n return string","def _get_sim_config_str(self):\n\n log = \"[FMU Validator] The set of configuration_parameters, inputs, and outputs defined is the following:\\n\"\n log += \"\\n{}: {}\".format(\"Sim Config Params -- Brain Config \", self.sim_config_params)\n log += \"\\n{}: {}\".format(\"Sim Inputs -- Brain Actions \", self.sim_inputs)\n log += \"\\n{}: {}\".format(\"Sim Outputs -- Brain States \", self.sim_outputs)\n log += \"\\n{}: {}\".format(\"Sim Other Vars -- Other Sim States \", self.sim_other_vars)\n \n return log","def __repr__(self):\n template = \"{}(confetti_key='{}', confetti_app='{}', \" \\\n \"confetti_path='{}', session={}, recursive={})\"\n return template.format(\n self.__class__.__name__,\n self.confetti_key,\n self.confetti_app,\n self.confetti_path,\n self.session,\n self.recursive,\n )","def dump(self):\n return json.dumps(self._data, cls=ConfigEncoder)","def __str__(self) -> str:\n\n sources_joined = \" \".join(self.sources)\n sources = f\"[SOURCES]\\n{sources_joined}\"\n\n sp_joined = \"\\n\".join(map(str, self.source_parameters))\n source_parameters = f\"[SOURCE-PARAMETERS]\\n{sp_joined}\"\n\n hints_joined = \"\\n\".join(map(str, self.hints))\n general = f\"[GENERAL]\\n{hints_joined}\"\n\n return \"\\n\".join([\n \"# Augustus extrinsic hints config file.\",\n (\"# Automatically generated by [augustus_optimiser]\"\n \"(https://github.com/darcyabjones/augustus_optimiser)\"),\n \"\",\n sources,\n \"\",\n source_parameters,\n \"\",\n general,\n ])","def wallet_config(self) -> str:\n\n return self._wallet_config","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())","def to_str(self):\n return pformat(self.to_dict())"],"string":"[\n \"def __str__():\\n return str(_config)\",\n \"def __str__(self):\\n config_str = 'Configurations\\\\n'\\n config_str += pprint.pformat(self.__dict__)\\n return config_str\",\n \"def __repr__(self) -> str:\\n return json.dumps(self._config)\",\n \"def str(self):\\n\\n list_of_entries = ['{0} name={1}'.format(self.layer_type, self.name)]\\n for key, value in sorted(self.config.items()):\\n if isinstance(value, str) and re.search('=', value):\\n # the value is a string that contains an '=' sign, so we need to\\n # enclose it in double-quotes, otherwise we woudldn't be able to\\n # parse from that output.\\n if re.search('\\\"', value):\\n print(\\\"Warning: config '{0}={1}' contains both double-quotes \\\"\\n \\\"and equals sign; it will not be possible to parse it \\\"\\n \\\"from the file.\\\".format(key, value), file=sys.stderr)\\n list_of_entries.append('{0}=\\\"{1}\\\"'.format(key, value))\\n else:\\n list_of_entries.append('{0}={1}'.format(key, value))\\n\\n return ' '.join(list_of_entries)\",\n \"def __str__(self):\\n return \\\"%s #config from: %s\\\" % (self._config, self._realpath)\",\n \"def prettify(self):\\n return self._config_dict\",\n \"def __repr__(self):\\n string = ''\\n for key, val in self.setting().items():\\n string += '{}({})\\\\n'.format(key, val)\\n return string\",\n \"def serialize(self):\\n return json.dumps(self._config, default=lambda o: o.__dict__, sort_keys=True, indent=4)\",\n \"def serialize(self):\\n return json.dumps(self._config, default=lambda o: o.__dict__, sort_keys=True, indent=4)\",\n \"def __str__(self):\\n return str(self._config.name)\",\n \"def config(self):\\n return \\\"\\\\n\\\".join([ c.config(True) for p, c in self.configs_ ])\",\n \"def config(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"config\\\")\",\n \"def __str__(self):\\n return (\\\"{{'global_config' : {0._global}, \\\"\\n \\\"'local_config' : {0._local}, \\\"\\n \\\"'on_demand_config': {0._on_demand}, \\\"\\n \\\"'recent_caller' : '{0._recent_caller}'}}\\\".format(self))\",\n \"def __repr__(self) -> str:\\n view = {\\n \\\"server\\\": self.server,\\n \\\"access-token\\\": 'yes' if self.token is not None else 'no',\\n \\\"insecure\\\": self.insecure,\\n \\\"output\\\": self.output,\\n \\\"verbose\\\": self.verbose,\\n }\\n\\n return \\\"<Configuration({})\\\".format(view)\",\n \"def showConf(self):\\n\\n return json.dumps(\\n self.config, sort_keys=True, indent=4, separators=(',', ': '))\",\n \"def _config_str(config: Config) -> str:\\n _C = config\\n\\n __C: CN = CN({\\\"RANDOM_SEED\\\": _C.random_seed})\\n common_string: str = str(__C) + \\\"\\\\n\\\"\\n\\n return common_string\",\n \"def config_debug():\\n config_str = request.args.get('config')\\n config = pickle.loads(b64decode(config_str))\\n return str(config)\",\n \"def serialize_config(config):\\n return dumps(config)\",\n \"def __repr__(self) -> str:\\n dump_conf = copy.deepcopy(self)\\n string = \\\"\\\"\\n for k in dump_conf:\\n v = dump_conf[k]\\n if k == \\\"wpscan_args\\\":\\n v = safe_log_wpscan_args(v)\\n if k == \\\"smtp_pass\\\" and v != \\\"\\\":\\n v = \\\"***\\\"\\n if isinstance(v, (list, dict)):\\n v = json.dumps(v)\\n else:\\n v = str(v)\\n string += f\\\"\\\\n{k:<25}\\\\t=\\\\t{v}\\\"\\n return string\",\n \"def _get_sim_config_str(self):\\n\\n log = \\\"[FMU Validator] The set of configuration_parameters, inputs, and outputs defined is the following:\\\\n\\\"\\n log += \\\"\\\\n{}: {}\\\".format(\\\"Sim Config Params -- Brain Config \\\", self.sim_config_params)\\n log += \\\"\\\\n{}: {}\\\".format(\\\"Sim Inputs -- Brain Actions \\\", self.sim_inputs)\\n log += \\\"\\\\n{}: {}\\\".format(\\\"Sim Outputs -- Brain States \\\", self.sim_outputs)\\n log += \\\"\\\\n{}: {}\\\".format(\\\"Sim Other Vars -- Other Sim States \\\", self.sim_other_vars)\\n \\n return log\",\n \"def __repr__(self):\\n template = \\\"{}(confetti_key='{}', confetti_app='{}', \\\" \\\\\\n \\\"confetti_path='{}', session={}, recursive={})\\\"\\n return template.format(\\n self.__class__.__name__,\\n self.confetti_key,\\n self.confetti_app,\\n self.confetti_path,\\n self.session,\\n self.recursive,\\n )\",\n \"def dump(self):\\n return json.dumps(self._data, cls=ConfigEncoder)\",\n \"def __str__(self) -> str:\\n\\n sources_joined = \\\" \\\".join(self.sources)\\n sources = f\\\"[SOURCES]\\\\n{sources_joined}\\\"\\n\\n sp_joined = \\\"\\\\n\\\".join(map(str, self.source_parameters))\\n source_parameters = f\\\"[SOURCE-PARAMETERS]\\\\n{sp_joined}\\\"\\n\\n hints_joined = \\\"\\\\n\\\".join(map(str, self.hints))\\n general = f\\\"[GENERAL]\\\\n{hints_joined}\\\"\\n\\n return \\\"\\\\n\\\".join([\\n \\\"# Augustus extrinsic hints config file.\\\",\\n (\\\"# Automatically generated by [augustus_optimiser]\\\"\\n \\\"(https://github.com/darcyabjones/augustus_optimiser)\\\"),\\n \\\"\\\",\\n sources,\\n \\\"\\\",\\n source_parameters,\\n \\\"\\\",\\n general,\\n ])\",\n \"def wallet_config(self) -> str:\\n\\n return self._wallet_config\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\",\n \"def to_str(self):\\n return pformat(self.to_dict())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.85173273","0.8513157","0.8259779","0.7956899","0.77279353","0.7583788","0.7550117","0.7511544","0.7511544","0.7487914","0.74800324","0.74372464","0.7417465","0.737675","0.73606914","0.7319001","0.72816837","0.7248459","0.7144512","0.7063809","0.68749636","0.685046","0.6745381","0.66540927","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797","0.6628797"],"string":"[\n \"0.85173273\",\n \"0.8513157\",\n \"0.8259779\",\n \"0.7956899\",\n \"0.77279353\",\n \"0.7583788\",\n \"0.7550117\",\n \"0.7511544\",\n \"0.7511544\",\n \"0.7487914\",\n \"0.74800324\",\n \"0.74372464\",\n \"0.7417465\",\n \"0.737675\",\n \"0.73606914\",\n \"0.7319001\",\n \"0.72816837\",\n \"0.7248459\",\n \"0.7144512\",\n \"0.7063809\",\n \"0.68749636\",\n \"0.685046\",\n \"0.6745381\",\n \"0.66540927\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\",\n \"0.6628797\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":91994,"cells":{"query":{"kind":"string","value":"Checks whether a config is a goal or not"},"document":{"kind":"string","value":"def isGoal(self):\n for index in range(self.DIM):\n if not self.values('r',index).count(0) is 0:\n return False\n if not self.isValid():\n return False\n return True"},"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 test_goal(puzzle_state, goal):\n return puzzle_state.config == goal","def test_goal(state):\r\n \r\n if state.config == (0,1,2,3,4,5,6,7,8):\r\n return True\r\n else:\r\n return False","def check_config(cfg):","def is_goal(self, url):\n return url == self.goal_url","def is_goal(self, state):\n return state in self.goals # Optionally override this!","def test_goal(puzzle_state):\n goal_state = (0, 1, 2, 3, 4, 5, 6, 7, 8)\n\n if(puzzle_state.config == goal_state):\n return True\n else:\n return False","def goal_test(self, state):\n \"*** YOUR CODE HERE ***\"\n if (state[0], state[1]) in self.goals: #Check to see if at goal state\n return True\n else:\n return False","def check_config(self):\n # Check if tool is at all included in workflow\n if \"external\" not in self.config[\"tools\"][\"dna\"]:\n return # External not run, don't check configuration # pragma: no cover","def check_config(config):\n pass","def goal_test(self, state):\n\t\tif isinstance(self.goal, list):\n\t\t\treturn is_in(state, self.goal)\n\t\telse:\n\t\t\treturn state == self.goal","def is_goal(state):\n pass","def goal_test(self, state):\n\n\t\treturn self.goal == state","def is_goal(self, node):\n # print(\"is {} in {}\".format(node, self.goal_nodes))\n if node in self.goal_nodes:\n return True","def goal_test(self, state):\n if isinstance(self.goal, list):\n return is_in(state, self.goal)\n else:\n return state == self.goal","def is_goal(self, state: Grid2D.State) -> bool:\n return state.agent_position in self.goals","def goal_test(self, state):\n return state == self.goal","def goal_test(self, state):\n return state == self.goal","def goal_test(self, state):\n\n return state == self.goal","def goal_test(self, state):\n\n return state == self.goal","def goal_test(self, state):\n return (set(state[1]) == set(self.goal))","def goal_test(self, state):\n return (set(state[1]) == set(self.goal))","def requires_route(self) -> bool:\n return self.goal.is_specific()","def check_config(self):\n # Check if tool is at all included in workflow\n if \"gatk_post_bam\" not in (self.config[\"postprocessing\"] or []): # pylint: disable=C0325\n return # GATK BAM postprocessing not enabled, skip\n\n # Check required configuration settings present\n self.parent.ensure_w_config(\n config_keys=(\"step_config\", \"ngs_mapping\", \"gatk_post_bam\", \"paths_known_sites\"),\n msg=\"Known sites list cannot be empty for GATK BAM postprocessing\",\n )\n self.parent.ensure_w_config(\n config_keys=(\"static_data_config\", \"reference\", \"path\"),\n msg=\"Path to reference FASTA required for GATK BAM postprocessing\",\n )","def validateConfig(config):\n if getattr(config, 'TaskWorker', None) is None:\n return False, \"Configuration problem: Task worker section is missing. \"\n return True, 'Ok'","def is_at_goal(self):\n return self._current_loc.get_row() == BoardPath._goal_loc.get_row() and \\\n self._current_loc.get_column() == BoardPath._goal_loc.get_column()","def _check_config(self):","def _goal_test(self, state):\n if type(self.goal_states[0]) == list:\n return list(state) in self.goal_states\n elif type(self.goal_states[0]) == tuple:\n return tuple(state) in self.goal_states","def _goal_test(self, state):\n if type(self.goal_states[0]) == list:\n return list(state) in self.goal_states\n elif type(self.goal_states[0]) == tuple:\n return tuple(state) in self.goal_states","def isGoalState(self, state):\n\t\tutil.raiseNotDefined()","def isGoal(self, state):\n x, y = state\n return (x, y) in self.food.asList()","def isGoalState(self, state):\n x,y = state\n if x == self.goal[0] and y == self.goal[1]:\n return True\n else:\n return False\n util.raiseNotDefined()","def isInGoal(self):\n coordx= self.playerPos.x\n coordy= self.playerPos.y\n target = 0 if self.id_team == 1 else 1\n\n if((((target == 0)and (coordx<=5))|\n ((target == 1) and(coordx>145))) \n and (coordy<=50 and coordy>=40)):\n return True\n else:\n return False","def checkconfig(self): \n validconfig = {\n 'loglevel': lambda s: s in self.loglevels,\n 'logfilelevel': lambda s: s in self.loglevels,\n 'nodes': lambda s: isinstance(s, list),\n 'pynodes': lambda s: isinstance(s, list)\n }\n alive = True\n for key in self.config: \n if (key in validconfig and \n not validconfig[key](self.config[key])):\n logging.critical(\"Invalid configuration option {}: {}\".format(\n key, self.config[key]))\n alive = False\n return alive","def goal_test(self, state):\n #return state == self.goal","def _is_goal_achieved(self) -> bool:\n assert self._goal_info_cache\n return self._goal_info_cache[1]","def _is_supplied_by_config(group: argparse._MutuallyExclusiveGroup, conf: Dict[str, Any]) -> bool:\n group_args = []\n for arg in group._group_actions:\n group_args.append(arg.dest)\n\n count = 0\n for val in group_args:\n if val in conf:\n count += 1\n return count == len(group_args) or count == 0","def check() -> bool:\n\ttry:\n\t\twith open(configPath, 'r') as file:\n\t\t\tcfg = json.load(file) # load the file\n\texcept FileNotFoundError:\n\t\treturn False\n\t# check if EVERY config exists\n\tfor i in default_config.keys():\n\t\tif i in cfg.keys():\n\t\t\tcontinue\n\t\treturn False\n\t# final check\n\treturn cfg['config_type'] == default_config['config_type']","def goal_test(self, state):\n for x, y in state.alvos:\n if state.tabuleiro[x][y] is not BOX_ON_TARGET:\n return False\n return True","def is_goal(self):\r\n\t\tfor row in range(self.n):\r\n\t\t\tfor col in range(self.n):\r\n\t\t\t\tif self.board[row][col] != BoardClass.goal[row][col]:\r\n\t\t\t\t\treturn False\r\n\r\n\t\treturn True","def check_config(self):\n # Check if tool is at all included in workflow\n if not (set(self.config[\"tools\"][\"dna_long\"]) & {\"ngmlr\", \"ngmlr_chained\"}):\n return # NGLMR not run, don't check configuration # pragma: no cover\n\n # Check required configuration settings present\n self.parent.ensure_w_config(\n config_keys=(\"step_config\", \"ngs_mapping\", \"ngmlr\", \"path_index\"),\n msg=\"Path to NGMLR index is required\",\n )","def is_goal(self, state):\n return ''.join(self.desired_arrangement) in state.text","def is_config_action(func: CLIActionType) -> bool:\n return check_function_type(func, [HammerDriver, Callable[[str], None]], Optional[dict]) is None","def checkGoal(self):\n # -- It is not included for simplifity --#\n if self.reward_cumulative != None:\n x = round((abs(self.reward_cumulative) - abs(round(self.reward_cumulative))) * 100);\n rem_goal = x % 25\n rem_timeout = x % 20\n if rem_goal == 0 and x != 0:\n self.is_goal = True\n else:\n self.is_goal = False\n\n if rem_timeout == 0 and x != 0:\n self.is_timeout = True\n else:\n self.is_timeout = False","def antenny_config_check(self):\n return self.antenny_config.check()","def isGoalState(self, state):\n x, y = state\n if state in self.food.asList():\n return True","def check_config(self):\n # Check if tool is at all included in workflow\n if self.__class__.name not in self.config[\"tools\"][\"dna\"]:\n return # BWA not run, don't check configuration # pragma: no cover\n\n # Check required configuration settings present\n self.parent.ensure_w_config(\n config_keys=(\"step_config\", \"ngs_mapping\", \"bwa\", \"path_index\"),\n msg=\"Path to BWA index is required\",\n )\n\n # Check that the path to the BWA index is valid.\n for ext in (\".amb\", \".ann\", \".bwt\", \".pac\", \".sa\"):\n expected_path = self.config[\"bwa\"][\"path_index\"] + ext\n if not os.path.exists(expected_path): # pragma: no cover\n tpl = \"Expected BWA input path {expected_path} does not exist!\".format(\n expected_path=expected_path\n )\n raise InvalidConfiguration(tpl)","def is_goal_state(self, state):\n return self._solved_board == state.board","def check(self, context):\r\n return context.config.preset is not None","def __check_config(self):\n if not os.path.exists(self.__config_path):\n return False\n else:\n return True","def goal_test(self):\n if -1 in self.state:\n return False\n else:\n return True","def config_input(self):\n answer = simpledialog.askstring(\"Input\", \"Please input the path of the config file.\",\n parent=self._master) # ask for a string\n if answer is not None:\n try:\n self.read_config(answer) # read the config\n if all(k in self._config for k in ('World', 'Player')):\n # check whether have a 'World' and 'Player'\n return True\n else: # if don't have 'World' or 'Player'\n messagebox.showerror(\"Missing necessary heading\", \"Missing World or Player\")\n return False\n except IOError:\n messagebox.showerror(\"Invalid path\",\n \"'\" + answer + \"' is not a valid path!\")\n return False","def reach_goal(state: State, action: Action, next_state: State) -> bool:\n return overlap(state, action, next_state, object_type=Goal)","def goal_state(game_state):\n if game_state[0]:\n return False\n return True","def isGoalState(self, state):\n x,y = state\n\n if state in self.food.asList():\n return True\n else:\n return False\n\n util.raiseNotDefined()","def check_config_file():\n # Locate and init config.\n default_config = \"config.json\"\n if len(sys.argv) == 2:\n # config from command line\n app_config = config_reader(sys.argv[1])\n else:\n # config should be in default\n app_config = config_reader(default_config)\n # fin\n if not app_config:\n print(\"Exiting due to invalid config file.\")\n return False\n # fin\n return app_config","def check_config(self):\n # Check if tool is at all included in workflow\n if self.__class__.name not in self.config[\"tools\"][\"rna\"]:\n return # STAR not run, don't check configuration # pragma: no cover\n\n # Check required configuration settings present\n self.parent.ensure_w_config(\n config_keys=(\"step_config\", \"ngs_mapping\", \"star\", \"path_index\"),\n msg=\"Path to STAR index is required\",\n )\n self.parent.ensure_w_config(\n config_keys=(\"static_data_config\", \"reference\"),\n msg=\"No reference genome FASTA file given\",\n )\n\n # Check validity of the STAR index\n full_path = self.config[\"star\"][\"path_index\"]\n # a lot of files should be in this dir, justtest these\n for indfile in (\"Genome\", \"SA\", \"SAindex\"):\n expected_path = os.path.join(full_path, indfile)\n if not os.path.exists(expected_path): # pragma: no cover\n tpl = \"Expected STAR index file {expected_path} does not exist!\".format(\n expected_path=expected_path\n )\n raise InvalidConfiguration(tpl)","def resolve(self, config: \"Config\") -> bool:\n option = config.getoption(self.argument, default=None)\n if option is not None:\n # A value is set, and it is not the default one\n return self.validate(option)\n\n if os.getenv(self.environment_variable):\n return True\n\n return False","def check_configuration(self, configuration):\n super(Hipchap, self).check_configuration(configuration)","def test_goal(puzzle_state):\n \n x = puzzle_state.dimension\n final_state = []\n \n for i in range(x*x):\n final_state += [i]\n \n final_state_tuple = tuple(final_state)\n \n if puzzle_state.config == final_state_tuple:\n return True\n else:\n return False","def is_goal(state):\r\n goal_state = [[0], [1, 2, 3], [4, 5, 6], [7, 8, 9]]\r\n return state == goal_state","def isGoalState(self, state):\n \"*** YOUR CODE HERE ***\"\n # Utilizaré el método .count del grid, de manera que me contará los trues que haya.\n # Cuando no queden trues, ya hemos acabado.\n return state[1].count() == 0\n # util.raiseNotDefined()","def check_config():\n\n if not config_instance:\n LOG.error(\"Failed to load the config!\")\n sys.exit(9)\n\n if not hasattr(config_instance, \"CONFIG_VERSION\"):\n LOG.warning( \"The config file does not specify CONFIG_VERSION! I will \"\n \"try to continue anyway, but this field is recommended to allow \"\n \"some internal tests to work. I will assume the value '(1,0)'!\" )\n config_instance.CONFIG_VERSION = (1, 0)\n\n major, minor = config_instance.CONFIG_VERSION\n expected_major, expected_minor = EXPECTED_CONFIG_VERSION\n\n if major < expected_major:\n LOG.critical(\"The config system has undergone a major change! \"\n \"I cannot continue without an upgrade!\")\n sys.exit(9)\n\n if minor < expected_minor:\n LOG.warning(\"The config system has undergone a minor change! \"\n \"It should work, but you still should review the docs!\")\n\n if major == expected_major and minor == expected_minor:\n LOG.debug( \"Config version OK!\" )\n\n if not hasattr(config_instance, \"GENERATORS\"):\n LOG.critical(\"Variable 'GENERATORS' not found in config!\")\n sys.exit(9)\n\n if not hasattr(config_instance, \"TARGETS\"):\n LOG.critical(\"Variable 'TARGETS' not found in config!\")\n sys.exit(9)","def goal_check(current_node, target_node):\n if current_node.id == target_node.id:\n return True\n else:\n return False","def isGoalState(self, state):\n x,y = state\n foods = self.food.asList()\n if state in foods:\n return True\n else:\n return False\n util.raiseNotDefined()","def isGoalState(self, state):\n return state in self.food.asList()","def check_configs(self):\n\n pass","def goal_test(self, state):\r\n assignment = dict(state)\r\n return (len(assignment) == len(self.variables)\r\n and all(self.nconflicts(variables, assignment[variables], assignment) == 0\r\n for variables in self.variables))","def __isTileGoalState(self, point):\n return point == self.goalPoint","def is_experiment(cfg):\n if CONDITIONS in list(cfg.keys()):\n return True\n else:\n return False","def check_config_mode(self):\n return False","def validate_config(self, config: Dict) -> bool:\n raise NotImplementedError","def valid_configuration(self):\n valid = True\n\n if (not self.__config.suffix()) and (self.__config.output_dir() == self.__config.input_dir()):\n print(\"ERROR: output_dir directory cannot be the same as input_dir with an empty suffix!\")\n valid = False\n if not self.__config.public_key():\n print(\"ERROR: public_key not set! Set it through 'pdfworkshop config public_key <your_key>'. \"\n \"A free API key can be obtained from https://developer.ilovepdf.com/\")\n valid = False\n return valid","def is_config_exist(self) -> bool:\n pass","def is_configured(command):\n return command in COMMANDS","def check_configuration(self, configuration):\n super(Pixiv_bot, self).check_configuration(configuration)","def check():\n\t\t# This forces user to set dirs before running the app for first time.\n\t\tif len(Config.lyrics_dir) == 0:\n\t\t\t# see which directory in not set and raise BadConfigError with that as value\n\t\t\tprint('lyrics_dir is not set.')\n\t\t\tprint('Please use the \"set\" command to set lyrics_dir.')\n\t\t\tprint('use \"lyrico --help\" to view commands.')\n\t\t\treturn False\n\n\t\tif len(Config.source_dir) == 0:\n\t\t\t# see which directory in not set and raise BadConfigError with that as value\n\t\t\tprint('source_dir is not set.')\n\t\t\tprint('Please use the \"set\" command to set source_dir or pass it as parameter.')\n\t\t\tprint('use \"lyrico --help\" to view commands.')\n\t\t\treturn False\n\n\t\t# if user disable both saving mode. Notify & force user to correct on next run.\n\t\tif not Config.save_to_file and not Config.save_to_tag:\n\t\t\tprint('Both \"save_to_file\" and \"save_to_tag\" modes are disabled. Please enable one.')\n\t\t\tprint('use \"lyrico --help\" to view commands.')\n\t\t\treturn False\n\n\t\t# if user disables all sources. Notify & force user to enable one.\n\t\tif (not Config.lyric_wikia\n\t\t and not Config.az_lyrics\n\t\t and not Config.musix_match\n\t\t and not Config.lyricsmode):\n\t\t\tprint('All lyrics sources are disabled. Please enable one.')\n\t\t\tprint('use \"lyrico --help\" to view commands.')\n\t\t\treturn False\n\t\treturn True","def check_config(configd):\n # XXX: verify first that the required config parameters are present\n if not os.path.exists(configd['player']):\n logging.error(\"player %s wasn't found\" % (configd['player'],))\n return False\n if not os.path.isdir(configd['sound_dir']):\n logging.error(\"sound directory %s wasn't found\" % (configd['sound_dir'],))\n return False\n return True","def is_config(command): \n if command.startswith('<') and command.endswith('>') and \\\n ('WRITE' not in command) and ('READ' not in command):\n return True\n else:\n return False\n # end if","def is_config_exist(self) -> bool:\n return True","def check_configuration(self):\n\n return bool(os.path.isfile(self.config_path) and\n self.validate_configuration_file())","def isGoalState(self, state):\n diff = state.get_pos() - self._player_loc\n return diff.y == 0 and (diff.x == 0 or diff.z == 0) and \\\n abs(diff.x) + abs(diff.z) == 2 and \\\n state.get_block(self._player_loc + diff/2 + _Vec3(0, -1, 0)) not in \\\n (_AIR, _LAVA, _WATER)","def isGoalState(self, state):\n return state.contains(self._block_id)","def goal_test(goal_test_state):\n goal_state = (1, 2, 3, 4, 5, 6, 7, 8, 0)\n return goal_state == goal_test_state","def check(self, context):\r\n return context.config.stopAt is not None","def is_command_ancillary(args):\n # pylint: disable=bad-continuation\n if (\n # skip the parent check and only\n # determine if the parameter is present\n is_valid_executes(args, skip=True)\n ):\n return True\n return False","def is_valid_task_config(config):\n try:\n config_json = json.loads(config)\n except ValueError:\n return False\n return validate_config(config_json)","def is_goal_node(self, node):\n for agent, position in node.curr_positions.items():\n\n if position['location'] != self.goalPositions[agent]:\n return False\n\n return True","def _acceptable(self, team):\r\n current = [c for c in self.configurations if self._validateNoSpies(c, team)]\r\n return bool(len(current) > 0)","def check_annotation(config):\n # Check whether to set annotation downstream of assembly\n tools = [config[\"annotation\"][key] for key in config[\"annotation\"].keys()]\n assems = [config[\"assembly\"][\"metaspades\"], config[\"assembly\"][\"megahit\"]]\n config[\"run_assembly\"] = False\n if True in tools and True in assems:\n config[\"run_annotation\"] = True\n # if True also assume the user wants assembly\n config[\"run_assembly\"] = True\n # Set megahit as default unless metaspades is set\n if not config[\"assembly\"][\"megahit\"] and not config[\"assembly\"][\n \"metaspades\"]:\n config[\"assembly\"][\"megahit\"] = True\n return config","def is_goal(self):\n if 0 in self.final_values: # Check if any zeroes are in the final states\n return False\n return True","def config_sanity_check():\n\n rv = True\n # For now, only \"error\" supported for get returns\n if config_check(\"copy_semantics\") != \"read\":\n debug(\"Only 'read' is supported for copy_semantics\");\n rv = False \n if config_check(\"get_returns\") != \"error\":\n debug(\"Only 'error' is supported for get-accessor return types\\m\");\n rv = False \n if not config_check(\"use_fn_ptrs\") and not config_check(\"gen_unified_fns\"):\n debug(\"Must have gen_fn_ptrs and/or gen_unified_fns set in config\")\n rv = False\n if config_check(\"use_obj_id\"):\n debug(\"use_obj_id is set but not yet supported (change \\\nconfig_sanity_check if it is)\")\n rv = False\n if config_check(\"gen_unified_macros\") and config_check(\"gen_unified_fns\") \\\n and config_check(\"gen_unified_macro_lower\"):\n debug(\"Conflict: Cannot generate unified functions and lower case \\\nunified macros\")\n rv = False\n \n return rv","def is_solution(self):\n # Only need to check the length because the configuration expansion assesses the feasibility.\n return len(self._path) == self._N","async def is_configured(hass: HomeAssistant) -> bool:\n manager = await async_get_manager(hass)\n if manager.data is None:\n return False\n return bool(manager.data != manager.default_preferences())","def isGoalState(self, state):\n x, y = state[0]\n\n \"*** YOUR CODE HERE ***\"\n return self.food[x][y]\n # util.raiseNotDefined()","def is_v1_config(config):\n return not is_v2_config(config)","def isGoalState(self, state):\n x,y = state\n\n \"*** YOUR CODE HERE ***\"\n return self.food[x][y]","def should_profile():\n if util.dev_server:\n return _config.should_profile_development()\n else:\n return _config.should_profile_production()","def validate_bot_config(config_bundle) -> None:\n if not config_bundle.looks_path or not config_bundle.name:\n raise AttributeError(f\"Bot config {config_bundle.config_path} is missing a name or a looks_path!\")\n\n # This will raise an exception if the looks config is malformed\n config_bundle.get_looks_config()","def check_config(config):\n\n # Check config\n assert config.dataset in [\"conll04\", \"ace05\"]\n assert config.train_mode in [\"train\", \"train+dev\"]\n\n for emb in config.embedder:\n assert emb in [\"word\", \"char\", \"bert-base\", \"bert-large\"], emb\n\n if \"char\" in config.embedder:\n assert config.char_pool in [\"last\", \"avg\", \"max\"]\n\n if config.encoder is not None:\n assert config.encoder == \"bilstm\"\n\n for task in config.tasks:\n assert task in [\"ner\", \"re\"]\n\n assert config.ner_decoder in [\"iobes\", \"span\"]\n\n if \"cuda\" in config.device:\n assert torch.cuda.is_available(), \"CUDA not available\"","def _verify_options(config: configuration.Config) -> None:\n\n if not config.config['species']:\n log._logger.error('You must specify a species (-s/--species)')\n exit(1)\n\n if config.config['hpc'] and config.config['local']:\n log._logger.error('You can only use one of the config options (hpc/local)')\n exit(1)\n\n if config.config['hpc'] and config.config['custom']:\n log._logger.error('You can only use one of the config options (hpc/custom)')\n exit(1)\n\n if config.config['local'] and config.config['custom']:\n log._logger.error('You can only use one of the config options (local/custom)')\n exit(1)\n\n if (not config.config['hpc']) and\\\n (not config.config['local']) and\\\n (not config.config['custom']):\n log._logger.error(\n 'You must specify a compute cluster environment (hpc/local/custom)'\n )\n exit(1)\n\n if config.config['custom'] and (not config.config['scheduler']):\n log._logger.error(\n 'The custom compute environment requires a scheduler address to be set'\n )\n exit(1)"],"string":"[\n \"def test_goal(puzzle_state, goal):\\n return puzzle_state.config == goal\",\n \"def test_goal(state):\\r\\n \\r\\n if state.config == (0,1,2,3,4,5,6,7,8):\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def check_config(cfg):\",\n \"def is_goal(self, url):\\n return url == self.goal_url\",\n \"def is_goal(self, state):\\n return state in self.goals # Optionally override this!\",\n \"def test_goal(puzzle_state):\\n goal_state = (0, 1, 2, 3, 4, 5, 6, 7, 8)\\n\\n if(puzzle_state.config == goal_state):\\n return True\\n else:\\n return False\",\n \"def goal_test(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n if (state[0], state[1]) in self.goals: #Check to see if at goal state\\n return True\\n else:\\n return False\",\n \"def check_config(self):\\n # Check if tool is at all included in workflow\\n if \\\"external\\\" not in self.config[\\\"tools\\\"][\\\"dna\\\"]:\\n return # External not run, don't check configuration # pragma: no cover\",\n \"def check_config(config):\\n pass\",\n \"def goal_test(self, state):\\n\\t\\tif isinstance(self.goal, list):\\n\\t\\t\\treturn is_in(state, self.goal)\\n\\t\\telse:\\n\\t\\t\\treturn state == self.goal\",\n \"def is_goal(state):\\n pass\",\n \"def goal_test(self, state):\\n\\n\\t\\treturn self.goal == state\",\n \"def is_goal(self, node):\\n # print(\\\"is {} in {}\\\".format(node, self.goal_nodes))\\n if node in self.goal_nodes:\\n return True\",\n \"def goal_test(self, state):\\n if isinstance(self.goal, list):\\n return is_in(state, self.goal)\\n else:\\n return state == self.goal\",\n \"def is_goal(self, state: Grid2D.State) -> bool:\\n return state.agent_position in self.goals\",\n \"def goal_test(self, state):\\n return state == self.goal\",\n \"def goal_test(self, state):\\n return state == self.goal\",\n \"def goal_test(self, state):\\n\\n return state == self.goal\",\n \"def goal_test(self, state):\\n\\n return state == self.goal\",\n \"def goal_test(self, state):\\n return (set(state[1]) == set(self.goal))\",\n \"def goal_test(self, state):\\n return (set(state[1]) == set(self.goal))\",\n \"def requires_route(self) -> bool:\\n return self.goal.is_specific()\",\n \"def check_config(self):\\n # Check if tool is at all included in workflow\\n if \\\"gatk_post_bam\\\" not in (self.config[\\\"postprocessing\\\"] or []): # pylint: disable=C0325\\n return # GATK BAM postprocessing not enabled, skip\\n\\n # Check required configuration settings present\\n self.parent.ensure_w_config(\\n config_keys=(\\\"step_config\\\", \\\"ngs_mapping\\\", \\\"gatk_post_bam\\\", \\\"paths_known_sites\\\"),\\n msg=\\\"Known sites list cannot be empty for GATK BAM postprocessing\\\",\\n )\\n self.parent.ensure_w_config(\\n config_keys=(\\\"static_data_config\\\", \\\"reference\\\", \\\"path\\\"),\\n msg=\\\"Path to reference FASTA required for GATK BAM postprocessing\\\",\\n )\",\n \"def validateConfig(config):\\n if getattr(config, 'TaskWorker', None) is None:\\n return False, \\\"Configuration problem: Task worker section is missing. \\\"\\n return True, 'Ok'\",\n \"def is_at_goal(self):\\n return self._current_loc.get_row() == BoardPath._goal_loc.get_row() and \\\\\\n self._current_loc.get_column() == BoardPath._goal_loc.get_column()\",\n \"def _check_config(self):\",\n \"def _goal_test(self, state):\\n if type(self.goal_states[0]) == list:\\n return list(state) in self.goal_states\\n elif type(self.goal_states[0]) == tuple:\\n return tuple(state) in self.goal_states\",\n \"def _goal_test(self, state):\\n if type(self.goal_states[0]) == list:\\n return list(state) in self.goal_states\\n elif type(self.goal_states[0]) == tuple:\\n return tuple(state) in self.goal_states\",\n \"def isGoalState(self, state):\\n\\t\\tutil.raiseNotDefined()\",\n \"def isGoal(self, state):\\n x, y = state\\n return (x, y) in self.food.asList()\",\n \"def isGoalState(self, state):\\n x,y = state\\n if x == self.goal[0] and y == self.goal[1]:\\n return True\\n else:\\n return False\\n util.raiseNotDefined()\",\n \"def isInGoal(self):\\n coordx= self.playerPos.x\\n coordy= self.playerPos.y\\n target = 0 if self.id_team == 1 else 1\\n\\n if((((target == 0)and (coordx<=5))|\\n ((target == 1) and(coordx>145))) \\n and (coordy<=50 and coordy>=40)):\\n return True\\n else:\\n return False\",\n \"def checkconfig(self): \\n validconfig = {\\n 'loglevel': lambda s: s in self.loglevels,\\n 'logfilelevel': lambda s: s in self.loglevels,\\n 'nodes': lambda s: isinstance(s, list),\\n 'pynodes': lambda s: isinstance(s, list)\\n }\\n alive = True\\n for key in self.config: \\n if (key in validconfig and \\n not validconfig[key](self.config[key])):\\n logging.critical(\\\"Invalid configuration option {}: {}\\\".format(\\n key, self.config[key]))\\n alive = False\\n return alive\",\n \"def goal_test(self, state):\\n #return state == self.goal\",\n \"def _is_goal_achieved(self) -> bool:\\n assert self._goal_info_cache\\n return self._goal_info_cache[1]\",\n \"def _is_supplied_by_config(group: argparse._MutuallyExclusiveGroup, conf: Dict[str, Any]) -> bool:\\n group_args = []\\n for arg in group._group_actions:\\n group_args.append(arg.dest)\\n\\n count = 0\\n for val in group_args:\\n if val in conf:\\n count += 1\\n return count == len(group_args) or count == 0\",\n \"def check() -> bool:\\n\\ttry:\\n\\t\\twith open(configPath, 'r') as file:\\n\\t\\t\\tcfg = json.load(file) # load the file\\n\\texcept FileNotFoundError:\\n\\t\\treturn False\\n\\t# check if EVERY config exists\\n\\tfor i in default_config.keys():\\n\\t\\tif i in cfg.keys():\\n\\t\\t\\tcontinue\\n\\t\\treturn False\\n\\t# final check\\n\\treturn cfg['config_type'] == default_config['config_type']\",\n \"def goal_test(self, state):\\n for x, y in state.alvos:\\n if state.tabuleiro[x][y] is not BOX_ON_TARGET:\\n return False\\n return True\",\n \"def is_goal(self):\\r\\n\\t\\tfor row in range(self.n):\\r\\n\\t\\t\\tfor col in range(self.n):\\r\\n\\t\\t\\t\\tif self.board[row][col] != BoardClass.goal[row][col]:\\r\\n\\t\\t\\t\\t\\treturn False\\r\\n\\r\\n\\t\\treturn True\",\n \"def check_config(self):\\n # Check if tool is at all included in workflow\\n if not (set(self.config[\\\"tools\\\"][\\\"dna_long\\\"]) & {\\\"ngmlr\\\", \\\"ngmlr_chained\\\"}):\\n return # NGLMR not run, don't check configuration # pragma: no cover\\n\\n # Check required configuration settings present\\n self.parent.ensure_w_config(\\n config_keys=(\\\"step_config\\\", \\\"ngs_mapping\\\", \\\"ngmlr\\\", \\\"path_index\\\"),\\n msg=\\\"Path to NGMLR index is required\\\",\\n )\",\n \"def is_goal(self, state):\\n return ''.join(self.desired_arrangement) in state.text\",\n \"def is_config_action(func: CLIActionType) -> bool:\\n return check_function_type(func, [HammerDriver, Callable[[str], None]], Optional[dict]) is None\",\n \"def checkGoal(self):\\n # -- It is not included for simplifity --#\\n if self.reward_cumulative != None:\\n x = round((abs(self.reward_cumulative) - abs(round(self.reward_cumulative))) * 100);\\n rem_goal = x % 25\\n rem_timeout = x % 20\\n if rem_goal == 0 and x != 0:\\n self.is_goal = True\\n else:\\n self.is_goal = False\\n\\n if rem_timeout == 0 and x != 0:\\n self.is_timeout = True\\n else:\\n self.is_timeout = False\",\n \"def antenny_config_check(self):\\n return self.antenny_config.check()\",\n \"def isGoalState(self, state):\\n x, y = state\\n if state in self.food.asList():\\n return True\",\n \"def check_config(self):\\n # Check if tool is at all included in workflow\\n if self.__class__.name not in self.config[\\\"tools\\\"][\\\"dna\\\"]:\\n return # BWA not run, don't check configuration # pragma: no cover\\n\\n # Check required configuration settings present\\n self.parent.ensure_w_config(\\n config_keys=(\\\"step_config\\\", \\\"ngs_mapping\\\", \\\"bwa\\\", \\\"path_index\\\"),\\n msg=\\\"Path to BWA index is required\\\",\\n )\\n\\n # Check that the path to the BWA index is valid.\\n for ext in (\\\".amb\\\", \\\".ann\\\", \\\".bwt\\\", \\\".pac\\\", \\\".sa\\\"):\\n expected_path = self.config[\\\"bwa\\\"][\\\"path_index\\\"] + ext\\n if not os.path.exists(expected_path): # pragma: no cover\\n tpl = \\\"Expected BWA input path {expected_path} does not exist!\\\".format(\\n expected_path=expected_path\\n )\\n raise InvalidConfiguration(tpl)\",\n \"def is_goal_state(self, state):\\n return self._solved_board == state.board\",\n \"def check(self, context):\\r\\n return context.config.preset is not None\",\n \"def __check_config(self):\\n if not os.path.exists(self.__config_path):\\n return False\\n else:\\n return True\",\n \"def goal_test(self):\\n if -1 in self.state:\\n return False\\n else:\\n return True\",\n \"def config_input(self):\\n answer = simpledialog.askstring(\\\"Input\\\", \\\"Please input the path of the config file.\\\",\\n parent=self._master) # ask for a string\\n if answer is not None:\\n try:\\n self.read_config(answer) # read the config\\n if all(k in self._config for k in ('World', 'Player')):\\n # check whether have a 'World' and 'Player'\\n return True\\n else: # if don't have 'World' or 'Player'\\n messagebox.showerror(\\\"Missing necessary heading\\\", \\\"Missing World or Player\\\")\\n return False\\n except IOError:\\n messagebox.showerror(\\\"Invalid path\\\",\\n \\\"'\\\" + answer + \\\"' is not a valid path!\\\")\\n return False\",\n \"def reach_goal(state: State, action: Action, next_state: State) -> bool:\\n return overlap(state, action, next_state, object_type=Goal)\",\n \"def goal_state(game_state):\\n if game_state[0]:\\n return False\\n return True\",\n \"def isGoalState(self, state):\\n x,y = state\\n\\n if state in self.food.asList():\\n return True\\n else:\\n return False\\n\\n util.raiseNotDefined()\",\n \"def check_config_file():\\n # Locate and init config.\\n default_config = \\\"config.json\\\"\\n if len(sys.argv) == 2:\\n # config from command line\\n app_config = config_reader(sys.argv[1])\\n else:\\n # config should be in default\\n app_config = config_reader(default_config)\\n # fin\\n if not app_config:\\n print(\\\"Exiting due to invalid config file.\\\")\\n return False\\n # fin\\n return app_config\",\n \"def check_config(self):\\n # Check if tool is at all included in workflow\\n if self.__class__.name not in self.config[\\\"tools\\\"][\\\"rna\\\"]:\\n return # STAR not run, don't check configuration # pragma: no cover\\n\\n # Check required configuration settings present\\n self.parent.ensure_w_config(\\n config_keys=(\\\"step_config\\\", \\\"ngs_mapping\\\", \\\"star\\\", \\\"path_index\\\"),\\n msg=\\\"Path to STAR index is required\\\",\\n )\\n self.parent.ensure_w_config(\\n config_keys=(\\\"static_data_config\\\", \\\"reference\\\"),\\n msg=\\\"No reference genome FASTA file given\\\",\\n )\\n\\n # Check validity of the STAR index\\n full_path = self.config[\\\"star\\\"][\\\"path_index\\\"]\\n # a lot of files should be in this dir, justtest these\\n for indfile in (\\\"Genome\\\", \\\"SA\\\", \\\"SAindex\\\"):\\n expected_path = os.path.join(full_path, indfile)\\n if not os.path.exists(expected_path): # pragma: no cover\\n tpl = \\\"Expected STAR index file {expected_path} does not exist!\\\".format(\\n expected_path=expected_path\\n )\\n raise InvalidConfiguration(tpl)\",\n \"def resolve(self, config: \\\"Config\\\") -> bool:\\n option = config.getoption(self.argument, default=None)\\n if option is not None:\\n # A value is set, and it is not the default one\\n return self.validate(option)\\n\\n if os.getenv(self.environment_variable):\\n return True\\n\\n return False\",\n \"def check_configuration(self, configuration):\\n super(Hipchap, self).check_configuration(configuration)\",\n \"def test_goal(puzzle_state):\\n \\n x = puzzle_state.dimension\\n final_state = []\\n \\n for i in range(x*x):\\n final_state += [i]\\n \\n final_state_tuple = tuple(final_state)\\n \\n if puzzle_state.config == final_state_tuple:\\n return True\\n else:\\n return False\",\n \"def is_goal(state):\\r\\n goal_state = [[0], [1, 2, 3], [4, 5, 6], [7, 8, 9]]\\r\\n return state == goal_state\",\n \"def isGoalState(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # Utilizaré el método .count del grid, de manera que me contará los trues que haya.\\n # Cuando no queden trues, ya hemos acabado.\\n return state[1].count() == 0\\n # util.raiseNotDefined()\",\n \"def check_config():\\n\\n if not config_instance:\\n LOG.error(\\\"Failed to load the config!\\\")\\n sys.exit(9)\\n\\n if not hasattr(config_instance, \\\"CONFIG_VERSION\\\"):\\n LOG.warning( \\\"The config file does not specify CONFIG_VERSION! I will \\\"\\n \\\"try to continue anyway, but this field is recommended to allow \\\"\\n \\\"some internal tests to work. I will assume the value '(1,0)'!\\\" )\\n config_instance.CONFIG_VERSION = (1, 0)\\n\\n major, minor = config_instance.CONFIG_VERSION\\n expected_major, expected_minor = EXPECTED_CONFIG_VERSION\\n\\n if major < expected_major:\\n LOG.critical(\\\"The config system has undergone a major change! \\\"\\n \\\"I cannot continue without an upgrade!\\\")\\n sys.exit(9)\\n\\n if minor < expected_minor:\\n LOG.warning(\\\"The config system has undergone a minor change! \\\"\\n \\\"It should work, but you still should review the docs!\\\")\\n\\n if major == expected_major and minor == expected_minor:\\n LOG.debug( \\\"Config version OK!\\\" )\\n\\n if not hasattr(config_instance, \\\"GENERATORS\\\"):\\n LOG.critical(\\\"Variable 'GENERATORS' not found in config!\\\")\\n sys.exit(9)\\n\\n if not hasattr(config_instance, \\\"TARGETS\\\"):\\n LOG.critical(\\\"Variable 'TARGETS' not found in config!\\\")\\n sys.exit(9)\",\n \"def goal_check(current_node, target_node):\\n if current_node.id == target_node.id:\\n return True\\n else:\\n return False\",\n \"def isGoalState(self, state):\\n x,y = state\\n foods = self.food.asList()\\n if state in foods:\\n return True\\n else:\\n return False\\n util.raiseNotDefined()\",\n \"def isGoalState(self, state):\\n return state in self.food.asList()\",\n \"def check_configs(self):\\n\\n pass\",\n \"def goal_test(self, state):\\r\\n assignment = dict(state)\\r\\n return (len(assignment) == len(self.variables)\\r\\n and all(self.nconflicts(variables, assignment[variables], assignment) == 0\\r\\n for variables in self.variables))\",\n \"def __isTileGoalState(self, point):\\n return point == self.goalPoint\",\n \"def is_experiment(cfg):\\n if CONDITIONS in list(cfg.keys()):\\n return True\\n else:\\n return False\",\n \"def check_config_mode(self):\\n return False\",\n \"def validate_config(self, config: Dict) -> bool:\\n raise NotImplementedError\",\n \"def valid_configuration(self):\\n valid = True\\n\\n if (not self.__config.suffix()) and (self.__config.output_dir() == self.__config.input_dir()):\\n print(\\\"ERROR: output_dir directory cannot be the same as input_dir with an empty suffix!\\\")\\n valid = False\\n if not self.__config.public_key():\\n print(\\\"ERROR: public_key not set! Set it through 'pdfworkshop config public_key <your_key>'. \\\"\\n \\\"A free API key can be obtained from https://developer.ilovepdf.com/\\\")\\n valid = False\\n return valid\",\n \"def is_config_exist(self) -> bool:\\n pass\",\n \"def is_configured(command):\\n return command in COMMANDS\",\n \"def check_configuration(self, configuration):\\n super(Pixiv_bot, self).check_configuration(configuration)\",\n \"def check():\\n\\t\\t# This forces user to set dirs before running the app for first time.\\n\\t\\tif len(Config.lyrics_dir) == 0:\\n\\t\\t\\t# see which directory in not set and raise BadConfigError with that as value\\n\\t\\t\\tprint('lyrics_dir is not set.')\\n\\t\\t\\tprint('Please use the \\\"set\\\" command to set lyrics_dir.')\\n\\t\\t\\tprint('use \\\"lyrico --help\\\" to view commands.')\\n\\t\\t\\treturn False\\n\\n\\t\\tif len(Config.source_dir) == 0:\\n\\t\\t\\t# see which directory in not set and raise BadConfigError with that as value\\n\\t\\t\\tprint('source_dir is not set.')\\n\\t\\t\\tprint('Please use the \\\"set\\\" command to set source_dir or pass it as parameter.')\\n\\t\\t\\tprint('use \\\"lyrico --help\\\" to view commands.')\\n\\t\\t\\treturn False\\n\\n\\t\\t# if user disable both saving mode. Notify & force user to correct on next run.\\n\\t\\tif not Config.save_to_file and not Config.save_to_tag:\\n\\t\\t\\tprint('Both \\\"save_to_file\\\" and \\\"save_to_tag\\\" modes are disabled. Please enable one.')\\n\\t\\t\\tprint('use \\\"lyrico --help\\\" to view commands.')\\n\\t\\t\\treturn False\\n\\n\\t\\t# if user disables all sources. Notify & force user to enable one.\\n\\t\\tif (not Config.lyric_wikia\\n\\t\\t and not Config.az_lyrics\\n\\t\\t and not Config.musix_match\\n\\t\\t and not Config.lyricsmode):\\n\\t\\t\\tprint('All lyrics sources are disabled. Please enable one.')\\n\\t\\t\\tprint('use \\\"lyrico --help\\\" to view commands.')\\n\\t\\t\\treturn False\\n\\t\\treturn True\",\n \"def check_config(configd):\\n # XXX: verify first that the required config parameters are present\\n if not os.path.exists(configd['player']):\\n logging.error(\\\"player %s wasn't found\\\" % (configd['player'],))\\n return False\\n if not os.path.isdir(configd['sound_dir']):\\n logging.error(\\\"sound directory %s wasn't found\\\" % (configd['sound_dir'],))\\n return False\\n return True\",\n \"def is_config(command): \\n if command.startswith('<') and command.endswith('>') and \\\\\\n ('WRITE' not in command) and ('READ' not in command):\\n return True\\n else:\\n return False\\n # end if\",\n \"def is_config_exist(self) -> bool:\\n return True\",\n \"def check_configuration(self):\\n\\n return bool(os.path.isfile(self.config_path) and\\n self.validate_configuration_file())\",\n \"def isGoalState(self, state):\\n diff = state.get_pos() - self._player_loc\\n return diff.y == 0 and (diff.x == 0 or diff.z == 0) and \\\\\\n abs(diff.x) + abs(diff.z) == 2 and \\\\\\n state.get_block(self._player_loc + diff/2 + _Vec3(0, -1, 0)) not in \\\\\\n (_AIR, _LAVA, _WATER)\",\n \"def isGoalState(self, state):\\n return state.contains(self._block_id)\",\n \"def goal_test(goal_test_state):\\n goal_state = (1, 2, 3, 4, 5, 6, 7, 8, 0)\\n return goal_state == goal_test_state\",\n \"def check(self, context):\\r\\n return context.config.stopAt is not None\",\n \"def is_command_ancillary(args):\\n # pylint: disable=bad-continuation\\n if (\\n # skip the parent check and only\\n # determine if the parameter is present\\n is_valid_executes(args, skip=True)\\n ):\\n return True\\n return False\",\n \"def is_valid_task_config(config):\\n try:\\n config_json = json.loads(config)\\n except ValueError:\\n return False\\n return validate_config(config_json)\",\n \"def is_goal_node(self, node):\\n for agent, position in node.curr_positions.items():\\n\\n if position['location'] != self.goalPositions[agent]:\\n return False\\n\\n return True\",\n \"def _acceptable(self, team):\\r\\n current = [c for c in self.configurations if self._validateNoSpies(c, team)]\\r\\n return bool(len(current) > 0)\",\n \"def check_annotation(config):\\n # Check whether to set annotation downstream of assembly\\n tools = [config[\\\"annotation\\\"][key] for key in config[\\\"annotation\\\"].keys()]\\n assems = [config[\\\"assembly\\\"][\\\"metaspades\\\"], config[\\\"assembly\\\"][\\\"megahit\\\"]]\\n config[\\\"run_assembly\\\"] = False\\n if True in tools and True in assems:\\n config[\\\"run_annotation\\\"] = True\\n # if True also assume the user wants assembly\\n config[\\\"run_assembly\\\"] = True\\n # Set megahit as default unless metaspades is set\\n if not config[\\\"assembly\\\"][\\\"megahit\\\"] and not config[\\\"assembly\\\"][\\n \\\"metaspades\\\"]:\\n config[\\\"assembly\\\"][\\\"megahit\\\"] = True\\n return config\",\n \"def is_goal(self):\\n if 0 in self.final_values: # Check if any zeroes are in the final states\\n return False\\n return True\",\n \"def config_sanity_check():\\n\\n rv = True\\n # For now, only \\\"error\\\" supported for get returns\\n if config_check(\\\"copy_semantics\\\") != \\\"read\\\":\\n debug(\\\"Only 'read' is supported for copy_semantics\\\");\\n rv = False \\n if config_check(\\\"get_returns\\\") != \\\"error\\\":\\n debug(\\\"Only 'error' is supported for get-accessor return types\\\\m\\\");\\n rv = False \\n if not config_check(\\\"use_fn_ptrs\\\") and not config_check(\\\"gen_unified_fns\\\"):\\n debug(\\\"Must have gen_fn_ptrs and/or gen_unified_fns set in config\\\")\\n rv = False\\n if config_check(\\\"use_obj_id\\\"):\\n debug(\\\"use_obj_id is set but not yet supported (change \\\\\\nconfig_sanity_check if it is)\\\")\\n rv = False\\n if config_check(\\\"gen_unified_macros\\\") and config_check(\\\"gen_unified_fns\\\") \\\\\\n and config_check(\\\"gen_unified_macro_lower\\\"):\\n debug(\\\"Conflict: Cannot generate unified functions and lower case \\\\\\nunified macros\\\")\\n rv = False\\n \\n return rv\",\n \"def is_solution(self):\\n # Only need to check the length because the configuration expansion assesses the feasibility.\\n return len(self._path) == self._N\",\n \"async def is_configured(hass: HomeAssistant) -> bool:\\n manager = await async_get_manager(hass)\\n if manager.data is None:\\n return False\\n return bool(manager.data != manager.default_preferences())\",\n \"def isGoalState(self, state):\\n x, y = state[0]\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n return self.food[x][y]\\n # util.raiseNotDefined()\",\n \"def is_v1_config(config):\\n return not is_v2_config(config)\",\n \"def isGoalState(self, state):\\n x,y = state\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n return self.food[x][y]\",\n \"def should_profile():\\n if util.dev_server:\\n return _config.should_profile_development()\\n else:\\n return _config.should_profile_production()\",\n \"def validate_bot_config(config_bundle) -> None:\\n if not config_bundle.looks_path or not config_bundle.name:\\n raise AttributeError(f\\\"Bot config {config_bundle.config_path} is missing a name or a looks_path!\\\")\\n\\n # This will raise an exception if the looks config is malformed\\n config_bundle.get_looks_config()\",\n \"def check_config(config):\\n\\n # Check config\\n assert config.dataset in [\\\"conll04\\\", \\\"ace05\\\"]\\n assert config.train_mode in [\\\"train\\\", \\\"train+dev\\\"]\\n\\n for emb in config.embedder:\\n assert emb in [\\\"word\\\", \\\"char\\\", \\\"bert-base\\\", \\\"bert-large\\\"], emb\\n\\n if \\\"char\\\" in config.embedder:\\n assert config.char_pool in [\\\"last\\\", \\\"avg\\\", \\\"max\\\"]\\n\\n if config.encoder is not None:\\n assert config.encoder == \\\"bilstm\\\"\\n\\n for task in config.tasks:\\n assert task in [\\\"ner\\\", \\\"re\\\"]\\n\\n assert config.ner_decoder in [\\\"iobes\\\", \\\"span\\\"]\\n\\n if \\\"cuda\\\" in config.device:\\n assert torch.cuda.is_available(), \\\"CUDA not available\\\"\",\n \"def _verify_options(config: configuration.Config) -> None:\\n\\n if not config.config['species']:\\n log._logger.error('You must specify a species (-s/--species)')\\n exit(1)\\n\\n if config.config['hpc'] and config.config['local']:\\n log._logger.error('You can only use one of the config options (hpc/local)')\\n exit(1)\\n\\n if config.config['hpc'] and config.config['custom']:\\n log._logger.error('You can only use one of the config options (hpc/custom)')\\n exit(1)\\n\\n if config.config['local'] and config.config['custom']:\\n log._logger.error('You can only use one of the config options (local/custom)')\\n exit(1)\\n\\n if (not config.config['hpc']) and\\\\\\n (not config.config['local']) and\\\\\\n (not config.config['custom']):\\n log._logger.error(\\n 'You must specify a compute cluster environment (hpc/local/custom)'\\n )\\n exit(1)\\n\\n if config.config['custom'] and (not config.config['scheduler']):\\n log._logger.error(\\n 'The custom compute environment requires a scheduler address to be set'\\n )\\n exit(1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7215837","0.6925614","0.68441874","0.67809874","0.6737237","0.66554487","0.6639001","0.6628785","0.6553829","0.6422694","0.6376019","0.63585305","0.63565326","0.63558185","0.6341891","0.63215846","0.63215846","0.6273997","0.6273997","0.6271821","0.6271821","0.6264714","0.6231262","0.6223104","0.6128232","0.6120011","0.60966974","0.60966974","0.60835415","0.60832304","0.606271","0.6053856","0.6049242","0.6049107","0.6043141","0.6011009","0.5950289","0.5949853","0.5936849","0.5921952","0.58815503","0.587708","0.58632207","0.58621895","0.5851822","0.58310664","0.582325","0.581294","0.580384","0.57841915","0.57597387","0.5756397","0.5755826","0.5751389","0.5745114","0.57411516","0.57379866","0.5736682","0.5708243","0.57037485","0.5700252","0.5688706","0.56785715","0.56689495","0.5663798","0.5663461","0.56542987","0.5650129","0.564979","0.5644545","0.5614238","0.55994296","0.55972517","0.55968773","0.55764055","0.55763274","0.5560546","0.5549074","0.55458105","0.5545001","0.5523722","0.54575914","0.5453511","0.5448844","0.54458994","0.5445096","0.54444224","0.54399514","0.5436141","0.54289097","0.54284114","0.5427166","0.542302","0.54123807","0.53944933","0.5384529","0.53843725","0.5383618","0.5375541","0.53749675"],"string":"[\n \"0.7215837\",\n \"0.6925614\",\n \"0.68441874\",\n \"0.67809874\",\n \"0.6737237\",\n \"0.66554487\",\n \"0.6639001\",\n \"0.6628785\",\n \"0.6553829\",\n \"0.6422694\",\n \"0.6376019\",\n \"0.63585305\",\n \"0.63565326\",\n \"0.63558185\",\n \"0.6341891\",\n \"0.63215846\",\n \"0.63215846\",\n \"0.6273997\",\n \"0.6273997\",\n \"0.6271821\",\n \"0.6271821\",\n \"0.6264714\",\n \"0.6231262\",\n \"0.6223104\",\n \"0.6128232\",\n \"0.6120011\",\n \"0.60966974\",\n \"0.60966974\",\n \"0.60835415\",\n \"0.60832304\",\n \"0.606271\",\n \"0.6053856\",\n \"0.6049242\",\n \"0.6049107\",\n \"0.6043141\",\n \"0.6011009\",\n \"0.5950289\",\n \"0.5949853\",\n \"0.5936849\",\n \"0.5921952\",\n \"0.58815503\",\n \"0.587708\",\n \"0.58632207\",\n \"0.58621895\",\n \"0.5851822\",\n \"0.58310664\",\n \"0.582325\",\n \"0.581294\",\n \"0.580384\",\n \"0.57841915\",\n \"0.57597387\",\n \"0.5756397\",\n \"0.5755826\",\n \"0.5751389\",\n \"0.5745114\",\n \"0.57411516\",\n \"0.57379866\",\n \"0.5736682\",\n \"0.5708243\",\n \"0.57037485\",\n \"0.5700252\",\n \"0.5688706\",\n \"0.56785715\",\n \"0.56689495\",\n \"0.5663798\",\n \"0.5663461\",\n \"0.56542987\",\n \"0.5650129\",\n \"0.564979\",\n \"0.5644545\",\n \"0.5614238\",\n \"0.55994296\",\n \"0.55972517\",\n \"0.55968773\",\n \"0.55764055\",\n \"0.55763274\",\n \"0.5560546\",\n \"0.5549074\",\n \"0.55458105\",\n \"0.5545001\",\n \"0.5523722\",\n \"0.54575914\",\n \"0.5453511\",\n \"0.5448844\",\n \"0.54458994\",\n \"0.5445096\",\n \"0.54444224\",\n \"0.54399514\",\n \"0.5436141\",\n \"0.54289097\",\n \"0.54284114\",\n \"0.5427166\",\n \"0.542302\",\n \"0.54123807\",\n \"0.53944933\",\n \"0.5384529\",\n \"0.53843725\",\n \"0.5383618\",\n \"0.5375541\",\n \"0.53749675\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.54483956"},"document_rank":{"kind":"string","value":"84"}}},{"rowIdx":91995,"cells":{"query":{"kind":"string","value":"Compute the entropy of the mean of the predictive distribution obtained from Monte Carlo sampling during prediction phase."},"document":{"kind":"string","value":"def predictive_entropy(mc_preds):\n return entropy(np.mean(mc_preds, axis=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 entropy(self):\n return -np.sum(self.log_likelihoods * np.exp(self.log_likelihoods))","def entropy(y):\n EPS = 0.0005\n\n # YOUR CODE HERE\n if len(y) == 0:\n return 0.\n \n pk = np.mean(y, axis=0)\n \n return - np.sum(pk * np.log(pk + EPS))","def entropy(self):\n Z = self.sum()\n assert (Z > 0), 'Non-normalizable factor (perhaps log factor?)' # also check for positivity?\n H = 0.0\n for x in np.nditer(self.t, op_flags=['readonly']):\n p = x/Z\n H += 0.0 if p==0 else -p*np.log(p)\n return H","def entropy(self):\n return self._normal.entropy()","def entropy(self):\n n = len(self.y)\n sum_ = 0\n for i in np.unique(self.y):\n v = len(self.y[self.y == i])\n sum_ += -((v/n) * log2(v/n))\n return sum_","def entropy(self):\r\n return 1/2 * (self.dim * (_LOG_2PI + 1) + self._log_det_cov)","def entropy(data):\n e = 0\n\n counter = collections.Counter(data)\n l = len(data)\n for count in counter.values():\n p_x = count / l\n e += - p_x * math.log2(p_x)\n\n return e","def entropy(Y):\n\n temp = np.unique(Y, return_counts=True)\n uniq_Y = list(temp[0])\n Y_count = list(temp[1])\n \n total = sum(Y_count)\n\n ent = 0\n for elem in uniq_Y:\n prob = Y_count[uniq_Y.index(elem)] / total\n # print(\"prob:\", prob)\n ent -= (prob * (math.log2(prob)))\n # print(\"ent:\",ent)\n\n return ent","def entropy(img):\n # by calculating\n histogram = img.histogram()\n histogram_size = sum(histogram)\n histogram = [float(h) / histogram_size for h in histogram]\n\n return -sum([p * math.log(p, 2) for p in histogram if p != 0])","def entropy(self):\n raise NotImplementedError","def entropy(out, dim=1, reduce='mean'):\n log_prob = F.log_softmax(out, dim=dim)\n h = -torch.sum(log_prob.exp() * log_prob, dim=dim)\n if reduce == 'none':\n return h\n if reduce == 'mean':\n return h.mean()\n if reduce == 'sum':\n return h.sum()","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 _entropy(data):\n hist = np.array(PIL.Image.fromarray(data).histogram())\n hist = hist / hist.sum()\n hist = hist[hist != 0]\n return -np.sum(hist * np.log2(hist))","def computeEntropy(self, img):\n hist, bins = np.histogram(img.ravel(), bins=256, density=True)\n return scipy.stats.entropy(hist)","def entropy(self, mean=None, cov=1):\r\n dim, mean, cov = _process_parameters(None, mean, cov)\r\n return 1/2 * np.log(np.linalg.det(2 * np.pi * np.e * cov))","def entropy(self, args):\n mean, stddev = args\n dist = tfp.distributions.Normal(loc=mean, scale=stddev)\n entropy = dist.entropy()\n return entropy","def mean_ent(cluster_assignments):\n nrow, ncol, nrun = cluster_assignments.shape\n csum = cluster_assignments.sum(axis=2)\n m = numpy.mean([scipy.stats.entropy(row) for row in csum])\n return m","def entropy(x):\n nz = np.nonzero(x)[0]\n return -np.sum(x[nz]*np.log2(x[nz]))","def entropy(self, X):\n if isinstance(X, np.ndarray):\n X = pd.DataFrame(X, index=[str(i) for i in range(len(X))])\n K = self._posterior_covariance(X)\n L = np.linalg.cholesky(K)\n D = len(X)\n return np.sum(np.log(np.diag(L))) + 0.5 * D * np.log(2*np.pi*np.exp(1))","def conditional_entropy(self) -> float:\n pass","def entropy(self):\n ent = 0.0\n for f in self.byte_freq:\n if f > 0:\n freq = float(f) / self.byte_total\n ent = ent + freq * math.log(freq, 2)\n return -ent","def entropy(Y):\n unique, count = np.unique(Y, return_counts=True, axis=0)\n prob = count/len(Y)\n en = np.sum((-1)*prob*np.log2(prob))\n return en","def __compute_entropy(row:pd.Series) -> float:\n probability = row.value_counts(normalize=True).values\n entropy = EntropicSolver.__compute_entropy_probability(probability)\n return entropy","def __compute_entropy_probability(probability:np.ndarray) -> float:\n entropy = -np.sum(probability * np.log2(probability))\n return entropy","def entropy(self, y):\n n = y.size\n if n <= 1:\n return 0\n\n labels, counts = unique(y, return_counts=True)\n\n if counts.size <= 1:\n return 0\n\n probs = counts / n\n entropy = -sum([p * log(p, 2) for p in probs])\n return entropy","def entropy(y):\n total = y.size\n value_counts = np.bincount(y).astype(\"float\")\n proportions = value_counts / y.size\n\n return sum(-i * np.log(i) for i in proportions if i)","def get_entropy(distribution, samples):\n entropy = -tf.reduce_sum(distribution.log_prob(samples), axis=1)\n return entropy","def entropy(y):\n p = _proba(y)\n return (-p * np.log2(p)).sum()","def ensemble_entropy(self):\n return transition_matrices.entropy_measure(self.ensemble_transition_matrix)","def entropy(d, total, word_count):\n\t# Entropie je - Sum_morf p(morf) * log_2 p(morf)\n\t# p(morf) = c(morf) / c(all)\n\te = 0\n\tfor count in d.values():\n\t\tp = count/total\n\t\ttype_e = - p * log2(p)\n\t\te += type_e * count\n\treturn e / word_count","def entropy(P):\n P_nan = P.copy()\n P_nan[P_nan == 0] = np.nan\n return np.nansum(np.multiply(P_nan, np.log2(1 / P_nan)))","def compute_entropy(sampled, dataset, model, train_args):\n all_entropy = None\n data = Subset(dataset, sampled)\n sampler = SequentialSampler(data)\n dataloader = DataLoader(data, sampler=sampler, batch_size=train_args.per_gpu_eval_batch_size)\n for batch in tqdm(dataloader, desc=\"Computing entropy\"):\n batch = tuple(t.to(train_args.device) for t in batch)\n with torch.no_grad():\n inputs = {\"input_ids\": batch[0], \"attention_mask\": batch[1]}\n if train_args.model_type != \"distilbert\":\n inputs[\"token_type_ids\"] = (\n batch[2] if train_args.model_type in [\"bert\", \"xlnet\", \"albert\"] else None\n ) # XLM, DistilBERT, RoBERTa, and XLM-RoBERTa don't use segment_ids\n outputs = model(**inputs)\n logits = outputs[0]\n categorical = Categorical(logits = logits)\n entropy = categorical.entropy()\n if all_entropy is None:\n all_entropy = entropy.detach().cpu().numpy()\n else:\n all_entropy = np.append(all_entropy, entropy.detach().cpu().numpy(), axis=0)\n avg_entropy = all_entropy.mean()\n return avg_entropy","def entropy(data):\n n, m = np.shape(data)\n data = np.tanh(data)\n data = data / np.sum(data, axis=0)\n a = data * 1.0\n a[np.where(data == 0)] = 0.000001\n\n e = (-1.0 / np.log(n)) * np.sum(data * np.log(a), axis=0)\n w = (1 - e) / np.sum(1 - e)\n return w","def entropy(self, params):\n log_std = params[:, :, 1]\n return (log_std + 0.5 * (self.LOG2PI + 1)).sum(dim=-1)","def entropy(self,classData):\n\n\t\t###### your implementation below ######\n\t\ttotalEntropy = 0\n\t\ttempSet = {}\n\t\tfor i in range(len(classData)):\n\t\t\ttempSet[classData[i]] = (classData.count(classData[i]))\n\t\ttotal = sum(tempSet.values())\n\t\tfor x in tempSet:\n\t\t\ttotalEntropy += -(tempSet[x]/total * math.log(tempSet[x]/total, 2))\n\t\treturn totalEntropy","def __entropy(self, data_set, target_feature):\n frequencies = self.__calculate_frequency(data_set, target_feature)\n feature_entropy = 0.0\n number_of_values = len(data_set)\n\n # Add entropy for each value in frequencies.\n for frequency in frequencies:\n probability = frequencies[frequency] / number_of_values\n feature_entropy += (probability * math.log(probability, 2))\n\n return feature_entropy * -1","def entropy(dist):\n #dist = array([max(d,1e-100) for d in dist])\n dist = dist + 1e-20\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)","def entropy(y):\r\n\r\n # INSERT YOUR CODE HERE\r\n value, count = np.unique(y,return_counts = True)\r\n Hy = 0.0\r\n prob = count.astype(float)/len(y)\r\n for p in prob:\r\n Hy += -(p)*(np.log2(p))\r\n return Hy\r\n raise Exception('Function not yet implemented!')","def entropy(self):\n return self._entropy_func","def calc_entropy(data_set): #calculates total entropy of the dataset\r\n republicans = 0\r\n democrats = 0\r\n total = 0\r\n for data_point in data_set:\r\n party = data_point.dat_party\r\n if party == \"R\":\r\n republicans+=1\r\n elif party == \"D\":\r\n democrats+=1\r\n total+=1\r\n\r\n if total == 0: return 0\r\n prob_dem = democrats/total\r\n prob_rep = republicans/total\r\n if prob_dem == 0: return -(prob_rep * math.log(prob_rep, 2))\r\n if prob_rep == 0: return -(prob_dem * math.log(prob_dem, 2))\r\n\r\n entropy = (-prob_dem * math.log(prob_dem, 2)) -(prob_rep * math.log(prob_rep, 2))\r\n return entropy","def entropy(self, policy_params):\n return self.head.entropy(policy_params)","def entropy(data):\n\n freqs = {}\n suma = len(data)\n\n for i in range(0, len(data)):\n freqs[data[i]] = 1.0 + freqs.get(data[i], 0)\n\n res = 0.0\n for i in freqs:\n res += (freqs[i] / suma) * log((freqs[i] / suma), 2)\n return -res","def image_entropy(img):\r\n hist = img.histogram()\r\n hist_size = sum(hist)\r\n hist = [float(h) / hist_size for h in hist]\r\n\r\n return -sum([p * math.log(p, 2) for p in hist if p != 0])","def _entropy(self):\n return self.rv.entropy(*self._pymc_dists_to_value(self.args), **self.kwds)","def entropy(group_counts):\n total = sum(group_counts)\n entro = 0\n for item_count in group_counts:\n entro += item_entropy(item_count, total)\n return entro","def entropy_root(self):\n\t\tif self.size() == 0:\n\t\t\treturn 0\n\n\t\tcounter = collections.Counter(self.y)\n\t\treturn entropy([x[1] for x in counter.items()], self.size())","def calculate_entropy(dataset) :\n\n num_entries = len(dataset)\n label_counts = {}\n for vector in dataset :\n # the label is at the last index of the data set\n current_label = vector[-1]\n if current_label not in label_counts :\n label_counts[current_label] = 0\n label_counts[current_label] += 1\n # Calculate the entropy\n entropy = 0.0\n for label in label_counts :\n # Calculate probability of each label within the dataset\n prob_of_label = label_counts[label]/num_entries\n # Since the entropy is the negative of the sum of all probability,\n # simply subtract it\n entropy -= prob_of_label * log(prob_of_label, 2)\n return entropy","def entropy(x):\n x_max, x_min = x.max(), x.min()\n assert (x_min >= 0) and (x_max <= 1)\n if x_min == x_max == 0:\n return np.float32(0.)\n # Take only non-zero values as log(0) = 0 :\n nnz_x = x[np.nonzero(x)]\n entr = -np.sum(nnz_x * np.log2(nnz_x))\n\n return entr","def entropy(self, **kwargs) -> TensorType:","def entropy(self, **kwargs) -> TensorType:","def entropy(self, dataset, target_attr):\n freq = {} #A dictionary to counts how many samples for each target classification \n data_entropy = 0.0\n samplenumbers = len(dataset) #Total number of samplers in data set\n \n #Calculate the frequency of each of the values in the target attribute\n for record in dataset:\n if (record[target_attr] in freq):\n freq[record[target_attr]] += 1.0\n else:\n freq[record[target_attr]] = 1.0\n \n # Calculate the entropy of the data for the target attribute\n for freq in list(freq.values()):\n data_entropy += (-freq/samplenumbers) * math.log(freq/samplenumbers, 2) \n \n return data_entropy","def entropy_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\n logits = args.attribution_model.output2logits(args.forward_output)\n out = torch.distributions.Categorical(logits=logits).entropy()\n if out.ndim > 1:\n out = out.squeeze(-1)\n return out","def compute_entropy(m, nan_as_zero=True):\n # normalize rows (the sum of each row must be 1)\n p = m / m.sum(axis=1, keepdims=True)\n # compute per row entropy (in base 2)\n e = entr(p).sum(axis=1) / np.log(2)\n if nan_as_zero:\n e = np.nan_to_num(e)\n return e","def _conditional_entropy_compute(confmat: Tensor) ->Tensor:\n confmat = _drop_empty_rows_and_cols(confmat)\n total_occurrences = confmat.sum()\n p_xy_m = confmat / total_occurrences\n p_y = confmat.sum(1) / total_occurrences\n p_y_m = p_y.unsqueeze(1).repeat(1, p_xy_m.shape[1])\n return torch.nansum(p_xy_m * torch.log(p_y_m / p_xy_m))","def calculate_entropy(eval_token_count, training_model):\n sum_of_counts = sum(eval_token_count.values())\n cross_entropy = 0\n mis = []\n for ngram in eval_token_count:\n if training_model.score(ngram[-1], list(ngram[0:3])) == 0 or sum_of_counts == 0:\n mi = np.mean(mis) if len(mis) > 0 else np.log2(0.287)\n else:\n mi = training_model.logscore(ngram[-1], list(ngram[0:3]))\n pi = eval_token_count[ngram] / sum_of_counts\n mis.append(mi)\n cross_entropy -= pi * mi\n return cross_entropy","def predict_mean(self, X):\n mu = np.exp(self.intercept_)\n return mu","def entropy(p):\n assert (p >= 0).all()\n assert abs(np.sum(p)-1) < 1e-6\n return -np.sum(p*np.log(p+1e-12))","def entropy(counts):\n assert (counts >= 0).all()\n probs = counts / counts.sum()\n probs = probs[probs > 0] # Avoid log(0)\n return - np.sum(probs * np.log2(probs))","def cal_globalEntropy(self):\n group_score = []\n pop_total = np.sum(self.pop_sum)\n prop = np.asarray(np.sum(self.pop, axis=0))[0]\n\n # loop at sum of each population groups\n for group in prop:\n group_idx = group / pop_total * np.log(1 / (group / pop_total))\n group_score.append(group_idx)\n entropy = np.sum(group_score)\n\n return entropy","def _entropy(self, y):\n # Get size\n n = y.shape[0]\n summation = 0\n\n # Summatory\n for c_i in np.unique(y):\n prob = sum(y == c_i) / float(n)\n summation += prob * np.log2(prob)\n\n return -summation","def entropy(temp,pres):\n g_t = liq_g(1,0,temp,pres)\n s = -g_t\n return s","def entropy(probabilities):\n return -(sum([p * log(p, 2) if p > 0 else 0 for p in probabilities]))","def entropy(self, logits):\n probs = torch.exp(logits)\n entropy = - torch.sum(probs * logits, dim=-1)\n return entropy","def predict_aleatoric(self, x):\n with torch.no_grad():\n e = self.predict_evidence(x)\n\n a = e + self.prior\n proba_in = (a / a.sum(-1, keepdim=True)).clamp_(1e-8, 1-1e-8)\n entropy = - torch.sum((proba_in * proba_in.log()), dim=-1)\n normalized_entropy = entropy / math.log(self.n_classes)\n return normalized_entropy","def calc_entropy(data_set):\n size = len(data_set)\n label_counts = {}\n for feat_vector in data_set:\n label = feat_vector[-1]\n label_counts.setdefault(label, 0)\n label_counts[label] += 1\n\n entropy = 0.0\n for key, count in label_counts.iteritems():\n prob = float(count) / size\n entropy -= prob * log(prob, 2)\n\n return entropy","def entropy(self, priors=None):\n def entropy_f(x):\n x[x != 0] *= np.log(x[x != 0])\n return -x.sum(axis=0)\n return self.utility(entropy_f, priors)","def _entropy(self, feature, node):\n entropy = 0\n categories = np.unique(feature)\n num_point = len(feature)\n for category in categories:\n # for each category in that feature\n num_category = len(feature[feature == category])\n for c in self.num_class:\n # count the number of each class\n num_category_class = len(feature[np.logical_and(feature == category, node.y == c)])\n if num_category_class == 0:\n continue\n # compute entropy/information gain or classification error\n entropy += num_category / num_point * (\n -num_category_class / num_category * log2(num_category_class / num_category))\n return entropy","def conditional_entropy_hyper(self) -> float:\n pass","def entropy( freq ):\n N = 0.0\n entropy = 0.0\n for x, v in freq.items( ):\n N += v\n entropy -= v * math.log( v, 2 )\n return (N * math.log( N, 2 ) + entropy) / N","def entropy ( target_array ):\n return -1 * sum (\n [\n pipe ( np.sum ( target_array == value ) / len ( target_array ), lambda ratio: ratio * np.log ( ratio ) )\n for value in set ( target_array )\n ]\n ) # End entropy()","def mixture_entropy_monte_carlo(self):\n if self.Ns > 63:\n raise ValueError('Mixture entropy estimation only works for fewer '\n 'than 64 substrates.')\n \n # sample mixtures\n base = 2 ** np.arange(0, self.Ns)\n observations = collections.Counter()\n for c in self._sample_mixtures():\n observations[np.dot(c, base)] += 1\n \n # estimate entropy from the histogram\n counts = np.fromiter(observations.values(), np.double,\n len(observations))\n \n # Naive implementation of measuring the entropy is\n # ps = counts / self._sample_steps\n # H = -np.sum(ps * np.log2(ps))\n # This can be transformed to a more stable implementation:\n log_steps = np.log2(self._sample_steps)\n return -np.sum(counts*(np.log2(counts) - log_steps))/self._sample_steps","def _Apply(self, c, p):\n entropy = ((1.0 - c) * tf.log(1.0 - p) + c * tf.log(p)) / (-math.log(2))\n entropy = tf.reduce_mean(entropy)\n return entropy","def cross_entropy(y_observed, p):\n\n pass","def entropy(p):\n ent = tf.where(p > np.finfo(np.float32).eps, -p * tf.log(p), tf.zeros_like(p))\n ent = tf.reduce_sum(ent, axis=1)\n return ent","def point_entropy(self, unlabeled_sequence):\n unlabeled_sequence = self._transform(unlabeled_sequence)\n\n T = len(unlabeled_sequence)\n N = len(self._states)\n\n alpha = self._forward_probability(unlabeled_sequence)\n beta = self._backward_probability(unlabeled_sequence)\n normalisation = logsumexp2(alpha[T - 1])\n\n entropies = np.zeros(T, np.float64)\n probs = np.zeros(N, np.float64)\n for t in range(T):\n for s in range(N):\n probs[s] = alpha[t, s] + beta[t, s] - normalisation\n\n for s in range(N):\n entropies[t] -= 2 ** (probs[s]) * probs[s]\n\n return entropies","def get_entropy(self, state):\n entropy = self.entropy_model.predict(state)\n return entropy[0]","def nats(self) -> float:\n return self.entropy()","def entropy(y):\n return -1 * sum(\n [\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\n for value in set(y)\n ]\n )","def get_entropy(self, rows):\n label_count = defaultdict(int)\n total_count = 0\n for row in rows:\n label = row[self.target_attribute]\n label_count[label] += 1\n total_count += 1\n return sum([-(float(label_count[label]) /\n total_count) * np.log2(float(label_count[label]) / total_count)\n for label in label_count.keys()])","def entropy(data):\n strings, lens = Counter(data), np.float(len(data))\n return -sum(count / lens * np.log2(count / lens) for count in strings.values())","def entropy(class_probabilities):\n return sum(-p * math.log(p,2)\n for p in class_probabilities\n if p)","def entropy(s):\n p, lns = Counter(s), float(len(s))\n return -sum( count/lns * math.log(count/lns, 2) for count in p.values())","def entropy_loss(policy_logits):\n\n softmax = nn.Softmax(dim=-1)\n logsoftmax = nn.LogSoftmax(dim=-1)\n\n policy = softmax(policy_logits.action_type)\n log_policy = logsoftmax(policy_logits.action_type)\n\n return torch.mean(torch.sum(-policy * log_policy, axis=-1))","def entropy(l):\n\n probabilities = np.bincount(l) / len(l)\n with np.errstate(divide='ignore'): # ignore log(0) errors, we'll handle\n log_probabilities = np.log2(probabilities)\n log_probabilities[~np.isfinite(log_probabilities)] = 0\n return -np.sum(probabilities * log_probabilities)","def entropy(p: torch.Tensor):\n nz = (p > 0).to(p.device)\n\n eps = torch.finfo(p.dtype).eps\n p_stable = p.clone().clamp(min=eps, max=1 - eps)\n\n out = torch.where(\n nz,\n p_stable * torch.log(p_stable),\n torch.tensor(0.0, device=p.device, dtype=torch.float),\n )\n\n return -(out).sum(-1)","def div(self):\n freqList = [i / sum(self.has.values()) for i in self.has.values()]\n entropies = [i * math.log(i, 2) for i in freqList]\n entropy = -sum(entropies)\n return entropy","def entropy(distribution, unit=2):\n frequencies = distribution.frequencies(normalised=True)\n # check to see if it is a deterministic case (all but one are zero)\n zeros_size = frequencies[frequencies == 0].size\n if zeros_size + 1 == frequencies.size:\n return 0\n else:\n return np.sum(-frequencies * np.log2(frequencies) / np.log2(unit))","def entropy(class_probabilities):\n return sum(-p * math.log(p, 2)\n for p in class_probabilities\n if p) #ignore 0's","def get_entropy(self, x_dict={}, sum_features=True, feature_dims=None):\n raise NotImplementedError()","def entropy_py(p):\n return 2 ** np.sum(-p*np.log2(p+1e-10))","def entropy_(P):\n res = 0.0\n\n mask = P != 0.0 # avoid 0 in log\n f = lambda x: x*np.log2(x)\n # map-reduce strategy (likely to be more optimized than loops)\n temp = list(map(f, P[mask]))\n res = -np.sum(temp, dtype=float)\n return res","def entropy(image, selem, out=None, mask=None, shift_x=False, shift_y=False):\n\n return _apply(_crank8.entropy, _crank16.entropy, image, selem, out=out,\n mask=mask, shift_x=shift_x, shift_y=shift_y)","def calculate_entropic_cost(self, log_prediction):\n\n log_prediction = tf.squeeze(log_prediction)\n mean, var_samples = tf.nn.moments(tf.exp(log_prediction), axes=0)\n clip_min_variance = 1e-5 # Prevents 1 / 0 errors\n var_samples = math_ops.maximum(var_samples, clip_min_variance)\n\n penalty = tf.reciprocal(var_samples) # Small variance across samples should be discouraged\n\n return tf.reduce_sum(penalty)","def mean_field_entropy(model, args, whitelist=None):\n trace = poutine.trace(model).get_trace(*args)\n entropy = 0.0\n for name, site in trace.nodes.items():\n if site[\"type\"] == \"sample\":\n if not poutine.util.site_is_subsample(site):\n if whitelist is None or name in whitelist:\n entropy += site[\"fn\"].entropy()\n return entropy","def entropyDistributed(distribution):\n return -sum(map(lambda p : p * log(p, 2), distribution))","def entropy(target_col):\n elements,counts = np.unique(target_col,return_counts = True)\n entropy = np.sum([(-counts[i]/np.sum(counts))*np.log2(counts[i]/np.sum(counts)) for i in range(len(elements))])\n return entropy","def getEntropy(self, pVal, nVal):\n totVal = pVal + nVal\n if pVal == 0 or nVal == 0:\n return 0\n\n pProb = pVal/totVal\n nProb = 1 - pProb\n entropy = - (pProb * math.log(pProb, 2) + nProb * math.log(nProb, 2))\n return entropy","def __entropy(data: np.array, bins: int) -> float:\n discretizer = KBinsDiscretizer(n_bins = bins, encode = \"onehot-dense\", strategy = ExamDropExtractor.BIN_STRATEGY)\n data = discretizer.fit_transform(data)\n new_entropy = np.sum(data, axis = 0)\n return sc.stats.entropy(new_entropy / np.sum(new_entropy))","def calculate_entropy(reduced_density_matrix_evals):\n vec_xlogx = vectorize(calculate_xlogx)\n result = -sum(vec_xlogx(reduced_density_matrix_evals,\n\t float_info.epsilon))\n return result","def _entropy(P):\n\n #TODO remove the \"+ 1e-20\" inside the log2 computation\n # it's just a hack to avoid to compute log2(0)\n ent = -1.0 * np.sum(P * np.log2(P+1e-20), axis=0)\n return ent"],"string":"[\n \"def entropy(self):\\n return -np.sum(self.log_likelihoods * np.exp(self.log_likelihoods))\",\n \"def entropy(y):\\n EPS = 0.0005\\n\\n # YOUR CODE HERE\\n if len(y) == 0:\\n return 0.\\n \\n pk = np.mean(y, axis=0)\\n \\n return - np.sum(pk * np.log(pk + EPS))\",\n \"def entropy(self):\\n Z = self.sum()\\n assert (Z > 0), 'Non-normalizable factor (perhaps log factor?)' # also check for positivity?\\n H = 0.0\\n for x in np.nditer(self.t, op_flags=['readonly']):\\n p = x/Z\\n H += 0.0 if p==0 else -p*np.log(p)\\n return H\",\n \"def entropy(self):\\n return self._normal.entropy()\",\n \"def entropy(self):\\n n = len(self.y)\\n sum_ = 0\\n for i in np.unique(self.y):\\n v = len(self.y[self.y == i])\\n sum_ += -((v/n) * log2(v/n))\\n return sum_\",\n \"def entropy(self):\\r\\n return 1/2 * (self.dim * (_LOG_2PI + 1) + self._log_det_cov)\",\n \"def entropy(data):\\n e = 0\\n\\n counter = collections.Counter(data)\\n l = len(data)\\n for count in counter.values():\\n p_x = count / l\\n e += - p_x * math.log2(p_x)\\n\\n return e\",\n \"def entropy(Y):\\n\\n temp = np.unique(Y, return_counts=True)\\n uniq_Y = list(temp[0])\\n Y_count = list(temp[1])\\n \\n total = sum(Y_count)\\n\\n ent = 0\\n for elem in uniq_Y:\\n prob = Y_count[uniq_Y.index(elem)] / total\\n # print(\\\"prob:\\\", prob)\\n ent -= (prob * (math.log2(prob)))\\n # print(\\\"ent:\\\",ent)\\n\\n return ent\",\n \"def entropy(img):\\n # by calculating\\n histogram = img.histogram()\\n histogram_size = sum(histogram)\\n histogram = [float(h) / histogram_size for h in histogram]\\n\\n return -sum([p * math.log(p, 2) for p in histogram if p != 0])\",\n \"def entropy(self):\\n raise NotImplementedError\",\n \"def entropy(out, dim=1, reduce='mean'):\\n log_prob = F.log_softmax(out, dim=dim)\\n h = -torch.sum(log_prob.exp() * log_prob, dim=dim)\\n if reduce == 'none':\\n return h\\n if reduce == 'mean':\\n return h.mean()\\n if reduce == 'sum':\\n return h.sum()\",\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 _entropy(data):\\n hist = np.array(PIL.Image.fromarray(data).histogram())\\n hist = hist / hist.sum()\\n hist = hist[hist != 0]\\n return -np.sum(hist * np.log2(hist))\",\n \"def computeEntropy(self, img):\\n hist, bins = np.histogram(img.ravel(), bins=256, density=True)\\n return scipy.stats.entropy(hist)\",\n \"def entropy(self, mean=None, cov=1):\\r\\n dim, mean, cov = _process_parameters(None, mean, cov)\\r\\n return 1/2 * np.log(np.linalg.det(2 * np.pi * np.e * cov))\",\n \"def entropy(self, args):\\n mean, stddev = args\\n dist = tfp.distributions.Normal(loc=mean, scale=stddev)\\n entropy = dist.entropy()\\n return entropy\",\n \"def mean_ent(cluster_assignments):\\n nrow, ncol, nrun = cluster_assignments.shape\\n csum = cluster_assignments.sum(axis=2)\\n m = numpy.mean([scipy.stats.entropy(row) for row in csum])\\n return m\",\n \"def entropy(x):\\n nz = np.nonzero(x)[0]\\n return -np.sum(x[nz]*np.log2(x[nz]))\",\n \"def entropy(self, X):\\n if isinstance(X, np.ndarray):\\n X = pd.DataFrame(X, index=[str(i) for i in range(len(X))])\\n K = self._posterior_covariance(X)\\n L = np.linalg.cholesky(K)\\n D = len(X)\\n return np.sum(np.log(np.diag(L))) + 0.5 * D * np.log(2*np.pi*np.exp(1))\",\n \"def conditional_entropy(self) -> float:\\n pass\",\n \"def entropy(self):\\n ent = 0.0\\n for f in self.byte_freq:\\n if f > 0:\\n freq = float(f) / self.byte_total\\n ent = ent + freq * math.log(freq, 2)\\n return -ent\",\n \"def entropy(Y):\\n unique, count = np.unique(Y, return_counts=True, axis=0)\\n prob = count/len(Y)\\n en = np.sum((-1)*prob*np.log2(prob))\\n return en\",\n \"def __compute_entropy(row:pd.Series) -> float:\\n probability = row.value_counts(normalize=True).values\\n entropy = EntropicSolver.__compute_entropy_probability(probability)\\n return entropy\",\n \"def __compute_entropy_probability(probability:np.ndarray) -> float:\\n entropy = -np.sum(probability * np.log2(probability))\\n return entropy\",\n \"def entropy(self, y):\\n n = y.size\\n if n <= 1:\\n return 0\\n\\n labels, counts = unique(y, return_counts=True)\\n\\n if counts.size <= 1:\\n return 0\\n\\n probs = counts / n\\n entropy = -sum([p * log(p, 2) for p in probs])\\n return entropy\",\n \"def entropy(y):\\n total = y.size\\n value_counts = np.bincount(y).astype(\\\"float\\\")\\n proportions = value_counts / y.size\\n\\n return sum(-i * np.log(i) for i in proportions if i)\",\n \"def get_entropy(distribution, samples):\\n entropy = -tf.reduce_sum(distribution.log_prob(samples), axis=1)\\n return entropy\",\n \"def entropy(y):\\n p = _proba(y)\\n return (-p * np.log2(p)).sum()\",\n \"def ensemble_entropy(self):\\n return transition_matrices.entropy_measure(self.ensemble_transition_matrix)\",\n \"def entropy(d, total, word_count):\\n\\t# Entropie je - Sum_morf p(morf) * log_2 p(morf)\\n\\t# p(morf) = c(morf) / c(all)\\n\\te = 0\\n\\tfor count in d.values():\\n\\t\\tp = count/total\\n\\t\\ttype_e = - p * log2(p)\\n\\t\\te += type_e * count\\n\\treturn e / word_count\",\n \"def entropy(P):\\n P_nan = P.copy()\\n P_nan[P_nan == 0] = np.nan\\n return np.nansum(np.multiply(P_nan, np.log2(1 / P_nan)))\",\n \"def compute_entropy(sampled, dataset, model, train_args):\\n all_entropy = None\\n data = Subset(dataset, sampled)\\n sampler = SequentialSampler(data)\\n dataloader = DataLoader(data, sampler=sampler, batch_size=train_args.per_gpu_eval_batch_size)\\n for batch in tqdm(dataloader, desc=\\\"Computing entropy\\\"):\\n batch = tuple(t.to(train_args.device) for t in batch)\\n with torch.no_grad():\\n inputs = {\\\"input_ids\\\": batch[0], \\\"attention_mask\\\": batch[1]}\\n if train_args.model_type != \\\"distilbert\\\":\\n inputs[\\\"token_type_ids\\\"] = (\\n batch[2] if train_args.model_type in [\\\"bert\\\", \\\"xlnet\\\", \\\"albert\\\"] else None\\n ) # XLM, DistilBERT, RoBERTa, and XLM-RoBERTa don't use segment_ids\\n outputs = model(**inputs)\\n logits = outputs[0]\\n categorical = Categorical(logits = logits)\\n entropy = categorical.entropy()\\n if all_entropy is None:\\n all_entropy = entropy.detach().cpu().numpy()\\n else:\\n all_entropy = np.append(all_entropy, entropy.detach().cpu().numpy(), axis=0)\\n avg_entropy = all_entropy.mean()\\n return avg_entropy\",\n \"def entropy(data):\\n n, m = np.shape(data)\\n data = np.tanh(data)\\n data = data / np.sum(data, axis=0)\\n a = data * 1.0\\n a[np.where(data == 0)] = 0.000001\\n\\n e = (-1.0 / np.log(n)) * np.sum(data * np.log(a), axis=0)\\n w = (1 - e) / np.sum(1 - e)\\n return w\",\n \"def entropy(self, params):\\n log_std = params[:, :, 1]\\n return (log_std + 0.5 * (self.LOG2PI + 1)).sum(dim=-1)\",\n \"def entropy(self,classData):\\n\\n\\t\\t###### your implementation below ######\\n\\t\\ttotalEntropy = 0\\n\\t\\ttempSet = {}\\n\\t\\tfor i in range(len(classData)):\\n\\t\\t\\ttempSet[classData[i]] = (classData.count(classData[i]))\\n\\t\\ttotal = sum(tempSet.values())\\n\\t\\tfor x in tempSet:\\n\\t\\t\\ttotalEntropy += -(tempSet[x]/total * math.log(tempSet[x]/total, 2))\\n\\t\\treturn totalEntropy\",\n \"def __entropy(self, data_set, target_feature):\\n frequencies = self.__calculate_frequency(data_set, target_feature)\\n feature_entropy = 0.0\\n number_of_values = len(data_set)\\n\\n # Add entropy for each value in frequencies.\\n for frequency in frequencies:\\n probability = frequencies[frequency] / number_of_values\\n feature_entropy += (probability * math.log(probability, 2))\\n\\n return feature_entropy * -1\",\n \"def entropy(dist):\\n #dist = array([max(d,1e-100) for d in dist])\\n dist = dist + 1e-20\\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)\",\n \"def entropy(y):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n value, count = np.unique(y,return_counts = True)\\r\\n Hy = 0.0\\r\\n prob = count.astype(float)/len(y)\\r\\n for p in prob:\\r\\n Hy += -(p)*(np.log2(p))\\r\\n return Hy\\r\\n raise Exception('Function not yet implemented!')\",\n \"def entropy(self):\\n return self._entropy_func\",\n \"def calc_entropy(data_set): #calculates total entropy of the dataset\\r\\n republicans = 0\\r\\n democrats = 0\\r\\n total = 0\\r\\n for data_point in data_set:\\r\\n party = data_point.dat_party\\r\\n if party == \\\"R\\\":\\r\\n republicans+=1\\r\\n elif party == \\\"D\\\":\\r\\n democrats+=1\\r\\n total+=1\\r\\n\\r\\n if total == 0: return 0\\r\\n prob_dem = democrats/total\\r\\n prob_rep = republicans/total\\r\\n if prob_dem == 0: return -(prob_rep * math.log(prob_rep, 2))\\r\\n if prob_rep == 0: return -(prob_dem * math.log(prob_dem, 2))\\r\\n\\r\\n entropy = (-prob_dem * math.log(prob_dem, 2)) -(prob_rep * math.log(prob_rep, 2))\\r\\n return entropy\",\n \"def entropy(self, policy_params):\\n return self.head.entropy(policy_params)\",\n \"def entropy(data):\\n\\n freqs = {}\\n suma = len(data)\\n\\n for i in range(0, len(data)):\\n freqs[data[i]] = 1.0 + freqs.get(data[i], 0)\\n\\n res = 0.0\\n for i in freqs:\\n res += (freqs[i] / suma) * log((freqs[i] / suma), 2)\\n return -res\",\n \"def image_entropy(img):\\r\\n hist = img.histogram()\\r\\n hist_size = sum(hist)\\r\\n hist = [float(h) / hist_size for h in hist]\\r\\n\\r\\n return -sum([p * math.log(p, 2) for p in hist if p != 0])\",\n \"def _entropy(self):\\n return self.rv.entropy(*self._pymc_dists_to_value(self.args), **self.kwds)\",\n \"def entropy(group_counts):\\n total = sum(group_counts)\\n entro = 0\\n for item_count in group_counts:\\n entro += item_entropy(item_count, total)\\n return entro\",\n \"def entropy_root(self):\\n\\t\\tif self.size() == 0:\\n\\t\\t\\treturn 0\\n\\n\\t\\tcounter = collections.Counter(self.y)\\n\\t\\treturn entropy([x[1] for x in counter.items()], self.size())\",\n \"def calculate_entropy(dataset) :\\n\\n num_entries = len(dataset)\\n label_counts = {}\\n for vector in dataset :\\n # the label is at the last index of the data set\\n current_label = vector[-1]\\n if current_label not in label_counts :\\n label_counts[current_label] = 0\\n label_counts[current_label] += 1\\n # Calculate the entropy\\n entropy = 0.0\\n for label in label_counts :\\n # Calculate probability of each label within the dataset\\n prob_of_label = label_counts[label]/num_entries\\n # Since the entropy is the negative of the sum of all probability,\\n # simply subtract it\\n entropy -= prob_of_label * log(prob_of_label, 2)\\n return entropy\",\n \"def entropy(x):\\n x_max, x_min = x.max(), x.min()\\n assert (x_min >= 0) and (x_max <= 1)\\n if x_min == x_max == 0:\\n return np.float32(0.)\\n # Take only non-zero values as log(0) = 0 :\\n nnz_x = x[np.nonzero(x)]\\n entr = -np.sum(nnz_x * np.log2(nnz_x))\\n\\n return entr\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def entropy(self, dataset, target_attr):\\n freq = {} #A dictionary to counts how many samples for each target classification \\n data_entropy = 0.0\\n samplenumbers = len(dataset) #Total number of samplers in data set\\n \\n #Calculate the frequency of each of the values in the target attribute\\n for record in dataset:\\n if (record[target_attr] in freq):\\n freq[record[target_attr]] += 1.0\\n else:\\n freq[record[target_attr]] = 1.0\\n \\n # Calculate the entropy of the data for the target attribute\\n for freq in list(freq.values()):\\n data_entropy += (-freq/samplenumbers) * math.log(freq/samplenumbers, 2) \\n \\n return data_entropy\",\n \"def entropy_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\\n logits = args.attribution_model.output2logits(args.forward_output)\\n out = torch.distributions.Categorical(logits=logits).entropy()\\n if out.ndim > 1:\\n out = out.squeeze(-1)\\n return out\",\n \"def compute_entropy(m, nan_as_zero=True):\\n # normalize rows (the sum of each row must be 1)\\n p = m / m.sum(axis=1, keepdims=True)\\n # compute per row entropy (in base 2)\\n e = entr(p).sum(axis=1) / np.log(2)\\n if nan_as_zero:\\n e = np.nan_to_num(e)\\n return e\",\n \"def _conditional_entropy_compute(confmat: Tensor) ->Tensor:\\n confmat = _drop_empty_rows_and_cols(confmat)\\n total_occurrences = confmat.sum()\\n p_xy_m = confmat / total_occurrences\\n p_y = confmat.sum(1) / total_occurrences\\n p_y_m = p_y.unsqueeze(1).repeat(1, p_xy_m.shape[1])\\n return torch.nansum(p_xy_m * torch.log(p_y_m / p_xy_m))\",\n \"def calculate_entropy(eval_token_count, training_model):\\n sum_of_counts = sum(eval_token_count.values())\\n cross_entropy = 0\\n mis = []\\n for ngram in eval_token_count:\\n if training_model.score(ngram[-1], list(ngram[0:3])) == 0 or sum_of_counts == 0:\\n mi = np.mean(mis) if len(mis) > 0 else np.log2(0.287)\\n else:\\n mi = training_model.logscore(ngram[-1], list(ngram[0:3]))\\n pi = eval_token_count[ngram] / sum_of_counts\\n mis.append(mi)\\n cross_entropy -= pi * mi\\n return cross_entropy\",\n \"def predict_mean(self, X):\\n mu = np.exp(self.intercept_)\\n return mu\",\n \"def entropy(p):\\n assert (p >= 0).all()\\n assert abs(np.sum(p)-1) < 1e-6\\n return -np.sum(p*np.log(p+1e-12))\",\n \"def entropy(counts):\\n assert (counts >= 0).all()\\n probs = counts / counts.sum()\\n probs = probs[probs > 0] # Avoid log(0)\\n return - np.sum(probs * np.log2(probs))\",\n \"def cal_globalEntropy(self):\\n group_score = []\\n pop_total = np.sum(self.pop_sum)\\n prop = np.asarray(np.sum(self.pop, axis=0))[0]\\n\\n # loop at sum of each population groups\\n for group in prop:\\n group_idx = group / pop_total * np.log(1 / (group / pop_total))\\n group_score.append(group_idx)\\n entropy = np.sum(group_score)\\n\\n return entropy\",\n \"def _entropy(self, y):\\n # Get size\\n n = y.shape[0]\\n summation = 0\\n\\n # Summatory\\n for c_i in np.unique(y):\\n prob = sum(y == c_i) / float(n)\\n summation += prob * np.log2(prob)\\n\\n return -summation\",\n \"def entropy(temp,pres):\\n g_t = liq_g(1,0,temp,pres)\\n s = -g_t\\n return s\",\n \"def entropy(probabilities):\\n return -(sum([p * log(p, 2) if p > 0 else 0 for p in probabilities]))\",\n \"def entropy(self, logits):\\n probs = torch.exp(logits)\\n entropy = - torch.sum(probs * logits, dim=-1)\\n return entropy\",\n \"def predict_aleatoric(self, x):\\n with torch.no_grad():\\n e = self.predict_evidence(x)\\n\\n a = e + self.prior\\n proba_in = (a / a.sum(-1, keepdim=True)).clamp_(1e-8, 1-1e-8)\\n entropy = - torch.sum((proba_in * proba_in.log()), dim=-1)\\n normalized_entropy = entropy / math.log(self.n_classes)\\n return normalized_entropy\",\n \"def calc_entropy(data_set):\\n size = len(data_set)\\n label_counts = {}\\n for feat_vector in data_set:\\n label = feat_vector[-1]\\n label_counts.setdefault(label, 0)\\n label_counts[label] += 1\\n\\n entropy = 0.0\\n for key, count in label_counts.iteritems():\\n prob = float(count) / size\\n entropy -= prob * log(prob, 2)\\n\\n return entropy\",\n \"def entropy(self, priors=None):\\n def entropy_f(x):\\n x[x != 0] *= np.log(x[x != 0])\\n return -x.sum(axis=0)\\n return self.utility(entropy_f, priors)\",\n \"def _entropy(self, feature, node):\\n entropy = 0\\n categories = np.unique(feature)\\n num_point = len(feature)\\n for category in categories:\\n # for each category in that feature\\n num_category = len(feature[feature == category])\\n for c in self.num_class:\\n # count the number of each class\\n num_category_class = len(feature[np.logical_and(feature == category, node.y == c)])\\n if num_category_class == 0:\\n continue\\n # compute entropy/information gain or classification error\\n entropy += num_category / num_point * (\\n -num_category_class / num_category * log2(num_category_class / num_category))\\n return entropy\",\n \"def conditional_entropy_hyper(self) -> float:\\n pass\",\n \"def entropy( freq ):\\n N = 0.0\\n entropy = 0.0\\n for x, v in freq.items( ):\\n N += v\\n entropy -= v * math.log( v, 2 )\\n return (N * math.log( N, 2 ) + entropy) / N\",\n \"def entropy ( target_array ):\\n return -1 * sum (\\n [\\n pipe ( np.sum ( target_array == value ) / len ( target_array ), lambda ratio: ratio * np.log ( ratio ) )\\n for value in set ( target_array )\\n ]\\n ) # End entropy()\",\n \"def mixture_entropy_monte_carlo(self):\\n if self.Ns > 63:\\n raise ValueError('Mixture entropy estimation only works for fewer '\\n 'than 64 substrates.')\\n \\n # sample mixtures\\n base = 2 ** np.arange(0, self.Ns)\\n observations = collections.Counter()\\n for c in self._sample_mixtures():\\n observations[np.dot(c, base)] += 1\\n \\n # estimate entropy from the histogram\\n counts = np.fromiter(observations.values(), np.double,\\n len(observations))\\n \\n # Naive implementation of measuring the entropy is\\n # ps = counts / self._sample_steps\\n # H = -np.sum(ps * np.log2(ps))\\n # This can be transformed to a more stable implementation:\\n log_steps = np.log2(self._sample_steps)\\n return -np.sum(counts*(np.log2(counts) - log_steps))/self._sample_steps\",\n \"def _Apply(self, c, p):\\n entropy = ((1.0 - c) * tf.log(1.0 - p) + c * tf.log(p)) / (-math.log(2))\\n entropy = tf.reduce_mean(entropy)\\n return entropy\",\n \"def cross_entropy(y_observed, p):\\n\\n pass\",\n \"def entropy(p):\\n ent = tf.where(p > np.finfo(np.float32).eps, -p * tf.log(p), tf.zeros_like(p))\\n ent = tf.reduce_sum(ent, axis=1)\\n return ent\",\n \"def point_entropy(self, unlabeled_sequence):\\n unlabeled_sequence = self._transform(unlabeled_sequence)\\n\\n T = len(unlabeled_sequence)\\n N = len(self._states)\\n\\n alpha = self._forward_probability(unlabeled_sequence)\\n beta = self._backward_probability(unlabeled_sequence)\\n normalisation = logsumexp2(alpha[T - 1])\\n\\n entropies = np.zeros(T, np.float64)\\n probs = np.zeros(N, np.float64)\\n for t in range(T):\\n for s in range(N):\\n probs[s] = alpha[t, s] + beta[t, s] - normalisation\\n\\n for s in range(N):\\n entropies[t] -= 2 ** (probs[s]) * probs[s]\\n\\n return entropies\",\n \"def get_entropy(self, state):\\n entropy = self.entropy_model.predict(state)\\n return entropy[0]\",\n \"def nats(self) -> float:\\n return self.entropy()\",\n \"def entropy(y):\\n return -1 * sum(\\n [\\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\\n for value in set(y)\\n ]\\n )\",\n \"def get_entropy(self, rows):\\n label_count = defaultdict(int)\\n total_count = 0\\n for row in rows:\\n label = row[self.target_attribute]\\n label_count[label] += 1\\n total_count += 1\\n return sum([-(float(label_count[label]) /\\n total_count) * np.log2(float(label_count[label]) / total_count)\\n for label in label_count.keys()])\",\n \"def entropy(data):\\n strings, lens = Counter(data), np.float(len(data))\\n return -sum(count / lens * np.log2(count / lens) for count in strings.values())\",\n \"def entropy(class_probabilities):\\n return sum(-p * math.log(p,2)\\n for p in class_probabilities\\n if p)\",\n \"def entropy(s):\\n p, lns = Counter(s), float(len(s))\\n return -sum( count/lns * math.log(count/lns, 2) for count in p.values())\",\n \"def entropy_loss(policy_logits):\\n\\n softmax = nn.Softmax(dim=-1)\\n logsoftmax = nn.LogSoftmax(dim=-1)\\n\\n policy = softmax(policy_logits.action_type)\\n log_policy = logsoftmax(policy_logits.action_type)\\n\\n return torch.mean(torch.sum(-policy * log_policy, axis=-1))\",\n \"def entropy(l):\\n\\n probabilities = np.bincount(l) / len(l)\\n with np.errstate(divide='ignore'): # ignore log(0) errors, we'll handle\\n log_probabilities = np.log2(probabilities)\\n log_probabilities[~np.isfinite(log_probabilities)] = 0\\n return -np.sum(probabilities * log_probabilities)\",\n \"def entropy(p: torch.Tensor):\\n nz = (p > 0).to(p.device)\\n\\n eps = torch.finfo(p.dtype).eps\\n p_stable = p.clone().clamp(min=eps, max=1 - eps)\\n\\n out = torch.where(\\n nz,\\n p_stable * torch.log(p_stable),\\n torch.tensor(0.0, device=p.device, dtype=torch.float),\\n )\\n\\n return -(out).sum(-1)\",\n \"def div(self):\\n freqList = [i / sum(self.has.values()) for i in self.has.values()]\\n entropies = [i * math.log(i, 2) for i in freqList]\\n entropy = -sum(entropies)\\n return entropy\",\n \"def entropy(distribution, unit=2):\\n frequencies = distribution.frequencies(normalised=True)\\n # check to see if it is a deterministic case (all but one are zero)\\n zeros_size = frequencies[frequencies == 0].size\\n if zeros_size + 1 == frequencies.size:\\n return 0\\n else:\\n return np.sum(-frequencies * np.log2(frequencies) / np.log2(unit))\",\n \"def entropy(class_probabilities):\\n return sum(-p * math.log(p, 2)\\n for p in class_probabilities\\n if p) #ignore 0's\",\n \"def get_entropy(self, x_dict={}, sum_features=True, feature_dims=None):\\n raise NotImplementedError()\",\n \"def entropy_py(p):\\n return 2 ** np.sum(-p*np.log2(p+1e-10))\",\n \"def entropy_(P):\\n res = 0.0\\n\\n mask = P != 0.0 # avoid 0 in log\\n f = lambda x: x*np.log2(x)\\n # map-reduce strategy (likely to be more optimized than loops)\\n temp = list(map(f, P[mask]))\\n res = -np.sum(temp, dtype=float)\\n return res\",\n \"def entropy(image, selem, out=None, mask=None, shift_x=False, shift_y=False):\\n\\n return _apply(_crank8.entropy, _crank16.entropy, image, selem, out=out,\\n mask=mask, shift_x=shift_x, shift_y=shift_y)\",\n \"def calculate_entropic_cost(self, log_prediction):\\n\\n log_prediction = tf.squeeze(log_prediction)\\n mean, var_samples = tf.nn.moments(tf.exp(log_prediction), axes=0)\\n clip_min_variance = 1e-5 # Prevents 1 / 0 errors\\n var_samples = math_ops.maximum(var_samples, clip_min_variance)\\n\\n penalty = tf.reciprocal(var_samples) # Small variance across samples should be discouraged\\n\\n return tf.reduce_sum(penalty)\",\n \"def mean_field_entropy(model, args, whitelist=None):\\n trace = poutine.trace(model).get_trace(*args)\\n entropy = 0.0\\n for name, site in trace.nodes.items():\\n if site[\\\"type\\\"] == \\\"sample\\\":\\n if not poutine.util.site_is_subsample(site):\\n if whitelist is None or name in whitelist:\\n entropy += site[\\\"fn\\\"].entropy()\\n return entropy\",\n \"def entropyDistributed(distribution):\\n return -sum(map(lambda p : p * log(p, 2), distribution))\",\n \"def entropy(target_col):\\n elements,counts = np.unique(target_col,return_counts = True)\\n entropy = np.sum([(-counts[i]/np.sum(counts))*np.log2(counts[i]/np.sum(counts)) for i in range(len(elements))])\\n return entropy\",\n \"def getEntropy(self, pVal, nVal):\\n totVal = pVal + nVal\\n if pVal == 0 or nVal == 0:\\n return 0\\n\\n pProb = pVal/totVal\\n nProb = 1 - pProb\\n entropy = - (pProb * math.log(pProb, 2) + nProb * math.log(nProb, 2))\\n return entropy\",\n \"def __entropy(data: np.array, bins: int) -> float:\\n discretizer = KBinsDiscretizer(n_bins = bins, encode = \\\"onehot-dense\\\", strategy = ExamDropExtractor.BIN_STRATEGY)\\n data = discretizer.fit_transform(data)\\n new_entropy = np.sum(data, axis = 0)\\n return sc.stats.entropy(new_entropy / np.sum(new_entropy))\",\n \"def calculate_entropy(reduced_density_matrix_evals):\\n vec_xlogx = vectorize(calculate_xlogx)\\n result = -sum(vec_xlogx(reduced_density_matrix_evals,\\n\\t float_info.epsilon))\\n return result\",\n \"def _entropy(P):\\n\\n #TODO remove the \\\"+ 1e-20\\\" inside the log2 computation\\n # it's just a hack to avoid to compute log2(0)\\n ent = -1.0 * np.sum(P * np.log2(P+1e-20), axis=0)\\n return ent\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7530867","0.74424595","0.74055004","0.7329188","0.7220066","0.7200022","0.7160352","0.7152894","0.71405065","0.70775807","0.70759517","0.7073769","0.70580447","0.70529985","0.7017805","0.69966227","0.69941026","0.69562703","0.6955483","0.69474715","0.6933696","0.6922308","0.6905468","0.68916005","0.6880754","0.6867878","0.68651897","0.6863487","0.6813274","0.6801523","0.6799478","0.6797567","0.6789673","0.6785084","0.67832536","0.6781316","0.6778428","0.6777774","0.6775056","0.6767114","0.6763378","0.6751576","0.6732271","0.6712832","0.6698888","0.66971123","0.66906744","0.66710645","0.6652795","0.6652795","0.6637531","0.66332334","0.66293955","0.6621033","0.66050804","0.65991527","0.658211","0.65561813","0.65508616","0.6532838","0.652392","0.6522654","0.6521532","0.6518939","0.65092295","0.6505895","0.65038884","0.6500845","0.65008134","0.6494431","0.64921224","0.6488942","0.6481915","0.6477916","0.6474133","0.64410937","0.64334327","0.6429092","0.64276344","0.641853","0.6418488","0.64165545","0.6415933","0.641471","0.6410474","0.6393217","0.63910556","0.63900965","0.6386787","0.6385099","0.6373676","0.63723993","0.63680834","0.63418436","0.6331681","0.6331558","0.63296574","0.6324906","0.63035136","0.6302504"],"string":"[\n \"0.7530867\",\n \"0.74424595\",\n \"0.74055004\",\n \"0.7329188\",\n \"0.7220066\",\n \"0.7200022\",\n \"0.7160352\",\n \"0.7152894\",\n \"0.71405065\",\n \"0.70775807\",\n \"0.70759517\",\n \"0.7073769\",\n \"0.70580447\",\n \"0.70529985\",\n \"0.7017805\",\n \"0.69966227\",\n \"0.69941026\",\n \"0.69562703\",\n \"0.6955483\",\n \"0.69474715\",\n \"0.6933696\",\n \"0.6922308\",\n \"0.6905468\",\n \"0.68916005\",\n \"0.6880754\",\n \"0.6867878\",\n \"0.68651897\",\n \"0.6863487\",\n \"0.6813274\",\n \"0.6801523\",\n \"0.6799478\",\n \"0.6797567\",\n \"0.6789673\",\n \"0.6785084\",\n \"0.67832536\",\n \"0.6781316\",\n \"0.6778428\",\n \"0.6777774\",\n \"0.6775056\",\n \"0.6767114\",\n \"0.6763378\",\n \"0.6751576\",\n \"0.6732271\",\n \"0.6712832\",\n \"0.6698888\",\n \"0.66971123\",\n \"0.66906744\",\n \"0.66710645\",\n \"0.6652795\",\n \"0.6652795\",\n \"0.6637531\",\n \"0.66332334\",\n \"0.66293955\",\n \"0.6621033\",\n \"0.66050804\",\n \"0.65991527\",\n \"0.658211\",\n \"0.65561813\",\n \"0.65508616\",\n \"0.6532838\",\n \"0.652392\",\n \"0.6522654\",\n \"0.6521532\",\n \"0.6518939\",\n \"0.65092295\",\n \"0.6505895\",\n \"0.65038884\",\n \"0.6500845\",\n \"0.65008134\",\n \"0.6494431\",\n \"0.64921224\",\n \"0.6488942\",\n \"0.6481915\",\n \"0.6477916\",\n \"0.6474133\",\n \"0.64410937\",\n \"0.64334327\",\n \"0.6429092\",\n \"0.64276344\",\n \"0.641853\",\n \"0.6418488\",\n \"0.64165545\",\n \"0.6415933\",\n \"0.641471\",\n \"0.6410474\",\n \"0.6393217\",\n \"0.63910556\",\n \"0.63900965\",\n \"0.6386787\",\n \"0.6385099\",\n \"0.6373676\",\n \"0.63723993\",\n \"0.63680834\",\n \"0.63418436\",\n \"0.6331681\",\n \"0.6331558\",\n \"0.63296574\",\n \"0.6324906\",\n \"0.63035136\",\n \"0.6302504\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6855338"},"document_rank":{"kind":"string","value":"28"}}},{"rowIdx":91996,"cells":{"query":{"kind":"string","value":"Compute the difference between the entropy of the mean of the predictive distribution and the mean of the entropy."},"document":{"kind":"string","value":"def mutual_information(mc_preds):\n mutual_info = entropy(np.mean(mc_preds, axis=0)) - np.mean(entropy(mc_preds),\n axis=0)\n return mutual_info"},"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 entropy(self):\n return -np.sum(self.log_likelihoods * np.exp(self.log_likelihoods))","def entropy(img):\n # by calculating\n histogram = img.histogram()\n histogram_size = sum(histogram)\n histogram = [float(h) / histogram_size for h in histogram]\n\n return -sum([p * math.log(p, 2) for p in histogram if p != 0])","def entropy(self):\n n = len(self.y)\n sum_ = 0\n for i in np.unique(self.y):\n v = len(self.y[self.y == i])\n sum_ += -((v/n) * log2(v/n))\n return sum_","def entropy(self):\n return self._normal.entropy()","def entropy(y):\n EPS = 0.0005\n\n # YOUR CODE HERE\n if len(y) == 0:\n return 0.\n \n pk = np.mean(y, axis=0)\n \n return - np.sum(pk * np.log(pk + EPS))","def _entropy(data):\n hist = np.array(PIL.Image.fromarray(data).histogram())\n hist = hist / hist.sum()\n hist = hist[hist != 0]\n return -np.sum(hist * np.log2(hist))","def entropy(self):\n Z = self.sum()\n assert (Z > 0), 'Non-normalizable factor (perhaps log factor?)' # also check for positivity?\n H = 0.0\n for x in np.nditer(self.t, op_flags=['readonly']):\n p = x/Z\n H += 0.0 if p==0 else -p*np.log(p)\n return H","def entropy(self):\r\n return 1/2 * (self.dim * (_LOG_2PI + 1) + self._log_det_cov)","def entropy(Y):\n\n temp = np.unique(Y, return_counts=True)\n uniq_Y = list(temp[0])\n Y_count = list(temp[1])\n \n total = sum(Y_count)\n\n ent = 0\n for elem in uniq_Y:\n prob = Y_count[uniq_Y.index(elem)] / total\n # print(\"prob:\", prob)\n ent -= (prob * (math.log2(prob)))\n # print(\"ent:\",ent)\n\n return ent","def entropy(data):\n e = 0\n\n counter = collections.Counter(data)\n l = len(data)\n for count in counter.values():\n p_x = count / l\n e += - p_x * math.log2(p_x)\n\n return e","def computeEntropy(self, img):\n hist, bins = np.histogram(img.ravel(), bins=256, density=True)\n return scipy.stats.entropy(hist)","def entropy(self, args):\n mean, stddev = args\n dist = tfp.distributions.Normal(loc=mean, scale=stddev)\n entropy = dist.entropy()\n return entropy","def get_entropy(distribution, samples):\n entropy = -tf.reduce_sum(distribution.log_prob(samples), axis=1)\n return entropy","def entropy(self):\n ent = 0.0\n for f in self.byte_freq:\n if f > 0:\n freq = float(f) / self.byte_total\n ent = ent + freq * math.log(freq, 2)\n return -ent","def entropy(self, mean=None, cov=1):\r\n dim, mean, cov = _process_parameters(None, mean, cov)\r\n return 1/2 * np.log(np.linalg.det(2 * np.pi * np.e * cov))","def image_entropy(img):\r\n hist = img.histogram()\r\n hist_size = sum(hist)\r\n hist = [float(h) / hist_size for h in hist]\r\n\r\n return -sum([p * math.log(p, 2) for p in hist if p != 0])","def gmean_diff(self) -> float:\n sim_log = np.log1p(self.predicted)\n obs_log = np.log1p(self.true)\n return float(np.exp(gmean(sim_log) - gmean(obs_log)))","def conditional_entropy(self) -> float:\n pass","def entropy(dist):\n #dist = array([max(d,1e-100) for d in dist])\n dist = dist + 1e-20\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)","def entropy(d, total, word_count):\n\t# Entropie je - Sum_morf p(morf) * log_2 p(morf)\n\t# p(morf) = c(morf) / c(all)\n\te = 0\n\tfor count in d.values():\n\t\tp = count/total\n\t\ttype_e = - p * log2(p)\n\t\te += type_e * count\n\treturn e / word_count","def __compute_entropy_probability(probability:np.ndarray) -> float:\n entropy = -np.sum(probability * np.log2(probability))\n return entropy","def demeaned(self):\n return self.data - self.mean","def entropy(out, dim=1, reduce='mean'):\n log_prob = F.log_softmax(out, dim=dim)\n h = -torch.sum(log_prob.exp() * log_prob, dim=dim)\n if reduce == 'none':\n return h\n if reduce == 'mean':\n return h.mean()\n if reduce == 'sum':\n return h.sum()","def entropy(temp,pres):\n g_t = liq_g(1,0,temp,pres)\n s = -g_t\n return s","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 ensemble_entropy(self):\n return transition_matrices.entropy_measure(self.ensemble_transition_matrix)","def div(self):\n freqList = [i / sum(self.has.values()) for i in self.has.values()]\n entropies = [i * math.log(i, 2) for i in freqList]\n entropy = -sum(entropies)\n return entropy","def entropy(data):\n strings, lens = Counter(data), np.float(len(data))\n return -sum(count / lens * np.log2(count / lens) for count in strings.values())","def calculate_entropy(eval_token_count, training_model):\n sum_of_counts = sum(eval_token_count.values())\n cross_entropy = 0\n mis = []\n for ngram in eval_token_count:\n if training_model.score(ngram[-1], list(ngram[0:3])) == 0 or sum_of_counts == 0:\n mi = np.mean(mis) if len(mis) > 0 else np.log2(0.287)\n else:\n mi = training_model.logscore(ngram[-1], list(ngram[0:3]))\n pi = eval_token_count[ngram] / sum_of_counts\n mis.append(mi)\n cross_entropy -= pi * mi\n return cross_entropy","def calculate_entropy(dataset) :\n\n num_entries = len(dataset)\n label_counts = {}\n for vector in dataset :\n # the label is at the last index of the data set\n current_label = vector[-1]\n if current_label not in label_counts :\n label_counts[current_label] = 0\n label_counts[current_label] += 1\n # Calculate the entropy\n entropy = 0.0\n for label in label_counts :\n # Calculate probability of each label within the dataset\n prob_of_label = label_counts[label]/num_entries\n # Since the entropy is the negative of the sum of all probability,\n # simply subtract it\n entropy -= prob_of_label * log(prob_of_label, 2)\n return entropy","def mean_ent(cluster_assignments):\n nrow, ncol, nrun = cluster_assignments.shape\n csum = cluster_assignments.sum(axis=2)\n m = numpy.mean([scipy.stats.entropy(row) for row in csum])\n return m","def entropy(self):\n raise NotImplementedError","def calculate_entropy(reduced_density_matrix_evals):\n vec_xlogx = vectorize(calculate_xlogx)\n result = -sum(vec_xlogx(reduced_density_matrix_evals,\n\t float_info.epsilon))\n return result","def entropy(x):\n nz = np.nonzero(x)[0]\n return -np.sum(x[nz]*np.log2(x[nz]))","def calculate_entropy(prob):\n return -(prob * math.log(prob,2))","def entropy(y):\n total = y.size\n value_counts = np.bincount(y).astype(\"float\")\n proportions = value_counts / y.size\n\n return sum(-i * np.log(i) for i in proportions if i)","def entropy_loss(policy_logits):\n\n softmax = nn.Softmax(dim=-1)\n logsoftmax = nn.LogSoftmax(dim=-1)\n\n policy = softmax(policy_logits.action_type)\n log_policy = logsoftmax(policy_logits.action_type)\n\n return torch.mean(torch.sum(-policy * log_policy, axis=-1))","def _mean_diff(x, y):\n return np.mean(x) - np.mean(y)","def calc_entropy(data_set): #calculates total entropy of the dataset\r\n republicans = 0\r\n democrats = 0\r\n total = 0\r\n for data_point in data_set:\r\n party = data_point.dat_party\r\n if party == \"R\":\r\n republicans+=1\r\n elif party == \"D\":\r\n democrats+=1\r\n total+=1\r\n\r\n if total == 0: return 0\r\n prob_dem = democrats/total\r\n prob_rep = republicans/total\r\n if prob_dem == 0: return -(prob_rep * math.log(prob_rep, 2))\r\n if prob_rep == 0: return -(prob_dem * math.log(prob_dem, 2))\r\n\r\n entropy = (-prob_dem * math.log(prob_dem, 2)) -(prob_rep * math.log(prob_rep, 2))\r\n return entropy","def mean_bias_error(self) -> float:\n return float(np.sum(self.true - self.predicted) / len(self.true))","def entropy_difference(feature, answers, num_lemma):\n f_max = np.max(feature)\n f_min = np.min(feature)\n # check is it unsound feature\n if f_max == f_min:\n # print('lemma 0: ', num_lemma)\n return 10000\n step = (f_max - f_min) / 1000\n p = [[0, 0] for _ in range(1000)]\n sum_p = len(feature)\n for j in range(len(feature)):\n index = math.trunc((feature[j] - f_min)/step)\n if index == 1000:\n index = 999\n p[index][answers[j]] += 1\n # difference between entropy feature+answers and just feature\n result = 0\n for i in range(1000):\n if (p[i][0] != 0) & (p[i][1] != 0):\n result += math.log2((p[i][0] + p[i][1]) / sum_p) * (p[i][0] + p[i][1]) / sum_p - \\\n math.log2(p[i][0] / sum_p) * (p[i][0]) / sum_p - \\\n math.log2(p[i][1] / sum_p) * (p[i][1]) / sum_p\n # entropy answers\n all_answers = len(answers)\n positive_answers = sum(answers) / all_answers\n negative_answers = 1 - positive_answers\n if (positive_answers == 0) or negative_answers == 0:\n entropy_answers = 0\n else:\n entropy_answers = - positive_answers * math.log2(positive_answers) - \\\n negative_answers * math.log2(negative_answers)\n\n # difference between (feature entropy + answers entropy) and (feature + answers) entropy\n if entropy_answers - result < 0:\n print('negative information', num_lemma, entropy_answers - result)\n return - (entropy_answers - result)","def entropy(self, params):\n log_std = params[:, :, 1]\n return (log_std + 0.5 * (self.LOG2PI + 1)).sum(dim=-1)","def entropy(self):\n return self._entropy_func","def mean(self):\n return math.exp(self.mu + (self.sigma ** 2) / 2)","def entropy(self, y):\n n = y.size\n if n <= 1:\n return 0\n\n labels, counts = unique(y, return_counts=True)\n\n if counts.size <= 1:\n return 0\n\n probs = counts / n\n entropy = -sum([p * log(p, 2) for p in probs])\n return entropy","def get_entropy(self, rows):\n label_count = defaultdict(int)\n total_count = 0\n for row in rows:\n label = row[self.target_attribute]\n label_count[label] += 1\n total_count += 1\n return sum([-(float(label_count[label]) /\n total_count) * np.log2(float(label_count[label]) / total_count)\n for label in label_count.keys()])","def entropy(s):\n p, lns = Counter(s), float(len(s))\n return -sum( count/lns * math.log(count/lns, 2) for count in p.values())","def entropy(y):\n p = _proba(y)\n return (-p * np.log2(p)).sum()","def _get_mean(self):\n mu = self._get_conditional_negative_energy()\n return sigmoid(mu)","def entropy(y):\r\n\r\n # INSERT YOUR CODE HERE\r\n value, count = np.unique(y,return_counts = True)\r\n Hy = 0.0\r\n prob = count.astype(float)/len(y)\r\n for p in prob:\r\n Hy += -(p)*(np.log2(p))\r\n return Hy\r\n raise Exception('Function not yet implemented!')","def __compute_entropy(row:pd.Series) -> float:\n probability = row.value_counts(normalize=True).values\n entropy = EntropicSolver.__compute_entropy_probability(probability)\n return entropy","def entropy(self,classData):\n\n\t\t###### your implementation below ######\n\t\ttotalEntropy = 0\n\t\ttempSet = {}\n\t\tfor i in range(len(classData)):\n\t\t\ttempSet[classData[i]] = (classData.count(classData[i]))\n\t\ttotal = sum(tempSet.values())\n\t\tfor x in tempSet:\n\t\t\ttotalEntropy += -(tempSet[x]/total * math.log(tempSet[x]/total, 2))\n\t\treturn totalEntropy","def mean_deviation(self):\r\n\t\t_mean = sum(self.sample)/len(self.sample)\r\n\t\treturn sum(map(lambda x: abs(x - _mean), self.sample))/len(self.sample)","def entropy(data):\n\n freqs = {}\n suma = len(data)\n\n for i in range(0, len(data)):\n freqs[data[i]] = 1.0 + freqs.get(data[i], 0)\n\n res = 0.0\n for i in freqs:\n res += (freqs[i] / suma) * log((freqs[i] / suma), 2)\n return -res","def entropy(Y):\n unique, count = np.unique(Y, return_counts=True, axis=0)\n prob = count/len(Y)\n en = np.sum((-1)*prob*np.log2(prob))\n return en","def compute(self): \r\n hist = self.confusion_matrix\r\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\r\n mean_iu = np.nanmean(iu)\r\n return mean_iu","def __entropy(self, data_set, target_feature):\n frequencies = self.__calculate_frequency(data_set, target_feature)\n feature_entropy = 0.0\n number_of_values = len(data_set)\n\n # Add entropy for each value in frequencies.\n for frequency in frequencies:\n probability = frequencies[frequency] / number_of_values\n feature_entropy += (probability * math.log(probability, 2))\n\n return feature_entropy * -1","def entropy( freq ):\n N = 0.0\n entropy = 0.0\n for x, v in freq.items( ):\n N += v\n entropy -= v * math.log( v, 2 )\n return (N * math.log( N, 2 ) + entropy) / N","def calc_entropy_tuning_loss(self, log_probs):\n with torch.no_grad():\n inner_prod = (log_probs + self.target_entropy).detach()\n alpha_loss = -(self.log_alpha * inner_prod).mean()\n return alpha_loss","def nats(self) -> float:\n return self.entropy()","def entropy(P):\n P_nan = P.copy()\n P_nan[P_nan == 0] = np.nan\n return np.nansum(np.multiply(P_nan, np.log2(1 / P_nan)))","def theoretical_effective(dataset):\n return float(sum(dataset))/len(dataset)","def gain(Y, X):\n return entropy(Y) - cEntropy(Y,X)","def computeLoss(self):\n return sum(np.arccosh(-minkowskiArrayDot(self.examples, self.centroid)) ** 2)[0] / np.shape(self.examples)[0]","def em_mean(self) -> float:\n if self.__total_pulls == 0:\n raise Exception('Number of pulls is 0. No empirical mean.')\n return self.__total_rewards / self.__total_pulls","def entropy(y):\n return -1 * sum(\n [\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\n for value in set(y)\n ]\n )","def entropy(probabilities):\n return -(sum([p * log(p, 2) if p > 0 else 0 for p in probabilities]))","def predictive_entropy(mc_preds):\n return entropy(np.mean(mc_preds, axis=0))","def entropy(group_counts):\n total = sum(group_counts)\n entro = 0\n for item_count in group_counts:\n entro += item_entropy(item_count, total)\n return entro","def entropy(data):\n n, m = np.shape(data)\n data = np.tanh(data)\n data = data / np.sum(data, axis=0)\n a = data * 1.0\n a[np.where(data == 0)] = 0.000001\n\n e = (-1.0 / np.log(n)) * np.sum(data * np.log(a), axis=0)\n w = (1 - e) / np.sum(1 - e)\n return w","def entropy(counts):\n assert (counts >= 0).all()\n probs = counts / counts.sum()\n probs = probs[probs > 0] # Avoid log(0)\n return - np.sum(probs * np.log2(probs))","def entropy(doc_or_tokens: types.DocOrTokens) -> float:\n words = utils.get_words(doc_or_tokens)\n word_counts = itertoolz.frequencies(word.text for word in words)\n n_words = sum(word_counts.values())\n probs = (count / n_words for count in word_counts.values())\n return -sum(prob * math.log2(prob) for prob in probs)","def crossEntropy(obs, actual, offset=1e-7):\n # (tf.Tensor, tf.Tensor, float) -> tf.Tensor\n # bound by clipping to avoid nan\n obs_ = tf.clip_by_value(obs, offset, 1 - offset)\n return -tf.reduce_sum(actual * tf.log(obs_) +\n (1 - actual) * tf.log(1 - obs_), 1)","def compute_entropy_loss(logits):\n policy = F.softmax(logits, dim=-1)\n log_policy = F.log_softmax(logits, dim=-1)\n return torch.sum(policy * log_policy)","def gaussian_entropy(log_std):\n return tf.reduce_sum(log_std + 0.5 * np.log(2.0 * np.pi * np.e), axis=-1)","def entropy(self, X):\n if isinstance(X, np.ndarray):\n X = pd.DataFrame(X, index=[str(i) for i in range(len(X))])\n K = self._posterior_covariance(X)\n L = np.linalg.cholesky(K)\n D = len(X)\n return np.sum(np.log(np.diag(L))) + 0.5 * D * np.log(2*np.pi*np.exp(1))","def entropy(x):\n x_max, x_min = x.max(), x.min()\n assert (x_min >= 0) and (x_max <= 1)\n if x_min == x_max == 0:\n return np.float32(0.)\n # Take only non-zero values as log(0) = 0 :\n nnz_x = x[np.nonzero(x)]\n entr = -np.sum(nnz_x * np.log2(nnz_x))\n\n return entr","def getEntropy(self, pVal, nVal):\n totVal = pVal + nVal\n if pVal == 0 or nVal == 0:\n return 0\n\n pProb = pVal/totVal\n nProb = 1 - pProb\n entropy = - (pProb * math.log(pProb, 2) + nProb * math.log(nProb, 2))\n return entropy","def calculate_entropic_cost(self, log_prediction):\n\n log_prediction = tf.squeeze(log_prediction)\n mean, var_samples = tf.nn.moments(tf.exp(log_prediction), axes=0)\n clip_min_variance = 1e-5 # Prevents 1 / 0 errors\n var_samples = math_ops.maximum(var_samples, clip_min_variance)\n\n penalty = tf.reciprocal(var_samples) # Small variance across samples should be discouraged\n\n return tf.reduce_sum(penalty)","def _get_mean(self):\n return self._get_conditional_negative_energy()","def electronicMinusHalfEntropy(self):\n\t\tif self.entropy is None:\n\t\t\toutVal = None\n\t\telse:\n\t\t\toutVal = self.electronicTotalE - (0.5*self.entropy)\n\t\treturn outVal","def target_loss(self, inp_hist):\n active_targ = self.get_active_target(inp_hist)\n return torch.mean((inp_hist[:, 1:3] - active_targ) ** 2)","def test_entropy_knn1(mean, std):\n n = 100000\n data = np.random.normal(mean, std, n).reshape(n, 1)\n h = differential_entropy_knn(data)\n assert h == pytest.approx(np.log2(2 * np.pi * np.e * std**2) / 2, abs=1e-1)","def mean_field_entropy(model, args, whitelist=None):\n trace = poutine.trace(model).get_trace(*args)\n entropy = 0.0\n for name, site in trace.nodes.items():\n if site[\"type\"] == \"sample\":\n if not poutine.util.site_is_subsample(site):\n if whitelist is None or name in whitelist:\n entropy += site[\"fn\"].entropy()\n return entropy","def conditional_entropy(f1, f2):\n\n ce = ee.entropyd(f1) - ee.midd(f1, f2)\n return ce","def entropy(self, **kwargs) -> TensorType:","def entropy(self, **kwargs) -> TensorType:","def _entropy(self, y):\n # Get size\n n = y.shape[0]\n summation = 0\n\n # Summatory\n for c_i in np.unique(y):\n prob = sum(y == c_i) / float(n)\n summation += prob * np.log2(prob)\n\n return -summation","def entropy_balance(self):\n return","def entropy_balance(self):\n return","def _entropy(self):\n return self.rv.entropy(*self._pymc_dists_to_value(self.args), **self.kwds)","def untruncatedMean(self):\n return self._distribution.untrMean()","def _cal_igr(x, y):\n return (_cal_entropy(y) - _cal_conditionalEnt(x, y)) / _cal_conditionalEnt(x, y)","def entropyDistributed(distribution):\n return -sum(map(lambda p : p * log(p, 2), distribution))","def cEntropy(Y, X):\n return jEntropy(Y, X) - entropy(X)","def cal_globalEntropy(self):\n group_score = []\n pop_total = np.sum(self.pop_sum)\n prop = np.asarray(np.sum(self.pop, axis=0))[0]\n\n # loop at sum of each population groups\n for group in prop:\n group_idx = group / pop_total * np.log(1 / (group / pop_total))\n group_score.append(group_idx)\n entropy = np.sum(group_score)\n\n return entropy","def nmse(actual: np.ndarray, predicted: np.ndarray):\n return np.mean(np.square(actual - predicted)) / (np.mean(actual) * np.mean(predicted) + np.finfo(float).eps)","def test_entropy_knn2(mean, std):\n n = 100000\n data = np.random.normal(mean, std, n).reshape(n, 1)\n h = differential_entropy_knn(data, [0])\n assert h == pytest.approx(np.log2(2 * np.pi * np.e * std**2) / 2, abs=1e-1)","def calculate_entropy():\n\tstat = {} # dictionary - chars and number of repetitions\n\tallchar = 0.0 # total number of characters\n\tentropy = 0.0 # initial entropy\n\n\tfor line in sys.stdin.readlines():\n\t\tline = re.sub(r'\\s', '', line)\n\t\tfor znak in line:\n\t\t\tif znak in stat:\n\t\t\t\tstat[znak] += 1\n\t\t\telse:\n\t\t\t\tstat[znak] = 1\n\t\t\tallchar += 1\n\n\tfor znak in stat:\n\t\tstat[znak] = stat[znak]/allchar\n\t\tentropy += stat[znak] * log(stat[znak], 2)\n\n\tentropy *= -1\n\treturn entropy","def get_entropy_df(self, df=None):\n if df is None:\n df = self.df\n target = self.target\n\n entropy = 0\n values = df[target].unique()\n\n for value in values:\n # Fraction of values of 'value' in target feature\n fraction = df[target].value_counts()[value]/len(df[target])\n entropy += -fraction*np.log2(fraction)\n\n return entropy","def entropy ( target_array ):\n return -1 * sum (\n [\n pipe ( np.sum ( target_array == value ) / len ( target_array ), lambda ratio: ratio * np.log ( ratio ) )\n for value in set ( target_array )\n ]\n ) # End entropy()"],"string":"[\n \"def entropy(self):\\n return -np.sum(self.log_likelihoods * np.exp(self.log_likelihoods))\",\n \"def entropy(img):\\n # by calculating\\n histogram = img.histogram()\\n histogram_size = sum(histogram)\\n histogram = [float(h) / histogram_size for h in histogram]\\n\\n return -sum([p * math.log(p, 2) for p in histogram if p != 0])\",\n \"def entropy(self):\\n n = len(self.y)\\n sum_ = 0\\n for i in np.unique(self.y):\\n v = len(self.y[self.y == i])\\n sum_ += -((v/n) * log2(v/n))\\n return sum_\",\n \"def entropy(self):\\n return self._normal.entropy()\",\n \"def entropy(y):\\n EPS = 0.0005\\n\\n # YOUR CODE HERE\\n if len(y) == 0:\\n return 0.\\n \\n pk = np.mean(y, axis=0)\\n \\n return - np.sum(pk * np.log(pk + EPS))\",\n \"def _entropy(data):\\n hist = np.array(PIL.Image.fromarray(data).histogram())\\n hist = hist / hist.sum()\\n hist = hist[hist != 0]\\n return -np.sum(hist * np.log2(hist))\",\n \"def entropy(self):\\n Z = self.sum()\\n assert (Z > 0), 'Non-normalizable factor (perhaps log factor?)' # also check for positivity?\\n H = 0.0\\n for x in np.nditer(self.t, op_flags=['readonly']):\\n p = x/Z\\n H += 0.0 if p==0 else -p*np.log(p)\\n return H\",\n \"def entropy(self):\\r\\n return 1/2 * (self.dim * (_LOG_2PI + 1) + self._log_det_cov)\",\n \"def entropy(Y):\\n\\n temp = np.unique(Y, return_counts=True)\\n uniq_Y = list(temp[0])\\n Y_count = list(temp[1])\\n \\n total = sum(Y_count)\\n\\n ent = 0\\n for elem in uniq_Y:\\n prob = Y_count[uniq_Y.index(elem)] / total\\n # print(\\\"prob:\\\", prob)\\n ent -= (prob * (math.log2(prob)))\\n # print(\\\"ent:\\\",ent)\\n\\n return ent\",\n \"def entropy(data):\\n e = 0\\n\\n counter = collections.Counter(data)\\n l = len(data)\\n for count in counter.values():\\n p_x = count / l\\n e += - p_x * math.log2(p_x)\\n\\n return e\",\n \"def computeEntropy(self, img):\\n hist, bins = np.histogram(img.ravel(), bins=256, density=True)\\n return scipy.stats.entropy(hist)\",\n \"def entropy(self, args):\\n mean, stddev = args\\n dist = tfp.distributions.Normal(loc=mean, scale=stddev)\\n entropy = dist.entropy()\\n return entropy\",\n \"def get_entropy(distribution, samples):\\n entropy = -tf.reduce_sum(distribution.log_prob(samples), axis=1)\\n return entropy\",\n \"def entropy(self):\\n ent = 0.0\\n for f in self.byte_freq:\\n if f > 0:\\n freq = float(f) / self.byte_total\\n ent = ent + freq * math.log(freq, 2)\\n return -ent\",\n \"def entropy(self, mean=None, cov=1):\\r\\n dim, mean, cov = _process_parameters(None, mean, cov)\\r\\n return 1/2 * np.log(np.linalg.det(2 * np.pi * np.e * cov))\",\n \"def image_entropy(img):\\r\\n hist = img.histogram()\\r\\n hist_size = sum(hist)\\r\\n hist = [float(h) / hist_size for h in hist]\\r\\n\\r\\n return -sum([p * math.log(p, 2) for p in hist if p != 0])\",\n \"def gmean_diff(self) -> float:\\n sim_log = np.log1p(self.predicted)\\n obs_log = np.log1p(self.true)\\n return float(np.exp(gmean(sim_log) - gmean(obs_log)))\",\n \"def conditional_entropy(self) -> float:\\n pass\",\n \"def entropy(dist):\\n #dist = array([max(d,1e-100) for d in dist])\\n dist = dist + 1e-20\\n return dot(dist,(log(1.0/dist) * (1.0/log(2.0))).T)\",\n \"def entropy(d, total, word_count):\\n\\t# Entropie je - Sum_morf p(morf) * log_2 p(morf)\\n\\t# p(morf) = c(morf) / c(all)\\n\\te = 0\\n\\tfor count in d.values():\\n\\t\\tp = count/total\\n\\t\\ttype_e = - p * log2(p)\\n\\t\\te += type_e * count\\n\\treturn e / word_count\",\n \"def __compute_entropy_probability(probability:np.ndarray) -> float:\\n entropy = -np.sum(probability * np.log2(probability))\\n return entropy\",\n \"def demeaned(self):\\n return self.data - self.mean\",\n \"def entropy(out, dim=1, reduce='mean'):\\n log_prob = F.log_softmax(out, dim=dim)\\n h = -torch.sum(log_prob.exp() * log_prob, dim=dim)\\n if reduce == 'none':\\n return h\\n if reduce == 'mean':\\n return h.mean()\\n if reduce == 'sum':\\n return h.sum()\",\n \"def entropy(temp,pres):\\n g_t = liq_g(1,0,temp,pres)\\n s = -g_t\\n return s\",\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 ensemble_entropy(self):\\n return transition_matrices.entropy_measure(self.ensemble_transition_matrix)\",\n \"def div(self):\\n freqList = [i / sum(self.has.values()) for i in self.has.values()]\\n entropies = [i * math.log(i, 2) for i in freqList]\\n entropy = -sum(entropies)\\n return entropy\",\n \"def entropy(data):\\n strings, lens = Counter(data), np.float(len(data))\\n return -sum(count / lens * np.log2(count / lens) for count in strings.values())\",\n \"def calculate_entropy(eval_token_count, training_model):\\n sum_of_counts = sum(eval_token_count.values())\\n cross_entropy = 0\\n mis = []\\n for ngram in eval_token_count:\\n if training_model.score(ngram[-1], list(ngram[0:3])) == 0 or sum_of_counts == 0:\\n mi = np.mean(mis) if len(mis) > 0 else np.log2(0.287)\\n else:\\n mi = training_model.logscore(ngram[-1], list(ngram[0:3]))\\n pi = eval_token_count[ngram] / sum_of_counts\\n mis.append(mi)\\n cross_entropy -= pi * mi\\n return cross_entropy\",\n \"def calculate_entropy(dataset) :\\n\\n num_entries = len(dataset)\\n label_counts = {}\\n for vector in dataset :\\n # the label is at the last index of the data set\\n current_label = vector[-1]\\n if current_label not in label_counts :\\n label_counts[current_label] = 0\\n label_counts[current_label] += 1\\n # Calculate the entropy\\n entropy = 0.0\\n for label in label_counts :\\n # Calculate probability of each label within the dataset\\n prob_of_label = label_counts[label]/num_entries\\n # Since the entropy is the negative of the sum of all probability,\\n # simply subtract it\\n entropy -= prob_of_label * log(prob_of_label, 2)\\n return entropy\",\n \"def mean_ent(cluster_assignments):\\n nrow, ncol, nrun = cluster_assignments.shape\\n csum = cluster_assignments.sum(axis=2)\\n m = numpy.mean([scipy.stats.entropy(row) for row in csum])\\n return m\",\n \"def entropy(self):\\n raise NotImplementedError\",\n \"def calculate_entropy(reduced_density_matrix_evals):\\n vec_xlogx = vectorize(calculate_xlogx)\\n result = -sum(vec_xlogx(reduced_density_matrix_evals,\\n\\t float_info.epsilon))\\n return result\",\n \"def entropy(x):\\n nz = np.nonzero(x)[0]\\n return -np.sum(x[nz]*np.log2(x[nz]))\",\n \"def calculate_entropy(prob):\\n return -(prob * math.log(prob,2))\",\n \"def entropy(y):\\n total = y.size\\n value_counts = np.bincount(y).astype(\\\"float\\\")\\n proportions = value_counts / y.size\\n\\n return sum(-i * np.log(i) for i in proportions if i)\",\n \"def entropy_loss(policy_logits):\\n\\n softmax = nn.Softmax(dim=-1)\\n logsoftmax = nn.LogSoftmax(dim=-1)\\n\\n policy = softmax(policy_logits.action_type)\\n log_policy = logsoftmax(policy_logits.action_type)\\n\\n return torch.mean(torch.sum(-policy * log_policy, axis=-1))\",\n \"def _mean_diff(x, y):\\n return np.mean(x) - np.mean(y)\",\n \"def calc_entropy(data_set): #calculates total entropy of the dataset\\r\\n republicans = 0\\r\\n democrats = 0\\r\\n total = 0\\r\\n for data_point in data_set:\\r\\n party = data_point.dat_party\\r\\n if party == \\\"R\\\":\\r\\n republicans+=1\\r\\n elif party == \\\"D\\\":\\r\\n democrats+=1\\r\\n total+=1\\r\\n\\r\\n if total == 0: return 0\\r\\n prob_dem = democrats/total\\r\\n prob_rep = republicans/total\\r\\n if prob_dem == 0: return -(prob_rep * math.log(prob_rep, 2))\\r\\n if prob_rep == 0: return -(prob_dem * math.log(prob_dem, 2))\\r\\n\\r\\n entropy = (-prob_dem * math.log(prob_dem, 2)) -(prob_rep * math.log(prob_rep, 2))\\r\\n return entropy\",\n \"def mean_bias_error(self) -> float:\\n return float(np.sum(self.true - self.predicted) / len(self.true))\",\n \"def entropy_difference(feature, answers, num_lemma):\\n f_max = np.max(feature)\\n f_min = np.min(feature)\\n # check is it unsound feature\\n if f_max == f_min:\\n # print('lemma 0: ', num_lemma)\\n return 10000\\n step = (f_max - f_min) / 1000\\n p = [[0, 0] for _ in range(1000)]\\n sum_p = len(feature)\\n for j in range(len(feature)):\\n index = math.trunc((feature[j] - f_min)/step)\\n if index == 1000:\\n index = 999\\n p[index][answers[j]] += 1\\n # difference between entropy feature+answers and just feature\\n result = 0\\n for i in range(1000):\\n if (p[i][0] != 0) & (p[i][1] != 0):\\n result += math.log2((p[i][0] + p[i][1]) / sum_p) * (p[i][0] + p[i][1]) / sum_p - \\\\\\n math.log2(p[i][0] / sum_p) * (p[i][0]) / sum_p - \\\\\\n math.log2(p[i][1] / sum_p) * (p[i][1]) / sum_p\\n # entropy answers\\n all_answers = len(answers)\\n positive_answers = sum(answers) / all_answers\\n negative_answers = 1 - positive_answers\\n if (positive_answers == 0) or negative_answers == 0:\\n entropy_answers = 0\\n else:\\n entropy_answers = - positive_answers * math.log2(positive_answers) - \\\\\\n negative_answers * math.log2(negative_answers)\\n\\n # difference between (feature entropy + answers entropy) and (feature + answers) entropy\\n if entropy_answers - result < 0:\\n print('negative information', num_lemma, entropy_answers - result)\\n return - (entropy_answers - result)\",\n \"def entropy(self, params):\\n log_std = params[:, :, 1]\\n return (log_std + 0.5 * (self.LOG2PI + 1)).sum(dim=-1)\",\n \"def entropy(self):\\n return self._entropy_func\",\n \"def mean(self):\\n return math.exp(self.mu + (self.sigma ** 2) / 2)\",\n \"def entropy(self, y):\\n n = y.size\\n if n <= 1:\\n return 0\\n\\n labels, counts = unique(y, return_counts=True)\\n\\n if counts.size <= 1:\\n return 0\\n\\n probs = counts / n\\n entropy = -sum([p * log(p, 2) for p in probs])\\n return entropy\",\n \"def get_entropy(self, rows):\\n label_count = defaultdict(int)\\n total_count = 0\\n for row in rows:\\n label = row[self.target_attribute]\\n label_count[label] += 1\\n total_count += 1\\n return sum([-(float(label_count[label]) /\\n total_count) * np.log2(float(label_count[label]) / total_count)\\n for label in label_count.keys()])\",\n \"def entropy(s):\\n p, lns = Counter(s), float(len(s))\\n return -sum( count/lns * math.log(count/lns, 2) for count in p.values())\",\n \"def entropy(y):\\n p = _proba(y)\\n return (-p * np.log2(p)).sum()\",\n \"def _get_mean(self):\\n mu = self._get_conditional_negative_energy()\\n return sigmoid(mu)\",\n \"def entropy(y):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n value, count = np.unique(y,return_counts = True)\\r\\n Hy = 0.0\\r\\n prob = count.astype(float)/len(y)\\r\\n for p in prob:\\r\\n Hy += -(p)*(np.log2(p))\\r\\n return Hy\\r\\n raise Exception('Function not yet implemented!')\",\n \"def __compute_entropy(row:pd.Series) -> float:\\n probability = row.value_counts(normalize=True).values\\n entropy = EntropicSolver.__compute_entropy_probability(probability)\\n return entropy\",\n \"def entropy(self,classData):\\n\\n\\t\\t###### your implementation below ######\\n\\t\\ttotalEntropy = 0\\n\\t\\ttempSet = {}\\n\\t\\tfor i in range(len(classData)):\\n\\t\\t\\ttempSet[classData[i]] = (classData.count(classData[i]))\\n\\t\\ttotal = sum(tempSet.values())\\n\\t\\tfor x in tempSet:\\n\\t\\t\\ttotalEntropy += -(tempSet[x]/total * math.log(tempSet[x]/total, 2))\\n\\t\\treturn totalEntropy\",\n \"def mean_deviation(self):\\r\\n\\t\\t_mean = sum(self.sample)/len(self.sample)\\r\\n\\t\\treturn sum(map(lambda x: abs(x - _mean), self.sample))/len(self.sample)\",\n \"def entropy(data):\\n\\n freqs = {}\\n suma = len(data)\\n\\n for i in range(0, len(data)):\\n freqs[data[i]] = 1.0 + freqs.get(data[i], 0)\\n\\n res = 0.0\\n for i in freqs:\\n res += (freqs[i] / suma) * log((freqs[i] / suma), 2)\\n return -res\",\n \"def entropy(Y):\\n unique, count = np.unique(Y, return_counts=True, axis=0)\\n prob = count/len(Y)\\n en = np.sum((-1)*prob*np.log2(prob))\\n return en\",\n \"def compute(self): \\r\\n hist = self.confusion_matrix\\r\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\\r\\n mean_iu = np.nanmean(iu)\\r\\n return mean_iu\",\n \"def __entropy(self, data_set, target_feature):\\n frequencies = self.__calculate_frequency(data_set, target_feature)\\n feature_entropy = 0.0\\n number_of_values = len(data_set)\\n\\n # Add entropy for each value in frequencies.\\n for frequency in frequencies:\\n probability = frequencies[frequency] / number_of_values\\n feature_entropy += (probability * math.log(probability, 2))\\n\\n return feature_entropy * -1\",\n \"def entropy( freq ):\\n N = 0.0\\n entropy = 0.0\\n for x, v in freq.items( ):\\n N += v\\n entropy -= v * math.log( v, 2 )\\n return (N * math.log( N, 2 ) + entropy) / N\",\n \"def calc_entropy_tuning_loss(self, log_probs):\\n with torch.no_grad():\\n inner_prod = (log_probs + self.target_entropy).detach()\\n alpha_loss = -(self.log_alpha * inner_prod).mean()\\n return alpha_loss\",\n \"def nats(self) -> float:\\n return self.entropy()\",\n \"def entropy(P):\\n P_nan = P.copy()\\n P_nan[P_nan == 0] = np.nan\\n return np.nansum(np.multiply(P_nan, np.log2(1 / P_nan)))\",\n \"def theoretical_effective(dataset):\\n return float(sum(dataset))/len(dataset)\",\n \"def gain(Y, X):\\n return entropy(Y) - cEntropy(Y,X)\",\n \"def computeLoss(self):\\n return sum(np.arccosh(-minkowskiArrayDot(self.examples, self.centroid)) ** 2)[0] / np.shape(self.examples)[0]\",\n \"def em_mean(self) -> float:\\n if self.__total_pulls == 0:\\n raise Exception('Number of pulls is 0. No empirical mean.')\\n return self.__total_rewards / self.__total_pulls\",\n \"def entropy(y):\\n return -1 * sum(\\n [\\n pipe(np.sum(y == value) / len(y), lambda ratio: ratio * np.log(ratio))\\n for value in set(y)\\n ]\\n )\",\n \"def entropy(probabilities):\\n return -(sum([p * log(p, 2) if p > 0 else 0 for p in probabilities]))\",\n \"def predictive_entropy(mc_preds):\\n return entropy(np.mean(mc_preds, axis=0))\",\n \"def entropy(group_counts):\\n total = sum(group_counts)\\n entro = 0\\n for item_count in group_counts:\\n entro += item_entropy(item_count, total)\\n return entro\",\n \"def entropy(data):\\n n, m = np.shape(data)\\n data = np.tanh(data)\\n data = data / np.sum(data, axis=0)\\n a = data * 1.0\\n a[np.where(data == 0)] = 0.000001\\n\\n e = (-1.0 / np.log(n)) * np.sum(data * np.log(a), axis=0)\\n w = (1 - e) / np.sum(1 - e)\\n return w\",\n \"def entropy(counts):\\n assert (counts >= 0).all()\\n probs = counts / counts.sum()\\n probs = probs[probs > 0] # Avoid log(0)\\n return - np.sum(probs * np.log2(probs))\",\n \"def entropy(doc_or_tokens: types.DocOrTokens) -> float:\\n words = utils.get_words(doc_or_tokens)\\n word_counts = itertoolz.frequencies(word.text for word in words)\\n n_words = sum(word_counts.values())\\n probs = (count / n_words for count in word_counts.values())\\n return -sum(prob * math.log2(prob) for prob in probs)\",\n \"def crossEntropy(obs, actual, offset=1e-7):\\n # (tf.Tensor, tf.Tensor, float) -> tf.Tensor\\n # bound by clipping to avoid nan\\n obs_ = tf.clip_by_value(obs, offset, 1 - offset)\\n return -tf.reduce_sum(actual * tf.log(obs_) +\\n (1 - actual) * tf.log(1 - obs_), 1)\",\n \"def compute_entropy_loss(logits):\\n policy = F.softmax(logits, dim=-1)\\n log_policy = F.log_softmax(logits, dim=-1)\\n return torch.sum(policy * log_policy)\",\n \"def gaussian_entropy(log_std):\\n return tf.reduce_sum(log_std + 0.5 * np.log(2.0 * np.pi * np.e), axis=-1)\",\n \"def entropy(self, X):\\n if isinstance(X, np.ndarray):\\n X = pd.DataFrame(X, index=[str(i) for i in range(len(X))])\\n K = self._posterior_covariance(X)\\n L = np.linalg.cholesky(K)\\n D = len(X)\\n return np.sum(np.log(np.diag(L))) + 0.5 * D * np.log(2*np.pi*np.exp(1))\",\n \"def entropy(x):\\n x_max, x_min = x.max(), x.min()\\n assert (x_min >= 0) and (x_max <= 1)\\n if x_min == x_max == 0:\\n return np.float32(0.)\\n # Take only non-zero values as log(0) = 0 :\\n nnz_x = x[np.nonzero(x)]\\n entr = -np.sum(nnz_x * np.log2(nnz_x))\\n\\n return entr\",\n \"def getEntropy(self, pVal, nVal):\\n totVal = pVal + nVal\\n if pVal == 0 or nVal == 0:\\n return 0\\n\\n pProb = pVal/totVal\\n nProb = 1 - pProb\\n entropy = - (pProb * math.log(pProb, 2) + nProb * math.log(nProb, 2))\\n return entropy\",\n \"def calculate_entropic_cost(self, log_prediction):\\n\\n log_prediction = tf.squeeze(log_prediction)\\n mean, var_samples = tf.nn.moments(tf.exp(log_prediction), axes=0)\\n clip_min_variance = 1e-5 # Prevents 1 / 0 errors\\n var_samples = math_ops.maximum(var_samples, clip_min_variance)\\n\\n penalty = tf.reciprocal(var_samples) # Small variance across samples should be discouraged\\n\\n return tf.reduce_sum(penalty)\",\n \"def _get_mean(self):\\n return self._get_conditional_negative_energy()\",\n \"def electronicMinusHalfEntropy(self):\\n\\t\\tif self.entropy is None:\\n\\t\\t\\toutVal = None\\n\\t\\telse:\\n\\t\\t\\toutVal = self.electronicTotalE - (0.5*self.entropy)\\n\\t\\treturn outVal\",\n \"def target_loss(self, inp_hist):\\n active_targ = self.get_active_target(inp_hist)\\n return torch.mean((inp_hist[:, 1:3] - active_targ) ** 2)\",\n \"def test_entropy_knn1(mean, std):\\n n = 100000\\n data = np.random.normal(mean, std, n).reshape(n, 1)\\n h = differential_entropy_knn(data)\\n assert h == pytest.approx(np.log2(2 * np.pi * np.e * std**2) / 2, abs=1e-1)\",\n \"def mean_field_entropy(model, args, whitelist=None):\\n trace = poutine.trace(model).get_trace(*args)\\n entropy = 0.0\\n for name, site in trace.nodes.items():\\n if site[\\\"type\\\"] == \\\"sample\\\":\\n if not poutine.util.site_is_subsample(site):\\n if whitelist is None or name in whitelist:\\n entropy += site[\\\"fn\\\"].entropy()\\n return entropy\",\n \"def conditional_entropy(f1, f2):\\n\\n ce = ee.entropyd(f1) - ee.midd(f1, f2)\\n return ce\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def _entropy(self, y):\\n # Get size\\n n = y.shape[0]\\n summation = 0\\n\\n # Summatory\\n for c_i in np.unique(y):\\n prob = sum(y == c_i) / float(n)\\n summation += prob * np.log2(prob)\\n\\n return -summation\",\n \"def entropy_balance(self):\\n return\",\n \"def entropy_balance(self):\\n return\",\n \"def _entropy(self):\\n return self.rv.entropy(*self._pymc_dists_to_value(self.args), **self.kwds)\",\n \"def untruncatedMean(self):\\n return self._distribution.untrMean()\",\n \"def _cal_igr(x, y):\\n return (_cal_entropy(y) - _cal_conditionalEnt(x, y)) / _cal_conditionalEnt(x, y)\",\n \"def entropyDistributed(distribution):\\n return -sum(map(lambda p : p * log(p, 2), distribution))\",\n \"def cEntropy(Y, X):\\n return jEntropy(Y, X) - entropy(X)\",\n \"def cal_globalEntropy(self):\\n group_score = []\\n pop_total = np.sum(self.pop_sum)\\n prop = np.asarray(np.sum(self.pop, axis=0))[0]\\n\\n # loop at sum of each population groups\\n for group in prop:\\n group_idx = group / pop_total * np.log(1 / (group / pop_total))\\n group_score.append(group_idx)\\n entropy = np.sum(group_score)\\n\\n return entropy\",\n \"def nmse(actual: np.ndarray, predicted: np.ndarray):\\n return np.mean(np.square(actual - predicted)) / (np.mean(actual) * np.mean(predicted) + np.finfo(float).eps)\",\n \"def test_entropy_knn2(mean, std):\\n n = 100000\\n data = np.random.normal(mean, std, n).reshape(n, 1)\\n h = differential_entropy_knn(data, [0])\\n assert h == pytest.approx(np.log2(2 * np.pi * np.e * std**2) / 2, abs=1e-1)\",\n \"def calculate_entropy():\\n\\tstat = {} # dictionary - chars and number of repetitions\\n\\tallchar = 0.0 # total number of characters\\n\\tentropy = 0.0 # initial entropy\\n\\n\\tfor line in sys.stdin.readlines():\\n\\t\\tline = re.sub(r'\\\\s', '', line)\\n\\t\\tfor znak in line:\\n\\t\\t\\tif znak in stat:\\n\\t\\t\\t\\tstat[znak] += 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tstat[znak] = 1\\n\\t\\t\\tallchar += 1\\n\\n\\tfor znak in stat:\\n\\t\\tstat[znak] = stat[znak]/allchar\\n\\t\\tentropy += stat[znak] * log(stat[znak], 2)\\n\\n\\tentropy *= -1\\n\\treturn entropy\",\n \"def get_entropy_df(self, df=None):\\n if df is None:\\n df = self.df\\n target = self.target\\n\\n entropy = 0\\n values = df[target].unique()\\n\\n for value in values:\\n # Fraction of values of 'value' in target feature\\n fraction = df[target].value_counts()[value]/len(df[target])\\n entropy += -fraction*np.log2(fraction)\\n\\n return entropy\",\n \"def entropy ( target_array ):\\n return -1 * sum (\\n [\\n pipe ( np.sum ( target_array == value ) / len ( target_array ), lambda ratio: ratio * np.log ( ratio ) )\\n for value in set ( target_array )\\n ]\\n ) # End entropy()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73744655","0.6969958","0.6913475","0.68965644","0.6835691","0.68118334","0.6751494","0.66962296","0.6673262","0.666841","0.6663414","0.66559005","0.66333395","0.660028","0.6595049","0.6591081","0.6569786","0.6554377","0.65446806","0.65093774","0.6505853","0.64524215","0.6449746","0.644608","0.6445319","0.64407605","0.6435502","0.6432921","0.6432916","0.6415892","0.63874334","0.63572365","0.6351874","0.6330948","0.6319385","0.63008285","0.6295855","0.6292862","0.62903506","0.62578195","0.6256433","0.62558347","0.6241552","0.6224271","0.6220349","0.6218167","0.62162","0.6202747","0.6199922","0.61940753","0.61892027","0.6184879","0.61846554","0.61772037","0.61749864","0.61573964","0.6157368","0.6153582","0.6142061","0.61402696","0.61399525","0.61350304","0.61328274","0.61121434","0.61011595","0.6091314","0.609067","0.6087085","0.6085659","0.6075867","0.6075369","0.6066698","0.60611886","0.6056473","0.60560423","0.6053428","0.60470855","0.6045847","0.6045438","0.6039741","0.6038829","0.6038725","0.60373133","0.6035671","0.601498","0.6010698","0.6010698","0.60090315","0.60087055","0.60087055","0.6005728","0.60011965","0.6000027","0.5995753","0.5983872","0.59829366","0.5981633","0.5968911","0.5964795","0.5962526","0.59623194"],"string":"[\n \"0.73744655\",\n \"0.6969958\",\n \"0.6913475\",\n \"0.68965644\",\n \"0.6835691\",\n \"0.68118334\",\n \"0.6751494\",\n \"0.66962296\",\n \"0.6673262\",\n \"0.666841\",\n \"0.6663414\",\n \"0.66559005\",\n \"0.66333395\",\n \"0.660028\",\n \"0.6595049\",\n \"0.6591081\",\n \"0.6569786\",\n \"0.6554377\",\n \"0.65446806\",\n \"0.65093774\",\n \"0.6505853\",\n \"0.64524215\",\n \"0.6449746\",\n \"0.644608\",\n \"0.6445319\",\n \"0.64407605\",\n \"0.6435502\",\n \"0.6432921\",\n \"0.6432916\",\n \"0.6415892\",\n \"0.63874334\",\n \"0.63572365\",\n \"0.6351874\",\n \"0.6330948\",\n \"0.6319385\",\n \"0.63008285\",\n \"0.6295855\",\n \"0.6292862\",\n \"0.62903506\",\n \"0.62578195\",\n \"0.6256433\",\n \"0.62558347\",\n \"0.6241552\",\n \"0.6224271\",\n \"0.6220349\",\n \"0.6218167\",\n \"0.62162\",\n \"0.6202747\",\n \"0.6199922\",\n \"0.61940753\",\n \"0.61892027\",\n \"0.6184879\",\n \"0.61846554\",\n \"0.61772037\",\n \"0.61749864\",\n \"0.61573964\",\n \"0.6157368\",\n \"0.6153582\",\n \"0.6142061\",\n \"0.61402696\",\n \"0.61399525\",\n \"0.61350304\",\n \"0.61328274\",\n \"0.61121434\",\n \"0.61011595\",\n \"0.6091314\",\n \"0.609067\",\n \"0.6087085\",\n \"0.6085659\",\n \"0.6075867\",\n \"0.6075369\",\n \"0.6066698\",\n \"0.60611886\",\n \"0.6056473\",\n \"0.60560423\",\n \"0.6053428\",\n \"0.60470855\",\n \"0.6045847\",\n \"0.6045438\",\n \"0.6039741\",\n \"0.6038829\",\n \"0.6038725\",\n \"0.60373133\",\n \"0.6035671\",\n \"0.601498\",\n \"0.6010698\",\n \"0.6010698\",\n \"0.60090315\",\n \"0.60087055\",\n \"0.60087055\",\n \"0.6005728\",\n \"0.60011965\",\n \"0.6000027\",\n \"0.5995753\",\n \"0.5983872\",\n \"0.59829366\",\n \"0.5981633\",\n \"0.5968911\",\n \"0.5964795\",\n \"0.5962526\",\n \"0.59623194\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":91997,"cells":{"query":{"kind":"string","value":"sigma is represented by softplus function 'sigma = log(1 + exp(rho))' to make sure it remains always positive and nontransformed 'rho' gets updated during backprop."},"document":{"kind":"string","value":"def get_rho(sigma, delta):\n rho = torch.log(torch.expm1(delta * torch.abs(sigma)) + 1e-20)\n return rho"},"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 rho2sigma(rho):\n return pt.softplus(rho)","def sigma2rho(sigma):\n return pt.log(pt.exp(pt.abs(sigma)) - 1.0)","def mbh_sigma(sigma):\n _MASS = 8.32\n _SLOPE = 5.64\n _VEL = 200e5\n\n mbh = _MASS + _SLOPE*np.log10(sigma/_VEL)\n mbh = np.power(10.0, mbh) * MSOL\n return mbh","def compute_sigma(\n T,\n S,\n z,\n **kwargs,\n):\n return compute_rho(T, S, z, **kwargs) - 1000","def zeroLJForce(sigma):\n return 2**(1/6) * sigma","def compute_sigma0(\n T,\n S,\n **kwargs,\n):\n return compute_rho(T, S, 0, **kwargs) - 1000","def M_sigma(self):\n\n print(\"\", file=self.logfile)\n print(\"Updating sigma_2\", file=self.logfile)\n self.sigma2 = 1/self.L_h*(np.square(np.linalg.norm(self.w)) + np.trace(self.R))","def const_sigma(self):\n if self.sigma is None:\n return (1 - 2 / self.eta) * np.eye(self.ndim)\n else:\n return np.array(self.sigma)","def _sigma_ep(self,gam,eps):\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n return self._sigma_1(gam,eps)","def _sigma_1(gam, eps):\n s1 = 4 * r0**2 * alpha / eps / mec2_unit\n s2 = 1 + (1./3. - eps/gam) * (1 - eps/gam)\n s3 = np.log(2 * gam * (gam - eps) / eps) - 1./2.\n s3[np.where(gam < eps)] = 0.0\n return s1 * s2 * s3","def _calc_sigma(self):\n if self.data is None:\n self._initial_blur()\n previous = self.init_sigma\n incr = 0\n self.sigmas = [(previous, incr)]\n for i in range(1, self.scale_per_octave + 3):\n sigma_abs = self.init_sigma * (self.dest_sigma / self.init_sigma) ** (1.0 * i / (self.scale_per_octave))\n increase = previous * sqrt((self.dest_sigma / self.init_sigma) ** (2.0 / self.scale_per_octave) - 1.0)\n self.sigmas.append((sigma_abs, increase))\n previous = sigma_abs\n logger.debug(\"Sigma= %s\" % self.sigmas)","def get_sigma_psf(self):\n pass","def post_rho(store):\n return loglike(store) + prior_rho(store)","def sigma(self):\n return self.__sigma","def true_lrv_ma1_t_free(sigma: float): \n return (19 / 3) * (sigma ** 2)","def _sigma_ee_nonrel(self,gam,eps):\n s0 = 4 * r0**2 * alpha / (15 * eps)\n x = 4 * eps / (gam**2 - 1)\n sigma_nonrel = s0 * self._F(x,gam)\n sigma_nonrel[np.where(eps >= 0.25*(gam**2 - 1.))] = 0.0\n sigma_nonrel[np.where(gam*np.ones_like(eps) < 1.0)] = 0.0\n return sigma_nonrel / mec2_unit","def get_sigma(rate, dt=1 * units.ns):\n return stats.norm.isf(rate * dt)","def calculate_sigma(self, params):\n ms = self.get_matrices(params)\n m_beta = ms['Beta']\n m_lambda = ms['Lambda']\n m_psi = ms['Psi']\n m_theta = ms['Theta']\n\n m_c = np.linalg.pinv(np.identity(m_beta.shape[0]) - m_beta)\n return m_lambda @ m_c @ m_psi @ m_c.T @ m_lambda.T + m_theta","def update_sigma(self):\n self.sigma = self.spw.sigmaSpinBox.value()","def _sigma(self, vect: Tensorlike):\n return 40 * vect ** 3 / (self.thickness + 1) ** 4","def _sigma(self, x):\n\n if self.jac is None: return 0\n\n return np.sqrt(\n np.dot(\n self.jac(x, *self.popt),\n np.dot(\n self.pcov,\n np.transpose(self.jac(x, *self.popt)))))","def sigma(x, a, b):\n\n def _sigma(d):\n return SIGMA0 * d ** 2 * np.heaviside(d, 0)\n\n return _sigma(a - x) + _sigma(x - b)","def _FWHMGauss(sigma, pixel=12):\n return sigma*2*np.sqrt(2*np.log(2))*pixel","def _sigma_inel(self, Tp):\n L = np.log(Tp/self._Tth)\n sigma = 30.7 - 0.96 * L + 0.18 * L ** 2\n sigma *= (1 - (self._Tth / Tp) ** 1.9) ** 3\n return sigma * 1e-27 # convert from mbarn to cm-2","def jeffreys(self, sigma):\n return 1. / sigma","def __init__(self, sigma=0.0001):\n self.sigma = sigma","def clamp_sigma(self, sigma, sigma_min=.01):\n self.logsigma.data.clamp_(np.log(sigma_min), np.log(sigma))","def _sigma_2(gam, eps):\n s0 = r0**2 * alpha / (3 * eps) / mec2_unit\n\n s1_1 = 16 * (1 - eps + eps**2) * np.log(gam / eps)\n s1_2 = -1 / eps**2 + 3 / eps - 4 - 4 * eps - 8 * eps**2\n s1_3 = -2 * (1 - 2 * eps) * np.log(1 - 2 * eps)\n s1_4 = 1 / (4 * eps**3) - 1 / (2 * eps**2) + 3 / eps - 2 + 4 * eps\n s1 = s1_1 + s1_2 + s1_3 * s1_4\n\n s2_1 = 2 / eps\n s2_2 = (4 - 1 / eps + 1 / (4 * eps**2)) * np.log(2 * gam)\n s2_3 = -2 + 2 / eps - 5 / (8 * eps**2)\n s2 = s2_1 * (s2_2 + s2_3)\n\n return s0 * np.where(eps <= 0.5, s1, s2) * heaviside(gam - eps)","def sampleGaussian(self, mu, log_sigma):\n # reparameterization trick\n epsilon = tf.random_normal(tf.shape(log_sigma), name=\"epsilon\")\n return mu + epsilon * tf.exp(log_sigma) # N(mu, I * sigma**2)","def reparameterize(self, mu, log_sigma):\n eps = tf.random.normal(shape=tf.shape(mu))\n return mu + tf.exp(log_sigma / 2) * eps","def prior_rho(store):\n if store['rho'] > 0. and store['rho'] < 1.0:\n alpha = 1.0\n beta = 1.0\n return (alpha - 1.) * log(store['rho']) + (beta - 1.) * \\\n log(1.-store['rho'])\n else:\n return -1E256","def gaussian(x, sigma):\n try: r = np.exp(-0.5*(x/sigma)**2) \n except: r = np.zeros(len(x))\n return r","def get_rate(sigma, dt=1*units.ns):\n return stats.norm.sf(sigma)/dt","def jeffreys(self, mu, sigma):\n return 1./sigma**3.","def _sigma_ee_rel(self,gam,eps):\n A = 1 - 8 / 3 * (gam - 1)**0.2 / (gam + 1) * (eps / gam)**(1./3.)\n\n return (self._sigma_1(gam,eps) + self._sigma_2(gam,eps)) * A","def sigma_R(field, scale):\n field_filtered = filter_Field(field, tophat_kernel, (scale,))\n return field_filtered.t.std()","def set_gaussian(self, X, sigma=0):\n sigma = float(sigma)\n if sigma < 0:\n raise ValueError('sigma should be positive')\n self.set_euclidian(X)\n d = self.weights\n\n if sigma == 0:\n sigma = (d ** 2).mean()\n\n w = np.exp(- (d ** 2) / (2 * sigma))\n self.weights = w","def sigma0_RG(self):\n sigma = np.sqrt(self.cosmo.gs_spectral_moment(l=0,RG=self.RG))\n return sigma","def sigmanorm(y):\n y = y.copy()\n y -= y.mean() # set to zero mean\n y /= y.std() # rescale to units of sigma\n return y","def sigmaz():\n return _SIGMAZ.copy()","def gaussion_smoothing(self,sigma=None):\n print(\"## Gaussian smoothing...\");\n corr_length = self.corr_length\n if sigma is None:\n corr = self.correlation\n oscillation=np.max(np.abs(corr[:-1]-corr[1:]),axis=0)\n peak=np.max(np.abs(corr),axis=0)\n oscillation /= peak\n sigma= corr_length/(5.0*oscillation*len(corr)*self.smooth_tune) # 15.0 has been tuned for many times \n print \"sigma:\"\n print sigma\n for i in np.arange(corr_length):\n self.correlation[i] *= exp(-i*i/(2*sigma*sigma))/(sigma*sqrt(2*pi))","def log_smear(x, sigma):\n return (\n -np.log(sigma) - 0.5*np.log(2*np.pi) - x**2 / (2*sigma**2)\n )","def _compute_stsigma(self):\n # S\n self.s = (np.log(1 - np.power(self.p2, 1 / (self.q * self.l))) - np.log(self.n_max)) / \\\n np.log(1 - (1 + self.r_dagger) / self.n_max)\n\n # sigma\n self.r = self._func_r(epsilon=self.epsilon / self.l,\n delta=self.delta_sharp)\n self.sigma = self.n * self.mu * self.g_dagger * self.r / self.lambda_ppsc\n\n # T\n self.phi_dagger = np.sqrt(self.dim)\n D, V = np.linalg.eig(self.A)\n D.sort()\n sigma_n_minus_one = D[-2]\n self.alpha_l = 1 / (self.l + 1)\n self.t = (np.log((1 - np.power(self.p1, 1 / self.l)) * self.v * self.alpha_l ** 4) -\n np.log(self.n * np.square(self.phi_dagger) + 2 * np.square(self.q) * np.square(self.s) * np.square(self.sigma)))\n self.t /= np.log(sigma_n_minus_one)\n\n # round\n self.s = int(self.s)\n self.t = int(self.t)","def posterior_loss(X, mu, sigma, log_pi):\r\n log_PDF = log_GaussPDF(X, mu, sigma)\r\n log_post = log_posterior(log_PDF, log_pi)\r\n\r\n loss = torch.logsumexp(log_post, dim=1)\r\n # loss = torch.exp(log_post)\r\n # loss = torch.sum(loss, dim=1)\r\n # loss = torch.log(loss)\r\n loss = torch.sum(loss)\r\n loss = -loss\r\n return loss","def kernel_sigma(n_kernels):\n sigmas = [0.001] # exact match small variance means exact match ?\n if n_kernels == 1:\n return sigmas\n return sigmas + [0.1] * (n_kernels - 1)","def __init__(self, sigma):\n self.sigma = float(sigma)\n super().__init__(domain=functional.domain,\n range=functional.domain, linear=False)\n\n # Setting up parameters\n self.const = 1 / (functional.epsilon * sigma)","def sigma_chromaticity(lbda, sigmaref, rho=-1/5., lbdaref=7000):\n return sigmaref * (lbda / lbdaref)**(rho)","def true_lrv_ma3_t_free(sigma: float): \n return (148 / 3) * (sigma ** 2)","def log_normal(x, mean, **kwargs):\n sigma = kwargs.get(\"sigma\")\n w = kwargs.get(\"w\")\n rho = kwargs.get(\"rho\")\n tau = kwargs.get(\"tau\")\n eps = kwargs.get(\"eps\", 0.0)\n check = sum(map(lambda a: a is not None, [sigma, w, rho, tau]))\n if check > 1:\n raise ValueError(\"more than one required kwarg is passed\")\n if check == 0:\n raise ValueError(\"none of required kwarg is passed\")\n if sigma is not None:\n std = sigma\n elif w is not None:\n std = pt.exp(w)\n elif rho is not None:\n std = rho2sigma(rho)\n else:\n std = tau ** (-1)\n std += f(eps)\n return f(c) - pt.log(pt.abs(std)) - (x - mean) ** 2 / (2.0 * std**2)","def sigma_delta(R, m_x, **kwargs):\n if R == 0:\n sigma = m_x\n else:\n sigma = np.zeros_like(m_x)\n\n return sigma","def __init__(self, sigma, multiplier=1e-1):\r\n super().__init__(multiplier=multiplier)\r\n self.sigma = sigma","def sigma(h,T):\r\n P = 1/(1+np.exp(-2*h/T)) #from the mean field results\r\n ll = len(h)\r\n rand = np.random.rand(ll)\r\n pos = np.where(P-rand>0)[0]\r\n r = -np.ones(ll)\r\n r[pos] = +1\r\n return r","def gaussian_sigma(t, params):\n t_final = tf.cast(params['t_final'].get_value(), dtype=tf.float64)\n sigma = tf.cast(params['sigma'].get_value(), dtype=tf.float64)\n gauss = tf.exp(-(t - t_final / 2) ** 2 / (2 * sigma ** 2))\n norm = (tf.sqrt(2 * np.pi * sigma ** 2)\n * tf.math.erf(t_final / (np.sqrt(8) * sigma))\n - t_final * tf.exp(-t_final ** 2 / (8 * sigma ** 2)))\n offset = tf.exp(-t_final ** 2 / (8 * sigma ** 2))\n return (gauss - offset) / norm","def Gaussian(x,t,sigma):\n return np.exp(-(x-t)**2/(2*sigma**2))","def compute_sigma_star_2(self, shape, array, j):\n array_lag = np.roll(array[:,j], 1)\n array_lag[0] = array[0,j]\n scale = (0.01 + sum((array[:,j] - array_lag)**2))**(-1)\n return invgamma.rvs(a = shape, scale = scale, size = 1)[0]","def get_sigma_dxdy(rs,x,Q2,F2,FL,F3,sign):\n global par\n y=Q2/(rs**2-par.M2)/x\n M2=par.M2\n YP=1+(1-y)**2\n YM=1-(1-y)**2\n thy=2*np.pi*par.alfa**2/x/y/Q2\n thy*=(YP+2*x**2*y**2*M2/Q2)*F2-y**2*FL+sign*YM*x*F3\n return thy","def Gausian_response(img,sigma=1):\n \n # Gausian response\n img_sigma = zeros(img.shape)\n filters.gaussian_filter(img, (sigma,sigma), (0,0), img_sigma)\n \n return img_sigma","def sigma(self, sigma_input):\n sigma_out = make_sigma.sigma_gen(self._parent.settings, sigma_input)\n # Assign to parent ICobj:\n self._parent.sigma = sigma_out\n print 'Sigma stored in <IC instance>.sigma'","def true_lrv_ar1_t_free(sigma: float):\n return (16 / 3) * (sigma ** 2)","def rho(x, rho1=1, sigma=1):\n d = rho1*((exp(x/sigma**2.)*erf(sqrt(x)/sigma))\n - (sqrt(4.*x/(pi*sigma**2.))*(1.+(2*x/(3.*sigma**2)))))\n return d","def sigma_0(n_n, tau):\n return n_n * e**2 * tau / m_e","def sigma(m):\n if(m <= 0):\n return 0\n else:\n return (m + sigma(m - 1))","def get_sigma_high_low_simulated(rate, simulation_name=\"NTU+cheb_1\"):\n def obj(sigma):\n return get_high_low_rate_simulated(sigma, simulation_name) - rate\n res = opt.brentq(obj, 0, 10)\n return res","def get_sigma_high_low(rate, dt=1 * units.ns, time_window_high_low=5 * units.ns):\n def obj(sigma):\n return get_high_low_rate(sigma, dt=dt, time_window_high_low=time_window_high_low) - rate\n res = opt.brentq(obj, 0, 10)\n return res","def calcu_noise_sigma(ts_data):\r\n ts_data_len = len(ts_data)\r\n if ts_data_len < 3:\r\n raise Exception('ts_data_len should be at least 3')\r\n y_ip1 = ts_data[2:]\r\n y_i = ts_data[1:-1]\r\n y_im1 = ts_data[:-2]\r\n sigma_n2 = (2.0 / (3 * len(y_ip1))) * sum(\r\n (0.5 * y_im1 - y_i + 0.5 * y_ip1)**2)\r\n sigma_n = np.sqrt(sigma_n2)\r\n # sigma_n = 1e-5 if sigma_n < 1e-5 else sigma_n\r\n minimal_sigma_n = 1e-6\r\n sigma_n = minimal_sigma_n if sigma_n < minimal_sigma_n else sigma_n\r\n return sigma_n","def sigma_nfw_fit(R, log10_mx, r_s, rho_x, **kwargs):\n m_x = 10**log10_mx\n r_x = tools.mass_to_radius(m_x, rho_x)\n c_x = r_x / r_s\n rho_s = m_x / (4 * np.pi * r_x**3) * c_x**3 / (np.log(1 + c_x) -\n c_x / (1 + c_x))\n\n prefactor = 2 * r_s * rho_s\n\n if R == r_s:\n sigma = 1. / 3 * prefactor\n\n elif R < r_s:\n x = R / r_s\n prefactor *= 1. / (x**2 - 1)\n sigma = prefactor * (1 - 2 / np.sqrt(1 - x**2) *\n np.arctanh(np.sqrt((1 - x) / (1 + x))))\n\n else:\n x = R / r_s\n prefactor *= 1. / (x**2 - 1)\n sigma = prefactor * (1 - 2 / np.sqrt(x**2 - 1) *\n np.arctan(np.sqrt((x - 1) / (x + 1))))\n\n return sigma","def rho(flag, S, K, t, r, sigma, q):\n\n b = r-q\n\n return numerical_rho(flag, S, K, t, r, sigma, b, f)","def bivariate_normal(x, mu, sigma, rho):\n\treturn (1. / (2. * math.pi * sigma[0] * sigma[1] * math.sqrt(1. - rho * rho))) * \\\n\t math.exp( (-1. / (2. * (1. - rho * rho))) * \\\n\t ( ( math.pow(x[0] - mu[0], 2) / sigma[0] * sigma[0] ) + \\\n\t ( math.pow(x[1] - mu[1], 2) / sigma[1] * sigma[1] ) - \\\n\t ( 2. * rho * (x[0] - mu[0]) * (x[1] - mu[1]) / (sigma[0] * sigma[1]) ) ) )","def gaussian_black(z, mu: 'normal' = 0, sigma: (0.4,1) = 0.7):\n return 1/(np.sqrt(2*np.pi)*sigma)*np.exp(-np.power((z - mu)/sigma, 2)/2)","def compute_gdp_mu(sampling_rate, sigma, steps):\n return sampling_rate * np.sqrt(steps * (np.exp(1 / sigma**2) - 1) )","def gaussian_decay(A, sigma, x, y):\n return A * math.exp(-((pow(x-16.,2.)/(2*pow(sigma,2)) + \\\n (pow(y-16.,2.)/(2*pow(sigma,2))))))","def fcn_sigma_rejection(x,srl=3,ni=3):\n x = x.astype(float)\n sizeX = np.shape(x)\n x = x.ravel()\n inliers = np.isfinite(x);\n for j in range(ni):\n newoutliers = (~inliers) & (~np.isnan(x));\n if ((j>0) & (~np.any(newoutliers))):\n break;\n sum_inliers = np.sum(inliers);\n if (sum_inliers < 3):\n break;\n x[newoutliers] = np.nan\n mu = np.nansum(x)/sum_inliers\n xms = (x-mu)**2\n sigma = np.sqrt(1./(sum_inliers-1)*np.nansum(xms))\n if (sigma == 0):\n break;\n inliers = (xms < (srl*sigma)**2)\n x = x[inliers]\n inliers = np.reshape(inliers,sizeX)\n return x,inliers","def kernel_gaussiano(image: np.ndarray, sigma: float, kind: str = 'low') -> np.ndarray:\n U, V = fourier_meshgrid(image)\n D = fourier_distance(U, V)\n H = np.exp( (-1.0 * D) / (2.0 * sigma**2) )\n \n if kind == 'high' or kind == 'highpass':\n H = 1.0 - H\n \n return H","def sigma_hat(frequency, sigma, epsilon=epsilon_0, quasistatic=False):\n if quasistatic is True:\n return sigma\n return sigma + 1j*omega(frequency)*epsilon","def ps(self, sigma, z):\n \n delta_c = self.params[0]\n \n return sqrt(2.e0/pi) * (delta_c/sigma) * exp( (-delta_c*delta_c)/(2.e0*sigma*sigma) )","def __init__(self, mu=None, sigma=1.):\n self.mu = mu\n self.sigmasqr = sigma**2","def der_gauss(shape,sigma):\r\n m,n = [(ss-1.)/2. for ss in shape]\r\n nx, ny = shape\r\n xv = np.linspace(-1, 1, nx)\r\n yv = np.linspace(-1, 1, ny)\r\n x1, y1 = np.meshgrid(xv, yv)\r\n \r\n \r\n h = np.exp( -(x1*x1 + y1*y1) / (2.*sigma*sigma) )\r\n h[ h < np.finfo(h.dtype).eps*h.max() ] = 0\r\n sumh = h.sum()\r\n if sumh != 0:\r\n h /= sumh\r\n gauss_x = -x1/sigma*sigma\r\n h1 = gauss_x * h\r\n return h1","def calculate_sigma(self, LLL_matrix, vy, prec=100):\n R = RealField(prec)\n z = (LLL_matrix.inverse()) * vy\n z_diff = []\n for elem in z:\n current_term = abs(R(elem - elem.round()))\n if current_term != 0:\n z_diff.append(current_term)\n return 1 if len(z_diff) == 0 else z_diff[-1]","def calculate_log_q_prior(theta, mu, rho):\n\n sigma = tf.nn.softplus(rho)\n log_qw = tm.log_gaussian(theta, mu, sigma)\n return tf.reduce_sum(log_qw)","def st(self, sigma, z):\n \n aa = self.params[0]\n a = self.params[1]\n p = self.params[2]\n delta_c = self.params[3]\n \n return aa * sqrt(2.e0*a/pi) * (delta_c/sigma) * exp( (-a*delta_c*delta_c) / (2.e0*sigma*sigma) )*(1.e0 + pow( ( (sigma*sigma)/(a*delta_c*delta_c) ) , p ))","def gabor(sigma, theta=0., lam=None, psi=0.0, gamma=1.0, ksize=None, removeDC=True):\n if ksize == None:\n ksize = sigma * 6\n ksize = int(ksize + 1 - ksize % 2)\n \n if lam == None:\n lam = sigma * 2.\n \n y, x = numpy.lib.index_tricks.nd_grid()[:ksize,:ksize] - ksize/2\n xp = x * cos(theta) + y * sin(theta)\n yp = -x * sin(theta) + y * cos(theta)\n gb = exp(- (xp**2 + gamma**2 * yp**2) / (2 * sigma**2)) * cos(2. * pi * xp / lam + psi)\n if removeDC:\n return gb - average(gb)\n else:\n return gb","def gauss_score(_r, _mu=0, _sigma=512):\n return np.exp(-(_r - _mu)**2 / (2*_sigma**2)) # / 2","def bn(x, e=1e-7):\n mu = np.mean(x)\n sigma2 = np.var(x)\n x_ = (x - mu) / np.sqrt(sigma2 + e)\n return x_","def __sig(x):\n return 1 / (1 + exp**(-x))","def normal_logprob(mu, sigma, z):\n normalization_constant = (-sigma.log() - 0.5 * np.log(2 * np.pi))\n square_term = -0.5 * ((z - mu) / sigma)**2\n logprob_vec = normalization_constant + square_term\n logprob = logprob_vec.sum(1)\n return logprob","def Sc(self, rho, mu, D_AB):\n return mu/(rho*D_AB)","def fspecial_gaussian(shape=(3, 3), sigma=0.5):\n m, n = [(ss - 1.) / 2. for ss in shape]\n y, x = np.ogrid[-m:m + 1, -n:n + 1]\n h = np.exp(-(x * x + y * y) / (2. * sigma * sigma))\n h[h < np.finfo(h.dtype).eps * h.max()] = 0\n sumh = h.sum()\n if sumh != 0:\n h /= sumh\n return h","def calculateGaussian(x, mean, stdev):\n\t\t\texponent = math.exp(-(math.pow(x-mean,2)/(2*math.pow(stdev,2))))\n\t\t\tvalue= (1 / (math.sqrt(2*math.pi) * stdev)) * exponent\n\t\t\tif value==0:\n\t\t\t\treturn np.nan\n\t\t\telse:\n\t\t\t\treturn math.log(value)","def gaussianPSF(shape, sigma):\n psf = dg.drawGaussiansXY(shape,\n numpy.array([0.5*shape[0]]),\n numpy.array([0.5*shape[1]]),\n sigma = sigma)\n return psf/numpy.sum(psf)","def maskBySigmas(self, sigma=2):\n\t\t# set up masking criteria\n\t\tself.avgFlux = np.mean(self.flux)\n\t\tself.stdFlux = np.std(self.flux)\n\n\t\tself.smoothFlux = self.flux\n\t\t# set the outliers as the flux below \n\t\tself.smoothFlux[self.smoothFlux <= self.avgFlux - sigma * self.stdFlux] = 0\n\t\t\n\t\tself.mask = np.where(self.smoothFlux <= 0)\n\t\tself.wave = np.delete(self.wave, list(self.mask))\n\t\tself.flux = np.delete(self.flux, list(self.mask))\n\t\tself.noise = np.delete(self.noise, list(self.mask))\n\t\tself.sky = np.delete(self.sky, list(self.mask))\n\t\tself.mask = self.mask[0]","def radius_gaussian(sq_r, sig, eps=1e-9):\n return torch.exp(-sq_r / (2 * sig**2 + eps))","def mean_sigma(h):\n h.Fit(\"gaus\", \"q\")\n result_fit = h.GetFunction(\"gaus\")\n mean = result_fit.GetParameter(1)\n sigma = result_fit.GetParameter(2)\n return mean, sigma","def sigma_gen(self):\n # Generate sigma\n sigma = make_sigma.sigma_gen(self._parent.settings)\n # Copy sigma to the parent (IC) object\n self._parent.sigma = sigma\n \n print 'Sigma stored in <IC instance>.sigma'","def normpdf(x, mu, sigma):\n return np.exp(-0.5 * ((x - mu) / sigma)**2) / (np.sqrt(2.0 * np.pi) * sigma)","def sigma_thermpollution(pollution_1, pollution_2, sigma, lyambda_wall): \n return (sigma / lyambda_wall) + (1 / pollution_1) + (1 / pollution_2)","def gaussian(x, mean, sigma):\n return np.exp(-np.square(x-mean)/(2*np.square(sigma))) / (np.sqrt(2*np.pi*sigma**2))","def sigma(self):\n with ops.name_scope(self.name):\n return self._cov.to_dense()","def gaussian(x, mu, sigma):\n return (np.exp(-(x - mu)**2 / 2.0 / sigma**2) /\n np.sqrt(2.0 * np.pi) / sigma)","def reduced_normal_pmf(x: np.array, mean: float, sigma: float) -> np.array:\n x = np.exp(-1 / 2 * ((x - mean) / sigma) ** 2)\n x /= np.sqrt(2 * np.pi * sigma ** 2)\n x[mean] = 0.\n x /= x.sum()\n return x","def posterior(mu, x, sigma):\n post = like(x, sigma, mu) * prior(mu)\n evidencia = np.trapz(post, mu)\n return post/evidencia"],"string":"[\n \"def rho2sigma(rho):\\n return pt.softplus(rho)\",\n \"def sigma2rho(sigma):\\n return pt.log(pt.exp(pt.abs(sigma)) - 1.0)\",\n \"def mbh_sigma(sigma):\\n _MASS = 8.32\\n _SLOPE = 5.64\\n _VEL = 200e5\\n\\n mbh = _MASS + _SLOPE*np.log10(sigma/_VEL)\\n mbh = np.power(10.0, mbh) * MSOL\\n return mbh\",\n \"def compute_sigma(\\n T,\\n S,\\n z,\\n **kwargs,\\n):\\n return compute_rho(T, S, z, **kwargs) - 1000\",\n \"def zeroLJForce(sigma):\\n return 2**(1/6) * sigma\",\n \"def compute_sigma0(\\n T,\\n S,\\n **kwargs,\\n):\\n return compute_rho(T, S, 0, **kwargs) - 1000\",\n \"def M_sigma(self):\\n\\n print(\\\"\\\", file=self.logfile)\\n print(\\\"Updating sigma_2\\\", file=self.logfile)\\n self.sigma2 = 1/self.L_h*(np.square(np.linalg.norm(self.w)) + np.trace(self.R))\",\n \"def const_sigma(self):\\n if self.sigma is None:\\n return (1 - 2 / self.eta) * np.eye(self.ndim)\\n else:\\n return np.array(self.sigma)\",\n \"def _sigma_ep(self,gam,eps):\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\")\\n return self._sigma_1(gam,eps)\",\n \"def _sigma_1(gam, eps):\\n s1 = 4 * r0**2 * alpha / eps / mec2_unit\\n s2 = 1 + (1./3. - eps/gam) * (1 - eps/gam)\\n s3 = np.log(2 * gam * (gam - eps) / eps) - 1./2.\\n s3[np.where(gam < eps)] = 0.0\\n return s1 * s2 * s3\",\n \"def _calc_sigma(self):\\n if self.data is None:\\n self._initial_blur()\\n previous = self.init_sigma\\n incr = 0\\n self.sigmas = [(previous, incr)]\\n for i in range(1, self.scale_per_octave + 3):\\n sigma_abs = self.init_sigma * (self.dest_sigma / self.init_sigma) ** (1.0 * i / (self.scale_per_octave))\\n increase = previous * sqrt((self.dest_sigma / self.init_sigma) ** (2.0 / self.scale_per_octave) - 1.0)\\n self.sigmas.append((sigma_abs, increase))\\n previous = sigma_abs\\n logger.debug(\\\"Sigma= %s\\\" % self.sigmas)\",\n \"def get_sigma_psf(self):\\n pass\",\n \"def post_rho(store):\\n return loglike(store) + prior_rho(store)\",\n \"def sigma(self):\\n return self.__sigma\",\n \"def true_lrv_ma1_t_free(sigma: float): \\n return (19 / 3) * (sigma ** 2)\",\n \"def _sigma_ee_nonrel(self,gam,eps):\\n s0 = 4 * r0**2 * alpha / (15 * eps)\\n x = 4 * eps / (gam**2 - 1)\\n sigma_nonrel = s0 * self._F(x,gam)\\n sigma_nonrel[np.where(eps >= 0.25*(gam**2 - 1.))] = 0.0\\n sigma_nonrel[np.where(gam*np.ones_like(eps) < 1.0)] = 0.0\\n return sigma_nonrel / mec2_unit\",\n \"def get_sigma(rate, dt=1 * units.ns):\\n return stats.norm.isf(rate * dt)\",\n \"def calculate_sigma(self, params):\\n ms = self.get_matrices(params)\\n m_beta = ms['Beta']\\n m_lambda = ms['Lambda']\\n m_psi = ms['Psi']\\n m_theta = ms['Theta']\\n\\n m_c = np.linalg.pinv(np.identity(m_beta.shape[0]) - m_beta)\\n return m_lambda @ m_c @ m_psi @ m_c.T @ m_lambda.T + m_theta\",\n \"def update_sigma(self):\\n self.sigma = self.spw.sigmaSpinBox.value()\",\n \"def _sigma(self, vect: Tensorlike):\\n return 40 * vect ** 3 / (self.thickness + 1) ** 4\",\n \"def _sigma(self, x):\\n\\n if self.jac is None: return 0\\n\\n return np.sqrt(\\n np.dot(\\n self.jac(x, *self.popt),\\n np.dot(\\n self.pcov,\\n np.transpose(self.jac(x, *self.popt)))))\",\n \"def sigma(x, a, b):\\n\\n def _sigma(d):\\n return SIGMA0 * d ** 2 * np.heaviside(d, 0)\\n\\n return _sigma(a - x) + _sigma(x - b)\",\n \"def _FWHMGauss(sigma, pixel=12):\\n return sigma*2*np.sqrt(2*np.log(2))*pixel\",\n \"def _sigma_inel(self, Tp):\\n L = np.log(Tp/self._Tth)\\n sigma = 30.7 - 0.96 * L + 0.18 * L ** 2\\n sigma *= (1 - (self._Tth / Tp) ** 1.9) ** 3\\n return sigma * 1e-27 # convert from mbarn to cm-2\",\n \"def jeffreys(self, sigma):\\n return 1. / sigma\",\n \"def __init__(self, sigma=0.0001):\\n self.sigma = sigma\",\n \"def clamp_sigma(self, sigma, sigma_min=.01):\\n self.logsigma.data.clamp_(np.log(sigma_min), np.log(sigma))\",\n \"def _sigma_2(gam, eps):\\n s0 = r0**2 * alpha / (3 * eps) / mec2_unit\\n\\n s1_1 = 16 * (1 - eps + eps**2) * np.log(gam / eps)\\n s1_2 = -1 / eps**2 + 3 / eps - 4 - 4 * eps - 8 * eps**2\\n s1_3 = -2 * (1 - 2 * eps) * np.log(1 - 2 * eps)\\n s1_4 = 1 / (4 * eps**3) - 1 / (2 * eps**2) + 3 / eps - 2 + 4 * eps\\n s1 = s1_1 + s1_2 + s1_3 * s1_4\\n\\n s2_1 = 2 / eps\\n s2_2 = (4 - 1 / eps + 1 / (4 * eps**2)) * np.log(2 * gam)\\n s2_3 = -2 + 2 / eps - 5 / (8 * eps**2)\\n s2 = s2_1 * (s2_2 + s2_3)\\n\\n return s0 * np.where(eps <= 0.5, s1, s2) * heaviside(gam - eps)\",\n \"def sampleGaussian(self, mu, log_sigma):\\n # reparameterization trick\\n epsilon = tf.random_normal(tf.shape(log_sigma), name=\\\"epsilon\\\")\\n return mu + epsilon * tf.exp(log_sigma) # N(mu, I * sigma**2)\",\n \"def reparameterize(self, mu, log_sigma):\\n eps = tf.random.normal(shape=tf.shape(mu))\\n return mu + tf.exp(log_sigma / 2) * eps\",\n \"def prior_rho(store):\\n if store['rho'] > 0. and store['rho'] < 1.0:\\n alpha = 1.0\\n beta = 1.0\\n return (alpha - 1.) * log(store['rho']) + (beta - 1.) * \\\\\\n log(1.-store['rho'])\\n else:\\n return -1E256\",\n \"def gaussian(x, sigma):\\n try: r = np.exp(-0.5*(x/sigma)**2) \\n except: r = np.zeros(len(x))\\n return r\",\n \"def get_rate(sigma, dt=1*units.ns):\\n return stats.norm.sf(sigma)/dt\",\n \"def jeffreys(self, mu, sigma):\\n return 1./sigma**3.\",\n \"def _sigma_ee_rel(self,gam,eps):\\n A = 1 - 8 / 3 * (gam - 1)**0.2 / (gam + 1) * (eps / gam)**(1./3.)\\n\\n return (self._sigma_1(gam,eps) + self._sigma_2(gam,eps)) * A\",\n \"def sigma_R(field, scale):\\n field_filtered = filter_Field(field, tophat_kernel, (scale,))\\n return field_filtered.t.std()\",\n \"def set_gaussian(self, X, sigma=0):\\n sigma = float(sigma)\\n if sigma < 0:\\n raise ValueError('sigma should be positive')\\n self.set_euclidian(X)\\n d = self.weights\\n\\n if sigma == 0:\\n sigma = (d ** 2).mean()\\n\\n w = np.exp(- (d ** 2) / (2 * sigma))\\n self.weights = w\",\n \"def sigma0_RG(self):\\n sigma = np.sqrt(self.cosmo.gs_spectral_moment(l=0,RG=self.RG))\\n return sigma\",\n \"def sigmanorm(y):\\n y = y.copy()\\n y -= y.mean() # set to zero mean\\n y /= y.std() # rescale to units of sigma\\n return y\",\n \"def sigmaz():\\n return _SIGMAZ.copy()\",\n \"def gaussion_smoothing(self,sigma=None):\\n print(\\\"## Gaussian smoothing...\\\");\\n corr_length = self.corr_length\\n if sigma is None:\\n corr = self.correlation\\n oscillation=np.max(np.abs(corr[:-1]-corr[1:]),axis=0)\\n peak=np.max(np.abs(corr),axis=0)\\n oscillation /= peak\\n sigma= corr_length/(5.0*oscillation*len(corr)*self.smooth_tune) # 15.0 has been tuned for many times \\n print \\\"sigma:\\\"\\n print sigma\\n for i in np.arange(corr_length):\\n self.correlation[i] *= exp(-i*i/(2*sigma*sigma))/(sigma*sqrt(2*pi))\",\n \"def log_smear(x, sigma):\\n return (\\n -np.log(sigma) - 0.5*np.log(2*np.pi) - x**2 / (2*sigma**2)\\n )\",\n \"def _compute_stsigma(self):\\n # S\\n self.s = (np.log(1 - np.power(self.p2, 1 / (self.q * self.l))) - np.log(self.n_max)) / \\\\\\n np.log(1 - (1 + self.r_dagger) / self.n_max)\\n\\n # sigma\\n self.r = self._func_r(epsilon=self.epsilon / self.l,\\n delta=self.delta_sharp)\\n self.sigma = self.n * self.mu * self.g_dagger * self.r / self.lambda_ppsc\\n\\n # T\\n self.phi_dagger = np.sqrt(self.dim)\\n D, V = np.linalg.eig(self.A)\\n D.sort()\\n sigma_n_minus_one = D[-2]\\n self.alpha_l = 1 / (self.l + 1)\\n self.t = (np.log((1 - np.power(self.p1, 1 / self.l)) * self.v * self.alpha_l ** 4) -\\n np.log(self.n * np.square(self.phi_dagger) + 2 * np.square(self.q) * np.square(self.s) * np.square(self.sigma)))\\n self.t /= np.log(sigma_n_minus_one)\\n\\n # round\\n self.s = int(self.s)\\n self.t = int(self.t)\",\n \"def posterior_loss(X, mu, sigma, log_pi):\\r\\n log_PDF = log_GaussPDF(X, mu, sigma)\\r\\n log_post = log_posterior(log_PDF, log_pi)\\r\\n\\r\\n loss = torch.logsumexp(log_post, dim=1)\\r\\n # loss = torch.exp(log_post)\\r\\n # loss = torch.sum(loss, dim=1)\\r\\n # loss = torch.log(loss)\\r\\n loss = torch.sum(loss)\\r\\n loss = -loss\\r\\n return loss\",\n \"def kernel_sigma(n_kernels):\\n sigmas = [0.001] # exact match small variance means exact match ?\\n if n_kernels == 1:\\n return sigmas\\n return sigmas + [0.1] * (n_kernels - 1)\",\n \"def __init__(self, sigma):\\n self.sigma = float(sigma)\\n super().__init__(domain=functional.domain,\\n range=functional.domain, linear=False)\\n\\n # Setting up parameters\\n self.const = 1 / (functional.epsilon * sigma)\",\n \"def sigma_chromaticity(lbda, sigmaref, rho=-1/5., lbdaref=7000):\\n return sigmaref * (lbda / lbdaref)**(rho)\",\n \"def true_lrv_ma3_t_free(sigma: float): \\n return (148 / 3) * (sigma ** 2)\",\n \"def log_normal(x, mean, **kwargs):\\n sigma = kwargs.get(\\\"sigma\\\")\\n w = kwargs.get(\\\"w\\\")\\n rho = kwargs.get(\\\"rho\\\")\\n tau = kwargs.get(\\\"tau\\\")\\n eps = kwargs.get(\\\"eps\\\", 0.0)\\n check = sum(map(lambda a: a is not None, [sigma, w, rho, tau]))\\n if check > 1:\\n raise ValueError(\\\"more than one required kwarg is passed\\\")\\n if check == 0:\\n raise ValueError(\\\"none of required kwarg is passed\\\")\\n if sigma is not None:\\n std = sigma\\n elif w is not None:\\n std = pt.exp(w)\\n elif rho is not None:\\n std = rho2sigma(rho)\\n else:\\n std = tau ** (-1)\\n std += f(eps)\\n return f(c) - pt.log(pt.abs(std)) - (x - mean) ** 2 / (2.0 * std**2)\",\n \"def sigma_delta(R, m_x, **kwargs):\\n if R == 0:\\n sigma = m_x\\n else:\\n sigma = np.zeros_like(m_x)\\n\\n return sigma\",\n \"def __init__(self, sigma, multiplier=1e-1):\\r\\n super().__init__(multiplier=multiplier)\\r\\n self.sigma = sigma\",\n \"def sigma(h,T):\\r\\n P = 1/(1+np.exp(-2*h/T)) #from the mean field results\\r\\n ll = len(h)\\r\\n rand = np.random.rand(ll)\\r\\n pos = np.where(P-rand>0)[0]\\r\\n r = -np.ones(ll)\\r\\n r[pos] = +1\\r\\n return r\",\n \"def gaussian_sigma(t, params):\\n t_final = tf.cast(params['t_final'].get_value(), dtype=tf.float64)\\n sigma = tf.cast(params['sigma'].get_value(), dtype=tf.float64)\\n gauss = tf.exp(-(t - t_final / 2) ** 2 / (2 * sigma ** 2))\\n norm = (tf.sqrt(2 * np.pi * sigma ** 2)\\n * tf.math.erf(t_final / (np.sqrt(8) * sigma))\\n - t_final * tf.exp(-t_final ** 2 / (8 * sigma ** 2)))\\n offset = tf.exp(-t_final ** 2 / (8 * sigma ** 2))\\n return (gauss - offset) / norm\",\n \"def Gaussian(x,t,sigma):\\n return np.exp(-(x-t)**2/(2*sigma**2))\",\n \"def compute_sigma_star_2(self, shape, array, j):\\n array_lag = np.roll(array[:,j], 1)\\n array_lag[0] = array[0,j]\\n scale = (0.01 + sum((array[:,j] - array_lag)**2))**(-1)\\n return invgamma.rvs(a = shape, scale = scale, size = 1)[0]\",\n \"def get_sigma_dxdy(rs,x,Q2,F2,FL,F3,sign):\\n global par\\n y=Q2/(rs**2-par.M2)/x\\n M2=par.M2\\n YP=1+(1-y)**2\\n YM=1-(1-y)**2\\n thy=2*np.pi*par.alfa**2/x/y/Q2\\n thy*=(YP+2*x**2*y**2*M2/Q2)*F2-y**2*FL+sign*YM*x*F3\\n return thy\",\n \"def Gausian_response(img,sigma=1):\\n \\n # Gausian response\\n img_sigma = zeros(img.shape)\\n filters.gaussian_filter(img, (sigma,sigma), (0,0), img_sigma)\\n \\n return img_sigma\",\n \"def sigma(self, sigma_input):\\n sigma_out = make_sigma.sigma_gen(self._parent.settings, sigma_input)\\n # Assign to parent ICobj:\\n self._parent.sigma = sigma_out\\n print 'Sigma stored in <IC instance>.sigma'\",\n \"def true_lrv_ar1_t_free(sigma: float):\\n return (16 / 3) * (sigma ** 2)\",\n \"def rho(x, rho1=1, sigma=1):\\n d = rho1*((exp(x/sigma**2.)*erf(sqrt(x)/sigma))\\n - (sqrt(4.*x/(pi*sigma**2.))*(1.+(2*x/(3.*sigma**2)))))\\n return d\",\n \"def sigma_0(n_n, tau):\\n return n_n * e**2 * tau / m_e\",\n \"def sigma(m):\\n if(m <= 0):\\n return 0\\n else:\\n return (m + sigma(m - 1))\",\n \"def get_sigma_high_low_simulated(rate, simulation_name=\\\"NTU+cheb_1\\\"):\\n def obj(sigma):\\n return get_high_low_rate_simulated(sigma, simulation_name) - rate\\n res = opt.brentq(obj, 0, 10)\\n return res\",\n \"def get_sigma_high_low(rate, dt=1 * units.ns, time_window_high_low=5 * units.ns):\\n def obj(sigma):\\n return get_high_low_rate(sigma, dt=dt, time_window_high_low=time_window_high_low) - rate\\n res = opt.brentq(obj, 0, 10)\\n return res\",\n \"def calcu_noise_sigma(ts_data):\\r\\n ts_data_len = len(ts_data)\\r\\n if ts_data_len < 3:\\r\\n raise Exception('ts_data_len should be at least 3')\\r\\n y_ip1 = ts_data[2:]\\r\\n y_i = ts_data[1:-1]\\r\\n y_im1 = ts_data[:-2]\\r\\n sigma_n2 = (2.0 / (3 * len(y_ip1))) * sum(\\r\\n (0.5 * y_im1 - y_i + 0.5 * y_ip1)**2)\\r\\n sigma_n = np.sqrt(sigma_n2)\\r\\n # sigma_n = 1e-5 if sigma_n < 1e-5 else sigma_n\\r\\n minimal_sigma_n = 1e-6\\r\\n sigma_n = minimal_sigma_n if sigma_n < minimal_sigma_n else sigma_n\\r\\n return sigma_n\",\n \"def sigma_nfw_fit(R, log10_mx, r_s, rho_x, **kwargs):\\n m_x = 10**log10_mx\\n r_x = tools.mass_to_radius(m_x, rho_x)\\n c_x = r_x / r_s\\n rho_s = m_x / (4 * np.pi * r_x**3) * c_x**3 / (np.log(1 + c_x) -\\n c_x / (1 + c_x))\\n\\n prefactor = 2 * r_s * rho_s\\n\\n if R == r_s:\\n sigma = 1. / 3 * prefactor\\n\\n elif R < r_s:\\n x = R / r_s\\n prefactor *= 1. / (x**2 - 1)\\n sigma = prefactor * (1 - 2 / np.sqrt(1 - x**2) *\\n np.arctanh(np.sqrt((1 - x) / (1 + x))))\\n\\n else:\\n x = R / r_s\\n prefactor *= 1. / (x**2 - 1)\\n sigma = prefactor * (1 - 2 / np.sqrt(x**2 - 1) *\\n np.arctan(np.sqrt((x - 1) / (x + 1))))\\n\\n return sigma\",\n \"def rho(flag, S, K, t, r, sigma, q):\\n\\n b = r-q\\n\\n return numerical_rho(flag, S, K, t, r, sigma, b, f)\",\n \"def bivariate_normal(x, mu, sigma, rho):\\n\\treturn (1. / (2. * math.pi * sigma[0] * sigma[1] * math.sqrt(1. - rho * rho))) * \\\\\\n\\t math.exp( (-1. / (2. * (1. - rho * rho))) * \\\\\\n\\t ( ( math.pow(x[0] - mu[0], 2) / sigma[0] * sigma[0] ) + \\\\\\n\\t ( math.pow(x[1] - mu[1], 2) / sigma[1] * sigma[1] ) - \\\\\\n\\t ( 2. * rho * (x[0] - mu[0]) * (x[1] - mu[1]) / (sigma[0] * sigma[1]) ) ) )\",\n \"def gaussian_black(z, mu: 'normal' = 0, sigma: (0.4,1) = 0.7):\\n return 1/(np.sqrt(2*np.pi)*sigma)*np.exp(-np.power((z - mu)/sigma, 2)/2)\",\n \"def compute_gdp_mu(sampling_rate, sigma, steps):\\n return sampling_rate * np.sqrt(steps * (np.exp(1 / sigma**2) - 1) )\",\n \"def gaussian_decay(A, sigma, x, y):\\n return A * math.exp(-((pow(x-16.,2.)/(2*pow(sigma,2)) + \\\\\\n (pow(y-16.,2.)/(2*pow(sigma,2))))))\",\n \"def fcn_sigma_rejection(x,srl=3,ni=3):\\n x = x.astype(float)\\n sizeX = np.shape(x)\\n x = x.ravel()\\n inliers = np.isfinite(x);\\n for j in range(ni):\\n newoutliers = (~inliers) & (~np.isnan(x));\\n if ((j>0) & (~np.any(newoutliers))):\\n break;\\n sum_inliers = np.sum(inliers);\\n if (sum_inliers < 3):\\n break;\\n x[newoutliers] = np.nan\\n mu = np.nansum(x)/sum_inliers\\n xms = (x-mu)**2\\n sigma = np.sqrt(1./(sum_inliers-1)*np.nansum(xms))\\n if (sigma == 0):\\n break;\\n inliers = (xms < (srl*sigma)**2)\\n x = x[inliers]\\n inliers = np.reshape(inliers,sizeX)\\n return x,inliers\",\n \"def kernel_gaussiano(image: np.ndarray, sigma: float, kind: str = 'low') -> np.ndarray:\\n U, V = fourier_meshgrid(image)\\n D = fourier_distance(U, V)\\n H = np.exp( (-1.0 * D) / (2.0 * sigma**2) )\\n \\n if kind == 'high' or kind == 'highpass':\\n H = 1.0 - H\\n \\n return H\",\n \"def sigma_hat(frequency, sigma, epsilon=epsilon_0, quasistatic=False):\\n if quasistatic is True:\\n return sigma\\n return sigma + 1j*omega(frequency)*epsilon\",\n \"def ps(self, sigma, z):\\n \\n delta_c = self.params[0]\\n \\n return sqrt(2.e0/pi) * (delta_c/sigma) * exp( (-delta_c*delta_c)/(2.e0*sigma*sigma) )\",\n \"def __init__(self, mu=None, sigma=1.):\\n self.mu = mu\\n self.sigmasqr = sigma**2\",\n \"def der_gauss(shape,sigma):\\r\\n m,n = [(ss-1.)/2. for ss in shape]\\r\\n nx, ny = shape\\r\\n xv = np.linspace(-1, 1, nx)\\r\\n yv = np.linspace(-1, 1, ny)\\r\\n x1, y1 = np.meshgrid(xv, yv)\\r\\n \\r\\n \\r\\n h = np.exp( -(x1*x1 + y1*y1) / (2.*sigma*sigma) )\\r\\n h[ h < np.finfo(h.dtype).eps*h.max() ] = 0\\r\\n sumh = h.sum()\\r\\n if sumh != 0:\\r\\n h /= sumh\\r\\n gauss_x = -x1/sigma*sigma\\r\\n h1 = gauss_x * h\\r\\n return h1\",\n \"def calculate_sigma(self, LLL_matrix, vy, prec=100):\\n R = RealField(prec)\\n z = (LLL_matrix.inverse()) * vy\\n z_diff = []\\n for elem in z:\\n current_term = abs(R(elem - elem.round()))\\n if current_term != 0:\\n z_diff.append(current_term)\\n return 1 if len(z_diff) == 0 else z_diff[-1]\",\n \"def calculate_log_q_prior(theta, mu, rho):\\n\\n sigma = tf.nn.softplus(rho)\\n log_qw = tm.log_gaussian(theta, mu, sigma)\\n return tf.reduce_sum(log_qw)\",\n \"def st(self, sigma, z):\\n \\n aa = self.params[0]\\n a = self.params[1]\\n p = self.params[2]\\n delta_c = self.params[3]\\n \\n return aa * sqrt(2.e0*a/pi) * (delta_c/sigma) * exp( (-a*delta_c*delta_c) / (2.e0*sigma*sigma) )*(1.e0 + pow( ( (sigma*sigma)/(a*delta_c*delta_c) ) , p ))\",\n \"def gabor(sigma, theta=0., lam=None, psi=0.0, gamma=1.0, ksize=None, removeDC=True):\\n if ksize == None:\\n ksize = sigma * 6\\n ksize = int(ksize + 1 - ksize % 2)\\n \\n if lam == None:\\n lam = sigma * 2.\\n \\n y, x = numpy.lib.index_tricks.nd_grid()[:ksize,:ksize] - ksize/2\\n xp = x * cos(theta) + y * sin(theta)\\n yp = -x * sin(theta) + y * cos(theta)\\n gb = exp(- (xp**2 + gamma**2 * yp**2) / (2 * sigma**2)) * cos(2. * pi * xp / lam + psi)\\n if removeDC:\\n return gb - average(gb)\\n else:\\n return gb\",\n \"def gauss_score(_r, _mu=0, _sigma=512):\\n return np.exp(-(_r - _mu)**2 / (2*_sigma**2)) # / 2\",\n \"def bn(x, e=1e-7):\\n mu = np.mean(x)\\n sigma2 = np.var(x)\\n x_ = (x - mu) / np.sqrt(sigma2 + e)\\n return x_\",\n \"def __sig(x):\\n return 1 / (1 + exp**(-x))\",\n \"def normal_logprob(mu, sigma, z):\\n normalization_constant = (-sigma.log() - 0.5 * np.log(2 * np.pi))\\n square_term = -0.5 * ((z - mu) / sigma)**2\\n logprob_vec = normalization_constant + square_term\\n logprob = logprob_vec.sum(1)\\n return logprob\",\n \"def Sc(self, rho, mu, D_AB):\\n return mu/(rho*D_AB)\",\n \"def fspecial_gaussian(shape=(3, 3), sigma=0.5):\\n m, n = [(ss - 1.) / 2. for ss in shape]\\n y, x = np.ogrid[-m:m + 1, -n:n + 1]\\n h = np.exp(-(x * x + y * y) / (2. * sigma * sigma))\\n h[h < np.finfo(h.dtype).eps * h.max()] = 0\\n sumh = h.sum()\\n if sumh != 0:\\n h /= sumh\\n return h\",\n \"def calculateGaussian(x, mean, stdev):\\n\\t\\t\\texponent = math.exp(-(math.pow(x-mean,2)/(2*math.pow(stdev,2))))\\n\\t\\t\\tvalue= (1 / (math.sqrt(2*math.pi) * stdev)) * exponent\\n\\t\\t\\tif value==0:\\n\\t\\t\\t\\treturn np.nan\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn math.log(value)\",\n \"def gaussianPSF(shape, sigma):\\n psf = dg.drawGaussiansXY(shape,\\n numpy.array([0.5*shape[0]]),\\n numpy.array([0.5*shape[1]]),\\n sigma = sigma)\\n return psf/numpy.sum(psf)\",\n \"def maskBySigmas(self, sigma=2):\\n\\t\\t# set up masking criteria\\n\\t\\tself.avgFlux = np.mean(self.flux)\\n\\t\\tself.stdFlux = np.std(self.flux)\\n\\n\\t\\tself.smoothFlux = self.flux\\n\\t\\t# set the outliers as the flux below \\n\\t\\tself.smoothFlux[self.smoothFlux <= self.avgFlux - sigma * self.stdFlux] = 0\\n\\t\\t\\n\\t\\tself.mask = np.where(self.smoothFlux <= 0)\\n\\t\\tself.wave = np.delete(self.wave, list(self.mask))\\n\\t\\tself.flux = np.delete(self.flux, list(self.mask))\\n\\t\\tself.noise = np.delete(self.noise, list(self.mask))\\n\\t\\tself.sky = np.delete(self.sky, list(self.mask))\\n\\t\\tself.mask = self.mask[0]\",\n \"def radius_gaussian(sq_r, sig, eps=1e-9):\\n return torch.exp(-sq_r / (2 * sig**2 + eps))\",\n \"def mean_sigma(h):\\n h.Fit(\\\"gaus\\\", \\\"q\\\")\\n result_fit = h.GetFunction(\\\"gaus\\\")\\n mean = result_fit.GetParameter(1)\\n sigma = result_fit.GetParameter(2)\\n return mean, sigma\",\n \"def sigma_gen(self):\\n # Generate sigma\\n sigma = make_sigma.sigma_gen(self._parent.settings)\\n # Copy sigma to the parent (IC) object\\n self._parent.sigma = sigma\\n \\n print 'Sigma stored in <IC instance>.sigma'\",\n \"def normpdf(x, mu, sigma):\\n return np.exp(-0.5 * ((x - mu) / sigma)**2) / (np.sqrt(2.0 * np.pi) * sigma)\",\n \"def sigma_thermpollution(pollution_1, pollution_2, sigma, lyambda_wall): \\n return (sigma / lyambda_wall) + (1 / pollution_1) + (1 / pollution_2)\",\n \"def gaussian(x, mean, sigma):\\n return np.exp(-np.square(x-mean)/(2*np.square(sigma))) / (np.sqrt(2*np.pi*sigma**2))\",\n \"def sigma(self):\\n with ops.name_scope(self.name):\\n return self._cov.to_dense()\",\n \"def gaussian(x, mu, sigma):\\n return (np.exp(-(x - mu)**2 / 2.0 / sigma**2) /\\n np.sqrt(2.0 * np.pi) / sigma)\",\n \"def reduced_normal_pmf(x: np.array, mean: float, sigma: float) -> np.array:\\n x = np.exp(-1 / 2 * ((x - mean) / sigma) ** 2)\\n x /= np.sqrt(2 * np.pi * sigma ** 2)\\n x[mean] = 0.\\n x /= x.sum()\\n return x\",\n \"def posterior(mu, x, sigma):\\n post = like(x, sigma, mu) * prior(mu)\\n evidencia = np.trapz(post, mu)\\n return post/evidencia\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.735956","0.7310387","0.6823238","0.6799738","0.66822535","0.66129714","0.65858775","0.6508815","0.6486363","0.6454253","0.6414886","0.6321964","0.6282718","0.6269426","0.6257471","0.624839","0.6226637","0.61909837","0.6161841","0.6161265","0.6147177","0.6115642","0.6098141","0.60849553","0.6042485","0.6031311","0.5993595","0.59875107","0.5983748","0.59721714","0.59699357","0.59678614","0.59652483","0.59555286","0.5949191","0.59454685","0.5934575","0.59292936","0.5925242","0.59232455","0.5916935","0.5892463","0.5888622","0.5882582","0.58814806","0.58652586","0.58621675","0.58524275","0.5836533","0.58347553","0.58160645","0.58100563","0.57754755","0.5767548","0.57568526","0.5743249","0.5729867","0.57297134","0.5722648","0.5721963","0.5721881","0.5715709","0.57080036","0.5698535","0.56766117","0.5668818","0.56651103","0.5652852","0.5651359","0.5649137","0.56471705","0.56400526","0.56369835","0.56315726","0.56112874","0.56024665","0.5601629","0.56009644","0.55948436","0.5584245","0.55803055","0.5579919","0.55763733","0.55707586","0.55655473","0.556343","0.55607176","0.5557594","0.5554144","0.5548668","0.5537521","0.5531356","0.55285513","0.5527481","0.552744","0.55252236","0.5523661","0.551819","0.5510555","0.5510468"],"string":"[\n \"0.735956\",\n \"0.7310387\",\n \"0.6823238\",\n \"0.6799738\",\n \"0.66822535\",\n \"0.66129714\",\n \"0.65858775\",\n \"0.6508815\",\n \"0.6486363\",\n \"0.6454253\",\n \"0.6414886\",\n \"0.6321964\",\n \"0.6282718\",\n \"0.6269426\",\n \"0.6257471\",\n \"0.624839\",\n \"0.6226637\",\n \"0.61909837\",\n \"0.6161841\",\n \"0.6161265\",\n \"0.6147177\",\n \"0.6115642\",\n \"0.6098141\",\n \"0.60849553\",\n \"0.6042485\",\n \"0.6031311\",\n \"0.5993595\",\n \"0.59875107\",\n \"0.5983748\",\n \"0.59721714\",\n \"0.59699357\",\n \"0.59678614\",\n \"0.59652483\",\n \"0.59555286\",\n \"0.5949191\",\n \"0.59454685\",\n \"0.5934575\",\n \"0.59292936\",\n \"0.5925242\",\n \"0.59232455\",\n \"0.5916935\",\n \"0.5892463\",\n \"0.5888622\",\n \"0.5882582\",\n \"0.58814806\",\n \"0.58652586\",\n \"0.58621675\",\n \"0.58524275\",\n \"0.5836533\",\n \"0.58347553\",\n \"0.58160645\",\n \"0.58100563\",\n \"0.57754755\",\n \"0.5767548\",\n \"0.57568526\",\n \"0.5743249\",\n \"0.5729867\",\n \"0.57297134\",\n \"0.5722648\",\n \"0.5721963\",\n \"0.5721881\",\n \"0.5715709\",\n \"0.57080036\",\n \"0.5698535\",\n \"0.56766117\",\n \"0.5668818\",\n \"0.56651103\",\n \"0.5652852\",\n \"0.5651359\",\n \"0.5649137\",\n \"0.56471705\",\n \"0.56400526\",\n \"0.56369835\",\n \"0.56315726\",\n \"0.56112874\",\n \"0.56024665\",\n \"0.5601629\",\n \"0.56009644\",\n \"0.55948436\",\n \"0.5584245\",\n \"0.55803055\",\n \"0.5579919\",\n \"0.55763733\",\n \"0.55707586\",\n \"0.55655473\",\n \"0.556343\",\n \"0.55607176\",\n \"0.5557594\",\n \"0.5554144\",\n \"0.5548668\",\n \"0.5537521\",\n \"0.5531356\",\n \"0.55285513\",\n \"0.5527481\",\n \"0.552744\",\n \"0.55252236\",\n \"0.5523661\",\n \"0.551819\",\n \"0.5510555\",\n \"0.5510468\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6352347"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":91998,"cells":{"query":{"kind":"string","value":"Set the priors and initialize surrogate posteriors of Bayesian NN with Empirical Bayes MOPED (Model Priors with Empirical Bayes using Deterministic DNN) Example implementation for Bayesian model with variational layers."},"document":{"kind":"string","value":"def MOPED(model, det_model, det_checkpoint, delta):\n det_model.load_state_dict(torch.load(det_checkpoint))\n for (idx, layer), (det_idx,\n det_layer) in zip(enumerate(model.modules()),\n enumerate(det_model.modules())):\n if (str(layer) == 'Conv1dReparameterization()'\n or str(layer) == 'Conv2dReparameterization()'\n or str(layer) == 'Conv3dReparameterization()'\n or str(layer) == 'ConvTranspose1dReparameterization()'\n or str(layer) == 'ConvTranspose2dReparameterization()'\n or str(layer) == 'ConvTranspose3dReparameterization()'\n or str(layer) == 'Conv1dFlipout()'\n or str(layer) == 'Conv2dFlipout()'\n or str(layer) == 'Conv3dFlipout()'\n or str(layer) == 'ConvTranspose1dFlipout()'\n or str(layer) == 'ConvTranspose2dFlipout()'\n or str(layer) == 'ConvTranspose3dFlipout()'):\n #set the priors\n layer.prior_weight_mu = det_layer.weight.data\n if layer.prior_bias_mu is not None:\n layer.prior_bias_mu = det_layer.bias.data\n\n #initialize surrogate posteriors\n layer.mu_kernel.data = det_layer.weight.data\n layer.rho_kernel.data = get_rho(det_layer.weight.data, delta)\n if layer.mu_bias is not None:\n layer.mu_bias.data = det_layer.bias.data\n layer.rho_bias.data = get_rho(det_layer.bias.data, delta)\n elif (str(layer) == 'LinearReparameterization()'\n or str(layer) == 'LinearFlipout()'):\n #set the priors\n layer.prior_weight_mu = det_layer.weight.data\n if layer.prior_bias_mu is not None:\n layer.prior_bias_mu.data = det_layer.bias\n\n #initialize the surrogate posteriors\n layer.mu_weight.data = det_layer.weight.data\n layer.rho_weight.data = get_rho(det_layer.weight.data, delta)\n if layer.mu_bias is not None:\n layer.mu_bias.data = det_layer.bias.data\n layer.rho_bias.data = get_rho(det_layer.bias.data, delta)\n\n elif str(layer).startswith('Batch'):\n #initialize parameters\n layer.weight.data = det_layer.weight.data\n if layer.bias is not None:\n layer.bias.data = det_layer.bias\n layer.running_mean.data = det_layer.running_mean.data\n layer.running_var.data = det_layer.running_var.data\n layer.num_batches_tracked.data = det_layer.num_batches_tracked.data\n\n model.state_dict()\n return model"},"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 init_bn(bn):\n \n bn.bias.data.fill_(0.)\n bn.running_mean.data.fill_(0.)\n bn.weight.data.fill_(1.)\n bn.running_var.data.fill_(1.)","def naiveBayes(train_set, train_labels, dev_set, smoothing_parameter, pos_prior):\n # TODO: Write your code here\n # return predicted labels of development set\n #\n ### len(train_set) 8000, len(dev) = 5000 P(pos) = 0.8 \n #### 0.55, 4.0, 0.30 ----------- 0.766\n #### 0.25 3.5 0.3 -------------- 0.766\n print(pos_prior)\n smoothing_parameter = 3.5\n pos_total_word = 0\n neg_total_word = 0\n pos_word_dict = {}\n neg_word_dict = {}\n dicts = [neg_word_dict, pos_word_dict]\n for i, sentence in enumerate(train_set):\n\n if train_labels[i] == 1: # positive reviews\n for word in sentence:\n pos_total_word += 1 \n if word in stop_words:\n continue\n if word in pos_word_dict:\n pos_word_dict[word] += 1\n else :\n pos_word_dict[word] = 1\n\n else: # negative reviews\n for word in sentence:\n neg_total_word += 1 \n if word in stop_words:\n continue\n if word in neg_word_dict:\n neg_word_dict[word] += 1\n else :\n neg_word_dict[word] = 1\n\n\n prob = {}\n denominator_pos = pos_total_word + smoothing_parameter * (len(pos_word_dict) + 1)\n denominator_neg = neg_total_word + smoothing_parameter * (len(neg_word_dict) + 1)\n de = [denominator_neg, denominator_pos]\n\n for t, dictionary in enumerate(dicts):\n for key, value in dictionary.items():\n if key not in prob:\n prob[key] = {0 : 0, 1 : 0}\n if smoothing_parameter != 0:\n prob[key][1 - t] = -1 * np.log(smoothing_parameter / de[t]) \n # print(prob[key][1 - t])\n\n prob[key][t] = -1 * np.log((value + smoothing_parameter) / de[t]) \n \n\n revised_prob = {}\n for key, value in prob.items():\n if np.abs(value[0] - value[1]) >= 0.25:\n revised_prob[key] = value \n\n print(len(revised_prob))\n\n dev_labels = []\n num_0 = 0\n for i, sentence in enumerate(dev_set):\n pos_odd = -1 * np.log(pos_prior)\n neg_odd = -1 * np.log(1.0 - pos_prior)\n for word in sentence:\n if word in revised_prob:\n pos_odd += revised_prob[word][1]\n neg_odd += revised_prob[word][0]\n \n if pos_odd > neg_odd:\n num_0 += 1\n dev_labels.append(1 if pos_odd <= neg_odd else 0)\n print(num_0)\n\n \n #### bigram model \n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n return dev_labels","def naiveBayesMixture(train_set, train_labels, dev_set, bigram_lambda,unigram_smoothing_parameter, bigram_smoothing_parameter, pos_prior):\n\n # TODO: Write your code here\n # return predicted labels of development set\n\n # counters for Training Phase\n ham = Counter()\n ham_bi = Counter()\n spam = Counter()\n spam_bi = Counter()\n\n for string, label in zip(train_set, train_labels):\n for i in range(len(string)):\n word = string[i]\n if i != len(string)-1:\n word_bi = string[i] + ' ' + string[i+1]\n if label == 1:\n ham_bi.update({word_bi:1})\n else:\n spam_bi.update({word_bi:1})\n if label == 1:\n ham.update({word:1})\n else:\n spam.update({word:1})\n\n ham_len = 0\n for w in ham:\n ham_len += ham[w]\n spam_len = 0\n for w in spam:\n spam_len += spam[w]\n \n hambi_len = 0\n for w in ham_bi:\n hambi_len += ham_bi[w]\n spambi_len = 0\n for w in spam_bi:\n spambi_len += spam_bi[w]\n\n # labels for Development Phase\n dev_labels = []\n # dicts for P(word|ham) and P(word|spam)\n p_ham = {}\n p_spam = {}\n p_hambi = {}\n p_spambi = {}\n\n # develop likelihoods based on dev_set\n for word in ham:\n numerator = ham[word] + unigram_smoothing_parameter\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\n p_ham[word] = numerator / denominator\n for word in spam:\n numerator = spam[word] + unigram_smoothing_parameter\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\n p_spam[word] = numerator / denominator\n\n for word_bi in ham_bi:\n numerator = ham_bi[word_bi] + bigram_smoothing_parameter\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\n p_hambi[word_bi] = numerator / denominator\n for word_bi in spam_bi:\n numerator = spam_bi[word_bi] + bigram_smoothing_parameter\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\n p_spambi[word_bi] = numerator / denominator\n \n numerator = unigram_smoothing_parameter\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\n p_ham_zero = numerator / denominator\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\n p_spam_zero = numerator / denominator\n\n numerator = bigram_smoothing_parameter\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\n p_hambi_zero = numerator / denominator\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\n p_spambi_zero = numerator / denominator\n\n for string in dev_set:\n p_words_ham = math.log(pos_prior)\n p_words_spam = math.log(1 - pos_prior)\n\n p_words_hambi = math.log(pos_prior)\n p_words_spambi = math.log(1 - pos_prior)\n \n for i in range(len(string)):\n word = string[i]\n if word in p_ham:\n p_words_ham += math.log(p_ham[word])\n else:\n p_words_ham += math.log(p_ham_zero)\n if word in p_spam:\n p_words_spam += math.log(p_spam[word])\n else:\n p_words_spam += math.log(p_spam_zero)\n\n if i != len(string)-1:\n word_bi = string[i] + ' ' + string[i+1]\n if word_bi in p_hambi:\n p_words_hambi += math.log(p_hambi[word_bi])\n else:\n p_words_hambi += math.log(p_hambi_zero)\n if word_bi in p_spambi:\n p_words_spambi += math.log(p_spambi[word_bi])\n else:\n p_words_spambi += math.log(p_spambi_zero)\n\n p_ham_mix = p_words_ham*(1-bigram_lambda) + p_words_hambi*bigram_lambda\n p_spam_mix = p_words_spam*(1-bigram_lambda) + p_words_spambi*bigram_lambda\n\n dev_labels.append(p_ham_mix >= p_spam_mix)\n\n return dev_labels","def __init__(self, bnn_omega, components):\n BaseBNNPrior.__init__(self, bnn_omega, components)\n self.params_to_exclude = []\n self.set_params_list(self.params_to_exclude)\n self.set_comps_qphi_to_e1e2()","def __init__(self, ebunch=None):\n super(BayesianModel, self).__init__()\n if ebunch:\n self.add_edges_from(ebunch)\n self.cpds = []\n self.cardinalities = self.get_cardinality()\n self.probs = dict()","def test_Bernoulli_NB_estimators():","def __init__(self, dim, switch=False, **kwargs):\n # Define the hyperparameters\n super(PAE, self).__init__(dim, **kwargs)\n # Initialize the models\n self.encode_ = Encoder([self.h_dim, self.z_dim])\n self.decode_ = Decoder([self.h_dim, self.image_size])\n self.b = RealNVP(num_coupling_layers=6, z_dim=self.z_dim)\n self.scaler = MinMaxScaler()\n # Build the models\n self.encode_.build(input_shape=(None, self.image_size))\n self.decode_.build(input_shape=(None, self.z_dim))\n self.b.build(input_shape=(None, self.z_dim))\n # Use bijecter in incode or not\n self.switch = switch","def naiveBayes(train_set, train_labels, dev_set, smoothing_parameter, pos_prior):\n # TODO: Write your code here\n # Bag of words model\n smoothing_parameter = .007 # override smoothing parameter\n posWordBag = {}\n negWordBag = {}\n for reviewIndex, review in enumerate(train_set):\n for word in review:\n if isWordTooCommon(word) == True: # If word is too common, skip the word\n continue\n else:\n if train_labels[reviewIndex] == 1: # Positive\n if word not in posWordBag.keys():\n posWordBag[word] = 1\n else:\n posWordBag[word] += 1\n elif train_labels[reviewIndex] == 0: # Negative\n if word not in negWordBag.keys():\n negWordBag[word] = 1\n else:\n negWordBag[word] += 1\n \n posProbList, posUNK = genProb(posWordBag, smoothing_parameter)\n negProbList, negUNK = genProb(negWordBag, smoothing_parameter)\n\n # Done with training. Now development with MAP\n dev_labels = []\n for devRev in dev_set:\n reviewIsPos = math.log10(pos_prior)\n reviewIsNeg = math.log10(1 - pos_prior)\n for word in devRev:\n if isWordTooCommon(word) == True: # If word is too common, skip the word\n continue\n else:\n if word in posProbList.keys():\n reviewIsPos += posProbList[word]\n else:\n reviewIsPos += posUNK\n if word in negProbList.keys():\n reviewIsNeg += negProbList[word]\n else:\n reviewIsNeg += negUNK\n if reviewIsPos < reviewIsNeg:\n dev_labels.append(0)\n else:\n dev_labels.append(1)\n\n # return predicted labels of development set\n return dev_labels","def __init__(self, bandits: List[Bandit], epsilon:float = None):\n self.bandits = bandits\n self.epsilon = epsilon\n # mu_pri and var_pri are hypermaterers for prior distribution\n self.mu_pri = np.zeros(len(self.bandits))\n self.var_pri = np.ones(len(self.bandits))*5\n # mu and var are hyperparameters for posterior distribution\n self.mu = self.mu_pri\n self.var = self.var_pri\n self.var0 = 1 # 1 is taken but any can be taken no prob upto a limit constant of inintial distribution\n self.logging = Logging()","def naiveBayes(train_set, train_labels, dev_set, smoothing_parameter, pos_prior):\r\n # TODO: Write your code here\r\n # return predicted labels of development set\r\n retval = []\r\n smoothing_parameter = 0.0055\r\n # Generate a unigram BOW for both positive and negative reviews, choose the top 2500 words\r\n pos_bow, neg_bow = generate_unigram_BOW(train_set, train_labels)\r\n sorted_pos = sorted(pos_bow.items(), key=lambda x: x[1], reverse = True)\r\n sorted_neg = sorted(neg_bow.items(), key=lambda x: x[1], reverse = True)\r\n pos_words = sorted_pos[:].copy()\r\n neg_words = sorted_neg[:].copy()\r\n\r\n pos_bi_bow, neg_bi_bow = generate_bigram_BOW(train_set, train_labels)\r\n sorted_bi_pos = sorted(pos_bi_bow.items(), key=lambda x: x[1], reverse = True)\r\n sorted_bi_neg = sorted(neg_bi_bow.items(), key=lambda x: x[1], reverse = True)\r\n bi_pos_words = sorted_bi_pos[:].copy()\r\n bi_neg_words = sorted_bi_neg[:].copy()\r\n\r\n # Calculate the log probabilities each word given type\r\n pos_count = sum(pair[1] for pair in pos_words)\r\n neg_count = sum(pair[1] for pair in neg_words)\r\n bi_pos_count = sum(pair[1] for pair in bi_pos_words)\r\n bi_neg_count = sum(pair[1] for pair in bi_neg_words)\r\n\r\n log_probability_pos = {} #(word)->P(word|positive)\r\n log_probability_neg = {} #(word)->P(word|negative)\r\n log_prob_bi_pos = {}\r\n log_prob_bi_neg = {}\r\n\r\n for pair in pos_words:\r\n pos_prob = np.log((pair[1]+smoothing_parameter)/(pos_count+smoothing_parameter*(len(pos_words) + 1)))\r\n log_probability_pos[pair[0]] = pos_prob\r\n\r\n for pair in neg_words:\r\n neg_prob = np.log((pair[1]+smoothing_parameter)/(neg_count+smoothing_parameter*(len(neg_words) + 1)))\r\n log_probability_neg[pair[0]] = neg_prob\r\n\r\n for pair in bi_pos_words:\r\n bi_pos_prob = np.log((pair[1]+smoothing_parameter)/(bi_pos_count+smoothing_parameter*(len(bi_pos_words) + 1)))\r\n log_prob_bi_pos[pair[0]] = bi_pos_prob\r\n\r\n for pair in bi_neg_words:\r\n bi_neg_prob = np.log((pair[1]+smoothing_parameter)/(bi_neg_count+smoothing_parameter*(len(bi_neg_words) + 1)))\r\n log_prob_bi_neg[pair[0]] = bi_neg_prob\r\n # Finished training\r\n\r\n # For each of the new reviews from development data\r\n for review in dev_set:\r\n uni_pos = np.log(pos_prior)\r\n uni_neg = np.log(1 - pos_prior)\r\n for word in review:\r\n if word in log_probability_pos:\r\n uni_pos += log_probability_pos[word]\r\n elif word not in log_probability_pos:\r\n uni_pos += np.log(smoothing_parameter/(pos_count+smoothing_parameter*(len(pos_words) + 1)))\r\n\r\n if word in log_probability_neg:\r\n uni_neg += log_probability_neg[word]\r\n elif word not in log_probability_neg:\r\n uni_neg += np.log(smoothing_parameter/(neg_count+smoothing_parameter*(len(neg_words) + 1)))\r\n\r\n bi_pos = np.log(pos_prior)\r\n bi_neg = np.log(1 - pos_prior)\r\n for i in range(len(review)-1):\r\n currTuple = (review[i], review[i+1])\r\n if currTuple in log_prob_bi_pos:\r\n bi_pos += log_prob_bi_pos[currTuple]\r\n elif currTuple not in log_prob_bi_pos:\r\n bi_pos += np.log(smoothing_parameter/(bi_pos_count+smoothing_parameter*(len(bi_pos_words) + 1)))\r\n\r\n if currTuple in log_prob_bi_neg:\r\n bi_neg += log_prob_bi_neg[currTuple]\r\n elif currTuple not in log_prob_bi_neg:\r\n bi_neg += np.log(smoothing_parameter/(bi_neg_count+smoothing_parameter*(len(bi_neg_words) + 1)))\r\n\r\n MAP_pos = (1-0.4)*uni_pos + 0.4*bi_pos\r\n MAP_neg = (1-0.4)*uni_neg + 0.4*bi_neg\r\n\r\n if MAP_pos >= MAP_neg:\r\n retval.append(1)\r\n else:\r\n retval.append(0)\r\n\r\n return retval","def bayesian_update(self):\n for p in self.parameters:\n p.bayesian_update()","def __init__(self, input_size: int, output_size: int, old_cols: List[AlphaModule] = None, hidden_size=768,\n ptm=\"bert\", feature_size=768, require_proto=False, tokenizer=None, prob_l=-1) -> None:\n super(PTMClassifier_PNN, self).__init__()\n \n if old_cols is None:\n old_cols = []\n \n self.old_cols = []\n \n self.output_size = output_size\n self.hidden_size = hidden_size # default\n self.feature_size = feature_size\n \n self.fc1 = nn.Linear(self.hidden_size, 100)\n self.classifier = nn.Linear(100, self.output_size)\n \n if len(old_cols) > 0:\n self.old_fc1s = ListModule()\n self.base_1 = nn.Sequential(\n nn.Linear(100 * len(old_cols), 100),\n nn.ReLU(),\n )\n self.base_2 = nn.Sequential(\n nn.Linear(100 * len(old_cols), 100),\n nn.ReLU(),\n )\n \n self.adaptor1 = nn.Sequential(AlphaModule(100 * len(old_cols)),\n self.base_1)\n self.adaptor2 = nn.Sequential(AlphaModule(100 * len(old_cols)),\n self.base_2)\n \n for old_col in old_cols:\n self.old_fc1s.append(\n nn.Sequential(nn.Linear(self.hidden_size, 100), nn.ReLU()))\n self.old_fc1s[-1][0].load_state_dict(old_col.fc1.state_dict())\n \n # ptm\n self.ptm = ptm.lower()\n assert self.ptm in supported_ptm\n ptm_ = import_from(\"transformers\", supported_ptm[self.ptm][0] + \"Model\")\n \n self.encoder = ptm_.from_pretrained(supported_ptm[self.ptm][1], output_hidden_states=True)\n if tokenizer is not None:\n self.encoder.resize_token_embeddings(len(tokenizer))\n self.prob_l = prob_l\n \n self.require_proto = require_proto\n \n # todo : modify net into one network\n if self.require_proto:\n # prototype-based classification\n self.net = nn.Sequential(\n self.fc1\n )\n self.net_ = nn.Sequential(\n self.encoder,\n self.fc1,\n self.encoder_adaptor,\n nn.ReLU(),\n )\n else:\n self.classifier = nn.Linear(self.feature_size, self.output_size, bias=True)\n self.net = nn.Sequential(\n self.classifier\n )\n self.net_ = nn.Sequential(\n self.encoder,\n self.classifier\n )\n \n self.reset_parameters()","def __init__(self, n=5, factors=50, learning_rate=0.001, bias_regularization=0.001, user_regularization=0.001,\n positive_item_regularization=0.001, negative_item_regularization=0.001,iter = 50):\n print 'bpr begin'\n self.n = n\n self.factors = factors\n self.learning_rate = learning_rate\n self.bias_regularization = bias_regularization\n self.user_regularization = user_regularization\n self.positive_item_regularization = positive_item_regularization\n self.negative_item_regularization = negative_item_regularization\n self.iter = iter","def build_naive_bayes():\n nb_pipeline = None\n ##### Write code here\n nb_pipeline = Pipeline([\n ('vect', CountVectorizer()),\n ('clf', ComplementNB())\n ])\n\n ##### End of your work ######\n return nb_pipeline","def __init__(self, **kwargs):\n\n super(MLP, self).__init__()\n\n # TODO: why lbfgs and not adam?\n self.solver = kwargs.pop('solver', 'lbfgs')\n self.alpha = kwargs.pop('alpha', 1e-5)\n self.random_state = kwargs.pop('random_state', 1)\n\n # determine if the MLP can be initialized or not\n self.clf = None\n self.hidden_layer_sizes = kwargs.pop('hidden_layer_sizes', -1)\n if not (self.hidden_layer_sizes == -1):\n self.initMLPClassifier(**kwargs)","def init_bn(bn):\n bn.bias.data.fill_(0.0)\n bn.weight.data.fill_(1.0)","def nbc_model(params):\n if (params['random']):\n params['alpha'] = random.randrange(1, 10, step=1) * 0.1\n model = MultinomialNB(\n alpha=params['alpha']\n )\n\n return model","def build_naive_bayes():\n nb_pipeline = None\n \n nb_pipeline = Pipeline([\n ('vect', CountVectorizer()),\n ('clf', ComplementNB()),\n ])\n \n return nb_pipeline","def __init__(self,args, variance_epsilon=1e-12):\n super(BERTLayerNorm, self).__init__()\n self.gamma = nn.Parameter(torch.ones(args.input_dim))\n self.beta = nn.Parameter(torch.zeros(args.input_dim))\n self.variance_epsilon = variance_epsilon","def __init__(self, beta):\n super(CuboidPoseHead, self).__init__()\n self.beta = beta\n self.loss = nn.L1Loss()","def __init__(self, bandits: List[Bandit]):\n self.bandits = bandits\n # mu_pri and var_pri are hypermaterers for prior distribution\n self.mu_pri = np.zeros(len(self.bandits)) # 5 for each\n self.var_pri = np.ones(len(self.bandits))*5\n # mu and var are hyperparameters for posterior distribution\n self.mu = self.mu_pri\n self.var = self.var_pri\n self.var0 = 1 # 1 is taken but any can be taken no prob upto a limit constant of inintial distribution\n self.logging = Logging()","def naive_bayes_train(train_data, train_labels, params):\n\n labels = np.unique(train_labels)\n\n d, n = train_data.shape\n num_classes = labels.size\n\n # Set LaPlace smoothing parameter. \n # As alpha increases, the probabilities tend towards the uniform distribution.\n # If there is little need for smoothing, setting alpha low will typically boost accuracy.\n alpha = 1\n\n # Initialize prior and likelihood arrays\n p_y = np.zeros(num_classes, dtype=float)\n likelihoods = np.zeros((d, num_classes), dtype=float)\n\n # Loop over each class\n for c in range(num_classes):\n # Get documents with current class label\n class_data = train_data[:,np.where(train_labels == c)[0]]\n # Get number of examples of current class\n m = class_data.shape[1]\n\n # Get current prior (w/ LaPlace Smoothing)\n p_y[c] = (m + alpha) / (n + alpha*num_classes)\n # Get class conditional probabilities (w/ LaPlace Smoothing)\n likelihoods[:,c] = (np.sum(class_data, axis=1) + alpha) / (m + 2*alpha)\n\n # Combine priors and likelihoods into model dictionary\n model = dict()\n model['likelihood'] = likelihoods\n model['prior'] = p_y\n return model","def predict_proba(self):\n ...","def test_posterior():\n\n # Initiate BEL object\n bel = init_bel()\n # Set seed\n seed = 123456\n bel.seed = seed\n\n # Get file path\n my_path = os.path.dirname(os.path.abspath(__file__))\n\n X_train = np.load(jp(my_path, \"X_train.npy\"))\n y_train = np.load(jp(my_path, \"y_train.npy\"))\n\n X_test = np.load(jp(my_path, \"X_test.npy\"))\n\n # Fit\n bel.fit(X=X_train, Y=y_train)\n # Predict posterior mean and covariance\n post_mean, post_cov = bel.predict(X_test)\n\n # Compare with reference\n ref_mean = np.load(jp(my_path, \"ref_mean.npy\"))\n ref_covariance = np.load(jp(my_path, \"ref_covariance.npy\"))\n\n msg1 = \"The posterior means are different\"\n np.testing.assert_allclose(post_mean, ref_mean, atol=1e-6, err_msg=msg1)\n\n msg2 = \"The posterior covariances are different\"\n np.testing.assert_allclose(post_cov, ref_covariance, atol=1e-6, err_msg=msg2)","def init_bn(bn):\n bn.bias.data.fill_(0.)\n bn.weight.data.fill_(1.)","def init_bn(bn):\n bn.bias.data.fill_(0.)\n bn.weight.data.fill_(1.)","def init_bn(bn):\n bn.bias.data.fill_(0.)\n bn.weight.data.fill_(1.)","def setup_b_instance(self,norm,add_ps_mask=True):\n inst_tag = self.tag + '_'+str(self.flux_array_ebin)\n b = bsm.bayesian_scan_NPTF(tag=inst_tag,nside=self.nside,work_dir='/tmp/'+self.tag+'/',psf_dir=psf_dir,nlive=700)\n # Input the data, using the external data if provided\n if self.use_external_data:\n b.load_external_data(self.f1.CTB_en_bins,[self.external_data[self.flux_array_ebin]],self.f1.CTB_exposure_maps)\n else:\n b.load_external_data(self.f1.CTB_en_bins,self.f1.CTB_count_maps,self.f1.CTB_exposure_maps)\n\n if add_ps_mask:\n b.make_mask_total(band_mask_range = [-self.band_mask,self.band_mask],mask_ring = False,ps_mask_array = self.f1.ps_mask_array)\n else:\n b.make_mask_total(band_mask_range = [-self.band_mask,self.band_mask],mask_ring = False)\n\n b.add_new_template(self.f1.template_dict)\n b.rebin_external_data(1)\n\n b.add_poiss_model('ps_model','$A_{ps}$',[0.0,3.0],False)\n b.add_poiss_model('p7','$A_{p7}$',[0.0,2.0],False)\n b.add_poiss_model('bubs','$A_{bubs}$',[0.0,2.0],False)\n b.add_poiss_model('iso','$A_{iso}$',[0.0,3.0],False)\n # Add in a fixed J_map template\n b.add_fixed_templates({'J_map':[norm*self.J_map_arr[self.flux_array_ebin]/np.mean(self.J_map_arr[self.flux_array_ebin])]})\n\n b.initiate_poissonian_edep()\n return b","def BayesPaperStats(maxIters, numRuns):\n\n comm = MPI.COMM_WORLD\n rank = comm.Get_rank()\n\n assert comm.Get_size() == numRuns, \"Please ensure there is one process running per run i.e \" + str(numRuns) + \" processes.\"\n \n problemBounds = {\"Bfield\": choco.uniform(10, 1300), \"T\": choco.uniform(50, 230), \"Btheta\": choco.uniform(0, 90), \"Etheta\": choco.uniform(0, 90)}\n\n # The target for each algorithm. This was determined by using the values in the literature, so there is clearly some deviation either due to the detuning or computation.\n globalFoM = 1.033\n\n if rank == 0:\n timeList = []\n iterationList = []\n\n # Set up the database for the chocolate optimiser.\n connection = choco.SQLiteConnection(\"sqlite:///bayes_paper_\" + str(rank) + \"_db.db\")\n\n # Define which solver will be used.\n solver = choco.Bayes(connection, problemBounds, utility_function = \"ei\", n_bootstrap = int(np.ceil(maxIters/10)), clear_db = True)\n\n # Clear the database. TODO: To do this?\n connection.clear()\n\n # Start timing.\n startTime = time.time()\n timeElapsed = None\n iterationSuccess = None\n\n # Start optimisation.\n for iteration in range(maxIters):\n\n # Make one suggestion.\n try:\n token, nextParams = solver.next()\n except:\n print(\"Error suggesting a new point. Here are the last set of parameters sampled:\")\n print(str(nextParams))\n print(\"Iteration number: \" + str(iteration))\n continue\n\n # Check what FoM this gives. Go negative as this is a minimisation routine.\n fEval = abs(FitnessPaper(**nextParams))\n\n # Update best FoM.\n if fEval >= globalFoM:\n # The algorithm has managed to surpass or equal the paper value.\n iterationSuccess = iteration\n timeElapsed = time.time() - startTime\n \n if rank == 0:\n iterationList.append(iterationSuccess)\n timeList.append(timeElapsed)\n\n break\n \n # Tell the optimiser about the result.\n solver.update(token, fEval)\n\n # Run complete. Send results to main process. Tags are unique identifiers.\n if rank != 0:\n comm.send(timeElapsed, dest = 0, tag = 1)\n comm.send(iterationSuccess, dest = 0, tag = 2)\n\n # Wait for all the processes to end.\n comm.Barrier()\n\n if rank == 0:\n # Aggregate the data.\n for process in range(comm.Get_size() - 1):\n # Get the data.\n individualTime = None\n individualTime = comm.recv(individualTime, source = process + 1, tag = 1)\n\n individualIter = None\n individualIter = comm.recv(individualIter, source = process + 1, tag = 2)\n\n if individualIter is not None:\n # Both values must therefore be non-null.\n iterationList.append(individualIter)\n timeList.append(individualTime)\n\n avgRuntime = np.average(timeList)\n avgIters = np.average(iterationList)\n try:\n\n fastestTime = np.min(timeList)\n\n except ValueError:\n \n # List is empty.\n fastestTime = float('NaN')\n\n numSuccess = len(iterationList)\n successRate = numSuccess/numRuns\n\n print(\"Bayesian optimisation paper testing complete! Here are the stats:\")\n print(\"Number of successful runs: \" + str(numSuccess) + \" (Success rate of \" + str(successRate) + \")\")\n print(\"Average iterations required for success: \" + str(avgIters))\n print(\"Average time required for success: \" + str(avgRuntime))\n print(\"Fastest convergence time: \" + str(fastestTime))\n print(\"------------------------------------------------------------------------------------------------------------------\")\n \n return","def __init__(self, b=0, drop_rate=0.5, pretrained=True):\n\n # Calls the super for the nn.Module.\n super(Classifier, self).__init__()\n\n # Sets the drop rate for the dropout layers.\n self.drop_rate = drop_rate\n\n # Loads the EfficientNet encoder.\n if pretrained:\n self.encoder = EfficientNet.from_pretrained(f\"efficientnet-b{str(b)}\")\n else:\n self.encoder = EfficientNet.from_name(f\"efficientnet-b{str(b)}\")\n self.encoder_pool = nn.AdaptiveAvgPool2d(1)\n\n # Defines a hidden layer.\n self.hidden = nn.Linear(2560, 512)\n\n # Defines the output layer of the neural network.\n self.classifier = nn.Linear(512, 2)","def __init__(self, config, variance_epsilon=1e-12):\r\n super(BertLayerNorm, self).__init__()\r\n self.gamma = nn.Parameter(torch.ones(config.hidden_size))\r\n self.beta = nn.Parameter(torch.zeros(config.hidden_size))\r\n self.variance_epsilon = variance_epsilon","def test_predict_prep_proba():\n args = get_layer('predict', 'manual', 'temporal', True, True, window=2, step_size=3)\n run_layer(*args)","def __init__(self, data, class_column):\n print(\"Naive Bayes Model created!\")\n\n # create report\n self.predict_summary = {}\n self.fit_report = {}\n\n # self.data=data\n self.data = data\n self.class_column = class_column\n\n # get the class column and get classes\n col_data = self.data[class_column]\n self.class_list = unique_list(col_data)\n\n # get numeric columns and categorical columns\n self.num_cols, self.cat_cols = get_both_columns(self.data, class_column)\n\n # Build the pro\n self.prob_hub = {}","def update_posterior_probs(vars_):\n vars_.weighted_sums += np.power(vars_.dprime_map[vars_.focus],2) * vars_.visual_field\n vars_.post_probs = np.exp(vars_.weighted_sums) * vars_.prior_prob\n vars_.post_probs /= np.sum(vars_.post_probs)","def probinit(self, aaa, n_obj):\n # Set algorithm...\n if aaa == 'nsga':\n algo = nsga_II(m=0.05)\n else:\n algo = jde(memory=True)\n #algo = mde_pbx()\n #algo = de_1220()\n\n # ...and initialize problem with instance atributes\n prob = mga_1dsm(seq = self.FBseq,\n multi_objective = n_obj,\n dsm_dv_barrier = self.MAX_DV)\n\n prob.set_vinf((self.C3)**0.5)\n prob.set_tof(self.TOF[0], self.TOF[1])\n prob.set_entry_barrier(self.entry_barrier)\n prob.set_launch_window(self.EPOCHSTART, self.EPOCHEND)\n return prob, algo","def fit_and_predict_BernoulliNB(X_train, Y_train, X_test):\n\n # Import the package\n from sklearn.naive_bayes import BernoulliNB \n\n ### YOUR SOLUTION STARTS HERE### \n #referenced to sklearn documentation \n # fit the model... \n clf = BernoulliNB(binarize=0.0).fit(X_train, Y_train) #fit naive bayes to X and Y train data\n # make predictions\n predicted_bernNB = clf.predict(X_test)\n return predicted_bernNB\n ### END SOLUTION ### ","def gibbs_ask_traffic(self, X, e, Z, bn, N):\n\n #makes copies\n X = e\n e = e\n\n #probability\n probability = [0,0]\n numerator = 0\n\n\n #True, False\n\n for x in range(N):\n # second joint\n if Z == True: # if non evidence variable\n random_choice = np.random.choice([0,1], 1, True, [0.5, 0.5])[0] #Rain or No Rain\n X[1] = bn[1][random_choice][0]\n else:\n random_choice = np.random.choice([0, 1], 1, True, [0.5, 0.5])[0] #Rain or No Rain\n X[1] = bn[1][random_choice][1]\n\n # first joint\n if X[1] == 0.8 or X[1] == 0.2: # Rain is true\n X[0] = bn[0][0]\n else: # Rain is False\n X[0] = bn[0][1]\n\n # third joint\n if X[1] == 0.8 or X[1] == 0.1: # traffic\n random_late = np.random.choice([0,1], 1, True, [0.5,0.5])[0]\n X[2] = bn[2][0][random_late]\n else: # no traffic\n random_late = np.random.choice([0, 1], 1, True, [0.5, 0.5])[0]\n X[2] = bn[2][1][random_late]\n\n # print(X)\n if X[0] == 0.1:\n probability[0] += 1\n else:\n probability[1] += 1\n\n\n probability[0] = probability[0] / N\n probability[1] = probability[1] / N\n # print(probability)\n return probability","def __init__(self,data,pos,neg,bk,prior,target,max_depth=2):\n\n self.data = data\n self.examples = {}\n self.pos = pos\n self.neg = neg\n #initial model assumed P(target|data)=0.5 to target=1,0\n for ex in pos+neg:\n self.examples[ex] = prior[ex]\n self.bk = bk\n self.target = target\n self.max_depth = max_depth\n self.boosted_trees = []","def __init__(self, nr_of_categories: int, alpha=0.1, beta=1e10, delta=1.0, reduction='none'):\n super().__init__()\n self.parabolic_penalty = ParabolicPenaltyLoss(nr_of_categories, delta, beta)\n self.categorical_crossentropy = CrossEntropyLoss()\n self.reduction = reduction\n self.alpha = alpha","def perform_bayesian_optimization(self):\n bounds = {'hunits': (self.hunits_lower, self.hunits_upper),\n 'embedding_dim': (self.embedding_dim_lower, self.embedding_dim_upper)}\n optimizer = BayesianOptimization(f=self.lstm_score, pbounds=bounds, random_state=1)\n optimizer.maximize(init_points=2, n_iter=self.iterations)\n print(optimizer.max)\n print(optimizer.res)","def __init__(self, \n num_vars, \n num_hidden,\n training_inputs = None,\n algorithm = None,\n algorithm_dict = None,\n batch_size = None,\n use_momentum = None,\n W0= None, \n b0= None, \n bhid0 = None,\n zero_diag = True,\n symmetric = True,\n report_p_tilda =False,\n learn_biases = True,\n test_mode= False,\n training = True):\n \n self.num_vars = num_vars\n \n self.num_hidden = num_hidden\n \n self.batch_size = batch_size\n \n self.zero_diag = zero_diag\n \n self.algorithm = algorithm\n \n self.num_samples = 0\n \n self.num_u_gibbs = 0\n \n self.gibbs_steps = 0\n \n self.resample = False\n \n self.uniform = False\n \n self.mixture = False\n \n self.mix_params = []\n \n self.m_params = []\n \n self.mf_steps = 0\n \n self.alpha = 0\n \n self.learn_biases = learn_biases\n \n if isinstance(algorithm_dict, dict):\n \n for param in algorithm_dict.keys():\n \n if param == 'resample':\n \n self.resample = algorithm_dict[param]\n \n if param == 'mf_steps':\n \n self.mf_steps = algorithm_dict[param]\n \n if param == \"gibbs_steps\":\n \n self.gibbs_steps = algorithm_dict[param]\n \n if param == \"num_samples\":\n \n self.num_samples = algorithm_dict[param]\n \n if param == \"num_u_gibbs\":\n \n self.num_u_gibbs = algorithm_dict[param]\n \n if param == \"uniform\":\n \n self.uniform = algorithm_dict[param] \n \n if param == \"mixture\":\n \n self.mixture = algorithm_dict[param] \n \n if param == \"mix_params\":\n \n self.mix_params = algorithm_dict[param] \n \n if param == \"alpha\" and algorithm_dict[param] != None:\n #### alpha defines transition rate from\n #### uniform to mean-field distribution\n self.alpha = algorithm_dict[param] \n \n self.m_params = (1-self.alpha)*0.5*np.ones([1,self.num_vars])+\\\n self.alpha*np.mean(training_inputs,0)\n \n self.use_momentum = use_momentum\n \n self.report_p_tilda = report_p_tilda\n \n self.side = int(np.sqrt(self.num_vars))\n \n self.np_rand_gen = np.random.RandomState(1234)\n \n self.theano_rand_gen =\\\n theano.sandbox.rng_mrg.MRG_RandomStreams(self.np_rand_gen.randint(2**30))\n \n #self.theano_rand_gen =\\\n #T.shared_randomstreams.RandomStreams(self.np_rand_gen.randint(2**30))\n \n theano.config.exception_verbosity = 'high'\n \n self.node_indices = \\\n theano.shared(np.arange(self.num_vars), name=\"node_indices\")\n \n self.x = T.matrix('x')\n \n self.x_tilda = T.matrix('x_tilda')\n \n self.sampler_theta = T.matrix('sampler_theta')\n \n self.symmetric = symmetric\n \n if training:\n \n if self.num_hidden ==0:\n \n self.num_x2 = self.num_vars\n \n elif self.num_hidden > 0 :\n \n self.num_x2 = self.num_hidden\n \n self.updates = OrderedDict()\n \n self.N_train = training_inputs.shape[0]\n \n self.train_inputs = theano.shared(np.asarray(training_inputs,\n dtype=theano.config.floatX),\n borrow= True)\n \n self.learning_rate = T.dscalar('learning_rate')\n \n if self.mixture:\n \n print(\"Importance distribution was specified as mixture\"+\\\n \" of Bernoulli products\")\n \n if self.mix_params == []:\n print(\"Error: parameters defining mixture means were\"+\\\n \" not provided\")\n sys.exit()\n \n self.set_mixture_means(inputs = training_inputs)\n \n if use_momentum:\n \n print(\"Will add momentum term to gradient computations\")\n \n self.momentum = T.dscalar('learning_rate')\n \n self.grad_vec = {}\n \n self.grad_vec['W'] = theano.shared(np.zeros([self.num_vars, self.num_x2],\n dtype = theano.config.floatX), name = 'W_momentum', borrow = True)\n \n if self.num_hidden > 0:\n \n self.grad_vec['bhid'] = theano.shared(np.zeros([self.num_x2],\n dtype = theano.config.floatX), name = 'b_momentum', borrow = True)\n \n self.grad_vec['b'] = theano.shared(np.zeros([self.num_vars],\n dtype = theano.config.floatX), name = 'b_momentum', borrow = True)\n \n if test_mode:\n \n b_init =self.np_rand_gen.uniform(0,1, num_vars)\n \n W_init =self.np_rand_gen.uniform(0,1, size = (num_vars, num_vars))\n \n # also tested ones\n # b_init = np.ones(num_vars)\n \n # W_init = np.ones([num_vars, num_vars])\n \n self.b_init= np.asarray(b_init, dtype = theano.config.floatX)\n \n self.W_init= np.asarray(W_init, dtype = theano.config.floatX)\n \n self.b = theano.shared(self.b_init, name='b', borrow = False)\n \n self.W = theano.shared(self.W_init, name='W', borrow = False)\n \n print(\"Initialized with test mode\")\n \n else:\n \n if W0 is None:\n \n if self.num_hidden > 0:\n \n W0_init =\\\n self.np_rand_gen.uniform(\n -4*np.sqrt(6.0/(self.num_vars+self.num_hidden)),\\\n 4*np.sqrt(6.0 /(self.num_vars + self.num_hidden)), \n size = (num_vars, self.num_hidden)\n )\n \n W0 = np.asarray(W0_init, dtype = theano.config.floatX) \n \n if self.num_hidden == 0:\n \n # different W initializations: \n \n # W0_init =\\\n # self.np_rand_gen.uniform(-np.sqrt(3.0/(num_vars)),\\\n # np.sqrt(3.0 / (num_vars)), size = (num_vars, num_vars))\n \n # W0_init =\\\n # self.np_rand_gen.uniform(-0.00000001,\\\n # 0.00000001, size = (num_vars, num_vars))\n \n W0_init = 0.00000001*\\\n self.np_rand_gen.normal(size = (num_vars, self.num_x2)) \n \n W0 = np.asarray(W0_init, dtype = theano.config.floatX)\n \n if self.symmetric:\n \n W0 = (W0 + np.transpose(W0))/2.0\n \n if self.zero_diag:\n \n W0 = W0 - np.diag(np.diag(W0))\n \n self.W = theano.shared(value= W0, name='W', borrow=True)\n \n if self.num_hidden == 0:\n \n test_W = self.W.get_value() \n \n assert sum(np.diag(test_W)) == 0.0\n \n assert (test_W == np.transpose(test_W)).all() == True\n \n else:\n print(\"W is initialized with provided array\")\n self.W = theano.shared(value= W0, name='W', borrow=True)\n \n if b0 is None:\n \n bias_init = np.zeros(num_vars, dtype = theano.config.floatX)\n \n self.b = theano.shared(value= bias_init, name='b', borrow=True)\n \n else:\n print(\"b vector is initialized with provided vector\")\n self.b = theano.shared(value= b0, name='b', borrow=True)\n \n if bhid0 is None and self.num_hidden > 0:\n \n hbias_init = np.zeros(self.num_hidden, dtype = theano.config.floatX)\n \n self.bhid = theano.shared(value= hbias_init, name='bhid', borrow=True)\n \n elif (bhid0 is not None) and (self.num_hidden > 0):\n print(\"bhid vector is initialized with provided vector\") \n self.bhid = theano.shared(value= bhid0, name='bhid', borrow=True)\n \n self.theta = [self.W, self.b]\n \n if self.num_hidden > 0 :\n \n self.theta.append(self.bhid)\n \n self.train_set = set(range(self.N_train))\n \n self.minibatch_set = T.ivector('minibatch_set')\n \n self.sample_set = T.ivector('sample_set')\n \n if \"CD\" in self.algorithm and self.num_hidden ==0:\n \n self.x_gibbs= theano.shared(np.ones([self.batch_size,self.num_vars],\n dtype=theano.config.floatX),\n borrow = True, name= \"x_gibbs\")\n \n if \"CD\" in self.algorithm and self.num_hidden > 0:\n \n self.persistent_gibbs =\\\n theano.shared(np.ones([self.batch_size,self.num_hidden],\n dtype=theano.config.floatX),\n borrow = True, \n name= \"persistent_gibbs\")\n \n if \"CSS\" in self.algorithm and self.mf_steps > 0:\n \n init_mf_vis = self.np_rand_gen.uniform(0, \n 1, \n size =(self.num_vars,1))\n \n init_mf_vis = np.asarray(init_mf_vis, dtype = theano.config.floatX)\n \n self.mf_vis_p = theano.shared(init_mf_vis, \n name= \"mf_vis_p\", \n borrow= True)\n \n if self.num_hidden > 0:\n \n init_mf_hid = \\\n self.np_rand_gen.uniform(0, 1, size =(self.num_hidden,1))\n \n init_mf_hid = np.asarray(init_mf_hid, \n dtype = theano.config.floatX)\n \n self.mf_hid_p = theano.shared(init_mf_hid, \n name= \"mf_hid_p\", \n borrow= True)\n \n elif \"CSS\" in self.algorithm and self.gibbs_steps > 0: \n \n if self.num_hidden ==0: \n self.x_gibbs= theano.shared(np.ones([self.batch_size,self.num_vars],\n dtype=theano.config.floatX),\n borrow = True, name= \"x_gibbs\")","def __init__(self, input, n_in, n_out,\r\n W=None, b=None, prob_constraint_on=None):\r\n\r\n # initialize weight matrix W\r\n if W is None:\r\n self.W = theano.shared(\r\n value=np.zeros((n_in, n_out), dtype=theano.config.floatX),\r\n name='W')\r\n else:\r\n self.W = W\r\n\r\n # initialize bias b\r\n if b is None:\r\n self.b = theano.shared(\r\n value=np.zeros((n_out,), dtype=theano.config.floatX),\r\n name='b')\r\n else:\r\n self.b = b\r\n\r\n # compute prediction\r\n # the linear output\r\n lin_output = T.dot(input, self.W) + self.b\r\n \r\n if prob_constraint_on == None:\r\n #### we do not use those probability constraints\r\n self.y_pred = Sigmoid(lin_output)\r\n\r\n elif prob_constraint_on == \"top\":\r\n #### We first predict the probability of each class using softmax.\r\n # We then weight those probabilities by multiplying them by the\r\n # probability of their parent in the Galaxy Zoo Decision Tree.\r\n \r\n # class 1\r\n prob_Class1 = SoftMax(lin_output[:,0:3])\r\n \r\n # class 2\r\n prob_Class2 = SoftMax(lin_output[:,3:5])\r\n # weight these probabilities using the probability of class 1.2\r\n prob_Class2 *= T.shape_padright(prob_Class1[:,1])\r\n \r\n # class 3\r\n prob_Class3 = SoftMax(lin_output[:,5:7])\r\n # weight these probabilities using the probability of class 2.2\r\n prob_Class3 *= T.shape_padright(prob_Class2[:,1])\r\n \r\n # class 4\r\n prob_Class4 = SoftMax(lin_output[:,7:9])\r\n # weight these probabilities using the probability of class 2.2\r\n prob_Class4 *= T.shape_padright(prob_Class2[:,1])\r\n \r\n # class 5\r\n prob_Class5 = SoftMax(lin_output[:,9:13])\r\n # weight these probabilities using the probability of class 2.2\r\n prob_Class5 *= T.shape_padright(prob_Class2[:,1])\r\n \r\n # class 6\r\n prob_Class6 = SoftMax(lin_output[:,13:15])\r\n \r\n # class 7\r\n prob_Class7 = SoftMax(lin_output[:,15:18])\r\n # weight these probabilities using the probability of class 1.1\r\n prob_Class7 *= T.shape_padright(prob_Class1[:,0])\r\n \r\n # class 8\r\n prob_Class8 = SoftMax(lin_output[:,18:25])\r\n # weight these probabilities using the probability of class 6.1\r\n prob_Class8 *= T.shape_padright(prob_Class6[:,0])\r\n \r\n # class 9\r\n prob_Class9 = SoftMax(lin_output[:,25:28])\r\n # weight these probabilities using the probability of class 2.1\r\n prob_Class9 *= T.shape_padright(prob_Class2[:,0])\r\n \r\n # class 10\r\n prob_Class10 = SoftMax(lin_output[:,28:31])\r\n # weight these probabilities using the probability of class 4.1\r\n prob_Class10 *= T.shape_padright(prob_Class4[:,0])\r\n \r\n # class 11\r\n prob_Class11 = SoftMax(lin_output[:,31:37])\r\n # weight these probabilities using the probability of class 4.1\r\n prob_Class11 *= T.shape_padright(prob_Class4[:,0])\r\n \r\n # concatenate all the probabilities into a single tensor variable\r\n self.y_pred = T.concatenate(\r\n [prob_Class1, prob_Class2, prob_Class3, prob_Class4,\r\n prob_Class5, prob_Class6, prob_Class7, prob_Class8,\r\n prob_Class9, prob_Class10, prob_Class11], axis=1)\r\n elif prob_constraint_on == \"down\":\r\n #### we use those probability constraints\r\n \r\n # the following probabilities should sum up to 1, so we use SoftMax\r\n # to predict all of them\r\n ind1 = [2, 8, 15, 16, 17, 25, 26, 27, 31, 32, 33, 34, 35, 36]\r\n p1 = SoftMax(lin_output[:,ind1])\r\n prob_Class1_3 = p1[:,0]\r\n prob_Class4_2 = p1[:,1]\r\n prob_Class7 = p1[:,2:5]\r\n prob_Class9 = p1[:,5:8]\r\n prob_Class11 = p1[:,8:14]\r\n \r\n prob_Class4_1 = T.sum(prob_Class11, axis=1)\r\n prob_Class2_1 = T.sum(prob_Class9, axis=1)\r\n prob_Class2_2 = prob_Class4_1 + prob_Class4_2\r\n prob_Class1_1 = T.sum(prob_Class7, axis=1)\r\n prob_Class1_2 = prob_Class2_1 + prob_Class2_2\r\n prob_Class1 = T.concatenate(\r\n [T.shape_padright(prob_Class1_1),\r\n T.shape_padright(prob_Class1_2),\r\n T.shape_padright(prob_Class1_3)], axis=1)\r\n prob_Class2 = T.concatenate(\r\n [T.shape_padright(prob_Class2_1),\r\n T.shape_padright(prob_Class2_2)], axis=1)\r\n prob_Class4 = T.concatenate(\r\n [T.shape_padright(prob_Class4_1),\r\n T.shape_padright(prob_Class4_2)], axis=1)\r\n \r\n # the following probabilities should sum up to 1, so we use SoftMax\r\n # to predict all of them\r\n ind2 = [14, 18, 19, 20, 21, 24, 23, 24] \r\n p2 = SoftMax(lin_output[:,ind2])\r\n prob_Class6_2 = p2[:,0]\r\n prob_Class8 = p2[:,1:8]\r\n prob_Class6_1 = T.sum(prob_Class8, axis=1)\r\n prob_Class6 = T.concatenate(\r\n [T.shape_padright(prob_Class6_1),\r\n T.shape_padright(prob_Class6_2)], axis=1)\r\n \r\n # for the following probabilities, we resort to the same strategy in\r\n # the \"top\" option\r\n # class 3\r\n prob_Class3 = SoftMax(lin_output[:,5:7])\r\n # weight these probabilities using the probability of class 2.2\r\n prob_Class3 *= T.shape_padright(prob_Class2[:,1])\r\n \r\n # class 5\r\n prob_Class5 = SoftMax(lin_output[:,9:13])\r\n # weight these probabilities using the probability of class 2.2\r\n prob_Class5 *= T.shape_padright(prob_Class2[:,1])\r\n \r\n # class 10\r\n prob_Class10 = SoftMax(lin_output[:,28:31])\r\n # weight these probabilities using the probability of class 4.1\r\n prob_Class10 *= T.shape_padright(prob_Class4[:,0])\r\n \r\n # concatenate all the probabilities into a single tensor variable\r\n self.y_pred = T.concatenate(\r\n [prob_Class1, prob_Class2, prob_Class3, prob_Class4,\r\n prob_Class5, prob_Class6, prob_Class7, prob_Class8,\r\n prob_Class9, prob_Class10, prob_Class11], axis=1)\r\n \r\n \r\n # parameters of the model\r\n self.params = [self.W, self.b]","def initialize_probabilities(self):\n self.probabilities = np.ndarray((2, len(self.variables)), dtype=np.float)\n self.update_probabilities()","def __init_finalaf(self, i,h1,classes):\n self.params['W'+i]=np.random.randn(h1,classes)*self.weight_scale\n self.params['b'+i]=np.zeros(classes)","def __init__(self, sizes, beta=1, momentum=0.9):\n self.beta = beta\n self.momentum = momentum\n\n self.nin = sizes[0] # number of features in each sample\n self.nhidden1 = sizes[1] # number of neurons in the first hidden layer\n self.nhidden2 = sizes[2] # number of neurons in the second hidden layer\n self.nout = sizes[3] # number of classes / the number of neurons in the output layer\n\n\n # Initialise the network of two hidden layers\n self.weights1 = (np.random.rand(self.nin+1,self.nhidden1)-0.5)*2/np.sqrt(self.nin) # hidden layer 1\n self.weights2 = (np.random.rand(self.nhidden1+1,self.nhidden2)-0.5)*2/np.sqrt(self.nhidden1) # hidden layer 2\n self.weights3 = (np.random.rand(self.nhidden2+1,self.nout)-0.5)*2/np.sqrt(self.nhidden2) # output layer","def naiveBayes(train_set, train_labels, dev_set, smoothing_parameter, org_dev_labels):\r\n\r\n # set to false to use bigram implementation instead\r\n # isUnigram = True\r\n isUnigram = True\r\n\r\n # return predicted labels of development set\r\n spam_words, spam_wordcount = parseIntoWordList(train_set, train_labels, 1)\r\n ham_words, ham_wordcount = parseIntoWordList(train_set, train_labels, 0)\r\n\r\n spamWords, spamProbs, spamUNK = createProbabilitiesList(spam_words, spam_wordcount, smoothing_parameter)\r\n hamWords, hamProbs, hamUNK = createProbabilitiesList(ham_words, ham_wordcount, smoothing_parameter)\r\n\r\n loggedSpam = np.log(spamProbs)\r\n loggedSpamUNK = np.log(spamUNK)\r\n loggedHam = np.log(hamProbs)\r\n loggedHamUNK = np.log(hamUNK)\r\n\r\n # Unigram\r\n dev_spam = []\r\n dev_ham = []\r\n\r\n dev_labels = []\r\n\r\n if isUnigram:\r\n for i in range(len(dev_set)):\r\n probSpam = 0\r\n probHam = 0\r\n\r\n for word in dev_set[i]:\r\n if word in spamWords:\r\n index = spamWords.index(word)\r\n probSpam += loggedSpam[index]\r\n else:\r\n probSpam += loggedSpamUNK\r\n\r\n if word in hamWords:\r\n index = hamWords.index(word)\r\n probHam += loggedHam[index]\r\n else:\r\n probHam += loggedHamUNK\r\n\r\n if (probSpam > probHam):\r\n dev_labels.append(1)\r\n else:\r\n dev_labels.append(0)\r\n\r\n else:\r\n for i in range(len(dev_set)):\r\n probSpam = 0\r\n probHam = 0\r\n\r\n for word in dev_set[i]:\r\n if word in spamWords:\r\n index = spamWords.index(word)\r\n probSpam += loggedSpam[index]\r\n else:\r\n probSpam += loggedSpamUNK\r\n\r\n if word in hamWords:\r\n index = hamWords.index(word)\r\n probHam += loggedHam[index]\r\n else:\r\n probHam += loggedHamUNK\r\n dev_spam.append(probSpam)\r\n dev_ham.append(probHam)\r\n # BiGram\r\n bi_spam_words, bi_spam_count = parseIntoBigramList(train_set, train_labels, 1)\r\n bi_ham_words, bi_ham_count = parseIntoBigramList(train_set, train_labels, 0)\r\n\r\n biSpamWords, biSpamProbs, biSpamUNK = createProbabilitiesList(bi_spam_words, bi_spam_count, smoothing_parameter)\r\n biHamWords, biHamProbs, biHamUNK = createProbabilitiesList(bi_ham_words, bi_ham_count, smoothing_parameter)\r\n\r\n biLoggedSpam = np.log(biSpamProbs)\r\n biLoggedSpamUNK = np.log(biSpamUNK)\r\n biLoggedHam = np.log(biHamProbs)\r\n biLoggedHamUNK = np.log(biHamUNK)\r\n\r\n # Bigram\r\n bi_dev_spam = []\r\n bi_dev_ham = []\r\n\r\n for i in range(len(dev_set)):\r\n biProbSpam = 0\r\n biProbHam = 0\r\n curr_email = dev_set[i]\r\n\r\n for j in range(len(curr_email) - 1):\r\n if (j % 2 == 1):\r\n continue\r\n curr_bigram = curr_email[j] + ' ' + curr_email[j + 1]\r\n\r\n if curr_bigram in biSpamWords:\r\n index = biSpamWords.index(curr_bigram)\r\n biProbSpam += biLoggedSpam[index]\r\n else:\r\n biProbSpam += biLoggedSpamUNK\r\n\r\n if curr_bigram in biHamWords:\r\n index = biHamWords.index(curr_bigram)\r\n biProbHam += biLoggedHam[index]\r\n else:\r\n probHam += biLoggedHamUNK\r\n bi_dev_spam.append(probSpam)\r\n bi_dev_ham.append(probHam)\r\n\r\n # Weights the models (1-lambda) multiplier for unigram and lamba multiplier for bigram\r\n dev_labels = getBigram(bi_dev_ham, bi_dev_spam, dev_ham, dev_set, dev_spam, org_dev_labels)\r\n\r\n return dev_labels","def build_bpmf_model(train, alpha=2, dim=10, std=0.01):\n n, m = train.shape\n beta_0 = 1 # scaling factor for lambdas; unclear on its use\n\n # Mean value imputation on training data.\n train = train.copy()\n nan_mask = np.isnan(train)\n train[nan_mask] = train[~nan_mask].mean()\n\n logging.info('building the BPMF model')\n with pm.Model() as bpmf:\n # Specify user feature matrix\n lambda_u = pm.Wishart(\n 'lambda_u', n=dim, V=np.eye(dim), shape=(dim, dim),\n testval=np.random.randn(dim, dim) * std)\n mu_u = pm.Normal(\n 'mu_u', mu=0, tau=beta_0 * lambda_u, shape=dim,\n testval=np.random.randn(dim) * std)\n U = pm.MvNormal(\n 'U', mu=mu_u, tau=lambda_u, shape=(n, dim),\n testval=np.random.randn(n, dim) * std)\n\n # Specify item feature matrix\n lambda_v = pm.Wishart(\n 'lambda_v', n=dim, V=np.eye(dim), shape=(dim, dim),\n testval=np.random.randn(dim, dim) * std)\n mu_v = pm.Normal(\n 'mu_v', mu=0, tau=beta_0 * lambda_v, shape=dim,\n testval=np.random.randn(dim) * std)\n V = pm.MvNormal(\n 'V', mu=mu_v, tau=lambda_v, shape=(m, dim),\n testval=np.random.randn(m, dim) * std)\n\n # Specify rating likelihood function\n R = pm.Normal(\n 'R', mu=t.dot(U, V.T), tau=alpha * np.ones((n, m)),\n observed=train)\n\n logging.info('done building the BPMF model')\n return bpmf","def __init__(self, X, y, sample_weights):\n self.name = \"Gaussian Naive Bayes\"\n self.clf = self.train(X, y, sample_weights)","def learning_proposal(self):\n\n n, s = self.X_select.shape\n\n beta_hat = self.observed_MLE\n\n perturbed_beta = beta_hat.copy()\n nidx = np.random.choice(np.arange(s), min(3, s), replace=False)\n for idx in nidx:\n scale = np.random.choice(self.scales, 1)\n perturbed_beta[idx] += (scale * np.random.standard_normal() *\n np.sqrt(self._beta_cov[idx, idx]))\n \n linpred = self.X_select.dot(perturbed_beta)\n prob = normal_dbn.cdf(linpred)\n perturbed_Y = np.random.binomial(1, prob)\n\n perturbed_MLE = probit_MLE(self.X, perturbed_Y, self.observed_outcome)[0]\n return perturbed_MLE, perturbed_Y","def __init__(self, pseudocount=0):\n self._model = dict()\n self._alpha = pseudocount\n self._N = 0\n self._V = 0","def __init__(self, hidden_size, eps=1e-12):\n super(BertLayerNorm, self).__init__()\n self.weight = nn.Parameter(torch.ones(hidden_size))\n self.bias = nn.Parameter(torch.zeros(hidden_size))\n self.variance_epsilon = eps","def __init__(self, hidden_size, eps=1e-12):\n super(BertLayerNorm, self).__init__()\n self.weight = nn.Parameter(torch.ones(hidden_size))\n self.bias = nn.Parameter(torch.zeros(hidden_size))\n self.variance_epsilon = eps","def __init__(self,\n num_features,\n eps=1e-5,\n momentum=0.1,\n affine=True,\n activation=\"leaky_relu\",\n slope=0.01):\n super(ABN, self).__init__()\n self.num_features = num_features\n self.affine = affine\n self.eps = eps\n self.momentum = momentum\n self.activation = activation\n self.slope = slope\n if self.affine:\n self.weight = nn.Parameter(torch.ones(num_features))\n self.bias = nn.Parameter(torch.zeros(num_features))\n else:\n self.register_parameter('weight', None)\n self.register_parameter('bias', None)\n self.register_buffer('running_mean', torch.zeros(num_features))\n self.register_buffer('running_var', torch.ones(num_features))\n self.reset_parameters()","def do_instance_pruning(self):\n\n # retrieve the probability of predicting fraud for each model (K models)\n # size: K x ChunkSize x 2 (2 for binary labels)\n predict_proba_fraud = [-1] * self.K\n\n # for each instance in the data chunk\n for i, instance in enumerate(self.y_chunk):\n sum_weight = 0\n current_F = 0\n F_vect = np.zeros(self.K) # Fk at each stage\n\n # compute F_k(y) for k = 1...K - the classifiers are sorted in DESCENDING order of weights\n k = -1\n for model in self.models.islice(start=0, stop=self.K, reverse=True):\n k += 1\n clf = model.clf\n sum_weight += model.weight\n\n # compute the current probability\n # if the probability is not initialized we call the `predict_proba` method\n if (type(predict_proba_fraud[k]) is int and predict_proba_fraud[k] == -1) \\\n or (predict_proba_fraud[k].shape[0] != self.S):\n predict_proba_fraud[k] = clf.predict_proba(self.X_chunk)\n\n # check if we have the probabilities of 2 labels (because we're working with BINARY classification)\n # if we don't have the probability of predicting fraud it will be 0 so we don't do anything\n if len(predict_proba_fraud[k][i]) == 2:\n current_F += model.weight * predict_proba_fraud[k][i][1]\n\n # (2) compute the Fk for each example seen at each stage\n F_k = current_F / sum_weight\n F_vect[k] = F_k\n\n # (3) compute the error\n err_x = F_vect - F_vect[-1]\n\n # (4) update the mean and the variance of the error of these training examples for each bin (i,k)\n # we look at the error at each step for the given example\n for k, err in enumerate(err_x):\n # 1 --> we assign Fk to the corresponding bin (i,k) or (j,k)here because we used i index before\n eps = len(self.bins)\n\n for j in range(0, eps):\n if (j / eps) <= F_vect[k] < ((j + 1) / eps):\n self.bins[j][k]['num'] += 1\n\n # 2--> we compute the mean error in this bin\n self.bins[j][k]['mean'] += err\n\n # 2--> we compute the variance of the error in this bin\n # (basically we will just compute the squared error and do the division later)\n self.bins[j][k]['var'] += err ** 2\n\n # if we've assigned it to a bin, break and go to the next stage\n break\n\n # after computing everything we do the division by the total number assigned to a bin\n for i in range(0, len(self.bins)):\n # a bit tricky because sometimes we have bins that don't have any input example --> remains at 0\n for k in range(self.K):\n if self.bins[i][k]['num'] > 0:\n # divide the sum of error by the number of examples in the bin\n self.bins[i][k]['mean'] = self.bins[i][k]['mean'] / self.bins[i][k]['num']\n\n # compute the variance\n self.bins[i][k]['var'] = (self.bins[i][k]['var'] / self.bins[i][k]['num']) - \\\n (self.bins[i][k]['mean']) ** 2","def naiveBayes(self):\n acc = 0\n #for each example in the test-set\n for d in self.dev:\n pred_good = self.prob_True\n pred_bad = self.prob_False\n #calc the probability for yes and no\n for index in range(len(d[0])):\n pred_good *= self.probs_yes[(index,d[0][index])]\n pred_bad *=(self.probs_no[(index,d[0][index])])\n pred = False\n if pred_good >= pred_bad:\n pred = True\n if pred == d[1]:\n acc +=1\n return acc/len(self.dev)","def main():\n parser = argparse.ArgumentParser(description='Implementation of the Naive Bayes and Perceptron classifiers')\n parser.add_argument('--statsmode', help='whether to gather stats or not', choices=['y','Y','N','n'], default='n')\n parser.add_argument('--classifier', help='classifier to use', choices=['BAYES', 'PERCEPTRON'], required=True)\n parser.add_argument('--mode', help='image class to test', choices=['VALIDATION', 'TEST'], default='TEST')\n parser.add_argument('--type', help='image type to train', choices=['DIGIT', 'FACE', 'MNIST'], required=True)\n parser.add_argument('--range', metavar=('START', 'END_EXCLUSIVE'), nargs=2, type=int, help='Range of data to test', default=[0, 100])\n parser.add_argument('--trainpercent', metavar='PERCENT', type=int, help='the percent of training data to use (int out of 100)', default=100, dest='percentage')\n parser.add_argument('--smoothing', type=int, help='Laplace smoothing constant (Naive Bayes)', default=2)\n parser.add_argument('--iterations', type=int, help='Number of times to iterate over training data (Perceptron)', default=5)\n parser.add_argument('--debug', help='Outputs more detailed information to stdout', action='store_true')\n parser.add_argument('--statloops', type=int, help='Number of times the classifier iterates over test data (Statistics only)', default=5)\n args = parser.parse_args()\n # image_type = ImageType.DIGIT if args.type == 'DIGIT' else ImageType.FACE\n image_type = None\n if args.type == 'DIGIT':\n image_type = ImageType.DIGIT\n elif args.type == 'FACE':\n image_type = ImageType.FACE\n else:\n image_type = ImageType.MNIST\n mode = Mode.TEST if args.mode == 'TEST' else Mode.VALIDATION\n if args.statsmode == 'y' or args.statsmode == 'Y':\n run_percentages_classifier(args.classifier, image_type, args)\n else:\n run = run_classifier_bayes if args.classifier == 'BAYES' else run_classifier_perceptron\n run(mode, image_type, args)","def build_posterior(self):\n if self.gp_core.alpha is None:\n self.gp_core.build_posterior()","def __init__(self):\n self.model = GaussianNB();\n self.X = iris.data\n self.y = iris.target","def __init__(self, epsilon=0.05, gamma=0.95, alpha=0.2, numTraining=0, **args):\n args['epsilon'] = epsilon\n args['gamma'] = gamma\n args['alpha'] = alpha\n args['numTraining'] = numTraining\n self.index = 0 # This is always Pacman\n PQLearningAgent.__init__(self, **args)","def run_positive():\n\tbnn = BNNSVGDRegressor(uid=\"bnn-positive-eg\", configfile=\"configs/bnn-positive-eg.json\")\n\tbnn.load(**toy2())\n\tbnn.add_positive_constraint((-5.0, -3.0), lambda x: -x + 5)\n\tbnn.add_positive_constraint((3.0, 5.0), lambda x: x + 5)\n\tbnn.infer()\n\tbnn.plot_pp(plot_title=\"Predictive Posterior Plot\", domain=np.arange(-4, 4, 0.05), ylims=(0, 14))","def __init__(self, hidden_layer_sizes, activation='relu', reg=0.001, k_fold=5, random_state=0):\n print(\"Initialize model Multi-layer Perceptron\")\n self.hidden_layer_sizes = hidden_layer_sizes\n self.activation = activation\n self.reg = reg\n self.k_fold = k_fold\n self.random_state = random_state\n self.model = sklearn.neural_network.MLPClassifier(self.hidden_layer_sizes,\n activation=self.activation,\n alpha=self.reg, max_iter=1000, \n random_state=self.random_state)","def bayes_model(feature_train, help_rank_train, model_name):\n model = MultinomialNB()\n model.fit(feature_train, help_rank_train)\n modelpkl = open(model_name,'wb')\n dump(model, modelpkl, -1)\n return","def __init__(self,nback=1,ntokens_pm=2,ntokens_og=3,stimdim=2,seed=99):\n np.random.seed(seed)\n tr.manual_seed(seed)\n self.nback = nback\n # embedding\n self.ntokens_pm = ntokens_pm\n self.ntokens_og = ntokens_og\n self.stimdim = stimdim\n # emat\n self.randomize_emat()\n return None","def __init__(self, num_features, eps=1e-6, is_bias=True, is_scale=True, is_eps_leanable=False):\n super(FRN, self).__init__()\n\n self.num_features = num_features\n self.init_eps = eps\n self.is_eps_leanable = is_eps_leanable\n self.is_bias = is_bias\n self.is_scale = is_scale\n\n\n self.weight = nn.parameter.Parameter(torch.Tensor(1, num_features, 1, 1), requires_grad=True)\n self.bias = nn.parameter.Parameter(torch.Tensor(1, num_features, 1, 1), requires_grad=True)\n if is_eps_leanable:\n self.eps = nn.parameter.Parameter(torch.Tensor(1), requires_grad=True)\n else:\n self.register_buffer('eps', torch.Tensor([eps]))\n self.reset_parameters()","def __init__(self, alpha=1, beta=1000, basis_func=linear_basis_func,\n prior=None, do_mcmc=True, n_hypers=20, chain_length=2000,\n burnin_steps=2000, rng=None):\n\n if rng is None:\n self.rng = np.random.RandomState(np.random.randint(0, 10000))\n else:\n self.rng = rng\n\n self.X = None\n self.y = None\n self.alpha = alpha\n self.beta = beta\n self.basis_func = basis_func\n if prior is None:\n self.prior = Prior(rng=self.rng)\n else:\n self.prior = prior\n self.do_mcmc = do_mcmc\n self.n_hypers = n_hypers\n self.chain_length = chain_length\n self.burned = False\n self.burnin_steps = burnin_steps\n self.models = None","def __init__(self, **config):\n super(Classifier, self).__init__()\n self.input_dim_drug = config['hidden_dim_drug']\n self.input_dim_protein = config['hidden_dim_protein']\n self.hidden_dims = config['cls_hidden_dims']\n self.visual_attention=config['visual_attention']\n dims = [self.input_dim_drug + self.input_dim_protein] + self.hidden_dims + [2]\n if config['attention']:\n if config['concatenation']:\n dims[0]+=config['cnn_target_filters'][-1]\n else:\n dims[0]=self.input_dim_drug+config['cnn_target_filters'][-1]\n self.predictor = nn.ModuleList([nn.Linear(dims[i], dims[i + 1]) for i in range(len(self.hidden_dims)+1)])\n self.dropout = nn.Dropout(0.25)\n self._initialize()","def build_mod_bpmf_model(train, alpha=2, dim=10, std=0.01):\n n, m = train.shape\n beta_0 = 1 # scaling factor for lambdas; unclear on its use\n\n # Mean value imputation on training data.\n train = train.copy()\n nan_mask = np.isnan(train)\n train[nan_mask] = train[~nan_mask].mean()\n\n # We will use separate priors for sigma and correlation matrix.\n # In order to convert the upper triangular correlation values to a\n # complete correlation matrix, we need to construct an index matrix:\n n_elem = dim * (dim - 1) / 2\n tri_index = np.zeros([dim, dim], dtype=int)\n tri_index[np.triu_indices(dim, k=1)] = np.arange(n_elem)\n tri_index[np.triu_indices(dim, k=1)[::-1]] = np.arange(n_elem)\n\n logging.info('building the BPMF model')\n with pm.Model() as bpmf:\n # Specify user feature matrix\n sigma_u = pm.Uniform('sigma_u', shape=dim)\n corr_triangle_u = pm.LKJCorr(\n 'corr_u', n=1, p=dim,\n testval=np.random.randn(n_elem) * std)\n\n corr_matrix_u = corr_triangle_u[tri_index]\n corr_matrix_u = t.fill_diagonal(corr_matrix_u, 1)\n cov_matrix_u = t.diag(sigma_u).dot(corr_matrix_u.dot(t.diag(sigma_u)))\n lambda_u = t.nlinalg.matrix_inverse(cov_matrix_u)\n\n mu_u = pm.Normal(\n 'mu_u', mu=0, tau=beta_0 * t.diag(lambda_u), shape=dim,\n testval=np.random.randn(dim) * std)\n U = pm.MvNormal(\n 'U', mu=mu_u, tau=lambda_u, shape=(n, dim),\n testval=np.random.randn(n, dim) * std)\n\n # Specify item feature matrix\n sigma_v = pm.Uniform('sigma_v', shape=dim)\n corr_triangle_v = pm.LKJCorr(\n 'corr_v', n=1, p=dim,\n testval=np.random.randn(n_elem) * std)\n\n corr_matrix_v = corr_triangle_v[tri_index]\n corr_matrix_v = t.fill_diagonal(corr_matrix_v, 1)\n cov_matrix_v = t.diag(sigma_v).dot(corr_matrix_v.dot(t.diag(sigma_v)))\n lambda_v = t.nlinalg.matrix_inverse(cov_matrix_v)\n\n mu_v = pm.Normal(\n 'mu_v', mu=0, tau=beta_0 * t.diag(lambda_v), shape=dim,\n testval=np.random.randn(dim) * std)\n V = pm.MvNormal(\n 'V', mu=mu_v, tau=lambda_v, shape=(m, dim),\n testval=np.random.randn(m, dim) * std)\n\n # Specify rating likelihood function\n R = pm.Normal(\n 'R', mu=t.dot(U, V.T), tau=alpha * np.ones((n, m)),\n observed=train)\n\n logging.info('done building the BPMF model')\n return bpmf","def model_setup(self):\n self.DNN = SganMLP(self.settings.number_of_bins)\n self.D = SganMLP(self.settings.number_of_bins)\n self.G = Generator()","def bias_prior(self):","def Bayes_classifier(pi, x0, lamb):\n D = len(x0)\n ans = [1-pi, pi]\n for y in range(2):\n arg = [poisson.pmf(x0[d], lamb[y][d]) for d in range(D)]\n ans[y] *= np.prod(arg)\n return np.argmax(ans)","def __init__(self, hidden_size, eps=1e-12):\n super(BertLayerNorm, self).__init__()\n self.weight = nn.Parameter(torch.ones(hidden_size))\n self.bias = nn.Parameter(torch.zeros(hidden_size))\n self.variance_epsilon = eps","def __init__(self, hidden_size, eps=1e-12):\n super(BertLayerNorm, self).__init__()\n self.weight = nn.Parameter(torch.ones(hidden_size))\n self.bias = nn.Parameter(torch.zeros(hidden_size))\n self.variance_epsilon = eps","def __init__(self, hidden_size, eps=1e-12):\n super(BertLayerNorm, self).__init__()\n self.weight = nn.Parameter(torch.ones(hidden_size))\n self.bias = nn.Parameter(torch.zeros(hidden_size))\n self.variance_epsilon = eps","def __init__(self, hidden_size, eps=1e-12):\n super(BertLayerNorm, self).__init__()\n self.weight = nn.Parameter(torch.ones(hidden_size))\n self.bias = nn.Parameter(torch.zeros(hidden_size))\n self.variance_epsilon = eps","def __init__(self, hidden_size, eps=1e-12):\n super(BertLayerNorm, self).__init__()\n self.weight = nn.Parameter(torch.ones(hidden_size))\n self.bias = nn.Parameter(torch.zeros(hidden_size))\n self.variance_epsilon = eps","def __init__(self, frames_n, state_size, action_size, hidden_layer_size):\n super(ActorCritic_Beta, self).__init__()\n \n self.frames_n = frames_n \n self.state_size = state_size\n self.action_size = action_size\n self.hidden_layer_size = hidden_layer_size\n \n # ACTOR\n self.actor_alphas_layer_1 = nn.Linear(in_features=self.frames_n * self.state_size, out_features=self.hidden_layer_size)\n self.actor_alphas_layer_2 = nn.Linear(in_features=self.hidden_layer_size, out_features=self.hidden_layer_size)\n self.actor_alphas_layer_3 = nn.Linear(in_features=self.hidden_layer_size, out_features=self.action_size)\n \n self.actor_betas_layer_1 = nn.Linear(in_features=self.frames_n * self.state_size, out_features=self.hidden_layer_size)\n self.actor_betas_layer_2 = nn.Linear(in_features=self.hidden_layer_size, out_features=self.hidden_layer_size)\n self.actor_betas_layer_3 = nn.Linear(in_features=self.hidden_layer_size, out_features=self.action_size)\n \n # CRITIC \n self.critic_layer_1 = nn.Linear(in_features=self.frames_n * self.state_size, out_features=self.hidden_layer_size)\n self.critic_layer_2 = nn.Linear(in_features=self.hidden_layer_size, out_features=self.hidden_layer_size)\n self.critic_layer_3 = nn.Linear(in_features=self.hidden_layer_size, out_features=1)","def __init__(self, in_features, out_features):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n self.params = {'weight': np.random.normal(loc = 0, scale=0.0001, size=(out_features,in_features)),\\\n 'bias': np.zeros((1, out_features))}\n \n self.grads = {'weight': np.zeros((out_features,in_features)),\\\n 'bias': np.zeros((1, out_features))}\n ########################\n # END OF YOUR CODE #\n #######################","def __init__(self, p1_proba=0.5):\n self.p1_proba = p1_proba","def __init__(self, maxBirthProb, clearProb):\r\n\r\n self.maxBirthProb = maxBirthProb\r\n self.clearProb = clearProb","def __init__(self, train_data, test_data):\n self.train_data = train_data\n self.test_data = test_data\n\n # Emission and transition probability distributions\n self.emission_PD: ConditionalProbDist = None\n self.transition_PD: ConditionalProbDist = None\n self.states = []\n\n self.viterbi = []\n self.backpointer = []","def get_untrained_naive_bayes(bool_var, data_desc, ml_models, train_feature, train_result, \n test_feature, option):\n # just return case we dont want any naive bayes\n if not bool_var: \n return\n\n if option != 'optimization':\n nb_name = 'naive_bayes' + get_suffix_ml_model()\n [nb] = get_optimal_param(data_desc, 'naive_bayes') \n multi_nb = MultiOutputRegressor(nb)\n nb_train_feat = list(train_feature)\n nb_test_feat = list(test_feature)\n ml_models.append([nb_name, multi_nb, nb_train_feat, nb_test_feat])\n\n # try all configuration\n else:\n nb_name_lst = ['gaussian', 'multinomial', 'multi_bernoulli']\n nb_obj_lst = [GaussianNB(), MultinomialNB(), BernoulliNB()]\n for i in range(len(nb_name_lst)):\n nb_name = 'naive_bayes' + get_suffix_ml_model()\n nb_name += get_suffix_configuration([nb_name_lst[i]])\n nb = nb_obj_lst[i]\n multi_nb = MultiOutputRegressor(nb)\n ml_models.append([nb_name, multi_nb, list(train_feature),\n list(test_feature)])","def test_bpe_embedder(self, resource_loader):\n config = {\n \"model_type\": \"tagger\",\n \"example_type\": ENTITY_EXAMPLE_TYPE,\n \"label_type\": ENTITIES_LABEL_TYPE,\n \"model_settings\": {\"classifier_type\": \"embedder\"},\n \"params\": { # default token_spans_pooling_type is \"first\"\n \"emb_dim\": 30, \"tokenizer_type\": \"bpe-tokenizer\", \"add_terminals\": True\n },\n }\n model = ModelFactory.create_model_from_config(ModelConfig(**config))\n examples = self.labeled_data.queries()\n labels = self.labeled_data.entities()\n model.initialize_resources(resource_loader, examples, labels)\n model.fit(examples, labels)\n model_predictions_assertions(model)\n\n config = {**config, \"params\": {**config[\"params\"], \"token_spans_pooling_type\": \"mean\"}}\n model = ModelFactory.create_model_from_config(ModelConfig(**config))\n model.initialize_resources(resource_loader, examples, labels)\n model.fit(examples, labels)\n model_predictions_assertions(model)\n\n config = {**config, \"params\": {**config[\"params\"], \"token_spans_pooling_type\": \"max\"}}\n model = ModelFactory.create_model_from_config(ModelConfig(**config))\n model.initialize_resources(resource_loader, examples, labels)\n model.fit(examples, labels)\n model_predictions_assertions(model)\n\n config = {**config, \"params\": {**config[\"params\"], \"token_spans_pooling_type\": \"mean_sqrt\"}}\n model = ModelFactory.create_model_from_config(ModelConfig(**config))\n model.initialize_resources(resource_loader, examples, labels)\n model.fit(examples, labels)\n model_predictions_assertions(model)\n\n config = {**config, \"params\": {**config[\"params\"], \"token_spans_pooling_type\": \"last\"}}\n model = ModelFactory.create_model_from_config(ModelConfig(**config))\n model.initialize_resources(resource_loader, examples, labels)\n model.fit(examples, labels)\n model_predictions_assertions(model)\n\n config = {**config, \"params\": {\n **config[\"params\"], \"use_crf_layer\": False, \"token_spans_pooling_type\": \"first\"}}\n model = ModelFactory.create_model_from_config(ModelConfig(**config))\n model.initialize_resources(resource_loader, examples, labels)\n model.fit(examples, labels)\n model_predictions_assertions(model)","def test_class():\n riskfree = .03\n maturity = 30/365\n moneyness = np.linspace(-.04, .04, 10)\n premium = np.ones_like(moneyness) * .05\n call = True\n data = {'riskfree': riskfree, 'maturity': maturity,\n 'moneyness': moneyness, 'call': call, 'premium': premium}\n\n sigma = .13\n bsm = BSmodel(sigma, data)\n\n weights = [.63]\n means = [-.01, .09]\n stds = [.16, .05]\n param = weights + means + stds\n mbs = MBSmodel(param, data)\n\n param_a, param_p, param_c = 4, 1.5, -.05\n gb2 = GB2model([param_a, param_p, param_c], data)\n print(gb2.get_pnames())\n\n plt.figure()\n for model in [bsm, mbs, gb2]:\n plt.plot(moneyness, model.density(moneyness), label=model.get_name())\n plt.legend()\n plt.show()\n\n plt.figure()\n for model in [bsm, mbs, gb2]:\n plt.plot(moneyness, model.premium(), label=model.get_name())\n plt.legend()\n plt.show()\n\n plt.figure()\n for model in [bsm, mbs, gb2]:\n plt.plot(moneyness, model.impvol(), label=model.get_name())\n plt.legend()\n plt.show()\n\n print('BS objective function = %.4f' % bsm.objective(sigma))\n print('GB2 objective function = %.4f'\n % gb2.objective([param_a, param_p, param_c]))","def run_bayes(self, prior, fill_half_light=True, verbose=True):\n # Checks\n if self.Pchance is None:\n raise IOError(\"Set Pchance before calling this method\")\n # Priors\n self.calc_priors(prior['S'], method=prior['M'])\n # Fill?\n if fill_half_light:\n prior['theta']['r_half'] = self.candidates['half_light'].values\n self.set_theta_prior(prior['theta'])\n # P(O|x)\n self.calc_POx()\n #\n if verbose:\n print(\"All done with Bayes\")","def trainUsingNNOnPenDigitData(actualData, labels, testData, testLabels):\n # Initialize variables\n epoch = 40\n eta = 0.01\n inputNeurons = actualData.shape[1]\n hiddenNeurons = 10\n outputNeurons = 4\n\n # Initialize weights and bias of hidden layer and output layer\n weightsHidden = np.random.uniform(-1, 0.99, size=(inputNeurons+1, hiddenNeurons))\n weightsOutput = np.random.uniform(-1, 0.99, size=(hiddenNeurons+1, outputNeurons))\n\n biasInput = np.ones((actualData.shape[0], 1))\n actualData = np.append(actualData, biasInput, axis=1)\n biasTest = np.ones((testData.shape[0], 1))\n testData = np.append(testData, biasTest, axis=1)\n\n # Outer loop for all the Epochs\n for i in range(epoch):\n print(\"Epoch: \", i)\n for index, row in enumerate(actualData):\n\n # Forward Propogation\n hiddenInputs = np.dot(row, weightsHidden)\n # hiddenActivation = nn.sigmoid(hiddenInputs)\n hiddenActivation = nn.sigmoid(hiddenInputs)\n hiddenActivation = np.append(hiddenActivation, [1], axis=0)\n outputInputs = np.dot(hiddenActivation, weightsOutput)\n sMaxOutput = nn.softMax(outputInputs)\n\n # Calculating stuff for backpropogation\n crossEntropyError = nn.calculateError(sMaxOutput, labels[index])\n\n # BackPropogation from Output to Hidden Layer\n derCrossEntropyErrors = nn.calculateDerCrossEntropy(sMaxOutput, labels[index])\n derSoftMaxOutputs = nn.calculateDerSoftMax(outputInputs)\n derOutputWeights = hiddenActivation\n updateWeightsOutput = np.matmul(derOutputWeights.reshape(hiddenNeurons+1, 1),\n np.transpose(derCrossEntropyErrors * derSoftMaxOutputs).reshape(1, 4))\n\n # BackPropogation from Hidden to Input Layer\n derTotalError = np.array([])\n temp1 = derCrossEntropyErrors * derSoftMaxOutputs\n\n for p, eachWeight in enumerate(weightsOutput):\n derTotalError = np.append(derTotalError, np.dot(np.transpose(temp1), eachWeight))\n\n derTotalError = derTotalError[:-1]\n derSigmoidHiddenInputs = nn.derivativeSigmoid(hiddenInputs)\n temp2 = derTotalError * derSigmoidHiddenInputs\n\n replicatedInput = nn.replicateRow(row, hiddenNeurons)\n\n updateWeightsInput = np.zeros(weightsHidden.shape)\n for p, eachRow in enumerate(np.transpose(replicatedInput)):\n updateWeightsInput[p] = temp2 * eachRow\n\n weightsOutput = weightsOutput - eta * updateWeightsOutput\n weightsHidden = weightsHidden - eta * updateWeightsInput\n\n correct = 0\n for j, r in enumerate(testData):\n # Forward Propogation\n hiddenInputs = np.dot(r, weightsHidden)\n # hiddenActivation = nn.sigmoid(hiddenInputs)\n hiddenActivation = nn.tanh(hiddenInputs)\n hiddenActivation = np.append(hiddenActivation, [1], axis=0)\n outputInputs = np.dot(hiddenActivation, weightsOutput)\n\n # Calculating stuff for backpropogation\n sMaxOutput = nn.softMax(outputInputs)\n predictedLabel = np.argmax(sMaxOutput) + 1\n if predictedLabel == (np.argmax(testLabels[j]) + 1):\n correct += 1\n\n print(\"Correct \", correct)\n print(\"Total \", testData.shape[0])\n accuracy = float(correct) / testData.shape[0]\n print(\"Accuracy: \", accuracy)","def __init__(self, n_source, t_base):\n self.null = BetaBernouilli(1.0, 1.0) # p(NULL) ~ Beta(1, 1)\n self.a_table = AlignmentDistribution(GammaPrior(1.0, 1.0, 4.0))\n self.t_base = t_base\n self.t_table = [PYP(self.t_base, PYPPrior(1.0, 1.0, 1.0, 1.0, 0.1, 1.0))\n for _ in xrange(n_source)]","def obtain_training_parameters(para, x, y, alg = 'LR'):\n \n \n global omega\n \n # Iterate to find the optimal parameters\n if alg == 'LR': # logistic regression\n omega = np.zeros((3, 1))\n alpha = para.step_size # step size\n for i in range(para.iteration):\n grad = np.zeros((3, 1))\n for i in range(len(x[:, 0])):\n grad += np.reshape(x[i, :], (3, 1)) * (-y[i] + 1 / (1 + np.exp(-np.dot(x[i, :], omega))))\n omega -= alpha * grad \n \n elif alg == 'GNB': # Gaussian Naive Bayes\n # get counts for each class\n itszero = 0\n itsone = 0\n for i in range(len(y)):\n if y[i] == 1:\n itsone += 1\n else:\n itszero += 1\n \n # probability of see y\n theta0 = itszero / len(y)\n theta1 = 1 - theta0\n \n # mean of omega\n mew00 = 0\n mew01 = 0\n mew02 = 0\n mew10 = 0\n mew11 = 0\n mew12 = 0\n for i in range(len(y)):\n if y[i] == 0:\n mew00 += x[i, 0] / itszero\n mew01 += x[i, 1] / itszero\n mew02 += x[i, 2] / itszero\n else:\n mew10 += x[i, 0] / itsone\n mew11 += x[i, 1] / itsone\n mew12 += x[i, 2] / itsone\n \n # variance of omega \n sigma00 = 0\n sigma01 = 0\n sigma02 = 0\n sigma10 = 0\n sigma11 = 0\n sigma12 = 0\n for i in range(len(y)):\n if y[i] == 0:\n sigma00 += (x[i, 0] - mew00)**2 / itszero\n sigma01 += (x[i, 1] - mew01)**2 / itszero\n sigma02 += (x[i, 2] - mew02)**2 / itszero\n else:\n sigma10 += (x[i, 0] - mew10)**2 / itsone\n sigma11 += (x[i, 1] - mew11)**2 / itsone\n sigma12 += (x[i, 2] - mew12)**2 / itsone\n \n # store these parameters into the name \"omage\"\n omega = [theta0, theta1, mew00, mew01, mew02, mew10, mew11, mew12,\n sigma00, sigma01, sigma02, sigma10, sigma11, sigma12] \n \n else: # Gaussian Mixture\n pass\n \n return omega","def betabinom_artifact_model_probability(data,\n prior_p=betabinom_p_prior[0],\n prior_beta=betabinom_beta_prior[0],\n mutation_object=True):\n\n if mutation_object is True:\n trajectories = data.data\n else:\n trajectories = data\n\n # initialise list of samples for p integration\n int_p = []\n # integral over betabinom p parameter\n for p_sample in prior_p[0, :]:\n # initialise list of samples for beta integration\n int_beta = []\n # integrate over beta parameter\n for beta_sample in prior_beta[0, :]:\n # For each combination of p and beta parameters compute\n # lieklihood of observing a given time-series conditional\n # on initial time-point.\n alpha_sample = beta_sample*p_sample/(1-p_sample)\n # compute likelihood for each individual omiting first time point\n ind_likelihoods = []\n for ind_traj in trajectories:\n likelihood = betabinom.pmf(k=ind_traj[1:].AO,\n n=ind_traj[1:].DP,\n a=alpha_sample,\n b=beta_sample)\n ind_likelihoods.append(np.product(likelihood))\n # for each beta append the total likelihood (product individuals).\n int_beta.append(np.product(ind_likelihoods))\n # For each p, compute the likelihood marginalised over beta\n int_p.append(\n np.trapz(x=prior_beta[0, :],\n y=int_beta*prior_beta[1, :]))\n \n # marginalise likelihood over p\n mutation_prob = np.trapz(x=prior_p[0, :],\n y=int_p*prior_p[1, :])\n\n if mutation_object is True:\n # return updated model_comparison object \n data.betabinom_artifact_prob = mutation_prob\n return data\n else:\n # return marginalised likelihood.\n return mutation_prob","def update_probabilities(self):\n self.probabilities = self.pheromones**self.EXP_PH * self.mcv**self.EXP_MCV","def sample_posterior(self):\n if(self.Bayesian):\n for i in range(self.num_layers):\n getattr(self, 'LSTMCell%i'%(i+1)).sample_posterior()","def naiveBayes(x_train, x_test, y_train):\n gnb = GaussianNB()\n y_pred = gnb.fit(x_train, y_train).predict(x_test)\n return y_pred","def test_fit_prep_proba():\n args = get_layer('fit', 'manual', 'temporal', True, True, window=2, step_size=3)\n run_layer(*args)","def __init__(self, clf, y_real, y_pred, y_proba):\n self.clf = clf\n self.y_real = y_real\n self.y_pred = y_pred\n self.y_proba = y_proba","def __init__(self) :\n self.probabilities_ = None","def __init__(self) :\n self.probabilities_ = None","def __init__(self) :\n self.probabilities_ = None","def __init__(self, prior: float, beta: float = 0., gamma: float = 1.0):\n super(NonNegativePULoss, self).__init__()\n\n self.beta = beta\n self.prior = prior\n self.gamma = gamma\n self.loss_fn = torch.nn.CrossEntropyLoss(reduction='none')","def __init__(self, b=0, drop_rate=0.5, pretrained=True):\n\n # Calls the super for the nn.Module.\n super(SelectiveNet, self).__init__()\n\n # Loads the EfficientNet encoder.\n if pretrained:\n self.encoder = EfficientNet.from_pretrained(f\"efficientnet-b{str(b)}\")\n else:\n self.encoder = EfficientNet.from_name(f\"efficientnet-b{str(b)}\")\n self.encoder_pool = nn.AdaptiveAvgPool2d(1)\n\n # Defines a hidden layer.\n self.hidden = nn.Linear(2560, 512)\n\n # Initialises the classifier for generating predictions.\n self.classifier = nn.Linear(512, 2)\n\n # Initialises the selective branch for generating selection scores.\n self.selective_hidden = nn.Linear(512, 512)\n self.selective_batch_norm = nn.BatchNorm1d(512)\n self.selective_regression = nn.Linear(512, 1)\n\n # Initialises the auxiliary output used by the model during training.\n self.auxiliary_output = nn.Linear(512, 2)\n\n # Stores the dropout rate in the object.\n self.drop_rate = drop_rate","def __init__(self, in_features, out_features):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n\n\n self.params = {'weight': 0.0001 * np.random.randn(out_features, in_features), 'bias': np.zeros((out_features, 1))}\n self.grads = {'weight': np.zeros((out_features, in_features)), 'bias': np.zeros((out_features, 1))}\n\n\n\n ########################\n # END OF YOUR CODE #\n #######################","def construct_parameters(self, method= \"random\", W = np.zeros(1), b = np.zeros(1), initialization=True):\n #W = np.asarray(W, dtype=object)\n #b = np.asarray(b, dtype=object)\n for i in reversed(range(1,len(self.architecture))):\n \n if initialization==True:\n if self.activations[i-1] in {'relu' , 'leakyrelu' , 'ealu'}:\n variance = np.sqrt(2/(self.architecture[i-1])) #He initialization\n elif self.activations[i-1] == 'tanh':\n variance = np.sqrt(6/(self.architecture[i-1] + self.architecture[i])) #Xavier initialization\n elif self.activations[i-1] in ('swish' , 'sigmoid'):\n variance = np.sqrt(1/(self.architecture[i-1]))\n else:\n variance = 1\n \n elif initialization == False:\n variance = 1\n \n if method == 'random':\n self.weights_and_biases[f'W{i}'] = np.random.rand(self.architecture[i-1], self.architecture[i])*variance #randomised initialisation \n self.weights_and_biases[f'b{i}'] = np.zeros(self.architecture[i])*variance\n \n elif method == 'manual': #manual initialisation using given weights and biases\n self.weights_and_biases[f'W{i}'] = W[i-1]\n self.weights_and_biases[f'b{i}'] = b[i-1] \n return self.weights_and_biases","def __post_init__(self) -> None:\n super().__post_init__()\n\n # We generate our instance seed pairs once\n is_keys = self.get_instance_seed_keys_of_interest()\n\n # Budgets, followed by lots of sanity-checking\n eta = self._eta\n min_budget = self._min_budget\n max_budget = self._max_budget\n\n if max_budget is not None and min_budget is not None and max_budget < min_budget:\n raise ValueError(\"Max budget has to be larger than min budget.\")\n\n if self.uses_instances:\n if isinstance(min_budget, float) or isinstance(max_budget, float):\n raise ValueError(\"Successive Halving requires integer budgets when using instances.\")\n\n min_budget = min_budget if min_budget is not None else 1\n max_budget = max_budget if max_budget is not None else len(is_keys)\n\n if max_budget > len(is_keys):\n raise ValueError(\n f\"Max budget of {max_budget} can not be greater than the number of instance-seed \"\n f\"keys ({len(is_keys)}).\"\n )\n\n if max_budget < len(is_keys):\n logger.warning(\n f\"Max budget {max_budget} does not include all instance seed \" f\"pairs ({len(is_keys)}).\"\n )\n else:\n if min_budget is None or max_budget is None:\n raise ValueError(\n \"Successive Halving requires the parameters min_budget and max_budget defined in the scenario.\"\n )\n\n if len(is_keys) != 1:\n raise ValueError(\"Successive Halving supports only one seed when using budgets.\")\n\n if min_budget is None or min_budget <= 0:\n raise ValueError(\"Min budget has to be larger than 0.\")\n\n budget_type = \"INSTANCES\" if self.uses_instances else \"BUDGETS\"\n logger.info(\n f\"Successive Halving uses budget type {budget_type} with eta {eta}, \"\n f\"min budget {min_budget}, and max budget {max_budget}.\"\n )\n\n # Pre-computing Successive Halving variables\n max_iter = self._get_max_iterations(eta, max_budget, min_budget)\n budgets, n_configs = self._compute_configs_and_budgets_for_stages(eta, max_budget, max_iter)\n\n # Global variables\n self._min_budget = min_budget\n self._max_budget = max_budget\n\n # Stage variables, depending on the bracket (0 is the bracket here since SH only has one bracket)\n self._max_iterations: dict[int, int] = {0: max_iter + 1}\n self._n_configs_in_stage: dict[int, list] = {0: n_configs}\n self._budgets_in_stage: dict[int, list] = {0: budgets}"],"string":"[\n \"def init_bn(bn):\\n \\n bn.bias.data.fill_(0.)\\n bn.running_mean.data.fill_(0.)\\n bn.weight.data.fill_(1.)\\n bn.running_var.data.fill_(1.)\",\n \"def naiveBayes(train_set, train_labels, dev_set, smoothing_parameter, pos_prior):\\n # TODO: Write your code here\\n # return predicted labels of development set\\n #\\n ### len(train_set) 8000, len(dev) = 5000 P(pos) = 0.8 \\n #### 0.55, 4.0, 0.30 ----------- 0.766\\n #### 0.25 3.5 0.3 -------------- 0.766\\n print(pos_prior)\\n smoothing_parameter = 3.5\\n pos_total_word = 0\\n neg_total_word = 0\\n pos_word_dict = {}\\n neg_word_dict = {}\\n dicts = [neg_word_dict, pos_word_dict]\\n for i, sentence in enumerate(train_set):\\n\\n if train_labels[i] == 1: # positive reviews\\n for word in sentence:\\n pos_total_word += 1 \\n if word in stop_words:\\n continue\\n if word in pos_word_dict:\\n pos_word_dict[word] += 1\\n else :\\n pos_word_dict[word] = 1\\n\\n else: # negative reviews\\n for word in sentence:\\n neg_total_word += 1 \\n if word in stop_words:\\n continue\\n if word in neg_word_dict:\\n neg_word_dict[word] += 1\\n else :\\n neg_word_dict[word] = 1\\n\\n\\n prob = {}\\n denominator_pos = pos_total_word + smoothing_parameter * (len(pos_word_dict) + 1)\\n denominator_neg = neg_total_word + smoothing_parameter * (len(neg_word_dict) + 1)\\n de = [denominator_neg, denominator_pos]\\n\\n for t, dictionary in enumerate(dicts):\\n for key, value in dictionary.items():\\n if key not in prob:\\n prob[key] = {0 : 0, 1 : 0}\\n if smoothing_parameter != 0:\\n prob[key][1 - t] = -1 * np.log(smoothing_parameter / de[t]) \\n # print(prob[key][1 - t])\\n\\n prob[key][t] = -1 * np.log((value + smoothing_parameter) / de[t]) \\n \\n\\n revised_prob = {}\\n for key, value in prob.items():\\n if np.abs(value[0] - value[1]) >= 0.25:\\n revised_prob[key] = value \\n\\n print(len(revised_prob))\\n\\n dev_labels = []\\n num_0 = 0\\n for i, sentence in enumerate(dev_set):\\n pos_odd = -1 * np.log(pos_prior)\\n neg_odd = -1 * np.log(1.0 - pos_prior)\\n for word in sentence:\\n if word in revised_prob:\\n pos_odd += revised_prob[word][1]\\n neg_odd += revised_prob[word][0]\\n \\n if pos_odd > neg_odd:\\n num_0 += 1\\n dev_labels.append(1 if pos_odd <= neg_odd else 0)\\n print(num_0)\\n\\n \\n #### bigram model \\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n return dev_labels\",\n \"def naiveBayesMixture(train_set, train_labels, dev_set, bigram_lambda,unigram_smoothing_parameter, bigram_smoothing_parameter, pos_prior):\\n\\n # TODO: Write your code here\\n # return predicted labels of development set\\n\\n # counters for Training Phase\\n ham = Counter()\\n ham_bi = Counter()\\n spam = Counter()\\n spam_bi = Counter()\\n\\n for string, label in zip(train_set, train_labels):\\n for i in range(len(string)):\\n word = string[i]\\n if i != len(string)-1:\\n word_bi = string[i] + ' ' + string[i+1]\\n if label == 1:\\n ham_bi.update({word_bi:1})\\n else:\\n spam_bi.update({word_bi:1})\\n if label == 1:\\n ham.update({word:1})\\n else:\\n spam.update({word:1})\\n\\n ham_len = 0\\n for w in ham:\\n ham_len += ham[w]\\n spam_len = 0\\n for w in spam:\\n spam_len += spam[w]\\n \\n hambi_len = 0\\n for w in ham_bi:\\n hambi_len += ham_bi[w]\\n spambi_len = 0\\n for w in spam_bi:\\n spambi_len += spam_bi[w]\\n\\n # labels for Development Phase\\n dev_labels = []\\n # dicts for P(word|ham) and P(word|spam)\\n p_ham = {}\\n p_spam = {}\\n p_hambi = {}\\n p_spambi = {}\\n\\n # develop likelihoods based on dev_set\\n for word in ham:\\n numerator = ham[word] + unigram_smoothing_parameter\\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\\n p_ham[word] = numerator / denominator\\n for word in spam:\\n numerator = spam[word] + unigram_smoothing_parameter\\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\\n p_spam[word] = numerator / denominator\\n\\n for word_bi in ham_bi:\\n numerator = ham_bi[word_bi] + bigram_smoothing_parameter\\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\\n p_hambi[word_bi] = numerator / denominator\\n for word_bi in spam_bi:\\n numerator = spam_bi[word_bi] + bigram_smoothing_parameter\\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\\n p_spambi[word_bi] = numerator / denominator\\n \\n numerator = unigram_smoothing_parameter\\n denominator = ham_len + unigram_smoothing_parameter*(len(ham))\\n p_ham_zero = numerator / denominator\\n denominator = spam_len + unigram_smoothing_parameter*(len(spam))\\n p_spam_zero = numerator / denominator\\n\\n numerator = bigram_smoothing_parameter\\n denominator = hambi_len + bigram_smoothing_parameter*(len(ham_bi))\\n p_hambi_zero = numerator / denominator\\n denominator = spambi_len + bigram_smoothing_parameter*(len(spam_bi))\\n p_spambi_zero = numerator / denominator\\n\\n for string in dev_set:\\n p_words_ham = math.log(pos_prior)\\n p_words_spam = math.log(1 - pos_prior)\\n\\n p_words_hambi = math.log(pos_prior)\\n p_words_spambi = math.log(1 - pos_prior)\\n \\n for i in range(len(string)):\\n word = string[i]\\n if word in p_ham:\\n p_words_ham += math.log(p_ham[word])\\n else:\\n p_words_ham += math.log(p_ham_zero)\\n if word in p_spam:\\n p_words_spam += math.log(p_spam[word])\\n else:\\n p_words_spam += math.log(p_spam_zero)\\n\\n if i != len(string)-1:\\n word_bi = string[i] + ' ' + string[i+1]\\n if word_bi in p_hambi:\\n p_words_hambi += math.log(p_hambi[word_bi])\\n else:\\n p_words_hambi += math.log(p_hambi_zero)\\n if word_bi in p_spambi:\\n p_words_spambi += math.log(p_spambi[word_bi])\\n else:\\n p_words_spambi += math.log(p_spambi_zero)\\n\\n p_ham_mix = p_words_ham*(1-bigram_lambda) + p_words_hambi*bigram_lambda\\n p_spam_mix = p_words_spam*(1-bigram_lambda) + p_words_spambi*bigram_lambda\\n\\n dev_labels.append(p_ham_mix >= p_spam_mix)\\n\\n return dev_labels\",\n \"def __init__(self, bnn_omega, components):\\n BaseBNNPrior.__init__(self, bnn_omega, components)\\n self.params_to_exclude = []\\n self.set_params_list(self.params_to_exclude)\\n self.set_comps_qphi_to_e1e2()\",\n \"def __init__(self, ebunch=None):\\n super(BayesianModel, self).__init__()\\n if ebunch:\\n self.add_edges_from(ebunch)\\n self.cpds = []\\n self.cardinalities = self.get_cardinality()\\n self.probs = dict()\",\n \"def test_Bernoulli_NB_estimators():\",\n \"def __init__(self, dim, switch=False, **kwargs):\\n # Define the hyperparameters\\n super(PAE, self).__init__(dim, **kwargs)\\n # Initialize the models\\n self.encode_ = Encoder([self.h_dim, self.z_dim])\\n self.decode_ = Decoder([self.h_dim, self.image_size])\\n self.b = RealNVP(num_coupling_layers=6, z_dim=self.z_dim)\\n self.scaler = MinMaxScaler()\\n # Build the models\\n self.encode_.build(input_shape=(None, self.image_size))\\n self.decode_.build(input_shape=(None, self.z_dim))\\n self.b.build(input_shape=(None, self.z_dim))\\n # Use bijecter in incode or not\\n self.switch = switch\",\n \"def naiveBayes(train_set, train_labels, dev_set, smoothing_parameter, pos_prior):\\n # TODO: Write your code here\\n # Bag of words model\\n smoothing_parameter = .007 # override smoothing parameter\\n posWordBag = {}\\n negWordBag = {}\\n for reviewIndex, review in enumerate(train_set):\\n for word in review:\\n if isWordTooCommon(word) == True: # If word is too common, skip the word\\n continue\\n else:\\n if train_labels[reviewIndex] == 1: # Positive\\n if word not in posWordBag.keys():\\n posWordBag[word] = 1\\n else:\\n posWordBag[word] += 1\\n elif train_labels[reviewIndex] == 0: # Negative\\n if word not in negWordBag.keys():\\n negWordBag[word] = 1\\n else:\\n negWordBag[word] += 1\\n \\n posProbList, posUNK = genProb(posWordBag, smoothing_parameter)\\n negProbList, negUNK = genProb(negWordBag, smoothing_parameter)\\n\\n # Done with training. Now development with MAP\\n dev_labels = []\\n for devRev in dev_set:\\n reviewIsPos = math.log10(pos_prior)\\n reviewIsNeg = math.log10(1 - pos_prior)\\n for word in devRev:\\n if isWordTooCommon(word) == True: # If word is too common, skip the word\\n continue\\n else:\\n if word in posProbList.keys():\\n reviewIsPos += posProbList[word]\\n else:\\n reviewIsPos += posUNK\\n if word in negProbList.keys():\\n reviewIsNeg += negProbList[word]\\n else:\\n reviewIsNeg += negUNK\\n if reviewIsPos < reviewIsNeg:\\n dev_labels.append(0)\\n else:\\n dev_labels.append(1)\\n\\n # return predicted labels of development set\\n return dev_labels\",\n \"def __init__(self, bandits: List[Bandit], epsilon:float = None):\\n self.bandits = bandits\\n self.epsilon = epsilon\\n # mu_pri and var_pri are hypermaterers for prior distribution\\n self.mu_pri = np.zeros(len(self.bandits))\\n self.var_pri = np.ones(len(self.bandits))*5\\n # mu and var are hyperparameters for posterior distribution\\n self.mu = self.mu_pri\\n self.var = self.var_pri\\n self.var0 = 1 # 1 is taken but any can be taken no prob upto a limit constant of inintial distribution\\n self.logging = Logging()\",\n \"def naiveBayes(train_set, train_labels, dev_set, smoothing_parameter, pos_prior):\\r\\n # TODO: Write your code here\\r\\n # return predicted labels of development set\\r\\n retval = []\\r\\n smoothing_parameter = 0.0055\\r\\n # Generate a unigram BOW for both positive and negative reviews, choose the top 2500 words\\r\\n pos_bow, neg_bow = generate_unigram_BOW(train_set, train_labels)\\r\\n sorted_pos = sorted(pos_bow.items(), key=lambda x: x[1], reverse = True)\\r\\n sorted_neg = sorted(neg_bow.items(), key=lambda x: x[1], reverse = True)\\r\\n pos_words = sorted_pos[:].copy()\\r\\n neg_words = sorted_neg[:].copy()\\r\\n\\r\\n pos_bi_bow, neg_bi_bow = generate_bigram_BOW(train_set, train_labels)\\r\\n sorted_bi_pos = sorted(pos_bi_bow.items(), key=lambda x: x[1], reverse = True)\\r\\n sorted_bi_neg = sorted(neg_bi_bow.items(), key=lambda x: x[1], reverse = True)\\r\\n bi_pos_words = sorted_bi_pos[:].copy()\\r\\n bi_neg_words = sorted_bi_neg[:].copy()\\r\\n\\r\\n # Calculate the log probabilities each word given type\\r\\n pos_count = sum(pair[1] for pair in pos_words)\\r\\n neg_count = sum(pair[1] for pair in neg_words)\\r\\n bi_pos_count = sum(pair[1] for pair in bi_pos_words)\\r\\n bi_neg_count = sum(pair[1] for pair in bi_neg_words)\\r\\n\\r\\n log_probability_pos = {} #(word)->P(word|positive)\\r\\n log_probability_neg = {} #(word)->P(word|negative)\\r\\n log_prob_bi_pos = {}\\r\\n log_prob_bi_neg = {}\\r\\n\\r\\n for pair in pos_words:\\r\\n pos_prob = np.log((pair[1]+smoothing_parameter)/(pos_count+smoothing_parameter*(len(pos_words) + 1)))\\r\\n log_probability_pos[pair[0]] = pos_prob\\r\\n\\r\\n for pair in neg_words:\\r\\n neg_prob = np.log((pair[1]+smoothing_parameter)/(neg_count+smoothing_parameter*(len(neg_words) + 1)))\\r\\n log_probability_neg[pair[0]] = neg_prob\\r\\n\\r\\n for pair in bi_pos_words:\\r\\n bi_pos_prob = np.log((pair[1]+smoothing_parameter)/(bi_pos_count+smoothing_parameter*(len(bi_pos_words) + 1)))\\r\\n log_prob_bi_pos[pair[0]] = bi_pos_prob\\r\\n\\r\\n for pair in bi_neg_words:\\r\\n bi_neg_prob = np.log((pair[1]+smoothing_parameter)/(bi_neg_count+smoothing_parameter*(len(bi_neg_words) + 1)))\\r\\n log_prob_bi_neg[pair[0]] = bi_neg_prob\\r\\n # Finished training\\r\\n\\r\\n # For each of the new reviews from development data\\r\\n for review in dev_set:\\r\\n uni_pos = np.log(pos_prior)\\r\\n uni_neg = np.log(1 - pos_prior)\\r\\n for word in review:\\r\\n if word in log_probability_pos:\\r\\n uni_pos += log_probability_pos[word]\\r\\n elif word not in log_probability_pos:\\r\\n uni_pos += np.log(smoothing_parameter/(pos_count+smoothing_parameter*(len(pos_words) + 1)))\\r\\n\\r\\n if word in log_probability_neg:\\r\\n uni_neg += log_probability_neg[word]\\r\\n elif word not in log_probability_neg:\\r\\n uni_neg += np.log(smoothing_parameter/(neg_count+smoothing_parameter*(len(neg_words) + 1)))\\r\\n\\r\\n bi_pos = np.log(pos_prior)\\r\\n bi_neg = np.log(1 - pos_prior)\\r\\n for i in range(len(review)-1):\\r\\n currTuple = (review[i], review[i+1])\\r\\n if currTuple in log_prob_bi_pos:\\r\\n bi_pos += log_prob_bi_pos[currTuple]\\r\\n elif currTuple not in log_prob_bi_pos:\\r\\n bi_pos += np.log(smoothing_parameter/(bi_pos_count+smoothing_parameter*(len(bi_pos_words) + 1)))\\r\\n\\r\\n if currTuple in log_prob_bi_neg:\\r\\n bi_neg += log_prob_bi_neg[currTuple]\\r\\n elif currTuple not in log_prob_bi_neg:\\r\\n bi_neg += np.log(smoothing_parameter/(bi_neg_count+smoothing_parameter*(len(bi_neg_words) + 1)))\\r\\n\\r\\n MAP_pos = (1-0.4)*uni_pos + 0.4*bi_pos\\r\\n MAP_neg = (1-0.4)*uni_neg + 0.4*bi_neg\\r\\n\\r\\n if MAP_pos >= MAP_neg:\\r\\n retval.append(1)\\r\\n else:\\r\\n retval.append(0)\\r\\n\\r\\n return retval\",\n \"def bayesian_update(self):\\n for p in self.parameters:\\n p.bayesian_update()\",\n \"def __init__(self, input_size: int, output_size: int, old_cols: List[AlphaModule] = None, hidden_size=768,\\n ptm=\\\"bert\\\", feature_size=768, require_proto=False, tokenizer=None, prob_l=-1) -> None:\\n super(PTMClassifier_PNN, self).__init__()\\n \\n if old_cols is None:\\n old_cols = []\\n \\n self.old_cols = []\\n \\n self.output_size = output_size\\n self.hidden_size = hidden_size # default\\n self.feature_size = feature_size\\n \\n self.fc1 = nn.Linear(self.hidden_size, 100)\\n self.classifier = nn.Linear(100, self.output_size)\\n \\n if len(old_cols) > 0:\\n self.old_fc1s = ListModule()\\n self.base_1 = nn.Sequential(\\n nn.Linear(100 * len(old_cols), 100),\\n nn.ReLU(),\\n )\\n self.base_2 = nn.Sequential(\\n nn.Linear(100 * len(old_cols), 100),\\n nn.ReLU(),\\n )\\n \\n self.adaptor1 = nn.Sequential(AlphaModule(100 * len(old_cols)),\\n self.base_1)\\n self.adaptor2 = nn.Sequential(AlphaModule(100 * len(old_cols)),\\n self.base_2)\\n \\n for old_col in old_cols:\\n self.old_fc1s.append(\\n nn.Sequential(nn.Linear(self.hidden_size, 100), nn.ReLU()))\\n self.old_fc1s[-1][0].load_state_dict(old_col.fc1.state_dict())\\n \\n # ptm\\n self.ptm = ptm.lower()\\n assert self.ptm in supported_ptm\\n ptm_ = import_from(\\\"transformers\\\", supported_ptm[self.ptm][0] + \\\"Model\\\")\\n \\n self.encoder = ptm_.from_pretrained(supported_ptm[self.ptm][1], output_hidden_states=True)\\n if tokenizer is not None:\\n self.encoder.resize_token_embeddings(len(tokenizer))\\n self.prob_l = prob_l\\n \\n self.require_proto = require_proto\\n \\n # todo : modify net into one network\\n if self.require_proto:\\n # prototype-based classification\\n self.net = nn.Sequential(\\n self.fc1\\n )\\n self.net_ = nn.Sequential(\\n self.encoder,\\n self.fc1,\\n self.encoder_adaptor,\\n nn.ReLU(),\\n )\\n else:\\n self.classifier = nn.Linear(self.feature_size, self.output_size, bias=True)\\n self.net = nn.Sequential(\\n self.classifier\\n )\\n self.net_ = nn.Sequential(\\n self.encoder,\\n self.classifier\\n )\\n \\n self.reset_parameters()\",\n \"def __init__(self, n=5, factors=50, learning_rate=0.001, bias_regularization=0.001, user_regularization=0.001,\\n positive_item_regularization=0.001, negative_item_regularization=0.001,iter = 50):\\n print 'bpr begin'\\n self.n = n\\n self.factors = factors\\n self.learning_rate = learning_rate\\n self.bias_regularization = bias_regularization\\n self.user_regularization = user_regularization\\n self.positive_item_regularization = positive_item_regularization\\n self.negative_item_regularization = negative_item_regularization\\n self.iter = iter\",\n \"def build_naive_bayes():\\n nb_pipeline = None\\n ##### Write code here\\n nb_pipeline = Pipeline([\\n ('vect', CountVectorizer()),\\n ('clf', ComplementNB())\\n ])\\n\\n ##### End of your work ######\\n return nb_pipeline\",\n \"def __init__(self, **kwargs):\\n\\n super(MLP, self).__init__()\\n\\n # TODO: why lbfgs and not adam?\\n self.solver = kwargs.pop('solver', 'lbfgs')\\n self.alpha = kwargs.pop('alpha', 1e-5)\\n self.random_state = kwargs.pop('random_state', 1)\\n\\n # determine if the MLP can be initialized or not\\n self.clf = None\\n self.hidden_layer_sizes = kwargs.pop('hidden_layer_sizes', -1)\\n if not (self.hidden_layer_sizes == -1):\\n self.initMLPClassifier(**kwargs)\",\n \"def init_bn(bn):\\n bn.bias.data.fill_(0.0)\\n bn.weight.data.fill_(1.0)\",\n \"def nbc_model(params):\\n if (params['random']):\\n params['alpha'] = random.randrange(1, 10, step=1) * 0.1\\n model = MultinomialNB(\\n alpha=params['alpha']\\n )\\n\\n return model\",\n \"def build_naive_bayes():\\n nb_pipeline = None\\n \\n nb_pipeline = Pipeline([\\n ('vect', CountVectorizer()),\\n ('clf', ComplementNB()),\\n ])\\n \\n return nb_pipeline\",\n \"def __init__(self,args, variance_epsilon=1e-12):\\n super(BERTLayerNorm, self).__init__()\\n self.gamma = nn.Parameter(torch.ones(args.input_dim))\\n self.beta = nn.Parameter(torch.zeros(args.input_dim))\\n self.variance_epsilon = variance_epsilon\",\n \"def __init__(self, beta):\\n super(CuboidPoseHead, self).__init__()\\n self.beta = beta\\n self.loss = nn.L1Loss()\",\n \"def __init__(self, bandits: List[Bandit]):\\n self.bandits = bandits\\n # mu_pri and var_pri are hypermaterers for prior distribution\\n self.mu_pri = np.zeros(len(self.bandits)) # 5 for each\\n self.var_pri = np.ones(len(self.bandits))*5\\n # mu and var are hyperparameters for posterior distribution\\n self.mu = self.mu_pri\\n self.var = self.var_pri\\n self.var0 = 1 # 1 is taken but any can be taken no prob upto a limit constant of inintial distribution\\n self.logging = Logging()\",\n \"def naive_bayes_train(train_data, train_labels, params):\\n\\n labels = np.unique(train_labels)\\n\\n d, n = train_data.shape\\n num_classes = labels.size\\n\\n # Set LaPlace smoothing parameter. \\n # As alpha increases, the probabilities tend towards the uniform distribution.\\n # If there is little need for smoothing, setting alpha low will typically boost accuracy.\\n alpha = 1\\n\\n # Initialize prior and likelihood arrays\\n p_y = np.zeros(num_classes, dtype=float)\\n likelihoods = np.zeros((d, num_classes), dtype=float)\\n\\n # Loop over each class\\n for c in range(num_classes):\\n # Get documents with current class label\\n class_data = train_data[:,np.where(train_labels == c)[0]]\\n # Get number of examples of current class\\n m = class_data.shape[1]\\n\\n # Get current prior (w/ LaPlace Smoothing)\\n p_y[c] = (m + alpha) / (n + alpha*num_classes)\\n # Get class conditional probabilities (w/ LaPlace Smoothing)\\n likelihoods[:,c] = (np.sum(class_data, axis=1) + alpha) / (m + 2*alpha)\\n\\n # Combine priors and likelihoods into model dictionary\\n model = dict()\\n model['likelihood'] = likelihoods\\n model['prior'] = p_y\\n return model\",\n \"def predict_proba(self):\\n ...\",\n \"def test_posterior():\\n\\n # Initiate BEL object\\n bel = init_bel()\\n # Set seed\\n seed = 123456\\n bel.seed = seed\\n\\n # Get file path\\n my_path = os.path.dirname(os.path.abspath(__file__))\\n\\n X_train = np.load(jp(my_path, \\\"X_train.npy\\\"))\\n y_train = np.load(jp(my_path, \\\"y_train.npy\\\"))\\n\\n X_test = np.load(jp(my_path, \\\"X_test.npy\\\"))\\n\\n # Fit\\n bel.fit(X=X_train, Y=y_train)\\n # Predict posterior mean and covariance\\n post_mean, post_cov = bel.predict(X_test)\\n\\n # Compare with reference\\n ref_mean = np.load(jp(my_path, \\\"ref_mean.npy\\\"))\\n ref_covariance = np.load(jp(my_path, \\\"ref_covariance.npy\\\"))\\n\\n msg1 = \\\"The posterior means are different\\\"\\n np.testing.assert_allclose(post_mean, ref_mean, atol=1e-6, err_msg=msg1)\\n\\n msg2 = \\\"The posterior covariances are different\\\"\\n np.testing.assert_allclose(post_cov, ref_covariance, atol=1e-6, err_msg=msg2)\",\n \"def init_bn(bn):\\n bn.bias.data.fill_(0.)\\n bn.weight.data.fill_(1.)\",\n \"def init_bn(bn):\\n bn.bias.data.fill_(0.)\\n bn.weight.data.fill_(1.)\",\n \"def init_bn(bn):\\n bn.bias.data.fill_(0.)\\n bn.weight.data.fill_(1.)\",\n \"def setup_b_instance(self,norm,add_ps_mask=True):\\n inst_tag = self.tag + '_'+str(self.flux_array_ebin)\\n b = bsm.bayesian_scan_NPTF(tag=inst_tag,nside=self.nside,work_dir='/tmp/'+self.tag+'/',psf_dir=psf_dir,nlive=700)\\n # Input the data, using the external data if provided\\n if self.use_external_data:\\n b.load_external_data(self.f1.CTB_en_bins,[self.external_data[self.flux_array_ebin]],self.f1.CTB_exposure_maps)\\n else:\\n b.load_external_data(self.f1.CTB_en_bins,self.f1.CTB_count_maps,self.f1.CTB_exposure_maps)\\n\\n if add_ps_mask:\\n b.make_mask_total(band_mask_range = [-self.band_mask,self.band_mask],mask_ring = False,ps_mask_array = self.f1.ps_mask_array)\\n else:\\n b.make_mask_total(band_mask_range = [-self.band_mask,self.band_mask],mask_ring = False)\\n\\n b.add_new_template(self.f1.template_dict)\\n b.rebin_external_data(1)\\n\\n b.add_poiss_model('ps_model','$A_{ps}$',[0.0,3.0],False)\\n b.add_poiss_model('p7','$A_{p7}$',[0.0,2.0],False)\\n b.add_poiss_model('bubs','$A_{bubs}$',[0.0,2.0],False)\\n b.add_poiss_model('iso','$A_{iso}$',[0.0,3.0],False)\\n # Add in a fixed J_map template\\n b.add_fixed_templates({'J_map':[norm*self.J_map_arr[self.flux_array_ebin]/np.mean(self.J_map_arr[self.flux_array_ebin])]})\\n\\n b.initiate_poissonian_edep()\\n return b\",\n \"def BayesPaperStats(maxIters, numRuns):\\n\\n comm = MPI.COMM_WORLD\\n rank = comm.Get_rank()\\n\\n assert comm.Get_size() == numRuns, \\\"Please ensure there is one process running per run i.e \\\" + str(numRuns) + \\\" processes.\\\"\\n \\n problemBounds = {\\\"Bfield\\\": choco.uniform(10, 1300), \\\"T\\\": choco.uniform(50, 230), \\\"Btheta\\\": choco.uniform(0, 90), \\\"Etheta\\\": choco.uniform(0, 90)}\\n\\n # The target for each algorithm. This was determined by using the values in the literature, so there is clearly some deviation either due to the detuning or computation.\\n globalFoM = 1.033\\n\\n if rank == 0:\\n timeList = []\\n iterationList = []\\n\\n # Set up the database for the chocolate optimiser.\\n connection = choco.SQLiteConnection(\\\"sqlite:///bayes_paper_\\\" + str(rank) + \\\"_db.db\\\")\\n\\n # Define which solver will be used.\\n solver = choco.Bayes(connection, problemBounds, utility_function = \\\"ei\\\", n_bootstrap = int(np.ceil(maxIters/10)), clear_db = True)\\n\\n # Clear the database. TODO: To do this?\\n connection.clear()\\n\\n # Start timing.\\n startTime = time.time()\\n timeElapsed = None\\n iterationSuccess = None\\n\\n # Start optimisation.\\n for iteration in range(maxIters):\\n\\n # Make one suggestion.\\n try:\\n token, nextParams = solver.next()\\n except:\\n print(\\\"Error suggesting a new point. Here are the last set of parameters sampled:\\\")\\n print(str(nextParams))\\n print(\\\"Iteration number: \\\" + str(iteration))\\n continue\\n\\n # Check what FoM this gives. Go negative as this is a minimisation routine.\\n fEval = abs(FitnessPaper(**nextParams))\\n\\n # Update best FoM.\\n if fEval >= globalFoM:\\n # The algorithm has managed to surpass or equal the paper value.\\n iterationSuccess = iteration\\n timeElapsed = time.time() - startTime\\n \\n if rank == 0:\\n iterationList.append(iterationSuccess)\\n timeList.append(timeElapsed)\\n\\n break\\n \\n # Tell the optimiser about the result.\\n solver.update(token, fEval)\\n\\n # Run complete. Send results to main process. Tags are unique identifiers.\\n if rank != 0:\\n comm.send(timeElapsed, dest = 0, tag = 1)\\n comm.send(iterationSuccess, dest = 0, tag = 2)\\n\\n # Wait for all the processes to end.\\n comm.Barrier()\\n\\n if rank == 0:\\n # Aggregate the data.\\n for process in range(comm.Get_size() - 1):\\n # Get the data.\\n individualTime = None\\n individualTime = comm.recv(individualTime, source = process + 1, tag = 1)\\n\\n individualIter = None\\n individualIter = comm.recv(individualIter, source = process + 1, tag = 2)\\n\\n if individualIter is not None:\\n # Both values must therefore be non-null.\\n iterationList.append(individualIter)\\n timeList.append(individualTime)\\n\\n avgRuntime = np.average(timeList)\\n avgIters = np.average(iterationList)\\n try:\\n\\n fastestTime = np.min(timeList)\\n\\n except ValueError:\\n \\n # List is empty.\\n fastestTime = float('NaN')\\n\\n numSuccess = len(iterationList)\\n successRate = numSuccess/numRuns\\n\\n print(\\\"Bayesian optimisation paper testing complete! Here are the stats:\\\")\\n print(\\\"Number of successful runs: \\\" + str(numSuccess) + \\\" (Success rate of \\\" + str(successRate) + \\\")\\\")\\n print(\\\"Average iterations required for success: \\\" + str(avgIters))\\n print(\\\"Average time required for success: \\\" + str(avgRuntime))\\n print(\\\"Fastest convergence time: \\\" + str(fastestTime))\\n print(\\\"------------------------------------------------------------------------------------------------------------------\\\")\\n \\n return\",\n \"def __init__(self, b=0, drop_rate=0.5, pretrained=True):\\n\\n # Calls the super for the nn.Module.\\n super(Classifier, self).__init__()\\n\\n # Sets the drop rate for the dropout layers.\\n self.drop_rate = drop_rate\\n\\n # Loads the EfficientNet encoder.\\n if pretrained:\\n self.encoder = EfficientNet.from_pretrained(f\\\"efficientnet-b{str(b)}\\\")\\n else:\\n self.encoder = EfficientNet.from_name(f\\\"efficientnet-b{str(b)}\\\")\\n self.encoder_pool = nn.AdaptiveAvgPool2d(1)\\n\\n # Defines a hidden layer.\\n self.hidden = nn.Linear(2560, 512)\\n\\n # Defines the output layer of the neural network.\\n self.classifier = nn.Linear(512, 2)\",\n \"def __init__(self, config, variance_epsilon=1e-12):\\r\\n super(BertLayerNorm, self).__init__()\\r\\n self.gamma = nn.Parameter(torch.ones(config.hidden_size))\\r\\n self.beta = nn.Parameter(torch.zeros(config.hidden_size))\\r\\n self.variance_epsilon = variance_epsilon\",\n \"def test_predict_prep_proba():\\n args = get_layer('predict', 'manual', 'temporal', True, True, window=2, step_size=3)\\n run_layer(*args)\",\n \"def __init__(self, data, class_column):\\n print(\\\"Naive Bayes Model created!\\\")\\n\\n # create report\\n self.predict_summary = {}\\n self.fit_report = {}\\n\\n # self.data=data\\n self.data = data\\n self.class_column = class_column\\n\\n # get the class column and get classes\\n col_data = self.data[class_column]\\n self.class_list = unique_list(col_data)\\n\\n # get numeric columns and categorical columns\\n self.num_cols, self.cat_cols = get_both_columns(self.data, class_column)\\n\\n # Build the pro\\n self.prob_hub = {}\",\n \"def update_posterior_probs(vars_):\\n vars_.weighted_sums += np.power(vars_.dprime_map[vars_.focus],2) * vars_.visual_field\\n vars_.post_probs = np.exp(vars_.weighted_sums) * vars_.prior_prob\\n vars_.post_probs /= np.sum(vars_.post_probs)\",\n \"def probinit(self, aaa, n_obj):\\n # Set algorithm...\\n if aaa == 'nsga':\\n algo = nsga_II(m=0.05)\\n else:\\n algo = jde(memory=True)\\n #algo = mde_pbx()\\n #algo = de_1220()\\n\\n # ...and initialize problem with instance atributes\\n prob = mga_1dsm(seq = self.FBseq,\\n multi_objective = n_obj,\\n dsm_dv_barrier = self.MAX_DV)\\n\\n prob.set_vinf((self.C3)**0.5)\\n prob.set_tof(self.TOF[0], self.TOF[1])\\n prob.set_entry_barrier(self.entry_barrier)\\n prob.set_launch_window(self.EPOCHSTART, self.EPOCHEND)\\n return prob, algo\",\n \"def fit_and_predict_BernoulliNB(X_train, Y_train, X_test):\\n\\n # Import the package\\n from sklearn.naive_bayes import BernoulliNB \\n\\n ### YOUR SOLUTION STARTS HERE### \\n #referenced to sklearn documentation \\n # fit the model... \\n clf = BernoulliNB(binarize=0.0).fit(X_train, Y_train) #fit naive bayes to X and Y train data\\n # make predictions\\n predicted_bernNB = clf.predict(X_test)\\n return predicted_bernNB\\n ### END SOLUTION ### \",\n \"def gibbs_ask_traffic(self, X, e, Z, bn, N):\\n\\n #makes copies\\n X = e\\n e = e\\n\\n #probability\\n probability = [0,0]\\n numerator = 0\\n\\n\\n #True, False\\n\\n for x in range(N):\\n # second joint\\n if Z == True: # if non evidence variable\\n random_choice = np.random.choice([0,1], 1, True, [0.5, 0.5])[0] #Rain or No Rain\\n X[1] = bn[1][random_choice][0]\\n else:\\n random_choice = np.random.choice([0, 1], 1, True, [0.5, 0.5])[0] #Rain or No Rain\\n X[1] = bn[1][random_choice][1]\\n\\n # first joint\\n if X[1] == 0.8 or X[1] == 0.2: # Rain is true\\n X[0] = bn[0][0]\\n else: # Rain is False\\n X[0] = bn[0][1]\\n\\n # third joint\\n if X[1] == 0.8 or X[1] == 0.1: # traffic\\n random_late = np.random.choice([0,1], 1, True, [0.5,0.5])[0]\\n X[2] = bn[2][0][random_late]\\n else: # no traffic\\n random_late = np.random.choice([0, 1], 1, True, [0.5, 0.5])[0]\\n X[2] = bn[2][1][random_late]\\n\\n # print(X)\\n if X[0] == 0.1:\\n probability[0] += 1\\n else:\\n probability[1] += 1\\n\\n\\n probability[0] = probability[0] / N\\n probability[1] = probability[1] / N\\n # print(probability)\\n return probability\",\n \"def __init__(self,data,pos,neg,bk,prior,target,max_depth=2):\\n\\n self.data = data\\n self.examples = {}\\n self.pos = pos\\n self.neg = neg\\n #initial model assumed P(target|data)=0.5 to target=1,0\\n for ex in pos+neg:\\n self.examples[ex] = prior[ex]\\n self.bk = bk\\n self.target = target\\n self.max_depth = max_depth\\n self.boosted_trees = []\",\n \"def __init__(self, nr_of_categories: int, alpha=0.1, beta=1e10, delta=1.0, reduction='none'):\\n super().__init__()\\n self.parabolic_penalty = ParabolicPenaltyLoss(nr_of_categories, delta, beta)\\n self.categorical_crossentropy = CrossEntropyLoss()\\n self.reduction = reduction\\n self.alpha = alpha\",\n \"def perform_bayesian_optimization(self):\\n bounds = {'hunits': (self.hunits_lower, self.hunits_upper),\\n 'embedding_dim': (self.embedding_dim_lower, self.embedding_dim_upper)}\\n optimizer = BayesianOptimization(f=self.lstm_score, pbounds=bounds, random_state=1)\\n optimizer.maximize(init_points=2, n_iter=self.iterations)\\n print(optimizer.max)\\n print(optimizer.res)\",\n \"def __init__(self, \\n num_vars, \\n num_hidden,\\n training_inputs = None,\\n algorithm = None,\\n algorithm_dict = None,\\n batch_size = None,\\n use_momentum = None,\\n W0= None, \\n b0= None, \\n bhid0 = None,\\n zero_diag = True,\\n symmetric = True,\\n report_p_tilda =False,\\n learn_biases = True,\\n test_mode= False,\\n training = True):\\n \\n self.num_vars = num_vars\\n \\n self.num_hidden = num_hidden\\n \\n self.batch_size = batch_size\\n \\n self.zero_diag = zero_diag\\n \\n self.algorithm = algorithm\\n \\n self.num_samples = 0\\n \\n self.num_u_gibbs = 0\\n \\n self.gibbs_steps = 0\\n \\n self.resample = False\\n \\n self.uniform = False\\n \\n self.mixture = False\\n \\n self.mix_params = []\\n \\n self.m_params = []\\n \\n self.mf_steps = 0\\n \\n self.alpha = 0\\n \\n self.learn_biases = learn_biases\\n \\n if isinstance(algorithm_dict, dict):\\n \\n for param in algorithm_dict.keys():\\n \\n if param == 'resample':\\n \\n self.resample = algorithm_dict[param]\\n \\n if param == 'mf_steps':\\n \\n self.mf_steps = algorithm_dict[param]\\n \\n if param == \\\"gibbs_steps\\\":\\n \\n self.gibbs_steps = algorithm_dict[param]\\n \\n if param == \\\"num_samples\\\":\\n \\n self.num_samples = algorithm_dict[param]\\n \\n if param == \\\"num_u_gibbs\\\":\\n \\n self.num_u_gibbs = algorithm_dict[param]\\n \\n if param == \\\"uniform\\\":\\n \\n self.uniform = algorithm_dict[param] \\n \\n if param == \\\"mixture\\\":\\n \\n self.mixture = algorithm_dict[param] \\n \\n if param == \\\"mix_params\\\":\\n \\n self.mix_params = algorithm_dict[param] \\n \\n if param == \\\"alpha\\\" and algorithm_dict[param] != None:\\n #### alpha defines transition rate from\\n #### uniform to mean-field distribution\\n self.alpha = algorithm_dict[param] \\n \\n self.m_params = (1-self.alpha)*0.5*np.ones([1,self.num_vars])+\\\\\\n self.alpha*np.mean(training_inputs,0)\\n \\n self.use_momentum = use_momentum\\n \\n self.report_p_tilda = report_p_tilda\\n \\n self.side = int(np.sqrt(self.num_vars))\\n \\n self.np_rand_gen = np.random.RandomState(1234)\\n \\n self.theano_rand_gen =\\\\\\n theano.sandbox.rng_mrg.MRG_RandomStreams(self.np_rand_gen.randint(2**30))\\n \\n #self.theano_rand_gen =\\\\\\n #T.shared_randomstreams.RandomStreams(self.np_rand_gen.randint(2**30))\\n \\n theano.config.exception_verbosity = 'high'\\n \\n self.node_indices = \\\\\\n theano.shared(np.arange(self.num_vars), name=\\\"node_indices\\\")\\n \\n self.x = T.matrix('x')\\n \\n self.x_tilda = T.matrix('x_tilda')\\n \\n self.sampler_theta = T.matrix('sampler_theta')\\n \\n self.symmetric = symmetric\\n \\n if training:\\n \\n if self.num_hidden ==0:\\n \\n self.num_x2 = self.num_vars\\n \\n elif self.num_hidden > 0 :\\n \\n self.num_x2 = self.num_hidden\\n \\n self.updates = OrderedDict()\\n \\n self.N_train = training_inputs.shape[0]\\n \\n self.train_inputs = theano.shared(np.asarray(training_inputs,\\n dtype=theano.config.floatX),\\n borrow= True)\\n \\n self.learning_rate = T.dscalar('learning_rate')\\n \\n if self.mixture:\\n \\n print(\\\"Importance distribution was specified as mixture\\\"+\\\\\\n \\\" of Bernoulli products\\\")\\n \\n if self.mix_params == []:\\n print(\\\"Error: parameters defining mixture means were\\\"+\\\\\\n \\\" not provided\\\")\\n sys.exit()\\n \\n self.set_mixture_means(inputs = training_inputs)\\n \\n if use_momentum:\\n \\n print(\\\"Will add momentum term to gradient computations\\\")\\n \\n self.momentum = T.dscalar('learning_rate')\\n \\n self.grad_vec = {}\\n \\n self.grad_vec['W'] = theano.shared(np.zeros([self.num_vars, self.num_x2],\\n dtype = theano.config.floatX), name = 'W_momentum', borrow = True)\\n \\n if self.num_hidden > 0:\\n \\n self.grad_vec['bhid'] = theano.shared(np.zeros([self.num_x2],\\n dtype = theano.config.floatX), name = 'b_momentum', borrow = True)\\n \\n self.grad_vec['b'] = theano.shared(np.zeros([self.num_vars],\\n dtype = theano.config.floatX), name = 'b_momentum', borrow = True)\\n \\n if test_mode:\\n \\n b_init =self.np_rand_gen.uniform(0,1, num_vars)\\n \\n W_init =self.np_rand_gen.uniform(0,1, size = (num_vars, num_vars))\\n \\n # also tested ones\\n # b_init = np.ones(num_vars)\\n \\n # W_init = np.ones([num_vars, num_vars])\\n \\n self.b_init= np.asarray(b_init, dtype = theano.config.floatX)\\n \\n self.W_init= np.asarray(W_init, dtype = theano.config.floatX)\\n \\n self.b = theano.shared(self.b_init, name='b', borrow = False)\\n \\n self.W = theano.shared(self.W_init, name='W', borrow = False)\\n \\n print(\\\"Initialized with test mode\\\")\\n \\n else:\\n \\n if W0 is None:\\n \\n if self.num_hidden > 0:\\n \\n W0_init =\\\\\\n self.np_rand_gen.uniform(\\n -4*np.sqrt(6.0/(self.num_vars+self.num_hidden)),\\\\\\n 4*np.sqrt(6.0 /(self.num_vars + self.num_hidden)), \\n size = (num_vars, self.num_hidden)\\n )\\n \\n W0 = np.asarray(W0_init, dtype = theano.config.floatX) \\n \\n if self.num_hidden == 0:\\n \\n # different W initializations: \\n \\n # W0_init =\\\\\\n # self.np_rand_gen.uniform(-np.sqrt(3.0/(num_vars)),\\\\\\n # np.sqrt(3.0 / (num_vars)), size = (num_vars, num_vars))\\n \\n # W0_init =\\\\\\n # self.np_rand_gen.uniform(-0.00000001,\\\\\\n # 0.00000001, size = (num_vars, num_vars))\\n \\n W0_init = 0.00000001*\\\\\\n self.np_rand_gen.normal(size = (num_vars, self.num_x2)) \\n \\n W0 = np.asarray(W0_init, dtype = theano.config.floatX)\\n \\n if self.symmetric:\\n \\n W0 = (W0 + np.transpose(W0))/2.0\\n \\n if self.zero_diag:\\n \\n W0 = W0 - np.diag(np.diag(W0))\\n \\n self.W = theano.shared(value= W0, name='W', borrow=True)\\n \\n if self.num_hidden == 0:\\n \\n test_W = self.W.get_value() \\n \\n assert sum(np.diag(test_W)) == 0.0\\n \\n assert (test_W == np.transpose(test_W)).all() == True\\n \\n else:\\n print(\\\"W is initialized with provided array\\\")\\n self.W = theano.shared(value= W0, name='W', borrow=True)\\n \\n if b0 is None:\\n \\n bias_init = np.zeros(num_vars, dtype = theano.config.floatX)\\n \\n self.b = theano.shared(value= bias_init, name='b', borrow=True)\\n \\n else:\\n print(\\\"b vector is initialized with provided vector\\\")\\n self.b = theano.shared(value= b0, name='b', borrow=True)\\n \\n if bhid0 is None and self.num_hidden > 0:\\n \\n hbias_init = np.zeros(self.num_hidden, dtype = theano.config.floatX)\\n \\n self.bhid = theano.shared(value= hbias_init, name='bhid', borrow=True)\\n \\n elif (bhid0 is not None) and (self.num_hidden > 0):\\n print(\\\"bhid vector is initialized with provided vector\\\") \\n self.bhid = theano.shared(value= bhid0, name='bhid', borrow=True)\\n \\n self.theta = [self.W, self.b]\\n \\n if self.num_hidden > 0 :\\n \\n self.theta.append(self.bhid)\\n \\n self.train_set = set(range(self.N_train))\\n \\n self.minibatch_set = T.ivector('minibatch_set')\\n \\n self.sample_set = T.ivector('sample_set')\\n \\n if \\\"CD\\\" in self.algorithm and self.num_hidden ==0:\\n \\n self.x_gibbs= theano.shared(np.ones([self.batch_size,self.num_vars],\\n dtype=theano.config.floatX),\\n borrow = True, name= \\\"x_gibbs\\\")\\n \\n if \\\"CD\\\" in self.algorithm and self.num_hidden > 0:\\n \\n self.persistent_gibbs =\\\\\\n theano.shared(np.ones([self.batch_size,self.num_hidden],\\n dtype=theano.config.floatX),\\n borrow = True, \\n name= \\\"persistent_gibbs\\\")\\n \\n if \\\"CSS\\\" in self.algorithm and self.mf_steps > 0:\\n \\n init_mf_vis = self.np_rand_gen.uniform(0, \\n 1, \\n size =(self.num_vars,1))\\n \\n init_mf_vis = np.asarray(init_mf_vis, dtype = theano.config.floatX)\\n \\n self.mf_vis_p = theano.shared(init_mf_vis, \\n name= \\\"mf_vis_p\\\", \\n borrow= True)\\n \\n if self.num_hidden > 0:\\n \\n init_mf_hid = \\\\\\n self.np_rand_gen.uniform(0, 1, size =(self.num_hidden,1))\\n \\n init_mf_hid = np.asarray(init_mf_hid, \\n dtype = theano.config.floatX)\\n \\n self.mf_hid_p = theano.shared(init_mf_hid, \\n name= \\\"mf_hid_p\\\", \\n borrow= True)\\n \\n elif \\\"CSS\\\" in self.algorithm and self.gibbs_steps > 0: \\n \\n if self.num_hidden ==0: \\n self.x_gibbs= theano.shared(np.ones([self.batch_size,self.num_vars],\\n dtype=theano.config.floatX),\\n borrow = True, name= \\\"x_gibbs\\\")\",\n \"def __init__(self, input, n_in, n_out,\\r\\n W=None, b=None, prob_constraint_on=None):\\r\\n\\r\\n # initialize weight matrix W\\r\\n if W is None:\\r\\n self.W = theano.shared(\\r\\n value=np.zeros((n_in, n_out), dtype=theano.config.floatX),\\r\\n name='W')\\r\\n else:\\r\\n self.W = W\\r\\n\\r\\n # initialize bias b\\r\\n if b is None:\\r\\n self.b = theano.shared(\\r\\n value=np.zeros((n_out,), dtype=theano.config.floatX),\\r\\n name='b')\\r\\n else:\\r\\n self.b = b\\r\\n\\r\\n # compute prediction\\r\\n # the linear output\\r\\n lin_output = T.dot(input, self.W) + self.b\\r\\n \\r\\n if prob_constraint_on == None:\\r\\n #### we do not use those probability constraints\\r\\n self.y_pred = Sigmoid(lin_output)\\r\\n\\r\\n elif prob_constraint_on == \\\"top\\\":\\r\\n #### We first predict the probability of each class using softmax.\\r\\n # We then weight those probabilities by multiplying them by the\\r\\n # probability of their parent in the Galaxy Zoo Decision Tree.\\r\\n \\r\\n # class 1\\r\\n prob_Class1 = SoftMax(lin_output[:,0:3])\\r\\n \\r\\n # class 2\\r\\n prob_Class2 = SoftMax(lin_output[:,3:5])\\r\\n # weight these probabilities using the probability of class 1.2\\r\\n prob_Class2 *= T.shape_padright(prob_Class1[:,1])\\r\\n \\r\\n # class 3\\r\\n prob_Class3 = SoftMax(lin_output[:,5:7])\\r\\n # weight these probabilities using the probability of class 2.2\\r\\n prob_Class3 *= T.shape_padright(prob_Class2[:,1])\\r\\n \\r\\n # class 4\\r\\n prob_Class4 = SoftMax(lin_output[:,7:9])\\r\\n # weight these probabilities using the probability of class 2.2\\r\\n prob_Class4 *= T.shape_padright(prob_Class2[:,1])\\r\\n \\r\\n # class 5\\r\\n prob_Class5 = SoftMax(lin_output[:,9:13])\\r\\n # weight these probabilities using the probability of class 2.2\\r\\n prob_Class5 *= T.shape_padright(prob_Class2[:,1])\\r\\n \\r\\n # class 6\\r\\n prob_Class6 = SoftMax(lin_output[:,13:15])\\r\\n \\r\\n # class 7\\r\\n prob_Class7 = SoftMax(lin_output[:,15:18])\\r\\n # weight these probabilities using the probability of class 1.1\\r\\n prob_Class7 *= T.shape_padright(prob_Class1[:,0])\\r\\n \\r\\n # class 8\\r\\n prob_Class8 = SoftMax(lin_output[:,18:25])\\r\\n # weight these probabilities using the probability of class 6.1\\r\\n prob_Class8 *= T.shape_padright(prob_Class6[:,0])\\r\\n \\r\\n # class 9\\r\\n prob_Class9 = SoftMax(lin_output[:,25:28])\\r\\n # weight these probabilities using the probability of class 2.1\\r\\n prob_Class9 *= T.shape_padright(prob_Class2[:,0])\\r\\n \\r\\n # class 10\\r\\n prob_Class10 = SoftMax(lin_output[:,28:31])\\r\\n # weight these probabilities using the probability of class 4.1\\r\\n prob_Class10 *= T.shape_padright(prob_Class4[:,0])\\r\\n \\r\\n # class 11\\r\\n prob_Class11 = SoftMax(lin_output[:,31:37])\\r\\n # weight these probabilities using the probability of class 4.1\\r\\n prob_Class11 *= T.shape_padright(prob_Class4[:,0])\\r\\n \\r\\n # concatenate all the probabilities into a single tensor variable\\r\\n self.y_pred = T.concatenate(\\r\\n [prob_Class1, prob_Class2, prob_Class3, prob_Class4,\\r\\n prob_Class5, prob_Class6, prob_Class7, prob_Class8,\\r\\n prob_Class9, prob_Class10, prob_Class11], axis=1)\\r\\n elif prob_constraint_on == \\\"down\\\":\\r\\n #### we use those probability constraints\\r\\n \\r\\n # the following probabilities should sum up to 1, so we use SoftMax\\r\\n # to predict all of them\\r\\n ind1 = [2, 8, 15, 16, 17, 25, 26, 27, 31, 32, 33, 34, 35, 36]\\r\\n p1 = SoftMax(lin_output[:,ind1])\\r\\n prob_Class1_3 = p1[:,0]\\r\\n prob_Class4_2 = p1[:,1]\\r\\n prob_Class7 = p1[:,2:5]\\r\\n prob_Class9 = p1[:,5:8]\\r\\n prob_Class11 = p1[:,8:14]\\r\\n \\r\\n prob_Class4_1 = T.sum(prob_Class11, axis=1)\\r\\n prob_Class2_1 = T.sum(prob_Class9, axis=1)\\r\\n prob_Class2_2 = prob_Class4_1 + prob_Class4_2\\r\\n prob_Class1_1 = T.sum(prob_Class7, axis=1)\\r\\n prob_Class1_2 = prob_Class2_1 + prob_Class2_2\\r\\n prob_Class1 = T.concatenate(\\r\\n [T.shape_padright(prob_Class1_1),\\r\\n T.shape_padright(prob_Class1_2),\\r\\n T.shape_padright(prob_Class1_3)], axis=1)\\r\\n prob_Class2 = T.concatenate(\\r\\n [T.shape_padright(prob_Class2_1),\\r\\n T.shape_padright(prob_Class2_2)], axis=1)\\r\\n prob_Class4 = T.concatenate(\\r\\n [T.shape_padright(prob_Class4_1),\\r\\n T.shape_padright(prob_Class4_2)], axis=1)\\r\\n \\r\\n # the following probabilities should sum up to 1, so we use SoftMax\\r\\n # to predict all of them\\r\\n ind2 = [14, 18, 19, 20, 21, 24, 23, 24] \\r\\n p2 = SoftMax(lin_output[:,ind2])\\r\\n prob_Class6_2 = p2[:,0]\\r\\n prob_Class8 = p2[:,1:8]\\r\\n prob_Class6_1 = T.sum(prob_Class8, axis=1)\\r\\n prob_Class6 = T.concatenate(\\r\\n [T.shape_padright(prob_Class6_1),\\r\\n T.shape_padright(prob_Class6_2)], axis=1)\\r\\n \\r\\n # for the following probabilities, we resort to the same strategy in\\r\\n # the \\\"top\\\" option\\r\\n # class 3\\r\\n prob_Class3 = SoftMax(lin_output[:,5:7])\\r\\n # weight these probabilities using the probability of class 2.2\\r\\n prob_Class3 *= T.shape_padright(prob_Class2[:,1])\\r\\n \\r\\n # class 5\\r\\n prob_Class5 = SoftMax(lin_output[:,9:13])\\r\\n # weight these probabilities using the probability of class 2.2\\r\\n prob_Class5 *= T.shape_padright(prob_Class2[:,1])\\r\\n \\r\\n # class 10\\r\\n prob_Class10 = SoftMax(lin_output[:,28:31])\\r\\n # weight these probabilities using the probability of class 4.1\\r\\n prob_Class10 *= T.shape_padright(prob_Class4[:,0])\\r\\n \\r\\n # concatenate all the probabilities into a single tensor variable\\r\\n self.y_pred = T.concatenate(\\r\\n [prob_Class1, prob_Class2, prob_Class3, prob_Class4,\\r\\n prob_Class5, prob_Class6, prob_Class7, prob_Class8,\\r\\n prob_Class9, prob_Class10, prob_Class11], axis=1)\\r\\n \\r\\n \\r\\n # parameters of the model\\r\\n self.params = [self.W, self.b]\",\n \"def initialize_probabilities(self):\\n self.probabilities = np.ndarray((2, len(self.variables)), dtype=np.float)\\n self.update_probabilities()\",\n \"def __init_finalaf(self, i,h1,classes):\\n self.params['W'+i]=np.random.randn(h1,classes)*self.weight_scale\\n self.params['b'+i]=np.zeros(classes)\",\n \"def __init__(self, sizes, beta=1, momentum=0.9):\\n self.beta = beta\\n self.momentum = momentum\\n\\n self.nin = sizes[0] # number of features in each sample\\n self.nhidden1 = sizes[1] # number of neurons in the first hidden layer\\n self.nhidden2 = sizes[2] # number of neurons in the second hidden layer\\n self.nout = sizes[3] # number of classes / the number of neurons in the output layer\\n\\n\\n # Initialise the network of two hidden layers\\n self.weights1 = (np.random.rand(self.nin+1,self.nhidden1)-0.5)*2/np.sqrt(self.nin) # hidden layer 1\\n self.weights2 = (np.random.rand(self.nhidden1+1,self.nhidden2)-0.5)*2/np.sqrt(self.nhidden1) # hidden layer 2\\n self.weights3 = (np.random.rand(self.nhidden2+1,self.nout)-0.5)*2/np.sqrt(self.nhidden2) # output layer\",\n \"def naiveBayes(train_set, train_labels, dev_set, smoothing_parameter, org_dev_labels):\\r\\n\\r\\n # set to false to use bigram implementation instead\\r\\n # isUnigram = True\\r\\n isUnigram = True\\r\\n\\r\\n # return predicted labels of development set\\r\\n spam_words, spam_wordcount = parseIntoWordList(train_set, train_labels, 1)\\r\\n ham_words, ham_wordcount = parseIntoWordList(train_set, train_labels, 0)\\r\\n\\r\\n spamWords, spamProbs, spamUNK = createProbabilitiesList(spam_words, spam_wordcount, smoothing_parameter)\\r\\n hamWords, hamProbs, hamUNK = createProbabilitiesList(ham_words, ham_wordcount, smoothing_parameter)\\r\\n\\r\\n loggedSpam = np.log(spamProbs)\\r\\n loggedSpamUNK = np.log(spamUNK)\\r\\n loggedHam = np.log(hamProbs)\\r\\n loggedHamUNK = np.log(hamUNK)\\r\\n\\r\\n # Unigram\\r\\n dev_spam = []\\r\\n dev_ham = []\\r\\n\\r\\n dev_labels = []\\r\\n\\r\\n if isUnigram:\\r\\n for i in range(len(dev_set)):\\r\\n probSpam = 0\\r\\n probHam = 0\\r\\n\\r\\n for word in dev_set[i]:\\r\\n if word in spamWords:\\r\\n index = spamWords.index(word)\\r\\n probSpam += loggedSpam[index]\\r\\n else:\\r\\n probSpam += loggedSpamUNK\\r\\n\\r\\n if word in hamWords:\\r\\n index = hamWords.index(word)\\r\\n probHam += loggedHam[index]\\r\\n else:\\r\\n probHam += loggedHamUNK\\r\\n\\r\\n if (probSpam > probHam):\\r\\n dev_labels.append(1)\\r\\n else:\\r\\n dev_labels.append(0)\\r\\n\\r\\n else:\\r\\n for i in range(len(dev_set)):\\r\\n probSpam = 0\\r\\n probHam = 0\\r\\n\\r\\n for word in dev_set[i]:\\r\\n if word in spamWords:\\r\\n index = spamWords.index(word)\\r\\n probSpam += loggedSpam[index]\\r\\n else:\\r\\n probSpam += loggedSpamUNK\\r\\n\\r\\n if word in hamWords:\\r\\n index = hamWords.index(word)\\r\\n probHam += loggedHam[index]\\r\\n else:\\r\\n probHam += loggedHamUNK\\r\\n dev_spam.append(probSpam)\\r\\n dev_ham.append(probHam)\\r\\n # BiGram\\r\\n bi_spam_words, bi_spam_count = parseIntoBigramList(train_set, train_labels, 1)\\r\\n bi_ham_words, bi_ham_count = parseIntoBigramList(train_set, train_labels, 0)\\r\\n\\r\\n biSpamWords, biSpamProbs, biSpamUNK = createProbabilitiesList(bi_spam_words, bi_spam_count, smoothing_parameter)\\r\\n biHamWords, biHamProbs, biHamUNK = createProbabilitiesList(bi_ham_words, bi_ham_count, smoothing_parameter)\\r\\n\\r\\n biLoggedSpam = np.log(biSpamProbs)\\r\\n biLoggedSpamUNK = np.log(biSpamUNK)\\r\\n biLoggedHam = np.log(biHamProbs)\\r\\n biLoggedHamUNK = np.log(biHamUNK)\\r\\n\\r\\n # Bigram\\r\\n bi_dev_spam = []\\r\\n bi_dev_ham = []\\r\\n\\r\\n for i in range(len(dev_set)):\\r\\n biProbSpam = 0\\r\\n biProbHam = 0\\r\\n curr_email = dev_set[i]\\r\\n\\r\\n for j in range(len(curr_email) - 1):\\r\\n if (j % 2 == 1):\\r\\n continue\\r\\n curr_bigram = curr_email[j] + ' ' + curr_email[j + 1]\\r\\n\\r\\n if curr_bigram in biSpamWords:\\r\\n index = biSpamWords.index(curr_bigram)\\r\\n biProbSpam += biLoggedSpam[index]\\r\\n else:\\r\\n biProbSpam += biLoggedSpamUNK\\r\\n\\r\\n if curr_bigram in biHamWords:\\r\\n index = biHamWords.index(curr_bigram)\\r\\n biProbHam += biLoggedHam[index]\\r\\n else:\\r\\n probHam += biLoggedHamUNK\\r\\n bi_dev_spam.append(probSpam)\\r\\n bi_dev_ham.append(probHam)\\r\\n\\r\\n # Weights the models (1-lambda) multiplier for unigram and lamba multiplier for bigram\\r\\n dev_labels = getBigram(bi_dev_ham, bi_dev_spam, dev_ham, dev_set, dev_spam, org_dev_labels)\\r\\n\\r\\n return dev_labels\",\n \"def build_bpmf_model(train, alpha=2, dim=10, std=0.01):\\n n, m = train.shape\\n beta_0 = 1 # scaling factor for lambdas; unclear on its use\\n\\n # Mean value imputation on training data.\\n train = train.copy()\\n nan_mask = np.isnan(train)\\n train[nan_mask] = train[~nan_mask].mean()\\n\\n logging.info('building the BPMF model')\\n with pm.Model() as bpmf:\\n # Specify user feature matrix\\n lambda_u = pm.Wishart(\\n 'lambda_u', n=dim, V=np.eye(dim), shape=(dim, dim),\\n testval=np.random.randn(dim, dim) * std)\\n mu_u = pm.Normal(\\n 'mu_u', mu=0, tau=beta_0 * lambda_u, shape=dim,\\n testval=np.random.randn(dim) * std)\\n U = pm.MvNormal(\\n 'U', mu=mu_u, tau=lambda_u, shape=(n, dim),\\n testval=np.random.randn(n, dim) * std)\\n\\n # Specify item feature matrix\\n lambda_v = pm.Wishart(\\n 'lambda_v', n=dim, V=np.eye(dim), shape=(dim, dim),\\n testval=np.random.randn(dim, dim) * std)\\n mu_v = pm.Normal(\\n 'mu_v', mu=0, tau=beta_0 * lambda_v, shape=dim,\\n testval=np.random.randn(dim) * std)\\n V = pm.MvNormal(\\n 'V', mu=mu_v, tau=lambda_v, shape=(m, dim),\\n testval=np.random.randn(m, dim) * std)\\n\\n # Specify rating likelihood function\\n R = pm.Normal(\\n 'R', mu=t.dot(U, V.T), tau=alpha * np.ones((n, m)),\\n observed=train)\\n\\n logging.info('done building the BPMF model')\\n return bpmf\",\n \"def __init__(self, X, y, sample_weights):\\n self.name = \\\"Gaussian Naive Bayes\\\"\\n self.clf = self.train(X, y, sample_weights)\",\n \"def learning_proposal(self):\\n\\n n, s = self.X_select.shape\\n\\n beta_hat = self.observed_MLE\\n\\n perturbed_beta = beta_hat.copy()\\n nidx = np.random.choice(np.arange(s), min(3, s), replace=False)\\n for idx in nidx:\\n scale = np.random.choice(self.scales, 1)\\n perturbed_beta[idx] += (scale * np.random.standard_normal() *\\n np.sqrt(self._beta_cov[idx, idx]))\\n \\n linpred = self.X_select.dot(perturbed_beta)\\n prob = normal_dbn.cdf(linpred)\\n perturbed_Y = np.random.binomial(1, prob)\\n\\n perturbed_MLE = probit_MLE(self.X, perturbed_Y, self.observed_outcome)[0]\\n return perturbed_MLE, perturbed_Y\",\n \"def __init__(self, pseudocount=0):\\n self._model = dict()\\n self._alpha = pseudocount\\n self._N = 0\\n self._V = 0\",\n \"def __init__(self, hidden_size, eps=1e-12):\\n super(BertLayerNorm, self).__init__()\\n self.weight = nn.Parameter(torch.ones(hidden_size))\\n self.bias = nn.Parameter(torch.zeros(hidden_size))\\n self.variance_epsilon = eps\",\n \"def __init__(self, hidden_size, eps=1e-12):\\n super(BertLayerNorm, self).__init__()\\n self.weight = nn.Parameter(torch.ones(hidden_size))\\n self.bias = nn.Parameter(torch.zeros(hidden_size))\\n self.variance_epsilon = eps\",\n \"def __init__(self,\\n num_features,\\n eps=1e-5,\\n momentum=0.1,\\n affine=True,\\n activation=\\\"leaky_relu\\\",\\n slope=0.01):\\n super(ABN, self).__init__()\\n self.num_features = num_features\\n self.affine = affine\\n self.eps = eps\\n self.momentum = momentum\\n self.activation = activation\\n self.slope = slope\\n if self.affine:\\n self.weight = nn.Parameter(torch.ones(num_features))\\n self.bias = nn.Parameter(torch.zeros(num_features))\\n else:\\n self.register_parameter('weight', None)\\n self.register_parameter('bias', None)\\n self.register_buffer('running_mean', torch.zeros(num_features))\\n self.register_buffer('running_var', torch.ones(num_features))\\n self.reset_parameters()\",\n \"def do_instance_pruning(self):\\n\\n # retrieve the probability of predicting fraud for each model (K models)\\n # size: K x ChunkSize x 2 (2 for binary labels)\\n predict_proba_fraud = [-1] * self.K\\n\\n # for each instance in the data chunk\\n for i, instance in enumerate(self.y_chunk):\\n sum_weight = 0\\n current_F = 0\\n F_vect = np.zeros(self.K) # Fk at each stage\\n\\n # compute F_k(y) for k = 1...K - the classifiers are sorted in DESCENDING order of weights\\n k = -1\\n for model in self.models.islice(start=0, stop=self.K, reverse=True):\\n k += 1\\n clf = model.clf\\n sum_weight += model.weight\\n\\n # compute the current probability\\n # if the probability is not initialized we call the `predict_proba` method\\n if (type(predict_proba_fraud[k]) is int and predict_proba_fraud[k] == -1) \\\\\\n or (predict_proba_fraud[k].shape[0] != self.S):\\n predict_proba_fraud[k] = clf.predict_proba(self.X_chunk)\\n\\n # check if we have the probabilities of 2 labels (because we're working with BINARY classification)\\n # if we don't have the probability of predicting fraud it will be 0 so we don't do anything\\n if len(predict_proba_fraud[k][i]) == 2:\\n current_F += model.weight * predict_proba_fraud[k][i][1]\\n\\n # (2) compute the Fk for each example seen at each stage\\n F_k = current_F / sum_weight\\n F_vect[k] = F_k\\n\\n # (3) compute the error\\n err_x = F_vect - F_vect[-1]\\n\\n # (4) update the mean and the variance of the error of these training examples for each bin (i,k)\\n # we look at the error at each step for the given example\\n for k, err in enumerate(err_x):\\n # 1 --> we assign Fk to the corresponding bin (i,k) or (j,k)here because we used i index before\\n eps = len(self.bins)\\n\\n for j in range(0, eps):\\n if (j / eps) <= F_vect[k] < ((j + 1) / eps):\\n self.bins[j][k]['num'] += 1\\n\\n # 2--> we compute the mean error in this bin\\n self.bins[j][k]['mean'] += err\\n\\n # 2--> we compute the variance of the error in this bin\\n # (basically we will just compute the squared error and do the division later)\\n self.bins[j][k]['var'] += err ** 2\\n\\n # if we've assigned it to a bin, break and go to the next stage\\n break\\n\\n # after computing everything we do the division by the total number assigned to a bin\\n for i in range(0, len(self.bins)):\\n # a bit tricky because sometimes we have bins that don't have any input example --> remains at 0\\n for k in range(self.K):\\n if self.bins[i][k]['num'] > 0:\\n # divide the sum of error by the number of examples in the bin\\n self.bins[i][k]['mean'] = self.bins[i][k]['mean'] / self.bins[i][k]['num']\\n\\n # compute the variance\\n self.bins[i][k]['var'] = (self.bins[i][k]['var'] / self.bins[i][k]['num']) - \\\\\\n (self.bins[i][k]['mean']) ** 2\",\n \"def naiveBayes(self):\\n acc = 0\\n #for each example in the test-set\\n for d in self.dev:\\n pred_good = self.prob_True\\n pred_bad = self.prob_False\\n #calc the probability for yes and no\\n for index in range(len(d[0])):\\n pred_good *= self.probs_yes[(index,d[0][index])]\\n pred_bad *=(self.probs_no[(index,d[0][index])])\\n pred = False\\n if pred_good >= pred_bad:\\n pred = True\\n if pred == d[1]:\\n acc +=1\\n return acc/len(self.dev)\",\n \"def main():\\n parser = argparse.ArgumentParser(description='Implementation of the Naive Bayes and Perceptron classifiers')\\n parser.add_argument('--statsmode', help='whether to gather stats or not', choices=['y','Y','N','n'], default='n')\\n parser.add_argument('--classifier', help='classifier to use', choices=['BAYES', 'PERCEPTRON'], required=True)\\n parser.add_argument('--mode', help='image class to test', choices=['VALIDATION', 'TEST'], default='TEST')\\n parser.add_argument('--type', help='image type to train', choices=['DIGIT', 'FACE', 'MNIST'], required=True)\\n parser.add_argument('--range', metavar=('START', 'END_EXCLUSIVE'), nargs=2, type=int, help='Range of data to test', default=[0, 100])\\n parser.add_argument('--trainpercent', metavar='PERCENT', type=int, help='the percent of training data to use (int out of 100)', default=100, dest='percentage')\\n parser.add_argument('--smoothing', type=int, help='Laplace smoothing constant (Naive Bayes)', default=2)\\n parser.add_argument('--iterations', type=int, help='Number of times to iterate over training data (Perceptron)', default=5)\\n parser.add_argument('--debug', help='Outputs more detailed information to stdout', action='store_true')\\n parser.add_argument('--statloops', type=int, help='Number of times the classifier iterates over test data (Statistics only)', default=5)\\n args = parser.parse_args()\\n # image_type = ImageType.DIGIT if args.type == 'DIGIT' else ImageType.FACE\\n image_type = None\\n if args.type == 'DIGIT':\\n image_type = ImageType.DIGIT\\n elif args.type == 'FACE':\\n image_type = ImageType.FACE\\n else:\\n image_type = ImageType.MNIST\\n mode = Mode.TEST if args.mode == 'TEST' else Mode.VALIDATION\\n if args.statsmode == 'y' or args.statsmode == 'Y':\\n run_percentages_classifier(args.classifier, image_type, args)\\n else:\\n run = run_classifier_bayes if args.classifier == 'BAYES' else run_classifier_perceptron\\n run(mode, image_type, args)\",\n \"def build_posterior(self):\\n if self.gp_core.alpha is None:\\n self.gp_core.build_posterior()\",\n \"def __init__(self):\\n self.model = GaussianNB();\\n self.X = iris.data\\n self.y = iris.target\",\n \"def __init__(self, epsilon=0.05, gamma=0.95, alpha=0.2, numTraining=0, **args):\\n args['epsilon'] = epsilon\\n args['gamma'] = gamma\\n args['alpha'] = alpha\\n args['numTraining'] = numTraining\\n self.index = 0 # This is always Pacman\\n PQLearningAgent.__init__(self, **args)\",\n \"def run_positive():\\n\\tbnn = BNNSVGDRegressor(uid=\\\"bnn-positive-eg\\\", configfile=\\\"configs/bnn-positive-eg.json\\\")\\n\\tbnn.load(**toy2())\\n\\tbnn.add_positive_constraint((-5.0, -3.0), lambda x: -x + 5)\\n\\tbnn.add_positive_constraint((3.0, 5.0), lambda x: x + 5)\\n\\tbnn.infer()\\n\\tbnn.plot_pp(plot_title=\\\"Predictive Posterior Plot\\\", domain=np.arange(-4, 4, 0.05), ylims=(0, 14))\",\n \"def __init__(self, hidden_layer_sizes, activation='relu', reg=0.001, k_fold=5, random_state=0):\\n print(\\\"Initialize model Multi-layer Perceptron\\\")\\n self.hidden_layer_sizes = hidden_layer_sizes\\n self.activation = activation\\n self.reg = reg\\n self.k_fold = k_fold\\n self.random_state = random_state\\n self.model = sklearn.neural_network.MLPClassifier(self.hidden_layer_sizes,\\n activation=self.activation,\\n alpha=self.reg, max_iter=1000, \\n random_state=self.random_state)\",\n \"def bayes_model(feature_train, help_rank_train, model_name):\\n model = MultinomialNB()\\n model.fit(feature_train, help_rank_train)\\n modelpkl = open(model_name,'wb')\\n dump(model, modelpkl, -1)\\n return\",\n \"def __init__(self,nback=1,ntokens_pm=2,ntokens_og=3,stimdim=2,seed=99):\\n np.random.seed(seed)\\n tr.manual_seed(seed)\\n self.nback = nback\\n # embedding\\n self.ntokens_pm = ntokens_pm\\n self.ntokens_og = ntokens_og\\n self.stimdim = stimdim\\n # emat\\n self.randomize_emat()\\n return None\",\n \"def __init__(self, num_features, eps=1e-6, is_bias=True, is_scale=True, is_eps_leanable=False):\\n super(FRN, self).__init__()\\n\\n self.num_features = num_features\\n self.init_eps = eps\\n self.is_eps_leanable = is_eps_leanable\\n self.is_bias = is_bias\\n self.is_scale = is_scale\\n\\n\\n self.weight = nn.parameter.Parameter(torch.Tensor(1, num_features, 1, 1), requires_grad=True)\\n self.bias = nn.parameter.Parameter(torch.Tensor(1, num_features, 1, 1), requires_grad=True)\\n if is_eps_leanable:\\n self.eps = nn.parameter.Parameter(torch.Tensor(1), requires_grad=True)\\n else:\\n self.register_buffer('eps', torch.Tensor([eps]))\\n self.reset_parameters()\",\n \"def __init__(self, alpha=1, beta=1000, basis_func=linear_basis_func,\\n prior=None, do_mcmc=True, n_hypers=20, chain_length=2000,\\n burnin_steps=2000, rng=None):\\n\\n if rng is None:\\n self.rng = np.random.RandomState(np.random.randint(0, 10000))\\n else:\\n self.rng = rng\\n\\n self.X = None\\n self.y = None\\n self.alpha = alpha\\n self.beta = beta\\n self.basis_func = basis_func\\n if prior is None:\\n self.prior = Prior(rng=self.rng)\\n else:\\n self.prior = prior\\n self.do_mcmc = do_mcmc\\n self.n_hypers = n_hypers\\n self.chain_length = chain_length\\n self.burned = False\\n self.burnin_steps = burnin_steps\\n self.models = None\",\n \"def __init__(self, **config):\\n super(Classifier, self).__init__()\\n self.input_dim_drug = config['hidden_dim_drug']\\n self.input_dim_protein = config['hidden_dim_protein']\\n self.hidden_dims = config['cls_hidden_dims']\\n self.visual_attention=config['visual_attention']\\n dims = [self.input_dim_drug + self.input_dim_protein] + self.hidden_dims + [2]\\n if config['attention']:\\n if config['concatenation']:\\n dims[0]+=config['cnn_target_filters'][-1]\\n else:\\n dims[0]=self.input_dim_drug+config['cnn_target_filters'][-1]\\n self.predictor = nn.ModuleList([nn.Linear(dims[i], dims[i + 1]) for i in range(len(self.hidden_dims)+1)])\\n self.dropout = nn.Dropout(0.25)\\n self._initialize()\",\n \"def build_mod_bpmf_model(train, alpha=2, dim=10, std=0.01):\\n n, m = train.shape\\n beta_0 = 1 # scaling factor for lambdas; unclear on its use\\n\\n # Mean value imputation on training data.\\n train = train.copy()\\n nan_mask = np.isnan(train)\\n train[nan_mask] = train[~nan_mask].mean()\\n\\n # We will use separate priors for sigma and correlation matrix.\\n # In order to convert the upper triangular correlation values to a\\n # complete correlation matrix, we need to construct an index matrix:\\n n_elem = dim * (dim - 1) / 2\\n tri_index = np.zeros([dim, dim], dtype=int)\\n tri_index[np.triu_indices(dim, k=1)] = np.arange(n_elem)\\n tri_index[np.triu_indices(dim, k=1)[::-1]] = np.arange(n_elem)\\n\\n logging.info('building the BPMF model')\\n with pm.Model() as bpmf:\\n # Specify user feature matrix\\n sigma_u = pm.Uniform('sigma_u', shape=dim)\\n corr_triangle_u = pm.LKJCorr(\\n 'corr_u', n=1, p=dim,\\n testval=np.random.randn(n_elem) * std)\\n\\n corr_matrix_u = corr_triangle_u[tri_index]\\n corr_matrix_u = t.fill_diagonal(corr_matrix_u, 1)\\n cov_matrix_u = t.diag(sigma_u).dot(corr_matrix_u.dot(t.diag(sigma_u)))\\n lambda_u = t.nlinalg.matrix_inverse(cov_matrix_u)\\n\\n mu_u = pm.Normal(\\n 'mu_u', mu=0, tau=beta_0 * t.diag(lambda_u), shape=dim,\\n testval=np.random.randn(dim) * std)\\n U = pm.MvNormal(\\n 'U', mu=mu_u, tau=lambda_u, shape=(n, dim),\\n testval=np.random.randn(n, dim) * std)\\n\\n # Specify item feature matrix\\n sigma_v = pm.Uniform('sigma_v', shape=dim)\\n corr_triangle_v = pm.LKJCorr(\\n 'corr_v', n=1, p=dim,\\n testval=np.random.randn(n_elem) * std)\\n\\n corr_matrix_v = corr_triangle_v[tri_index]\\n corr_matrix_v = t.fill_diagonal(corr_matrix_v, 1)\\n cov_matrix_v = t.diag(sigma_v).dot(corr_matrix_v.dot(t.diag(sigma_v)))\\n lambda_v = t.nlinalg.matrix_inverse(cov_matrix_v)\\n\\n mu_v = pm.Normal(\\n 'mu_v', mu=0, tau=beta_0 * t.diag(lambda_v), shape=dim,\\n testval=np.random.randn(dim) * std)\\n V = pm.MvNormal(\\n 'V', mu=mu_v, tau=lambda_v, shape=(m, dim),\\n testval=np.random.randn(m, dim) * std)\\n\\n # Specify rating likelihood function\\n R = pm.Normal(\\n 'R', mu=t.dot(U, V.T), tau=alpha * np.ones((n, m)),\\n observed=train)\\n\\n logging.info('done building the BPMF model')\\n return bpmf\",\n \"def model_setup(self):\\n self.DNN = SganMLP(self.settings.number_of_bins)\\n self.D = SganMLP(self.settings.number_of_bins)\\n self.G = Generator()\",\n \"def bias_prior(self):\",\n \"def Bayes_classifier(pi, x0, lamb):\\n D = len(x0)\\n ans = [1-pi, pi]\\n for y in range(2):\\n arg = [poisson.pmf(x0[d], lamb[y][d]) for d in range(D)]\\n ans[y] *= np.prod(arg)\\n return np.argmax(ans)\",\n \"def __init__(self, hidden_size, eps=1e-12):\\n super(BertLayerNorm, self).__init__()\\n self.weight = nn.Parameter(torch.ones(hidden_size))\\n self.bias = nn.Parameter(torch.zeros(hidden_size))\\n self.variance_epsilon = eps\",\n \"def __init__(self, hidden_size, eps=1e-12):\\n super(BertLayerNorm, self).__init__()\\n self.weight = nn.Parameter(torch.ones(hidden_size))\\n self.bias = nn.Parameter(torch.zeros(hidden_size))\\n self.variance_epsilon = eps\",\n \"def __init__(self, hidden_size, eps=1e-12):\\n super(BertLayerNorm, self).__init__()\\n self.weight = nn.Parameter(torch.ones(hidden_size))\\n self.bias = nn.Parameter(torch.zeros(hidden_size))\\n self.variance_epsilon = eps\",\n \"def __init__(self, hidden_size, eps=1e-12):\\n super(BertLayerNorm, self).__init__()\\n self.weight = nn.Parameter(torch.ones(hidden_size))\\n self.bias = nn.Parameter(torch.zeros(hidden_size))\\n self.variance_epsilon = eps\",\n \"def __init__(self, hidden_size, eps=1e-12):\\n super(BertLayerNorm, self).__init__()\\n self.weight = nn.Parameter(torch.ones(hidden_size))\\n self.bias = nn.Parameter(torch.zeros(hidden_size))\\n self.variance_epsilon = eps\",\n \"def __init__(self, frames_n, state_size, action_size, hidden_layer_size):\\n super(ActorCritic_Beta, self).__init__()\\n \\n self.frames_n = frames_n \\n self.state_size = state_size\\n self.action_size = action_size\\n self.hidden_layer_size = hidden_layer_size\\n \\n # ACTOR\\n self.actor_alphas_layer_1 = nn.Linear(in_features=self.frames_n * self.state_size, out_features=self.hidden_layer_size)\\n self.actor_alphas_layer_2 = nn.Linear(in_features=self.hidden_layer_size, out_features=self.hidden_layer_size)\\n self.actor_alphas_layer_3 = nn.Linear(in_features=self.hidden_layer_size, out_features=self.action_size)\\n \\n self.actor_betas_layer_1 = nn.Linear(in_features=self.frames_n * self.state_size, out_features=self.hidden_layer_size)\\n self.actor_betas_layer_2 = nn.Linear(in_features=self.hidden_layer_size, out_features=self.hidden_layer_size)\\n self.actor_betas_layer_3 = nn.Linear(in_features=self.hidden_layer_size, out_features=self.action_size)\\n \\n # CRITIC \\n self.critic_layer_1 = nn.Linear(in_features=self.frames_n * self.state_size, out_features=self.hidden_layer_size)\\n self.critic_layer_2 = nn.Linear(in_features=self.hidden_layer_size, out_features=self.hidden_layer_size)\\n self.critic_layer_3 = nn.Linear(in_features=self.hidden_layer_size, out_features=1)\",\n \"def __init__(self, in_features, out_features):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n self.params = {'weight': np.random.normal(loc = 0, scale=0.0001, size=(out_features,in_features)),\\\\\\n 'bias': np.zeros((1, out_features))}\\n \\n self.grads = {'weight': np.zeros((out_features,in_features)),\\\\\\n 'bias': np.zeros((1, out_features))}\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def __init__(self, p1_proba=0.5):\\n self.p1_proba = p1_proba\",\n \"def __init__(self, maxBirthProb, clearProb):\\r\\n\\r\\n self.maxBirthProb = maxBirthProb\\r\\n self.clearProb = clearProb\",\n \"def __init__(self, train_data, test_data):\\n self.train_data = train_data\\n self.test_data = test_data\\n\\n # Emission and transition probability distributions\\n self.emission_PD: ConditionalProbDist = None\\n self.transition_PD: ConditionalProbDist = None\\n self.states = []\\n\\n self.viterbi = []\\n self.backpointer = []\",\n \"def get_untrained_naive_bayes(bool_var, data_desc, ml_models, train_feature, train_result, \\n test_feature, option):\\n # just return case we dont want any naive bayes\\n if not bool_var: \\n return\\n\\n if option != 'optimization':\\n nb_name = 'naive_bayes' + get_suffix_ml_model()\\n [nb] = get_optimal_param(data_desc, 'naive_bayes') \\n multi_nb = MultiOutputRegressor(nb)\\n nb_train_feat = list(train_feature)\\n nb_test_feat = list(test_feature)\\n ml_models.append([nb_name, multi_nb, nb_train_feat, nb_test_feat])\\n\\n # try all configuration\\n else:\\n nb_name_lst = ['gaussian', 'multinomial', 'multi_bernoulli']\\n nb_obj_lst = [GaussianNB(), MultinomialNB(), BernoulliNB()]\\n for i in range(len(nb_name_lst)):\\n nb_name = 'naive_bayes' + get_suffix_ml_model()\\n nb_name += get_suffix_configuration([nb_name_lst[i]])\\n nb = nb_obj_lst[i]\\n multi_nb = MultiOutputRegressor(nb)\\n ml_models.append([nb_name, multi_nb, list(train_feature),\\n list(test_feature)])\",\n \"def test_bpe_embedder(self, resource_loader):\\n config = {\\n \\\"model_type\\\": \\\"tagger\\\",\\n \\\"example_type\\\": ENTITY_EXAMPLE_TYPE,\\n \\\"label_type\\\": ENTITIES_LABEL_TYPE,\\n \\\"model_settings\\\": {\\\"classifier_type\\\": \\\"embedder\\\"},\\n \\\"params\\\": { # default token_spans_pooling_type is \\\"first\\\"\\n \\\"emb_dim\\\": 30, \\\"tokenizer_type\\\": \\\"bpe-tokenizer\\\", \\\"add_terminals\\\": True\\n },\\n }\\n model = ModelFactory.create_model_from_config(ModelConfig(**config))\\n examples = self.labeled_data.queries()\\n labels = self.labeled_data.entities()\\n model.initialize_resources(resource_loader, examples, labels)\\n model.fit(examples, labels)\\n model_predictions_assertions(model)\\n\\n config = {**config, \\\"params\\\": {**config[\\\"params\\\"], \\\"token_spans_pooling_type\\\": \\\"mean\\\"}}\\n model = ModelFactory.create_model_from_config(ModelConfig(**config))\\n model.initialize_resources(resource_loader, examples, labels)\\n model.fit(examples, labels)\\n model_predictions_assertions(model)\\n\\n config = {**config, \\\"params\\\": {**config[\\\"params\\\"], \\\"token_spans_pooling_type\\\": \\\"max\\\"}}\\n model = ModelFactory.create_model_from_config(ModelConfig(**config))\\n model.initialize_resources(resource_loader, examples, labels)\\n model.fit(examples, labels)\\n model_predictions_assertions(model)\\n\\n config = {**config, \\\"params\\\": {**config[\\\"params\\\"], \\\"token_spans_pooling_type\\\": \\\"mean_sqrt\\\"}}\\n model = ModelFactory.create_model_from_config(ModelConfig(**config))\\n model.initialize_resources(resource_loader, examples, labels)\\n model.fit(examples, labels)\\n model_predictions_assertions(model)\\n\\n config = {**config, \\\"params\\\": {**config[\\\"params\\\"], \\\"token_spans_pooling_type\\\": \\\"last\\\"}}\\n model = ModelFactory.create_model_from_config(ModelConfig(**config))\\n model.initialize_resources(resource_loader, examples, labels)\\n model.fit(examples, labels)\\n model_predictions_assertions(model)\\n\\n config = {**config, \\\"params\\\": {\\n **config[\\\"params\\\"], \\\"use_crf_layer\\\": False, \\\"token_spans_pooling_type\\\": \\\"first\\\"}}\\n model = ModelFactory.create_model_from_config(ModelConfig(**config))\\n model.initialize_resources(resource_loader, examples, labels)\\n model.fit(examples, labels)\\n model_predictions_assertions(model)\",\n \"def test_class():\\n riskfree = .03\\n maturity = 30/365\\n moneyness = np.linspace(-.04, .04, 10)\\n premium = np.ones_like(moneyness) * .05\\n call = True\\n data = {'riskfree': riskfree, 'maturity': maturity,\\n 'moneyness': moneyness, 'call': call, 'premium': premium}\\n\\n sigma = .13\\n bsm = BSmodel(sigma, data)\\n\\n weights = [.63]\\n means = [-.01, .09]\\n stds = [.16, .05]\\n param = weights + means + stds\\n mbs = MBSmodel(param, data)\\n\\n param_a, param_p, param_c = 4, 1.5, -.05\\n gb2 = GB2model([param_a, param_p, param_c], data)\\n print(gb2.get_pnames())\\n\\n plt.figure()\\n for model in [bsm, mbs, gb2]:\\n plt.plot(moneyness, model.density(moneyness), label=model.get_name())\\n plt.legend()\\n plt.show()\\n\\n plt.figure()\\n for model in [bsm, mbs, gb2]:\\n plt.plot(moneyness, model.premium(), label=model.get_name())\\n plt.legend()\\n plt.show()\\n\\n plt.figure()\\n for model in [bsm, mbs, gb2]:\\n plt.plot(moneyness, model.impvol(), label=model.get_name())\\n plt.legend()\\n plt.show()\\n\\n print('BS objective function = %.4f' % bsm.objective(sigma))\\n print('GB2 objective function = %.4f'\\n % gb2.objective([param_a, param_p, param_c]))\",\n \"def run_bayes(self, prior, fill_half_light=True, verbose=True):\\n # Checks\\n if self.Pchance is None:\\n raise IOError(\\\"Set Pchance before calling this method\\\")\\n # Priors\\n self.calc_priors(prior['S'], method=prior['M'])\\n # Fill?\\n if fill_half_light:\\n prior['theta']['r_half'] = self.candidates['half_light'].values\\n self.set_theta_prior(prior['theta'])\\n # P(O|x)\\n self.calc_POx()\\n #\\n if verbose:\\n print(\\\"All done with Bayes\\\")\",\n \"def trainUsingNNOnPenDigitData(actualData, labels, testData, testLabels):\\n # Initialize variables\\n epoch = 40\\n eta = 0.01\\n inputNeurons = actualData.shape[1]\\n hiddenNeurons = 10\\n outputNeurons = 4\\n\\n # Initialize weights and bias of hidden layer and output layer\\n weightsHidden = np.random.uniform(-1, 0.99, size=(inputNeurons+1, hiddenNeurons))\\n weightsOutput = np.random.uniform(-1, 0.99, size=(hiddenNeurons+1, outputNeurons))\\n\\n biasInput = np.ones((actualData.shape[0], 1))\\n actualData = np.append(actualData, biasInput, axis=1)\\n biasTest = np.ones((testData.shape[0], 1))\\n testData = np.append(testData, biasTest, axis=1)\\n\\n # Outer loop for all the Epochs\\n for i in range(epoch):\\n print(\\\"Epoch: \\\", i)\\n for index, row in enumerate(actualData):\\n\\n # Forward Propogation\\n hiddenInputs = np.dot(row, weightsHidden)\\n # hiddenActivation = nn.sigmoid(hiddenInputs)\\n hiddenActivation = nn.sigmoid(hiddenInputs)\\n hiddenActivation = np.append(hiddenActivation, [1], axis=0)\\n outputInputs = np.dot(hiddenActivation, weightsOutput)\\n sMaxOutput = nn.softMax(outputInputs)\\n\\n # Calculating stuff for backpropogation\\n crossEntropyError = nn.calculateError(sMaxOutput, labels[index])\\n\\n # BackPropogation from Output to Hidden Layer\\n derCrossEntropyErrors = nn.calculateDerCrossEntropy(sMaxOutput, labels[index])\\n derSoftMaxOutputs = nn.calculateDerSoftMax(outputInputs)\\n derOutputWeights = hiddenActivation\\n updateWeightsOutput = np.matmul(derOutputWeights.reshape(hiddenNeurons+1, 1),\\n np.transpose(derCrossEntropyErrors * derSoftMaxOutputs).reshape(1, 4))\\n\\n # BackPropogation from Hidden to Input Layer\\n derTotalError = np.array([])\\n temp1 = derCrossEntropyErrors * derSoftMaxOutputs\\n\\n for p, eachWeight in enumerate(weightsOutput):\\n derTotalError = np.append(derTotalError, np.dot(np.transpose(temp1), eachWeight))\\n\\n derTotalError = derTotalError[:-1]\\n derSigmoidHiddenInputs = nn.derivativeSigmoid(hiddenInputs)\\n temp2 = derTotalError * derSigmoidHiddenInputs\\n\\n replicatedInput = nn.replicateRow(row, hiddenNeurons)\\n\\n updateWeightsInput = np.zeros(weightsHidden.shape)\\n for p, eachRow in enumerate(np.transpose(replicatedInput)):\\n updateWeightsInput[p] = temp2 * eachRow\\n\\n weightsOutput = weightsOutput - eta * updateWeightsOutput\\n weightsHidden = weightsHidden - eta * updateWeightsInput\\n\\n correct = 0\\n for j, r in enumerate(testData):\\n # Forward Propogation\\n hiddenInputs = np.dot(r, weightsHidden)\\n # hiddenActivation = nn.sigmoid(hiddenInputs)\\n hiddenActivation = nn.tanh(hiddenInputs)\\n hiddenActivation = np.append(hiddenActivation, [1], axis=0)\\n outputInputs = np.dot(hiddenActivation, weightsOutput)\\n\\n # Calculating stuff for backpropogation\\n sMaxOutput = nn.softMax(outputInputs)\\n predictedLabel = np.argmax(sMaxOutput) + 1\\n if predictedLabel == (np.argmax(testLabels[j]) + 1):\\n correct += 1\\n\\n print(\\\"Correct \\\", correct)\\n print(\\\"Total \\\", testData.shape[0])\\n accuracy = float(correct) / testData.shape[0]\\n print(\\\"Accuracy: \\\", accuracy)\",\n \"def __init__(self, n_source, t_base):\\n self.null = BetaBernouilli(1.0, 1.0) # p(NULL) ~ Beta(1, 1)\\n self.a_table = AlignmentDistribution(GammaPrior(1.0, 1.0, 4.0))\\n self.t_base = t_base\\n self.t_table = [PYP(self.t_base, PYPPrior(1.0, 1.0, 1.0, 1.0, 0.1, 1.0))\\n for _ in xrange(n_source)]\",\n \"def obtain_training_parameters(para, x, y, alg = 'LR'):\\n \\n \\n global omega\\n \\n # Iterate to find the optimal parameters\\n if alg == 'LR': # logistic regression\\n omega = np.zeros((3, 1))\\n alpha = para.step_size # step size\\n for i in range(para.iteration):\\n grad = np.zeros((3, 1))\\n for i in range(len(x[:, 0])):\\n grad += np.reshape(x[i, :], (3, 1)) * (-y[i] + 1 / (1 + np.exp(-np.dot(x[i, :], omega))))\\n omega -= alpha * grad \\n \\n elif alg == 'GNB': # Gaussian Naive Bayes\\n # get counts for each class\\n itszero = 0\\n itsone = 0\\n for i in range(len(y)):\\n if y[i] == 1:\\n itsone += 1\\n else:\\n itszero += 1\\n \\n # probability of see y\\n theta0 = itszero / len(y)\\n theta1 = 1 - theta0\\n \\n # mean of omega\\n mew00 = 0\\n mew01 = 0\\n mew02 = 0\\n mew10 = 0\\n mew11 = 0\\n mew12 = 0\\n for i in range(len(y)):\\n if y[i] == 0:\\n mew00 += x[i, 0] / itszero\\n mew01 += x[i, 1] / itszero\\n mew02 += x[i, 2] / itszero\\n else:\\n mew10 += x[i, 0] / itsone\\n mew11 += x[i, 1] / itsone\\n mew12 += x[i, 2] / itsone\\n \\n # variance of omega \\n sigma00 = 0\\n sigma01 = 0\\n sigma02 = 0\\n sigma10 = 0\\n sigma11 = 0\\n sigma12 = 0\\n for i in range(len(y)):\\n if y[i] == 0:\\n sigma00 += (x[i, 0] - mew00)**2 / itszero\\n sigma01 += (x[i, 1] - mew01)**2 / itszero\\n sigma02 += (x[i, 2] - mew02)**2 / itszero\\n else:\\n sigma10 += (x[i, 0] - mew10)**2 / itsone\\n sigma11 += (x[i, 1] - mew11)**2 / itsone\\n sigma12 += (x[i, 2] - mew12)**2 / itsone\\n \\n # store these parameters into the name \\\"omage\\\"\\n omega = [theta0, theta1, mew00, mew01, mew02, mew10, mew11, mew12,\\n sigma00, sigma01, sigma02, sigma10, sigma11, sigma12] \\n \\n else: # Gaussian Mixture\\n pass\\n \\n return omega\",\n \"def betabinom_artifact_model_probability(data,\\n prior_p=betabinom_p_prior[0],\\n prior_beta=betabinom_beta_prior[0],\\n mutation_object=True):\\n\\n if mutation_object is True:\\n trajectories = data.data\\n else:\\n trajectories = data\\n\\n # initialise list of samples for p integration\\n int_p = []\\n # integral over betabinom p parameter\\n for p_sample in prior_p[0, :]:\\n # initialise list of samples for beta integration\\n int_beta = []\\n # integrate over beta parameter\\n for beta_sample in prior_beta[0, :]:\\n # For each combination of p and beta parameters compute\\n # lieklihood of observing a given time-series conditional\\n # on initial time-point.\\n alpha_sample = beta_sample*p_sample/(1-p_sample)\\n # compute likelihood for each individual omiting first time point\\n ind_likelihoods = []\\n for ind_traj in trajectories:\\n likelihood = betabinom.pmf(k=ind_traj[1:].AO,\\n n=ind_traj[1:].DP,\\n a=alpha_sample,\\n b=beta_sample)\\n ind_likelihoods.append(np.product(likelihood))\\n # for each beta append the total likelihood (product individuals).\\n int_beta.append(np.product(ind_likelihoods))\\n # For each p, compute the likelihood marginalised over beta\\n int_p.append(\\n np.trapz(x=prior_beta[0, :],\\n y=int_beta*prior_beta[1, :]))\\n \\n # marginalise likelihood over p\\n mutation_prob = np.trapz(x=prior_p[0, :],\\n y=int_p*prior_p[1, :])\\n\\n if mutation_object is True:\\n # return updated model_comparison object \\n data.betabinom_artifact_prob = mutation_prob\\n return data\\n else:\\n # return marginalised likelihood.\\n return mutation_prob\",\n \"def update_probabilities(self):\\n self.probabilities = self.pheromones**self.EXP_PH * self.mcv**self.EXP_MCV\",\n \"def sample_posterior(self):\\n if(self.Bayesian):\\n for i in range(self.num_layers):\\n getattr(self, 'LSTMCell%i'%(i+1)).sample_posterior()\",\n \"def naiveBayes(x_train, x_test, y_train):\\n gnb = GaussianNB()\\n y_pred = gnb.fit(x_train, y_train).predict(x_test)\\n return y_pred\",\n \"def test_fit_prep_proba():\\n args = get_layer('fit', 'manual', 'temporal', True, True, window=2, step_size=3)\\n run_layer(*args)\",\n \"def __init__(self, clf, y_real, y_pred, y_proba):\\n self.clf = clf\\n self.y_real = y_real\\n self.y_pred = y_pred\\n self.y_proba = y_proba\",\n \"def __init__(self) :\\n self.probabilities_ = None\",\n \"def __init__(self) :\\n self.probabilities_ = None\",\n \"def __init__(self) :\\n self.probabilities_ = None\",\n \"def __init__(self, prior: float, beta: float = 0., gamma: float = 1.0):\\n super(NonNegativePULoss, self).__init__()\\n\\n self.beta = beta\\n self.prior = prior\\n self.gamma = gamma\\n self.loss_fn = torch.nn.CrossEntropyLoss(reduction='none')\",\n \"def __init__(self, b=0, drop_rate=0.5, pretrained=True):\\n\\n # Calls the super for the nn.Module.\\n super(SelectiveNet, self).__init__()\\n\\n # Loads the EfficientNet encoder.\\n if pretrained:\\n self.encoder = EfficientNet.from_pretrained(f\\\"efficientnet-b{str(b)}\\\")\\n else:\\n self.encoder = EfficientNet.from_name(f\\\"efficientnet-b{str(b)}\\\")\\n self.encoder_pool = nn.AdaptiveAvgPool2d(1)\\n\\n # Defines a hidden layer.\\n self.hidden = nn.Linear(2560, 512)\\n\\n # Initialises the classifier for generating predictions.\\n self.classifier = nn.Linear(512, 2)\\n\\n # Initialises the selective branch for generating selection scores.\\n self.selective_hidden = nn.Linear(512, 512)\\n self.selective_batch_norm = nn.BatchNorm1d(512)\\n self.selective_regression = nn.Linear(512, 1)\\n\\n # Initialises the auxiliary output used by the model during training.\\n self.auxiliary_output = nn.Linear(512, 2)\\n\\n # Stores the dropout rate in the object.\\n self.drop_rate = drop_rate\",\n \"def __init__(self, in_features, out_features):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n\\n\\n self.params = {'weight': 0.0001 * np.random.randn(out_features, in_features), 'bias': np.zeros((out_features, 1))}\\n self.grads = {'weight': np.zeros((out_features, in_features)), 'bias': np.zeros((out_features, 1))}\\n\\n\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def construct_parameters(self, method= \\\"random\\\", W = np.zeros(1), b = np.zeros(1), initialization=True):\\n #W = np.asarray(W, dtype=object)\\n #b = np.asarray(b, dtype=object)\\n for i in reversed(range(1,len(self.architecture))):\\n \\n if initialization==True:\\n if self.activations[i-1] in {'relu' , 'leakyrelu' , 'ealu'}:\\n variance = np.sqrt(2/(self.architecture[i-1])) #He initialization\\n elif self.activations[i-1] == 'tanh':\\n variance = np.sqrt(6/(self.architecture[i-1] + self.architecture[i])) #Xavier initialization\\n elif self.activations[i-1] in ('swish' , 'sigmoid'):\\n variance = np.sqrt(1/(self.architecture[i-1]))\\n else:\\n variance = 1\\n \\n elif initialization == False:\\n variance = 1\\n \\n if method == 'random':\\n self.weights_and_biases[f'W{i}'] = np.random.rand(self.architecture[i-1], self.architecture[i])*variance #randomised initialisation \\n self.weights_and_biases[f'b{i}'] = np.zeros(self.architecture[i])*variance\\n \\n elif method == 'manual': #manual initialisation using given weights and biases\\n self.weights_and_biases[f'W{i}'] = W[i-1]\\n self.weights_and_biases[f'b{i}'] = b[i-1] \\n return self.weights_and_biases\",\n \"def __post_init__(self) -> None:\\n super().__post_init__()\\n\\n # We generate our instance seed pairs once\\n is_keys = self.get_instance_seed_keys_of_interest()\\n\\n # Budgets, followed by lots of sanity-checking\\n eta = self._eta\\n min_budget = self._min_budget\\n max_budget = self._max_budget\\n\\n if max_budget is not None and min_budget is not None and max_budget < min_budget:\\n raise ValueError(\\\"Max budget has to be larger than min budget.\\\")\\n\\n if self.uses_instances:\\n if isinstance(min_budget, float) or isinstance(max_budget, float):\\n raise ValueError(\\\"Successive Halving requires integer budgets when using instances.\\\")\\n\\n min_budget = min_budget if min_budget is not None else 1\\n max_budget = max_budget if max_budget is not None else len(is_keys)\\n\\n if max_budget > len(is_keys):\\n raise ValueError(\\n f\\\"Max budget of {max_budget} can not be greater than the number of instance-seed \\\"\\n f\\\"keys ({len(is_keys)}).\\\"\\n )\\n\\n if max_budget < len(is_keys):\\n logger.warning(\\n f\\\"Max budget {max_budget} does not include all instance seed \\\" f\\\"pairs ({len(is_keys)}).\\\"\\n )\\n else:\\n if min_budget is None or max_budget is None:\\n raise ValueError(\\n \\\"Successive Halving requires the parameters min_budget and max_budget defined in the scenario.\\\"\\n )\\n\\n if len(is_keys) != 1:\\n raise ValueError(\\\"Successive Halving supports only one seed when using budgets.\\\")\\n\\n if min_budget is None or min_budget <= 0:\\n raise ValueError(\\\"Min budget has to be larger than 0.\\\")\\n\\n budget_type = \\\"INSTANCES\\\" if self.uses_instances else \\\"BUDGETS\\\"\\n logger.info(\\n f\\\"Successive Halving uses budget type {budget_type} with eta {eta}, \\\"\\n f\\\"min budget {min_budget}, and max budget {max_budget}.\\\"\\n )\\n\\n # Pre-computing Successive Halving variables\\n max_iter = self._get_max_iterations(eta, max_budget, min_budget)\\n budgets, n_configs = self._compute_configs_and_budgets_for_stages(eta, max_budget, max_iter)\\n\\n # Global variables\\n self._min_budget = min_budget\\n self._max_budget = max_budget\\n\\n # Stage variables, depending on the bracket (0 is the bracket here since SH only has one bracket)\\n self._max_iterations: dict[int, int] = {0: max_iter + 1}\\n self._n_configs_in_stage: dict[int, list] = {0: n_configs}\\n self._budgets_in_stage: dict[int, list] = {0: budgets}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6395938","0.63691896","0.6234702","0.62117696","0.6144598","0.6126539","0.61065125","0.61020076","0.60287267","0.60050046","0.60005945","0.59805095","0.59656256","0.59533674","0.5929694","0.5922263","0.58944905","0.58921105","0.5883023","0.58764946","0.585208","0.5844802","0.5842833","0.5828768","0.58260536","0.58260536","0.58260536","0.58228076","0.58201385","0.5805383","0.5797119","0.5787163","0.5762612","0.5758019","0.5721305","0.5717386","0.5716316","0.570585","0.5685052","0.56744957","0.5670233","0.56665957","0.56499296","0.5649122","0.56386083","0.5636627","0.56290656","0.5616187","0.56072503","0.56032544","0.5579845","0.5579845","0.5554132","0.55505425","0.5549657","0.5547715","0.55475134","0.5531218","0.5529652","0.55296266","0.5525663","0.5524145","0.55225086","0.55202335","0.5519314","0.55182123","0.5517017","0.55159324","0.55043864","0.5502841","0.5498889","0.5498889","0.5498889","0.5498889","0.5498889","0.54973763","0.54905814","0.5489699","0.54865015","0.54847515","0.54835063","0.5480873","0.5467628","0.5466357","0.5465051","0.5463129","0.5461488","0.5459505","0.5456491","0.54488","0.5442432","0.5441168","0.5437701","0.5433299","0.5433299","0.5433299","0.54319096","0.54296976","0.5420744","0.54190665","0.5418111"],"string":"[\n \"0.6395938\",\n \"0.63691896\",\n \"0.6234702\",\n \"0.62117696\",\n \"0.6144598\",\n \"0.6126539\",\n \"0.61065125\",\n \"0.61020076\",\n \"0.60287267\",\n \"0.60050046\",\n \"0.60005945\",\n \"0.59805095\",\n \"0.59656256\",\n \"0.59533674\",\n \"0.5929694\",\n \"0.5922263\",\n \"0.58944905\",\n \"0.58921105\",\n \"0.5883023\",\n \"0.58764946\",\n \"0.585208\",\n \"0.5844802\",\n \"0.5842833\",\n \"0.5828768\",\n \"0.58260536\",\n \"0.58260536\",\n \"0.58260536\",\n \"0.58228076\",\n \"0.58201385\",\n \"0.5805383\",\n \"0.5797119\",\n \"0.5787163\",\n \"0.5762612\",\n \"0.5758019\",\n \"0.5721305\",\n \"0.5717386\",\n \"0.5716316\",\n \"0.570585\",\n \"0.5685052\",\n \"0.56744957\",\n \"0.5670233\",\n \"0.56665957\",\n \"0.56499296\",\n \"0.5649122\",\n \"0.56386083\",\n \"0.5636627\",\n \"0.56290656\",\n \"0.5616187\",\n \"0.56072503\",\n \"0.56032544\",\n \"0.5579845\",\n \"0.5579845\",\n \"0.5554132\",\n \"0.55505425\",\n \"0.5549657\",\n \"0.5547715\",\n \"0.55475134\",\n \"0.5531218\",\n \"0.5529652\",\n \"0.55296266\",\n \"0.5525663\",\n \"0.5524145\",\n \"0.55225086\",\n \"0.55202335\",\n \"0.5519314\",\n \"0.55182123\",\n \"0.5517017\",\n \"0.55159324\",\n \"0.55043864\",\n \"0.5502841\",\n \"0.5498889\",\n \"0.5498889\",\n \"0.5498889\",\n \"0.5498889\",\n \"0.5498889\",\n \"0.54973763\",\n \"0.54905814\",\n \"0.5489699\",\n \"0.54865015\",\n \"0.54847515\",\n \"0.54835063\",\n \"0.5480873\",\n \"0.5467628\",\n \"0.5466357\",\n \"0.5465051\",\n \"0.5463129\",\n \"0.5461488\",\n \"0.5459505\",\n \"0.5456491\",\n \"0.54488\",\n \"0.5442432\",\n \"0.5441168\",\n \"0.5437701\",\n \"0.5433299\",\n \"0.5433299\",\n \"0.5433299\",\n \"0.54319096\",\n \"0.54296976\",\n \"0.5420744\",\n \"0.54190665\",\n \"0.5418111\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":91999,"cells":{"query":{"kind":"string","value":"THIS FUNCTION REMOVES THE PLANNED EVENTS FROM THE EVENT DATASET"},"document":{"kind":"string","value":"def removePlanned(X,y):\n \n X_new=[]\n y_new=[]\n for i in range(len(y)):\n #print(i)\n \n if y[i]==0:\n y_new.append(0)\n X_new.append(X[i,:,:,:])\n \n elif y[i]==1:\n y_new.append(1)\n X_new.append(X[i,:,:,:])\n \n \n elif y[i]==2:\n y_new.append(2)\n X_new.append(X[i,:,:,:])\n \n elif y[i]==3:\n y_new.append(3)\n X_new.append(X[i,:,:,:])\n \n\n return np.array(X_new), np.array(y_new)"},"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 OnRearrangeEnd(self, evt):\n\t\tself._potentialRearrange = False\n\t\tself._didCopy = False\n\t\tevt.Skip()","def bindEvents(fusionEvents,divisionEvents, buff):\n #1/Finding correspondances\n fusion_indices = []\n fusion_labels = []\n fusion_labels_2 = [] # In label 2 says with which cell the disappearded one has\n for events,label in fusionEvents:\n index,osef,labels = events\n fusion_indices.append(index)\n fusion_labels.append(labels[0])\n fusion_labels_2.append(label)\n \n division_indices = []\n division_labels = []\n division_labels_2 = [] # Tells in which cell it is created\n for events,label in divisionEvents:\n index,osef,labels = events\n division_indices.append(index)\n division_labels.append(labels[0])\n division_labels_2.append(label)\n \n associated_division_list = []\n associated_indexes = []\n for i in fusion_indices:\n ind = next((x for x in division_indices if x>i),-1)\n if ind>0:\n associated_division_list.append((i,ind))\n corr_ind_fusion = fusion_indices.index(i)\n corr_ind_division = division_indices.index(ind)\n associated_indexes.append((corr_ind_fusion,corr_ind_division))\n\n \n #2/removing corresponding elements\n for j in range(len(associated_division_list)):\n index_fus, index_div = associated_indexes[j]\n if division_labels_2[index_div]==fusion_labels_2[index_fus]:\n #If they are not equal, means that the process of division/fusion \n #has not happened on the same blob and hence is not relevant\n big_label = division_labels_2[index_div]\n small_label = fusion_labels[index_fus]\n new_label = division_labels[index_div] #Replace after division this label by small label\n first_index = fusion_indices[index_fus]\n second_index = division_indices[index_div]\n \n for k in range(second_index-first_index):\n splitCell(buff,first_index+k,big_label,small_label)\n \n #Attribution of the new created cells to each one of the previous cells:\n #For this, we take the closest centroid\n #centroid of the big label\n last_image = buff[:,:,second_index]\n xs,ys = centroids2(last_image,[big_label,new_label])\n xs0,ys0 = centroids2(buff[:,:,second_index-1],[big_label,small_label])\n dist_regular = (xs0[0]-xs[0])**2 + (ys0[0]-ys[0])**2 + (xs0[1]-xs[1])**2 + (ys0[1]-ys[1])**2\n dist_inverted = (xs0[0]-xs[1])**2 + (ys0[0]-ys[1])**2 + (xs0[1]-xs[0])**2 + (ys0[1]-ys[0])**2\n \n if dist_regular>dist_inverted:\n print \"ca marche pas gael euh quoi?\"\n tmp_stack = buff[:,:,second_index:]\n tmp_stack[buff[:,:,second_index:]==big_label]=small_label\n tmp_stack[buff[:,:,second_index:]==new_label]=big_label\n buff[:,:,second_index:] = tmp_stack\n division_labels = [x if (x!=new_label and x!=big_label) else big_label if x==new_label else small_label for x in division_labels]\n fusion_labels = [x if x!=new_label and x!=big_label else big_label if x==new_label else small_label for x in fusion_labels]\n division_labels_2= [x if x!=new_label and x!=big_label else big_label if x==new_label else small_label for x in division_labels_2]\n fusion_labels_2= [x if x!=new_label and x!=big_label else big_label if x==new_label else small_label for x in fusion_labels_2]\n else:\n print \"ca marche bien gael\"\n \"\"\"Reassigning new labels\"\"\"\n tmp_stack = buff[:,:,second_index:]\n tmp_stack[tmp_stack==new_label] = small_label\n buff[:,:,second_index:] = tmp_stack\n division_labels = [x if x!=new_label else small_label for x in division_labels]\n fusion_labels = [x if x!=new_label else small_label for x in fusion_labels]\n division_labels_2 = [x if x!=new_label else small_label for x in division_labels_2]\n fusion_labels_2 = [x if x!=new_label else small_label for x in fusion_labels_2]","def onafterresetting(self, event):\n print('onafterresetting; event: %s, %s->%s' % (event.event, event.src, event.dst))","def delace(self):\n if not self.isdelaced:\n newframes = []\n self.frame_dt /= 2\n for i, frame in enumerate(self.frames):\n newframes.append(\n Frame(\n frame.data[1::2, :],\n self.starttime\n + datetime.timedelta(seconds=self.frame_dt * (2 * i)),\n )\n )\n newframes.append(\n Frame(\n frame.data[0::2, :],\n self.starttime\n + datetime.timedelta(seconds=self.frame_dt * (2 * i + 1)),\n )\n )\n self.isdelaced = True\n self.frames = newframes\n self.length = len(newframes)\n else:\n print(\"Video already deinterlaced.\")","def _clear(self):\n self.events = []\n self.last_on = None\n self.last_off = None","def on_unassign(self):","def reset(self):\n for k,v in self.events.items():\n self.events[k] = None","def switch_pattern(self):\n event = self.event_deque.popleft()\n event.reset()\n self.event_deque.append(event)\n self.last_switch = pygame.time.get_ticks()","def _unmove(self):\n (start, end) = self.history.pop()\n self._board[start] = self._board[end]\n self._board[end] = 0\n self.winner = None\n self.player_turn = CheckersGame.opposite[self.player_turn]","def cleanup_event_list(self):\n self._event_list, self._event_index_list = \\\n zip(*SimpleDeduplicator.remove_duplicates_from_event_list(\n zip(self._event_list, self._event_index_list)))","def recall(self):\n for t in self.placed_tiles:\n row = self.placed_tiles[t][1][0]\n col = self.placed_tiles[t][1][1]\n # remove tiles from board\n self.board.board[row][col].letter = None\n # put tiles back on rack\n self.rack[t] = self.placed_tiles[t][0]","def _revert(self):\n if self.kwargs.get(\"collect\"):\n remove_exported_collect_data(self.kwargs[\"collect\"])","def delete_lag_ports(self, ports, lag):\n pass","def disconnect_poselocs():\r\n #TODO: Eventually create a non-linear way to re-add the nodes for a pose if you want to edit it later.\r\n if DRYRUN:\r\n print('poselocs deleted - DRY RUN ONLY')\r\n return False\r\n\r\n for oPos in pm.ls('*_POSE', type='transform'):\r\n pm.delete(oPos.getChildren(ad=True, type='transform'))","def clear_events():\n while len(events) > 0:\n canvas.delete(events.pop())","def clean(self):\n self.change_events = []","def unisolvent_nodes(self):\r\n pass","def undo(self):\n if self._snapshot_index >= 0:\n snapshot = self._snapshots[self._snapshot_index]\n for chunk_location in snapshot:\n dimension, cx, cz = chunk_location\n chunk = self._unserialise_chunk(dimension, cx, cz, -1)\n self._chunk_cache[chunk_location] = chunk\n self._snapshot_index -= 1","def _revert(self):\n self.release_from_output(\"data\")\n # delete ONA submissions on ONA","def finish_command(self):\n\n # remap source\n orig_nodes = self.data.keys()\n for orig_node in orig_nodes:\n new_node = self.mapping[orig_node] or orig_node\n\n if new_node != orig_node:\n self.data[new_node] = self.data[orig_node]\n del self.data[orig_node]\n\n set_data(self.data,\n create_attrs=self.create_attrs,\n set_values=self.set_values,\n set_values_on_all=self.set_values_on_all)","def _revert(self):\n self.kwargs[\"collect\"].change_status(self.kwargs[\"collect\"].ENDED)","def wipe(self):\n if len(self.node) > 1:\n # self.obj.Shape.nullify() # For some reason this fails\n self.obj.ViewObject.Visibility = False\n self.node = [self.node[-1]]\n if self.planetrack:\n self.planetrack.set(self.node[0])\n _msg(translate(\"draft\", \"Pick next point\"))","def wipe(self):\n if len(self.node) > 1:\n # self.obj.Shape.nullify() # For some reason this fails\n self.obj.ViewObject.Visibility = False\n self.node = [self.node[-1]]\n if self.planetrack:\n self.planetrack.set(self.node[0])\n _msg(translate(\"draft\", \"Pick next point\"))","def revive(self) -> None:\n\n cached_events = cherrypy.engine.publish(\n \"cache:match\",\n \"scheduler\"\n ).pop()\n\n if not cached_events:\n return\n\n counter = 0\n\n for cached_event in cached_events:\n self.add(\n cached_event[\"time\"] - time.time(),\n *cached_event[\"argument\"],\n **cached_event[\"kwargs\"]\n )\n counter += 1\n\n if counter > 0:\n unit = \"event\" if counter == 1 else \"events\"\n\n cherrypy.engine.publish(\n \"applog:add\",\n \"scheduler\",\n f\"{counter} {unit} revived\"\n )","def popUnsetData(self,N):\n self.r_Vm = self.r_Vm[:N]\n self.r_Va = self.r_Va[:N]","def unscheduleFirst(self, runnable):\n for evt in self.store.query(TimedEvent, TimedEvent.runnable == runnable, sort=TimedEvent.time.ascending):\n evt.deleteFromStore()\n break","def recycle_fragments(self, fragments: list, source: tuple, destination: tuple):\n pass","def clear_for_new_board(self):\r\n self.game_board = []\r\n self.good_contours = []\r\n self.game_board_contours = []","def event_remove(event_name:str):#maybe make a add events function\n global removed_manually\n global notification_index #always incremented so notifications can be removed\n for y in range(len(Events_list)): # sorted in ascending order.\n if removed_manually is False:#if the alrm has expired by its own ,check if it has extras selected and if so; display them:\n if Events_list[y][5] == \"true\": #news\n temp_notifi_list = news().copy()\n for w in temp_notifi_list:\n a = w[0]#news title\n b = w[1]#link\n notification_list.append(['\"{}\"'.format(a), \"not_alarm\",[str(notification_index),\"newslink\",'{}'.format(b)]])\n notification_index+=1\n temp_notifi_list = covid_data().copy()\n for w in temp_notifi_list:\n notification_list.append(['\"{}\"'.format(w), \"not_alarm\",[str(notification_index)]])\n notification_index+=1\n if Events_list[y][4] == \"true\":#weather\n notification_list.append(['\"{}\"'.format(\"Todays Weather: \" + weather()), \"not_alarm\",[str(notification_index)]])\n notification_index+=1\n if Events_list[y][0] == event_name:\n event_log(\"rescheduling alarm for next day....\",\"\")\n if Events_list[y][3] == \"true\" and removed_manually is False:#if this is true the the event is set to be repeated\n new_date = time.strftime('%Y-%m-%d %H:%M', time.localtime(convert_to_epoch(Events_list[y][1]) + 86400))\n set_alarm(new_date, event_name, Events_list[y][2], Events_list[y][3],Events_list[y][4],Events_list[y][5])\n notification_list.append(['\"{}\"'.format(event_name) + \"Has been rescheduled for next day\", \"alarm\", Events_list[y]])\n speak_output(event_name + \"has been repeated for next day\")\n else:#event is going to be removed\n event_log(\"removing alarm....\",\"\")\n removed_manually = False#changes the boolean so the function can go back to deafult state as this is global varibale\n notification_list.append(['\"{}\"'.format(event_name) + \" is expired/deleted\", \"alarm\", Events_list[y]])\n speak_output(event_name + \"has expired or been removed\")\n Events_list.pop(y)#removes from list\n temp_notifi_list = []\n write()\n break","def reset_wm(self):\n\n self.plan = []\n self.hist = []","def test_remove_portless_vfc_maps2(self):\n vwrap = self.vio_feed[0]\n # Save the \"before\" size of the VFC mapping list\n vfc_len = len(vwrap.vfc_mappings)\n # Count our target LPAR's mappings before\n lpar24maps = self.count_maps_for_lpar(vwrap.vfc_mappings, 24)\n ts.ScrubPortlessVFCMaps(self.adpt, lpar_id=24).execute()\n # Overall one map was scrubbed\n self.assertEqual(vfc_len - 1, len(vwrap.vfc_mappings))\n # ...and it was the right one\n self.assertEqual(lpar24maps - 1,\n self.count_maps_for_lpar(vwrap.vfc_mappings, 24))\n self.assertEqual(1, self.txfx.patchers['update'].mock.call_count)","def undo(self, event=None):\n if not self.segs == []:\n self.requestSegByDct((self.segs[-1].getDct() + 2) % 4)","def update_schedule(module, array):\n changed = True\n if not module.check_mode:\n changed = False\n try:\n schedule = array.get_pgroup(module.params['name'], schedule=True)\n retention = array.get_pgroup(module.params['name'], retention=True)\n if not schedule['replicate_blackout']:\n schedule['replicate_blackout'] = [{'start': 0, 'end': 0}]\n except Exception:\n module.fail_json(msg=\"Failed to get current schedule for pgroup {0}.\".format(module.params['name']))\n current_repl = {'replicate_frequency': schedule['replicate_frequency'],\n 'replicate_enabled': schedule['replicate_enabled'],\n 'target_days': retention['target_days'],\n 'replicate_at': schedule['replicate_at'],\n 'target_per_day': retention['target_per_day'],\n 'target_all_for': retention['target_all_for'],\n 'blackout_start': schedule['replicate_blackout'][0]['start'],\n 'blackout_end': schedule['replicate_blackout'][0]['end']}\n current_snap = {'days': retention['days'],\n 'snap_frequency': schedule['snap_frequency'],\n 'snap_enabled': schedule['snap_enabled'],\n 'snap_at': schedule['snap_at'],\n 'per_day': retention['per_day'],\n 'all_for': retention['all_for']}\n if module.params['schedule'] == 'snapshot':\n if not module.params['snap_frequency']:\n snap_frequency = current_snap['snap_frequency']\n else:\n if not 300 <= module.params['snap_frequency'] <= 34560000:\n module.fail_json(msg=\"Snap Frequency support is out of range (300 to 34560000)\")\n else:\n snap_frequency = module.params['snap_frequency']\n\n if not module.params['snap_at']:\n snap_at = current_snap['snap_at']\n else:\n snap_at = module.params['snap_at']\n\n if not module.params['days']:\n days = current_snap['days']\n else:\n if module.params['days'] > 4000:\n module.fail_json(msg=\"Maximum value for days is 4000\")\n else:\n days = module.params['days']\n\n if not module.params['per_day']:\n per_day = current_snap['per_day']\n else:\n if module.params['per_day'] > 1440:\n module.fail_json(msg=\"Maximum value for per_day is 1440\")\n else:\n per_day = module.params['per_day']\n\n if not module.params['all_for']:\n all_for = current_snap['all_for']\n else:\n if module.params['all_for'] > 34560000:\n module.fail_json(msg=\"Maximum all_for value is 34560000\")\n else:\n all_for = module.params['all_for']\n new_snap = {'days': days,\n 'snap_frequency': snap_frequency,\n 'snap_enabled': module.params['enabled'],\n 'snap_at': snap_at,\n 'per_day': per_day,\n 'all_for': all_for}\n if current_snap != new_snap:\n try:\n array.set_pgroup(module.params['name'],\n snap_enabled=module.params['enabled'])\n array.set_pgroup(module.params['name'],\n snap_frequency=snap_frequency,\n snap_at=snap_at)\n array.set_pgroup(module.params['name'],\n days=days,\n per_day=per_day,\n all_for=all_for)\n changed = True\n except Exception:\n module.fail_json(msg='Failed to change snapshot schedule for pgroup {0}.'.format(module.params['name']))\n else:\n if not module.params['replicate_frequency']:\n replicate_frequency = current_repl['replicate_frequency']\n else:\n model = array.get(controllers=True)[0]['model']\n if '405' in model or '10' in model or 'CBS' in model:\n if not 900 <= module.params['replicate_frequency'] <= 34560000:\n module.fail_json(msg=\"Replication Frequency support is out of range (900 to 34560000)\")\n else:\n replicate_frequency = module.params['replicate_frequency']\n else:\n if not 300 <= module.params['replicate_frequency'] <= 34560000:\n module.fail_json(msg=\"Replication Frequency support is out of range (300 to 34560000)\")\n else:\n replicate_frequency = module.params['replicate_frequency']\n\n if not module.params['replicate_at']:\n replicate_at = current_repl['replicate_at']\n else:\n replicate_at = module.params['replicate_at']\n\n if not module.params['target_days']:\n target_days = current_repl['target_days']\n else:\n if module.params['target_days'] > 4000:\n module.fail_json(msg=\"Maximum value for target_days is 4000\")\n else:\n target_days = module.params['target_days']\n\n if not module.params['target_per_day']:\n target_per_day = current_repl['target_per_day']\n else:\n if module.params['target_per_day'] > 1440:\n module.fail_json(msg=\"Maximum value for target_per_day is 1440\")\n else:\n target_per_day = module.params['target_per_day']\n\n if not module.params['target_all_for']:\n target_all_for = current_repl['target_all_for']\n else:\n if module.params['target_all_for'] > 34560000:\n module.fail_json(msg=\"Maximum target_all_for value is 34560000\")\n else:\n target_all_for = module.params['target_all_for']\n if not module.params['blackout_end']:\n blackout_end = current_repl['blackout_start']\n else:\n blackout_end = _convert_to_minutes(module.params['blackout_end'])\n if not module.params['blackout_start']:\n blackout_start = current_repl['blackout_start']\n else:\n blackout_start = _convert_to_minutes(module.params['blackout_start'])\n\n new_repl = {'replicate_frequency': replicate_frequency,\n 'replicate_enabled': module.params['enabled'],\n 'target_days': target_days,\n 'replicate_at': replicate_at,\n 'target_per_day': target_per_day,\n 'target_all_for': target_all_for,\n 'blackout_start': blackout_start,\n 'blackout_end': blackout_end}\n if current_repl != new_repl:\n blackout = {'start': blackout_start, 'end': blackout_end}\n try:\n array.set_pgroup(module.params['name'],\n replicate_enabled=module.params['enabled'])\n array.set_pgroup(module.params['name'],\n replicate_frequency=replicate_frequency,\n replicate_at=replicate_at)\n if blackout_start == 0:\n array.set_pgroup(module.params['name'],\n replicate_blackout=None)\n else:\n array.set_pgroup(module.params['name'],\n replicate_blackout=blackout)\n array.set_pgroup(module.params['name'],\n target_days=target_days,\n target_per_day=target_per_day,\n target_all_for=target_all_for)\n changed = True\n except Exception:\n module.fail_json(msg='Failed to change replication schedule for pgroup {0}.'.format(module.params['name']))\n\n module.exit_json(changed=changed)","def restart(self):\n self.dominated_set = []\n self.np = 0\n self.rank = None\n self.crowding_distance = 0","def __reset(self):\n self.game_moves_history = []\n self.player_id = None","def fix_unpaired_events(self):\n\n if self.observationId:\n\n r, msg = project_functions.check_state_events_obs(self.observationId, self.pj[ETHOGRAM],\n self.pj[OBSERVATIONS][self.observationId])\n if \"not PAIRED\" not in msg:\n QMessageBox.information(self, programName, \"All state events are already paired\",\n QMessageBox.Ok | QMessageBox.Default, QMessageBox.NoButton)\n return\n\n '''\n if self.playerType == VIEWER:\n # max time\n time_ = max(x[0] for x in self.pj[OBSERVATIONS][self.observationId][EVENTS])\n else:\n time_ = self.getLaps()\n '''\n\n w = dialog.JumpTo(self.timeFormat)\n w.setWindowTitle(\"Fix UNPAIRED state events\")\n w.label.setText(\"Fix UNPAIRED events at time\")\n\n if w.exec_():\n if self.timeFormat == HHMMSS:\n fix_at_time = utilities.time2seconds(w.te.time().toString(HHMMSSZZZ))\n elif self.timeFormat == S:\n fix_at_time = Decimal(str(w.te.value()))\n print(\"fix_at_time\", fix_at_time)\n\n events_to_add = project_functions.fix_unpaired_state_events(self.observationId,\n self.pj[ETHOGRAM],\n self.pj[OBSERVATIONS][self.observationId],\n fix_at_time - Decimal(\"0.001\")\n )\n if events_to_add:\n self.pj[OBSERVATIONS][self.observationId][EVENTS].extend(events_to_add)\n self.projectChanged = True\n self.pj[OBSERVATIONS][self.observationId][EVENTS].sort()\n self.loadEventsInTW(self.observationId)\n item = self.twEvents.item(\n [i for i, t in enumerate(self.pj[OBSERVATIONS][self.observationId][EVENTS]) if\n t[0] == fix_at_time][0], 0)\n self.twEvents.scrollToItem(item)\n\n # selected observations\n else:\n result, selected_observations = self.selectObservations(MULTIPLE)\n if not selected_observations:\n return\n\n # check if state events are paired\n out = \"\"\n not_paired_obs_list = []\n for obs_id in selected_observations:\n r, msg = project_functions.check_state_events_obs(obs_id, self.pj[ETHOGRAM],\n self.pj[OBSERVATIONS][obs_id])\n print(\"msg\", msg)\n if \"NOT PAIRED\" in msg.upper():\n fix_at_time = max(x[0] for x in self.pj[OBSERVATIONS][obs_id][EVENTS])\n events_to_add = project_functions.fix_unpaired_state_events(obs_id,\n self.pj[ETHOGRAM],\n self.pj[OBSERVATIONS][obs_id],\n fix_at_time\n )\n if events_to_add:\n events_backup = self.pj[OBSERVATIONS][obs_id][EVENTS][:]\n self.pj[OBSERVATIONS][obs_id][EVENTS].extend(events_to_add)\n\n # check if modified obs if fixed\n r, msg = project_functions.check_state_events_obs(obs_id, self.pj[ETHOGRAM],\n self.pj[OBSERVATIONS][obs_id])\n if \"NOT PAIRED\" in msg.upper():\n out += \"The observation <b>{}</b> can not be automatically fixed.<br><br>\".format(obs_id)\n self.pj[OBSERVATIONS][obs_id][EVENTS] = events_backup\n else:\n out += \"<b>{}</b><br>\".format(obs_id)\n self.projectChanged = True\n if out:\n out = \"The following observations were modified to fix the unpaired state events:<br><br>\" + out\n self.results = dialog.Results_dialog()\n self.results.setWindowTitle(programName + \" - Fixed observations\")\n self.results.ptText.setReadOnly(True)\n self.results.ptText.appendHtml(out)\n self.results.pbSave.setVisible(False)\n self.results.pbCancel.setVisible(True)\n self.results.exec_()\n else:\n QMessageBox.information(self, programName, \"All state events are already paired\",\n QMessageBox.Ok | QMessageBox.Default, QMessageBox.NoButton)","def remove(name, send_events=True, moving=False):","def revolver(self):\r\n\t\tself.__revuelto=True","def reset(self):\n inv_perm = np.argsort(self._current_order)\n self._current_order = self._current_order[inv_perm]\n self.inputs = self.inputs[inv_perm]\n self.targets = self.targets[inv_perm]\n self.new_epoch()","def switch_features_handler(self, ev):\n datapath = ev.msg.datapath\n [self.remove_flows(datapath, n) for n in [0, 1]]","def BorrarListas(self,evt):\n self.l_bal = []\n self.l_muestras = []\n self.l_vol = []\n self.l_den = []\n self.l_calidad = []\n self.idact = 0","def island_migration(self):\n for y in self.island_map:\n for cell in y:\n cell.migration()\n\n for y in self.island_map:\n for cell in y:\n for animal in cell.population:\n animal.has_moved = False","def migrateDown(self):\n subStore = self.store.parent.getItemByID(self.store.idInParent)\n ssph = self.store.parent.findUnique(\n _SubSchedulerParentHook,\n _SubSchedulerParentHook.subStore == subStore,\n default=None)\n if ssph is not None:\n te = self.store.parent.findUnique(TimedEvent,\n TimedEvent.runnable == ssph,\n default=None)\n if te is not None:\n te.deleteFromStore()\n ssph.deleteFromStore()","def reset(self):\n inv_perm = np.argsort(self._current_order)\n self._current_order = self._current_order[inv_perm]\n self.inputs = self.inputs[inv_perm]\n self.targets = self.targets[inv_perm]\n self.target_ids = self.target_ids[inv_perm]\n self.new_epoch()","def _revert(self):\n if self.kwargs.get(\"collect\"):\n remove_collect_medias(self.kwargs[\"collect\"])","def redo(self):\n if self._snapshot_index <= len(self._snapshots) - 2:\n snapshot = self._snapshots[self._snapshot_index + 1]\n for chunk_location in snapshot:\n dimension, cx, cz = chunk_location\n chunk = self._unserialise_chunk(dimension, cx, cz, 1)\n self._chunk_cache[chunk_location] = chunk\n self._snapshot_index += 1","def reformat_events(self, data, features):\n # Update alias\n if isinstance(features, list):\n [x.update(dict(alias=self.alias[(x[features[0]],\n x[features[1]])])) for x in data]\n else:\n [x.update(dict(alias=self.alias[x[features]])) for x in data]\n temp_data = list()\n # define ordering keys and columns\n if self.one_timestamp:\n columns = ['alias', 'duration', 'dur_act_norm']\n sort_key = 'end_timestamp'\n else:\n sort_key = 'start_timestamp'\n columns = ['alias', 'processing_time',\n 'proc_act_norm', 'waiting_time', 'wait_act_norm']\n data = sorted(data, key=lambda x: (x['caseid'], x[sort_key]))\n for key, group in itertools.groupby(data, key=lambda x: x['caseid']):\n trace = list(group)\n temp_dict = dict()\n for col in columns:\n serie = [y[col] for y in trace]\n if col == 'alias':\n temp_dict = {**{'profile': serie}, **temp_dict}\n else:\n serie = [y[col] for y in trace]\n temp_dict = {**{col: serie}, **temp_dict}\n temp_dict = {**{'caseid': key, 'start_time': trace[0][sort_key],\n 'end_time': trace[-1][sort_key]},\n **temp_dict}\n temp_data.append(temp_dict)\n return sorted(temp_data, key=itemgetter('start_time'))","def resend_buffer_packets():\n global BUFFER\n for seq in BUFFER.keys():\n packet_info = BUFFER[seq]\n msg_obj = packet_info.msg\n new_start = time.time()\n handle_packet_send(msg_obj)\n new_packet_info = PacketInfo(msg_obj, new_start)\n # Update the packet in the buffer with the new time sent at\n BUFFER[seq] = new_packet_info","def update_events_start_stop(self):\n\n # stateEventsList = [self.pj[ETHOGRAM][x][BEHAVIOR_CODE] for x in self.pj[ETHOGRAM] if\n # STATE in self.pj[ETHOGRAM][x][TYPE].upper()]\n\n for row in range(0, self.twEvents.rowCount()):\n\n t = self.twEvents.item(row, tw_obs_fields[\"Tempo\"]).text()\n\n if \":\" in t:\n time = time2seconds(t)\n else:\n time = Decimal(t)\n\n subject = self.twEvents.item(row, tw_obs_fields[\"Sujeito\"]).text()\n key = self.twEvents.item(row, tw_obs_fields[\"Chave\"]).text()\n modifier = self.twEvents.item(row, tw_obs_fields[\"Modificador\"]).text()\n\n # check if code is state\n nbEvents = len(\n [event[EVENT_BEHAVIOR_FIELD_IDX] for event in self.pj[OBSERVATIONS][self.observationId][EVENTS]\n if event[EVENT_BEHAVIOR_FIELD_IDX] == key\n and event[EVENT_TIME_FIELD_IDX] < time\n and event[EVENT_SUBJECT_FIELD_IDX] == subject\n and event[EVENT_MODIFIER_FIELD_IDX] == modifier])\n\n # if nbEvents and (nbEvents % 2): # test >0 and odd\n # self.twEvents.item(row, tw_obs_fields[TYPE]).setText(STOP)\n # else:\n # self.twEvents.item(row, tw_obs_fields[TYPE]).setText(START)","def reset(self):\n\t\tself.offsets = self.start_off.copy()","def wipe(self, segments):\n self.firstCoords = None\n self.moveLead(MIDDLE, MIDDLE)\n for seg in self.segs:\n self.can.delete(seg.getGraphicObject())\n seg.rmGraphicObject()\n self.segs = segments\n self.redrawSegs()","def stop_procrastinating(self):\n for layer, l in sorted(self.postponed.items()):\n for fun, args, rgb in l:\n self.set_source_rgb(*rgb)\n fun(*args, procrastinate=0)\n self.postponed = {}","def _handle_window_update(self, event: events.WindowUpdated) -> None:\n stream_id = event.stream_id\n\n if stream_id and stream_id in self._flow_control_events:\n g_event = self._flow_control_events.pop(stream_id)\n g_event.set()\n elif not stream_id:\n # Need to keep a real list here to use only the events present at this time.\n blocked_streams = list(self._flow_control_events.keys())\n for stream_id in blocked_streams:\n g_event = self._flow_control_events.pop(stream_id)\n g_event.set()","def remove_events(self):\n tofiltercalibfnames1, tofiltercalibfnames2 = split_into_telescopes(self.tofiltercalibfnames)\n\n nameiter = tqdm(self.superstarmcolfnames)\n for ssmcolfname in nameiter:\n nameiter.set_description(f\"Processing {path.basename(ssmcolfname)}\")\n currentrun = get_run(ssmcolfname)\n ssmcoldf = pd.read_csv(ssmcolfname, index_col=False)\n # newfname1 = self.single_remove_events(ssmcoldf, ssmcolfname, tofiltercalibfnames1, self.m1sscols)\n # newfname2 = self.single_remove_events(ssmcoldf, ssmcolfname, tofiltercalibfnames2, self.m2sscols)\n # if self.assert_filtermask_and_dfs(filtermask1, filtermask2, tofiltercalibdf1, tofiltercalibdf2, ssmcoldf) is False:\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames1, currentrun), self.bugdir)\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames2, currentrun), self.bugdir)\n # os.remove(newfname1)\n # os.remove(newfname2)\n # continue\n tofiltercalibdf1, oldname1 = self._merge_subruns(tofiltercalibfnames1,\n currentrun, getoldname=True)\n tofiltercalibdf2, oldname2 = self._merge_subruns(tofiltercalibfnames2,\n currentrun, getoldname=True)\n if len(tofiltercalibdf1) == 0:\n logger.warning(f\"calibfiles already processed, skipping {path.basename(ssmcolfname)} current run: {currentrun} \\n\")\n continue\n\n filtermask1 = self.get_filtermask(tofiltercalibdf1.iloc[:, self.mcolidx], ssmcoldf[self.m1sscols])\n filtermask2 = self.get_filtermask(tofiltercalibdf2.iloc[:, self.mcolidx], ssmcoldf[self.m2sscols])\n if self.invert is False:\n filtermask1, tofiltercalibdf1 = self.fix_idiosyncracies(filtermask1, tofiltercalibdf1, ssmcoldf[self.m1sscols])\n filtermask2, tofiltercalibdf2 = self.fix_idiosyncracies(filtermask2, tofiltercalibdf2, ssmcoldf[self.m2sscols])\n\n if self.assert_filtermask_and_dfs(filtermask1, filtermask2, tofiltercalibdf1, tofiltercalibdf2, ssmcoldf) is False:\n self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames1, currentrun), self.bugdir)\n self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames2, currentrun), self.bugdir)\n continue\n\n newfname1 = self._get_newfilename(oldname=oldname1)\n newfname2 = self._get_newfilename(oldname=oldname2)\n\n nameiter.set_description(f\"Saving {path.basename(newfname1)}\")\n tofiltercalibdf1.iloc[filtermask1].to_csv(newfname1, header=False, index=False)\n nameiter.set_description(f\"Saving {path.basename(newfname2)}\")\n tofiltercalibdf2.iloc[filtermask2].to_csv(newfname2, header=False, index=False)\n self.outfilenames.extend([newfname1, newfname2])\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames1, currentrun))\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames2, currentrun))","def events_reset(self):\n self._expected_events = []\n jsonfiles = [p for p in [os.path.join(self._event_dir, f)\n for f in os.listdir(self._event_dir)]\n if os.path.isfile(p)]\n for jsonfile in jsonfiles:\n os.unlink(jsonfile)","def removeEvent(self):\n raise NotImplementedError","def clear_points(self):\n print \"clearing each frame of selected points\"\n self.point_3d = None\n self.allUVs = []\n for iFrame in self.frames:\n iFrame.lastClick = None; \n self.displayImage(iFrame)","def refreshView(self):\n chldn = self.tDisp.get_children()\n for chld in chldn:\n self.tDisp.delete(chld)\n if len(self.conflict.infeasibles) > 0:\n self.conflict.recalculateFeasibleStates()\n for infeas in self.conflict.infeasibles:\n key = infeas.name\n self.tDisp.insert('', 'end', key, text=key)\n self.tDisp.set(key, 'state', key)\n self.tDisp.set(key, 'stDes', str(2**(key.count('-'))))\n self.tDisp.set(key, 'stRem', str(infeas.statesRemoved))","def on_detach(self, function_graph):","def actualizar_poderes(self, event):\r\n pass","def reset_component_data(self, result):\n self.toggle_components(result)\n self.event = None\n self.pose_shifter_status = None\n self.started_components = False","def filter_out_flickers(total_buffer,index_disappeared):\n \n wait_for_disparition = False\n candidate_for_disparition = -1\n to_destroy = [] #List of 3D tuples (value,first_index,last_index) of segmented elements to remove from image\n beginning_index = -1\n premier_i =-1\n list_of_is =[]\n \n previous_index, osef2, osef3 = index_disappeared[0] #Get the index for the first event\n\n for i in range(0,len(index_disappeared)):\n index,diff,list_index = index_disappeared[i]\n #Remove an appearing and disappearing object from the experiment only if it\n #disappears in the next 5 (arbitrary) frames. If longer, conseder that something relevant\n #happened.\n \n if wait_for_disparition:\n #If sth appeared, destroy it if:\n #-It is the same object that disappears\n #-If the event is a disparition\n #-If it disappears in a time<time_thr\n size = np.count_nonzero(total_buffer[:,:,index-1]==list_index[0])\n if list_index[0]==candidate_for_disparition and diff<0 and size<500:\n to_destroy.append((list_index[0],beginning_index,index))\n list_of_is.append(premier_i)\n list_of_is.append(i)\n wait_for_disparition=False\n \n if diff>0: #Creation, do wait for disparition\n candidate_for_disparition = list_index[0]\n beginning_index = index\n wait_for_disparition =True\n premier_i = i\n \n return to_destroy,list_of_is","def remove():","def test_remove_portless_vfc_maps1(self):\n vwrap = self.vio_feed[0]\n # Save the \"before\" size of the VFC mapping list\n vfc_len = len(vwrap.vfc_mappings)\n # Count our target LPARs' mappings before\n lpar24maps = self.count_maps_for_lpar(vwrap.vfc_mappings, 24)\n lpar124maps = self.count_maps_for_lpar(vwrap.vfc_mappings, 124)\n ts.ScrubPortlessVFCMaps(self.adpt).execute()\n # Overall two fewer maps\n self.assertEqual(vfc_len - 2, len(vwrap.vfc_mappings))\n # ...and they were the right ones\n self.assertEqual(lpar24maps - 1,\n self.count_maps_for_lpar(vwrap.vfc_mappings, 24))\n self.assertEqual(lpar124maps - 1,\n self.count_maps_for_lpar(vwrap.vfc_mappings, 124))\n self.assertEqual(1, self.txfx.patchers['update'].mock.call_count)","def revise():","def prepare(self):\n # Remove rows where the temporal scope could not be parsed correctly.\n self.triples = self.triples[(self.triples.time_begin != -99999) & (self.triples.time_end != -99999)]\n\n # Remove rows with start time after the end time.\n time_diffs = self.triples[\"time_end\"] - self.triples[\"time_begin\"]\n invalid_times = time_diffs[time_diffs < 0].index\n self.triples.drop([x for x in invalid_times], inplace=True, axis=\"index\")\n\n # Remove all entities that no longer have any facts associated with them from the dictionary.\n entity_counts = Utils.get_entity_counts(self.triples, self.entities)\n for idx, count in entity_counts.items():\n if count == 0:\n del self.entities[idx]\n\n # Remove all relations that no longer have any facts associated with them from the dictionary.\n relation_counts = Utils.get_group_counts(self.triples.groupby(\"relation_id\"), self.relations)\n for idx, count in relation_counts.items():\n if count == 0:\n del self.relations[idx]","def reset_data(self):\n\n # Callback object to run, step and reset the model properly.\n self.residential = True\n self.callback_obj = None\n self.data = self.model.measurements.get_bokeh_vis_data()\n\n # Check if it's the initial reset (create new sources) or a reset button\n # click (update .data only)\n try:\n self.source.data = self.data\n self.line_source.data = self.data[self.data.agent_type == 'system']\n self.update_filters()\n self.update_data()\n\n # Reset is clicked --> update .data only\n except AttributeError:\n self.source = ColumnDataSource(self.data)\n self.line_source = ColumnDataSource(\n self.data[self.data.agent_type == 'system'])","def undo(self):\n if self.history:\n xy0, xy1, data_size = self.history.pop()\n x0, y0 = xy0\n x1, y1 = xy1\n self._used[y1][x1] -= data_size\n self._used[y0][x0] = data_size\n if self.goal == xy1:\n self.goal = xy0","def _replace_event(self, state, new_event, old_event, total_events):\n raise NotImplemented","def delete_schedule(module, array):\n changed = True\n if not module.check_mode:\n try:\n current_state = array.get_pgroup(module.params['name'], schedule=True)\n if module.params['schedule'] == \"replication\":\n if current_state['replicate_enabled']:\n array.set_pgroup(module.params['name'], replicate_enabled=False)\n array.set_pgroup(module.params['name'], target_days=0, target_per_day=0,\n target_all_for=1)\n array.set_pgroup(module.params['name'], replicate_frequency=14400,\n replicate_blackout=None)\n else:\n changed = False\n else:\n if current_state['snap_enabled']:\n array.set_pgroup(module.params['name'], snap_enabled=False)\n array.set_pgroup(module.params['name'], days=0, per_day=0, all_for=1)\n array.set_pgroup(module.params['name'], snap_frequency=300)\n else:\n changed = False\n except Exception:\n module.fail_json(msg='Deleting pgroup {0} {1} schedule failed.'.format(module.params['name'],\n module.params['schedule']))\n module.exit_json(changed=changed)","def disarm(self):\n pass","def undo_scan(self, sub_array_id: int):","def test_delete_voltage_maps(self):\n pass","def resumeFrameEvents(self, resumeevent):\n print \"resume decision made\"\n self.playstate = \"PLAYING\"\n self.framequeue = sorted(self.framequeue, key=lambda event: event.timestamp, reverse=True)\n delta = resumeevent.timestamp - self.framequeue[-1].timestamp\n \n tmp_framequeue = list()\n for event in self.framequeue:\n event.timestamp += delta\n tmp_framequeue.append(event)\n self.framequeue = tmp_framequeue","def rm_button_press(self, cmdid):\n i = index_of_cmdid(self.cmds_list, cmdid)\n del self.sched_rv.data[i]\n del self.cmds_list[i]\n self.clear_sched()\n\n startingID = 0 # zero indexed\n idCounter = startingID\n\n for cmds in self.cmds_list: # repopulate schedule tab w/ updated cmds_list and their new id\n if cmds.cmdid > idCounter:\n cmds.cmdid = idCounter # keep id count consistent\n self.sched_rv.data.append(cmds.cmd_dict())\n idCounter = idCounter + 1\n self.cmdid = idCounter","def clear(self):\n self.events={}","def filterEvents(intervals_dates,list_infected,distance):\n d=distance\n list_gpsevents=[]\n for z in range(len(intervals_dates)-1):\n print(\"Interval: \",intervals_dates[z], \"y\", intervals_dates[z+1])\n infected,uninfected=getTrazaTimestamp(intervals_dates[z],intervals_dates[z+1],GPSrecords,list_infected)\n events_gps = nearest_neighbor(infected, uninfected, d)\n events_gps = events_gps.drop(['geometry','closest_stop_geom'], axis=1)\n print(len(events_gps))\n if(len(events_gps)!=0):\n list_gpsevents.append(events_gps.reset_index(drop=True))\n else:\n events_gps=pd.DataFrame()\n list_gpsevents.append(events_gps)\n #GPSevents=pd.concat(list_gpsevents).reset_index(drop=True)\n #return GPSevents\n return list_gpsevents","def moveSelectedSegs(self,dragPosy,source):\n # TODO: check: I think the dict is always in descending order down screen?\n self.segsChanged = True\n # The first line seemed neater, but the verticalSpacing() doesn't update when you rescale the window\n #movetoID = dragPosy//(self.picbuttons[0].size().height()+self.flowLayout.layout.verticalSpacing())\n movetoID = dragPosy//(self.flowLayout.layout.geometry().height()//self.nclasses)\n\n # drags which start and end in the same cluster most likely were just long clicks:\n for ix in range(len(self.picbuttons)):\n if self.picbuttons[ix] == source:\n if self.segments[ix][-1] == movetoID:\n source.clicked.emit()\n return\n\n # Even if the button that was dragged isn't highlighted, make it so\n source.mark = 'yellow'\n\n for ix in range(len(self.picbuttons)):\n if self.picbuttons[ix].mark == 'yellow':\n self.segments[ix][-1] = movetoID\n self.picbuttons[ix].mark = 'green'\n\n # update self.clusters, delete clusters with no members\n todelete = []\n for ID, label in self.clusters.items():\n empty = True\n for seg in self.segments:\n if seg[-1] == ID:\n empty = False\n break\n if empty:\n todelete.append(ID)\n\n self.clearButtons()\n\n # Generate new class labels\n if len(todelete) > 0:\n keys = [i for i in range(self.nclasses) if i not in todelete] # the old keys those didn't delete\n # print('old keys left: ', keys)\n\n nclasses = self.nclasses - len(todelete)\n max_label = nclasses - 1\n labels = []\n c = self.nclasses - 1\n while c > -1:\n if c in keys:\n labels.append((c, max_label))\n max_label -= 1\n c -= 1\n\n # print('[old, new] labels')\n labels = dict(labels)\n print(labels)\n\n # update clusters dictionary {ID: cluster_name}\n clusters = {}\n for i in keys:\n clusters.update({labels[i]: self.clusters[i]})\n\n print('before move: ', self.clusters)\n self.clusters = clusters\n print('after move: ', self.clusters)\n\n # update the segments\n for seg in self.segments:\n seg[-1] = labels[seg[-1]]\n\n self.nclasses = nclasses\n\n # redraw the buttons\n self.updateButtons()\n self.updateClusterNames()\n self.completeChanged.emit()","def on_leave(self):\r\n for widgets in self.timecompoundlist:\r\n for w in widgets:\r\n self.ids.inlayout.remove_widget(w)\r\n self.ids.inlayout.remove_widget(self.add_button)\r\n self.ids.inlayout.remove_widget(self.del_button)","def on_prune(self, fgraph, app, reason):\r\n #if app not in self.debug_all_apps: raise ProtocolError(\"prune without import\")\r\n #self.debug_all_apps.remove(app)\r\n\r\n #UPDATE self.clients\r\n for i, input in enumerate(OrderedSet(app.inputs)):\r\n del self.clients[input][app]\r\n\r\n if getattr(app.op, 'destroy_map', {}):\r\n self.destroyers.remove(app)\r\n\r\n # Note: leaving empty client dictionaries in the struct.\r\n # Why? It's a pain to remove them. I think they aren't doing any harm, they will be\r\n # deleted on_detach().\r\n\r\n #UPDATE self.view_i, self.view_o\r\n for o_idx, i_idx_list in getattr(app.op, 'view_map', {}).items():\r\n if len(i_idx_list) > 1:\r\n #destroying this output invalidates multiple inputs\r\n raise NotImplementedError()\r\n o = app.outputs[o_idx]\r\n i = app.inputs[i_idx_list[0]]\r\n\r\n del self.view_i[o]\r\n\r\n self.view_o[i].remove(o)\r\n if not self.view_o[i]:\r\n del self.view_o[i]\r\n\r\n self.stale_droot = True","def clean_window(self) -> None:\r\n prune_before = time.time() - self.window_size\r\n while self.frames_rec:\r\n left = self.frames_rec.popleft()\r\n if left[1] >= prune_before:\r\n self.frames_rec.appendleft(left)\r\n break\r\n self.sum_frames_rec -= left[0]\r\n\r\n while self.frames_proc:\r\n left = self.frames_proc.popleft()\r\n if left[1] >= prune_before:\r\n self.frames_proc.appendleft(left)\r\n break\r\n self.sum_frames_proc -= left[0]","def new_loop_packet(self, event):\n # packet has traveled back in time\n if self.end_ts > event.packet['dateTime']:\n self.logger.error(\"Service ignoring packet has dateTime of %f which is prior to previous packet %f\"\n %(event.packet['dateTime'], self.end_ts))\n else:\n start_ts = self.end_ts\n self.end_ts = event.packet['dateTime']\n\n for topic in self.subscriber.subscribed_topics: # topics might not be cached.. therefore use subscribed?\n self.logger.debug(\"Service packet prior to update is: %s %s\"\n % (weeutil.weeutil.timestamp_to_string(event.packet['dateTime']),\n to_sorted_string(event.packet)))\n target_data = self.subscriber.get_accumulated_data(topic,\n start_ts, self.end_ts, event.packet['usUnits'])\n event.packet.update(target_data)\n self.logger.debug(\"Service packet after update is: %s %s\"\n % (weeutil.weeutil.timestamp_to_string(event.packet['dateTime']),\n to_sorted_string(event.packet)))","def clean():\n filter_phase_data()\n combine_phase_data()\n remove_duplicates_phase_data()","def pruning(self):\n data = self.data.copy()\n for d in self.data:\n # cascade purning method. Inspired from \"Efficient Computation of Group Skyline Queries on MapReduce (FCU)\"\n if d in data:\n pastart = [self.drange[1] if i+self.radius>self.drange[1] else i+self.radius for i in d.getLocationMax()]\n pamax = [self.drange[1] for j in range(self.dim)]\n # prune data points that are obviously dominated by current data point\n pruned = (self.index.intersection(tuple(pastart+pamax),objects=True))\n for p in pruned:\n if p.object in data:\n data.remove(p.object)\n self.pruned = data","def XPLMDataChanged_f(inRefcon):","def forwarder_state_changed(self, ev):\n\n\n dp = ev.dp\n ofp = dp.ofproto\n parser = dp.ofproto_parser\n\n\n if ev.enter is True:\n # in plain MAC setup, this should install only ICMP and ARP re-route rules, watchout for hardcoded DP id\n self.on_inner_dp_join(dp)\n\t ##For evry new forwarder we send out discovery ICMP packets out of every port except OFPP_CONTROLLER\n LOG.debug('TOPO MNGR: Forwarder: ' + str(dp.id) + ' saying hello to Unifycore Controller, Unifycore warmly welcomes you!')\n for port in dp.ports:\n if port != (ofp.OFPP_CONTROLLER):\n LOG.debug('TOPO MNGR: Controller is sending topology discovery ICMPs to forwarder: ' + str(dp.id) + ', port: ' + str(port))\n _icmp_send(dp,port,DISCOVERY_IP_SRC, DISCOVERY_IP_DST)\n\n ##For evry new forwarder we send out discovery ARP packets out of every port except OFPP_CONTROLLER to find APN\n for apn in APN_POOL:\n if apn.ip_addr != None:\n LOG.debug('TOPO MNGR: Forwarder: '+str(dp.id)+', port: '+ str(port) + ' is looking for APN: ' + str(apn.name) +' at IP: '+str(apn.ip_addr)+' with ARP search source IP: ' + str(apn.arp_origin_ip))\n _arp_send(dp=dp, port_out=port, arp_code=1, ip_target=apn.ip_addr, ip_sender=apn.arp_origin_ip)\n\n\n\n\n\n if ev.enter is False:\n\t ##TODO: We need to scan if any tunnels were affected, and if so, if any PDP COntexts were affected\n ##JUST REMOVING NODE FROM TOPOLOGY ISNT ENOUGH!\n LOG.debug('TOPO MNGR: Forwarder: ' + str(dp.id) + ' is leaving topology. It was a pleasure for us!')\n topo.del_forwarder(dp.id)","def event11022120():\n header(11022120)\n\n item_type, item_id = define_args('Bi')\n end_if_this_event_slot_on()\n if_new_game_count_greater_than_or_equal(1, 1)\n end_if_condition_false(1)\n item.remove_items_from_player(item_type, item_id, 0)","def cancelUnblockVis(self):\n if self.__nextSetZoneDoneEvent is not None:\n self.ignore(self.__nextSetZoneDoneEvent)\n self.__nextSetZoneDoneEvent = None","def handle_link_down (self, port):\n for dest in self.hosts.keys():\n currPort = self.hosts[dest][0]\n if currPort == port:\n del self.hosts[dest]\n \n deleteDests = set()\n for dest in self.routesToDest:\n currPort = self.routesToDest[dest][0]\n \n if currPort == port:\n\n if dest in self.hosts:\n self.routesToDest[dest] = self.hosts[dest]\n packet = basics.RoutePacket(dest, self.routesToDest[dest][1])\n self.send(packet, self.routesToDest[dest][0], True)\n else:\n self.sendPoison(dest)\n deleteDests.add(dest)\n\n\n for dest in deleteDests:\n del self.routesToDest[dest]\n\n del self.neighbours[port]","def on_epoch_end(self):\n if self.shuffle:\n self.indexes = np.random.permutation(self.indexes)","def on_epoch_end(self):\n if self.shuffle:\n self.indexes = np.random.permutation(self.indexes)","def _reset_stored(self):\n ## Main information\n self.idxs = None\n self.sp_relative_pos = None\n self._setted = False\n self.ks = None\n self.iss = [0]","def on_epoch_end(self):\n if self.shuffle:\n self.dataset_df = skl_shuffle(self.dataset_df)","def removeOldCars(self):\n self.cars = [car for car in self.cars if (self.currentFrame - car.updatedInFrame) < DROP_AFTER_N_FRAMES]\n for i, car in enumerate(self.cars): # update id's\n car.id = i + 1","def unschedule(self, func):\n for sched in (\n self.schedules, self.update_schedules, self.frame_schedules,\n self.interval_schedules,\n ):\n for item in list(sched):\n if item.func == func:\n sched.remove(item)","def reset(self):\n self.placeables = []\n self.previous_placeable = None\n self.current_volume = 0\n self.reset_tip_tracking()","def decimate(self, valid):\r\n self.points = self.points[valid]\r\n for obj in self.data: self.data[obj] = self.data[obj][valid]","def checkpoint_unset():\n unwind(checkpoints.pop())","def remove_to_destroy(total_buffer,to_destroy):\n totbuf=np.copy(total_buffer)\n for val,begInd,endInd in to_destroy:\n for j in range(endInd-begInd):\n index_beg = begInd+j\n totbuf[ total_buffer[:,:,index_beg]==val,index_beg]=0\n return totbuf","def rePop(self):\n nScan = 0\n pScan = self.num-1\n while not self.isFull():\n while self.genepool[0][pScan] == None:\n pScan = (pScan-1)%self.num\n while self.genepool[0][nScan] != None:\n nScan = (nScan+1)%self.num\n self.genepool[0][nScan] = self.genepool[0][pScan].mutate()\n self.genepool[1][nScan] = self.genepool[1][pScan].mutate()\n nScan = (nScan+1)%self.num\n pScan = (pScan-1)%self.num","def rePop(self):\n nScan = 0\n pScan = self.num-1\n while not self.isFull():\n while self.genepool[0][pScan] == None:\n pScan = (pScan-1)%self.num\n while self.genepool[0][nScan] != None:\n nScan = (nScan+1)%self.num\n self.genepool[0][nScan] = self.genepool[0][pScan].mutate()\n self.genepool[1][nScan] = self.genepool[1][pScan].mutate()\n nScan = (nScan+1)%self.num\n pScan = (pScan-1)%self.num"],"string":"[\n \"def OnRearrangeEnd(self, evt):\\n\\t\\tself._potentialRearrange = False\\n\\t\\tself._didCopy = False\\n\\t\\tevt.Skip()\",\n \"def bindEvents(fusionEvents,divisionEvents, buff):\\n #1/Finding correspondances\\n fusion_indices = []\\n fusion_labels = []\\n fusion_labels_2 = [] # In label 2 says with which cell the disappearded one has\\n for events,label in fusionEvents:\\n index,osef,labels = events\\n fusion_indices.append(index)\\n fusion_labels.append(labels[0])\\n fusion_labels_2.append(label)\\n \\n division_indices = []\\n division_labels = []\\n division_labels_2 = [] # Tells in which cell it is created\\n for events,label in divisionEvents:\\n index,osef,labels = events\\n division_indices.append(index)\\n division_labels.append(labels[0])\\n division_labels_2.append(label)\\n \\n associated_division_list = []\\n associated_indexes = []\\n for i in fusion_indices:\\n ind = next((x for x in division_indices if x>i),-1)\\n if ind>0:\\n associated_division_list.append((i,ind))\\n corr_ind_fusion = fusion_indices.index(i)\\n corr_ind_division = division_indices.index(ind)\\n associated_indexes.append((corr_ind_fusion,corr_ind_division))\\n\\n \\n #2/removing corresponding elements\\n for j in range(len(associated_division_list)):\\n index_fus, index_div = associated_indexes[j]\\n if division_labels_2[index_div]==fusion_labels_2[index_fus]:\\n #If they are not equal, means that the process of division/fusion \\n #has not happened on the same blob and hence is not relevant\\n big_label = division_labels_2[index_div]\\n small_label = fusion_labels[index_fus]\\n new_label = division_labels[index_div] #Replace after division this label by small label\\n first_index = fusion_indices[index_fus]\\n second_index = division_indices[index_div]\\n \\n for k in range(second_index-first_index):\\n splitCell(buff,first_index+k,big_label,small_label)\\n \\n #Attribution of the new created cells to each one of the previous cells:\\n #For this, we take the closest centroid\\n #centroid of the big label\\n last_image = buff[:,:,second_index]\\n xs,ys = centroids2(last_image,[big_label,new_label])\\n xs0,ys0 = centroids2(buff[:,:,second_index-1],[big_label,small_label])\\n dist_regular = (xs0[0]-xs[0])**2 + (ys0[0]-ys[0])**2 + (xs0[1]-xs[1])**2 + (ys0[1]-ys[1])**2\\n dist_inverted = (xs0[0]-xs[1])**2 + (ys0[0]-ys[1])**2 + (xs0[1]-xs[0])**2 + (ys0[1]-ys[0])**2\\n \\n if dist_regular>dist_inverted:\\n print \\\"ca marche pas gael euh quoi?\\\"\\n tmp_stack = buff[:,:,second_index:]\\n tmp_stack[buff[:,:,second_index:]==big_label]=small_label\\n tmp_stack[buff[:,:,second_index:]==new_label]=big_label\\n buff[:,:,second_index:] = tmp_stack\\n division_labels = [x if (x!=new_label and x!=big_label) else big_label if x==new_label else small_label for x in division_labels]\\n fusion_labels = [x if x!=new_label and x!=big_label else big_label if x==new_label else small_label for x in fusion_labels]\\n division_labels_2= [x if x!=new_label and x!=big_label else big_label if x==new_label else small_label for x in division_labels_2]\\n fusion_labels_2= [x if x!=new_label and x!=big_label else big_label if x==new_label else small_label for x in fusion_labels_2]\\n else:\\n print \\\"ca marche bien gael\\\"\\n \\\"\\\"\\\"Reassigning new labels\\\"\\\"\\\"\\n tmp_stack = buff[:,:,second_index:]\\n tmp_stack[tmp_stack==new_label] = small_label\\n buff[:,:,second_index:] = tmp_stack\\n division_labels = [x if x!=new_label else small_label for x in division_labels]\\n fusion_labels = [x if x!=new_label else small_label for x in fusion_labels]\\n division_labels_2 = [x if x!=new_label else small_label for x in division_labels_2]\\n fusion_labels_2 = [x if x!=new_label else small_label for x in fusion_labels_2]\",\n \"def onafterresetting(self, event):\\n print('onafterresetting; event: %s, %s->%s' % (event.event, event.src, event.dst))\",\n \"def delace(self):\\n if not self.isdelaced:\\n newframes = []\\n self.frame_dt /= 2\\n for i, frame in enumerate(self.frames):\\n newframes.append(\\n Frame(\\n frame.data[1::2, :],\\n self.starttime\\n + datetime.timedelta(seconds=self.frame_dt * (2 * i)),\\n )\\n )\\n newframes.append(\\n Frame(\\n frame.data[0::2, :],\\n self.starttime\\n + datetime.timedelta(seconds=self.frame_dt * (2 * i + 1)),\\n )\\n )\\n self.isdelaced = True\\n self.frames = newframes\\n self.length = len(newframes)\\n else:\\n print(\\\"Video already deinterlaced.\\\")\",\n \"def _clear(self):\\n self.events = []\\n self.last_on = None\\n self.last_off = None\",\n \"def on_unassign(self):\",\n \"def reset(self):\\n for k,v in self.events.items():\\n self.events[k] = None\",\n \"def switch_pattern(self):\\n event = self.event_deque.popleft()\\n event.reset()\\n self.event_deque.append(event)\\n self.last_switch = pygame.time.get_ticks()\",\n \"def _unmove(self):\\n (start, end) = self.history.pop()\\n self._board[start] = self._board[end]\\n self._board[end] = 0\\n self.winner = None\\n self.player_turn = CheckersGame.opposite[self.player_turn]\",\n \"def cleanup_event_list(self):\\n self._event_list, self._event_index_list = \\\\\\n zip(*SimpleDeduplicator.remove_duplicates_from_event_list(\\n zip(self._event_list, self._event_index_list)))\",\n \"def recall(self):\\n for t in self.placed_tiles:\\n row = self.placed_tiles[t][1][0]\\n col = self.placed_tiles[t][1][1]\\n # remove tiles from board\\n self.board.board[row][col].letter = None\\n # put tiles back on rack\\n self.rack[t] = self.placed_tiles[t][0]\",\n \"def _revert(self):\\n if self.kwargs.get(\\\"collect\\\"):\\n remove_exported_collect_data(self.kwargs[\\\"collect\\\"])\",\n \"def delete_lag_ports(self, ports, lag):\\n pass\",\n \"def disconnect_poselocs():\\r\\n #TODO: Eventually create a non-linear way to re-add the nodes for a pose if you want to edit it later.\\r\\n if DRYRUN:\\r\\n print('poselocs deleted - DRY RUN ONLY')\\r\\n return False\\r\\n\\r\\n for oPos in pm.ls('*_POSE', type='transform'):\\r\\n pm.delete(oPos.getChildren(ad=True, type='transform'))\",\n \"def clear_events():\\n while len(events) > 0:\\n canvas.delete(events.pop())\",\n \"def clean(self):\\n self.change_events = []\",\n \"def unisolvent_nodes(self):\\r\\n pass\",\n \"def undo(self):\\n if self._snapshot_index >= 0:\\n snapshot = self._snapshots[self._snapshot_index]\\n for chunk_location in snapshot:\\n dimension, cx, cz = chunk_location\\n chunk = self._unserialise_chunk(dimension, cx, cz, -1)\\n self._chunk_cache[chunk_location] = chunk\\n self._snapshot_index -= 1\",\n \"def _revert(self):\\n self.release_from_output(\\\"data\\\")\\n # delete ONA submissions on ONA\",\n \"def finish_command(self):\\n\\n # remap source\\n orig_nodes = self.data.keys()\\n for orig_node in orig_nodes:\\n new_node = self.mapping[orig_node] or orig_node\\n\\n if new_node != orig_node:\\n self.data[new_node] = self.data[orig_node]\\n del self.data[orig_node]\\n\\n set_data(self.data,\\n create_attrs=self.create_attrs,\\n set_values=self.set_values,\\n set_values_on_all=self.set_values_on_all)\",\n \"def _revert(self):\\n self.kwargs[\\\"collect\\\"].change_status(self.kwargs[\\\"collect\\\"].ENDED)\",\n \"def wipe(self):\\n if len(self.node) > 1:\\n # self.obj.Shape.nullify() # For some reason this fails\\n self.obj.ViewObject.Visibility = False\\n self.node = [self.node[-1]]\\n if self.planetrack:\\n self.planetrack.set(self.node[0])\\n _msg(translate(\\\"draft\\\", \\\"Pick next point\\\"))\",\n \"def wipe(self):\\n if len(self.node) > 1:\\n # self.obj.Shape.nullify() # For some reason this fails\\n self.obj.ViewObject.Visibility = False\\n self.node = [self.node[-1]]\\n if self.planetrack:\\n self.planetrack.set(self.node[0])\\n _msg(translate(\\\"draft\\\", \\\"Pick next point\\\"))\",\n \"def revive(self) -> None:\\n\\n cached_events = cherrypy.engine.publish(\\n \\\"cache:match\\\",\\n \\\"scheduler\\\"\\n ).pop()\\n\\n if not cached_events:\\n return\\n\\n counter = 0\\n\\n for cached_event in cached_events:\\n self.add(\\n cached_event[\\\"time\\\"] - time.time(),\\n *cached_event[\\\"argument\\\"],\\n **cached_event[\\\"kwargs\\\"]\\n )\\n counter += 1\\n\\n if counter > 0:\\n unit = \\\"event\\\" if counter == 1 else \\\"events\\\"\\n\\n cherrypy.engine.publish(\\n \\\"applog:add\\\",\\n \\\"scheduler\\\",\\n f\\\"{counter} {unit} revived\\\"\\n )\",\n \"def popUnsetData(self,N):\\n self.r_Vm = self.r_Vm[:N]\\n self.r_Va = self.r_Va[:N]\",\n \"def unscheduleFirst(self, runnable):\\n for evt in self.store.query(TimedEvent, TimedEvent.runnable == runnable, sort=TimedEvent.time.ascending):\\n evt.deleteFromStore()\\n break\",\n \"def recycle_fragments(self, fragments: list, source: tuple, destination: tuple):\\n pass\",\n \"def clear_for_new_board(self):\\r\\n self.game_board = []\\r\\n self.good_contours = []\\r\\n self.game_board_contours = []\",\n \"def event_remove(event_name:str):#maybe make a add events function\\n global removed_manually\\n global notification_index #always incremented so notifications can be removed\\n for y in range(len(Events_list)): # sorted in ascending order.\\n if removed_manually is False:#if the alrm has expired by its own ,check if it has extras selected and if so; display them:\\n if Events_list[y][5] == \\\"true\\\": #news\\n temp_notifi_list = news().copy()\\n for w in temp_notifi_list:\\n a = w[0]#news title\\n b = w[1]#link\\n notification_list.append(['\\\"{}\\\"'.format(a), \\\"not_alarm\\\",[str(notification_index),\\\"newslink\\\",'{}'.format(b)]])\\n notification_index+=1\\n temp_notifi_list = covid_data().copy()\\n for w in temp_notifi_list:\\n notification_list.append(['\\\"{}\\\"'.format(w), \\\"not_alarm\\\",[str(notification_index)]])\\n notification_index+=1\\n if Events_list[y][4] == \\\"true\\\":#weather\\n notification_list.append(['\\\"{}\\\"'.format(\\\"Todays Weather: \\\" + weather()), \\\"not_alarm\\\",[str(notification_index)]])\\n notification_index+=1\\n if Events_list[y][0] == event_name:\\n event_log(\\\"rescheduling alarm for next day....\\\",\\\"\\\")\\n if Events_list[y][3] == \\\"true\\\" and removed_manually is False:#if this is true the the event is set to be repeated\\n new_date = time.strftime('%Y-%m-%d %H:%M', time.localtime(convert_to_epoch(Events_list[y][1]) + 86400))\\n set_alarm(new_date, event_name, Events_list[y][2], Events_list[y][3],Events_list[y][4],Events_list[y][5])\\n notification_list.append(['\\\"{}\\\"'.format(event_name) + \\\"Has been rescheduled for next day\\\", \\\"alarm\\\", Events_list[y]])\\n speak_output(event_name + \\\"has been repeated for next day\\\")\\n else:#event is going to be removed\\n event_log(\\\"removing alarm....\\\",\\\"\\\")\\n removed_manually = False#changes the boolean so the function can go back to deafult state as this is global varibale\\n notification_list.append(['\\\"{}\\\"'.format(event_name) + \\\" is expired/deleted\\\", \\\"alarm\\\", Events_list[y]])\\n speak_output(event_name + \\\"has expired or been removed\\\")\\n Events_list.pop(y)#removes from list\\n temp_notifi_list = []\\n write()\\n break\",\n \"def reset_wm(self):\\n\\n self.plan = []\\n self.hist = []\",\n \"def test_remove_portless_vfc_maps2(self):\\n vwrap = self.vio_feed[0]\\n # Save the \\\"before\\\" size of the VFC mapping list\\n vfc_len = len(vwrap.vfc_mappings)\\n # Count our target LPAR's mappings before\\n lpar24maps = self.count_maps_for_lpar(vwrap.vfc_mappings, 24)\\n ts.ScrubPortlessVFCMaps(self.adpt, lpar_id=24).execute()\\n # Overall one map was scrubbed\\n self.assertEqual(vfc_len - 1, len(vwrap.vfc_mappings))\\n # ...and it was the right one\\n self.assertEqual(lpar24maps - 1,\\n self.count_maps_for_lpar(vwrap.vfc_mappings, 24))\\n self.assertEqual(1, self.txfx.patchers['update'].mock.call_count)\",\n \"def undo(self, event=None):\\n if not self.segs == []:\\n self.requestSegByDct((self.segs[-1].getDct() + 2) % 4)\",\n \"def update_schedule(module, array):\\n changed = True\\n if not module.check_mode:\\n changed = False\\n try:\\n schedule = array.get_pgroup(module.params['name'], schedule=True)\\n retention = array.get_pgroup(module.params['name'], retention=True)\\n if not schedule['replicate_blackout']:\\n schedule['replicate_blackout'] = [{'start': 0, 'end': 0}]\\n except Exception:\\n module.fail_json(msg=\\\"Failed to get current schedule for pgroup {0}.\\\".format(module.params['name']))\\n current_repl = {'replicate_frequency': schedule['replicate_frequency'],\\n 'replicate_enabled': schedule['replicate_enabled'],\\n 'target_days': retention['target_days'],\\n 'replicate_at': schedule['replicate_at'],\\n 'target_per_day': retention['target_per_day'],\\n 'target_all_for': retention['target_all_for'],\\n 'blackout_start': schedule['replicate_blackout'][0]['start'],\\n 'blackout_end': schedule['replicate_blackout'][0]['end']}\\n current_snap = {'days': retention['days'],\\n 'snap_frequency': schedule['snap_frequency'],\\n 'snap_enabled': schedule['snap_enabled'],\\n 'snap_at': schedule['snap_at'],\\n 'per_day': retention['per_day'],\\n 'all_for': retention['all_for']}\\n if module.params['schedule'] == 'snapshot':\\n if not module.params['snap_frequency']:\\n snap_frequency = current_snap['snap_frequency']\\n else:\\n if not 300 <= module.params['snap_frequency'] <= 34560000:\\n module.fail_json(msg=\\\"Snap Frequency support is out of range (300 to 34560000)\\\")\\n else:\\n snap_frequency = module.params['snap_frequency']\\n\\n if not module.params['snap_at']:\\n snap_at = current_snap['snap_at']\\n else:\\n snap_at = module.params['snap_at']\\n\\n if not module.params['days']:\\n days = current_snap['days']\\n else:\\n if module.params['days'] > 4000:\\n module.fail_json(msg=\\\"Maximum value for days is 4000\\\")\\n else:\\n days = module.params['days']\\n\\n if not module.params['per_day']:\\n per_day = current_snap['per_day']\\n else:\\n if module.params['per_day'] > 1440:\\n module.fail_json(msg=\\\"Maximum value for per_day is 1440\\\")\\n else:\\n per_day = module.params['per_day']\\n\\n if not module.params['all_for']:\\n all_for = current_snap['all_for']\\n else:\\n if module.params['all_for'] > 34560000:\\n module.fail_json(msg=\\\"Maximum all_for value is 34560000\\\")\\n else:\\n all_for = module.params['all_for']\\n new_snap = {'days': days,\\n 'snap_frequency': snap_frequency,\\n 'snap_enabled': module.params['enabled'],\\n 'snap_at': snap_at,\\n 'per_day': per_day,\\n 'all_for': all_for}\\n if current_snap != new_snap:\\n try:\\n array.set_pgroup(module.params['name'],\\n snap_enabled=module.params['enabled'])\\n array.set_pgroup(module.params['name'],\\n snap_frequency=snap_frequency,\\n snap_at=snap_at)\\n array.set_pgroup(module.params['name'],\\n days=days,\\n per_day=per_day,\\n all_for=all_for)\\n changed = True\\n except Exception:\\n module.fail_json(msg='Failed to change snapshot schedule for pgroup {0}.'.format(module.params['name']))\\n else:\\n if not module.params['replicate_frequency']:\\n replicate_frequency = current_repl['replicate_frequency']\\n else:\\n model = array.get(controllers=True)[0]['model']\\n if '405' in model or '10' in model or 'CBS' in model:\\n if not 900 <= module.params['replicate_frequency'] <= 34560000:\\n module.fail_json(msg=\\\"Replication Frequency support is out of range (900 to 34560000)\\\")\\n else:\\n replicate_frequency = module.params['replicate_frequency']\\n else:\\n if not 300 <= module.params['replicate_frequency'] <= 34560000:\\n module.fail_json(msg=\\\"Replication Frequency support is out of range (300 to 34560000)\\\")\\n else:\\n replicate_frequency = module.params['replicate_frequency']\\n\\n if not module.params['replicate_at']:\\n replicate_at = current_repl['replicate_at']\\n else:\\n replicate_at = module.params['replicate_at']\\n\\n if not module.params['target_days']:\\n target_days = current_repl['target_days']\\n else:\\n if module.params['target_days'] > 4000:\\n module.fail_json(msg=\\\"Maximum value for target_days is 4000\\\")\\n else:\\n target_days = module.params['target_days']\\n\\n if not module.params['target_per_day']:\\n target_per_day = current_repl['target_per_day']\\n else:\\n if module.params['target_per_day'] > 1440:\\n module.fail_json(msg=\\\"Maximum value for target_per_day is 1440\\\")\\n else:\\n target_per_day = module.params['target_per_day']\\n\\n if not module.params['target_all_for']:\\n target_all_for = current_repl['target_all_for']\\n else:\\n if module.params['target_all_for'] > 34560000:\\n module.fail_json(msg=\\\"Maximum target_all_for value is 34560000\\\")\\n else:\\n target_all_for = module.params['target_all_for']\\n if not module.params['blackout_end']:\\n blackout_end = current_repl['blackout_start']\\n else:\\n blackout_end = _convert_to_minutes(module.params['blackout_end'])\\n if not module.params['blackout_start']:\\n blackout_start = current_repl['blackout_start']\\n else:\\n blackout_start = _convert_to_minutes(module.params['blackout_start'])\\n\\n new_repl = {'replicate_frequency': replicate_frequency,\\n 'replicate_enabled': module.params['enabled'],\\n 'target_days': target_days,\\n 'replicate_at': replicate_at,\\n 'target_per_day': target_per_day,\\n 'target_all_for': target_all_for,\\n 'blackout_start': blackout_start,\\n 'blackout_end': blackout_end}\\n if current_repl != new_repl:\\n blackout = {'start': blackout_start, 'end': blackout_end}\\n try:\\n array.set_pgroup(module.params['name'],\\n replicate_enabled=module.params['enabled'])\\n array.set_pgroup(module.params['name'],\\n replicate_frequency=replicate_frequency,\\n replicate_at=replicate_at)\\n if blackout_start == 0:\\n array.set_pgroup(module.params['name'],\\n replicate_blackout=None)\\n else:\\n array.set_pgroup(module.params['name'],\\n replicate_blackout=blackout)\\n array.set_pgroup(module.params['name'],\\n target_days=target_days,\\n target_per_day=target_per_day,\\n target_all_for=target_all_for)\\n changed = True\\n except Exception:\\n module.fail_json(msg='Failed to change replication schedule for pgroup {0}.'.format(module.params['name']))\\n\\n module.exit_json(changed=changed)\",\n \"def restart(self):\\n self.dominated_set = []\\n self.np = 0\\n self.rank = None\\n self.crowding_distance = 0\",\n \"def __reset(self):\\n self.game_moves_history = []\\n self.player_id = None\",\n \"def fix_unpaired_events(self):\\n\\n if self.observationId:\\n\\n r, msg = project_functions.check_state_events_obs(self.observationId, self.pj[ETHOGRAM],\\n self.pj[OBSERVATIONS][self.observationId])\\n if \\\"not PAIRED\\\" not in msg:\\n QMessageBox.information(self, programName, \\\"All state events are already paired\\\",\\n QMessageBox.Ok | QMessageBox.Default, QMessageBox.NoButton)\\n return\\n\\n '''\\n if self.playerType == VIEWER:\\n # max time\\n time_ = max(x[0] for x in self.pj[OBSERVATIONS][self.observationId][EVENTS])\\n else:\\n time_ = self.getLaps()\\n '''\\n\\n w = dialog.JumpTo(self.timeFormat)\\n w.setWindowTitle(\\\"Fix UNPAIRED state events\\\")\\n w.label.setText(\\\"Fix UNPAIRED events at time\\\")\\n\\n if w.exec_():\\n if self.timeFormat == HHMMSS:\\n fix_at_time = utilities.time2seconds(w.te.time().toString(HHMMSSZZZ))\\n elif self.timeFormat == S:\\n fix_at_time = Decimal(str(w.te.value()))\\n print(\\\"fix_at_time\\\", fix_at_time)\\n\\n events_to_add = project_functions.fix_unpaired_state_events(self.observationId,\\n self.pj[ETHOGRAM],\\n self.pj[OBSERVATIONS][self.observationId],\\n fix_at_time - Decimal(\\\"0.001\\\")\\n )\\n if events_to_add:\\n self.pj[OBSERVATIONS][self.observationId][EVENTS].extend(events_to_add)\\n self.projectChanged = True\\n self.pj[OBSERVATIONS][self.observationId][EVENTS].sort()\\n self.loadEventsInTW(self.observationId)\\n item = self.twEvents.item(\\n [i for i, t in enumerate(self.pj[OBSERVATIONS][self.observationId][EVENTS]) if\\n t[0] == fix_at_time][0], 0)\\n self.twEvents.scrollToItem(item)\\n\\n # selected observations\\n else:\\n result, selected_observations = self.selectObservations(MULTIPLE)\\n if not selected_observations:\\n return\\n\\n # check if state events are paired\\n out = \\\"\\\"\\n not_paired_obs_list = []\\n for obs_id in selected_observations:\\n r, msg = project_functions.check_state_events_obs(obs_id, self.pj[ETHOGRAM],\\n self.pj[OBSERVATIONS][obs_id])\\n print(\\\"msg\\\", msg)\\n if \\\"NOT PAIRED\\\" in msg.upper():\\n fix_at_time = max(x[0] for x in self.pj[OBSERVATIONS][obs_id][EVENTS])\\n events_to_add = project_functions.fix_unpaired_state_events(obs_id,\\n self.pj[ETHOGRAM],\\n self.pj[OBSERVATIONS][obs_id],\\n fix_at_time\\n )\\n if events_to_add:\\n events_backup = self.pj[OBSERVATIONS][obs_id][EVENTS][:]\\n self.pj[OBSERVATIONS][obs_id][EVENTS].extend(events_to_add)\\n\\n # check if modified obs if fixed\\n r, msg = project_functions.check_state_events_obs(obs_id, self.pj[ETHOGRAM],\\n self.pj[OBSERVATIONS][obs_id])\\n if \\\"NOT PAIRED\\\" in msg.upper():\\n out += \\\"The observation <b>{}</b> can not be automatically fixed.<br><br>\\\".format(obs_id)\\n self.pj[OBSERVATIONS][obs_id][EVENTS] = events_backup\\n else:\\n out += \\\"<b>{}</b><br>\\\".format(obs_id)\\n self.projectChanged = True\\n if out:\\n out = \\\"The following observations were modified to fix the unpaired state events:<br><br>\\\" + out\\n self.results = dialog.Results_dialog()\\n self.results.setWindowTitle(programName + \\\" - Fixed observations\\\")\\n self.results.ptText.setReadOnly(True)\\n self.results.ptText.appendHtml(out)\\n self.results.pbSave.setVisible(False)\\n self.results.pbCancel.setVisible(True)\\n self.results.exec_()\\n else:\\n QMessageBox.information(self, programName, \\\"All state events are already paired\\\",\\n QMessageBox.Ok | QMessageBox.Default, QMessageBox.NoButton)\",\n \"def remove(name, send_events=True, moving=False):\",\n \"def revolver(self):\\r\\n\\t\\tself.__revuelto=True\",\n \"def reset(self):\\n inv_perm = np.argsort(self._current_order)\\n self._current_order = self._current_order[inv_perm]\\n self.inputs = self.inputs[inv_perm]\\n self.targets = self.targets[inv_perm]\\n self.new_epoch()\",\n \"def switch_features_handler(self, ev):\\n datapath = ev.msg.datapath\\n [self.remove_flows(datapath, n) for n in [0, 1]]\",\n \"def BorrarListas(self,evt):\\n self.l_bal = []\\n self.l_muestras = []\\n self.l_vol = []\\n self.l_den = []\\n self.l_calidad = []\\n self.idact = 0\",\n \"def island_migration(self):\\n for y in self.island_map:\\n for cell in y:\\n cell.migration()\\n\\n for y in self.island_map:\\n for cell in y:\\n for animal in cell.population:\\n animal.has_moved = False\",\n \"def migrateDown(self):\\n subStore = self.store.parent.getItemByID(self.store.idInParent)\\n ssph = self.store.parent.findUnique(\\n _SubSchedulerParentHook,\\n _SubSchedulerParentHook.subStore == subStore,\\n default=None)\\n if ssph is not None:\\n te = self.store.parent.findUnique(TimedEvent,\\n TimedEvent.runnable == ssph,\\n default=None)\\n if te is not None:\\n te.deleteFromStore()\\n ssph.deleteFromStore()\",\n \"def reset(self):\\n inv_perm = np.argsort(self._current_order)\\n self._current_order = self._current_order[inv_perm]\\n self.inputs = self.inputs[inv_perm]\\n self.targets = self.targets[inv_perm]\\n self.target_ids = self.target_ids[inv_perm]\\n self.new_epoch()\",\n \"def _revert(self):\\n if self.kwargs.get(\\\"collect\\\"):\\n remove_collect_medias(self.kwargs[\\\"collect\\\"])\",\n \"def redo(self):\\n if self._snapshot_index <= len(self._snapshots) - 2:\\n snapshot = self._snapshots[self._snapshot_index + 1]\\n for chunk_location in snapshot:\\n dimension, cx, cz = chunk_location\\n chunk = self._unserialise_chunk(dimension, cx, cz, 1)\\n self._chunk_cache[chunk_location] = chunk\\n self._snapshot_index += 1\",\n \"def reformat_events(self, data, features):\\n # Update alias\\n if isinstance(features, list):\\n [x.update(dict(alias=self.alias[(x[features[0]],\\n x[features[1]])])) for x in data]\\n else:\\n [x.update(dict(alias=self.alias[x[features]])) for x in data]\\n temp_data = list()\\n # define ordering keys and columns\\n if self.one_timestamp:\\n columns = ['alias', 'duration', 'dur_act_norm']\\n sort_key = 'end_timestamp'\\n else:\\n sort_key = 'start_timestamp'\\n columns = ['alias', 'processing_time',\\n 'proc_act_norm', 'waiting_time', 'wait_act_norm']\\n data = sorted(data, key=lambda x: (x['caseid'], x[sort_key]))\\n for key, group in itertools.groupby(data, key=lambda x: x['caseid']):\\n trace = list(group)\\n temp_dict = dict()\\n for col in columns:\\n serie = [y[col] for y in trace]\\n if col == 'alias':\\n temp_dict = {**{'profile': serie}, **temp_dict}\\n else:\\n serie = [y[col] for y in trace]\\n temp_dict = {**{col: serie}, **temp_dict}\\n temp_dict = {**{'caseid': key, 'start_time': trace[0][sort_key],\\n 'end_time': trace[-1][sort_key]},\\n **temp_dict}\\n temp_data.append(temp_dict)\\n return sorted(temp_data, key=itemgetter('start_time'))\",\n \"def resend_buffer_packets():\\n global BUFFER\\n for seq in BUFFER.keys():\\n packet_info = BUFFER[seq]\\n msg_obj = packet_info.msg\\n new_start = time.time()\\n handle_packet_send(msg_obj)\\n new_packet_info = PacketInfo(msg_obj, new_start)\\n # Update the packet in the buffer with the new time sent at\\n BUFFER[seq] = new_packet_info\",\n \"def update_events_start_stop(self):\\n\\n # stateEventsList = [self.pj[ETHOGRAM][x][BEHAVIOR_CODE] for x in self.pj[ETHOGRAM] if\\n # STATE in self.pj[ETHOGRAM][x][TYPE].upper()]\\n\\n for row in range(0, self.twEvents.rowCount()):\\n\\n t = self.twEvents.item(row, tw_obs_fields[\\\"Tempo\\\"]).text()\\n\\n if \\\":\\\" in t:\\n time = time2seconds(t)\\n else:\\n time = Decimal(t)\\n\\n subject = self.twEvents.item(row, tw_obs_fields[\\\"Sujeito\\\"]).text()\\n key = self.twEvents.item(row, tw_obs_fields[\\\"Chave\\\"]).text()\\n modifier = self.twEvents.item(row, tw_obs_fields[\\\"Modificador\\\"]).text()\\n\\n # check if code is state\\n nbEvents = len(\\n [event[EVENT_BEHAVIOR_FIELD_IDX] for event in self.pj[OBSERVATIONS][self.observationId][EVENTS]\\n if event[EVENT_BEHAVIOR_FIELD_IDX] == key\\n and event[EVENT_TIME_FIELD_IDX] < time\\n and event[EVENT_SUBJECT_FIELD_IDX] == subject\\n and event[EVENT_MODIFIER_FIELD_IDX] == modifier])\\n\\n # if nbEvents and (nbEvents % 2): # test >0 and odd\\n # self.twEvents.item(row, tw_obs_fields[TYPE]).setText(STOP)\\n # else:\\n # self.twEvents.item(row, tw_obs_fields[TYPE]).setText(START)\",\n \"def reset(self):\\n\\t\\tself.offsets = self.start_off.copy()\",\n \"def wipe(self, segments):\\n self.firstCoords = None\\n self.moveLead(MIDDLE, MIDDLE)\\n for seg in self.segs:\\n self.can.delete(seg.getGraphicObject())\\n seg.rmGraphicObject()\\n self.segs = segments\\n self.redrawSegs()\",\n \"def stop_procrastinating(self):\\n for layer, l in sorted(self.postponed.items()):\\n for fun, args, rgb in l:\\n self.set_source_rgb(*rgb)\\n fun(*args, procrastinate=0)\\n self.postponed = {}\",\n \"def _handle_window_update(self, event: events.WindowUpdated) -> None:\\n stream_id = event.stream_id\\n\\n if stream_id and stream_id in self._flow_control_events:\\n g_event = self._flow_control_events.pop(stream_id)\\n g_event.set()\\n elif not stream_id:\\n # Need to keep a real list here to use only the events present at this time.\\n blocked_streams = list(self._flow_control_events.keys())\\n for stream_id in blocked_streams:\\n g_event = self._flow_control_events.pop(stream_id)\\n g_event.set()\",\n \"def remove_events(self):\\n tofiltercalibfnames1, tofiltercalibfnames2 = split_into_telescopes(self.tofiltercalibfnames)\\n\\n nameiter = tqdm(self.superstarmcolfnames)\\n for ssmcolfname in nameiter:\\n nameiter.set_description(f\\\"Processing {path.basename(ssmcolfname)}\\\")\\n currentrun = get_run(ssmcolfname)\\n ssmcoldf = pd.read_csv(ssmcolfname, index_col=False)\\n # newfname1 = self.single_remove_events(ssmcoldf, ssmcolfname, tofiltercalibfnames1, self.m1sscols)\\n # newfname2 = self.single_remove_events(ssmcoldf, ssmcolfname, tofiltercalibfnames2, self.m2sscols)\\n # if self.assert_filtermask_and_dfs(filtermask1, filtermask2, tofiltercalibdf1, tofiltercalibdf2, ssmcoldf) is False:\\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames1, currentrun), self.bugdir)\\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames2, currentrun), self.bugdir)\\n # os.remove(newfname1)\\n # os.remove(newfname2)\\n # continue\\n tofiltercalibdf1, oldname1 = self._merge_subruns(tofiltercalibfnames1,\\n currentrun, getoldname=True)\\n tofiltercalibdf2, oldname2 = self._merge_subruns(tofiltercalibfnames2,\\n currentrun, getoldname=True)\\n if len(tofiltercalibdf1) == 0:\\n logger.warning(f\\\"calibfiles already processed, skipping {path.basename(ssmcolfname)} current run: {currentrun} \\\\n\\\")\\n continue\\n\\n filtermask1 = self.get_filtermask(tofiltercalibdf1.iloc[:, self.mcolidx], ssmcoldf[self.m1sscols])\\n filtermask2 = self.get_filtermask(tofiltercalibdf2.iloc[:, self.mcolidx], ssmcoldf[self.m2sscols])\\n if self.invert is False:\\n filtermask1, tofiltercalibdf1 = self.fix_idiosyncracies(filtermask1, tofiltercalibdf1, ssmcoldf[self.m1sscols])\\n filtermask2, tofiltercalibdf2 = self.fix_idiosyncracies(filtermask2, tofiltercalibdf2, ssmcoldf[self.m2sscols])\\n\\n if self.assert_filtermask_and_dfs(filtermask1, filtermask2, tofiltercalibdf1, tofiltercalibdf2, ssmcoldf) is False:\\n self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames1, currentrun), self.bugdir)\\n self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames2, currentrun), self.bugdir)\\n continue\\n\\n newfname1 = self._get_newfilename(oldname=oldname1)\\n newfname2 = self._get_newfilename(oldname=oldname2)\\n\\n nameiter.set_description(f\\\"Saving {path.basename(newfname1)}\\\")\\n tofiltercalibdf1.iloc[filtermask1].to_csv(newfname1, header=False, index=False)\\n nameiter.set_description(f\\\"Saving {path.basename(newfname2)}\\\")\\n tofiltercalibdf2.iloc[filtermask2].to_csv(newfname2, header=False, index=False)\\n self.outfilenames.extend([newfname1, newfname2])\\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames1, currentrun))\\n # self._move_processed_files(self._handle_fnames_for_merging(tofiltercalibfnames2, currentrun))\",\n \"def events_reset(self):\\n self._expected_events = []\\n jsonfiles = [p for p in [os.path.join(self._event_dir, f)\\n for f in os.listdir(self._event_dir)]\\n if os.path.isfile(p)]\\n for jsonfile in jsonfiles:\\n os.unlink(jsonfile)\",\n \"def removeEvent(self):\\n raise NotImplementedError\",\n \"def clear_points(self):\\n print \\\"clearing each frame of selected points\\\"\\n self.point_3d = None\\n self.allUVs = []\\n for iFrame in self.frames:\\n iFrame.lastClick = None; \\n self.displayImage(iFrame)\",\n \"def refreshView(self):\\n chldn = self.tDisp.get_children()\\n for chld in chldn:\\n self.tDisp.delete(chld)\\n if len(self.conflict.infeasibles) > 0:\\n self.conflict.recalculateFeasibleStates()\\n for infeas in self.conflict.infeasibles:\\n key = infeas.name\\n self.tDisp.insert('', 'end', key, text=key)\\n self.tDisp.set(key, 'state', key)\\n self.tDisp.set(key, 'stDes', str(2**(key.count('-'))))\\n self.tDisp.set(key, 'stRem', str(infeas.statesRemoved))\",\n \"def on_detach(self, function_graph):\",\n \"def actualizar_poderes(self, event):\\r\\n pass\",\n \"def reset_component_data(self, result):\\n self.toggle_components(result)\\n self.event = None\\n self.pose_shifter_status = None\\n self.started_components = False\",\n \"def filter_out_flickers(total_buffer,index_disappeared):\\n \\n wait_for_disparition = False\\n candidate_for_disparition = -1\\n to_destroy = [] #List of 3D tuples (value,first_index,last_index) of segmented elements to remove from image\\n beginning_index = -1\\n premier_i =-1\\n list_of_is =[]\\n \\n previous_index, osef2, osef3 = index_disappeared[0] #Get the index for the first event\\n\\n for i in range(0,len(index_disappeared)):\\n index,diff,list_index = index_disappeared[i]\\n #Remove an appearing and disappearing object from the experiment only if it\\n #disappears in the next 5 (arbitrary) frames. If longer, conseder that something relevant\\n #happened.\\n \\n if wait_for_disparition:\\n #If sth appeared, destroy it if:\\n #-It is the same object that disappears\\n #-If the event is a disparition\\n #-If it disappears in a time<time_thr\\n size = np.count_nonzero(total_buffer[:,:,index-1]==list_index[0])\\n if list_index[0]==candidate_for_disparition and diff<0 and size<500:\\n to_destroy.append((list_index[0],beginning_index,index))\\n list_of_is.append(premier_i)\\n list_of_is.append(i)\\n wait_for_disparition=False\\n \\n if diff>0: #Creation, do wait for disparition\\n candidate_for_disparition = list_index[0]\\n beginning_index = index\\n wait_for_disparition =True\\n premier_i = i\\n \\n return to_destroy,list_of_is\",\n \"def remove():\",\n \"def test_remove_portless_vfc_maps1(self):\\n vwrap = self.vio_feed[0]\\n # Save the \\\"before\\\" size of the VFC mapping list\\n vfc_len = len(vwrap.vfc_mappings)\\n # Count our target LPARs' mappings before\\n lpar24maps = self.count_maps_for_lpar(vwrap.vfc_mappings, 24)\\n lpar124maps = self.count_maps_for_lpar(vwrap.vfc_mappings, 124)\\n ts.ScrubPortlessVFCMaps(self.adpt).execute()\\n # Overall two fewer maps\\n self.assertEqual(vfc_len - 2, len(vwrap.vfc_mappings))\\n # ...and they were the right ones\\n self.assertEqual(lpar24maps - 1,\\n self.count_maps_for_lpar(vwrap.vfc_mappings, 24))\\n self.assertEqual(lpar124maps - 1,\\n self.count_maps_for_lpar(vwrap.vfc_mappings, 124))\\n self.assertEqual(1, self.txfx.patchers['update'].mock.call_count)\",\n \"def revise():\",\n \"def prepare(self):\\n # Remove rows where the temporal scope could not be parsed correctly.\\n self.triples = self.triples[(self.triples.time_begin != -99999) & (self.triples.time_end != -99999)]\\n\\n # Remove rows with start time after the end time.\\n time_diffs = self.triples[\\\"time_end\\\"] - self.triples[\\\"time_begin\\\"]\\n invalid_times = time_diffs[time_diffs < 0].index\\n self.triples.drop([x for x in invalid_times], inplace=True, axis=\\\"index\\\")\\n\\n # Remove all entities that no longer have any facts associated with them from the dictionary.\\n entity_counts = Utils.get_entity_counts(self.triples, self.entities)\\n for idx, count in entity_counts.items():\\n if count == 0:\\n del self.entities[idx]\\n\\n # Remove all relations that no longer have any facts associated with them from the dictionary.\\n relation_counts = Utils.get_group_counts(self.triples.groupby(\\\"relation_id\\\"), self.relations)\\n for idx, count in relation_counts.items():\\n if count == 0:\\n del self.relations[idx]\",\n \"def reset_data(self):\\n\\n # Callback object to run, step and reset the model properly.\\n self.residential = True\\n self.callback_obj = None\\n self.data = self.model.measurements.get_bokeh_vis_data()\\n\\n # Check if it's the initial reset (create new sources) or a reset button\\n # click (update .data only)\\n try:\\n self.source.data = self.data\\n self.line_source.data = self.data[self.data.agent_type == 'system']\\n self.update_filters()\\n self.update_data()\\n\\n # Reset is clicked --> update .data only\\n except AttributeError:\\n self.source = ColumnDataSource(self.data)\\n self.line_source = ColumnDataSource(\\n self.data[self.data.agent_type == 'system'])\",\n \"def undo(self):\\n if self.history:\\n xy0, xy1, data_size = self.history.pop()\\n x0, y0 = xy0\\n x1, y1 = xy1\\n self._used[y1][x1] -= data_size\\n self._used[y0][x0] = data_size\\n if self.goal == xy1:\\n self.goal = xy0\",\n \"def _replace_event(self, state, new_event, old_event, total_events):\\n raise NotImplemented\",\n \"def delete_schedule(module, array):\\n changed = True\\n if not module.check_mode:\\n try:\\n current_state = array.get_pgroup(module.params['name'], schedule=True)\\n if module.params['schedule'] == \\\"replication\\\":\\n if current_state['replicate_enabled']:\\n array.set_pgroup(module.params['name'], replicate_enabled=False)\\n array.set_pgroup(module.params['name'], target_days=0, target_per_day=0,\\n target_all_for=1)\\n array.set_pgroup(module.params['name'], replicate_frequency=14400,\\n replicate_blackout=None)\\n else:\\n changed = False\\n else:\\n if current_state['snap_enabled']:\\n array.set_pgroup(module.params['name'], snap_enabled=False)\\n array.set_pgroup(module.params['name'], days=0, per_day=0, all_for=1)\\n array.set_pgroup(module.params['name'], snap_frequency=300)\\n else:\\n changed = False\\n except Exception:\\n module.fail_json(msg='Deleting pgroup {0} {1} schedule failed.'.format(module.params['name'],\\n module.params['schedule']))\\n module.exit_json(changed=changed)\",\n \"def disarm(self):\\n pass\",\n \"def undo_scan(self, sub_array_id: int):\",\n \"def test_delete_voltage_maps(self):\\n pass\",\n \"def resumeFrameEvents(self, resumeevent):\\n print \\\"resume decision made\\\"\\n self.playstate = \\\"PLAYING\\\"\\n self.framequeue = sorted(self.framequeue, key=lambda event: event.timestamp, reverse=True)\\n delta = resumeevent.timestamp - self.framequeue[-1].timestamp\\n \\n tmp_framequeue = list()\\n for event in self.framequeue:\\n event.timestamp += delta\\n tmp_framequeue.append(event)\\n self.framequeue = tmp_framequeue\",\n \"def rm_button_press(self, cmdid):\\n i = index_of_cmdid(self.cmds_list, cmdid)\\n del self.sched_rv.data[i]\\n del self.cmds_list[i]\\n self.clear_sched()\\n\\n startingID = 0 # zero indexed\\n idCounter = startingID\\n\\n for cmds in self.cmds_list: # repopulate schedule tab w/ updated cmds_list and their new id\\n if cmds.cmdid > idCounter:\\n cmds.cmdid = idCounter # keep id count consistent\\n self.sched_rv.data.append(cmds.cmd_dict())\\n idCounter = idCounter + 1\\n self.cmdid = idCounter\",\n \"def clear(self):\\n self.events={}\",\n \"def filterEvents(intervals_dates,list_infected,distance):\\n d=distance\\n list_gpsevents=[]\\n for z in range(len(intervals_dates)-1):\\n print(\\\"Interval: \\\",intervals_dates[z], \\\"y\\\", intervals_dates[z+1])\\n infected,uninfected=getTrazaTimestamp(intervals_dates[z],intervals_dates[z+1],GPSrecords,list_infected)\\n events_gps = nearest_neighbor(infected, uninfected, d)\\n events_gps = events_gps.drop(['geometry','closest_stop_geom'], axis=1)\\n print(len(events_gps))\\n if(len(events_gps)!=0):\\n list_gpsevents.append(events_gps.reset_index(drop=True))\\n else:\\n events_gps=pd.DataFrame()\\n list_gpsevents.append(events_gps)\\n #GPSevents=pd.concat(list_gpsevents).reset_index(drop=True)\\n #return GPSevents\\n return list_gpsevents\",\n \"def moveSelectedSegs(self,dragPosy,source):\\n # TODO: check: I think the dict is always in descending order down screen?\\n self.segsChanged = True\\n # The first line seemed neater, but the verticalSpacing() doesn't update when you rescale the window\\n #movetoID = dragPosy//(self.picbuttons[0].size().height()+self.flowLayout.layout.verticalSpacing())\\n movetoID = dragPosy//(self.flowLayout.layout.geometry().height()//self.nclasses)\\n\\n # drags which start and end in the same cluster most likely were just long clicks:\\n for ix in range(len(self.picbuttons)):\\n if self.picbuttons[ix] == source:\\n if self.segments[ix][-1] == movetoID:\\n source.clicked.emit()\\n return\\n\\n # Even if the button that was dragged isn't highlighted, make it so\\n source.mark = 'yellow'\\n\\n for ix in range(len(self.picbuttons)):\\n if self.picbuttons[ix].mark == 'yellow':\\n self.segments[ix][-1] = movetoID\\n self.picbuttons[ix].mark = 'green'\\n\\n # update self.clusters, delete clusters with no members\\n todelete = []\\n for ID, label in self.clusters.items():\\n empty = True\\n for seg in self.segments:\\n if seg[-1] == ID:\\n empty = False\\n break\\n if empty:\\n todelete.append(ID)\\n\\n self.clearButtons()\\n\\n # Generate new class labels\\n if len(todelete) > 0:\\n keys = [i for i in range(self.nclasses) if i not in todelete] # the old keys those didn't delete\\n # print('old keys left: ', keys)\\n\\n nclasses = self.nclasses - len(todelete)\\n max_label = nclasses - 1\\n labels = []\\n c = self.nclasses - 1\\n while c > -1:\\n if c in keys:\\n labels.append((c, max_label))\\n max_label -= 1\\n c -= 1\\n\\n # print('[old, new] labels')\\n labels = dict(labels)\\n print(labels)\\n\\n # update clusters dictionary {ID: cluster_name}\\n clusters = {}\\n for i in keys:\\n clusters.update({labels[i]: self.clusters[i]})\\n\\n print('before move: ', self.clusters)\\n self.clusters = clusters\\n print('after move: ', self.clusters)\\n\\n # update the segments\\n for seg in self.segments:\\n seg[-1] = labels[seg[-1]]\\n\\n self.nclasses = nclasses\\n\\n # redraw the buttons\\n self.updateButtons()\\n self.updateClusterNames()\\n self.completeChanged.emit()\",\n \"def on_leave(self):\\r\\n for widgets in self.timecompoundlist:\\r\\n for w in widgets:\\r\\n self.ids.inlayout.remove_widget(w)\\r\\n self.ids.inlayout.remove_widget(self.add_button)\\r\\n self.ids.inlayout.remove_widget(self.del_button)\",\n \"def on_prune(self, fgraph, app, reason):\\r\\n #if app not in self.debug_all_apps: raise ProtocolError(\\\"prune without import\\\")\\r\\n #self.debug_all_apps.remove(app)\\r\\n\\r\\n #UPDATE self.clients\\r\\n for i, input in enumerate(OrderedSet(app.inputs)):\\r\\n del self.clients[input][app]\\r\\n\\r\\n if getattr(app.op, 'destroy_map', {}):\\r\\n self.destroyers.remove(app)\\r\\n\\r\\n # Note: leaving empty client dictionaries in the struct.\\r\\n # Why? It's a pain to remove them. I think they aren't doing any harm, they will be\\r\\n # deleted on_detach().\\r\\n\\r\\n #UPDATE self.view_i, self.view_o\\r\\n for o_idx, i_idx_list in getattr(app.op, 'view_map', {}).items():\\r\\n if len(i_idx_list) > 1:\\r\\n #destroying this output invalidates multiple inputs\\r\\n raise NotImplementedError()\\r\\n o = app.outputs[o_idx]\\r\\n i = app.inputs[i_idx_list[0]]\\r\\n\\r\\n del self.view_i[o]\\r\\n\\r\\n self.view_o[i].remove(o)\\r\\n if not self.view_o[i]:\\r\\n del self.view_o[i]\\r\\n\\r\\n self.stale_droot = True\",\n \"def clean_window(self) -> None:\\r\\n prune_before = time.time() - self.window_size\\r\\n while self.frames_rec:\\r\\n left = self.frames_rec.popleft()\\r\\n if left[1] >= prune_before:\\r\\n self.frames_rec.appendleft(left)\\r\\n break\\r\\n self.sum_frames_rec -= left[0]\\r\\n\\r\\n while self.frames_proc:\\r\\n left = self.frames_proc.popleft()\\r\\n if left[1] >= prune_before:\\r\\n self.frames_proc.appendleft(left)\\r\\n break\\r\\n self.sum_frames_proc -= left[0]\",\n \"def new_loop_packet(self, event):\\n # packet has traveled back in time\\n if self.end_ts > event.packet['dateTime']:\\n self.logger.error(\\\"Service ignoring packet has dateTime of %f which is prior to previous packet %f\\\"\\n %(event.packet['dateTime'], self.end_ts))\\n else:\\n start_ts = self.end_ts\\n self.end_ts = event.packet['dateTime']\\n\\n for topic in self.subscriber.subscribed_topics: # topics might not be cached.. therefore use subscribed?\\n self.logger.debug(\\\"Service packet prior to update is: %s %s\\\"\\n % (weeutil.weeutil.timestamp_to_string(event.packet['dateTime']),\\n to_sorted_string(event.packet)))\\n target_data = self.subscriber.get_accumulated_data(topic,\\n start_ts, self.end_ts, event.packet['usUnits'])\\n event.packet.update(target_data)\\n self.logger.debug(\\\"Service packet after update is: %s %s\\\"\\n % (weeutil.weeutil.timestamp_to_string(event.packet['dateTime']),\\n to_sorted_string(event.packet)))\",\n \"def clean():\\n filter_phase_data()\\n combine_phase_data()\\n remove_duplicates_phase_data()\",\n \"def pruning(self):\\n data = self.data.copy()\\n for d in self.data:\\n # cascade purning method. Inspired from \\\"Efficient Computation of Group Skyline Queries on MapReduce (FCU)\\\"\\n if d in data:\\n pastart = [self.drange[1] if i+self.radius>self.drange[1] else i+self.radius for i in d.getLocationMax()]\\n pamax = [self.drange[1] for j in range(self.dim)]\\n # prune data points that are obviously dominated by current data point\\n pruned = (self.index.intersection(tuple(pastart+pamax),objects=True))\\n for p in pruned:\\n if p.object in data:\\n data.remove(p.object)\\n self.pruned = data\",\n \"def XPLMDataChanged_f(inRefcon):\",\n \"def forwarder_state_changed(self, ev):\\n\\n\\n dp = ev.dp\\n ofp = dp.ofproto\\n parser = dp.ofproto_parser\\n\\n\\n if ev.enter is True:\\n # in plain MAC setup, this should install only ICMP and ARP re-route rules, watchout for hardcoded DP id\\n self.on_inner_dp_join(dp)\\n\\t ##For evry new forwarder we send out discovery ICMP packets out of every port except OFPP_CONTROLLER\\n LOG.debug('TOPO MNGR: Forwarder: ' + str(dp.id) + ' saying hello to Unifycore Controller, Unifycore warmly welcomes you!')\\n for port in dp.ports:\\n if port != (ofp.OFPP_CONTROLLER):\\n LOG.debug('TOPO MNGR: Controller is sending topology discovery ICMPs to forwarder: ' + str(dp.id) + ', port: ' + str(port))\\n _icmp_send(dp,port,DISCOVERY_IP_SRC, DISCOVERY_IP_DST)\\n\\n ##For evry new forwarder we send out discovery ARP packets out of every port except OFPP_CONTROLLER to find APN\\n for apn in APN_POOL:\\n if apn.ip_addr != None:\\n LOG.debug('TOPO MNGR: Forwarder: '+str(dp.id)+', port: '+ str(port) + ' is looking for APN: ' + str(apn.name) +' at IP: '+str(apn.ip_addr)+' with ARP search source IP: ' + str(apn.arp_origin_ip))\\n _arp_send(dp=dp, port_out=port, arp_code=1, ip_target=apn.ip_addr, ip_sender=apn.arp_origin_ip)\\n\\n\\n\\n\\n\\n if ev.enter is False:\\n\\t ##TODO: We need to scan if any tunnels were affected, and if so, if any PDP COntexts were affected\\n ##JUST REMOVING NODE FROM TOPOLOGY ISNT ENOUGH!\\n LOG.debug('TOPO MNGR: Forwarder: ' + str(dp.id) + ' is leaving topology. It was a pleasure for us!')\\n topo.del_forwarder(dp.id)\",\n \"def event11022120():\\n header(11022120)\\n\\n item_type, item_id = define_args('Bi')\\n end_if_this_event_slot_on()\\n if_new_game_count_greater_than_or_equal(1, 1)\\n end_if_condition_false(1)\\n item.remove_items_from_player(item_type, item_id, 0)\",\n \"def cancelUnblockVis(self):\\n if self.__nextSetZoneDoneEvent is not None:\\n self.ignore(self.__nextSetZoneDoneEvent)\\n self.__nextSetZoneDoneEvent = None\",\n \"def handle_link_down (self, port):\\n for dest in self.hosts.keys():\\n currPort = self.hosts[dest][0]\\n if currPort == port:\\n del self.hosts[dest]\\n \\n deleteDests = set()\\n for dest in self.routesToDest:\\n currPort = self.routesToDest[dest][0]\\n \\n if currPort == port:\\n\\n if dest in self.hosts:\\n self.routesToDest[dest] = self.hosts[dest]\\n packet = basics.RoutePacket(dest, self.routesToDest[dest][1])\\n self.send(packet, self.routesToDest[dest][0], True)\\n else:\\n self.sendPoison(dest)\\n deleteDests.add(dest)\\n\\n\\n for dest in deleteDests:\\n del self.routesToDest[dest]\\n\\n del self.neighbours[port]\",\n \"def on_epoch_end(self):\\n if self.shuffle:\\n self.indexes = np.random.permutation(self.indexes)\",\n \"def on_epoch_end(self):\\n if self.shuffle:\\n self.indexes = np.random.permutation(self.indexes)\",\n \"def _reset_stored(self):\\n ## Main information\\n self.idxs = None\\n self.sp_relative_pos = None\\n self._setted = False\\n self.ks = None\\n self.iss = [0]\",\n \"def on_epoch_end(self):\\n if self.shuffle:\\n self.dataset_df = skl_shuffle(self.dataset_df)\",\n \"def removeOldCars(self):\\n self.cars = [car for car in self.cars if (self.currentFrame - car.updatedInFrame) < DROP_AFTER_N_FRAMES]\\n for i, car in enumerate(self.cars): # update id's\\n car.id = i + 1\",\n \"def unschedule(self, func):\\n for sched in (\\n self.schedules, self.update_schedules, self.frame_schedules,\\n self.interval_schedules,\\n ):\\n for item in list(sched):\\n if item.func == func:\\n sched.remove(item)\",\n \"def reset(self):\\n self.placeables = []\\n self.previous_placeable = None\\n self.current_volume = 0\\n self.reset_tip_tracking()\",\n \"def decimate(self, valid):\\r\\n self.points = self.points[valid]\\r\\n for obj in self.data: self.data[obj] = self.data[obj][valid]\",\n \"def checkpoint_unset():\\n unwind(checkpoints.pop())\",\n \"def remove_to_destroy(total_buffer,to_destroy):\\n totbuf=np.copy(total_buffer)\\n for val,begInd,endInd in to_destroy:\\n for j in range(endInd-begInd):\\n index_beg = begInd+j\\n totbuf[ total_buffer[:,:,index_beg]==val,index_beg]=0\\n return totbuf\",\n \"def rePop(self):\\n nScan = 0\\n pScan = self.num-1\\n while not self.isFull():\\n while self.genepool[0][pScan] == None:\\n pScan = (pScan-1)%self.num\\n while self.genepool[0][nScan] != None:\\n nScan = (nScan+1)%self.num\\n self.genepool[0][nScan] = self.genepool[0][pScan].mutate()\\n self.genepool[1][nScan] = self.genepool[1][pScan].mutate()\\n nScan = (nScan+1)%self.num\\n pScan = (pScan-1)%self.num\",\n \"def rePop(self):\\n nScan = 0\\n pScan = self.num-1\\n while not self.isFull():\\n while self.genepool[0][pScan] == None:\\n pScan = (pScan-1)%self.num\\n while self.genepool[0][nScan] != None:\\n nScan = (nScan+1)%self.num\\n self.genepool[0][nScan] = self.genepool[0][pScan].mutate()\\n self.genepool[1][nScan] = self.genepool[1][pScan].mutate()\\n nScan = (nScan+1)%self.num\\n pScan = (pScan-1)%self.num\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58445203","0.5509604","0.538551","0.5352465","0.5347396","0.53318274","0.5314644","0.52846736","0.5262972","0.5220926","0.52139837","0.51859725","0.5173534","0.51570314","0.51506615","0.5138261","0.51148987","0.5111304","0.5085959","0.5082112","0.50595564","0.5055803","0.5055803","0.5019372","0.50145763","0.5004144","0.49869683","0.49747965","0.49731392","0.4969835","0.49399543","0.49353945","0.49271154","0.4922409","0.49219245","0.4915374","0.49135748","0.49103943","0.490875","0.49063045","0.49050525","0.48981252","0.48741758","0.48690325","0.48678344","0.4866853","0.48665714","0.48605385","0.48594275","0.4845884","0.4838595","0.48350397","0.48331124","0.4832337","0.4831773","0.48303762","0.48107988","0.48074844","0.48051912","0.47944066","0.47820002","0.47735578","0.47704232","0.4769333","0.47570384","0.4750899","0.47508457","0.4748569","0.47480652","0.47393358","0.4736109","0.47342166","0.47310528","0.47236705","0.47218925","0.47215387","0.47206086","0.47144184","0.47103623","0.47033006","0.47005376","0.4692863","0.46926722","0.46890095","0.46836853","0.46797988","0.46794763","0.46760598","0.46727365","0.46671012","0.46671012","0.46631733","0.46591184","0.46567285","0.46539387","0.4651008","0.46505943","0.46431726","0.46402007","0.46382222","0.46382222"],"string":"[\n \"0.58445203\",\n \"0.5509604\",\n \"0.538551\",\n \"0.5352465\",\n \"0.5347396\",\n \"0.53318274\",\n \"0.5314644\",\n \"0.52846736\",\n \"0.5262972\",\n \"0.5220926\",\n \"0.52139837\",\n \"0.51859725\",\n \"0.5173534\",\n \"0.51570314\",\n \"0.51506615\",\n \"0.5138261\",\n \"0.51148987\",\n \"0.5111304\",\n \"0.5085959\",\n \"0.5082112\",\n \"0.50595564\",\n \"0.5055803\",\n \"0.5055803\",\n \"0.5019372\",\n \"0.50145763\",\n \"0.5004144\",\n \"0.49869683\",\n \"0.49747965\",\n \"0.49731392\",\n \"0.4969835\",\n \"0.49399543\",\n \"0.49353945\",\n \"0.49271154\",\n \"0.4922409\",\n \"0.49219245\",\n \"0.4915374\",\n \"0.49135748\",\n \"0.49103943\",\n \"0.490875\",\n \"0.49063045\",\n \"0.49050525\",\n \"0.48981252\",\n \"0.48741758\",\n \"0.48690325\",\n \"0.48678344\",\n \"0.4866853\",\n \"0.48665714\",\n \"0.48605385\",\n \"0.48594275\",\n \"0.4845884\",\n \"0.4838595\",\n \"0.48350397\",\n \"0.48331124\",\n \"0.4832337\",\n \"0.4831773\",\n \"0.48303762\",\n \"0.48107988\",\n \"0.48074844\",\n \"0.48051912\",\n \"0.47944066\",\n \"0.47820002\",\n \"0.47735578\",\n \"0.47704232\",\n \"0.4769333\",\n \"0.47570384\",\n \"0.4750899\",\n \"0.47508457\",\n \"0.4748569\",\n \"0.47480652\",\n \"0.47393358\",\n \"0.4736109\",\n \"0.47342166\",\n \"0.47310528\",\n \"0.47236705\",\n \"0.47218925\",\n \"0.47215387\",\n \"0.47206086\",\n \"0.47144184\",\n \"0.47103623\",\n \"0.47033006\",\n \"0.47005376\",\n \"0.4692863\",\n \"0.46926722\",\n \"0.46890095\",\n \"0.46836853\",\n \"0.46797988\",\n \"0.46794763\",\n \"0.46760598\",\n \"0.46727365\",\n \"0.46671012\",\n \"0.46671012\",\n \"0.46631733\",\n \"0.46591184\",\n \"0.46567285\",\n \"0.46539387\",\n \"0.4651008\",\n \"0.46505943\",\n \"0.46431726\",\n \"0.46402007\",\n \"0.46382222\",\n \"0.46382222\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":919,"numItemsPerPage":100,"numTotalItems":95772,"offset":91900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTYwNTg2NywianRpIjoiMmQ4OTQ4OGUtY2U5MS00N2MxLWEyMGUtYTE0ZDg2OTk4YTE1Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU2MDk0NjcsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.n2ry_eQxDlTQRHJpO7xuawCpmV4JbwPuWbjz1T4S8jMdIZxiouMZHtBklc6KKnn_CkifNt5rYkb31xNfZUNGCA","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 |
|---|---|---|---|---|---|---|
A helper for backends to let them redirect to a generic "order was cancelled" URL of their choosing. | def get_cancel_url(self):
return reverse('checkout_payment') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _order_not_found():\n pecan.abort(404, u._('Order not found.'))",
"def do_cancel(order):\r\n self.gox.cancel(order.oid)",
"def _order_cancel(self, bo):\n log.info(\"bo_blotter: order_cancel bracket order bo#%s\" % bo.ticket) \n cancelled = bo.cancel()\n return(canc... | [
"0.63242435",
"0.6176782",
"0.6108915",
"0.6008895",
"0.5965189",
"0.59537345",
"0.5943401",
"0.5943401",
"0.5923187",
"0.58964926",
"0.58032817",
"0.58032817",
"0.5802958",
"0.58013177",
"0.5782521",
"0.5767809",
"0.57137996",
"0.5702149",
"0.5667031",
"0.56372297",
"0.55683... | 0.68018407 | 0 |
Set initial location of the central controller. | def main():
location = gen_Location("0.856901647439813,14.08447265625")
add_location(location) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulator_window_center(self, value: str) -> None:\n self.set_capability(SIMULATOR_WINDOW_CENTER, value)",
"def _configure_main(self, client):\n width = self._get_main_width()\n height = self.screen_rect.height\n left = self.screen_rect.x\n top = self.screen_rect.y\n\n ... | [
"0.5979996",
"0.5911836",
"0.5897334",
"0.5872533",
"0.5869994",
"0.5820433",
"0.58033293",
"0.57864046",
"0.57571167",
"0.5735946",
"0.57304484",
"0.5696587",
"0.56753886",
"0.56547064",
"0.5641599",
"0.5622692",
"0.5616644",
"0.56052744",
"0.56052464",
"0.5605135",
"0.56011... | 0.0 | -1 |
Extrapolate the next value for `values`, based on the last `n` samples. | def extrapolate_with_worst_case(values: List[float], n: int = 5) -> float:
n = min(len(values), n)
return values[-1] + max(v_next - v_prev for v_prev, v_next in zip(values[-n:], values[-n+1:])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _append_value(self, v_values, next_value, v_idx=None, n_vals=1):\n for _ in range(n_vals):\n if v_idx:\n try:\n v_i = next(v_idx)\n except StopIteration:\n # Repeating commas are null-statements and can be ignored\n ... | [
"0.5853784",
"0.5652507",
"0.5483655",
"0.54175586",
"0.53613377",
"0.5355311",
"0.5346964",
"0.52661806",
"0.52464515",
"0.5240065",
"0.5202819",
"0.5179259",
"0.51771766",
"0.5159131",
"0.51569784",
"0.51434296",
"0.5133736",
"0.51274586",
"0.51172006",
"0.5096899",
"0.5076... | 0.735803 | 0 |
Save the model at "checkpoint_interval" and its multiple | def save_model(opt, epoch, iteration, len_dataset, G_AB, G_BA):
if opt.multi_gpu == True:
if opt.save_mode == 'epoch':
if (epoch % opt.save_by_epoch == 0) and (iteration % len_dataset == 0):
if opt.save_name_mode:
torch.save(G_AB.modul... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_checkpoint(self, model_path=None):\n # TODO: include new params based on ConfigEnum\n if not os.path.isdir(path_checkpoints_dir):\n os.mkdir(path_checkpoints_dir)\n if model_path is None:\n model_path = os.path.join(path_checkpoints_dir, f\"{self.experiment_id}.p... | [
"0.7401582",
"0.71482164",
"0.70594513",
"0.70572174",
"0.7051137",
"0.6978655",
"0.69547313",
"0.69219506",
"0.68931407",
"0.6889052",
"0.68744576",
"0.67990834",
"0.677864",
"0.67624456",
"0.6761798",
"0.6743924",
"0.6712295",
"0.66999596",
"0.6690734",
"0.6688848",
"0.6674... | 0.0 | -1 |
Make alternating progression from 0..len(mask) and apply mask | def bin_to_progression(cnum):
cnum = '{:b}'.format(cnum)
lbits = len(cnum)
cnum = tuple(bool(int(b)) for b in cnum)
res = [-x if x % 2 == 0 else x for x in xrange(lbits)]
for x in reversed(range(lbits)):
if not cnum[x]:
del res[x]
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_mask(data, mask):\n if len(mask) != 4:\n raise ValueError(\"mask must contain 4 bytes\")\n\n return bytes(b ^ m for b, m in zip(data, itertools.cycle(mask)))",
"def dilate(mask, forbidden):\n new_mask = np.copy(mask)\n # Shift right\n new_mask[:, 1:] |= mask[:, :-1]\n # Shift l... | [
"0.68521",
"0.6847219",
"0.67219555",
"0.6714275",
"0.6687717",
"0.6558609",
"0.65374684",
"0.6342248",
"0.62859005",
"0.6244902",
"0.6208443",
"0.6195653",
"0.6113903",
"0.6106946",
"0.60793924",
"0.60774386",
"0.60697985",
"0.60546464",
"0.60513604",
"0.6038645",
"0.6037974... | 0.0 | -1 |
Generate a waveform at a given pitch | def oscillator(pitch):
phi = 0.0
frequency = (2.0 ** ((pitch - 69.0) / 12.0)) * 440.0
delta = 2.0 * math.pi * frequency / 44100.0
while True:
yield math.sin(phi) + math.sin(2.0 * phi)
phi += delta | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pitch_gen(freq: float, duration: float, signal: np.array, sample_freq: int, alpha=0.99, ref_length=50):\n total_sample_number = int(sample_freq * duration)\n desire_signal_length = int(sample_freq / freq)\n # pad or cur signal\n if len(signal) >= desire_signal_length:\n input_signal = signal... | [
"0.68925357",
"0.6726234",
"0.66145486",
"0.6221028",
"0.6093583",
"0.6090684",
"0.607366",
"0.6036504",
"0.6002003",
"0.6001324",
"0.59268504",
"0.58418846",
"0.58402395",
"0.5825315",
"0.5818039",
"0.58005536",
"0.5795154",
"0.5773108",
"0.57607305",
"0.57472736",
"0.572024... | 0.62913406 | 3 |
Attenuate the input signal by a given gain factor | def amplifier(gain, iterable):
return (gain * sample for sample in iterable) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gain(self, value: int):\n self._gain = value",
"def _augment_gain(audio, low=0.25, high=1.25):\n gain = low + torch.rand(1) * (high - low)\n return audio * gain",
"def _augment_gain(audio, low=0.5, high=1.5):\n g = low + np.random.random_sample(1) * (high - low)\n return audio * g",
"d... | [
"0.66207147",
"0.65744394",
"0.65512675",
"0.64316994",
"0.621831",
"0.6208555",
"0.6176225",
"0.61242586",
"0.60282975",
"0.5953353",
"0.5933839",
"0.5906124",
"0.5894021",
"0.5892993",
"0.58928",
"0.589171",
"0.5890473",
"0.588739",
"0.5873238",
"0.5856382",
"0.58518577",
... | 0.54098356 | 51 |
Converts chord symbols to a list of MIDI notes. | def chord_generator(iterable):
return (CHORDS[chord_symbol] for chord_symbol in iterable) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def midiToNotes(notes):\n names = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']\n chord = []\n \n for note in notes:\n name = names[note%12]\n octave = int((note-12)/12)\n chord.append(name + str(octave))\n \n return chord",
"def do_notes(self, sym):... | [
"0.7616489",
"0.7372916",
"0.6316395",
"0.61998713",
"0.61932015",
"0.6102809",
"0.6100707",
"0.60786456",
"0.5910005",
"0.59029245",
"0.58734196",
"0.58396786",
"0.580742",
"0.5697692",
"0.56194425",
"0.5570026",
"0.5569478",
"0.556555",
"0.55168945",
"0.5492388",
"0.5487699... | 0.5514109 | 19 |
Converts a list of MIDI notes to (length, notes) tuples in a jazzy pattern. | def comp_pattern_generator(iterable):
for chord in iterable:
yield (600, chord) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def midiToNotes(notes):\n names = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']\n chord = []\n \n for note in notes:\n name = names[note%12]\n octave = int((note-12)/12)\n chord.append(name + str(octave))\n \n return chord",
"def get_notes(n_notes=3)... | [
"0.72751355",
"0.6409998",
"0.6386394",
"0.63532275",
"0.6276241",
"0.6104568",
"0.6063792",
"0.6033236",
"0.5902657",
"0.5802162",
"0.5789134",
"0.5754933",
"0.5710029",
"0.5709479",
"0.5675543",
"0.5661066",
"0.56405497",
"0.5631645",
"0.56205016",
"0.5610599",
"0.56057876"... | 0.0 | -1 |
Converts a (length, notes) tuple into a (start time, list of voices) tuple | def voice_generator(iterable):
t = 0
for length, pitches in iterable:
voices = [Voice(pitch, length) for pitch in pitches]
yield (t, voices)
t += length | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def notes2trk(notes):\n\n trk = MidiTrack()\n\n for i, note in enumerate(notes):\n if note[0] == 's': # Message for a silence\n trk.append(Message(\"note_on\", note=0, velocity=0, time=0))\n trk.append(Message(\"note_off\", note=0, velocity=0, time=note[1]))\n continu... | [
"0.5827614",
"0.58031875",
"0.5766902",
"0.5739528",
"0.564799",
"0.55279285",
"0.5484863",
"0.5467367",
"0.545753",
"0.5285937",
"0.52673745",
"0.52369463",
"0.5207202",
"0.5189461",
"0.5179867",
"0.5171127",
"0.5165314",
"0.5151694",
"0.51371425",
"0.5110185",
"0.5105895",
... | 0.53834355 | 9 |
Renders samples from voices and maintains a voice pool | def voice_combiner(iterable):
t = 0.0
stopping = False
voice_pool = []
voice_time, voice_list = next(iterable)
while True:
# add new voices to the pool
while t >= voice_time:
voice_pool.extend(voice_list)
try:
voice_time, voice_list = next(it... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_samplers(self):\n raise NotImplementedError(\" The draw_samplers() method has not been implemented \")",
"def vad_collector(sample_rate, frame_duration_ms,\n padding_duration_ms, vad, frames):\n num_padding_frames = int(padding_duration_ms / frame_duration_ms)\n # We use a ... | [
"0.6162303",
"0.5727719",
"0.55910593",
"0.5577907",
"0.5498214",
"0.5483886",
"0.54681635",
"0.5461217",
"0.54054",
"0.5372851",
"0.53714526",
"0.5359456",
"0.5333311",
"0.5311192",
"0.5289894",
"0.52676386",
"0.5251842",
"0.52288085",
"0.52242666",
"0.5217163",
"0.5215833",... | 0.57762194 | 1 |
Converts floating point audio signals to 16 bit integers | def quantizer(iterable):
return (int(32767.0 * sample) for sample in iterable) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _float_to_16_bit_sample(value):\n sample = int(32767.0 * value)\n byte0 = sample & 255\n byte1 = (sample >> 8) & 255\n return byte0, byte1",
"def float_to_int_16(x):\n return np.float16(x).view(np.int16)",
"def bit_to_short(bits: str) -> float:\n ints = int(bits, 2)\n r... | [
"0.741024",
"0.70081574",
"0.64652306",
"0.64043653",
"0.6338653",
"0.6219103",
"0.6193878",
"0.61736125",
"0.6150416",
"0.60350937",
"0.5967454",
"0.59377503",
"0.58848333",
"0.58737385",
"0.58616364",
"0.5821956",
"0.5818692",
"0.5739716",
"0.57278293",
"0.57149684",
"0.570... | 0.0 | -1 |
return the maximum value achievable in 'capacity' weight using 'items' when repeated items are allowed | def knapval_rep(capacity, items):
# def knapv(w):
# subprobs = [(knapv(w-item.weight) + item.value)
# for item in items if item.weight <= w]
# return reduce(max, subprobs, 0)
#
# return knapv(capacity)
result = 0
if len(items) == 0:
result = 0
elif ca... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def knapsack(items, capacity):\n if len(items) == 0 or capacity <= 0:\n return 0\n \n name, weight, value = items[0]\n val_without = knapsack(items[1:], capacity)\n\n if weight > capacity:\n return val_without\n val_with = value + knapsack(items[1:], capacity - weight)\n\n return... | [
"0.80529207",
"0.7795684",
"0.7373593",
"0.73671526",
"0.7362459",
"0.73233944",
"0.7159021",
"0.71527445",
"0.704665",
"0.69259",
"0.6890195",
"0.68810976",
"0.6865774",
"0.68263716",
"0.67208666",
"0.665759",
"0.6596336",
"0.6569543",
"0.6552361",
"0.650723",
"0.6473436",
... | 0.7531622 | 2 |
return the maximum value achievable in 'capacity' weight using 'items' when repeated items are allowed | def knapval_norep_rec(capacity, items):
# # choose to use item.weight and get item.value + optimal from what's left
# options = list(
# item.value + knapval_norep(capacity-item.weight, lits(i for i in items if i is not item))
# for item in items if item.weight <= capacity)
# if len(optio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def knapsack(items, capacity):\n if len(items) == 0 or capacity <= 0:\n return 0\n \n name, weight, value = items[0]\n val_without = knapsack(items[1:], capacity)\n\n if weight > capacity:\n return val_without\n val_with = value + knapsack(items[1:], capacity - weight)\n\n return... | [
"0.8053362",
"0.7796187",
"0.7531503",
"0.7373693",
"0.7362247",
"0.7323349",
"0.7159887",
"0.71528",
"0.7046194",
"0.6925851",
"0.6890471",
"0.6880475",
"0.6865383",
"0.68267167",
"0.67212474",
"0.66574955",
"0.65967155",
"0.65697443",
"0.65523726",
"0.65078604",
"0.64739335... | 0.7367629 | 4 |
return the maximum value achievable in 'capacity' weight using 'items' when repeated items are allowed | def knapval_norep(W, wt):
# choose to use item.weight and get item.value + optimal from what's left
# last_item = items[-1]
# other_items = items[:-1]
# options = list(
# knpaval_norep(capacity, other_items))
# if last_item.weight <= capacity:
# options.append(last_item.value +
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def knapsack(items, capacity):\n if len(items) == 0 or capacity <= 0:\n return 0\n \n name, weight, value = items[0]\n val_without = knapsack(items[1:], capacity)\n\n if weight > capacity:\n return val_without\n val_with = value + knapsack(items[1:], capacity - weight)\n\n return... | [
"0.80534375",
"0.7795931",
"0.75310713",
"0.737376",
"0.7366686",
"0.7362282",
"0.732389",
"0.7152785",
"0.7045815",
"0.69256973",
"0.68899876",
"0.68808466",
"0.68654317",
"0.68268967",
"0.6720455",
"0.66579473",
"0.65970707",
"0.6569917",
"0.65530336",
"0.65083057",
"0.6473... | 0.71592444 | 7 |
Get a collection or raise a NoObject exception. | def get_collection(coll_id=None, transform_id=None, relation_type=None):
return collections.get_collection(coll_id=coll_id, transform_id=transform_id, relation_type=relation_type) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_collection(collection_id):\n print('collection_checker.get_collection()')\n collection = collection_dao.get_collection(collection_id)\n if collection is None:\n abort(404, 'Collection does not exist')\n else:\n collection = collection_dao.get_collection(collection_id)\n pri... | [
"0.69242334",
"0.68296415",
"0.67922777",
"0.66790384",
"0.66327196",
"0.6520115",
"0.6349354",
"0.6292217",
"0.6282009",
"0.62539697",
"0.6183507",
"0.6162687",
"0.60547894",
"0.6030391",
"0.6023147",
"0.6020786",
"0.6013222",
"0.5970177",
"0.5962228",
"0.5952375",
"0.593433... | 0.6146809 | 12 |
Returns a function which standardizes a value to zero mean and unit variance. | def generateStandardizationFunction(self, col, mean, nf):
def f(value):
if value is None:
value = 0.
return float((value - mean) / nf)
return f | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def standardize(x, mean=None, std=None): \n \n mean = mean if mean is not None else x.mean(axis=0)\n std = std if std is not None else x.std(axis=0) \n \n return (x - mean) / std, mean, std",
"def standardize(data):\r\n mean = data.mean(axis=0)\r\n std = data.std(axis=0)\r\n return (data... | [
"0.7531515",
"0.7436087",
"0.7393924",
"0.7227247",
"0.7196341",
"0.7187475",
"0.7001668",
"0.6994719",
"0.69453627",
"0.69395155",
"0.6934991",
"0.68891823",
"0.6886294",
"0.6884869",
"0.68243986",
"0.6824206",
"0.6813376",
"0.6759209",
"0.6759209",
"0.6711206",
"0.66860104"... | 0.71010065 | 6 |
Returns a set of SparseVectorDimensions which are each assigned a transformation function appropriate for standardizing the respective dimension. | def generateStandardizedColumns(self, data_set, columns):
cstat = data_set.colStats()
stdDevs = np.sqrt(cstat.variance())
means = cstat.mean()
normalizingFactors = map(lambda x: x if x != 0.0 else 1.0, stdDevs)
result = []
for col, mean, nf in zip(columns, means, normaliz... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_scale_features_standardize(self):\n data = array([[0.564, 20.661], [-18.512, 41.168], [-0.009, 20.440]])\n cdata = CData(data)\n\n # correct answer computed in Mathematica\n # TODO: can we compute the right answer in Python?\n answer = array([[0.60355, -0.568043], [-1.15... | [
"0.58996356",
"0.5885209",
"0.562922",
"0.5424146",
"0.5354879",
"0.5301714",
"0.52051574",
"0.5184689",
"0.51839614",
"0.51808983",
"0.5156929",
"0.5156137",
"0.5154081",
"0.51329243",
"0.5126789",
"0.50431347",
"0.49799955",
"0.4977521",
"0.4954653",
"0.4950907",
"0.4950194... | 0.60437644 | 0 |
Returns a function which standardizes a row's data and returns a potentially labeled `Row`. | def generateMlRow(self, successFunct=None, columns=None, labelColName="label",
featureColName="features", standardizeCols=True):
if columns is None:
columns = self.sparseDataSet.columns
if standardizeCols:
standardized_columns = self.standardize(columns)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fake_clean_row(row):\n\treturn row",
"def _format_table(row):\n row = pd.to_numeric(row, errors=\"ignore\")\n #try:\n # row = eval(row)\n #except (TypeError, ValueError, SyntaxError, NameError):\n # #print(\"Could not evaluate {}\".format(row))\n # pass\n ... | [
"0.6164406",
"0.6127066",
"0.6019099",
"0.6005075",
"0.5726464",
"0.5528043",
"0.5512648",
"0.5436464",
"0.53070384",
"0.52938306",
"0.5247783",
"0.5208071",
"0.5205887",
"0.5141943",
"0.50920874",
"0.50907654",
"0.5074286",
"0.5066809",
"0.5063445",
"0.5063213",
"0.5057529",... | 0.51083314 | 14 |
Returns a DataFrame where the rows have been transformed according to the dataset transformation. | def generateMlDataSet(self, successFunct=None, columns=None, labelColName="label",
featureColName="features", standardizeCols=True):
generate_ml_row = self.generateMlRow(successFunct, columns, labelColName=labelColName,
featureColName=featur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit_transform(self) -> DataFrame:\n\n self.fit()\n return self.transform()",
"def transform(self, dataframe: DataFrame) -> DataFrame:",
"def get_transformed_data(self, df):\n temp_df = pd.DataFrame(self.fa.transform(df))\n return temp_df",
"def transform(self, data: pd.DataFra... | [
"0.7627935",
"0.7551968",
"0.73451376",
"0.7242807",
"0.72086525",
"0.68814796",
"0.6862239",
"0.6858905",
"0.6770108",
"0.675803",
"0.6718472",
"0.66019315",
"0.660158",
"0.6600896",
"0.65621793",
"0.65621793",
"0.65621793",
"0.65608925",
"0.64859825",
"0.6464547",
"0.644794... | 0.0 | -1 |
Redirect to OpenID Connect provider. | async def oidc_start(request: aiohttp.web.Request) -> aiohttp.web.Response:
try:
oidc = request.app["oidc_client"].begin("oidc")
except Exception as e:
# This can be caused if config is improperly configured, and
# oidcrp is unable to fetch oidc configuration from the given URL
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def openid_redirect(request):\n request.session['next'] = _get_next(request)\n request.session['openid_provider'] = request.GET.get('openid_provider')\n request.session['socialregistration_connect_object'] = get_object(request.GET)\n\n client = OpenID(\n request,\n 'http%s://%s%s' % (\n ... | [
"0.8395367",
"0.67317396",
"0.6725063",
"0.6613689",
"0.6543737",
"0.6418836",
"0.63803566",
"0.6359176",
"0.633025",
"0.627315",
"0.6260299",
"0.6230966",
"0.62175244",
"0.6199159",
"0.61552745",
"0.61548233",
"0.61204106",
"0.6104589",
"0.6092281",
"0.60429436",
"0.60429436... | 0.58814025 | 32 |
Finalize OIDC login and create a new session with the data from the OIDC provicer. | async def oidc_end(request: aiohttp.web.Request) -> aiohttp.web.Response:
# Response from AAI must have the query params `state` and `code`
if "state" in request.query and "code" in request.query:
request.app["Log"].debug("AAI response contained the correct params.")
params = {"state": request.q... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def oidc_start(request: aiohttp.web.Request) -> aiohttp.web.Response:\n try:\n oidc = request.app[\"oidc_client\"].begin(\"oidc\")\n except Exception as e:\n # This can be caused if config is improperly configured, and\n # oidcrp is unable to fetch oidc configuration from the given... | [
"0.60672337",
"0.59889543",
"0.5987495",
"0.589744",
"0.5842709",
"0.5828801",
"0.5826942",
"0.57812965",
"0.57745713",
"0.570731",
"0.5674367",
"0.5672693",
"0.5672693",
"0.56480044",
"0.5619016",
"0.56117016",
"0.55854535",
"0.55616057",
"0.55613655",
"0.55609727",
"0.55518... | 0.6306145 | 0 |
Create new session cookie for the user. | async def handle_login(
request: aiohttp.web.Request,
) -> typing.Union[aiohttp.web.Response, aiohttp.web.FileResponse]:
response: typing.Union[aiohttp.web.Response, aiohttp.web.FileResponse]
response = aiohttp.web.Response(status=302, reason="Redirection to login")
# Add a cookie for navigating
if... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createCookie(self, sessionid, realmPath=None):\n cookie = Cookie.SimpleCookie()\n cookie[\"session\"] = sessionid\n if realmPath:\n cookie[\"session\"][\"Path\"] = realmPath\n return str(cookie)",
"def set_user_cookie_id():\n #new fresh user\n if not request.cooki... | [
"0.72525936",
"0.7124941",
"0.7083443",
"0.7062573",
"0.69455165",
"0.6611357",
"0.65830433",
"0.65830433",
"0.6502849",
"0.648782",
"0.6434921",
"0.6416773",
"0.637933",
"0.6350128",
"0.6345116",
"0.63331276",
"0.6314953",
"0.62808114",
"0.6279916",
"0.6206115",
"0.61690265"... | 0.0 | -1 |
Display login page and initiate federated keystone authentication. | async def sso_query_begin(
request: typing.Union[aiohttp.web.Request, None]
) -> typing.Union[aiohttp.web.Response, aiohttp.web.FileResponse]:
# Return the form based login page if the service isn't trusted
response: typing.Union[aiohttp.web.Response, aiohttp.web.FileResponse]
if request and setd["oidc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def login():\n return render_template('auth/login.html')",
"def login():\n return render_template('auth/login.html')",
"def login():",
"def login():",
"def login():\n login_page = Login()\n login_page.login_main_page()",
"def login(self):\n\n self.__login_if_required()",
"def login(s... | [
"0.68994683",
"0.68994683",
"0.68386334",
"0.68386334",
"0.68231094",
"0.6799125",
"0.67573166",
"0.67412186",
"0.6670987",
"0.66576177",
"0.66256535",
"0.659779",
"0.6574785",
"0.6571977",
"0.65605384",
"0.65423954",
"0.6526172",
"0.6500901",
"0.64738524",
"0.64659566",
"0.6... | 0.0 | -1 |
Initiate a federated Keystone authentication with OIDC. | async def sso_query_begin_oidc(
request: typing.Union[aiohttp.web.Request, None]
) -> typing.Union[aiohttp.web.Response, aiohttp.web.FileResponse]:
response: typing.Union[aiohttp.web.Response, aiohttp.web.FileResponse]
if request and setd["oidc_enabled"]:
session = await aiohttp_session.get_session... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_keystone_client(self, username, password, tenant_id, auth_url):\n\n __logger__.debug(\"Init Keystone Client\")\n self.keystone_client = KeystoneClient(username=username, password=password, tenant_id=tenant_id,\n auth_url=auth_url)",
"def setUp(... | [
"0.641375",
"0.6165142",
"0.61065006",
"0.608807",
"0.60520416",
"0.5751912",
"0.57354933",
"0.5702204",
"0.5676696",
"0.5632091",
"0.56215346",
"0.5571263",
"0.55176306",
"0.5507107",
"0.54945993",
"0.5489177",
"0.5451096",
"0.5450595",
"0.54504687",
"0.54402965",
"0.5404991... | 0.0 | -1 |
Handle the login procedure with classic POST. | async def credentials_login_end(
request: aiohttp.web.Request,
) -> typing.Union[aiohttp.web.Response, aiohttp.web.FileResponse]:
log = request.app["Log"]
client = request.app["api_client"]
log.info("Got login request with username, password")
form = await request.post()
try:
username ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def login_post():\n\treturn \"LOGIN\"",
"def post(self):\n args = login_parser.parse_args()\n if request.form:\n username = request.form['username']\n password = request.form['password']\n else:\n username = args['username'] # form['username']\n pa... | [
"0.8056917",
"0.7878615",
"0.78097796",
"0.76373166",
"0.76373166",
"0.7398554",
"0.7387662",
"0.7373524",
"0.7298845",
"0.7247156",
"0.7236259",
"0.7218368",
"0.7187571",
"0.71775395",
"0.7155747",
"0.7127159",
"0.7089878",
"0.70238686",
"0.7013341",
"0.70069367",
"0.7006773... | 0.0 | -1 |
Handle the login procedure return from SSO or user from POST. | async def sso_query_end(
request: aiohttp.web.Request,
) -> typing.Union[aiohttp.web.Response, aiohttp.web.FileResponse]:
formdata = await request.post()
# Declare the unscoped token
unscoped = test_token(formdata, request)
return await login_with_token(request, unscoped) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def login_post():\n logger.debug(\"entering function login_post\")\n response = check_user_credentials(request.json)\n logger.debug(\"exiting function login_post\")\n return jsonify(response)",
"def post(self):\n args = login_parser.parse_args()\n if request.form:\n username ... | [
"0.7276632",
"0.7169859",
"0.7103338",
"0.70456195",
"0.6930159",
"0.68893594",
"0.688071",
"0.68596727",
"0.68079287",
"0.68037826",
"0.6794347",
"0.67866087",
"0.6769371",
"0.67304015",
"0.67024994",
"0.6697399",
"0.668939",
"0.668939",
"0.66856444",
"0.6664718",
"0.6663869... | 0.0 | -1 |
Log in a session with token. | async def login_with_token(
request: aiohttp.web.Request,
token: str,
) -> typing.Union[aiohttp.web.Response, aiohttp.web.FileResponse]:
# Establish connection and begin user session
response: typing.Union[aiohttp.web.Response, aiohttp.web.FileResponse]
response = aiohttp.web.Response(
statu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def login(self):\n r = self._login_token()",
"def login():\n token = request.form.get('idtoken')\n if verify_token(token):\n session['logged_in'] = True\n return '', 204\n else:\n return '', 401",
"def _login_token(self):\n data = {\n 'cmd': 'login',\n ... | [
"0.7596102",
"0.72045684",
"0.7020027",
"0.70106757",
"0.70056885",
"0.69228905",
"0.69088507",
"0.68233377",
"0.6813642",
"0.6765508",
"0.67347586",
"0.6731763",
"0.6728156",
"0.67254066",
"0.67147374",
"0.66933644",
"0.66545373",
"0.66474944",
"0.66474944",
"0.6645271",
"0.... | 0.63838345 | 47 |
Lock down to a specific project. | async def handle_project_lock(request: aiohttp.web.Request) -> aiohttp.web.Response:
log = request.app["Log"]
log.info("Call for locking down the project.")
session = await aiohttp_session.get_session(request)
project = request.match_info["project"]
# Ditch all projects that aren't the one specif... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def StopProject (paser):\n\tModKeyProjectProtection = Project.status()\t\t#Status del proyecto\n\n\tif ModKeyProjectProtection == False:\n\t\trepositorio.stopChanges()",
"def f_unlock(self):\n self._locked = False",
"def unlock(project, env_spec_name):\n failed = _check_problems(project)\n if fail... | [
"0.6348069",
"0.6022437",
"0.6013928",
"0.59228545",
"0.5799038",
"0.5796983",
"0.5793839",
"0.57587075",
"0.5754687",
"0.5732977",
"0.56677544",
"0.5666943",
"0.5657372",
"0.56248546",
"0.56235677",
"0.5605617",
"0.5602566",
"0.5585458",
"0.55657995",
"0.55327934",
"0.552069... | 0.70834726 | 0 |
Properly kill the session for the user. | async def handle_logout(request: aiohttp.web.Request) -> aiohttp.web.Response:
log = request.app["Log"]
client = request.app["api_client"]
if not setd["set_session_devmode"]:
try:
session = await aiohttp_session.get_session(request)
log.info(f"Killing session {session.identit... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kill_session(user):\n\n # Destroy cookie\n user.cookie = None\n user.cookie_expiration = datetime.now()\n\n # Commit\n db.session.add(user)\n db.session.commit()",
"def kill(self):\n self.rpc.call(MsfRpcMethod.SessionMeterpreterSessionKill, [self.sid])",
"def do_logout():\n del ... | [
"0.80263066",
"0.77319854",
"0.7595093",
"0.7439574",
"0.733163",
"0.72445107",
"0.720937",
"0.7187225",
"0.7032344",
"0.7017926",
"0.69207746",
"0.6849991",
"0.6842349",
"0.68047076",
"0.6778811",
"0.6765883",
"0.6765883",
"0.6765883",
"0.67380124",
"0.67192554",
"0.6714616"... | 0.0 | -1 |
Parse projects from userinfo. | def _get_projects_from_userinfo(
userinfo: typing.Dict[str, typing.Any],
) -> typing.List[typing.Any] | None:
if "sdConnectProjects" in userinfo:
# Remove the possibly existing "project_" prefix
projects = [
p.removeprefix("project_") for p in userinfo["sdConnectProjects"].split(" ")... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_user_project(src_url: str) -> tuple:\n # TODO: improve the splitting with regex .. this way it misses some projects\n gh_user, gh_project = src_url.rsplit('/', 2)[-2:]\n\n return gh_user, gh_project",
"def get_user_projects(username):\n\n tx = cypher_transaction()\n query = \"\... | [
"0.638",
"0.6257913",
"0.6091854",
"0.5990585",
"0.5930123",
"0.5728555",
"0.5728555",
"0.570004",
"0.5605483",
"0.5585763",
"0.55782217",
"0.5531046",
"0.5516802",
"0.5503669",
"0.5475661",
"0.5474088",
"0.5468539",
"0.5466969",
"0.53591806",
"0.53487664",
"0.53265506",
"0... | 0.77144426 | 0 |
Transform the IO data into the requested format and projection if necessary. | def transform_data(self, outformat=None, epsg=None):
out_data = geopandas.GeoDataFrame.copy(self.data)
if epsg and str(self.get_epsg()) != epsg:
out_data[out_data.geometry.name] = \
self.data.geometry.to_crs(epsg=epsg)
out_data.crs = fiona.crs.from_epsg(epsg)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def file_converter(self, **kwds):\n if (self.reformat == 'zarr'):\n # output zarr file\n self.HDF5_to_zarr(**kwds)\n elif (self.reformat == 'HDF5'):\n # output rechunked HDF5 file\n self.HDF5_to_HDF5(**kwds)\n # elif (reformat == 'JPL'):\n # ... | [
"0.5569975",
"0.5505671",
"0.5388421",
"0.5375472",
"0.5293689",
"0.52527857",
"0.5248115",
"0.51841456",
"0.517878",
"0.51682824",
"0.5125906",
"0.50980085",
"0.50823504",
"0.5060049",
"0.50447756",
"0.49652284",
"0.49562937",
"0.4953078",
"0.49232402",
"0.49127552",
"0.4909... | 0.5966752 | 0 |
Create a FeatureIO object | def __init__(self, features=None, **kwargs):
super(FeatureIO, self).__init__(**kwargs)
self.features = features | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, features=None):\n self.features = features",
"def construct(data_dir, fname, X=None, normalize=False, _type='sparse'):\n if _type == 'sparse':\n return SparseFeatures(data_dir, fname, X, normalize)\n elif _type == 'dense':\n return DenseFeatures(data_dir, fname, X, n... | [
"0.649636",
"0.63637304",
"0.6343216",
"0.63154984",
"0.6243798",
"0.62359333",
"0.62053484",
"0.6069705",
"0.6026877",
"0.6018775",
"0.6010477",
"0.59540987",
"0.5934894",
"0.59044176",
"0.5893953",
"0.58894765",
"0.58461726",
"0.583732",
"0.58244425",
"0.58146846",
"0.58110... | 0.7322272 | 0 |
Parse the FeatureIO.features and return as a GeoDataFrame or GeoJSON | def read(self, format=None, epsg=None):
if not format:
format = self.default_output
if self.data is None and self.features:
if type(self.features) == str:
self.features = json.loads(self.features)
features = self.features
if 'type' in feat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getFeatures(gdf):\n import json\n return [json.loads(gdf.to_json())['features'][0]['geometry']]",
"def getFeatures(gdf):\n import json\n return [json.loads(gdf.to_json())['features'][0]['geometry']]",
"def getFeatures(gdf):\n import json\n return [json.loads(gdf.to_json())['features'][0][... | [
"0.7279601",
"0.7279601",
"0.7279601",
"0.72584164",
"0.720255",
"0.71832156",
"0.7088852",
"0.66288954",
"0.6549225",
"0.64755887",
"0.6387266",
"0.6373814",
"0.63635164",
"0.6338724",
"0.6322752",
"0.63146687",
"0.6307491",
"0.6301861",
"0.62509245",
"0.62180096",
"0.621699... | 0.71520513 | 6 |
Reset the IO data to None | def delete(self):
self.data = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset_data(self):\n self.data = None",
"def reset(self):\n self.temp_data.clear()",
"def reset_output(self):\r\n self.output.seek(0)\r\n self.output.truncate(0)",
"def clear(self):\n self._out = None",
"def reset_io(self) -> None:\n\n self.serial.write(b\"z!\")... | [
"0.7848442",
"0.7181984",
"0.69473",
"0.6905416",
"0.6878329",
"0.68388647",
"0.68236834",
"0.6814159",
"0.68113273",
"0.6800893",
"0.6769905",
"0.6764747",
"0.67208916",
"0.6711561",
"0.66598177",
"0.66127276",
"0.6574715",
"0.65620214",
"0.6531298",
"0.6508345",
"0.64923096... | 0.0 | -1 |
Read vector data from a file (JSON, Shapefile, etc) | def read(self, format=None, epsg=None):
if not format:
format = self.default_output
if self.ext not in formats.VECTOR:
raise UnsupportedFormatException(
"Only the following vector formats are supported: {}".format(
','.join(formats.VECTOR)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_vector_file(fname):\n return np.genfromtxt(fname)",
"def read_value(file_obj, version, vectors):\n type_key, data = common.read_generic_typed_data(file_obj)\n\n return loads_value(type_key, data, version, vectors)",
"def load_pretrained_vectors(vectors):\n with open(vectors) as f:\n ... | [
"0.7258415",
"0.6939972",
"0.68744355",
"0.6670833",
"0.6651395",
"0.6568607",
"0.6519597",
"0.6446601",
"0.64014494",
"0.63939184",
"0.6376528",
"0.6256297",
"0.6248714",
"0.6245435",
"0.6237502",
"0.6200828",
"0.6200563",
"0.6152685",
"0.6100003",
"0.60942775",
"0.6087425",... | 0.6674612 | 3 |
Write data (assumed geopandas) to geojson or shapefile | def write(self, filename=None, as_type='json'):
if not filename:
filename = self.uri
self.create_output_dir(filename)
if as_type == 'json':
with open(filename, 'w') as outfile:
outfile.write(self.transform_data(outformat=formats.JSON))
elif as_type... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_geojson(vec:gpd.GeoDataFrame, dest):\n\t\tdest = str(dest)\n\n\t\t# WGS 84\n\t\t#vec = vec.to_crs({'init': 'epsg:4326'})\n\n\t\tif os.path.isfile(dest):\n\t\t\tos.remove(dest)\n\t\t\t\n\t\tvec.to_file(dest, driver='GeoJSON', encoding='utf-8')",
"def save_to_geojson(self, topology_map, filename):",
"d... | [
"0.7644244",
"0.7486198",
"0.7072212",
"0.69965905",
"0.66923374",
"0.6669104",
"0.6602326",
"0.6577784",
"0.65675855",
"0.6484299",
"0.63121295",
"0.6291043",
"0.62831575",
"0.6254037",
"0.6212789",
"0.6133664",
"0.61290187",
"0.60963386",
"0.6094165",
"0.6067398",
"0.602487... | 0.5382228 | 90 |
Apply filters to the dataset | def filter_data(self):
self.data = filter_pandas(self.data, self.filters) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_filters(self, filters):\n self._data = self.model.objects.filter(**filters)",
"def filter(self, filters):",
"def filter_data(self, data):\n for f in self.filters:\n data = getattr(self, f)(data)\n return data",
"def filter_data(data,filters):\n final_filter = pd.S... | [
"0.76852214",
"0.7679097",
"0.75132066",
"0.7299479",
"0.7155812",
"0.7077142",
"0.6961737",
"0.6916808",
"0.68126285",
"0.67535377",
"0.6718354",
"0.66857404",
"0.6545745",
"0.6495445",
"0.6494822",
"0.6489582",
"0.6474239",
"0.645313",
"0.645255",
"0.6376576",
"0.6371919",
... | 0.7998662 | 0 |
Read data from a raster dataset | def read(self, as_numpy_array=False, as_single_band=True,
old_nodata=None, new_nodata=None, epsg=None):
if self.ext not in formats.RASTER:
raise UnsupportedFormatException(
"Only the following raster formats are supported: {}".format(
','.join(formats... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_raster (self, filename):\n raster = gdal.Open (filename)\n band = raster.GetRasterBand(1)\n x = band.ReadAsArray () \n nodata_val = band.GetNoDataValue () # get the missing data flag\n x [x == nodata_val] = np.nan # set missing data properly\n re... | [
"0.69494873",
"0.69347304",
"0.68553156",
"0.6753696",
"0.65782833",
"0.65512747",
"0.65204966",
"0.6435528",
"0.64259845",
"0.6375671",
"0.6340665",
"0.6337834",
"0.6337424",
"0.61567295",
"0.61204016",
"0.6108158",
"0.61068714",
"0.6098699",
"0.6089202",
"0.60586715",
"0.60... | 0.54776746 | 94 |
Create an IO object containing a GaiaProcess to run | def __init__(self, process=None, parent=None, **kwargs):
super(ProcessIO, self).__init__(**kwargs)
self.process = process
self.parent = parent
self.default_output = process.default_output | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new_process() -> Process:\n return multiprocessing.Process()",
"async def open_process(\r\n cls, args: \"Union[str, List[str]]\", env_additions: Dict[str, str] = {}\r\n ) -> \"AsyncIterator[Expect]\":\r\n printer_channels: (\r\n \"Tuple[MemorySendChannel[bytes], MemoryReceiveCh... | [
"0.63116145",
"0.57088315",
"0.56168306",
"0.55841285",
"0.5541996",
"0.5525313",
"0.5505391",
"0.5478076",
"0.5466999",
"0.5392637",
"0.53815526",
"0.53630763",
"0.533476",
"0.5331508",
"0.53179747",
"0.5307854",
"0.5251125",
"0.5241876",
"0.5231719",
"0.52115893",
"0.520870... | 0.60687447 | 1 |
Return the EPSG code of the dataset | def get_epsg(self):
if hasattr(self.process, 'output') and self.process.output.data \
is not None:
return self.process.output.get_epsg()
else:
return self.process.inputs[0].get_epsg() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _epsg(self):\n info = self._info['coordinateSystem']['wkt'].rsplit('\"EPSG\",', 1)[-1]\n return int(re.findall(r\"\\d+\", info)[0])",
"def Get_epsg(g, extension = 'tiff'):\n try:\n if extension == 'tiff':\n # Get info of the dataset that is used for transforming\n ... | [
"0.6720755",
"0.61444277",
"0.61156243",
"0.6113944",
"0.6069787",
"0.58153844",
"0.5619182",
"0.55280834",
"0.5330134",
"0.5246141",
"0.52392507",
"0.5231817",
"0.5206324",
"0.52020574",
"0.5200296",
"0.5191889",
"0.5170663",
"0.5132812",
"0.5132812",
"0.50836676",
"0.505531... | 0.0 | -1 |
Return the process output dataset | def read(self, epsg=None):
if self.data is None:
self.process.compute()
self.data = self.process.output.data
out_data = self.data
if epsg and self.get_epsg() != epsg:
out_data = reproject(self.data, epsg)
return out_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def outputs(self):\n return {\"path_to_dtb_evaluation_result\": File_IO(\n self.node.outputs[0])}",
"def get_output_data(self, name='0'):\n if self.dirty:\n self.run()\n\n return self._output_data.get(name)",
"def output_data(self):\n with open(self.output_... | [
"0.64601994",
"0.63788813",
"0.63788176",
"0.63515645",
"0.6285533",
"0.6242062",
"0.6201643",
"0.61590755",
"0.6152272",
"0.61005825",
"0.60810196",
"0.60395235",
"0.60348016",
"0.60348016",
"0.60348016",
"0.60348016",
"0.60348016",
"0.60348016",
"0.6032868",
"0.6019135",
"0... | 0.0 | -1 |
Instantiate a PostgisIO object for querying a PostGIS table | def __init__(self, table, **kwargs):
super(PostgisIO, self).__init__(**kwargs)
self.table = table
self.host = kwargs.get('host') or gaia.config['gaia_postgis']['host']
self.dbname = kwargs.get(
'dbname') or gaia.config['gaia_postgis']['dbname']
self.user = kwargs.get(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createPostgisConnection(dbFormat, dbHost, dbName, dbSchema, dbUser, dbPWD):\r\n\r\n pg = ogr.GetDriverByName(dbFormat)\r\n if pg is None:\r\n raise RuntimeError('{0} driver not available'.format(dbFormat))\r\n conn = pg.Open(\"PG:dbname='{0}' user='{1}' password='{2}'\".format(dbName, dbUser, d... | [
"0.6855516",
"0.67369133",
"0.6698161",
"0.64499944",
"0.62568384",
"0.6199102",
"0.603529",
"0.60263604",
"0.5996107",
"0.590071",
"0.5864445",
"0.58015627",
"0.56797826",
"0.5659731",
"0.56208915",
"0.55889374",
"0.55734766",
"0.5566591",
"0.5559148",
"0.55440044",
"0.54781... | 0.68292403 | 1 |
Create and return a SQLAlchemy engine object | def get_engine(self, connection_string):
if connection_string not in sqlengines:
sqlengines[connection_string] = create_engine(
self.get_connection_string())
return sqlengines[connection_string] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_engine(self):\n connection_string = f'postgresql://{self.user}:{self.password}@{self.host}/{self.database_name}'\n return create_engine(connection_string)",
"def get_engine(db_params: Dict[str, str]) -> sa.engine:\r\n db_uri = get_uri(db_params)\r\n return sa.create_engine(db_uri)"... | [
"0.81582",
"0.8151789",
"0.8096098",
"0.8074667",
"0.78949046",
"0.7888775",
"0.78016627",
"0.7694161",
"0.7633024",
"0.7619185",
"0.75568897",
"0.7526892",
"0.75230956",
"0.75139517",
"0.751324",
"0.7408494",
"0.7328666",
"0.73017824",
"0.7291083",
"0.7289729",
"0.7289729",
... | 0.0 | -1 |
Make sure that all PostgisIO columns exist in the actual table | def verify(self):
for col in self.columns:
if col not in self.table_obj.columns.keys():
raise Exception('{} column not found in {}'.format(
col, self.table_obj)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def verify(self):\n for col in self._columns:\n if col not in self._table_obj.columns.keys():\n raise GaiaException('{} column not found in {}'.format(\n col, self._table_obj))",
"def test_missing_column(self):\n df = pd.DataFrame({\"notlat\": [1, 2, 3],... | [
"0.6435384",
"0.57924956",
"0.5753893",
"0.57230234",
"0.56842715",
"0.5627222",
"0.5578372",
"0.55553114",
"0.5551072",
"0.5520966",
"0.55202276",
"0.55151975",
"0.54960734",
"0.54696405",
"0.54570687",
"0.5438926",
"0.5419409",
"0.5386217",
"0.53728265",
"0.53636533",
"0.53... | 0.6008417 | 1 |
Get connection string based on host, dbname, username, password | def get_connection_string(self):
auth = ''
if self.user:
auth = self.user
if self.password:
auth = auth + ':' + self.password
if auth:
auth += '@'
conn_string = 'postgresql://{auth}{host}/{dbname}'.format(
auth=auth, host=self.host,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_connection_string(self):\n auth = ''\n if self._user:\n auth = self._user\n if self._password:\n auth = auth + ':' + self._password\n if auth:\n auth += '@'\n conn_string = 'postgresql://{auth}{host}/{dbname}'.format(\n auth=aut... | [
"0.7930437",
"0.7801941",
"0.76585364",
"0.7592892",
"0.75295997",
"0.7524706",
"0.74851537",
"0.73222303",
"0.72575486",
"0.7244134",
"0.72296304",
"0.7219336",
"0.7214253",
"0.71637756",
"0.70156115",
"0.6987775",
"0.69751585",
"0.6895092",
"0.6813161",
"0.68097425",
"0.680... | 0.7869148 | 1 |
Get the EPSG code of the data | def get_epsg(self):
return self.epsg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _epsg(self):\n info = self._info['coordinateSystem']['wkt'].rsplit('\"EPSG\",', 1)[-1]\n return int(re.findall(r\"\\d+\", info)[0])",
"def Get_epsg(g, extension = 'tiff'):\n try:\n if extension == 'tiff':\n # Get info of the dataset that is used for transforming\n ... | [
"0.7254906",
"0.64514357",
"0.6360719",
"0.6358505",
"0.6047866",
"0.5811747",
"0.57437235",
"0.5492534",
"0.54540646",
"0.54467815",
"0.5446062",
"0.538035",
"0.53101516",
"0.5284902",
"0.526871",
"0.52095604",
"0.520738",
"0.51227933",
"0.5107158",
"0.5104999",
"0.5089013",... | 0.0 | -1 |
Use SQLALchemy reflection to gather data on the table, including the geometry column, geometry type, and EPSG code, and assign to the PostgisIO object's attributes. | def get_table_info(self):
epsg = None
meta = MetaData()
table_obj = Table(self.table, meta,
autoload=True, autoload_with=self.engine)
if not self.columns:
self.columns = table_obj.columns.keys()
geo_cols = [(col.name, col.type) for col in tab... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_table_info(self):\n epsg = None\n meta = MetaData()\n table_obj = Table(self._table, meta,\n autoload=True, autoload_with=self._engine)\n if not self._columns:\n self._columns = table_obj.columns.keys()\n geo_cols = [(col.name, col.type... | [
"0.70732105",
"0.68428886",
"0.6452087",
"0.624894",
"0.61648315",
"0.61188686",
"0.61173916",
"0.60497487",
"0.5862017",
"0.5860301",
"0.5783066",
"0.5763595",
"0.5719233",
"0.5694905",
"0.5623751",
"0.5593062",
"0.55429846",
"0.55166006",
"0.5488583",
"0.54816383",
"0.54250... | 0.71974653 | 0 |
Get the geometry type of the data | def get_geometry_type(self):
return self.geometry_type | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_geometry_type(self):\n return self._geometry_type",
"def geometry_type(self) -> ir.StringValue:\n return ops.GeoGeometryType(self).to_expr()",
"def geom_type(self): # -> str:\n ...",
"def geometry_type(number):\n try:\n return GDAL_GEOMETRY_TYPES[number]\n ... | [
"0.8112586",
"0.7843717",
"0.7644851",
"0.76259863",
"0.7605449",
"0.7579384",
"0.68932897",
"0.6887345",
"0.66878814",
"0.6671334",
"0.6600797",
"0.6596621",
"0.6585204",
"0.6499065",
"0.6425121",
"0.641309",
"0.6407867",
"0.6349588",
"0.6349588",
"0.6349588",
"0.6292295",
... | 0.8192831 | 0 |
Formulate a query string and parameter list based on the table name, columns, and filter | def get_query(self):
columns = ','.join(['"{}"'.format(x) for x in self.columns])
query = 'SELECT {} FROM "{}"'.format(columns, self.table)
filter_params = []
if self.filters:
filter_sql, filter_params = filter_postgis(self.filters)
query += ' WHERE {}'.format(fil... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_query(self):\n columns = ','.join(['\"{}\"'.format(x) for x in self._columns])\n query = 'SELECT {} FROM \"{}\"'.format(columns, self._table)\n filter_params = []\n if self._filters:\n filter_sql, filter_params = filter_postgis(self._filters)\n query += ' W... | [
"0.6481889",
"0.6394177",
"0.6319321",
"0.62386817",
"0.6229315",
"0.6171959",
"0.6170874",
"0.6115932",
"0.61042583",
"0.6103268",
"0.61031204",
"0.6026723",
"0.6023874",
"0.6014606",
"0.6011875",
"0.6009841",
"0.5997763",
"0.59938264",
"0.5971514",
"0.597093",
"0.5968318",
... | 0.6632733 | 0 |
Load the table data into a GeoDataFrame, and return as a GeoDataFrame or GeoJSON object | def read(self, format=None, epsg=None):
if self.data is None:
query, params = self.get_query()
self.data = df_from_postgis(self.engine, query, params,
self.geom_column, self.epsg)
return self.transform_data(outformat=format, epsg=epsg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def geojson2postgis(self, filepath, table_name, geo_type):\n map_data = gpd.GeoDataFrame.from_file(filepath)\n # Maybe you want to change link address\n link = \"postgresql://{0}:{1}@{3}:5432/{2}\".format(self.username, self.password, self.dbname, self.host)\n engine = create_engine(lin... | [
"0.65196556",
"0.6514663",
"0.6500165",
"0.6484223",
"0.6471508",
"0.63549626",
"0.6187911",
"0.61573",
"0.60074055",
"0.59858817",
"0.5967683",
"0.5962735",
"0.5955036",
"0.5944749",
"0.5936001",
"0.591422",
"0.59009284",
"0.5860339",
"0.58540696",
"0.5840662",
"0.582958",
... | 0.5821095 | 21 |
Run a PostGIS query and return results as a GeoDataFrame | def df_from_postgis(engine, query, params, geocolumn, epsg):
data = geopandas.GeoDataFrame.from_postgis(
query,
engine,
geom_col=geocolumn,
crs={'init': 'epsg:{}'.format(epsg)},
params=params)
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def queryToPDTable(postgreSql_selectQuery):\n\n import os\n import psycopg2\n import pandas as pd\n\n #basic query function to the database using environmental variables for\n #the user name and password\n conn=psycopg2.connect(host=\"postgis1\",\n dbname=\"sdad\",\n ... | [
"0.68622106",
"0.6783693",
"0.6631549",
"0.65065295",
"0.64609385",
"0.6398335",
"0.63537514",
"0.63044345",
"0.629543",
"0.6189722",
"0.6184706",
"0.61680967",
"0.6097106",
"0.6089787",
"0.60863835",
"0.60695153",
"0.60299134",
"0.6028463",
"0.6016495",
"0.5989992",
"0.59744... | 0.83570623 | 0 |
Reproject a dataset to the specified EPSG code | def reproject(dataset, epsg):
dataclass = dataset.__class__.__name__
# Run appropriate reprojection method
if dataclass == 'GeoDataFrame':
repro = geopandas.GeoDataFrame.copy(dataclass)
repro[repro.geometry.name] = repro.geometry.to_crs(epsg=epsg)
repro.crs = fiona.crs.from_epsg(epsg... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reproject_dataset_example(dataset, dataset_example, method=1):\n # open dataset that must be transformed\n try:\n if (os.path.splitext(dataset)[-1] == '.tif' or os.path.splitext(dataset)[-1] == '.TIF'):\n g = gdal.Open(dataset)\n else:\n g = dataset\n except:\n ... | [
"0.6619954",
"0.62397677",
"0.61324847",
"0.60862654",
"0.60619205",
"0.6057335",
"0.6052431",
"0.60024583",
"0.5995381",
"0.5954171",
"0.590265",
"0.58267164",
"0.58260304",
"0.57626706",
"0.5728477",
"0.56918794",
"0.5690801",
"0.5552014",
"0.55259335",
"0.5460811",
"0.5403... | 0.7723594 | 0 |
Convert raster output to numpy array output | def raster_to_numpy_array(raster_data, as_single_band=True,
old_nodata=None, new_nodata=None):
bands = as_single_band + (1 - as_single_band) * raster_data.RasterCount
nrow = raster_data.RasterYSize
ncol = raster_data.RasterXSize
dims = (bands, nrow, ncol)
out_data_array = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def raster_to_array(input_raster):\n\n raster = gdal.Open(input_raster)\n band = raster.GetRasterBand(1)\n converted_array = band.ReadAsArray()\n\n return converted_array",
"def convert_raster_to_array(input_raster_path, raster=None, band=1):\n # print \"input raster path\", input_raster_path\n ... | [
"0.7566383",
"0.7091297",
"0.6795634",
"0.67187595",
"0.65891033",
"0.6584043",
"0.6519365",
"0.64970326",
"0.6492841",
"0.64761984",
"0.64678997",
"0.6418959",
"0.64067036",
"0.6209067",
"0.6150287",
"0.6082056",
"0.6037599",
"0.6036444",
"0.59958696",
"0.59908175",
"0.59660... | 0.60263014 | 18 |
Get appropriate DataFrame column name and readable axis label. | def _axis_labels(self, data_name: str) -> Tuple[str, str]:
# Single activity attributes (column name must be present in summary dataframe)
if data_name == 'distance':
if self.config.distance_unit == 'km':
return 'distance_2d_km', 'Distance (km)'
elif self.config.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_label ( self ):\n if self._label is not None:\n return self._label\n return 'Column %d' % (self.index + 1)",
"def _label(self, column):\n # XXX\n return column",
"def _get_column_name(df, name='agg'):\n while name in df.columns:\n name += '_'\n retur... | [
"0.6837961",
"0.66392434",
"0.6530014",
"0.6514728",
"0.6507803",
"0.6419064",
"0.636666",
"0.63305116",
"0.62810653",
"0.62264484",
"0.62251216",
"0.62186813",
"0.62026006",
"0.61959815",
"0.61305",
"0.6121797",
"0.6063063",
"0.6025661",
"0.60128766",
"0.60128766",
"0.596436... | 0.62674105 | 9 |
Generate the main scatter plot figure. | def main_scatter_fig(self, x: str, y: str) -> go.Figure:
x_col, x_label = self._axis_labels(x)
y_col, y_label = self._axis_labels(y)
fig = px.scatter(
self.summary,
x=x_col,
y=y_col,
labels={
x_col: x_label,
y_col: y... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main_scatterplot(self) -> Component:\n logger.debug('Generating main scatterplot.')\n\n x_dropdown = dcc.Dropdown('overview_main_scatterplot_x_dropdown', options=[\n {'label': 'Distance', 'value': 'distance'},\n {'label': 'Average speed', 'value': 'mean_speed'},\n ... | [
"0.7791738",
"0.74087775",
"0.72489434",
"0.71679926",
"0.69586086",
"0.6956765",
"0.69084084",
"0.6881678",
"0.68715435",
"0.67730665",
"0.67312944",
"0.67114747",
"0.66551024",
"0.6645001",
"0.6621074",
"0.6581735",
"0.6570473",
"0.6557734",
"0.6556813",
"0.65257436",
"0.65... | 0.6566985 | 17 |
A configurable scatterplot of all activities. | def main_scatterplot(self) -> Component:
logger.debug('Generating main scatterplot.')
x_dropdown = dcc.Dropdown('overview_main_scatterplot_x_dropdown', options=[
{'label': 'Distance', 'value': 'distance'},
{'label': 'Average speed', 'value': 'mean_speed'},
{'label': ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_scatter(self):\n plt.scatter(self.a1[:, 0], self.a1[:, 1], c=\"red\", alpha=0.5, s=10)\n plt.scatter(self.a2[:, 0], self.a2[:, 1], c=\"blue\", alpha=0.5, s=10)\n plt.scatter(0, 0, marker=\"D\", c=\"black\", alpha=0.8)\n plt.scatter(2, 2, marker=\"D\", c=\"black\", alpha=0.8)\n ... | [
"0.67238843",
"0.6708577",
"0.66642416",
"0.6630281",
"0.630712",
"0.63052666",
"0.6298917",
"0.6278833",
"0.6265205",
"0.6168853",
"0.6166783",
"0.6123382",
"0.61222416",
"0.6115842",
"0.6083699",
"0.60783607",
"0.607288",
"0.6068224",
"0.6062484",
"0.6058355",
"0.6018583",
... | 0.7072408 | 0 |
Generate the chart figure for the main time plot. | def main_time_fig(self, freq: str, y: str) -> go.Figure:
if freq == 'weekly':
df = self.activity_manager.metadata_weekly_time_series()
date_label = 'Week of'
elif freq == 'monthly':
df = self.activity_manager.metadata_monthly_time_series()
date_label = 'Mo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main_time_chart(self) -> Component:\n logger.debug('Generating time graph.')\n df = self.activity_manager.metadata_weekly_time_series(activity_type='run')\n\n freq_dropdown = dcc.Dropdown('overview_main_time_chart_freq_dropdown', options=[\n {'label': 'Weekly', 'value': 'weekly'... | [
"0.7703338",
"0.68641454",
"0.6779474",
"0.6707098",
"0.65798086",
"0.65385634",
"0.65024126",
"0.6488374",
"0.6484134",
"0.64522904",
"0.6446261",
"0.6431686",
"0.63733166",
"0.63720703",
"0.6272359",
"0.62661344",
"0.6259788",
"0.6258643",
"0.62565494",
"0.62492335",
"0.623... | 0.7200148 | 1 |
A line chart plotting some selected value over time. | def main_time_chart(self) -> Component:
logger.debug('Generating time graph.')
df = self.activity_manager.metadata_weekly_time_series(activity_type='run')
freq_dropdown = dcc.Dropdown('overview_main_time_chart_freq_dropdown', options=[
{'label': 'Weekly', 'value': 'weekly'},
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def value_line(self):\n marks = self._get_marks(False)\n marks['Val'] = self.data['Value']\n fig = plt.figure(figsize=(4,2), dpi=200)\n fig.patch.set_facecolor('#ececec')\n ax = fig.add_subplot(111)\n ax.plot(self.data['Value'], alpha=0.8, lw=1.2, color=\"green\", label='V... | [
"0.6986507",
"0.66361314",
"0.65602136",
"0.65592897",
"0.65517896",
"0.65218306",
"0.6515136",
"0.6431805",
"0.6410622",
"0.6358669",
"0.6323132",
"0.6321626",
"0.62683046",
"0.6235126",
"0.6228971",
"0.6213806",
"0.62032735",
"0.61976856",
"0.6170221",
"0.61547273",
"0.6136... | 0.0 | -1 |
Generate all graphs based on the contents of config.overview_graphs (which is in turn generated based on the contents of test_overview_graphs.json). See docs/graphs.rst for help on how test_overview_graphs.json is interpreted. | def custom_graphs(self) -> List[Component]:
graphs = []
# TODO: Figure this out
for i, go_data in enumerate(self.config.overview_graphs):
groupby = go_data.pop('groupby', None)
agg = go_data.pop('agg', None)
if groupby and agg:
data = getattr(s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_statistics_plots(graph_name, graph_steps):\n df_final_situation = pd.DataFrame(columns=[\"type\", \"value\"])\n df_step = pd.DataFrame(columns=[\"type\", \"step\", \"value\"])\n df_exposed = pd.DataFrame(columns=[\"step\", \"type\", \"value\"])\n\n st.markdown(\"\")\n\n for i in range(g... | [
"0.57757014",
"0.571238",
"0.56258476",
"0.5602885",
"0.55782235",
"0.5502178",
"0.5366498",
"0.53558487",
"0.53391075",
"0.5319257",
"0.5311666",
"0.52981985",
"0.5294715",
"0.5271559",
"0.525541",
"0.5254248",
"0.5241613",
"0.5230479",
"0.522659",
"0.52127856",
"0.52093905"... | 0.62306833 | 0 |
Extracts square patches of patch_dim by patch_dim from the data. Returns a patch_dim^2 by numpatches matrix. | def extract_patches(data,patch_dim):
m = data.shape[0]
im_x = data.shape[1]
im_y = data.shape[2]
assert im_x%float(patch_dim)==0 and im_y%float(patch_dim)==0, \
"patch_size must divide x and y dimensions of image"
numpatchs = m*(im_x/patch_dim)*(im_y/patch_dim)
patch_size = patch_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patches_sampling(self, image, patch_size, stride):\n h, w = image.shape[2:4]\n patches = []\n for i in range(0, h - patch_size + 1, stride):\n for j in range(0, w - patch_size + 1, stride):\n patches.append(image[:, :, i:i + patch_size, j:j + patch_size])\n ... | [
"0.6891319",
"0.6779682",
"0.66917896",
"0.6450875",
"0.64256436",
"0.6412834",
"0.6366795",
"0.63452667",
"0.6342837",
"0.6332445",
"0.63294715",
"0.6287567",
"0.62787473",
"0.6240202",
"0.6159606",
"0.6138685",
"0.606784",
"0.60129994",
"0.597121",
"0.5943119",
"0.59225255"... | 0.7664922 | 0 |
Subtract DC component (mean) from each patch, and contrast normalize (divide by std dev). | def normalize(data):
p_means = np.mean(data,axis=0)
p_vars = np.var(data,axis=0)
# subtract dc component
data = data-p_means
# contrast normalize
data = data/np.sqrt(p_vars+10) # plus 10 to account for small variances
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _normalize_patches(patches):\n patches = array_ops.concat(patches, 0)\n mean, variance = nn.moments(patches, [1, 2, 3], keep_dims=True)\n patches = (patches - mean) / math_ops.sqrt(variance)\n return array_ops.reshape(patches, [array_ops.shape(patches)[0], -1])",
"def color_normalize(x, mean, std):\n ... | [
"0.6298055",
"0.5891793",
"0.58737147",
"0.58737147",
"0.5847109",
"0.5814175",
"0.57039946",
"0.5647964",
"0.5528056",
"0.5524043",
"0.55056757",
"0.5503953",
"0.54944885",
"0.5488362",
"0.54770255",
"0.5466837",
"0.5453476",
"0.54484415",
"0.53919643",
"0.53899807",
"0.5378... | 0.68733734 | 0 |
Makes ZCA whitening matrix (U(V+epsilonI)^(1/2)U^T), where U is the matrix of orthogonal eigenvectors and V the corresponding eigenvalues from eigenvalue decomposition of the covariance matrix for the data. | def whiten(data):
from numpy.linalg import eig
eps = 0.01
# covariance matrix
Sigma = np.cov(data)
# eigenvalue decomposition
V,U = eig(Sigma)
W = U.dot(np.diag((V+eps)**(-0.5)).dot(U.transpose()))
return W | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def zca_whitening_matrix(X):\n # Covariance matrix [column-wise variables]: Sigma = (X-mu)' * (X-mu) / N\n sigma = np.cov(X, rowvar=True) # [M x M]\n # Singular Value Decomposition. X = U * np.diag(S) * V\n U,S,V = np.linalg.svd(sigma)\n # U: [M x M] eigenvectors of sigma.\n # S: [M x 1] ... | [
"0.76188344",
"0.69833094",
"0.69694257",
"0.668602",
"0.6582816",
"0.6568755",
"0.65559185",
"0.6485466",
"0.64088285",
"0.63796425",
"0.58479804",
"0.58176255",
"0.57855535",
"0.5762374",
"0.5539313",
"0.5447399",
"0.54079866",
"0.5402104",
"0.5383259",
"0.53804785",
"0.536... | 0.7267214 | 1 |
Extracts patches from data and whitens the patches. Returns whitened patches and whitening matrix. | def process(data,patch_dim,W=None):
# pull patches from image
patches = extract_patches(data,patch_dim)
# remove dc component and contrast normalize
patches = normalize(patches)
if W is None:
# build whitening matrix
W = whiten(patches)
# apply whitening
patches = W.dot(p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_patches(data, idxs=None, patch_size=3, min_val=0, ctx_radius=(3,5,7), economy_patch=True, mean=False):\n # catch errors and setup the initialize values of required variables\n if idxs is None:\n idxs = np.where(data > min_val)\n if patch_size % 2 != 1 and patch_size > 0:\n raise ... | [
"0.6271824",
"0.6121198",
"0.5840078",
"0.56840724",
"0.5544035",
"0.5534577",
"0.55345744",
"0.5533361",
"0.55265146",
"0.5479646",
"0.5470446",
"0.5416568",
"0.5400108",
"0.53770685",
"0.5371271",
"0.532619",
"0.531805",
"0.5317908",
"0.5315576",
"0.5302089",
"0.5280466",
... | 0.7724127 | 0 |
Convert rgb image to grayscale | def rgb2gray(rgb):
r, g, b = rgb[...,0], rgb[...,1], rgb[...,2]
gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
return gray | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rgb2gray(img):\r\n return 0.2989 * img[..., 0] + 0.587 * img[..., 1] + 0.114 * img[..., 2]",
"def rgb2grayscale(image):\r\n\r\n assert image.ndim == 3 and image.shape[2] == 3\r\n\r\n gray_image = np.dot(image, [0.2989, 0.5870, 0.1140]).astype(np.uint8)\r\n\r\n return gray_image",
"def convert_t... | [
"0.824732",
"0.81395787",
"0.811807",
"0.8095474",
"0.7850972",
"0.77897877",
"0.77344203",
"0.7730983",
"0.7730983",
"0.7730983",
"0.7730983",
"0.769052",
"0.7676294",
"0.76603323",
"0.7658235",
"0.76398575",
"0.76376325",
"0.76082414",
"0.7554931",
"0.7517657",
"0.7511747",... | 0.70695215 | 65 |
Saves images and corresponding whitened patches in a format that makes sense for the images class. | def save_data(data,patches,labels,name,patch_dim,size=None):
patchPerIm = (data.shape[1]*data.shape[2])/(patch_dim**2)
if size is None:
size = labels.shape[0]
img_f = open('data/images_'+name,'w')
patches_f = open('data/patches_'+name,'w')
label_f = open('data/labels_'+name,'w')
patc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def export_patches(self):\n filename = tkFileDialog.asksaveasfilename(initialdir = self.cwd, title = \"Save patches\", filetypes = ((\"inp file\",\"*.inp\"),(\"all files\",\"*.*\")))\n if filename:\n patches = self.myGlycosylator.export_patches(self.linked_glycans)\n with open(f... | [
"0.7023205",
"0.67222565",
"0.65105355",
"0.64340895",
"0.63914835",
"0.6342699",
"0.6314629",
"0.61798173",
"0.6148035",
"0.61195004",
"0.60702795",
"0.6026399",
"0.6015969",
"0.6014457",
"0.600203",
"0.5998917",
"0.59706134",
"0.5965257",
"0.5957205",
"0.59544414",
"0.59414... | 0.69192946 | 1 |
Save whitening matrix. (Probably don't need this funtion) | def save_whiten_mat(W):
w_id = open('data/W.bin','w')
W.tofile(w_id)
w_id.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self, filename):\n hebbian_weights = open(filename, \"w\")\n for i in xrange(self.hidden):\n hebbian_weights.write(\"\\t\".join(self.vis_layer[i].get_weights()) + '\\n')\n for i in xrange(self.layers):\n for j in xrange(self.hidden):\n hebbian_weig... | [
"0.6092257",
"0.60249054",
"0.58878946",
"0.5833244",
"0.5784645",
"0.5762371",
"0.575296",
"0.56992406",
"0.5612847",
"0.5594328",
"0.5574145",
"0.5554583",
"0.5548206",
"0.5548206",
"0.55330473",
"0.5496872",
"0.5472161",
"0.54410243",
"0.54121757",
"0.5404685",
"0.53983784... | 0.76458836 | 0 |
Specific to CIFAR dataset Loads data from file, returns color, grayscale images and labels. | def load_cifar_images(filename):
from load_cifar import load_file
from load_cifar import label_dict
data,labels = load_file(filename)
# two classes to keep
class0 = label_dict['airplane']
class1 = label_dict['bird']
# remove all but two classes
keep = np.logical_or(labels==class0,labe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_CIFAR_batch(filename):\r\n with open(filename, 'rb') as f:\r\n datadict = pickle.load(f, encoding='latin1')\r\n X = datadict['data']\r\n Y = datadict['labels']\r\n X = X.reshape(10000, 3, 32, 32).transpose(0,2,3,1).astype(\"float\")\r\n Y = np.array(Y)\r\n return X, Y",
"def load_CIFA... | [
"0.73128104",
"0.7272266",
"0.7227609",
"0.7224899",
"0.7196789",
"0.71712595",
"0.71459734",
"0.7134772",
"0.7129105",
"0.7112924",
"0.70436376",
"0.6898891",
"0.6793835",
"0.67866397",
"0.6777393",
"0.6743453",
"0.67378056",
"0.67167586",
"0.6703161",
"0.66613394",
"0.66538... | 0.8135456 | 0 |
Block the given request if necessary. | def filter_yt(info: interceptor.Request):
url = info.request_url
if (url.host() == 'www.youtube.com' and
url.path() == '/get_video_info' and
'&adformat=' in url.query()):
info.block() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Block(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')",
"def block_one(self):",
"def block(self):\n pass",
"def check_for_lock_request(self):\n while T... | [
"0.6859457",
"0.66493475",
"0.66157824",
"0.64418024",
"0.6186081",
"0.61827296",
"0.6047875",
"0.60476345",
"0.6017209",
"0.59764713",
"0.59704554",
"0.5955465",
"0.5930965",
"0.58846414",
"0.584605",
"0.584605",
"0.584605",
"0.5845607",
"0.58448905",
"0.58070934",
"0.578768... | 0.0 | -1 |
Processes a line of data | def dependency_parse(nlp, article):
if type(article) == str:
parsed = nlp(article)
return [[{"sender": {k[1:]: dep[0].__dict__[k] for k in dep[0].__dict__ if not k.startswith("_parent")},
"edge": dep[1],
"receiver": {k[1:]: dep[2].__dict__[k] for k in dep[2].__dic... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_line(self, line, data):\n return data",
"def parse_line(self, line):\n success = self.parser.handle_line(line)\n if success:\n self.data.update()\n else:\n self.bot.log(\"didn't handle line: '{}'\".format(line))",
"def process_line(self, line):\n ... | [
"0.83830035",
"0.7128161",
"0.7065565",
"0.68617666",
"0.67690486",
"0.6642529",
"0.66226065",
"0.66152495",
"0.65900004",
"0.6549268",
"0.6546678",
"0.6521599",
"0.6446941",
"0.64292336",
"0.64112836",
"0.6405173",
"0.63816816",
"0.6381636",
"0.6326672",
"0.63175094",
"0.629... | 0.0 | -1 |
The step repeated in the main function. It processes a single line and writes the result to the final file | def process_line(nlp, line, parsed_file):
m = json.loads(line)
if "highlights" in m:
if m['sentences'] != '' and m['sentences'] != [] and m['sentences'] != [''] and m['highlights'] != '':
m["highlights_ud"] = dependency_parse(nlp, m['highlights'])
m["sentences_ud"] = dependency_p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __processOutputLine(self, line):\n if (\n line.startswith(\"--- \") or\n line.startswith(\"+++ \")\n ):\n self.__processFileLine(line)\n \n self.__output.append(line)",
"def add_to_output(line: str) -> None:\n with open(OUTPUT, \"a+\") as proble... | [
"0.67841345",
"0.6634219",
"0.6592885",
"0.6466333",
"0.63316095",
"0.6178653",
"0.61690086",
"0.6127863",
"0.60613734",
"0.5948732",
"0.5920585",
"0.5872873",
"0.58408296",
"0.5816387",
"0.5814094",
"0.5742575",
"0.57180977",
"0.5688523",
"0.56645995",
"0.5642619",
"0.562859... | 0.5227363 | 69 |
Main function to process the input file with the nlp pipeline. | def main(nlp, file_path, final_file_path, from_line=0, to_line=None):
with open(final_file_path, "w") as parsed_file:
with open(file_path) as cnn_dm:
line = cnn_dm.readline().strip()
article_idx = 0
while article_idx < from_line:
line = cnn_dm.readline().s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main ():\n\n\tfio = fileIo('input.txt')\n text = fio.getInput()\n\n\tp = re.compile(r'#?\\d[\\s\\.]?[\\s]?')\n\tout = filter(None, p.split(text))\n\ti = 0\n\tlistOfLists = []\n\t\n\n\tfor s in out:\n\t\ti += 1\n\t\ttext = nltk.word_tokenize(s)\n\t\tpos = nltk.pos_tag(text)\n\t\tpattern = \"NP: {<DT>?<JJ... | [
"0.6942143",
"0.65095925",
"0.6476295",
"0.64673996",
"0.62523973",
"0.625186",
"0.6231466",
"0.6204096",
"0.61911345",
"0.61845344",
"0.61776495",
"0.6155281",
"0.6135536",
"0.6135536",
"0.6135536",
"0.6103798",
"0.6096503",
"0.60951585",
"0.60811174",
"0.60290784",
"0.60128... | 0.6569378 | 1 |
Reads a file and counts the words frequency and total word count | def file_read(filename):
fin=open(filename)
count=0
d=dict()
for line in fin:
line=line.replace("-"," ")
word=line.split()
for item in word:
item=item.strip(string.punctuation + string.whitespace)
item=item.lower()
d[item]=d.get(item,0)+1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_words(filename):",
"def word_count_2(filename):\n\n with open(filename) as file_:\n # read file and lowercase all words\n words = file_.read().lower()\n # use translate to remove punc\n words = words.translate(None, string.punctuation)\n # call counter to count on ... | [
"0.82008404",
"0.7888448",
"0.7832937",
"0.77919406",
"0.7706766",
"0.76518214",
"0.76488185",
"0.7634585",
"0.76182836",
"0.7587663",
"0.75641406",
"0.75639457",
"0.7504516",
"0.74861825",
"0.7480002",
"0.74630535",
"0.74255395",
"0.74054885",
"0.7391366",
"0.7357203",
"0.73... | 0.6632512 | 64 |
Prints the histogram dictionary | def print_dict(d):
list1=list()
for key,value in d.items():
list1.append((value,key))
list1.sort(reverse=True)
for word,value in list1[:20]:
print(word, value, sep='\t') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_hist(h):\n for k in h:\n print(k, h[k])",
"def do_hist(self, args):\n print(self._hist)",
"def show_histo(dict, orient=\"horiz\", label=\"counts\", title=\"title\"):\n plt.clf()\n plt.cla()\n if orient==\"horiz\":\n bar_fun = plt.barh \n bar... | [
"0.79336995",
"0.7364849",
"0.7264949",
"0.7221877",
"0.6844306",
"0.67762184",
"0.67736197",
"0.670204",
"0.6640156",
"0.658255",
"0.6464321",
"0.6459065",
"0.6452475",
"0.6445913",
"0.6416502",
"0.6416502",
"0.6401292",
"0.6320839",
"0.6299228",
"0.62942815",
"0.6251127",
... | 0.0 | -1 |
Calculate the closest cruising altitude to the given altitude. | def closest_cruising_altitude(altitude):
return 1000 * ((altitude + 500) // 1000) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def altitude(self):\n if self.__altitude:\n return sum(self.__altitude) / len(self.__altitude)\n else:\n return -9999",
"def altitude(self):\r\n pressure = self.pressure # in Si units for hPascal\r\n return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressu... | [
"0.68563944",
"0.6599064",
"0.6381891",
"0.6333543",
"0.6299421",
"0.6299421",
"0.62524825",
"0.61202556",
"0.609955",
"0.60223883",
"0.5997195",
"0.595264",
"0.5929024",
"0.59270704",
"0.58204633",
"0.5791743",
"0.5770483",
"0.5733085",
"0.5660749",
"0.5638563",
"0.5614531",... | 0.8231129 | 0 |
Determine whether an altitude may be a cruising altitude. | def is_cruising(altitude, cruise_altitude=None):
if cruise_altitude is None:
cruise_altitude = closest_cruising_altitude(altitude)
return abs(altitude - cruise_altitude) <= 200 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_elevation(self):\n return not self._is_depth",
"def altitude(self):\n if self.__altitude:\n return sum(self.__altitude) / len(self.__altitude)\n else:\n return -9999",
"def is_slope(self):\n\t\tif self.high_elevation != self.low_elevation:\n\t\t\treturn True\n\... | [
"0.62690014",
"0.60328066",
"0.58956814",
"0.58533365",
"0.57905114",
"0.5768535",
"0.57448244",
"0.5742459",
"0.56997365",
"0.56776786",
"0.56776786",
"0.5669931",
"0.566654",
"0.56537473",
"0.5641513",
"0.56306905",
"0.5626469",
"0.56141675",
"0.55750054",
"0.5573237",
"0.5... | 0.713465 | 0 |
Determine whether an altitude range may be at a cruising altitude. | def in_cruise_level_range(altitudes, cruise_altitude):
return is_cruising(altitudes, cruise_altitude).all() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_cruising(altitude, cruise_altitude=None):\n if cruise_altitude is None:\n cruise_altitude = closest_cruising_altitude(altitude)\n return abs(altitude - cruise_altitude) <= 200",
"def check_altitude_at(self, altim, coords, altitude_bounds):\n altitude = altim.mesh.point_altitude(coords)... | [
"0.71779066",
"0.61347663",
"0.6049398",
"0.59661514",
"0.59199977",
"0.58426267",
"0.5821014",
"0.57130736",
"0.5702021",
"0.5696651",
"0.56564146",
"0.56514233",
"0.564707",
"0.56175345",
"0.560205",
"0.5593734",
"0.5585223",
"0.5575167",
"0.5550343",
"0.5514078",
"0.549265... | 0.58846647 | 5 |
Find pairs of start/finish indicies of consecutive altitudes with the same value. I.e. where an aircraft was in level flight. | def find_level_sections(alts):
# Get the indicies of positions at the starts and end of levels
level_indicies = []
if len(alts) > 2:
prev_alt = alts[0]
alt = alts[1]
# If the first two altitudea are the same, mark as is_level
is_level = (prev_alt == alt)
if is_level... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intersection_distances(self, altitude, start_distance, finish_distance):\n distances = []\n alt_index, alt_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, alt_index, al... | [
"0.61895657",
"0.57591677",
"0.5693731",
"0.55963063",
"0.5349171",
"0.5304589",
"0.52295",
"0.51885813",
"0.51586705",
"0.51529676",
"0.5115243",
"0.51014274",
"0.5073773",
"0.5066128",
"0.5040757",
"0.50405693",
"0.5022069",
"0.5019296",
"0.50123805",
"0.50085217",
"0.49733... | 0.61840254 | 1 |
Find pairs of start/finish indicies of altitudes where an aircraft was cruising. | def find_cruise_sections(altitudes):
indicies = find_level_sections(altitudes)
if indicies:
prev_altitude = altitudes[indicies[0]]
cruise_altitude = closest_cruising_altitude(prev_altitude)
was_cruising = is_cruising(prev_altitude, cruise_altitude)
prev_altitude = cruise_altitud... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intersection_distances(self, altitude, start_distance, finish_distance):\n distances = []\n alt_index, alt_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, alt_index, al... | [
"0.6280308",
"0.59270215",
"0.58374995",
"0.5785568",
"0.5549861",
"0.54942876",
"0.5423105",
"0.539191",
"0.5391667",
"0.5305186",
"0.5304457",
"0.5252072",
"0.5251932",
"0.5228445",
"0.5205544",
"0.51648146",
"0.5155315",
"0.51186764",
"0.5109229",
"0.5094685",
"0.5079075",... | 0.59695065 | 1 |
Create a numpy boolean array with all positions inbetween the starts and finishes of cruising sections marked as True. | def find_cruise_positions(num_altitudes, cruise_indicies):
cruise_positions = np.zeros(num_altitudes, dtype=bool)
if cruise_indicies:
for index in range(0, len(cruise_indicies), 2):
start = cruise_indicies[index] + 1
stop = cruise_indicies[index + 1]
if start < stop:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def enumerate_bool(bool_array, nstart=0):\n ind = bool_2_indices(bool_array)\n ns = np.full(bool_array.size, nstart, dtype=int)\n for n, lims in enumerate(ind):\n ns[lims[0]:lims[-1]] = nstart + n + 1\n return ns",
"def masktoregions(in_mask):\n regions = []\n for i in [0,1]: # do the th... | [
"0.6591012",
"0.64183784",
"0.6045036",
"0.5852564",
"0.5838651",
"0.5837393",
"0.5796877",
"0.5683957",
"0.56573534",
"0.55983865",
"0.55705667",
"0.554639",
"0.5524945",
"0.5523016",
"0.5494886",
"0.54834664",
"0.54707986",
"0.5469798",
"0.54545856",
"0.5441271",
"0.5429074... | 0.5647696 | 9 |
Set cruising altitudes to the closest cruising altitude. | def set_cruise_altitudes(altitudes, cruise_indicies):
if cruise_indicies:
for index in range(0, len(cruise_indicies), 2):
start = cruise_indicies[index]
stop = cruise_indicies[index + 1]
if start < stop:
cruise_altitude = closest_cruising_altitude(altitude... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_altitude(self):\n self.altitude = self.Calculations.convert_to_altitude( self.declination, self.right_ascension, self.Latitude, self.LHA)\n print('altitude set to', self.altitude)\n if self.altitude < 0:\n self.altitude = self.altitude + 360.0\n return self.altitu... | [
"0.6397559",
"0.60705537",
"0.58555746",
"0.58198625",
"0.5693789",
"0.55685645",
"0.5377789",
"0.5350137",
"0.5192501",
"0.5148783",
"0.51282614",
"0.51085854",
"0.51039815",
"0.49786505",
"0.49037406",
"0.48799503",
"0.48787838",
"0.48784757",
"0.48330465",
"0.48201117",
"0... | 0.6250826 | 1 |
Classify an altitude profile based on the altitudes. | def classify_altitude_profile(altitudes):
max_alt = altitudes.max()
has_climb = (max_alt > altitudes[0])
has_descent = (max_alt > altitudes[-1])
if has_climb or has_descent:
if has_climb != has_descent:
return AltitudeProfileType.CLIMBING if has_climb \
else Altitude... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def altitude_profile(self, alt):\n # checking if the units entered are km\n if alt.unit == u.km:\n if 150 <= alt.value < 500:\n alt_properties = self._altitude_profile(500)\n else:\n alt_properties = self._altitude_profile(alt.value)\n\n retu... | [
"0.7040563",
"0.60490364",
"0.5742719",
"0.569368",
"0.56679446",
"0.5570887",
"0.5441801",
"0.54371053",
"0.5434901",
"0.53988135",
"0.52956814",
"0.5294227",
"0.5294227",
"0.52853245",
"0.5224944",
"0.52045184",
"0.51312333",
"0.51289755",
"0.50556916",
"0.50430584",
"0.503... | 0.7570481 | 0 |
Interpolate altitudes at distance values. Uses the scipy.interpolate.interp1d function to linearly interpolate altitudes at the required distances. | def interpolate(self, distances):
cs = interp1d(self.distances, self.altitudes, fill_value='extrapolate')
return cs(distances) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def interpolate(self, distance, normalized=...): # -> BaseGeometry:\n ...",
"def interpolate(i0, d0, i1, d1):\n if i0 == i1:\n return [d0]\n values = []\n a = (d1 - d0) / (i1 - i0)\n d = d0\n for i in range(i0,i1+1):\n values.append(d)\n d = d + a\n return values",
... | [
"0.6566528",
"0.5902961",
"0.58026075",
"0.57675046",
"0.5665642",
"0.5541325",
"0.5525913",
"0.5521779",
"0.5509595",
"0.5484826",
"0.5441326",
"0.54245895",
"0.5362832",
"0.5246091",
"0.52411157",
"0.5231471",
"0.5227989",
"0.5221338",
"0.5212287",
"0.520249",
"0.5196203",
... | 0.8268463 | 0 |
Determine the range of altitudes between start_distance and finish_distance. | def altitude_range(self, start_distance, finish_distance):
start_index, start_ratio = calculate_value_reference(self.distances,
start_distance)
start_alt = calculate_value(self.altitudes, start_index, start_ratio)
finish_index, finish_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intersection_distances(self, altitude, start_distance, finish_distance):\n distances = []\n alt_index, alt_ratio = calculate_value_reference(self.distances,\n start_distance)\n start_alt = calculate_value(self.altitudes, alt_index, al... | [
"0.7745811",
"0.5996923",
"0.58210236",
"0.5799497",
"0.5713338",
"0.57017654",
"0.56947106",
"0.5679401",
"0.5613159",
"0.5584916",
"0.5583578",
"0.55816114",
"0.5579437",
"0.54959893",
"0.54946244",
"0.5478117",
"0.5467547",
"0.5465406",
"0.54653704",
"0.54519516",
"0.54467... | 0.912184 | 0 |
Determine the index of the top of climb altitude. Returns The index of the first cruising altitude. | def top_of_climb_index(self):
return self.altitudes.argmax() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def top_of_descent_index(self):\n tod = self.altitudes.argmax()\n # if the altitude profile is not just a climb\n # and there is a cruising section\n if (tod < len(self.altitudes) - 1) and \\\n (self.altitudes[tod] == self.altitudes[tod + 1]):\n tod += 1\n\n ... | [
"0.82650274",
"0.6586973",
"0.64087886",
"0.63747007",
"0.63523763",
"0.62209785",
"0.60802037",
"0.6078412",
"0.60293245",
"0.60026336",
"0.59891087",
"0.5984468",
"0.5980566",
"0.5978508",
"0.5973972",
"0.59719825",
"0.59692377",
"0.5964401",
"0.59599084",
"0.59111434",
"0.... | 0.84036976 | 0 |
Determine the index of the top of climb altitude. Returns The index of the last cruising altitude. | def top_of_descent_index(self):
tod = self.altitudes.argmax()
# if the altitude profile is not just a climb
# and there is a cruising section
if (tod < len(self.altitudes) - 1) and \
(self.altitudes[tod] == self.altitudes[tod + 1]):
tod += 1
return to... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def top_of_climb_index(self):\n return self.altitudes.argmax()",
"def alt_index(self) -> Optional[int]:\n if not self.is_hom_alt():\n return None\n return max(self.allele1, self.allele2) - 1",
"def top_offset(self):\n raise NotImplementedError",
"def top(self):\n ... | [
"0.845523",
"0.66592854",
"0.6438688",
"0.64357513",
"0.64272976",
"0.64195174",
"0.6181029",
"0.6179077",
"0.6126768",
"0.61237574",
"0.6112536",
"0.61075664",
"0.61017954",
"0.60960674",
"0.60574836",
"0.6043104",
"0.60421985",
"0.6038397",
"0.6038397",
"0.60144544",
"0.601... | 0.82606477 | 1 |
Determine the path distance of the top of climb altitude. Returns The path distance of the first cruising altitude. | def top_of_climb_distance(self):
return self.distances[self.top_of_climb_index()] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def closest_cruising_altitude(altitude):\n return 1000 * ((altitude + 500) // 1000)",
"def find_closest_path(self):\n\t\tclosest_distance = sys.maxint\n\t\tclosest_path = 0\n\t\tbike_position = (self.map_model.bike.xB, self.map_model.bike.yB)\n\t\tfor path_index in range(len(self.map_model.paths)):\n\t\t\tnea... | [
"0.6739397",
"0.63740313",
"0.62297326",
"0.6201111",
"0.61479735",
"0.6109232",
"0.58568966",
"0.57820773",
"0.5728556",
"0.5677432",
"0.5653691",
"0.5620571",
"0.5601367",
"0.55796075",
"0.55561036",
"0.5536733",
"0.5516684",
"0.55092776",
"0.54958546",
"0.5482631",
"0.5458... | 0.69647264 | 0 |
Determine the path distance of the top of descent altitude. Returns The path distance of the first cruising altitude. | def top_of_descent_distance(self):
return self.distances[self.top_of_descent_index()] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def closest_cruising_altitude(altitude):\n return 1000 * ((altitude + 500) // 1000)",
"def top_of_descent_index(self):\n tod = self.altitudes.argmax()\n # if the altitude profile is not just a climb\n # and there is a cruising section\n if (tod < len(self.altitudes) - 1) and \\\n ... | [
"0.6641679",
"0.6360074",
"0.6237355",
"0.6115602",
"0.6089604",
"0.5971742",
"0.5874693",
"0.58288443",
"0.5771951",
"0.57360345",
"0.5729539",
"0.57193947",
"0.56928456",
"0.5685602",
"0.5612506",
"0.5589079",
"0.5577618",
"0.557536",
"0.55737656",
"0.55690765",
"0.55622447... | 0.660244 | 1 |
Calculate distances where the profile is at the given altitude. | def intersection_distances(self, altitude, start_distance, finish_distance):
distances = []
alt_index, alt_ratio = calculate_value_reference(self.distances,
start_distance)
start_alt = calculate_value(self.altitudes, alt_index, alt_ratio)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def altitude_profile(self, alt):\n # checking if the units entered are km\n if alt.unit == u.km:\n if 150 <= alt.value < 500:\n alt_properties = self._altitude_profile(500)\n else:\n alt_properties = self._altitude_profile(alt.value)\n\n retu... | [
"0.69530743",
"0.65202653",
"0.6478382",
"0.6396903",
"0.639056",
"0.6178385",
"0.6178385",
"0.6144988",
"0.60816115",
"0.58620787",
"0.58369505",
"0.58215445",
"0.58118826",
"0.57391644",
"0.5735804",
"0.5733575",
"0.57045203",
"0.5664503",
"0.56433076",
"0.5625876",
"0.5607... | 0.67026734 | 1 |
esta es una funcion que recibe dos parametros y retorna la suma de ellos | def sum(a,v):
return a+v | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_sum(a,b):\n return",
"def sum(*args):\n result = 0\n for i in args:\n result += i\n return result",
"def sums(arg1, arg2): # create function sums with arguments arg1 and arg2\n totals = arg1 + arg2 # set the variable totals to equal arg1 + arg2\n print(\"Inside the function :... | [
"0.7318327",
"0.7009012",
"0.698997",
"0.6969839",
"0.6940038",
"0.6829298",
"0.6651685",
"0.6611744",
"0.6542105",
"0.6539168",
"0.6525985",
"0.6523398",
"0.6488423",
"0.6481863",
"0.6465098",
"0.64590466",
"0.6432706",
"0.64280194",
"0.63407207",
"0.6335891",
"0.6335891",
... | 0.6171152 | 33 |
Read a population from file and return a list of dictionaries of the relationships and the agents | def read_timestep(root_path: str, time: str):
path = os.path.join(root_path, time)
agent_file = glob.glob(os.path.join(path, "*_agents.csv"))[0]
rel_file = glob.glob(os.path.join(path, "*_relationships.csv"))[0]
feat_files = glob.glob(os.path.join(path, "*_feat_*.csv"))
exposure_files = glob.glob(o... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read(self):\n\t\tentities = dict()\n\t\trelations = set()\n\t\tedges = set()\n\t\twith open(self.file_path, encoding=\"utf-8\") as f:\n\t\t\tfor line in tqdm(f):\n\t\t\t\tif(self.prob == 1.0 or random() < self.prob):\n\t\t\t\t\tsource, relation, target, _ = line.split(\" \", 3)\n\t\t\t\t\tis_dataprop = target.... | [
"0.67748284",
"0.6408295",
"0.61751515",
"0.5888248",
"0.58689374",
"0.58549124",
"0.583973",
"0.58324826",
"0.5831974",
"0.5760128",
"0.5753357",
"0.57407457",
"0.5708623",
"0.56422573",
"0.5570306",
"0.555868",
"0.55579597",
"0.5540641",
"0.5510702",
"0.5494685",
"0.5494377... | 0.51426554 | 61 |
Return pandas dataframe with annual, quarterly, monthly or daily data. | def get_frame(freq: str):
url = 'http://minikep-db.herokuapp.com/api/frame?freq={}'.format(freq)
return pd.read_csv(url, converters={0: pd.to_datetime}, index_col=0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_time_series_data():\r\n # Grab the requested years and columns from the query arguments\r\n ls_year = [int(year) for year in request.args.getlist(\"n\")]\r\n ls_col = request.args.getlist(\"m\")\r\n\r\n # Generate a list of all the months we need to get\r\n all_years = [str(year) for year in... | [
"0.61230016",
"0.6044962",
"0.59703547",
"0.5963478",
"0.5958542",
"0.59389883",
"0.5922768",
"0.5885662",
"0.58801645",
"0.58436364",
"0.5840979",
"0.58044046",
"0.57593805",
"0.57528985",
"0.5697548",
"0.5684046",
"0.5673133",
"0.564309",
"0.56324506",
"0.56079215",
"0.5598... | 0.0 | -1 |
Run a simulation with the standard and Galilean scheme respectively and check that the first one is unstable while the second one is stable | def test_cherenkov_instability( show=False ):
# Dictionary to record the final value of E
slope_Erms = {}
for scheme in [ 'standard', 'galilean', 'pseudo-galilean']:
# Choose the correct parameters for the scheme
if scheme == 'standard':
v_comoving = 0.
use_galilean... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_1_do_valid_sim(self) :\n self.banner(\"Testing if simulation gives the right percentages.\")\n filename = self.find_file('project9.py')\n self.assertIsNotNone(filename, \"I can't find your project file (project9.py)\")\n\n with open('logs/test_1_valid_sim.out', 'a') as log :\n ... | [
"0.68798894",
"0.67589664",
"0.6691962",
"0.6658642",
"0.66065735",
"0.6502654",
"0.6430964",
"0.6405235",
"0.62871385",
"0.6238632",
"0.6205848",
"0.62035537",
"0.6201428",
"0.6168178",
"0.61394686",
"0.611758",
"0.60966617",
"0.6089579",
"0.6072231",
"0.60561776",
"0.603497... | 0.5700753 | 63 |
Return a string representation of the config. | def __str__(self):
# top row
result = ' '
result = '\n ' + '-' * (self.DIM*2+5) + '\n'
# board rows
for row in range(self.DIM):
if row is 3 or row is 6:
result += '|' + '-' * (self.DIM*2+5) + '|' + '\n'
# result +... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__():\n return str(_config)",
"def __str__(self):\n config_str = 'Configurations\\n'\n config_str += pprint.pformat(self.__dict__)\n return config_str",
"def __repr__(self) -> str:\n return json.dumps(self._config)",
"def str(self):\n\n list_of_entries = ['{0} n... | [
"0.85173273",
"0.8513157",
"0.8259779",
"0.7956899",
"0.77279353",
"0.7583788",
"0.7550117",
"0.7511544",
"0.7511544",
"0.7487914",
"0.74800324",
"0.74372464",
"0.7417465",
"0.737675",
"0.73606914",
"0.7319001",
"0.72816837",
"0.7248459",
"0.7144512",
"0.7063809",
"0.68749636... | 0.0 | -1 |
Checks whether a config is a goal or not | def isGoal(self):
for index in range(self.DIM):
if not self.values('r',index).count(0) is 0:
return False
if not self.isValid():
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_goal(puzzle_state, goal):\n return puzzle_state.config == goal",
"def test_goal(state):\r\n \r\n if state.config == (0,1,2,3,4,5,6,7,8):\r\n return True\r\n else:\r\n return False",
"def check_config(cfg):",
"def is_goal(self, url):\n return url == self.goal_url",
... | [
"0.7215837",
"0.6925614",
"0.68441874",
"0.67809874",
"0.6737237",
"0.66554487",
"0.6639001",
"0.6628785",
"0.6553829",
"0.6422694",
"0.6376019",
"0.63585305",
"0.63565326",
"0.63558185",
"0.6341891",
"0.63215846",
"0.63215846",
"0.6273997",
"0.6273997",
"0.6271821",
"0.62718... | 0.54483956 | 84 |
Compute the entropy of the mean of the predictive distribution obtained from Monte Carlo sampling during prediction phase. | def predictive_entropy(mc_preds):
return entropy(np.mean(mc_preds, axis=0)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def entropy(self):\n return -np.sum(self.log_likelihoods * np.exp(self.log_likelihoods))",
"def entropy(y):\n EPS = 0.0005\n\n # YOUR CODE HERE\n if len(y) == 0:\n return 0.\n \n pk = np.mean(y, axis=0)\n \n return - np.sum(pk * np.log(pk + EPS))",
"def entropy(self):\n Z ... | [
"0.7530867",
"0.74424595",
"0.74055004",
"0.7329188",
"0.7220066",
"0.7200022",
"0.7160352",
"0.7152894",
"0.71405065",
"0.70775807",
"0.70759517",
"0.7073769",
"0.70580447",
"0.70529985",
"0.7017805",
"0.69966227",
"0.69941026",
"0.69562703",
"0.6955483",
"0.69474715",
"0.69... | 0.6855338 | 28 |
Compute the difference between the entropy of the mean of the predictive distribution and the mean of the entropy. | def mutual_information(mc_preds):
mutual_info = entropy(np.mean(mc_preds, axis=0)) - np.mean(entropy(mc_preds),
axis=0)
return mutual_info | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def entropy(self):\n return -np.sum(self.log_likelihoods * np.exp(self.log_likelihoods))",
"def entropy(img):\n # by calculating\n histogram = img.histogram()\n histogram_size = sum(histogram)\n histogram = [float(h) / histogram_size for h in histogram]\n\n return -sum([p * math.log(p, 2) f... | [
"0.73744655",
"0.6969958",
"0.6913475",
"0.68965644",
"0.6835691",
"0.68118334",
"0.6751494",
"0.66962296",
"0.6673262",
"0.666841",
"0.6663414",
"0.66559005",
"0.66333395",
"0.660028",
"0.6595049",
"0.6591081",
"0.6569786",
"0.6554377",
"0.65446806",
"0.65093774",
"0.6505853... | 0.0 | -1 |
sigma is represented by softplus function 'sigma = log(1 + exp(rho))' to make sure it remains always positive and nontransformed 'rho' gets updated during backprop. | def get_rho(sigma, delta):
rho = torch.log(torch.expm1(delta * torch.abs(sigma)) + 1e-20)
return rho | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rho2sigma(rho):\n return pt.softplus(rho)",
"def sigma2rho(sigma):\n return pt.log(pt.exp(pt.abs(sigma)) - 1.0)",
"def mbh_sigma(sigma):\n _MASS = 8.32\n _SLOPE = 5.64\n _VEL = 200e5\n\n mbh = _MASS + _SLOPE*np.log10(sigma/_VEL)\n mbh = np.power(10.0, mbh) * MSOL\n return mbh",
"d... | [
"0.735956",
"0.7310387",
"0.6823238",
"0.6799738",
"0.66822535",
"0.66129714",
"0.65858775",
"0.6508815",
"0.6486363",
"0.6454253",
"0.6414886",
"0.6321964",
"0.6282718",
"0.6269426",
"0.6257471",
"0.624839",
"0.6226637",
"0.61909837",
"0.6161841",
"0.6161265",
"0.6147177",
... | 0.6352347 | 11 |
Set the priors and initialize surrogate posteriors of Bayesian NN with Empirical Bayes MOPED (Model Priors with Empirical Bayes using Deterministic DNN) Example implementation for Bayesian model with variational layers. | def MOPED(model, det_model, det_checkpoint, delta):
det_model.load_state_dict(torch.load(det_checkpoint))
for (idx, layer), (det_idx,
det_layer) in zip(enumerate(model.modules()),
enumerate(det_model.modules())):
if (str(layer) == 'Conv1dRe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_bn(bn):\n \n bn.bias.data.fill_(0.)\n bn.running_mean.data.fill_(0.)\n bn.weight.data.fill_(1.)\n bn.running_var.data.fill_(1.)",
"def naiveBayes(train_set, train_labels, dev_set, smoothing_parameter, pos_prior):\n # TODO: Write your code here\n # return predicted labels of developm... | [
"0.6395938",
"0.63691896",
"0.6234702",
"0.62117696",
"0.6144598",
"0.6126539",
"0.61065125",
"0.61020076",
"0.60287267",
"0.60050046",
"0.60005945",
"0.59805095",
"0.59656256",
"0.59533674",
"0.5929694",
"0.5922263",
"0.58944905",
"0.58921105",
"0.5883023",
"0.58764946",
"0.... | 0.0 | -1 |
THIS FUNCTION REMOVES THE PLANNED EVENTS FROM THE EVENT DATASET | def removePlanned(X,y):
X_new=[]
y_new=[]
for i in range(len(y)):
#print(i)
if y[i]==0:
y_new.append(0)
X_new.append(X[i,:,:,:])
elif y[i]==1:
y_new.append(1)
X_new.append(X[i,:,:,:])
elif y[i]==... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def OnRearrangeEnd(self, evt):\n\t\tself._potentialRearrange = False\n\t\tself._didCopy = False\n\t\tevt.Skip()",
"def bindEvents(fusionEvents,divisionEvents, buff):\n #1/Finding correspondances\n fusion_indices = []\n fusion_labels = []\n fusion_labels_2 = [] # In label 2 says with which cell the d... | [
"0.58445203",
"0.5509604",
"0.538551",
"0.5352465",
"0.5347396",
"0.53318274",
"0.5314644",
"0.52846736",
"0.5262972",
"0.5220926",
"0.52139837",
"0.51859725",
"0.5173534",
"0.51570314",
"0.51506615",
"0.5138261",
"0.51148987",
"0.5111304",
"0.5085959",
"0.5082112",
"0.505955... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.