None:\\n pass\",\n \"def transform(self, vdf: Union[str, vDataFrame] = None, X: list = []):\\n if isinstance(X, str):\\n X = [X]\\n try:\\n self.steps[-1][1].transform\\n except:\\n raise ModelError(\\n \\\"The last estimator of the Pipeline has no 'transform' method.\\\"\\n )\\n if not (vdf):\\n vdf = self.input_relation\\n if isinstance(vdf, str):\\n vdf = vdf_from_relation(relation=vdf, cursor=self.steps[0][1].cursor)\\n X_new, X_all = [elem for elem in X], []\\n current_vdf = vdf\\n for idx, step in enumerate(self.steps):\\n current_vdf = step[1].transform(current_vdf, X_new)\\n X_new = step[1].get_names(X=X)\\n X_all += X_new\\n return current_vdf\",\n \"def transform(self):\\n self.validate_ports()\\n\\n # TODO: Find a more reusable way of enforcing this behavior.\\n if self.distance.variable.ndim != 1:\\n raise ValueError(\\\"`distance` must be a vector.\\\")\\n\\n if self.equivalence.variable.ndim != 1:\\n raise ValueError(\\\"`equivalence` must be a vector.\\\")\\n\\n dist = self.distance.variable\\n equiv = self.equivalence.variable\\n smarg = self.sim_margin.variable\\n dmarg = self.diff_margin.variable\\n\\n sim_cost = T.pow(functions.relu(dist - smarg), 2.0)\\n diff_cost = T.pow(functions.relu(dmarg - dist), 2.0)\\n total_cost = equiv * sim_cost + (1 - equiv) * diff_cost\\n self.output.variable = T.mean(total_cost)\",\n \"def cnvValues( self, values, unit, toUnit ):\\n\\n if type( values ) == types.IntType or \\\\\\n type( values ) == types.FloatType:\\n return acuUnit.convert( values, unit, toUnit )\\n\\n else:\\n for i in xrange( values.shape[0] ):\\n values[i] = self.cnvValues( values[i], unit,\\n toUnit )\\n return values\",\n \"def _canon_cg(expr):\\n return expr.replace(CG, _canon_cg_core)\",\n \"def result_to_vector(results):\\n return [vectorized_result(x) for x in results]\",\n \"def transform():\\n pass\",\n \"def process_coordinates(void: 'ChargeSystem', steps: int) -> list:\\n result = [[] for _ in void]\\n\\n for _ in range(steps):\\n for ind, charge in enumerate(void):\\n result[ind].append(list(charge.position))\\n void.update()\\n\\n return result\",\n \"def _parse_clash_vectorlist_body(lines):\\n\\n ATOM = 1\\n COLOR = 2\\n LP = 3\\n PM = 4\\n COORDS = 5\\n\\n active_atom = None\\n vectors = []\\n\\n # Parse lines to generate Vectors\\n for i, l in enumerate(lines):\\n matches = VECTORLIST_CLASH_RE.finditer(l)\\n\\n v = []\\n for m in matches:\\n logger.debug('match: {}'.format(m.group(0)))\\n logger.debug('clash vectorlist body line: {}'.format(m.groups()))\\n logger.debug('beginning match...')\\n # Atom selection in kinemages is only written explicitly the first\\n # time for a given list of points. Afterward, it inherits from the\\n # previous point via a single double-quote character (\\\").\\n atom_sel = m.group(ATOM)\\n if atom_sel == '\\\"':\\n #logger.debug('using active atom...')\\n atom = active_atom\\n else:\\n # TODO don't create duplicate atoms (track in MPObject)\\n logger.debug('Generating atom for vector %i point...' % i)\\n atom = process_basic_atom_string(atom_sel)\\n logger.debug('Finished generating atom for vector %i point.' % i)\\n\\n active_atom = atom\\n\\n color = m.group(COLOR)\\n pointmaster = m.group(PM)\\n coords = [float(c) for c in m.group(COORDS).split(',')]\\n\\n v.append({\\n 'atom': atom,\\n 'color': color,\\n 'pm': pointmaster,\\n 'coords': coords})\\n\\n # Create the Vector\\n vector = Vector(v[0]['atom'], v[0]['color'], v[0]['pm'], v[0]['coords'],\\n v[1]['atom'], v[1]['color'], v[1]['pm'], v[1]['coords'])\\n vectors.append(vector)\\n\\n return vectors\",\n \"def __call__(self):\\n return self._representation_vector\",\n \"def reconstruct(self, X):\",\n \"def reconstruct(self, X):\",\n \"def _evaluate(self,\\n x, #\\n out,\\n *args,\\n **kwargs):\\n # Stage 1: Execute all refactoring operations in the sequence x\\n for refactoring_operation in x.refactoring_operations:\\n refactoring_operation.do_refactoring()\\n\\n # Stage 2: Computing quality attributes\\n # Todo: Add testability and modularity objectives\\n # Todo: Normalize objective values in a standard range\\n # Todo: Reduce QMOOD metrics to one objective by averaging them\\n o1 = Objectives.reusability\\n o2 = Objectives.understandability\\n # o1 = 1/6 * sum qmood metrics\\n # o2 = testability ## Our new objective\\n # o3 = modularity ## Our new objective\\n\\n # Stage 3: Marshal objectives into vector\\n out[\\\"F\\\"] = np.array([-1 * o1, -1 * o2], dtype=float)\",\n \"def transform(self, X, copy=...):\\n ...\",\n \"def transform(self, X, copy=...):\\n ...\",\n \"def transform(self, X, copy=...):\\n ...\",\n \"def optimize_tree_list(self, tree_list: list[list[list]], namespace: str = \\\"base\\\") -> list[list[list]]:\\n\\n # First lets take all constant values and insert them into a dictionary\\n # For later reference\\n const_values: dict = {}\\n\\n # For every expression\\n for expr in tree_list[0]:\\n # If it is a const:\\n if expr[0] == \\\"const\\\":\\n # Add it to const vals\\n const_values[expr[1]] = expr[2]\\n \\n # Now filter constants from expressions\\n tree_list[0] = filter(lambda value: value if value[0] == \\\"dyn\\\" else None, tree_list[0])\\n\\n # And convert tree list back to a list\\n tree_list[0] = list(tree_list[0])\\n\\n # Now resolve and replace constant values\\n for expr in tree_list[0]:\\n for i, x in enumerate(expr):\\n if x in const_values.keys():\\n expr[i] = const_values[x]\\n \\n # Now we check for variables consisting only of constants\\n # We replace them with their result\\n # And we keep bubbling until none need to be replaced\\n\\n # Create a constant list of variables\\n variables_list = [expr[0] for expr in tree_list[1]]\\n\\n keep_going = True\\n while keep_going:\\n # Assume we are not going to keep going\\n keep_going = False\\n\\n # Create a dictionary for the consts found\\n replace_consts: dict = {}\\n\\n # For every expression\\n for expr in tree_list[0]:\\n # Check if a is a constant int\\n aConst = expr[3] not in variables_list and str(expr[3]).isnumeric()\\n\\n # Check if b is a constant int\\n bConst = expr[4] not in variables_list and str(expr[4]).isnumeric()\\n\\n # Check if both are constant ints\\n bthConst = aConst and bConst\\n\\n # If both are constant integers\\n if bthConst:\\n # Perform the expression on them\\n\\n # Get the expression\\n x = expr[2]\\n\\n # Default value to 0\\n val = 0\\n\\n # Check if this is an operator\\n if self.is_token(x):\\n # If it is, calculate\\n val = self.tokens[x][1](\\n int(expr[3]), # A\\n int(expr[4]) # B\\n )\\n else:\\n # If not, just skip\\n continue\\n \\n # And add to replace_consts\\n replace_consts[expr[1]] = str(val)\\n\\n # Now strip all const declarations\\n # For every expression in tree_list\\n for i,expr in enumerate(tree_list[0]):\\n # If it is a constant\\n if expr[1] in replace_consts.keys():\\n # Delete\\n del tree_list[0][i]\\n \\n # Now replace all constant references\\n # For every expression\\n for expr in tree_list[0]:\\n # For every part of the expression\\n for i, x in enumerate(expr):\\n # If this part is a const and is not a declaration\\n if x in replace_consts.keys() and i != 1:\\n # Make sure that we keep going\\n keep_going = True\\n # And replace it\\n expr[i] = replace_consts[x]\\n \\n\\n # Now all unneeded variables have been removed\\n # or replaced\\n\\n # Renumber all of the elements\\n # Lets create a dictionary of references to renumber\\n renumDict: dict = {}\\n for i,expr in enumerate(tree_list[0]):\\n renumDict[expr[1]] = f\\\"{namespace}_{i}\\\"\\n\\n # Now lets replace these renumbers\\n for expr in tree_list[0]:\\n for i,x in enumerate(expr):\\n if x in renumDict.keys():\\n expr[i] = renumDict[x]\\n\\n # Return treelist\\n return tree_list\",\n \"def project(self, new_expn):\\n \\\"\\\"\\\"\\n data = numpy.array(self.parent.serialisedArrayDataList)\\n import sklearn\\n skpca = sklearn.decomposition.PCA()\\n X_r = skpca.fit(data).transform(data)\\n \\n self.__v = X_r\\n \\\"\\\"\\\"\\n # old martrisx\\n matrix = numpy.array(self.parent.serialisedArrayDataList)\\n U, S, V = numpy.linalg.svd(matrix.T, full_matrices=False)\\n \\n print(\\\"matrix\\\", matrix.shape)\\n \\n # set-ups\\n self.parent = new_expn\\n if self.rowwise:\\n self.labels = new_expn[self.label_key]\\n else:\\n self.labels = new_expn.getConditionNames()\\n \\n matrix = numpy.array(self.parent.serialisedArrayDataList)\\n S = numpy.diag(S)\\n print(\\\"U\\\", U.shape)\\n print(\\\"V\\\", V.shape)\\n print(\\\"S\\\", S.shape)\\n print(\\\"matrix\\\", matrix.shape)\\n \\n #data = np.dot(U, np.dot(S, V))\\n #X_transformed = np.dot(X_transformed, self.V.T)\\n print(numpy.dot(S, V).shape)\\n\\n pr = numpy.dot(matrix, S)\\n print(\\\"pr\\\", pr.shape)\\n #y = x*W;\\n #y0 = Y(1,:);\\n #sum(abs(y0 - y)) %\\n \\n # I want a new v. U and D are the same.\\n \\n self.__v = pr\\n \\n print(U)\\n print()\\n print(pr)\\n \\n print(numpy.allclose(U, pr)) \\n print(numpy.allclose(matrix.T, numpy.dot(U, numpy.dot(S, V))))\\n return(True)\",\n \"def __call__(self, node):\\n if node.inputs:\\n if node.inputs[0].is_constant(Primitive):\\n prim = node.inputs[0].value\\n visit = getattr(self, f'_visit_{prim}', None)\\n if visit is None:\\n return node.inputs[1:]\\n return visit(node)\\n else:\\n return node.inputs\\n return []\",\n \"def project_vectors(self, vectors):\\n return np.dot(vectors, self.components.T)\",\n \"def process_text(self):\\n prp1 = preprocessor.Preprocess()\\n processed_text = prp1.clean_data(self.text)\\n self.vec1 = self.vec.transform(pd.Series(processed_text))\",\n \"def Cheb_to_real_transform(vec, y_points) :\\n rVec = zeros(numYs, dtype='complex')\\n for yIndx in range(numYs):\\n y = y_points[yIndx]\\n for m in range(M):\\n term = vec[m] * cos(m*arccos(y))\\n rVec[yIndx] += term\\n del y,m\\n\\n return rVec\",\n \"def process_tree(tree):\\n c = circuit()\\n l = line()\\n names = {}\\n procedures = []\\n for lst in tree.children:\\n print(lst)\\n if type(lst[0]) is str:\\n names[lst[0]] = lst[1]\\n else:\\n procedures.append(lst)\\n print(names)\\n #print(procedures)\\n\\n for proc in procedures:\\n\\n proc_elements_names = proc[0]\\n proc_name = proc[1]\\n\\n #print(proc_elements_names)\\n #print(proc_name)\\n\\n if proc_name == \\\"set_mode\\\":\\n mode_name = proc_elements_names[0]\\n if mode_name != \\\"draw-mode\\\": \\n c.set_mode(mode_name)\\n elif mode_name == \\\"draw-mode\\\":\\n l1 = line()\\n # draw mode is different from other modes\\n for element in names:\\n e = CompleteElement(element)\\n e.set_other_attrs(names[element])\\n e.process_other_attrs()\\n l1.addElement(e)\\n c.connectInSeries(l1)\\n c.set_mode(\\\"draw-mode\\\")\\n \\n \\n if proc_name == \\\"series\\\":\\n l1 = line()\\n for element in proc_elements_names:\\n l1.addElement(names[element])\\n l = l1\\n c.connectInSeries(l)\\n #raise SyntaxError(\\\"Alias {0} referrenced before assignment\\\".format(item[0]))\\n\\n elif proc_name == \\\"parallel\\\":\\n l1 = line()\\n for element in proc_elements_names:\\n l1.addElement(names[element])\\n c.connectInParallel(l1)\\n l1 = line()\\n\\n\\n elif proc_name == \\\"add_parallel\\\":\\n new_element = proc_elements_names[1]\\n old_element = proc_elements_names[0]\\n l1 = line()\\n l1.addElement(names[new_element])\\n c.connection.append(l1)\\n\\n\\n elif proc_name == \\\"add_series\\\":\\n new_element = proc_elements_names[1]\\n old_element = proc_elements_names[0]\\n for ln in c.connection:\\n for e in ln.elements:\\n if names[old_element] == e:\\n ln.addElement(names[new_element])\\n\\n\\n c.evaluate(\\\"output.png\\\")\\n #print(c)\",\n \"def convert_to_numpy_list_vector_array(obj):\\n obj = preassemble(obj)\\n return ConvertToNumpyListVectorArrayRules().apply(obj)\",\n \"def transform(fn):\\n def _(vec, dt):\\n return np.einsum(\\n 'ji,i,ki,k...->j...',\\n evecs, fn(evals, dt), evecs, vec, optimize=True)\\n\\n return _\",\n \"def apply(self, v):\\n u = np.zeros(self.Dimension, dtype=complex)\\n for me in self.Elements:\\n for index in range(v.Elements.size):\\n if index == me.j:\\n u[me.i] += me.val * v.Elements[index]\\n u = Vector(u) \\n return u\",\n \"def vectorize_doc(document):\\n # return document vector for tokenized input doc\\n return bc.encode([document])[0]\",\n \"def __call__(self):\\n return self._vector\",\n \"def update_agent_location_vector(self):\\n\\n for agent in self.agents:\\n location = agent.getz()\\n # print(location)\\n if location[0] == 0:\\n vectorized_agent_loc = location[1]\\n elif location[0] == 1:\\n vectorized_agent_loc = 4 + location[1]\\n elif location[0] == 2:\\n vectorized_agent_loc = 8 + location[1]\\n else: # location[0] == 3\\n vectorized_agent_loc = 12 + location[1]\\n\\n if agent.isBusy == False:\\n # remove any location if it shows it as well\\n self.agent_locations[0][vectorized_agent_loc] = 0\\n continue\\n else:\\n self.agent_locations[0][vectorized_agent_loc] = 1\\n if self.DEBUG:\\n print('agent location vector is ', self.agent_locations)\",\n \"def complexify(self,z):\\r\\n \\r\\n import numpy as np\\r\\n \\r\\n if not np.iscomplex(z).any():\\r\\n if len(z.shape) != 2 or z.shape[1] != 2:\\r\\n raise Exception('Shape format not understood. Provide shape vertices either as a complex vector, or as a N-by-2 real numpy array.')\\r\\n else:\\r\\n z = z[:,0] + 1j*z[:,1]\\r\\n \\r\\n return z\",\n \"def complexify(self,z):\\r\\n \\r\\n import numpy as np\\r\\n \\r\\n if not np.iscomplex(z).any():\\r\\n if len(z.shape) != 2 or z.shape[1] != 2:\\r\\n raise Exception('Shape format not understood. Provide shape vertices either as a complex vector, or as a N-by-2 real numpy array.')\\r\\n else:\\r\\n z = z[:,0] + 1j*z[:,1]\\r\\n \\r\\n return z\",\n \"def complexify(self,z):\\r\\n \\r\\n import numpy as np\\r\\n \\r\\n if not np.iscomplex(z).any():\\r\\n if len(z.shape) != 2 or z.shape[1] != 2:\\r\\n raise Exception('Shape format not understood. Provide shape vertices either as a complex vector, or as a N-by-2 real numpy array.')\\r\\n else:\\r\\n z = z[:,0] + 1j*z[:,1]\\r\\n \\r\\n return z\",\n \"def complexify(self,z):\\r\\n \\r\\n import numpy as np\\r\\n \\r\\n if not np.iscomplex(z).any():\\r\\n if len(z.shape) != 2 or z.shape[1] != 2:\\r\\n raise Exception('Shape format not understood. Provide shape vertices either as a complex vector, or as a N-by-2 real numpy array.')\\r\\n else:\\r\\n z = z[:,0] + 1j*z[:,1]\\r\\n \\r\\n return z\",\n \"def complexify(self,z):\\r\\n \\r\\n import numpy as np\\r\\n \\r\\n if not np.iscomplex(z).any():\\r\\n if len(z.shape) != 2 or z.shape[1] != 2:\\r\\n raise Exception('Shape format not understood. Provide shape vertices either as a complex vector, or as a N-by-2 real numpy array.')\\r\\n else:\\r\\n z = z[:,0] + 1j*z[:,1]\\r\\n \\r\\n return z\",\n \"def complexify(self,z):\\r\\n \\r\\n import numpy as np\\r\\n \\r\\n if not np.iscomplex(z).any():\\r\\n if len(z.shape) != 2 or z.shape[1] != 2:\\r\\n raise Exception('Shape format not understood. Provide shape vertices either as a complex vector, or as a N-by-2 real numpy array.')\\r\\n else:\\r\\n z = z[:,0] + 1j*z[:,1]\\r\\n \\r\\n return z\",\n \"def complexify(self,z):\\r\\n \\r\\n import numpy as np\\r\\n \\r\\n if not np.iscomplex(z).any():\\r\\n if len(z.shape) != 2 or z.shape[1] != 2:\\r\\n raise Exception('Shape format not understood. Provide shape vertices either as a complex vector, or as a N-by-2 real numpy array.')\\r\\n else:\\r\\n z = z[:,0] + 1j*z[:,1]\\r\\n \\r\\n return z\",\n \"def complexify(self,z):\\r\\n \\r\\n import numpy as np\\r\\n \\r\\n if not np.iscomplex(z).any():\\r\\n if len(z.shape) != 2 or z.shape[1] != 2:\\r\\n raise Exception('Shape format not understood. Provide shape vertices either as a complex vector, or as a N-by-2 real numpy array.')\\r\\n else:\\r\\n z = z[:,0] + 1j*z[:,1]\\r\\n \\r\\n return z\",\n \"def complexify(self,z):\\r\\n \\r\\n import numpy as np\\r\\n \\r\\n if not np.iscomplex(z).any():\\r\\n if len(z.shape) != 2 or z.shape[1] != 2:\\r\\n raise Exception('Shape format not understood. Provide shape vertices either as a complex vector, or as a N-by-2 real numpy array.')\\r\\n else:\\r\\n z = z[:,0] + 1j*z[:,1]\\r\\n \\r\\n return z\",\n \"def complexify(self,z):\\r\\n \\r\\n import numpy as np\\r\\n \\r\\n if not np.iscomplex(z).any():\\r\\n if len(z.shape) != 2 or z.shape[1] != 2:\\r\\n raise Exception('Shape format not understood. Provide shape vertices either as a complex vector, or as a N-by-2 real numpy array.')\\r\\n else:\\r\\n z = z[:,0] + 1j*z[:,1]\\r\\n \\r\\n return z\",\n \"def _transform(self, matrix):\\n for x in list(self.keys()):\\n ar = self[x]\\n if len(ar.shape) == 2 and ar.shape[1] == 3:\\n self[x] = np.dot(matrix, ar.transpose()).transpose()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5212036","0.52045906","0.51515454","0.5148588","0.51139396","0.50830597","0.50787544","0.5040814","0.50208473","0.50208473","0.50208473","0.50208473","0.50208473","0.50208473","0.50208473","0.4996494","0.4929204","0.48569438","0.4855723","0.48394084","0.48311576","0.48142242","0.4800003","0.4796885","0.4753511","0.46930832","0.46629986","0.465945","0.46547583","0.4645742","0.46416187","0.461342","0.459783","0.459477","0.45888734","0.45876887","0.4578403","0.457459","0.456907","0.4566954","0.45667237","0.45639813","0.4555819","0.45495036","0.4547032","0.45421708","0.45372164","0.45322946","0.4524112","0.45201218","0.44981316","0.44918814","0.4488014","0.44856152","0.44850865","0.44762543","0.44760236","0.44750866","0.44699636","0.44678205","0.4466378","0.44651458","0.44636837","0.4463425","0.4452332","0.44469696","0.4446911","0.44461846","0.44443116","0.4439278","0.4435738","0.4435738","0.44315413","0.4431144","0.4431144","0.4431144","0.44162256","0.4412537","0.4409512","0.44074914","0.4406115","0.4406054","0.44043574","0.44041097","0.4400889","0.43939507","0.43899453","0.4385069","0.43843037","0.43802127","0.43802127","0.43802127","0.43802127","0.43802127","0.43802127","0.43802127","0.43802127","0.43802127","0.43802127","0.4379552"],"string":"[\n \"0.5212036\",\n \"0.52045906\",\n \"0.51515454\",\n \"0.5148588\",\n \"0.51139396\",\n \"0.50830597\",\n \"0.50787544\",\n \"0.5040814\",\n \"0.50208473\",\n \"0.50208473\",\n \"0.50208473\",\n \"0.50208473\",\n \"0.50208473\",\n \"0.50208473\",\n \"0.50208473\",\n \"0.4996494\",\n \"0.4929204\",\n \"0.48569438\",\n \"0.4855723\",\n \"0.48394084\",\n \"0.48311576\",\n \"0.48142242\",\n \"0.4800003\",\n \"0.4796885\",\n \"0.4753511\",\n \"0.46930832\",\n \"0.46629986\",\n \"0.465945\",\n \"0.46547583\",\n \"0.4645742\",\n \"0.46416187\",\n \"0.461342\",\n \"0.459783\",\n \"0.459477\",\n \"0.45888734\",\n \"0.45876887\",\n \"0.4578403\",\n \"0.457459\",\n \"0.456907\",\n \"0.4566954\",\n \"0.45667237\",\n \"0.45639813\",\n \"0.4555819\",\n \"0.45495036\",\n \"0.4547032\",\n \"0.45421708\",\n \"0.45372164\",\n \"0.45322946\",\n \"0.4524112\",\n \"0.45201218\",\n \"0.44981316\",\n \"0.44918814\",\n \"0.4488014\",\n \"0.44856152\",\n \"0.44850865\",\n \"0.44762543\",\n \"0.44760236\",\n \"0.44750866\",\n \"0.44699636\",\n \"0.44678205\",\n \"0.4466378\",\n \"0.44651458\",\n \"0.44636837\",\n \"0.4463425\",\n \"0.4452332\",\n \"0.44469696\",\n \"0.4446911\",\n \"0.44461846\",\n \"0.44443116\",\n \"0.4439278\",\n \"0.4435738\",\n \"0.4435738\",\n \"0.44315413\",\n \"0.4431144\",\n \"0.4431144\",\n \"0.4431144\",\n \"0.44162256\",\n \"0.4412537\",\n \"0.4409512\",\n \"0.44074914\",\n \"0.4406115\",\n \"0.4406054\",\n \"0.44043574\",\n \"0.44041097\",\n \"0.4400889\",\n \"0.43939507\",\n \"0.43899453\",\n \"0.4385069\",\n \"0.43843037\",\n \"0.43802127\",\n \"0.43802127\",\n \"0.43802127\",\n \"0.43802127\",\n \"0.43802127\",\n \"0.43802127\",\n \"0.43802127\",\n \"0.43802127\",\n \"0.43802127\",\n \"0.43802127\",\n \"0.4379552\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.52657586"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":87598,"cells":{"query":{"kind":"string","value":"Evaluates all occurrences of States to a float using Evaluater. It is done as intersection of particular state with given state and sum of resulting elements. If the result is nan, None is returned instead."},"document":{"kind":"string","value":"def evaluate(self, state) -> float:\n evaluater = Evaluater(state)\n result = evaluater.transform(self.expression)\n\n try:\n value = sympy.sympify(\"\".join(tree_to_string(result)), locals=evaluater.locals)\n if value == sympy.nan:\n return None\n return value\n except TypeError:\n return None"},"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 evaluate(self, state):\n\n fitness = np.sum(state)\n self.num_evals += 1\n #print(self.num_evals)\n return fitness","def evaluate(self, state):\n\n if self.is_coords and len(state) != len(self.coords):\n raise Exception(\"\"\"state must have the same length as coords.\"\"\")\n\n if not len(state) == len(set(state)):\n raise Exception(\"\"\"Each node must appear exactly once in state.\"\"\")\n\n if min(state) < 0:\n raise Exception(\"\"\"All elements of state must be non-negative\"\"\"\n + \"\"\" integers.\"\"\")\n\n if max(state) >= len(state):\n raise Exception(\"\"\"All elements of state must be less than\"\"\"\n + \"\"\" len(state).\"\"\")\n\n return self.calculate_fitness(state)","def evaluate(self, state):\n\n if len(state) != len(self.weights):\n raise Exception(\"\"\"The state array must be the same size as the\"\"\"\n + \"\"\" weight and values arrays.\"\"\")\n\n # Calculate total weight and value of knapsack\n total_weight = np.sum(state*self.weights)\n total_value = np.sum(state*self.values)\n\n # Allow for weight constraint\n if total_weight <= self._w:\n fitness = total_value\n else:\n fitness = 0\n self.num_evals += 1\n return fitness","def _evaluate(self, state):\n leading_power_error = self.get_leading_power_error(state)\n if np.isfinite(leading_power_error):\n return -float(leading_power_error)\n else:\n return self._default_value","def evaluate(self) :\n for inp in self.inStates :\n if inp.getState() == 1 : return 1\n return 0","def computeValueFromQValues(self, state):\n bestAction = self.computeActionFromQValues(state)\n if bestAction == None:\n return 0.0\n return self.getQValue(state, bestAction)","def evaluate(self, state):\n _n = len(state)\n _t = np.ceil(self.t_pct*_n)\n\n # Calculate head and tail values\n tail_0 = self.tail(0, state)\n head_1 = self.head(1, state)\n\n # Calculate R(X, T)\n if (tail_0 > _t and head_1 > _t):\n _r = _n\n else:\n _r = 0\n\n # Evaluate function\n fitness = max(tail_0, head_1) + _r\n self.num_evals += 1\n return fitness","def evaluate(self) :\n for inp in self.inStates :\n if inp.getState() == 0 : return 0\n return 1","def computeValueFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n valueList = []\n ############################################################################################################ Eric Changed state to self.index\n for a in state.getLegalActions(self.index):\n valueList.append(self.getQValue(state, a))\n if len(valueList) == 0:\n return 0.0\n return max(valueList)\n\n\n util.raiseNotDefined()","def evaluate(self) :\n if self.inStates[0].getState() == self.inStates[1].getState(): return 0\n return 1","def _get_values(self, hash: str) -> float:\n if hash not in self.states:\n values = 0.0\n else:\n values = self.states[hash]\n\n return values","def evaluate(self, state):\n abstract","def fval_function(sN, weight):\n#IMPLEMENT\n \n #Many searches will explore nodes (or states) that are ordered by their f-value.\n #For UCS, the fvalue is the same as the gval of the state. For best-first search, the fvalue is the hval of the state.\n #You can use this function to create an alternate f-value for states; this must be a function of the state and the weight.\n #The function must return a numeric f-value.\n #The value will determine your state's position on the Frontier list during a 'custom' search.\n #You must initialize your search engine object as a 'custom' search engine if you supply a custom fval function.\n return 0","def EvaluateFunction(self, p_float=..., p_float=..., p_float=...):\n ...","def calc_q_values_1(self, state):\n return self._sess.run(self._q_pred_1,\n feed_dict={self._state_placeholder:state});","def estimate(self, states):\n scores = [state.get_score() for state in states]\n return np.array([score[0] - score[1] for score in scores])","def f1(predictions, gold):\n if len(gold) == 0:\n return 1. if len(predictions) == 0 else 0.\n if len(predictions) == 0:\n return 0.\n predictions_set = set(predictions)\n gold_set = set(gold)\n nom = 2 * len(predictions_set.intersection(gold_set))\n denom = len(predictions_set) + len(gold_set)\n return float(nom)/float(denom)","def evaluate_ising(linear, quad, state):\n\n # If we were given a numpy array cast to list\n if _numpy and isinstance(state, np.ndarray):\n return evaluate_ising(linear, quad, state.tolist())\n\n # Accumulate the linear and quadratic values\n energy = 0.0\n for index, value in uniform_iterator(linear):\n energy += state[index] * value\n for (index_a, index_b), value in six.iteritems(quad):\n energy += value * state[index_a] * state[index_b]\n return energy","def eval(self, state):\n valueOfPlayers = 0\n valueOfRebelAdvancments = 0\n valueOfLocations = 0\n\n\n\n for coordinate in state.gameState:\n if state.gameState[coordinate]==state.blank:\n continue\n elif state.gameState[coordinate]==state.rebel:\n valueOfRebelAdvancments = -coordinate[0]\n elif state.gameState[coordinate]==state.jedi:\n continue\n elif state.gameState[coordinate]==state.sith:\n continue\n \n valueOfLocations += valueOfRebelAdvancments\n\n \n valueOfPlayers = state.numRebels + 4*state.numJedi - 4*state.numSith\n \n return valueOfPlayers*4 + valueOfLocations","def evals_result(self):\n if self.evals_result_:\n evals_result = self.evals_result_\n else:\n raise XGBoostError('No results.')\n\n return evals_result","def evals_result(self):\n if self.evals_result_:\n evals_result = self.evals_result_\n else:\n raise XGBoostError('No results.')\n\n return evals_result","def calc_q_values(self, state):\n return self._sess.run(self._q_pred_0,\n feed_dict={self._state_placeholder:state});","def evaluateState(self, gameState, currIndex):\n score = gameState.getScore()\n scoreScore = score * 100\n # If current \n if currIndex in gameState.getRedTeamIndices():\n foodLocations = gameState.getBlueFood().asList()\n foodScore = 900-(self.getMinFoodDistance(gameState.getAgentPosition(currIndex), foodLocations))\n scoreScore = score * 1000\n else:\n foodLocations = gameState.getRedFood().asList()\n foodScore = -(self.getMinFoodDistance(gameState.getAgentPosition(currIndex), foodLocations))\n scoreScore = -(score * 1000)\n return foodScore + scoreScore","def evaluator(self, candidates, args):\r\n fitness = []\r\n if self._use_ants:\r\n for candidate in candidates:\r\n total = 0\r\n for c in candidate:\r\n total += self.weights[c.element[0]][c.element[1]]\r\n last = (candidate[-1].element[1], candidate[0].element[0])\r\n total += self.weights[last[0]][last[1]]\r\n fitness.append(1 / total)\r\n else:\r\n for candidate in candidates:\r\n total = 0\r\n for src, dst in zip(candidate, candidate[1:] + [candidate[0]]):\r\n total += self.weights[src][dst]\r\n fitness.append(1 / total)\r\n return fitness","def computevaluefromqvalues(self, state):\n legalactions = env.getlegalactions(deepcopy(env.state_to_array(state)))\n if len(legalactions) == 0:\n return 0.0\n tmp = Counter()\n for action in legalactions:\n tmp[action] = self.getqvalue(state, action)\n return tmp[tmp.argMax()]","def computeValueFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n\n legal_actions = self.getLegalActions(state)\n\n if len(legal_actions) == 0:\n return 0.0\n\n return max([self.getQValue(str(state), action) for action in legal_actions])","def computeValueFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n\n legal_actions = self.getLegalActions(state)\n\n if len(legal_actions) == 0:\n return 0.0\n\n return max([self.getQValue(state, action) for action in legal_actions])","def computeValueFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n\n legal_actions = self.getLegalActions(state)\n\n if len(legal_actions) == 0:\n return 0.0\n\n return max([self.getQValue(state, action) for action in legal_actions])","def computeValueFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n\n legal_actions = self.getLegalActions(state)\n\n if len(legal_actions) == 0:\n return 0.0\n\n return max([self.getQValue(state, action) for action in legal_actions])","def computeValueFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n\n legal_actions = self.getLegalActions(state)\n\n if len(legal_actions) == 0:\n return 0.0\n\n return max([self.getQValue(state, action) for action in legal_actions])","def evaluate(self, state):\n\n fitness = 0\n\n for i in range(1, len(state)):\n if state[i] != state[i - 1]:\n fitness += 1\n\n return fitness","def calc_q_values(self, state):\n return self.q_values_func([state])[0]","def computeValueFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n actions = self.getLegalActions(state)\n if len(actions) == 0:\n return 0.0\n values = [self.getQValue(state, action) for action in actions]\n return max(values)","def fval_function(sN, weight):\r\n # IMPLEMENT\r\n\r\n # Many searches will explore nodes (or states) that are ordered by their f-value.\r\n # For UCS, the fvalue is the same as the gval of the state. For best-first search, the fvalue is the hval of the state.\r\n # You can use this function to create an alternate f-value for states; this must be a function of the state and the weight.\r\n # The function must return a numeric f-value.\r\n # The value will determine your state's position on the Frontier list during a 'custom' search.\r\n # You must initialize your search engine object as a 'custom' search engine if you supply a custom fval function.\r\n\r\n\r\n return (1 - weight) * sN.gval + weight * sN.hval","def compute_qvalues(self, state):\n return self.model.predict([np.expand_dims(item, 0) for item in state])[0]","def computeQValueFromValues(self, state, action):\n newState_prob = self.mdp.getTransitionStatesAndProbs(state, action)\n sum = 0\n for i in newState_prob:\n sum += i[1]*(self.mdp.getReward(state, action, i[0])+(self.discount*self.getValue(i[0])))\n return sum \n \n util.raiseNotDefined()","def result (result = None):\n if result is not None:\n results.append (float (result))\n\n if len (results) < self.min_count:\n return None, None\n\n result_mean = functools.reduce (operator.add, results, 0) / len (results)\n result_error = (functools.reduce (operator.add,\n ((result - result_mean)**2 for result in results), 0) / (len (results) - 1))\n return result_mean, result_error","def evaluate_direct(self, values, params) -> float:\n evaluater = DirectEvaluater(values, params)\n result = evaluater.transform(self.expression)\n\n try:\n value = sympy.sympify(\"\".join(tree_to_string(result)))\n if value == sympy.nan:\n return None\n return value\n except TypeError:\n return None","def _evaluate(self, state):\n input_values_rmse = self.get_input_values_rmse(state)\n if not self._include_leading_powers:\n if np.isfinite(input_values_rmse):\n return -input_values_rmse\n else:\n return self._default_value\n # NOTE(leeley): If computing the leading power fails\n # (timeout or sympy ValueError) or functions in symbolic_properties return\n # nan (for example, 1 / (x - x)).\n leading_power_error = self.get_leading_power_error(state)\n\n if self._hard_penalty_default_value is None:\n # Soft penalty.\n if np.isfinite(leading_power_error):\n return -input_values_rmse - leading_power_error\n else:\n return self._default_value\n else:\n # Hard penalty.\n if (np.isfinite(leading_power_error)\n and np.isclose(leading_power_error, 0)):\n return -input_values_rmse\n else:\n return self._hard_penalty_default_value","def evaluator(self, candidates, args):\r\n fitness = []\r\n if self._use_ants:\r\n for candidate in candidates:\r\n total = 0\r\n for c in candidate:\r\n total += c.value\r\n fitness.append(total)\r\n else:\r\n for candidate in candidates:\r\n total_value = 0\r\n total_weight = 0\r\n for c, i in zip(candidate, self.items):\r\n total_weight += c * i[0]\r\n total_value += c * i[1]\r\n if total_weight > self.capacity:\r\n fitness.append(self.capacity - total_weight)\r\n else:\r\n fitness.append(total_value)\r\n return fitness","def get_value(self, state):\n epsilon = self.epsilon\n possible_actions = self.get_legal_actions(state)\n\n #If there are no legal actions, return 0.0\n if len(possible_actions) == 0:\n return 0.0\n\n optimal_action = possible_actions[\n np.argmax([self.get_qvalue(state, action) for action in possible_actions])\n ]\n state_value = 0\n for action in possible_actions:\n if action == optimal_action:\n state_value += (1 - epsilon) * self.get_qvalue(state, action)\n state_value += (epsilon / len(possible_actions)) * self.get_qvalue(state, action)\n return state_value","def evaluate(self,**d):\r\n\t\t\r\n\t\t# evaluate terms\r\n\t\tv = [i.evaluate(**d) for i in self]\r\n\t\t\r\n\t\t# sum results\r\n\t\tc = Pa(v).sum()\r\n\t\t\r\n\t\treturn c","def computeValueFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n if not self.getLegalActions(state): return 0\n\n best_action = self.computeActionFromQValues(state)\n return self.getQValue(state, best_action)","def calculate(self) :\n #self.graph\n self.val_i = 0\n while (len(self.undefined_vertices) > 0) :\n cond = True\n while cond:\n cond = False\n for node in self.undefined_vertices:\n if self.condition_satisfied(node, self.val_i) :\n cond = True\n self.undefined_vertices.remove(node)\n self.val_l[node] = self.val_i\n self.val_c[node] = self.val_m\n self.val_m += 1\n for node in self.undefined_vertices:\n if self.val_i not in [self.val_l[n] for n in\n self.graph.next_nodes(node)]:\n self.undefined_vertices.remove(node)\n self.val_l[node] = self.infinity\n self.val_c[node] = 0\n self.val_i += 1\n self.graph.save_graph(\"check\")\n self.save(\"this.value\")\n return self.graph.to_dictionary(), self.val_l, self.val_c","def __evaluateLocal__(self,featureVals):\n returnEvaluation = {self.pivotParameterID:self.pivotValues}\n for target in list(set(self.target) - set([self.pivotParameterID])):\n reconstructData = self._reconstructData(target).real\n # find the nearest data and compute weights\n if len(reconstructData) > 1:\n weights, indexes = self.KDTreeFinder.query(featureVals, k=min(2**len(self.features),len(reconstructData)))\n # if 0 (perfect match), assign minimum possible distance\n weights[weights == 0] = sys.float_info.min\n weights =1./weights\n # normalize to 1\n weights = weights/weights.sum()\n for point in range(len(weights)):\n returnEvaluation[target] = np.sum ((weights[point,:]*reconstructData[indexes[point,:]].T) , axis=1)\n else:\n returnEvaluation[target] = reconstructData[0]\n\n return returnEvaluation","def evaluate(self):\n return self._evaluate_recur(self.root())","def evaluate(self):\n return self._evaluate_recur(self.root())","def _evaluate(self, x, y, z):\n if _isscalar(x):\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\n z_pos = max(min(self.zSearchFunc(self.z_list, z), self.z_n - 1), 1)\n else:\n x_pos = self.xSearchFunc(self.x_list, x)\n x_pos[x_pos < 1] = 1\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\n y_pos = self.ySearchFunc(self.y_list, y)\n y_pos[y_pos < 1] = 1\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\n z_pos = self.zSearchFunc(self.z_list, z)\n z_pos[z_pos < 1] = 1\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\n alpha = (x - self.x_list[x_pos - 1]) / (\n self.x_list[x_pos] - self.x_list[x_pos - 1]\n )\n beta = (y - self.y_list[y_pos - 1]) / (\n self.y_list[y_pos] - self.y_list[y_pos - 1]\n )\n gamma = (z - self.z_list[z_pos - 1]) / (\n self.z_list[z_pos] - self.z_list[z_pos - 1]\n )\n f = (\n (1 - alpha)\n * (1 - beta)\n * (1 - gamma)\n * self.f_values[x_pos - 1, y_pos - 1, z_pos - 1]\n + (1 - alpha)\n * (1 - beta)\n * gamma\n * self.f_values[x_pos - 1, y_pos - 1, z_pos]\n + (1 - alpha)\n * beta\n * (1 - gamma)\n * self.f_values[x_pos - 1, y_pos, z_pos - 1]\n + (1 - alpha) * beta * gamma * self.f_values[x_pos - 1, y_pos, z_pos]\n + alpha\n * (1 - beta)\n * (1 - gamma)\n * self.f_values[x_pos, y_pos - 1, z_pos - 1]\n + alpha * (1 - beta) * gamma * self.f_values[x_pos, y_pos - 1, z_pos]\n + alpha * beta * (1 - gamma) * self.f_values[x_pos, y_pos, z_pos - 1]\n + alpha * beta * gamma * self.f_values[x_pos, y_pos, z_pos]\n )\n return f","def calculate(self) -> float:","def evaluate(self) -> Dict[str, float]:\n eval_dataloader = self.get_eval_dataloader()\n\n output = self._prediction_loop(eval_dataloader, description=\"Evaluation\")\n return output.metrics","def computeQValueFromValues(self, state, action):\n #get the Transition function and nextStates\n state_prob_pair=self.mdp.getTransitionStatesAndProbs(state,action)\n #initialize the value to zero\n actual_value=0\n #iterate over probabilities (transition functions) and next states\n for pair in state_prob_pair:\n #compute qvalue\n actual_value+=pair[1]*(self.mdp.getReward(state,action,pair[0])+self.discount*self.values[pair[0]])\n #print \"The Q value is \",actual_value\n return actual_value","def on_aggregate_evaluate(\n self,\n rnd: int,\n results: List[Tuple[ClientProxy, EvaluateRes]],\n failures: List[BaseException],\n ) -> Optional[float]:\n if not results:\n return None\n\n # Check if enough results are available\n completion_rate = len(results) / (len(results) + len(failures))\n if completion_rate < self.min_completion_rate_evaluate:\n # Not enough results for aggregation\n return None\n\n return weighted_loss_avg([evaluate_res for _, evaluate_res in results])","def computeQValueFromValues(self, state, action):\n totalsum = 0\n reward = 0\n for nextstate, transition in self.mdp.getTransitionStatesAndProbs(state, action):\n reward = self.mdp.getReward(state, action, nextstate)\n totalsum += transition * (reward + self.discount * self.getValue(nextstate)) # right way to access previous value?\n return totalsum","def computeQValueFromValues(self, state, action):\n \"*** YOUR CODE HERE ***\"\n transition_state_probs = self.mdp.getTransitionStatesAndProbs(state, action)\n # Add each state and probability to q_value\n q_value = 0\n for state_, probability in transition_state_probs:\n state_reward = self.mdp.getReward(state, state_, action)\n q_value += probability * (state_reward + self.discount * self.values[state_])\n return q_value","def critic_compute_vvalue(dict_states, val_func):\n\n values = val_func.predict(dict_states['states'])\n dict_states['values'] = values","def __call__(self, observation):\n # Validates that the state variable is a scalar with this float() call.\n current_val = float(observation[self.dict_key])\n retval = current_val - self.last_val\n self.last_val = current_val\n return retval","def evaluate(self, values):\r\n return self.left.evaluate(values) - self.right.evaluate(values)","def all_nan_result(self):\n if self._all_nan_result is None:\n result_files = glob.glob(\n os.path.join(self.location, \"results\", RSLT_NM.format(\"*\"))\n )\n if not result_files:\n raise XYZError(\n \"To infer an all-nan result requires at least \"\n \"one finished result.\"\n )\n reference_result = read_from_disk(result_files[0])[0]\n self._all_nan_result = nan_like_result(reference_result)\n\n return self._all_nan_result","def evaluate(state):\n if wins(state, COMP):\n score = -1\n elif wins(state, HUMAN):\n score = 1\n else:\n score = 0\n\n return score","def result(self):\n tp = self.true_positive.read_value()\n fn = self.false_negative.read_value()\n return math_ops.div_no_nan(tp, tp + fn)","def computeQValueFromValues(self, state, action):\n #get all possible actions from current state\n possibleActions = self.mdp.getPossibleActions(state)\n\n #if action is illegal return 0\n if action in possibleActions:\n transitions = self.mdp.getTransitionStatesAndProbs(state, action)\n returnVal = 0\n index = 0\n\n #loop through all trainsitions/probabilities\n while index < len(transitions):\n #This returns s' and T(s, a, s')\n (nextState, prob) = transitions[index]\n\n\n #This returns R(s,a,s')\n rewardVal = self.mdp.getReward(state, action, nextState)\n\n #This is gamma * V(s')\n lastPartOfEquation = self.values[nextState] *self.discount\n\n #This is T(s, a, s')[R(s, a, s') + gamma * V(s'). Bellman equation\n returnVal = returnVal + prob * (rewardVal + lastPartOfEquation)\n index = index + 1\n\n return returnVal\n else:\n return 0","def calculate(self):\n if all( map( lambda x: isinstance(x, N),self.args) ):\n return self.evaluate()\n else:\n return self.__class__( map(operator.methodcaller('calculate'), self.args))\n #return self.__class__( (self.args[0].calculate(), self.args[1].calculate()) )","def computeQValueFromValues(self, state, action):\n \"*** YOUR CODE HERE ***\"\n qValue = 0\n transitions = self.mdp.getTransitionStatesAndProbs(state, action)\n #print('Transitions: ' + str(transitions))\n for t in transitions:\n nextState, prob = t\n reward = self.mdp.getReward(state, action, nextState)\n #print('Reward: ' + str(reward))\n oneTransition = prob * (reward + self.discount * self.values[nextState])\n qValue = qValue + oneTransition\n return qValue","def evaluate(state):\r\n if wins(state, COMP):\r\n score = +1\r\n elif wins(state, HUMAN):\r\n score = -1\r\n else:\r\n score = 0\r\n\r\n return score","def scoreEvaluationFunction(gameState):\n return gameState.getScore()","def compute(self, event=None, zs=None, thetas=None, nhats=None):\n\n\n if self.strassen:\n return self._strassen_compute(event, zs, thetas)\n else:\n return self._efp_compute(event, zs, thetas, nhats)","def evaluate(self, representativeness: float, weight: float) -> float:\n pass","def _squad_compute(f1: Tensor, exact_match: Tensor, total: Tensor) ->Dict[str, Tensor]:\n exact_match = 100.0 * exact_match / total\n f1 = 100.0 * f1 / total\n return {'exact_match': exact_match, 'f1': f1}","def evaluate(self, x):\n # type: (array) -> SupportsFloat\n from interruptingcow import timeout\n self.reset()\n self.setParameterVector(x)\n self.quantity_residuals = dict((quantity,list()) for quantity in self.measurement_map)\n def worker():\n self.buildResidualList()\n if self.divergent():\n return 1e9*self.penalty_scale\n try:\n with timeout(10, StalledSimulation):\n worker()\n except (RuntimeError, StalledSimulation):\n # if convergence fails, use a penalty score\n return 1e9*self.penalty_scale\n print('evaluate')\n # for quantity,residuals in self.quantity_residuals.items():\n # print(quantity,mean(array(residuals)**2.),self.mean_measurement_map[quantity])\n return sqrt(mean(array([\n mean(array(residuals)**2.)/self.mean_measurement_map[quantity]**2. \\\n for quantity,residuals in self.quantity_residuals.items() \\\n ])))","def eval_fis(self,fis):\n #res = 0.0\n #for cl_state in self.classes:\n # res += cl_state.eval_fis(fis)\n #print \"=>\",res\n #return 1.0/res\n try:\n correct,count = self.quality_fis(fis)\n except Exception as err:\n print err\n correct = 0\n return correct","def f(self, x):\n\n # Initialize\n n = len(x)\n f_val = 0.0\n\n # Loop through averaging\n for i in range(self.num_avg):\n try:\n f_val += self.fun(x, *self.args)\n except AttributeError:\n f_val += self.fun(x, *self.args)\n with self.eval_calls.get_lock():\n self.eval_calls.value += 1\n \n # Compute average\n f_val = f_val*self.avg_inv\n\n # Print out\n msg = \"{0:>20}\".format(f_val)\n for value in x:\n msg += \", {0:>20}\".format(value)\n self.queue.put(msg)\n\n return f_val","def compute_values(self, update_statistics=False):\n\n self.compute_iterations()\n self.axsec = sum([one.axsec for one in self])\n self.xsec = sum([one.xsec for one in self])\n self.xerrc = sum([one.xerrc for one in self])\n self.xerru = math.sqrt(sum([one.xerru**2 for one in self]))\n\n self.nevents = sum([one.nevents for one in self])\n self.nw = sum([one.nw for one in self])\n self.maxit = len(self.yerr_iter) # \n self.nunwgt = sum([one.nunwgt for one in self]) \n self.wgt = 0\n self.luminosity = min([0]+[one.luminosity for one in self])\n if update_statistics:\n self.run_statistics.aggregate_statistics([_.run_statistics for _ in self])","def evaluate(self):\n eval_list = nx.topological_sort(self.graph)\n for n in eval_list:\n n.evaluate()\n print(\"evaluating type\", type(n))\n\n # Notify observers of finished calculation\n self.notifyObservers(\"EVALUATION DONE\")\n return \"FINISHED\"","def evaluate(self) -> int:","def evaluate(self,p):\n if not self.initialized: self.__initialize__()\n if self.vp0: p_ = 1-p\n else: p_ = p\n if self.ids_to_consider is None:\n #sum on all parametrized cell\n cf = np.sum(self.V[self.p_ids-1]*p_)/self.V_tot - self.max_v_frac\n else:\n cf = np.sum((self.V[self.ids_to_consider-1]*p_))/self.V_tot - self.max_v_frac\n return cf","def evaluate(self, prediction_fn):\n pass","def compute(self) -> Tuple[float, float, float]:\n # @TODO: ddp hotfix, could be done better\n if self._is_ddp:\n for key in self.statistics:\n value: List[float] = all_gather(self.statistics[key])\n value: float = sum(value)\n self.statistics[key] = value\n\n precision_value, recall_value, f1_value = get_binary_metrics(\n tp=self.statistics[\"tp\"],\n fp=self.statistics[\"fp\"],\n fn=self.statistics[\"fn\"],\n zero_division=self.zero_division,\n )\n return precision_value, recall_value, f1_value","def evaluate(self):\n raise NotImplementedError(\"Abstract method\")","def sum_evaluations(evaluations):\n\n def add_evaluations(e1, e2):\n \"\"\"Add two evaluations.\n\n If Signs do not have detections the distance is -1, therefore the distance needs\n to be handled separately.\n \"\"\"\n true_positive = e1[0] + e2[0]\n false_positive = e1[1] + e2[1]\n distance = e1[2] + e2[2]\n if e1[2] < 0 and e2[2] < 0:\n distance = -1\n elif e1[2] < 0:\n distance = e2[2]\n elif e2[2] < 0:\n distance = e1[2]\n return true_positive, false_positive, distance\n\n length = len(evaluations)\n tp, fp, d = functools.reduce(add_evaluations, evaluations)\n return tp, fp, float(d) / float(length)","def compValFromState(self, state):\n \"*** YOUR CODE HERE ***\"\n # print \"compValFromState\"\n #actions = self.getLegalActions(state)\n # if len(actions) == 0:\n # return 0.0\n # values = [self.getQValue() for action in actions]\n return self.getQValue(state, None)","def __call__(self, state, action):\n s = float(state.__hash__()) # pybrain secretly casts state to float when we do rl\n a = int(action)\n qvalues = self.module.getActionValues(s)\n maxq = max(qvalues)\n if qvalues[a] == maxq:\n n_max = sum([1 if q == maxq else 0 for q in qvalues])\n return 1.0 / n_max\n return 0","def run_solution1(self):\n return reduce(lambda a, b: a + self.calculate_fuel(b), self.data, 0)","def get_instance_evidence_f1(\n gold_sentence_keys: List[str],\n predicted_sentence_key: List[str],\n all_non_empty_sentence_key: List[str]\n) -> float:\n\n gold_labels: List[str] = []\n predicted_labels: List[str] = []\n for key in all_non_empty_sentence_key:\n gold_label: str = 'evidence' if key in gold_sentence_keys else 'neutral'\n pred_label: str = 'evidence' if key in predicted_sentence_key else 'neutral'\n gold_labels.append(gold_label)\n predicted_labels.append(pred_label)\n\n assert len(predicted_labels) == len(all_non_empty_sentence_key)\n\n # zero division=1 because it is correct to select none if none exists\n return f1_score(gold_labels, predicted_labels, pos_label='evidence', zero_division=1)","def evaluate(self):\n raise NotImplementedError()","def test_const_evaluate():\n pop = test_population\n pop = ops.const_evaluate(pop, value=123456789.0)\n \n for ind in pop:\n assert(pytest.approx(123456789.0) == ind.fitness)","def evaluate(self, stochastic=False):\n ob = self._convert_state(self._env.reset())\n done = False\n actions = []\n sum_rew = 0\n while not done:\n ac, _ = self._act(ob, stochastic=stochastic)\n actions.append(ac)\n ob, rew, done, _ = self._env.step(ac)\n ob = self._convert_state(ob)\n sum_rew += rew\n self.ob = self._convert_state(self._env.reset())\n self.new = True\n return sum_rew, actions","def evaluate(self) :\n pass","def eval(self):\n results = [expr.eval() if isinstance(expr, Symbol)\n else expr for expr in self.args]\n\n if len(results) == 1: return self.op()(results[0])\n try:\n result = reduce(self.op(),results)\n return result\n except ZeroDivisionError:\n raise DivideByZeroError(self.dictionary(),self.name())","def evaluate(self, pred, **nargs):\n sse = sum((pred(u, ds=self, **nargs) - (1 if g == \"F\" else 0)) ** 2\n for (u, g) in self.gender_test.items())\n\n ll = 0\n for (u, g) in self.gender_test.items():\n for prn in [pred(u, ds=self, **nargs)]:\n if g == 'F' and prn == 0:\n ll = math.inf\n break\n elif g == 'F':\n ll += math.log(prn, 2)\n elif g == 'M' and prn == 1:\n ll = math.inf\n break\n else:\n ll += math.log(1 - prn, 2)\n\n return (sse, -ll, sse / len(self.gender_test), -ll / len(self.gender_test))","def result(self):\n tp = self.true_positive\n fp = self.false_positive\n return math_ops.div_no_nan(tp, tp + fp)","def value(self, state):\n num_visits = len(state)\n value = 0\n\n for i in range(1, num_visits):\n try:\n value += distances[(state[i-1], state[i])]\n except KeyError:\n value += distances[(state[i], state[i - 1])]\n\n value = -1 * value\n\n return value","def evaluate_state(state):\n\n my_score = get_action_score(state.action[0], state.action[1], state.action_player, state.occupied)\n other_score = get_action_score(state.action[0], state.action[1], state.player, state.occupied)\n \n return max(my_score, other_score)","def calcFidelity(self, state):\n \n obj1 = qutip.Qobj(self.rho)\n obj2 = qutip.Qobj(state.rho)\n \n F =qutip.metrics.fidelity(obj1, obj2)\n return (F)","def computeQValueFromValues(self, state, action):\n\n ##util.raiseNotDefined()\n #\"*** YOUR CODE STARTS HERE ***\"\n # Code to remove --- from here\n transitions = self.mdp.getTransitionStatesAndProbabilities(state, action)\n qvalue = 0\n for (nextState, probability) in transitions:\n reward = self.mdp.getReward(state, action, nextState)\n qvalue += probability *(reward + self.discount*self.values[nextState])\n # Code to remove --- to here\n #\"*** YOUR CODE FINISHES HERE ***\"\n \n return qvalue","def multi_score(self, r, s, f):\n return [None] if r is None else [0.0] if s is None else [f(x, y)\n for y in self.ensure_list(s)\n for x in self.ensure_list(r)]","def evaluate(net, data_loader):\n correct = 0\n total = 0\n net.reset()\n for data in tqdm(data_loader):\n inputs, output = data\n mask, score = gate_activation(net, inputs.view(-1))\n selected_score = score[mask]\n if selected_score.size == 0:\n xo = 0.5\n else:\n xo = np.sum(selected_score) / selected_score.size\n print()\n print()\n print(\"mask\", mask)\n print(\"score\", score)\n print(\"xo\", xo)\n total += 1\n correct += ((xo > 0.5) == output[0].item())\n\n return float(correct)/total","def evaluate(pred_file, ref_file):\n ref_dict, pred_dict, query_dict, id_dict = build_pred_ref_dict(ref_file, pred_file, ref_file)\n total, acc, scores = res_eval_with_type_acc(query_dict, pred_dict, ref_dict, id_dict, save=False)\n em = calculate_exact_match(pred_dict, ref_dict)\n print('Comp Acc: {:.3f}%\\tBleu-4: {:.3f}\\tRouge-L: {:.3f}'.format(acc, scores['Bleu-4'], scores['Rouge-L']))\n print('EM: {:.3f}%'.format(em))\n # calculate_sketch_type_acc(ref_file, pred_file)\n # calculate_exact_match_for_each_q_type(ref_file, pred_file)\n return total, acc, scores, em","def evaluate(self):\n pass","def evaluate(self):\n pass","def evaluate_predictions(predictions, actual):\n sum = 0\n for estimate, real in zip(predictions, actual):\n real = 1 if real==0 else real\n sum += pow((float(real) - estimate)/real, 2)\n return pow(sum/len(actual), 0.5)"],"string":"[\n \"def evaluate(self, state):\\n\\n fitness = np.sum(state)\\n self.num_evals += 1\\n #print(self.num_evals)\\n return fitness\",\n \"def evaluate(self, state):\\n\\n if self.is_coords and len(state) != len(self.coords):\\n raise Exception(\\\"\\\"\\\"state must have the same length as coords.\\\"\\\"\\\")\\n\\n if not len(state) == len(set(state)):\\n raise Exception(\\\"\\\"\\\"Each node must appear exactly once in state.\\\"\\\"\\\")\\n\\n if min(state) < 0:\\n raise Exception(\\\"\\\"\\\"All elements of state must be non-negative\\\"\\\"\\\"\\n + \\\"\\\"\\\" integers.\\\"\\\"\\\")\\n\\n if max(state) >= len(state):\\n raise Exception(\\\"\\\"\\\"All elements of state must be less than\\\"\\\"\\\"\\n + \\\"\\\"\\\" len(state).\\\"\\\"\\\")\\n\\n return self.calculate_fitness(state)\",\n \"def evaluate(self, state):\\n\\n if len(state) != len(self.weights):\\n raise Exception(\\\"\\\"\\\"The state array must be the same size as the\\\"\\\"\\\"\\n + \\\"\\\"\\\" weight and values arrays.\\\"\\\"\\\")\\n\\n # Calculate total weight and value of knapsack\\n total_weight = np.sum(state*self.weights)\\n total_value = np.sum(state*self.values)\\n\\n # Allow for weight constraint\\n if total_weight <= self._w:\\n fitness = total_value\\n else:\\n fitness = 0\\n self.num_evals += 1\\n return fitness\",\n \"def _evaluate(self, state):\\n leading_power_error = self.get_leading_power_error(state)\\n if np.isfinite(leading_power_error):\\n return -float(leading_power_error)\\n else:\\n return self._default_value\",\n \"def evaluate(self) :\\n for inp in self.inStates :\\n if inp.getState() == 1 : return 1\\n return 0\",\n \"def computeValueFromQValues(self, state):\\n bestAction = self.computeActionFromQValues(state)\\n if bestAction == None:\\n return 0.0\\n return self.getQValue(state, bestAction)\",\n \"def evaluate(self, state):\\n _n = len(state)\\n _t = np.ceil(self.t_pct*_n)\\n\\n # Calculate head and tail values\\n tail_0 = self.tail(0, state)\\n head_1 = self.head(1, state)\\n\\n # Calculate R(X, T)\\n if (tail_0 > _t and head_1 > _t):\\n _r = _n\\n else:\\n _r = 0\\n\\n # Evaluate function\\n fitness = max(tail_0, head_1) + _r\\n self.num_evals += 1\\n return fitness\",\n \"def evaluate(self) :\\n for inp in self.inStates :\\n if inp.getState() == 0 : return 0\\n return 1\",\n \"def computeValueFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n valueList = []\\n ############################################################################################################ Eric Changed state to self.index\\n for a in state.getLegalActions(self.index):\\n valueList.append(self.getQValue(state, a))\\n if len(valueList) == 0:\\n return 0.0\\n return max(valueList)\\n\\n\\n util.raiseNotDefined()\",\n \"def evaluate(self) :\\n if self.inStates[0].getState() == self.inStates[1].getState(): return 0\\n return 1\",\n \"def _get_values(self, hash: str) -> float:\\n if hash not in self.states:\\n values = 0.0\\n else:\\n values = self.states[hash]\\n\\n return values\",\n \"def evaluate(self, state):\\n abstract\",\n \"def fval_function(sN, weight):\\n#IMPLEMENT\\n \\n #Many searches will explore nodes (or states) that are ordered by their f-value.\\n #For UCS, the fvalue is the same as the gval of the state. For best-first search, the fvalue is the hval of the state.\\n #You can use this function to create an alternate f-value for states; this must be a function of the state and the weight.\\n #The function must return a numeric f-value.\\n #The value will determine your state's position on the Frontier list during a 'custom' search.\\n #You must initialize your search engine object as a 'custom' search engine if you supply a custom fval function.\\n return 0\",\n \"def EvaluateFunction(self, p_float=..., p_float=..., p_float=...):\\n ...\",\n \"def calc_q_values_1(self, state):\\n return self._sess.run(self._q_pred_1,\\n feed_dict={self._state_placeholder:state});\",\n \"def estimate(self, states):\\n scores = [state.get_score() for state in states]\\n return np.array([score[0] - score[1] for score in scores])\",\n \"def f1(predictions, gold):\\n if len(gold) == 0:\\n return 1. if len(predictions) == 0 else 0.\\n if len(predictions) == 0:\\n return 0.\\n predictions_set = set(predictions)\\n gold_set = set(gold)\\n nom = 2 * len(predictions_set.intersection(gold_set))\\n denom = len(predictions_set) + len(gold_set)\\n return float(nom)/float(denom)\",\n \"def evaluate_ising(linear, quad, state):\\n\\n # If we were given a numpy array cast to list\\n if _numpy and isinstance(state, np.ndarray):\\n return evaluate_ising(linear, quad, state.tolist())\\n\\n # Accumulate the linear and quadratic values\\n energy = 0.0\\n for index, value in uniform_iterator(linear):\\n energy += state[index] * value\\n for (index_a, index_b), value in six.iteritems(quad):\\n energy += value * state[index_a] * state[index_b]\\n return energy\",\n \"def eval(self, state):\\n valueOfPlayers = 0\\n valueOfRebelAdvancments = 0\\n valueOfLocations = 0\\n\\n\\n\\n for coordinate in state.gameState:\\n if state.gameState[coordinate]==state.blank:\\n continue\\n elif state.gameState[coordinate]==state.rebel:\\n valueOfRebelAdvancments = -coordinate[0]\\n elif state.gameState[coordinate]==state.jedi:\\n continue\\n elif state.gameState[coordinate]==state.sith:\\n continue\\n \\n valueOfLocations += valueOfRebelAdvancments\\n\\n \\n valueOfPlayers = state.numRebels + 4*state.numJedi - 4*state.numSith\\n \\n return valueOfPlayers*4 + valueOfLocations\",\n \"def evals_result(self):\\n if self.evals_result_:\\n evals_result = self.evals_result_\\n else:\\n raise XGBoostError('No results.')\\n\\n return evals_result\",\n \"def evals_result(self):\\n if self.evals_result_:\\n evals_result = self.evals_result_\\n else:\\n raise XGBoostError('No results.')\\n\\n return evals_result\",\n \"def calc_q_values(self, state):\\n return self._sess.run(self._q_pred_0,\\n feed_dict={self._state_placeholder:state});\",\n \"def evaluateState(self, gameState, currIndex):\\n score = gameState.getScore()\\n scoreScore = score * 100\\n # If current \\n if currIndex in gameState.getRedTeamIndices():\\n foodLocations = gameState.getBlueFood().asList()\\n foodScore = 900-(self.getMinFoodDistance(gameState.getAgentPosition(currIndex), foodLocations))\\n scoreScore = score * 1000\\n else:\\n foodLocations = gameState.getRedFood().asList()\\n foodScore = -(self.getMinFoodDistance(gameState.getAgentPosition(currIndex), foodLocations))\\n scoreScore = -(score * 1000)\\n return foodScore + scoreScore\",\n \"def evaluator(self, candidates, args):\\r\\n fitness = []\\r\\n if self._use_ants:\\r\\n for candidate in candidates:\\r\\n total = 0\\r\\n for c in candidate:\\r\\n total += self.weights[c.element[0]][c.element[1]]\\r\\n last = (candidate[-1].element[1], candidate[0].element[0])\\r\\n total += self.weights[last[0]][last[1]]\\r\\n fitness.append(1 / total)\\r\\n else:\\r\\n for candidate in candidates:\\r\\n total = 0\\r\\n for src, dst in zip(candidate, candidate[1:] + [candidate[0]]):\\r\\n total += self.weights[src][dst]\\r\\n fitness.append(1 / total)\\r\\n return fitness\",\n \"def computevaluefromqvalues(self, state):\\n legalactions = env.getlegalactions(deepcopy(env.state_to_array(state)))\\n if len(legalactions) == 0:\\n return 0.0\\n tmp = Counter()\\n for action in legalactions:\\n tmp[action] = self.getqvalue(state, action)\\n return tmp[tmp.argMax()]\",\n \"def computeValueFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n legal_actions = self.getLegalActions(state)\\n\\n if len(legal_actions) == 0:\\n return 0.0\\n\\n return max([self.getQValue(str(state), action) for action in legal_actions])\",\n \"def computeValueFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n legal_actions = self.getLegalActions(state)\\n\\n if len(legal_actions) == 0:\\n return 0.0\\n\\n return max([self.getQValue(state, action) for action in legal_actions])\",\n \"def computeValueFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n legal_actions = self.getLegalActions(state)\\n\\n if len(legal_actions) == 0:\\n return 0.0\\n\\n return max([self.getQValue(state, action) for action in legal_actions])\",\n \"def computeValueFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n legal_actions = self.getLegalActions(state)\\n\\n if len(legal_actions) == 0:\\n return 0.0\\n\\n return max([self.getQValue(state, action) for action in legal_actions])\",\n \"def computeValueFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n legal_actions = self.getLegalActions(state)\\n\\n if len(legal_actions) == 0:\\n return 0.0\\n\\n return max([self.getQValue(state, action) for action in legal_actions])\",\n \"def evaluate(self, state):\\n\\n fitness = 0\\n\\n for i in range(1, len(state)):\\n if state[i] != state[i - 1]:\\n fitness += 1\\n\\n return fitness\",\n \"def calc_q_values(self, state):\\n return self.q_values_func([state])[0]\",\n \"def computeValueFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n actions = self.getLegalActions(state)\\n if len(actions) == 0:\\n return 0.0\\n values = [self.getQValue(state, action) for action in actions]\\n return max(values)\",\n \"def fval_function(sN, weight):\\r\\n # IMPLEMENT\\r\\n\\r\\n # Many searches will explore nodes (or states) that are ordered by their f-value.\\r\\n # For UCS, the fvalue is the same as the gval of the state. For best-first search, the fvalue is the hval of the state.\\r\\n # You can use this function to create an alternate f-value for states; this must be a function of the state and the weight.\\r\\n # The function must return a numeric f-value.\\r\\n # The value will determine your state's position on the Frontier list during a 'custom' search.\\r\\n # You must initialize your search engine object as a 'custom' search engine if you supply a custom fval function.\\r\\n\\r\\n\\r\\n return (1 - weight) * sN.gval + weight * sN.hval\",\n \"def compute_qvalues(self, state):\\n return self.model.predict([np.expand_dims(item, 0) for item in state])[0]\",\n \"def computeQValueFromValues(self, state, action):\\n newState_prob = self.mdp.getTransitionStatesAndProbs(state, action)\\n sum = 0\\n for i in newState_prob:\\n sum += i[1]*(self.mdp.getReward(state, action, i[0])+(self.discount*self.getValue(i[0])))\\n return sum \\n \\n util.raiseNotDefined()\",\n \"def result (result = None):\\n if result is not None:\\n results.append (float (result))\\n\\n if len (results) < self.min_count:\\n return None, None\\n\\n result_mean = functools.reduce (operator.add, results, 0) / len (results)\\n result_error = (functools.reduce (operator.add,\\n ((result - result_mean)**2 for result in results), 0) / (len (results) - 1))\\n return result_mean, result_error\",\n \"def evaluate_direct(self, values, params) -> float:\\n evaluater = DirectEvaluater(values, params)\\n result = evaluater.transform(self.expression)\\n\\n try:\\n value = sympy.sympify(\\\"\\\".join(tree_to_string(result)))\\n if value == sympy.nan:\\n return None\\n return value\\n except TypeError:\\n return None\",\n \"def _evaluate(self, state):\\n input_values_rmse = self.get_input_values_rmse(state)\\n if not self._include_leading_powers:\\n if np.isfinite(input_values_rmse):\\n return -input_values_rmse\\n else:\\n return self._default_value\\n # NOTE(leeley): If computing the leading power fails\\n # (timeout or sympy ValueError) or functions in symbolic_properties return\\n # nan (for example, 1 / (x - x)).\\n leading_power_error = self.get_leading_power_error(state)\\n\\n if self._hard_penalty_default_value is None:\\n # Soft penalty.\\n if np.isfinite(leading_power_error):\\n return -input_values_rmse - leading_power_error\\n else:\\n return self._default_value\\n else:\\n # Hard penalty.\\n if (np.isfinite(leading_power_error)\\n and np.isclose(leading_power_error, 0)):\\n return -input_values_rmse\\n else:\\n return self._hard_penalty_default_value\",\n \"def evaluator(self, candidates, args):\\r\\n fitness = []\\r\\n if self._use_ants:\\r\\n for candidate in candidates:\\r\\n total = 0\\r\\n for c in candidate:\\r\\n total += c.value\\r\\n fitness.append(total)\\r\\n else:\\r\\n for candidate in candidates:\\r\\n total_value = 0\\r\\n total_weight = 0\\r\\n for c, i in zip(candidate, self.items):\\r\\n total_weight += c * i[0]\\r\\n total_value += c * i[1]\\r\\n if total_weight > self.capacity:\\r\\n fitness.append(self.capacity - total_weight)\\r\\n else:\\r\\n fitness.append(total_value)\\r\\n return fitness\",\n \"def get_value(self, state):\\n epsilon = self.epsilon\\n possible_actions = self.get_legal_actions(state)\\n\\n #If there are no legal actions, return 0.0\\n if len(possible_actions) == 0:\\n return 0.0\\n\\n optimal_action = possible_actions[\\n np.argmax([self.get_qvalue(state, action) for action in possible_actions])\\n ]\\n state_value = 0\\n for action in possible_actions:\\n if action == optimal_action:\\n state_value += (1 - epsilon) * self.get_qvalue(state, action)\\n state_value += (epsilon / len(possible_actions)) * self.get_qvalue(state, action)\\n return state_value\",\n \"def evaluate(self,**d):\\r\\n\\t\\t\\r\\n\\t\\t# evaluate terms\\r\\n\\t\\tv = [i.evaluate(**d) for i in self]\\r\\n\\t\\t\\r\\n\\t\\t# sum results\\r\\n\\t\\tc = Pa(v).sum()\\r\\n\\t\\t\\r\\n\\t\\treturn c\",\n \"def computeValueFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n if not self.getLegalActions(state): return 0\\n\\n best_action = self.computeActionFromQValues(state)\\n return self.getQValue(state, best_action)\",\n \"def calculate(self) :\\n #self.graph\\n self.val_i = 0\\n while (len(self.undefined_vertices) > 0) :\\n cond = True\\n while cond:\\n cond = False\\n for node in self.undefined_vertices:\\n if self.condition_satisfied(node, self.val_i) :\\n cond = True\\n self.undefined_vertices.remove(node)\\n self.val_l[node] = self.val_i\\n self.val_c[node] = self.val_m\\n self.val_m += 1\\n for node in self.undefined_vertices:\\n if self.val_i not in [self.val_l[n] for n in\\n self.graph.next_nodes(node)]:\\n self.undefined_vertices.remove(node)\\n self.val_l[node] = self.infinity\\n self.val_c[node] = 0\\n self.val_i += 1\\n self.graph.save_graph(\\\"check\\\")\\n self.save(\\\"this.value\\\")\\n return self.graph.to_dictionary(), self.val_l, self.val_c\",\n \"def __evaluateLocal__(self,featureVals):\\n returnEvaluation = {self.pivotParameterID:self.pivotValues}\\n for target in list(set(self.target) - set([self.pivotParameterID])):\\n reconstructData = self._reconstructData(target).real\\n # find the nearest data and compute weights\\n if len(reconstructData) > 1:\\n weights, indexes = self.KDTreeFinder.query(featureVals, k=min(2**len(self.features),len(reconstructData)))\\n # if 0 (perfect match), assign minimum possible distance\\n weights[weights == 0] = sys.float_info.min\\n weights =1./weights\\n # normalize to 1\\n weights = weights/weights.sum()\\n for point in range(len(weights)):\\n returnEvaluation[target] = np.sum ((weights[point,:]*reconstructData[indexes[point,:]].T) , axis=1)\\n else:\\n returnEvaluation[target] = reconstructData[0]\\n\\n return returnEvaluation\",\n \"def evaluate(self):\\n return self._evaluate_recur(self.root())\",\n \"def evaluate(self):\\n return self._evaluate_recur(self.root())\",\n \"def _evaluate(self, x, y, z):\\n if _isscalar(x):\\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\\n z_pos = max(min(self.zSearchFunc(self.z_list, z), self.z_n - 1), 1)\\n else:\\n x_pos = self.xSearchFunc(self.x_list, x)\\n x_pos[x_pos < 1] = 1\\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\\n y_pos = self.ySearchFunc(self.y_list, y)\\n y_pos[y_pos < 1] = 1\\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\\n z_pos = self.zSearchFunc(self.z_list, z)\\n z_pos[z_pos < 1] = 1\\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\\n alpha = (x - self.x_list[x_pos - 1]) / (\\n self.x_list[x_pos] - self.x_list[x_pos - 1]\\n )\\n beta = (y - self.y_list[y_pos - 1]) / (\\n self.y_list[y_pos] - self.y_list[y_pos - 1]\\n )\\n gamma = (z - self.z_list[z_pos - 1]) / (\\n self.z_list[z_pos] - self.z_list[z_pos - 1]\\n )\\n f = (\\n (1 - alpha)\\n * (1 - beta)\\n * (1 - gamma)\\n * self.f_values[x_pos - 1, y_pos - 1, z_pos - 1]\\n + (1 - alpha)\\n * (1 - beta)\\n * gamma\\n * self.f_values[x_pos - 1, y_pos - 1, z_pos]\\n + (1 - alpha)\\n * beta\\n * (1 - gamma)\\n * self.f_values[x_pos - 1, y_pos, z_pos - 1]\\n + (1 - alpha) * beta * gamma * self.f_values[x_pos - 1, y_pos, z_pos]\\n + alpha\\n * (1 - beta)\\n * (1 - gamma)\\n * self.f_values[x_pos, y_pos - 1, z_pos - 1]\\n + alpha * (1 - beta) * gamma * self.f_values[x_pos, y_pos - 1, z_pos]\\n + alpha * beta * (1 - gamma) * self.f_values[x_pos, y_pos, z_pos - 1]\\n + alpha * beta * gamma * self.f_values[x_pos, y_pos, z_pos]\\n )\\n return f\",\n \"def calculate(self) -> float:\",\n \"def evaluate(self) -> Dict[str, float]:\\n eval_dataloader = self.get_eval_dataloader()\\n\\n output = self._prediction_loop(eval_dataloader, description=\\\"Evaluation\\\")\\n return output.metrics\",\n \"def computeQValueFromValues(self, state, action):\\n #get the Transition function and nextStates\\n state_prob_pair=self.mdp.getTransitionStatesAndProbs(state,action)\\n #initialize the value to zero\\n actual_value=0\\n #iterate over probabilities (transition functions) and next states\\n for pair in state_prob_pair:\\n #compute qvalue\\n actual_value+=pair[1]*(self.mdp.getReward(state,action,pair[0])+self.discount*self.values[pair[0]])\\n #print \\\"The Q value is \\\",actual_value\\n return actual_value\",\n \"def on_aggregate_evaluate(\\n self,\\n rnd: int,\\n results: List[Tuple[ClientProxy, EvaluateRes]],\\n failures: List[BaseException],\\n ) -> Optional[float]:\\n if not results:\\n return None\\n\\n # Check if enough results are available\\n completion_rate = len(results) / (len(results) + len(failures))\\n if completion_rate < self.min_completion_rate_evaluate:\\n # Not enough results for aggregation\\n return None\\n\\n return weighted_loss_avg([evaluate_res for _, evaluate_res in results])\",\n \"def computeQValueFromValues(self, state, action):\\n totalsum = 0\\n reward = 0\\n for nextstate, transition in self.mdp.getTransitionStatesAndProbs(state, action):\\n reward = self.mdp.getReward(state, action, nextstate)\\n totalsum += transition * (reward + self.discount * self.getValue(nextstate)) # right way to access previous value?\\n return totalsum\",\n \"def computeQValueFromValues(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n transition_state_probs = self.mdp.getTransitionStatesAndProbs(state, action)\\n # Add each state and probability to q_value\\n q_value = 0\\n for state_, probability in transition_state_probs:\\n state_reward = self.mdp.getReward(state, state_, action)\\n q_value += probability * (state_reward + self.discount * self.values[state_])\\n return q_value\",\n \"def critic_compute_vvalue(dict_states, val_func):\\n\\n values = val_func.predict(dict_states['states'])\\n dict_states['values'] = values\",\n \"def __call__(self, observation):\\n # Validates that the state variable is a scalar with this float() call.\\n current_val = float(observation[self.dict_key])\\n retval = current_val - self.last_val\\n self.last_val = current_val\\n return retval\",\n \"def evaluate(self, values):\\r\\n return self.left.evaluate(values) - self.right.evaluate(values)\",\n \"def all_nan_result(self):\\n if self._all_nan_result is None:\\n result_files = glob.glob(\\n os.path.join(self.location, \\\"results\\\", RSLT_NM.format(\\\"*\\\"))\\n )\\n if not result_files:\\n raise XYZError(\\n \\\"To infer an all-nan result requires at least \\\"\\n \\\"one finished result.\\\"\\n )\\n reference_result = read_from_disk(result_files[0])[0]\\n self._all_nan_result = nan_like_result(reference_result)\\n\\n return self._all_nan_result\",\n \"def evaluate(state):\\n if wins(state, COMP):\\n score = -1\\n elif wins(state, HUMAN):\\n score = 1\\n else:\\n score = 0\\n\\n return score\",\n \"def result(self):\\n tp = self.true_positive.read_value()\\n fn = self.false_negative.read_value()\\n return math_ops.div_no_nan(tp, tp + fn)\",\n \"def computeQValueFromValues(self, state, action):\\n #get all possible actions from current state\\n possibleActions = self.mdp.getPossibleActions(state)\\n\\n #if action is illegal return 0\\n if action in possibleActions:\\n transitions = self.mdp.getTransitionStatesAndProbs(state, action)\\n returnVal = 0\\n index = 0\\n\\n #loop through all trainsitions/probabilities\\n while index < len(transitions):\\n #This returns s' and T(s, a, s')\\n (nextState, prob) = transitions[index]\\n\\n\\n #This returns R(s,a,s')\\n rewardVal = self.mdp.getReward(state, action, nextState)\\n\\n #This is gamma * V(s')\\n lastPartOfEquation = self.values[nextState] *self.discount\\n\\n #This is T(s, a, s')[R(s, a, s') + gamma * V(s'). Bellman equation\\n returnVal = returnVal + prob * (rewardVal + lastPartOfEquation)\\n index = index + 1\\n\\n return returnVal\\n else:\\n return 0\",\n \"def calculate(self):\\n if all( map( lambda x: isinstance(x, N),self.args) ):\\n return self.evaluate()\\n else:\\n return self.__class__( map(operator.methodcaller('calculate'), self.args))\\n #return self.__class__( (self.args[0].calculate(), self.args[1].calculate()) )\",\n \"def computeQValueFromValues(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n qValue = 0\\n transitions = self.mdp.getTransitionStatesAndProbs(state, action)\\n #print('Transitions: ' + str(transitions))\\n for t in transitions:\\n nextState, prob = t\\n reward = self.mdp.getReward(state, action, nextState)\\n #print('Reward: ' + str(reward))\\n oneTransition = prob * (reward + self.discount * self.values[nextState])\\n qValue = qValue + oneTransition\\n return qValue\",\n \"def evaluate(state):\\r\\n if wins(state, COMP):\\r\\n score = +1\\r\\n elif wins(state, HUMAN):\\r\\n score = -1\\r\\n else:\\r\\n score = 0\\r\\n\\r\\n return score\",\n \"def scoreEvaluationFunction(gameState):\\n return gameState.getScore()\",\n \"def compute(self, event=None, zs=None, thetas=None, nhats=None):\\n\\n\\n if self.strassen:\\n return self._strassen_compute(event, zs, thetas)\\n else:\\n return self._efp_compute(event, zs, thetas, nhats)\",\n \"def evaluate(self, representativeness: float, weight: float) -> float:\\n pass\",\n \"def _squad_compute(f1: Tensor, exact_match: Tensor, total: Tensor) ->Dict[str, Tensor]:\\n exact_match = 100.0 * exact_match / total\\n f1 = 100.0 * f1 / total\\n return {'exact_match': exact_match, 'f1': f1}\",\n \"def evaluate(self, x):\\n # type: (array) -> SupportsFloat\\n from interruptingcow import timeout\\n self.reset()\\n self.setParameterVector(x)\\n self.quantity_residuals = dict((quantity,list()) for quantity in self.measurement_map)\\n def worker():\\n self.buildResidualList()\\n if self.divergent():\\n return 1e9*self.penalty_scale\\n try:\\n with timeout(10, StalledSimulation):\\n worker()\\n except (RuntimeError, StalledSimulation):\\n # if convergence fails, use a penalty score\\n return 1e9*self.penalty_scale\\n print('evaluate')\\n # for quantity,residuals in self.quantity_residuals.items():\\n # print(quantity,mean(array(residuals)**2.),self.mean_measurement_map[quantity])\\n return sqrt(mean(array([\\n mean(array(residuals)**2.)/self.mean_measurement_map[quantity]**2. \\\\\\n for quantity,residuals in self.quantity_residuals.items() \\\\\\n ])))\",\n \"def eval_fis(self,fis):\\n #res = 0.0\\n #for cl_state in self.classes:\\n # res += cl_state.eval_fis(fis)\\n #print \\\"=>\\\",res\\n #return 1.0/res\\n try:\\n correct,count = self.quality_fis(fis)\\n except Exception as err:\\n print err\\n correct = 0\\n return correct\",\n \"def f(self, x):\\n\\n # Initialize\\n n = len(x)\\n f_val = 0.0\\n\\n # Loop through averaging\\n for i in range(self.num_avg):\\n try:\\n f_val += self.fun(x, *self.args)\\n except AttributeError:\\n f_val += self.fun(x, *self.args)\\n with self.eval_calls.get_lock():\\n self.eval_calls.value += 1\\n \\n # Compute average\\n f_val = f_val*self.avg_inv\\n\\n # Print out\\n msg = \\\"{0:>20}\\\".format(f_val)\\n for value in x:\\n msg += \\\", {0:>20}\\\".format(value)\\n self.queue.put(msg)\\n\\n return f_val\",\n \"def compute_values(self, update_statistics=False):\\n\\n self.compute_iterations()\\n self.axsec = sum([one.axsec for one in self])\\n self.xsec = sum([one.xsec for one in self])\\n self.xerrc = sum([one.xerrc for one in self])\\n self.xerru = math.sqrt(sum([one.xerru**2 for one in self]))\\n\\n self.nevents = sum([one.nevents for one in self])\\n self.nw = sum([one.nw for one in self])\\n self.maxit = len(self.yerr_iter) # \\n self.nunwgt = sum([one.nunwgt for one in self]) \\n self.wgt = 0\\n self.luminosity = min([0]+[one.luminosity for one in self])\\n if update_statistics:\\n self.run_statistics.aggregate_statistics([_.run_statistics for _ in self])\",\n \"def evaluate(self):\\n eval_list = nx.topological_sort(self.graph)\\n for n in eval_list:\\n n.evaluate()\\n print(\\\"evaluating type\\\", type(n))\\n\\n # Notify observers of finished calculation\\n self.notifyObservers(\\\"EVALUATION DONE\\\")\\n return \\\"FINISHED\\\"\",\n \"def evaluate(self) -> int:\",\n \"def evaluate(self,p):\\n if not self.initialized: self.__initialize__()\\n if self.vp0: p_ = 1-p\\n else: p_ = p\\n if self.ids_to_consider is None:\\n #sum on all parametrized cell\\n cf = np.sum(self.V[self.p_ids-1]*p_)/self.V_tot - self.max_v_frac\\n else:\\n cf = np.sum((self.V[self.ids_to_consider-1]*p_))/self.V_tot - self.max_v_frac\\n return cf\",\n \"def evaluate(self, prediction_fn):\\n pass\",\n \"def compute(self) -> Tuple[float, float, float]:\\n # @TODO: ddp hotfix, could be done better\\n if self._is_ddp:\\n for key in self.statistics:\\n value: List[float] = all_gather(self.statistics[key])\\n value: float = sum(value)\\n self.statistics[key] = value\\n\\n precision_value, recall_value, f1_value = get_binary_metrics(\\n tp=self.statistics[\\\"tp\\\"],\\n fp=self.statistics[\\\"fp\\\"],\\n fn=self.statistics[\\\"fn\\\"],\\n zero_division=self.zero_division,\\n )\\n return precision_value, recall_value, f1_value\",\n \"def evaluate(self):\\n raise NotImplementedError(\\\"Abstract method\\\")\",\n \"def sum_evaluations(evaluations):\\n\\n def add_evaluations(e1, e2):\\n \\\"\\\"\\\"Add two evaluations.\\n\\n If Signs do not have detections the distance is -1, therefore the distance needs\\n to be handled separately.\\n \\\"\\\"\\\"\\n true_positive = e1[0] + e2[0]\\n false_positive = e1[1] + e2[1]\\n distance = e1[2] + e2[2]\\n if e1[2] < 0 and e2[2] < 0:\\n distance = -1\\n elif e1[2] < 0:\\n distance = e2[2]\\n elif e2[2] < 0:\\n distance = e1[2]\\n return true_positive, false_positive, distance\\n\\n length = len(evaluations)\\n tp, fp, d = functools.reduce(add_evaluations, evaluations)\\n return tp, fp, float(d) / float(length)\",\n \"def compValFromState(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # print \\\"compValFromState\\\"\\n #actions = self.getLegalActions(state)\\n # if len(actions) == 0:\\n # return 0.0\\n # values = [self.getQValue() for action in actions]\\n return self.getQValue(state, None)\",\n \"def __call__(self, state, action):\\n s = float(state.__hash__()) # pybrain secretly casts state to float when we do rl\\n a = int(action)\\n qvalues = self.module.getActionValues(s)\\n maxq = max(qvalues)\\n if qvalues[a] == maxq:\\n n_max = sum([1 if q == maxq else 0 for q in qvalues])\\n return 1.0 / n_max\\n return 0\",\n \"def run_solution1(self):\\n return reduce(lambda a, b: a + self.calculate_fuel(b), self.data, 0)\",\n \"def get_instance_evidence_f1(\\n gold_sentence_keys: List[str],\\n predicted_sentence_key: List[str],\\n all_non_empty_sentence_key: List[str]\\n) -> float:\\n\\n gold_labels: List[str] = []\\n predicted_labels: List[str] = []\\n for key in all_non_empty_sentence_key:\\n gold_label: str = 'evidence' if key in gold_sentence_keys else 'neutral'\\n pred_label: str = 'evidence' if key in predicted_sentence_key else 'neutral'\\n gold_labels.append(gold_label)\\n predicted_labels.append(pred_label)\\n\\n assert len(predicted_labels) == len(all_non_empty_sentence_key)\\n\\n # zero division=1 because it is correct to select none if none exists\\n return f1_score(gold_labels, predicted_labels, pos_label='evidence', zero_division=1)\",\n \"def evaluate(self):\\n raise NotImplementedError()\",\n \"def test_const_evaluate():\\n pop = test_population\\n pop = ops.const_evaluate(pop, value=123456789.0)\\n \\n for ind in pop:\\n assert(pytest.approx(123456789.0) == ind.fitness)\",\n \"def evaluate(self, stochastic=False):\\n ob = self._convert_state(self._env.reset())\\n done = False\\n actions = []\\n sum_rew = 0\\n while not done:\\n ac, _ = self._act(ob, stochastic=stochastic)\\n actions.append(ac)\\n ob, rew, done, _ = self._env.step(ac)\\n ob = self._convert_state(ob)\\n sum_rew += rew\\n self.ob = self._convert_state(self._env.reset())\\n self.new = True\\n return sum_rew, actions\",\n \"def evaluate(self) :\\n pass\",\n \"def eval(self):\\n results = [expr.eval() if isinstance(expr, Symbol)\\n else expr for expr in self.args]\\n\\n if len(results) == 1: return self.op()(results[0])\\n try:\\n result = reduce(self.op(),results)\\n return result\\n except ZeroDivisionError:\\n raise DivideByZeroError(self.dictionary(),self.name())\",\n \"def evaluate(self, pred, **nargs):\\n sse = sum((pred(u, ds=self, **nargs) - (1 if g == \\\"F\\\" else 0)) ** 2\\n for (u, g) in self.gender_test.items())\\n\\n ll = 0\\n for (u, g) in self.gender_test.items():\\n for prn in [pred(u, ds=self, **nargs)]:\\n if g == 'F' and prn == 0:\\n ll = math.inf\\n break\\n elif g == 'F':\\n ll += math.log(prn, 2)\\n elif g == 'M' and prn == 1:\\n ll = math.inf\\n break\\n else:\\n ll += math.log(1 - prn, 2)\\n\\n return (sse, -ll, sse / len(self.gender_test), -ll / len(self.gender_test))\",\n \"def result(self):\\n tp = self.true_positive\\n fp = self.false_positive\\n return math_ops.div_no_nan(tp, tp + fp)\",\n \"def value(self, state):\\n num_visits = len(state)\\n value = 0\\n\\n for i in range(1, num_visits):\\n try:\\n value += distances[(state[i-1], state[i])]\\n except KeyError:\\n value += distances[(state[i], state[i - 1])]\\n\\n value = -1 * value\\n\\n return value\",\n \"def evaluate_state(state):\\n\\n my_score = get_action_score(state.action[0], state.action[1], state.action_player, state.occupied)\\n other_score = get_action_score(state.action[0], state.action[1], state.player, state.occupied)\\n \\n return max(my_score, other_score)\",\n \"def calcFidelity(self, state):\\n \\n obj1 = qutip.Qobj(self.rho)\\n obj2 = qutip.Qobj(state.rho)\\n \\n F =qutip.metrics.fidelity(obj1, obj2)\\n return (F)\",\n \"def computeQValueFromValues(self, state, action):\\n\\n ##util.raiseNotDefined()\\n #\\\"*** YOUR CODE STARTS HERE ***\\\"\\n # Code to remove --- from here\\n transitions = self.mdp.getTransitionStatesAndProbabilities(state, action)\\n qvalue = 0\\n for (nextState, probability) in transitions:\\n reward = self.mdp.getReward(state, action, nextState)\\n qvalue += probability *(reward + self.discount*self.values[nextState])\\n # Code to remove --- to here\\n #\\\"*** YOUR CODE FINISHES HERE ***\\\"\\n \\n return qvalue\",\n \"def multi_score(self, r, s, f):\\n return [None] if r is None else [0.0] if s is None else [f(x, y)\\n for y in self.ensure_list(s)\\n for x in self.ensure_list(r)]\",\n \"def evaluate(net, data_loader):\\n correct = 0\\n total = 0\\n net.reset()\\n for data in tqdm(data_loader):\\n inputs, output = data\\n mask, score = gate_activation(net, inputs.view(-1))\\n selected_score = score[mask]\\n if selected_score.size == 0:\\n xo = 0.5\\n else:\\n xo = np.sum(selected_score) / selected_score.size\\n print()\\n print()\\n print(\\\"mask\\\", mask)\\n print(\\\"score\\\", score)\\n print(\\\"xo\\\", xo)\\n total += 1\\n correct += ((xo > 0.5) == output[0].item())\\n\\n return float(correct)/total\",\n \"def evaluate(pred_file, ref_file):\\n ref_dict, pred_dict, query_dict, id_dict = build_pred_ref_dict(ref_file, pred_file, ref_file)\\n total, acc, scores = res_eval_with_type_acc(query_dict, pred_dict, ref_dict, id_dict, save=False)\\n em = calculate_exact_match(pred_dict, ref_dict)\\n print('Comp Acc: {:.3f}%\\\\tBleu-4: {:.3f}\\\\tRouge-L: {:.3f}'.format(acc, scores['Bleu-4'], scores['Rouge-L']))\\n print('EM: {:.3f}%'.format(em))\\n # calculate_sketch_type_acc(ref_file, pred_file)\\n # calculate_exact_match_for_each_q_type(ref_file, pred_file)\\n return total, acc, scores, em\",\n \"def evaluate(self):\\n pass\",\n \"def evaluate(self):\\n pass\",\n \"def evaluate_predictions(predictions, actual):\\n sum = 0\\n for estimate, real in zip(predictions, actual):\\n real = 1 if real==0 else real\\n sum += pow((float(real) - estimate)/real, 2)\\n return pow(sum/len(actual), 0.5)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63039607","0.6107048","0.6043089","0.59678954","0.59345084","0.59076506","0.5898974","0.5843427","0.5723326","0.5705815","0.5685411","0.5680647","0.5665845","0.56275225","0.55861384","0.5577219","0.5554043","0.554357","0.55327356","0.55058116","0.55058116","0.5496821","0.54936874","0.5429052","0.5426709","0.5420493","0.54162544","0.54162544","0.54162544","0.54162544","0.54133147","0.5372911","0.5371966","0.5367993","0.5364739","0.53603685","0.5347137","0.5334041","0.533203","0.5323494","0.5319822","0.5302445","0.52950287","0.52641976","0.52614725","0.5251202","0.5251202","0.524619","0.5245846","0.5237585","0.52306324","0.5225528","0.52226996","0.5216305","0.5184765","0.51751155","0.51666415","0.51624435","0.51532","0.51157403","0.5105469","0.5102304","0.509654","0.5095307","0.5095291","0.5068288","0.5061","0.5054464","0.5048786","0.5043364","0.5036983","0.503662","0.503583","0.50270134","0.5022455","0.5020771","0.50009924","0.49995044","0.4996677","0.49805042","0.49779153","0.49720937","0.49709123","0.49690774","0.49681786","0.49648213","0.49623692","0.4958993","0.49554268","0.4953351","0.49528885","0.4951736","0.49508223","0.49506947","0.4949596","0.4949411","0.49493507","0.49485675","0.49485675","0.49475065"],"string":"[\n \"0.63039607\",\n \"0.6107048\",\n \"0.6043089\",\n \"0.59678954\",\n \"0.59345084\",\n \"0.59076506\",\n \"0.5898974\",\n \"0.5843427\",\n \"0.5723326\",\n \"0.5705815\",\n \"0.5685411\",\n \"0.5680647\",\n \"0.5665845\",\n \"0.56275225\",\n \"0.55861384\",\n \"0.5577219\",\n \"0.5554043\",\n \"0.554357\",\n \"0.55327356\",\n \"0.55058116\",\n \"0.55058116\",\n \"0.5496821\",\n \"0.54936874\",\n \"0.5429052\",\n \"0.5426709\",\n \"0.5420493\",\n \"0.54162544\",\n \"0.54162544\",\n \"0.54162544\",\n \"0.54162544\",\n \"0.54133147\",\n \"0.5372911\",\n \"0.5371966\",\n \"0.5367993\",\n \"0.5364739\",\n \"0.53603685\",\n \"0.5347137\",\n \"0.5334041\",\n \"0.533203\",\n \"0.5323494\",\n \"0.5319822\",\n \"0.5302445\",\n \"0.52950287\",\n \"0.52641976\",\n \"0.52614725\",\n \"0.5251202\",\n \"0.5251202\",\n \"0.524619\",\n \"0.5245846\",\n \"0.5237585\",\n \"0.52306324\",\n \"0.5225528\",\n \"0.52226996\",\n \"0.5216305\",\n \"0.5184765\",\n \"0.51751155\",\n \"0.51666415\",\n \"0.51624435\",\n \"0.51532\",\n \"0.51157403\",\n \"0.5105469\",\n \"0.5102304\",\n \"0.509654\",\n \"0.5095307\",\n \"0.5095291\",\n \"0.5068288\",\n \"0.5061\",\n \"0.5054464\",\n \"0.5048786\",\n \"0.5043364\",\n \"0.5036983\",\n \"0.503662\",\n \"0.503583\",\n \"0.50270134\",\n \"0.5022455\",\n \"0.5020771\",\n \"0.50009924\",\n \"0.49995044\",\n \"0.4996677\",\n \"0.49805042\",\n \"0.49779153\",\n \"0.49720937\",\n \"0.49709123\",\n \"0.49690774\",\n \"0.49681786\",\n \"0.49648213\",\n \"0.49623692\",\n \"0.4958993\",\n \"0.49554268\",\n \"0.4953351\",\n \"0.49528885\",\n \"0.4951736\",\n \"0.49508223\",\n \"0.49506947\",\n \"0.4949596\",\n \"0.4949411\",\n \"0.49493507\",\n \"0.49485675\",\n \"0.49485675\",\n \"0.49475065\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.670078"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":87599,"cells":{"query":{"kind":"string","value":"Translates rate from vector representation to symbolic one as a sum of particular components. e.g. [1, 0, 1] > (x_0 + x_2)"},"document":{"kind":"string","value":"def to_symbolic(self):\n transformer = SymbolicAgents()\n self.expression = transformer.transform(self.expression)"},"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 ExpU(x):\n\treturn sum(x * lambdas)","def relative_rate(self):\n return _add_vector_swig.add_vector_2_cpp_sptr_relative_rate(self)","def _eval(self, v):\n if v.dtype == np.complex64 or v.dtype == np.complex128:\n return ne.evaluate('sum(real(v * conj(v)))')\n else:\n return ne.evaluate('sum(v * v)')","def custom_np_function(vector):\n summation = 0\n for item in vector:\n summation += item ** 2\n return summation","def __add__(self, vector):\n return self.translated(vector)","def test_numbers_can_substitute_scalars(free_alg, full_balance):\n\n dr = free_alg\n p = dr.names\n\n x = IndexedBase('x')\n y = IndexedBase('y')\n r = Range('D', 0, 2)\n i, j, k, l = symbols('i j k l')\n dr.set_dumms(r, [i, j, k, l])\n v = p.v\n\n orig = dr.sum((i, r), x[i] ** 2 * x[j] * y[k] * v[l])\n\n res = orig.subst(x[i], 0, full_balance=full_balance).simplify()\n assert res == 0\n res = orig.subst(x[j], 1, full_balance=full_balance).simplify()\n assert res == dr.sum(2 * y[k] * v[l])\n res = orig.subst(x[k], 2, full_balance=full_balance).simplify()\n assert res == dr.sum(16 * y[k] * v[l])","def getVectorCostFunction(self, evalpts, observations):\n def _(params):\n forward = self.getForwardEvaluator(evalpts)\n return sum(forward(params) - observations)\n return _","def forward(self,\n x: Tensor) \\\n -> Tensor:\n\n x = self.convs[0](x)\n res = x\n for i in range(self.num_rates):\n x = torch.tanh(self.filter_convs[i](\n x)) * torch.sigmoid(self.gate_convs[i](x))\n x = self.convs[i+1](x)\n res = res + x\n return res","def xscalary_plus_z(scalar, x, y, activation=None):\n R = tf.add(tf.scalar_mul(scalar,x), y)\n if activation:\n return activation(R)\n else: \n return R","def vec_add_scalar (x, c):\n return [x_i+c for x_i in x]","def costFun(self, S, x):","def polynomial_incremental_value(multipliers, variable):\n return sum([(mult * order * variable ** (order - 1) if order > 0 else 0) for order, mult in enumerate(multipliers)])","def vector_add(v1, v2):\n return v1[0] + v2[0], v1[1] + v2[1]","def linear_source(tau, a):\n\n return a[0]+a[1]*tau","def __add__(self, rhs: Union[float, Simpy]) -> Simpy:\n result: list[float] = []\n if isinstance(rhs, float):\n for item in self.values:\n result.append(item + rhs)\n else:\n assert len(self.values) == len(rhs.values)\n for i in range(len(self.values)):\n result.append(self.values[i] + rhs.values[i])\n return Simpy(result)","def test_numbers_can_substitute_vectors(free_alg, full_balance):\n\n dr = free_alg\n p = dr.names\n\n x = IndexedBase('x')\n y = IndexedBase('y')\n r = p.R\n i, j, k, l = symbols('i j k l')\n v = p.v\n w = Vec('w')\n\n orig = dr.sum((i, r), (j, r), x[i, j] * v[i] * w[j] + y[i, j] * v[i] * v[j])\n\n res = orig.subst(v[k], 0, full_balance=full_balance).simplify()\n assert res == 0\n res = orig.subst(v[i], 1, full_balance=full_balance).simplify()\n assert res == dr.sum((i, r), (j, r), x[j, i] * w[i] + y[i, j])","def matrix_sym_op(x):\n return (x + tf.transpose(x))/2","def _evalPoly(self,a,x):\n y = a[0]\n for i in range(1,len(a)):\n y = self.F.Multiply(y, x)\n y = self.F.Add(y, a[i])\n return y","def vector_add(v, w):\n\treturn [v_i + w_i for v_i, w_i in zip(v, w)]","def rosen(self, x, alpha=1e2):\r\n x = [x] if np.isscalar(x[0]) else x # scalar into list\r\n f = [sum(alpha*(x[:-1]**2-x[1:])**2 + (1.-x[:-1])**2) for x in x]\r\n return f if len(f) > 1 else f[0] # 1-element-list into scalar\r","def evaluate_poly(poly: Sequence[float], x: float) -> float:\n return sum(c * (x**i) for i, c in enumerate(poly))","def scalar_multiply(s: float, v: Vector) -> Vector:\n return [s * v_item for v_item in v]","def sum(self, vector):\n\n # return (self.from_list([x+vector.vector[self.vector.index(x)]\n # for x in self.vector]))\n return Vector(self.x + vector.x, self.y + vector.y, self.z + vector.z)","def evaluate(f, a):\n if f == []:\n return 0\n result = f[-1] # begin with leading coefficient\n i = len(f) - 1 # number of times to iterate \n while i >= 0:\n result = f[i] + a*result\n i -= 1\n return result","def lpSum(vector):\n\treturn LpAffineExpression().addInPlace(vector)","def _eval_coeff(self, pt):\n return sum(a.coeff(pt) for a in self.args)","def vector_sum(vectors):\n\tresult = vectors[0]\n\tfor vector in vectors:\n\t\tresult = vector_add(result, vector)\n\treturn result","def scalar_vector_ext(alpha, v, a, b):\n return [alpha * v[0],\n alpha * v[0] * a + b]","def vector_add(v, w):\n return [v_i + w_i for v_i, w_i in zip(v, w)]","def tf(vector):\n for line in vector:\n line[0] = np.true_divide(line[0], np.sum(line[0]))\n return vector","def add(self, value):\n if self.squared:\n if isinstance(value, list):\n value = [np.square(x) for x in value]\n else:\n value = np.square(value)\n\n if isinstance(value, list):\n for i in range(0, len(value)):\n self.value[i] = np.multiply(self.decay, self.value[i]) + np.multiply((1. - self.decay), value[i])\n else:\n self.value = np.multiply(self.decay, self.value) + np.multiply((1. - self.decay), value)","def eval_sum(parse_result):\r\n total = 0.0\r\n current_op = operator.add\r\n for token in parse_result:\r\n if token == '+':\r\n current_op = operator.add\r\n elif token == '-':\r\n current_op = operator.sub\r\n else:\r\n total = current_op(total, token)\r\n return total","def _symbolic_jacobian(self):\n return self._symbolic_system.jacobian([V[0], V[1]])","def l1_regularization(variables, factor=1e-4, name='l1_regularization', collections=['regularization']):\n l1 = tf.add_n([tf.reduce_sum(tf.abs(var)) for var in variables], name=name) if variables else tf.constant(0.)\n loss = factor * l1\n scalar_summary(loss, name, collections)\n return loss","def costFun(self, x):\n\ttmp = x.reshape(self.inp_shape)\n\tc = np.float64(self.calcCost(np.asarray(tmp,dtype=np.float32))) + self.alpha * np.dot(x.T, x)\n\treturn c","def evaluate_rhs(self, x, V):\n rhs = self._numeric_system(x, V, *self.model.params.values()).ravel()\n return rhs","def vector_add(v, w):\n return [v_i + w_i for v_i, w_i in zip(v,w)]","def add_vectors(v, u):\n return (v[0] + u[0], v[1] + u[1])","def polynomial_sum(x1, x2):\n #-- convert variable to array if importing a single value\n x2 = np.atleast_1d(x2)\n return np.sum([c * (x2 ** i) for i,c in enumerate(x1)],axis=0)","def vecToFunc(vector):\n def f(x):\n f = 0\n for i in range(len(vector)):\n f += vector[i]*x**i\n return f\n return f","def L_fun(x):\n \n f_x0 = f(ad.create_vector('x0', x0, seed_vector=x));\n f_x0 = np.array(f_x0) #ensure that f_x0 is np.array\n action = sum_values(ad.get_deriv(f_x0))\n return action","def general_poly (L):\n def to_apply (x):\n n = 0\n for i in L:\n n = x*n + i\n return n\n return to_apply","def easy_eval(self, x):\n answer = 0\n for i in range(len(self.coefficients)):\n coef = self.coefficients[i]\n degree = len(self.coefficients) - (i+1)\n answer += x ** degree * coef\n return answer","def polynomial_value(multipliers, variable):\n def term(mult, var, order):\n if order > 1:\n return mult * variable ** order\n elif order == 1:\n return mult * variable\n elif order == 0:\n return mult\n return sum([term(mult, variable, order) for order, mult in enumerate(multipliers)])","def evaluate( self, x ) :\n\n P = 0.\n for c_l in reversed( self.coefficients ) : P = c_l + x * P\n return( P )","def add(value1, value2):\n return 1 / (1.0 / value1 + 1.0 / value2)","def func1(x,u):\r\n return 5*x*u+(x+7)*np.sin(x)","def scalarmul(scalar,vector):\r\n result = [[0] for row in range(len(vector))]\r\n # creates a list full of 0s with the same lenght of the vector\r\n for z in range(len(vector)):\r\n # for loop which continues as long as there are more elements left in the given vector \r\n result[z] = scalar*vector[z]\r\n # the list full of 0s is replaced by the product of each element in the given vector and the the scalar \r\n return result","def scalar_mult(s, v):\n\tnewscal = [ ]\n\tfor i in range(len(v)):\n\t\tnewscal += [s * v[i]]\n\tprint(newscal)","def cost_function(self, u):\n # enforce that the input is a numpy array\n u = np.asarray(u)\n\n # Reshape the control input to (mxT). Vector input is required for some optimization libraries\n T = int(len(u)/2)\n u = u.reshape((2,T))\n\n J = - self.rho(u)\n\n return J","def scalar_vector_mult(alpha, v):\n return [alpha*x for x in v]","def eval(self, x):\n self.__check_input__(x)\n x1 = x[0]\n x2 = x[1]\n\n t = 1 / (8 * np.pi)\n s = 10\n r = 6\n c = 5 / np.pi\n b = 5.1 / (4 * np.pi ** 2)\n a = 1\n\n term1 = a * (x2 - b * x1 ** 2 + c * x1 - r) ** 2\n term2 = s * (1 - t) * np.cos(x1)\n\n return term1 + term2 + s","def symbolic_objective(ingredients) -> Tuple[List[sp.Symbol], sp.Eq]:\n assignments = sp.symbols(' '.join(ingredients.keys()))\n\n # Skip negative logic due to differentiability requirements\n objective = 1\n for attribute in filter(lambda x: x != \"calories\", next(iter(ingredients.values())).keys()):\n objective *= sum(ingredients[str(x)][attribute] * x for x in assignments)\n\n return assignments, objective","def get_magnitude_vector(given_vector):\n\n # Note: given vector is a dictionary of the form:\n # {term : score}\n\n magnitude = 0\n for item in given_vector.values():\n magnitude += item ** 2\n\n return magnitude ** 0.5","def _linear_dispersion_sum(k, j, d, beta, tau):\n # k, j, d , beta = columns -> convert to Series -> broadcasted\n # tau = Matrix as Frame\n calc_column = (k + j * d) * np.sqrt(beta)\n if isinstance(calc_column, pd.DataFrame):\n calc_column = calc_column.squeeze()\n return np.cos(2 * np.pi * tau).mul(calc_column, axis='index').sum(axis='index')","def g(t1):\n if isinstance(t1, IdentExp) and self.st.has_key(t1.name):\n ninfo = self.st[t1.name]\n if ninfo[\"srcty\"] == \"vector\":\n if self.existMats and t1.name == n.exp.lhs.name:\n return ArrayRefExp(t1, IdentExp(\"i2\"))\n else:\n self.st[\"itrs\"][0].update({ninfo[\"len\"][0]: \"i1\"})\n return ArrayRefExp(t1, IdentExp(\"i1\"))\n elif ninfo[\"srcty\"] == \"matrix\":\n self.st[\"itrs\"][0].update({ninfo[\"len\"][0]: \"i1\"})\n self.st[\"itrs\"][1].update({ninfo[\"len\"][1]: \"i2\"})\n sub = s2t(\"exp\", ninfo[\"len\"][0] + \" * i2 + i1\")\n return ArrayRefExp(t1, sub)\n else:\n return t1\n else:\n return t1","def forward_substitution(l, b):\n y = np.zeros(b.shape[0])\n y[0] = b[0] / l[0, 0]\n for i in range(1, b.shape[0]):\n _sum = np.sum(l[i, :i] * y[:i])\n y[i] = (b[i] - _sum) / l[i, i]\n return y","def symrate_to_subsymrate(self, symrate: t.T) -> t.T:\n return symrate * self.subsymbol_count","def _R(state, effects, observed_frequencies):\n # this small number ~ 10^-304 is added so that we don't get divide by zero errors\n machine_eps = np.finfo(float).tiny\n # have a zero in the numerator, we can fix this is we look a little more carefully.\n predicted_probs = np.array([np.real(np.trace(state.dot(effect))) for effect in effects])\n update_operator = sum([effect * observed_frequencies[i] / (predicted_probs[i] + machine_eps)\n for i, effect in enumerate(effects)])\n return update_operator","def y(x):\n x1, x2, x3, x4 = x[:, 0], x[:, 1], x[:, 2], x[:, 3]\n return 1 + 0.3 * x1 - 0.6 * x2 ** 2 - 0.2 * x3 ** 3 + 0.5 * x4 ** 4","def u(self,x,i,temp):\n return self.coeffs[i]*self.psi_funcs[i+temp](x) + self.coeffs[i+1]*self.psi_funcs[i+temp+1](x) + self.coeffs[i+2]*self.psi_funcs[i+temp+2](x)","def _eval(self, v):\n return super(weighted_sum_squares, self)._eval(self.weight * v)","def x_rate(self):\n values = self._interpolate_table(\"x\", derivative_order=1)\n # values += self._corrections(('ortho_eop', iers.ortho_eop, 0, 1e-6),\n # ('pmsdnut2', iers.pmsdnut2, 0, 1e-6))\n return values","def fv(rate, n_years):\n return pow(1 + rate, n_years)","def l1_reg(tensors, name='L1Reg'):\n if hasattr(tensors, '__iter__'):\n tensors = list(tensors)\n with tf.name_scope(name, values=tensors):\n return sum(tf.reduce_sum(tf.abs(p)) for p in tensors)\n else:\n with tf.name_scope(name, values=[tensors]):\n return tf.reduce_sum(tf.abs(tensors))","def eval(self, x):\n y = list(x)\n if not self.biased:\n y.insert(0, 1.0)\n y = np.array(y).reshape((self.Ws[0].shape[1], 1))\n for W, g in zip(self.Ws, self.gs):\n y = g(np.dot(W, y))\n return y.flatten()","def sym_sipexprs():\n u, v = symbols('u v')\n\n sipu = 0\n sipv = 0\n for m in range(8):\n for n in range(0, 8-m):\n ac = symbols('a_%d_%d' % (m, n))\n bc = symbols('b_%d_%d' % (m, n))\n sipu += ac*u**m*v**n\n sipv += bc*u**m*v**n\n sipu.expand()\n sipv.expand()\n return sipu, sipv","def similarity_vector(self, x):\n r_x = self.encoder(x)[1]\n return self.prototypes_layer(r_x)","def get_lr_cost(self):\n\n\t\tlabels = self.get_symbolic_expected_rewards()\n\n\t\treturn -theano.tensor.mean(\n\t\t\ttheano.tensor.log(labels)[\n\t\t\t\ttheano.tensor.arange(self.symbolic_output.shape[0]),\n\t\t\t\tself.symbolic_output])","def test_amp_sums_can_be_simplified(free_alg):\n dr = free_alg\n v = dr.names.v\n n, i, j = symbols('n i j')\n x = IndexedBase('x')\n r = Range('D', 0, n)\n\n tensor = dr.sum((i, r), (j, r), i ** 2 * x[j] * v[j])\n res = tensor.simplify_sums()\n assert res == dr.sum((j, r), (\n n ** 3 / 3 - n ** 2 / 2 + n / 6\n ) * x[j] * v[j])","def calcStartlingRates(startles):\n startle_rates = np.sum(startles, axis=-1)\n return startle_rates","def v(x):\n return x*x","def vector_sum(a, b):\n return a[0] + b[0], a[1] + b[1]","def _abel_sym():\n from sympy import symbols, simplify, integrate, sqrt\n from sympy.assumptions.assume import global_assumptions\n r, y,r0, r1,r2, z,dr, c0, c_r, c_rr,c_z, c_zz, c_rz = symbols(\n 'r y r0 r1 r2 z dr c0 c_r c_rr c_z c_zz c_rz', positive=True)\n f0, f1, f2 = symbols('f0 f1 f2')\n global_assumptions.add(Q.is_true(r>y))\n global_assumptions.add(Q.is_true(r1>y))\n global_assumptions.add(Q.is_true(r2>y))\n global_assumptions.add(Q.is_true(r2>r1))\n P = c0 + (r-y)*c_r #+ (r-r0)**2*c_rr\n K_d = 1/sqrt(r**2-y**2)\n res = integrate(P*K_d, (r,y, r1))\n sres= simplify(res)\n print(sres)","def rate (self, indep):\n data = self.data\n index = len(data)-2\n for i in xrange(len(data)-1):\n if indep < float(data[i+1][0]):\n index = i\n break\n return self.interpolateValue(float(data[index][0]),float(data[index][2]),float(data[index+1][0]),float(data[index+1][2]),indep)","def add(self, x):\n self.sum += (1 / self.counter) * (x - self.sum)\n self.counter += 1","def constant_equation(funct):\n return funct + \"x\"","def linear(self, X):\n return X","def changeCurve(self, V):\n # FIXME: is \"(not V[0] != 0)\" a correct condition?\n if (not isinstance(V, list)) or (not len(V) == 4) or (not V[0] != 0):\n raise ValueError(\"([u, r, s, t]) with u must not be 0.\")\n\n # FIXME: this is dependent rational.Rational\n if self.ch == 0:\n return EC([rational.Rational(self.a1+2*V[2], V[0]),\n rational.Rational(self.a2-V[2]*self.a1+3*V[1]-V[2]**2, V[0]**2),\n rational.Rational(self.a3+V[1]*self.a1+2*V[3], V[0]**3),\n rational.Rational(self.a4-V[2]*self.a3+2*V[1]*self.a2-(V[3]+V[1]*V[2])*self.a1+3*V[1]**2-2*V[2]*V[3], V[0]**4),\n rational.Rational(self.a6+V[1]*self.a4+V[1]**2*self.a2+V[1]**3-V[3]*self.a3-V[3]**2-V[1]*V[3]*self.a1, V[0]**6)])\n else:\n for v in V:\n if not isinstance(v, int) or not (v in self.basefield):\n raise ValueError(\"transform V must be integer sequence.\")\n v = self.basefield.createElement(V[0]).inverse()\n return EC([(self.a1+2*V[2])*v,\n ((self.a2-V[2]*self.a1+3*V[1]-V[2]**2)*v**2),\n ((self.a3+V[1]*self.a1+2*V[3])*v**3),\n ((self.a4-V[2]*self.a3+2*V[1]*self.a2-(V[3]+V[1]*V[2])*self.a1+3*V[1]**2-2*V[2]*V[3])*v**4),\n ((self.a6+V[1]*self.a4+V[1]**2*self.a2+V[1]**3-V[3]*self.a3-V[3]**2-V[1]*V[3]*self.a1)*v**6)], self.basefield)","def __add__(self, B):\n return (Polynomial(self) + B).simplify()","def vector_sum(vectors):\n results = vectors[0]\n for vector in vectors[1:]:\n results = vector_add(results, vector)\n return results","def ADD_I_Vx(self, x):\n\t\tself.I += self.V[x]","def scipy_fun2(x):\n answer = 0.0\n for i in range(0, len(x)):\n answer += (math.pow(-1,i))*(math.pow((i+1),math.pow(x[i], (i+1))))\n return answer","def _eval_coeff(self, pt):\n val = 1\n for a in self.args:\n val *= a.coeff(pt)\n return val","def sum_of_squares(v: Vector) -> float:\n return dot(v,v)","def f(z, X, Y, _lambda):\r\n w = z[:-1]\r\n beta = np.squeeze(z[-1])\r\n term_1_d = (X * (Y[:, np.newaxis] - g(X.dot(w) + beta))).sum(axis=0)\r\n term_d_1 = (Y[:, np.newaxis] - g(X.dot(w) + beta)).sum() + 2 * _lambda * beta\r\n return np.hstack((term_1_d, term_d_1))[:, np.newaxis]","def portfolio(R, x, Rx=None):\n if Rx is None:\n Rx = R @ x\n return -np.sum(np.log(Rx)), Rx","def prod_value(self, lv, rv):","def conv_to_annualised_rate(sr):\r\n return np.expm1(sr)","def update_V(self, Vs, Vs_next, reward, alpha, gamma):\r\n return Vs + alpha * (reward + gamma * Vs_next - Vs)","def _symbolic_system(self):\n system = sym.Matrix(self._symbolic_equations)\n return system.subs(self._symbolic_change_of_vars)","def solver_2star(d):\n return sum([iterative_fuel(x) for x in d])","def add(self, term):\n self._value = self.accum_param.addInPlace(self._value, term)","def add(self, number):\n\n return self.from_list([x+number for x in self.vector])","def scalar_multiply(c: float, v: Vector) -> Vector:\n return [c * v_i for v_i in v]","def scalar_multiply(c: float, v: Vector) -> Vector:\n return [c * v_i for v_i in v]","def rrdb(x):\n h = dense_block(x)\n h = dense_block(h)\n h = dense_block(h)\n h = tf.keras.layers.Lambda(lambda x: x * 0.2)(h)\n out = tf.keras.layers.Add()([h, x])\n return out","def incrementSparseVector(v1, scale, v2):\n for index in v2:\n v1[index] += v2[index] * scale","def at_value(self, *value):\n result = 0\n for x in value:\n i = 0\n for coef in self.arg:\n result = result + coef * (x ** i)\n i = i + 1\n result = -result\n return -result","def rate(self, t, i):\n return np.real(self._rates[i](t))","def prob1():\n \n x = sy.symbols('x')\n exp = (sy.sin(x) + 1)**(sy.sin(sy.cos(x)))\n f1 = sy.lambdify(x, sy.diff(exp, x))\n return f1"],"string":"[\n \"def ExpU(x):\\n\\treturn sum(x * lambdas)\",\n \"def relative_rate(self):\\n return _add_vector_swig.add_vector_2_cpp_sptr_relative_rate(self)\",\n \"def _eval(self, v):\\n if v.dtype == np.complex64 or v.dtype == np.complex128:\\n return ne.evaluate('sum(real(v * conj(v)))')\\n else:\\n return ne.evaluate('sum(v * v)')\",\n \"def custom_np_function(vector):\\n summation = 0\\n for item in vector:\\n summation += item ** 2\\n return summation\",\n \"def __add__(self, vector):\\n return self.translated(vector)\",\n \"def test_numbers_can_substitute_scalars(free_alg, full_balance):\\n\\n dr = free_alg\\n p = dr.names\\n\\n x = IndexedBase('x')\\n y = IndexedBase('y')\\n r = Range('D', 0, 2)\\n i, j, k, l = symbols('i j k l')\\n dr.set_dumms(r, [i, j, k, l])\\n v = p.v\\n\\n orig = dr.sum((i, r), x[i] ** 2 * x[j] * y[k] * v[l])\\n\\n res = orig.subst(x[i], 0, full_balance=full_balance).simplify()\\n assert res == 0\\n res = orig.subst(x[j], 1, full_balance=full_balance).simplify()\\n assert res == dr.sum(2 * y[k] * v[l])\\n res = orig.subst(x[k], 2, full_balance=full_balance).simplify()\\n assert res == dr.sum(16 * y[k] * v[l])\",\n \"def getVectorCostFunction(self, evalpts, observations):\\n def _(params):\\n forward = self.getForwardEvaluator(evalpts)\\n return sum(forward(params) - observations)\\n return _\",\n \"def forward(self,\\n x: Tensor) \\\\\\n -> Tensor:\\n\\n x = self.convs[0](x)\\n res = x\\n for i in range(self.num_rates):\\n x = torch.tanh(self.filter_convs[i](\\n x)) * torch.sigmoid(self.gate_convs[i](x))\\n x = self.convs[i+1](x)\\n res = res + x\\n return res\",\n \"def xscalary_plus_z(scalar, x, y, activation=None):\\n R = tf.add(tf.scalar_mul(scalar,x), y)\\n if activation:\\n return activation(R)\\n else: \\n return R\",\n \"def vec_add_scalar (x, c):\\n return [x_i+c for x_i in x]\",\n \"def costFun(self, S, x):\",\n \"def polynomial_incremental_value(multipliers, variable):\\n return sum([(mult * order * variable ** (order - 1) if order > 0 else 0) for order, mult in enumerate(multipliers)])\",\n \"def vector_add(v1, v2):\\n return v1[0] + v2[0], v1[1] + v2[1]\",\n \"def linear_source(tau, a):\\n\\n return a[0]+a[1]*tau\",\n \"def __add__(self, rhs: Union[float, Simpy]) -> Simpy:\\n result: list[float] = []\\n if isinstance(rhs, float):\\n for item in self.values:\\n result.append(item + rhs)\\n else:\\n assert len(self.values) == len(rhs.values)\\n for i in range(len(self.values)):\\n result.append(self.values[i] + rhs.values[i])\\n return Simpy(result)\",\n \"def test_numbers_can_substitute_vectors(free_alg, full_balance):\\n\\n dr = free_alg\\n p = dr.names\\n\\n x = IndexedBase('x')\\n y = IndexedBase('y')\\n r = p.R\\n i, j, k, l = symbols('i j k l')\\n v = p.v\\n w = Vec('w')\\n\\n orig = dr.sum((i, r), (j, r), x[i, j] * v[i] * w[j] + y[i, j] * v[i] * v[j])\\n\\n res = orig.subst(v[k], 0, full_balance=full_balance).simplify()\\n assert res == 0\\n res = orig.subst(v[i], 1, full_balance=full_balance).simplify()\\n assert res == dr.sum((i, r), (j, r), x[j, i] * w[i] + y[i, j])\",\n \"def matrix_sym_op(x):\\n return (x + tf.transpose(x))/2\",\n \"def _evalPoly(self,a,x):\\n y = a[0]\\n for i in range(1,len(a)):\\n y = self.F.Multiply(y, x)\\n y = self.F.Add(y, a[i])\\n return y\",\n \"def vector_add(v, w):\\n\\treturn [v_i + w_i for v_i, w_i in zip(v, w)]\",\n \"def rosen(self, x, alpha=1e2):\\r\\n x = [x] if np.isscalar(x[0]) else x # scalar into list\\r\\n f = [sum(alpha*(x[:-1]**2-x[1:])**2 + (1.-x[:-1])**2) for x in x]\\r\\n return f if len(f) > 1 else f[0] # 1-element-list into scalar\\r\",\n \"def evaluate_poly(poly: Sequence[float], x: float) -> float:\\n return sum(c * (x**i) for i, c in enumerate(poly))\",\n \"def scalar_multiply(s: float, v: Vector) -> Vector:\\n return [s * v_item for v_item in v]\",\n \"def sum(self, vector):\\n\\n # return (self.from_list([x+vector.vector[self.vector.index(x)]\\n # for x in self.vector]))\\n return Vector(self.x + vector.x, self.y + vector.y, self.z + vector.z)\",\n \"def evaluate(f, a):\\n if f == []:\\n return 0\\n result = f[-1] # begin with leading coefficient\\n i = len(f) - 1 # number of times to iterate \\n while i >= 0:\\n result = f[i] + a*result\\n i -= 1\\n return result\",\n \"def lpSum(vector):\\n\\treturn LpAffineExpression().addInPlace(vector)\",\n \"def _eval_coeff(self, pt):\\n return sum(a.coeff(pt) for a in self.args)\",\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 scalar_vector_ext(alpha, v, a, b):\\n return [alpha * v[0],\\n alpha * v[0] * a + b]\",\n \"def vector_add(v, w):\\n return [v_i + w_i for v_i, w_i in zip(v, w)]\",\n \"def tf(vector):\\n for line in vector:\\n line[0] = np.true_divide(line[0], np.sum(line[0]))\\n return vector\",\n \"def add(self, value):\\n if self.squared:\\n if isinstance(value, list):\\n value = [np.square(x) for x in value]\\n else:\\n value = np.square(value)\\n\\n if isinstance(value, list):\\n for i in range(0, len(value)):\\n self.value[i] = np.multiply(self.decay, self.value[i]) + np.multiply((1. - self.decay), value[i])\\n else:\\n self.value = np.multiply(self.decay, self.value) + np.multiply((1. - self.decay), value)\",\n \"def eval_sum(parse_result):\\r\\n total = 0.0\\r\\n current_op = operator.add\\r\\n for token in parse_result:\\r\\n if token == '+':\\r\\n current_op = operator.add\\r\\n elif token == '-':\\r\\n current_op = operator.sub\\r\\n else:\\r\\n total = current_op(total, token)\\r\\n return total\",\n \"def _symbolic_jacobian(self):\\n return self._symbolic_system.jacobian([V[0], V[1]])\",\n \"def l1_regularization(variables, factor=1e-4, name='l1_regularization', collections=['regularization']):\\n l1 = tf.add_n([tf.reduce_sum(tf.abs(var)) for var in variables], name=name) if variables else tf.constant(0.)\\n loss = factor * l1\\n scalar_summary(loss, name, collections)\\n return loss\",\n \"def costFun(self, x):\\n\\ttmp = x.reshape(self.inp_shape)\\n\\tc = np.float64(self.calcCost(np.asarray(tmp,dtype=np.float32))) + self.alpha * np.dot(x.T, x)\\n\\treturn c\",\n \"def evaluate_rhs(self, x, V):\\n rhs = self._numeric_system(x, V, *self.model.params.values()).ravel()\\n return rhs\",\n \"def vector_add(v, w):\\n return [v_i + w_i for v_i, w_i in zip(v,w)]\",\n \"def add_vectors(v, u):\\n return (v[0] + u[0], v[1] + u[1])\",\n \"def polynomial_sum(x1, x2):\\n #-- convert variable to array if importing a single value\\n x2 = np.atleast_1d(x2)\\n return np.sum([c * (x2 ** i) for i,c in enumerate(x1)],axis=0)\",\n \"def vecToFunc(vector):\\n def f(x):\\n f = 0\\n for i in range(len(vector)):\\n f += vector[i]*x**i\\n return f\\n return f\",\n \"def L_fun(x):\\n \\n f_x0 = f(ad.create_vector('x0', x0, seed_vector=x));\\n f_x0 = np.array(f_x0) #ensure that f_x0 is np.array\\n action = sum_values(ad.get_deriv(f_x0))\\n return action\",\n \"def general_poly (L):\\n def to_apply (x):\\n n = 0\\n for i in L:\\n n = x*n + i\\n return n\\n return to_apply\",\n \"def easy_eval(self, x):\\n answer = 0\\n for i in range(len(self.coefficients)):\\n coef = self.coefficients[i]\\n degree = len(self.coefficients) - (i+1)\\n answer += x ** degree * coef\\n return answer\",\n \"def polynomial_value(multipliers, variable):\\n def term(mult, var, order):\\n if order > 1:\\n return mult * variable ** order\\n elif order == 1:\\n return mult * variable\\n elif order == 0:\\n return mult\\n return sum([term(mult, variable, order) for order, mult in enumerate(multipliers)])\",\n \"def evaluate( self, x ) :\\n\\n P = 0.\\n for c_l in reversed( self.coefficients ) : P = c_l + x * P\\n return( P )\",\n \"def add(value1, value2):\\n return 1 / (1.0 / value1 + 1.0 / value2)\",\n \"def func1(x,u):\\r\\n return 5*x*u+(x+7)*np.sin(x)\",\n \"def scalarmul(scalar,vector):\\r\\n result = [[0] for row in range(len(vector))]\\r\\n # creates a list full of 0s with the same lenght of the vector\\r\\n for z in range(len(vector)):\\r\\n # for loop which continues as long as there are more elements left in the given vector \\r\\n result[z] = scalar*vector[z]\\r\\n # the list full of 0s is replaced by the product of each element in the given vector and the the scalar \\r\\n return result\",\n \"def scalar_mult(s, v):\\n\\tnewscal = [ ]\\n\\tfor i in range(len(v)):\\n\\t\\tnewscal += [s * v[i]]\\n\\tprint(newscal)\",\n \"def cost_function(self, u):\\n # enforce that the input is a numpy array\\n u = np.asarray(u)\\n\\n # Reshape the control input to (mxT). Vector input is required for some optimization libraries\\n T = int(len(u)/2)\\n u = u.reshape((2,T))\\n\\n J = - self.rho(u)\\n\\n return J\",\n \"def scalar_vector_mult(alpha, v):\\n return [alpha*x for x in v]\",\n \"def eval(self, x):\\n self.__check_input__(x)\\n x1 = x[0]\\n x2 = x[1]\\n\\n t = 1 / (8 * np.pi)\\n s = 10\\n r = 6\\n c = 5 / np.pi\\n b = 5.1 / (4 * np.pi ** 2)\\n a = 1\\n\\n term1 = a * (x2 - b * x1 ** 2 + c * x1 - r) ** 2\\n term2 = s * (1 - t) * np.cos(x1)\\n\\n return term1 + term2 + s\",\n \"def symbolic_objective(ingredients) -> Tuple[List[sp.Symbol], sp.Eq]:\\n assignments = sp.symbols(' '.join(ingredients.keys()))\\n\\n # Skip negative logic due to differentiability requirements\\n objective = 1\\n for attribute in filter(lambda x: x != \\\"calories\\\", next(iter(ingredients.values())).keys()):\\n objective *= sum(ingredients[str(x)][attribute] * x for x in assignments)\\n\\n return assignments, objective\",\n \"def get_magnitude_vector(given_vector):\\n\\n # Note: given vector is a dictionary of the form:\\n # {term : score}\\n\\n magnitude = 0\\n for item in given_vector.values():\\n magnitude += item ** 2\\n\\n return magnitude ** 0.5\",\n \"def _linear_dispersion_sum(k, j, d, beta, tau):\\n # k, j, d , beta = columns -> convert to Series -> broadcasted\\n # tau = Matrix as Frame\\n calc_column = (k + j * d) * np.sqrt(beta)\\n if isinstance(calc_column, pd.DataFrame):\\n calc_column = calc_column.squeeze()\\n return np.cos(2 * np.pi * tau).mul(calc_column, axis='index').sum(axis='index')\",\n \"def g(t1):\\n if isinstance(t1, IdentExp) and self.st.has_key(t1.name):\\n ninfo = self.st[t1.name]\\n if ninfo[\\\"srcty\\\"] == \\\"vector\\\":\\n if self.existMats and t1.name == n.exp.lhs.name:\\n return ArrayRefExp(t1, IdentExp(\\\"i2\\\"))\\n else:\\n self.st[\\\"itrs\\\"][0].update({ninfo[\\\"len\\\"][0]: \\\"i1\\\"})\\n return ArrayRefExp(t1, IdentExp(\\\"i1\\\"))\\n elif ninfo[\\\"srcty\\\"] == \\\"matrix\\\":\\n self.st[\\\"itrs\\\"][0].update({ninfo[\\\"len\\\"][0]: \\\"i1\\\"})\\n self.st[\\\"itrs\\\"][1].update({ninfo[\\\"len\\\"][1]: \\\"i2\\\"})\\n sub = s2t(\\\"exp\\\", ninfo[\\\"len\\\"][0] + \\\" * i2 + i1\\\")\\n return ArrayRefExp(t1, sub)\\n else:\\n return t1\\n else:\\n return t1\",\n \"def forward_substitution(l, b):\\n y = np.zeros(b.shape[0])\\n y[0] = b[0] / l[0, 0]\\n for i in range(1, b.shape[0]):\\n _sum = np.sum(l[i, :i] * y[:i])\\n y[i] = (b[i] - _sum) / l[i, i]\\n return y\",\n \"def symrate_to_subsymrate(self, symrate: t.T) -> t.T:\\n return symrate * self.subsymbol_count\",\n \"def _R(state, effects, observed_frequencies):\\n # this small number ~ 10^-304 is added so that we don't get divide by zero errors\\n machine_eps = np.finfo(float).tiny\\n # have a zero in the numerator, we can fix this is we look a little more carefully.\\n predicted_probs = np.array([np.real(np.trace(state.dot(effect))) for effect in effects])\\n update_operator = sum([effect * observed_frequencies[i] / (predicted_probs[i] + machine_eps)\\n for i, effect in enumerate(effects)])\\n return update_operator\",\n \"def y(x):\\n x1, x2, x3, x4 = x[:, 0], x[:, 1], x[:, 2], x[:, 3]\\n return 1 + 0.3 * x1 - 0.6 * x2 ** 2 - 0.2 * x3 ** 3 + 0.5 * x4 ** 4\",\n \"def u(self,x,i,temp):\\n return self.coeffs[i]*self.psi_funcs[i+temp](x) + self.coeffs[i+1]*self.psi_funcs[i+temp+1](x) + self.coeffs[i+2]*self.psi_funcs[i+temp+2](x)\",\n \"def _eval(self, v):\\n return super(weighted_sum_squares, self)._eval(self.weight * v)\",\n \"def x_rate(self):\\n values = self._interpolate_table(\\\"x\\\", derivative_order=1)\\n # values += self._corrections(('ortho_eop', iers.ortho_eop, 0, 1e-6),\\n # ('pmsdnut2', iers.pmsdnut2, 0, 1e-6))\\n return values\",\n \"def fv(rate, n_years):\\n return pow(1 + rate, n_years)\",\n \"def l1_reg(tensors, name='L1Reg'):\\n if hasattr(tensors, '__iter__'):\\n tensors = list(tensors)\\n with tf.name_scope(name, values=tensors):\\n return sum(tf.reduce_sum(tf.abs(p)) for p in tensors)\\n else:\\n with tf.name_scope(name, values=[tensors]):\\n return tf.reduce_sum(tf.abs(tensors))\",\n \"def eval(self, x):\\n y = list(x)\\n if not self.biased:\\n y.insert(0, 1.0)\\n y = np.array(y).reshape((self.Ws[0].shape[1], 1))\\n for W, g in zip(self.Ws, self.gs):\\n y = g(np.dot(W, y))\\n return y.flatten()\",\n \"def sym_sipexprs():\\n u, v = symbols('u v')\\n\\n sipu = 0\\n sipv = 0\\n for m in range(8):\\n for n in range(0, 8-m):\\n ac = symbols('a_%d_%d' % (m, n))\\n bc = symbols('b_%d_%d' % (m, n))\\n sipu += ac*u**m*v**n\\n sipv += bc*u**m*v**n\\n sipu.expand()\\n sipv.expand()\\n return sipu, sipv\",\n \"def similarity_vector(self, x):\\n r_x = self.encoder(x)[1]\\n return self.prototypes_layer(r_x)\",\n \"def get_lr_cost(self):\\n\\n\\t\\tlabels = self.get_symbolic_expected_rewards()\\n\\n\\t\\treturn -theano.tensor.mean(\\n\\t\\t\\ttheano.tensor.log(labels)[\\n\\t\\t\\t\\ttheano.tensor.arange(self.symbolic_output.shape[0]),\\n\\t\\t\\t\\tself.symbolic_output])\",\n \"def test_amp_sums_can_be_simplified(free_alg):\\n dr = free_alg\\n v = dr.names.v\\n n, i, j = symbols('n i j')\\n x = IndexedBase('x')\\n r = Range('D', 0, n)\\n\\n tensor = dr.sum((i, r), (j, r), i ** 2 * x[j] * v[j])\\n res = tensor.simplify_sums()\\n assert res == dr.sum((j, r), (\\n n ** 3 / 3 - n ** 2 / 2 + n / 6\\n ) * x[j] * v[j])\",\n \"def calcStartlingRates(startles):\\n startle_rates = np.sum(startles, axis=-1)\\n return startle_rates\",\n \"def v(x):\\n return x*x\",\n \"def vector_sum(a, b):\\n return a[0] + b[0], a[1] + b[1]\",\n \"def _abel_sym():\\n from sympy import symbols, simplify, integrate, sqrt\\n from sympy.assumptions.assume import global_assumptions\\n r, y,r0, r1,r2, z,dr, c0, c_r, c_rr,c_z, c_zz, c_rz = symbols(\\n 'r y r0 r1 r2 z dr c0 c_r c_rr c_z c_zz c_rz', positive=True)\\n f0, f1, f2 = symbols('f0 f1 f2')\\n global_assumptions.add(Q.is_true(r>y))\\n global_assumptions.add(Q.is_true(r1>y))\\n global_assumptions.add(Q.is_true(r2>y))\\n global_assumptions.add(Q.is_true(r2>r1))\\n P = c0 + (r-y)*c_r #+ (r-r0)**2*c_rr\\n K_d = 1/sqrt(r**2-y**2)\\n res = integrate(P*K_d, (r,y, r1))\\n sres= simplify(res)\\n print(sres)\",\n \"def rate (self, indep):\\n data = self.data\\n index = len(data)-2\\n for i in xrange(len(data)-1):\\n if indep < float(data[i+1][0]):\\n index = i\\n break\\n return self.interpolateValue(float(data[index][0]),float(data[index][2]),float(data[index+1][0]),float(data[index+1][2]),indep)\",\n \"def add(self, x):\\n self.sum += (1 / self.counter) * (x - self.sum)\\n self.counter += 1\",\n \"def constant_equation(funct):\\n return funct + \\\"x\\\"\",\n \"def linear(self, X):\\n return X\",\n \"def changeCurve(self, V):\\n # FIXME: is \\\"(not V[0] != 0)\\\" a correct condition?\\n if (not isinstance(V, list)) or (not len(V) == 4) or (not V[0] != 0):\\n raise ValueError(\\\"([u, r, s, t]) with u must not be 0.\\\")\\n\\n # FIXME: this is dependent rational.Rational\\n if self.ch == 0:\\n return EC([rational.Rational(self.a1+2*V[2], V[0]),\\n rational.Rational(self.a2-V[2]*self.a1+3*V[1]-V[2]**2, V[0]**2),\\n rational.Rational(self.a3+V[1]*self.a1+2*V[3], V[0]**3),\\n rational.Rational(self.a4-V[2]*self.a3+2*V[1]*self.a2-(V[3]+V[1]*V[2])*self.a1+3*V[1]**2-2*V[2]*V[3], V[0]**4),\\n rational.Rational(self.a6+V[1]*self.a4+V[1]**2*self.a2+V[1]**3-V[3]*self.a3-V[3]**2-V[1]*V[3]*self.a1, V[0]**6)])\\n else:\\n for v in V:\\n if not isinstance(v, int) or not (v in self.basefield):\\n raise ValueError(\\\"transform V must be integer sequence.\\\")\\n v = self.basefield.createElement(V[0]).inverse()\\n return EC([(self.a1+2*V[2])*v,\\n ((self.a2-V[2]*self.a1+3*V[1]-V[2]**2)*v**2),\\n ((self.a3+V[1]*self.a1+2*V[3])*v**3),\\n ((self.a4-V[2]*self.a3+2*V[1]*self.a2-(V[3]+V[1]*V[2])*self.a1+3*V[1]**2-2*V[2]*V[3])*v**4),\\n ((self.a6+V[1]*self.a4+V[1]**2*self.a2+V[1]**3-V[3]*self.a3-V[3]**2-V[1]*V[3]*self.a1)*v**6)], self.basefield)\",\n \"def __add__(self, B):\\n return (Polynomial(self) + B).simplify()\",\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 ADD_I_Vx(self, x):\\n\\t\\tself.I += self.V[x]\",\n \"def scipy_fun2(x):\\n answer = 0.0\\n for i in range(0, len(x)):\\n answer += (math.pow(-1,i))*(math.pow((i+1),math.pow(x[i], (i+1))))\\n return answer\",\n \"def _eval_coeff(self, pt):\\n val = 1\\n for a in self.args:\\n val *= a.coeff(pt)\\n return val\",\n \"def sum_of_squares(v: Vector) -> float:\\n return dot(v,v)\",\n \"def f(z, X, Y, _lambda):\\r\\n w = z[:-1]\\r\\n beta = np.squeeze(z[-1])\\r\\n term_1_d = (X * (Y[:, np.newaxis] - g(X.dot(w) + beta))).sum(axis=0)\\r\\n term_d_1 = (Y[:, np.newaxis] - g(X.dot(w) + beta)).sum() + 2 * _lambda * beta\\r\\n return np.hstack((term_1_d, term_d_1))[:, np.newaxis]\",\n \"def portfolio(R, x, Rx=None):\\n if Rx is None:\\n Rx = R @ x\\n return -np.sum(np.log(Rx)), Rx\",\n \"def prod_value(self, lv, rv):\",\n \"def conv_to_annualised_rate(sr):\\r\\n return np.expm1(sr)\",\n \"def update_V(self, Vs, Vs_next, reward, alpha, gamma):\\r\\n return Vs + alpha * (reward + gamma * Vs_next - Vs)\",\n \"def _symbolic_system(self):\\n system = sym.Matrix(self._symbolic_equations)\\n return system.subs(self._symbolic_change_of_vars)\",\n \"def solver_2star(d):\\n return sum([iterative_fuel(x) for x in d])\",\n \"def add(self, term):\\n self._value = self.accum_param.addInPlace(self._value, term)\",\n \"def add(self, number):\\n\\n return self.from_list([x+number for x in self.vector])\",\n \"def scalar_multiply(c: float, v: Vector) -> Vector:\\n return [c * v_i for v_i in v]\",\n \"def scalar_multiply(c: float, v: Vector) -> Vector:\\n return [c * v_i for v_i in v]\",\n \"def rrdb(x):\\n h = dense_block(x)\\n h = dense_block(h)\\n h = dense_block(h)\\n h = tf.keras.layers.Lambda(lambda x: x * 0.2)(h)\\n out = tf.keras.layers.Add()([h, x])\\n return out\",\n \"def incrementSparseVector(v1, scale, v2):\\n for index in v2:\\n v1[index] += v2[index] * scale\",\n \"def at_value(self, *value):\\n result = 0\\n for x in value:\\n i = 0\\n for coef in self.arg:\\n result = result + coef * (x ** i)\\n i = i + 1\\n result = -result\\n return -result\",\n \"def rate(self, t, i):\\n return np.real(self._rates[i](t))\",\n \"def prob1():\\n \\n x = sy.symbols('x')\\n exp = (sy.sin(x) + 1)**(sy.sin(sy.cos(x)))\\n f1 = sy.lambdify(x, sy.diff(exp, x))\\n return f1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58277977","0.5783349","0.57700616","0.57329583","0.56626755","0.5629675","0.5581536","0.55512124","0.54802674","0.5467065","0.5376773","0.5362954","0.5352122","0.53469217","0.5333205","0.53328913","0.5313943","0.5284388","0.52732974","0.52684164","0.5260822","0.5260451","0.5247471","0.5213614","0.52048886","0.5200404","0.51898557","0.5181363","0.5179256","0.51788235","0.51678175","0.5167044","0.5164718","0.51591766","0.5155653","0.51516676","0.5143719","0.5136796","0.513464","0.51300794","0.5115254","0.51062125","0.51056814","0.51029813","0.5091951","0.5089748","0.5086944","0.5086875","0.50850314","0.5084913","0.50832385","0.507135","0.5069031","0.5068909","0.50601125","0.5059446","0.5050318","0.50482994","0.50441134","0.5041059","0.50369555","0.5033685","0.50324434","0.5029193","0.5024864","0.50180477","0.50145465","0.5011588","0.5006784","0.49987024","0.49963996","0.49905008","0.49855867","0.49798107","0.49681205","0.49663496","0.49634293","0.49570394","0.49498162","0.49497822","0.4948864","0.49465138","0.49453232","0.49388158","0.4920417","0.49197483","0.49186498","0.4915965","0.4910835","0.4910246","0.49089396","0.49082592","0.49062654","0.4904676","0.4903235","0.4903235","0.4902018","0.49011767","0.4898759","0.48980677","0.48974732"],"string":"[\n \"0.58277977\",\n \"0.5783349\",\n \"0.57700616\",\n \"0.57329583\",\n \"0.56626755\",\n \"0.5629675\",\n \"0.5581536\",\n \"0.55512124\",\n \"0.54802674\",\n \"0.5467065\",\n \"0.5376773\",\n \"0.5362954\",\n \"0.5352122\",\n \"0.53469217\",\n \"0.5333205\",\n \"0.53328913\",\n \"0.5313943\",\n \"0.5284388\",\n \"0.52732974\",\n \"0.52684164\",\n \"0.5260822\",\n \"0.5260451\",\n \"0.5247471\",\n \"0.5213614\",\n \"0.52048886\",\n \"0.5200404\",\n \"0.51898557\",\n \"0.5181363\",\n \"0.5179256\",\n \"0.51788235\",\n \"0.51678175\",\n \"0.5167044\",\n \"0.5164718\",\n \"0.51591766\",\n \"0.5155653\",\n \"0.51516676\",\n \"0.5143719\",\n \"0.5136796\",\n \"0.513464\",\n \"0.51300794\",\n \"0.5115254\",\n \"0.51062125\",\n \"0.51056814\",\n \"0.51029813\",\n \"0.5091951\",\n \"0.5089748\",\n \"0.5086944\",\n \"0.5086875\",\n \"0.50850314\",\n \"0.5084913\",\n \"0.50832385\",\n \"0.507135\",\n \"0.5069031\",\n \"0.5068909\",\n \"0.50601125\",\n \"0.5059446\",\n \"0.5050318\",\n \"0.50482994\",\n \"0.50441134\",\n \"0.5041059\",\n \"0.50369555\",\n \"0.5033685\",\n \"0.50324434\",\n \"0.5029193\",\n \"0.5024864\",\n \"0.50180477\",\n \"0.50145465\",\n \"0.5011588\",\n \"0.5006784\",\n \"0.49987024\",\n \"0.49963996\",\n \"0.49905008\",\n \"0.49855867\",\n \"0.49798107\",\n \"0.49681205\",\n \"0.49663496\",\n \"0.49634293\",\n \"0.49570394\",\n \"0.49498162\",\n \"0.49497822\",\n \"0.4948864\",\n \"0.49465138\",\n \"0.49453232\",\n \"0.49388158\",\n \"0.4920417\",\n \"0.49197483\",\n \"0.49186498\",\n \"0.4915965\",\n \"0.4910835\",\n \"0.4910246\",\n \"0.49089396\",\n \"0.49082592\",\n \"0.49062654\",\n \"0.4904676\",\n \"0.4903235\",\n \"0.4903235\",\n \"0.4902018\",\n \"0.49011767\",\n \"0.4898759\",\n \"0.48980677\",\n \"0.48974732\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":875,"numItemsPerPage":100,"numTotalItems":95772,"offset":87500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTg3MjEyNiwianRpIjoiYjZiNDQ0MWMtMWYwOC00NDQxLWE5YzAtNmI1ZDU1MzViOTRiIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU4NzU3MjYsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.z2nthuRCmXVTji890rvL9ocoiVBeb1RCZ9y-dkXQnwd2HMLd6TrSGEwYe_4GDS53ktBBRMajF5DUuiou42hhDg","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 |
|---|---|---|---|---|---|---|
Initialize first name, last name, age, and gender attributes. | def __init__(self, first_name, last_name, age, gender):
self.first_name = first_name
self.last_name = last_name
self.age = age
self.gender = gender | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, f_name, l_name, age, gender, m_number):\n self.f_name = f_name\n self.l_name = l_name\n self.age = age\n self.gender = gender\n self.m_number = m_number",
"def __init__(self, first_name, last_name, age):\n\n self.first_name = first_name\n self.l... | [
"0.7688818",
"0.75608855",
"0.7557712",
"0.7557712",
"0.7557712",
"0.7557712",
"0.7557712",
"0.7557712",
"0.7557712",
"0.7557712",
"0.72796017",
"0.71924347",
"0.6994145",
"0.6983084",
"0.69552344",
"0.6938817",
"0.6919511",
"0.6853096",
"0.684336",
"0.6801357",
"0.67757064",... | 0.8197995 | 0 |
Prints a summary of the users information. | def describe_user(self):
print(self.first_name.title() + " " + self.last_name.title() +
" is a " + str(self.age) + " year old who identifies as " +
self.gender + ".") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def describe_user(self):\n print(self.first_name + \"\\n\" + self.last_name + \"\\n\" + self.Screen_name)",
"def describe_user(self):\r\n print('\\nFirst Name: ' + self.first_name.title(), end='\\n',)\r\n print('Last Name: ' + self.last_name.title(), end='\\n')\r\n print('Address: ' +... | [
"0.7686036",
"0.764411",
"0.7633761",
"0.7598822",
"0.75661665",
"0.75661665",
"0.75358224",
"0.74810886",
"0.7473855",
"0.7462429",
"0.7422792",
"0.74164706",
"0.73984045",
"0.73918474",
"0.72651684",
"0.7172735",
"0.7020377",
"0.69007635",
"0.6849133",
"0.68072605",
"0.6768... | 0.6934623 | 17 |
Prints a personlized greeting to the user. | def greet_user(self):
print("Welcome, " + self.first_name.title() + "!") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def greeting(name):\n print(\"\")\n print(\n \"Welcome to Mister Sweet's Mad Lib Story Telling Journey \" + name +\n \" :)\")\n print(\"\")",
"def greet_user(self):\n greeting = f\"Hi {self.first_name.title()}, welcome back!\\n\"\n print(greeting)",
"def greet_user():\r\n p... | [
"0.7979247",
"0.79529935",
"0.793578",
"0.7930732",
"0.7874761",
"0.78726554",
"0.7837822",
"0.783697",
"0.78200954",
"0.78161484",
"0.77571064",
"0.7719434",
"0.7597742",
"0.7597742",
"0.7512549",
"0.7466066",
"0.745762",
"0.745762",
"0.7451555",
"0.7346045",
"0.7307862",
... | 0.77470785 | 11 |
Initializes attributes from the parent class. Then initializes attributes specific to this subclass. | def __init__(self, first_name, last_name, age, gender):
super().__init__(first_name, last_name, age, gender)
self.priveleges = "can add post", "can delete post", "can ban user" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_attrs(self):\n raise NotImplementedError",
"def _init_attributes(self):\n self.attr = {\n 'name': None,\n 'tags': [],\n 'openHours': None,\n 'type': None,\n 'parent': None,\n 'locationId': None,\n 'bannerAbbreviat... | [
"0.7667003",
"0.71117824",
"0.69872975",
"0.677331",
"0.67648923",
"0.6745417",
"0.66914773",
"0.6608188",
"0.6567776",
"0.65150833",
"0.65029776",
"0.64848316",
"0.64557666",
"0.638375",
"0.63699836",
"0.6324615",
"0.63119954",
"0.62745345",
"0.62635255",
"0.6254116",
"0.623... | 0.0 | -1 |
Prints the priveleges granted to this type of User(Admin). | def show_priveleges(self):
print("This user:")
for privelege in self.priveleges:
print(privelege) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def showprivelages(self):\r\n\t\tprint (\"An administrator has the following abilities: \")\r\n\t\tfor power in self.powers:\r\n\t\t\tprint (\"- \" + power)",
"def show_privileges(self):\n print(\"This admin user has the following privileges:\")\n for item in self.privileges:\n print(f\"... | [
"0.77525014",
"0.76014477",
"0.7597725",
"0.7547358",
"0.7508543",
"0.74574864",
"0.73488426",
"0.7288568",
"0.5971587",
"0.586329",
"0.5682209",
"0.56727153",
"0.56551707",
"0.547195",
"0.54604584",
"0.54411626",
"0.5435521",
"0.5409437",
"0.53908664",
"0.5389564",
"0.538702... | 0.7839699 | 0 |
Passes the HTML file to the Markdown parser. Gets the resulting md and stores it in its own property | def parse(self, htmlFile):
htmlToMdParser = HtmlToMarkdown()
htmlToMdParser.readFile(htmlFile)
self.__setMarkdownOutput(htmlToMdParser.getMarkdown()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __html__(self, file_path:str) -> str:\n with open(f\"{file_path}\", \"r\") as mdfile: # Parse markdown file\n text = mdfile.read()\n html = self.md.convert(text) # Convert the markdown content text to hmtl\n return html",
"def parse(self, htmlfile):\r\n title_el, summary_el... | [
"0.7806094",
"0.75215423",
"0.72866136",
"0.7171097",
"0.71067405",
"0.69807774",
"0.68494374",
"0.6752766",
"0.6671119",
"0.6567304",
"0.6497255",
"0.64291793",
"0.63721174",
"0.6348815",
"0.6338439",
"0.6311875",
"0.6305898",
"0.6284648",
"0.62832975",
"0.6280578",
"0.62183... | 0.8087815 | 0 |
Write selfs markdown data to file | def __writeToFile(self, mdFile):
with open(mdFile, 'a') as writer:
for line in self.__markdownOutput:
writer.write(line) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_markdown_report(self, **kwargs):\n save_dir = os.path.dirname(self.file_paths[0])\n timestamp = datetime.datetime.utcnow().strftime(\"%Y-%j-%Hh%Mm%Ss\")\n markdown_file_name = \"report_{}.md\".format(timestamp)\n markdown_file_path = os.path.join(save_dir, markdown_file_name)\n... | [
"0.70040005",
"0.65243876",
"0.6442088",
"0.6366318",
"0.6351913",
"0.63268805",
"0.6305234",
"0.62839085",
"0.62771386",
"0.62156075",
"0.61913127",
"0.6144183",
"0.61168224",
"0.6007978",
"0.60004336",
"0.60001224",
"0.5982156",
"0.59446424",
"0.59380436",
"0.59365654",
"0.... | 0.7303364 | 0 |
Public method to coordinate the writing out of markdown | def outputMarkdown(self, mdFile):
if os.path.exists(mdFile):
os.remove(mdFile)
self.__writeToFile(mdFile) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write():\n \n st.title(\"All about me..!!\")\n st.markdown(\n \"\"\"\n\n:large_blue_diamond: **Data Engineer**\\n\nThe current role revolves around working with database management(AWS Redshift), automation of tasks (using Python), and helping out other teams at work with required data ... | [
"0.7164668",
"0.6390969",
"0.6139194",
"0.61002076",
"0.60791314",
"0.6069406",
"0.6055646",
"0.6033149",
"0.6022967",
"0.5998853",
"0.59313035",
"0.5926876",
"0.5887407",
"0.5865887",
"0.5865716",
"0.58579427",
"0.58537984",
"0.5846108",
"0.5844487",
"0.58379096",
"0.583403"... | 0.5605465 | 34 |
Generate a Bert wordpiece vocabulary from a `tf.data.Dataset` of texts. ``` import tensorflow_text as text vocab = bert_vocab_from_dataset(dataset, vocab_size, reserved_tokens, bert_tokenizer_params, learn_params) bert_tokenizer = text.BertTokenizer(vocab, bert_tokenizer_params) token_ids = bert_tokenizer.tokenize(text... | def bert_vocab_from_dataset(dataset,
vocab_size: int,
reserved_tokens: List[str],
bert_tokenizer_params=None,
learn_params=None) -> List[str]:
if bert_tokenizer_params is None:
bert_tokenizer_params = {... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_dataset(cls, dataset, col_names, vocab_size, character_coverage, model_type, params):\n\n vocab = SentencePieceVocab()\n root = copy.deepcopy(dataset).build_sentencepiece_vocab(vocab, col_names, vocab_size, character_coverage,\n ... | [
"0.6695434",
"0.59435654",
"0.57949984",
"0.56768864",
"0.56709015",
"0.5485758",
"0.5482027",
"0.543974",
"0.5393621",
"0.5373836",
"0.53656673",
"0.53424793",
"0.53227395",
"0.5320037",
"0.5311882",
"0.5262313",
"0.52581626",
"0.5236028",
"0.5179154",
"0.51750255",
"0.51681... | 0.72508216 | 0 |
save all the FLAG values in a config file / xml file | def save_config(FLAGS, logfolder, file_name = "configuration"):
print("Save configuration to: {}".format(logfolder))
root = ET.Element("conf")
flg = ET.SubElement(root, "flags")
flags_dict=FLAGS.__dict__
for f in sorted(flags_dict.keys()):
# print f, flags_dict[f]
e = ET.SubElement(flg, f, name=f) ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_config(logfolder, file_name = \"configuration\"):\n print(\"Save configuration to: \", logfolder)\n root = ET.Element(\"conf\")\n flg = ET.SubElement(root, \"flags\")\n \n flags_dict = FLAGS.__dict__['__flags']\n for f in flags_dict:\n #print f, flags_dict[f]\n ET.SubElement(flg, f, name=f).te... | [
"0.758127",
"0.7308489",
"0.67504543",
"0.67352724",
"0.6585914",
"0.62659514",
"0.62000674",
"0.61799616",
"0.6170416",
"0.6162446",
"0.61308473",
"0.61104065",
"0.61041206",
"0.60973454",
"0.60634506",
"0.60334367",
"0.599318",
"0.59699816",
"0.5965832",
"0.59636515",
"0.59... | 0.76940143 | 0 |
save all the FLAG values in a config file / xml file | def load_config(FLAGS, modelfolder, file_name = "configuration"):
print("Load configuration from: ", modelfolder)
tree = ET.parse(os.path.join(modelfolder,file_name+".xml"))
boollist=['auxiliary_depth', 'discrete']
intlist=['n_frames', 'num_outputs']
floatlist=['depth_multiplier','speed','action_bound']
str... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_config(FLAGS, logfolder, file_name = \"configuration\"):\n print(\"Save configuration to: {}\".format(logfolder))\n root = ET.Element(\"conf\")\n flg = ET.SubElement(root, \"flags\")\n \n flags_dict=FLAGS.__dict__\n for f in sorted(flags_dict.keys()):\n # print f, flags_dict[f]\n e = ET.SubEle... | [
"0.76940143",
"0.758127",
"0.7308489",
"0.67504543",
"0.67352724",
"0.6585914",
"0.62659514",
"0.62000674",
"0.61799616",
"0.6170416",
"0.6162446",
"0.61308473",
"0.61104065",
"0.61041206",
"0.60973454",
"0.60634506",
"0.60334367",
"0.599318",
"0.59699816",
"0.5965832",
"0.59... | 0.57908255 | 33 |
Map natural position to machine code postion | def map_position(pos):
posiction_dict = dict(zip(range(1, 17), [i for i in range(30, 62) if i % 2]))
return posiction_dict[pos] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def map_pos_tag(pos):\n\n\tmappings = {'NN': wn.NOUN, 'JJ': wn.ADJ, 'VB': wn.VERB, 'RB': wn.ADV}\n\tpos = pos[:2]\n\tif pos in mappings:\n\t\tpos = mappings[pos]\n\telse:\n\t\tpos = wn.NOUN\n\treturn pos",
"def compute_offset_pos(seq, pos):\n \n nogap_seq = transform_seq(seq)\n assert(pos >= 0 and pos <... | [
"0.5799386",
"0.56906056",
"0.5584939",
"0.5500977",
"0.54784864",
"0.5363552",
"0.5348209",
"0.525057",
"0.52384615",
"0.5234695",
"0.51939845",
"0.5183469",
"0.5177587",
"0.51565945",
"0.51374286",
"0.51320094",
"0.51159453",
"0.51113105",
"0.5074599",
"0.50590044",
"0.5052... | 0.6337538 | 0 |
Get a snapshot and save it to disk. | def snap(self, path=None):
if path is None:
path = "/tmp"
else:
path = path.rstrip("/")
day_dir = datetime.datetime.now().strftime("%d%m%Y")
hour_dir = datetime.datetime.now().strftime("%H%M")
ensure_snapshot_dir(path+"/"+self.cam_id+"/"+day_dir+"/"+hour_d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def saveSnapshot(self, filename): \n\t\tpass",
"def snapshot(self):\n self._client.snapshot()",
"def snapshot(self) -> Snapshot:\n snapshot = self.open(Snapshot.type).signed\n if not isinstance(snapshot, Snapshot):\n raise RuntimeError(\"Unexpected snapshot type\")\n ... | [
"0.73514926",
"0.70761585",
"0.66926736",
"0.6627929",
"0.66162276",
"0.6583161",
"0.65360063",
"0.63850576",
"0.63814706",
"0.6340474",
"0.63032293",
"0.6283096",
"0.6270011",
"0.6243555",
"0.6231108",
"0.6216452",
"0.6180958",
"0.6147651",
"0.6147121",
"0.6104813",
"0.60983... | 0.7027908 | 2 |
Move cam to given preset position. pos must be within 1 to 16. | def move(self, pos):
try:
payload = {"address":self.address, "user": self.user, "pwd": self.pswd, "pos": map_position(pos)}
resp = requests.get(
"http://{address}/decoder_control.cgi?command={pos}&user={user}&pwd={pwd}".format(**payload)
)
except ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setPos(self, pos):\n self.cameraNode.setPos(pos)",
"def set_position(self, pos, debug=False):\n pos = max(pos, 0)\n pos = min(pos, 1)\n posrange = pos * self.range\n pos = posrange + self.min\n if debug:\n print('Setting Dynamixel {} with posrange {} to po... | [
"0.7138918",
"0.64176524",
"0.6216379",
"0.6157313",
"0.60971105",
"0.6046289",
"0.60182077",
"0.59599185",
"0.5955653",
"0.5935965",
"0.5924134",
"0.58532727",
"0.5846093",
"0.5841225",
"0.5791711",
"0.5789152",
"0.5782726",
"0.5772265",
"0.57623875",
"0.57590634",
"0.573229... | 0.69712156 | 1 |
Retrieve some configuration params. | def status(self):
resp = requests.get("http://{0}/get_status.cgi".format(self.address))
data = resp.text.replace(";", "")
data = data.replace("var", "")
data_s = data.split("\n")
# Last is an empty line
data_s.pop()
data_array = [s.split("=") for s in data_s]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getParams(self):\n self.logger.info(\"Getting All Params from config file.\")\n self.params = {}\n for interface in self.config.get('agent', 'interfaces'):\n params = self.params.setdefault(interface, {})\n for item in [['intf_reserve', 1000], ['intf_max', 10000], ['l... | [
"0.7338206",
"0.7333596",
"0.72458017",
"0.70778966",
"0.70616674",
"0.70084393",
"0.69818825",
"0.69765306",
"0.69468594",
"0.69468594",
"0.69375813",
"0.6893419",
"0.68922675",
"0.6865233",
"0.6865233",
"0.6865233",
"0.68336135",
"0.6805127",
"0.6796573",
"0.67850155",
"0.6... | 0.0 | -1 |
Return error message in unicode type OR new pair data | def insert_keyword(self, keyword, reply, creator_id, pinned, kw_type, rep_type, linked_word=None, rep_attach_text=None):
creator_id_ref = self._uid2ref(creator_id)
if keyword.replace(' ', '') == '':
return error.main.invalid_thing_with_correct_format(u'關鍵字', u'字數大於0，但小於500字(中文250字)的字串', key... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data_type_error_text(field_name, field_value, type_name):\n\n\tmessage = ''\n\n\ttry:\n\t\tmessage = (\"Value '{0}' entered for '{1}' could not be parsed as a valid {2}\"\n\t\t\t\t .format(str(field_value),field_name,type_name))\n\texcept TypeError:\n\t\tmessage = (\"A value entered for '{0}' could not b... | [
"0.62162715",
"0.6213315",
"0.61661386",
"0.6143035",
"0.6127491",
"0.6063554",
"0.6040141",
"0.59521276",
"0.5943248",
"0.59175944",
"0.5916721",
"0.58774024",
"0.58451897",
"0.5836796",
"0.58296627",
"0.58269215",
"0.5776696",
"0.5756682",
"0.57526934",
"0.5747043",
"0.5727... | 0.0 | -1 |
Return disabled data list in type pair_data. None if nothing updated. | def disable_keyword(self, keywords, disabler, pinned=False, exclude_id=None):
if isinstance(keywords, (str, unicode)):
keywords = [keywords]
query_dict = { pair_data.KEYWORD: { '$in': [kw.lower() for kw in keywords] } }
if exclude_id is not None:
query_dict[pair_data.SE... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def disable(self):\n for val in data:\n val.disable()\n self.enabled = False",
"async def refresh_pairs(self):\n\n summaries = await self.api.get_market_summaries()\n if summaries is None:\n self.log.error('Could not get market summaries data.')\n ... | [
"0.542848",
"0.5315378",
"0.51291287",
"0.509663",
"0.50135475",
"0.49947545",
"0.49913836",
"0.49693638",
"0.49531627",
"0.4946007",
"0.49041572",
"0.48881",
"0.48801425",
"0.48505482",
"0.4849771",
"0.48385632",
"0.4810579",
"0.481049",
"0.4790208",
"0.4790183",
"0.47853807... | 0.0 | -1 |
Return disabled data list in type pair_data. None if nothing updated. | def disable_keyword_by_id(self, id_or_id_list, disabler, pinned=False):
if not isinstance(id_or_id_list, list):
id_or_id_list = [id_or_id_list]
query_dict = { pair_data.SEQUENCE: { '$in': id_or_id_list } }
return self._disable(query_dict, disabler, pinned) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def disable(self):\n for val in data:\n val.disable()\n self.enabled = False",
"async def refresh_pairs(self):\n\n summaries = await self.api.get_market_summaries()\n if summaries is None:\n self.log.error('Could not get market summaries data.')\n ... | [
"0.5426085",
"0.5321331",
"0.5129032",
"0.5097894",
"0.50142515",
"0.49939844",
"0.49927738",
"0.49670318",
"0.4954972",
"0.4945268",
"0.4904914",
"0.4892326",
"0.48819578",
"0.4856891",
"0.48528916",
"0.48417345",
"0.481017",
"0.48065466",
"0.47947448",
"0.47891176",
"0.4785... | 0.0 | -1 |
Return none if nothing found, else return result in pair_data class | def get_reply_data(self, keyword, kw_type=word_type.TEXT):
data_result = self.find_one({
pair_data.KEYWORD: keyword.lower(),
pair_data.PROPERTIES + '.' + pair_data.DISABLED: False,
pair_data.PROPERTIES + '.' + pair_data.KEYWORD_TYPE: int(kw_type)
}, sort=[(pair_data.P... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def first(pair):\n\treturn pair[0]",
"def get_uncertain_pair(self):\n\n record_pair = self.uncertain_pairs.pop()\n\n self.print_pair(record_pair)\n\n return record_pair",
"def create_pair(self, players_list: list[Player], id_number, already_paired=[]) -> tuple:\n for player_1, playe... | [
"0.57107174",
"0.5575479",
"0.55203307",
"0.5501925",
"0.5500681",
"0.5489601",
"0.54136205",
"0.5363637",
"0.53393865",
"0.53346926",
"0.52999115",
"0.5282481",
"0.5273748",
"0.5250695",
"0.52297556",
"0.52251554",
"0.5213558",
"0.5200448",
"0.5177069",
"0.51753825",
"0.5154... | 0.4736274 | 89 |
Add Linked words by ID(s) to specified keyword pair. Keyword pair is specified by ID(s). | def set_pinned_by_index(self, ids, pinned=True):
if isinstance(ids, (int, long)):
ids = [ids]
ids = [int(id) for id in ids]
update_result = self.update_many({ '$and': [{ pair_data.SEQUENCE: { '$in': ids } }, { pair_data.PROPERTIES + '.' + pair_data.DISABLED: False }] },
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_word_and_label_id(self, word, label_id):\n self.words.append(word)\n self.label_ids.append(label_id)",
"def _add_word(self, id_: int, word: str, key: str) -> None:\n node = self.root\n for c in word:\n self._alphabet.add(c)\n node = node[c]\n # we can't ha... | [
"0.68641037",
"0.65201336",
"0.63025326",
"0.6189139",
"0.60892147",
"0.60643345",
"0.6054709",
"0.6050733",
"0.60165113",
"0.6014936",
"0.5979364",
"0.59585273",
"0.5942754",
"0.5929582",
"0.5904541",
"0.58855027",
"0.5830861",
"0.5762395",
"0.5753166",
"0.57341135",
"0.5724... | 0.0 | -1 |
Add Linked words by ID(s) to specified keyword pair. Keyword pair is specified by ID(s). | def set_pinned_by_keyword(self, keywords, pinned=True):
if isinstance(keywords, (str, unicode)):
keywords = [keywords]
update_result = self.update_many({ '$and': [{ pair_data.KEYWORD: { '$in': [kw.lower() for kw in keywords] } },
{ pair_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_word_and_label_id(self, word, label_id):\n self.words.append(word)\n self.label_ids.append(label_id)",
"def _add_word(self, id_: int, word: str, key: str) -> None:\n node = self.root\n for c in word:\n self._alphabet.add(c)\n node = node[c]\n # we can't ha... | [
"0.68639284",
"0.65199584",
"0.6300855",
"0.6188392",
"0.6087073",
"0.6063204",
"0.605348",
"0.6049926",
"0.60149044",
"0.6013106",
"0.5977732",
"0.59588736",
"0.5941377",
"0.5927862",
"0.59027624",
"0.5883227",
"0.5829075",
"0.5761525",
"0.57517624",
"0.5732342",
"0.5723102"... | 0.0 | -1 |
Return none if nothing found, else return result in list of pair_data class | def search_pair_by_keyword(self, keyword, data_exact_same=False):
keyword = unicode(keyword).lower()
filter_dict = {
'$or': [
{ pair_data.KEYWORD: keyword if data_exact_same else { '$regex': keyword, '$options': 'i' } },
{ pair_data.REPLY: keyword if data_exa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def paired(self):\n return Pairs(filter(not_none, self))",
"def _get_pairs_simple(self, distance):\n pairs = self.data_kd[0].query_pairs(distance)\n pairs = set(frozenset(p) for p in pairs)\n for kd in self.data_kd[1:]:\n newpairs = set(frozenset(p) for p in kd.query_pairs(... | [
"0.6096052",
"0.5926023",
"0.58436996",
"0.57692224",
"0.5673958",
"0.5628035",
"0.56151766",
"0.5612439",
"0.5584885",
"0.5577176",
"0.5573816",
"0.5546721",
"0.5541174",
"0.5510128",
"0.5508485",
"0.54793435",
"0.5476978",
"0.5472595",
"0.5451191",
"0.54276234",
"0.5424087"... | 0.0 | -1 |
Return none if nothing found, else return result in list of pair_data class | def search_pair_by_index(self, start_id_or_id_list, end_id=None):
if not isinstance(start_id_or_id_list, (int, long, list)) or (not isinstance(end_id, (int, long)) and end_id is not None):
raise ValueError('Start index must be integer, long or list. End index must be integer or long.')
if i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def paired(self):\n return Pairs(filter(not_none, self))",
"def _get_pairs_simple(self, distance):\n pairs = self.data_kd[0].query_pairs(distance)\n pairs = set(frozenset(p) for p in pairs)\n for kd in self.data_kd[1:]:\n newpairs = set(frozenset(p) for p in kd.query_pairs(... | [
"0.6096052",
"0.5926023",
"0.58436996",
"0.57692224",
"0.5673958",
"0.5628035",
"0.56151766",
"0.5612439",
"0.5584885",
"0.5577176",
"0.5573816",
"0.5546721",
"0.5541174",
"0.5510128",
"0.5508485",
"0.54793435",
"0.5476978",
"0.5472595",
"0.5451191",
"0.54276234",
"0.5424087"... | 0.0 | -1 |
Return none if nothing found, else return result in list of pair_data class | def search_all_available_pair(self):
return self._search({}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def paired(self):\n return Pairs(filter(not_none, self))",
"def _get_pairs_simple(self, distance):\n pairs = self.data_kd[0].query_pairs(distance)\n pairs = set(frozenset(p) for p in pairs)\n for kd in self.data_kd[1:]:\n newpairs = set(frozenset(p) for p in kd.query_pairs(... | [
"0.6096052",
"0.5926023",
"0.58436996",
"0.57692224",
"0.5673958",
"0.5628035",
"0.56151766",
"0.5612439",
"0.5584885",
"0.5577176",
"0.5573816",
"0.5546721",
"0.5541174",
"0.5508485",
"0.54793435",
"0.5476978",
"0.5472595",
"0.5451191",
"0.54276234",
"0.5424087",
"0.54121107... | 0.5510128 | 13 |
Return none if nothing found, else return result in list of pair_data class | def search_pair_by_creator(self, uid):
filter_dict = { pair_data.STATISTICS + '.' + pair_data.CREATOR: uid }
return self._search(filter_dict) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def paired(self):\n return Pairs(filter(not_none, self))",
"def _get_pairs_simple(self, distance):\n pairs = self.data_kd[0].query_pairs(distance)\n pairs = set(frozenset(p) for p in pairs)\n for kd in self.data_kd[1:]:\n newpairs = set(frozenset(p) for p in kd.query_pairs(... | [
"0.60958713",
"0.592484",
"0.5841869",
"0.5769072",
"0.56732744",
"0.562842",
"0.56133056",
"0.56118524",
"0.55850166",
"0.5577919",
"0.55734175",
"0.5546835",
"0.5540125",
"0.55101573",
"0.55081344",
"0.54785544",
"0.54759765",
"0.5471472",
"0.5451345",
"0.5426233",
"0.54235... | 0.0 | -1 |
Add Linked words by ID(s) to specified keyword pair. Keyword pair is specified by ID(s). | def add_linked_word_by_id(self, target_ids, linked_ids, able_to_mod_pin=False):
filter_dict, linked_ids = self._preproc_linked_by_id(target_ids, linked_ids, able_to_mod_pin)
return self._postproc_linked(filter_dict, linked_ids, True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_word_and_label_id(self, word, label_id):\n self.words.append(word)\n self.label_ids.append(label_id)",
"def _add_word(self, id_: int, word: str, key: str) -> None:\n node = self.root\n for c in word:\n self._alphabet.add(c)\n node = node[c]\n # we can't ha... | [
"0.68641037",
"0.65201336",
"0.63025326",
"0.6189139",
"0.60892147",
"0.60643345",
"0.6054709",
"0.6050733",
"0.60165113",
"0.6014936",
"0.5979364",
"0.5942754",
"0.5929582",
"0.5904541",
"0.58855027",
"0.5830861",
"0.5762395",
"0.5753166",
"0.57341135",
"0.5724238",
"0.57221... | 0.59585273 | 11 |
Delete Linked words from specified keyword pair. Keyword pair is specified by ID(s). | def del_linked_word_by_id(self, target_ids, linked_ids, able_to_mod_pin=False):
filter_dict, linked_ids = self._preproc_linked_by_id(target_ids, linked_ids, able_to_mod_pin)
return self._postproc_linked(filter_dict, linked_ids, False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self, keyword, key):",
"def delete_link(self, word):\n meaning = self.word2meaning[word]\n print(str(self.unique_id) + \" forgot \" +\n str(word) + \" for \" + str(meaning))\n del self.word2meaning[word]\n del self.meaning2word[meaning]\n del self.wordsu... | [
"0.68989724",
"0.6787392",
"0.66336787",
"0.66126007",
"0.6610202",
"0.65756625",
"0.64265597",
"0.63914794",
"0.6191663",
"0.6145425",
"0.6071145",
"0.60503215",
"0.6015974",
"0.5968459",
"0.5925361",
"0.5912555",
"0.58320093",
"0.5829038",
"0.581899",
"0.5680304",
"0.566869... | 0.60354024 | 12 |
Add Linked words by ID(s) to specified keyword pair. Keyword pair is specified by keyword(s). | def add_linked_word_by_word(self, target_words, linked_words, able_to_mod_pin=False):
filter_dict, linked_words = self._preproc_linked_by_word(target_words, linked_words, able_to_mod_pin)
return self._postproc_linked(filter_dict, linked_words, True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_word_and_label_id(self, word, label_id):\n self.words.append(word)\n self.label_ids.append(label_id)",
"def add(self, word):\n\t\tif word not in self.link_words:\n\t\t\tself.link_words.append(word)",
"def insert_keyword(kwd, pkg_id):\n global kwd_index\n try:\n sql = 'INSERT INTO key... | [
"0.664027",
"0.6335486",
"0.6330179",
"0.6327179",
"0.621176",
"0.61829555",
"0.6150729",
"0.61346394",
"0.6093935",
"0.60321534",
"0.59955174",
"0.5984343",
"0.597471",
"0.59707475",
"0.5912863",
"0.5886187",
"0.5872698",
"0.58481836",
"0.5820663",
"0.58013463",
"0.5750912",... | 0.58132297 | 19 |
Delete Linked words from specified keyword pair. Keyword pair is specified by keyword. | def del_linked_word_by_word(self, target_words, linked_words, able_to_mod_pin=False):
filter_dict, linked_words = self._preproc_linked_by_word(target_words, linked_words, able_to_mod_pin)
return self._postproc_linked(filter_dict, linked_words, False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self, keyword, key):",
"def problem_keyword_delete(self, identifier, keyword):\n self._delete(\"problems/%d/keywords/%s\" % (identifier, quote(keyword, safe=\"\")))",
"def remove(self, word):\n\t\tif word in self.link_words:\n\t\t\tself.link_words.remove(word)",
"def delete_link(self, word)... | [
"0.7170378",
"0.68357",
"0.68182",
"0.6725521",
"0.67138326",
"0.64427257",
"0.63949317",
"0.6371659",
"0.6353016",
"0.62722796",
"0.6100241",
"0.6067523",
"0.5961908",
"0.59342724",
"0.58869314",
"0.58450747",
"0.58347297",
"0.5744543",
"0.5683425",
"0.56488854",
"0.5644567"... | 0.6335577 | 9 |
Return empty array if nothing found, else return array of sequence id. | def user_created_id_array(self, uid):
result = self.find({ pair_data.STATISTICS + '.' + pair_data.CREATOR: self._uid2ref(uid) },
{ pair_data.SEQUENCE: True } ).sort(pair_data.SEQUENCE, pymongo.ASCENDING)
if result is not None:
return [data[pair_data.SEQUENCE] for... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ids(self) -> List[str]:",
"def _id_seq(self):\n return list(self.keys())",
"def subseqs_ids(subsequences, sequence):\n return [1 if subsequence in sequence else 0 for subsequence in subsequences]",
"def get_seq(self): # -> list[Unknown]:\n ...",
"def getIDs():",
"def get_seq_ids(... | [
"0.63351494",
"0.63165605",
"0.6204257",
"0.6197235",
"0.6129571",
"0.6069571",
"0.59799623",
"0.5919414",
"0.5913466",
"0.5878638",
"0.5865883",
"0.5837098",
"0.58289546",
"0.57959354",
"0.5780037",
"0.5777107",
"0.57456404",
"0.5724617",
"0.571826",
"0.571826",
"0.5714811",... | 0.6340417 | 0 |
Return none if not found | def _ref2uid(self, ref):
return self._uid_ref.get_uid(ref) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find(found_item, _):\n if found_item:\n return found_item[1]\n else:\n return default",
"def lookup():",
"def find_exact(self, **kwargs):\n results = list(self.find(**kwargs))\n if len(results) == 1:\n return results[0]\n r... | [
"0.65665185",
"0.6487816",
"0.6405071",
"0.636868",
"0.63648057",
"0.6285282",
"0.6283602",
"0.6252866",
"0.6241064",
"0.6221074",
"0.6160002",
"0.6154548",
"0.612161",
"0.6106493",
"0.60867506",
"0.6037409",
"0.6020851",
"0.60034883",
"0.59787875",
"0.5951527",
"0.5948574",
... | 0.0 | -1 |
Always not none, length will be 0 if nothing inside(empty array). | def linked_words(self):
return self[pair_data.PROPERTIES][pair_data.LINKED_WORDS] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _len(self):\n if self.array is not None:\n return len(self.array)\n print(\">>> List is None\")\n return None",
"def is_empty(self):\n return self.size == []",
"def __len__(self):\n return len(self.array)",
"def __len__(self):\n return len(self.array)"... | [
"0.75212395",
"0.7021856",
"0.6965229",
"0.6965229",
"0.6914274",
"0.684622",
"0.68350154",
"0.6810869",
"0.6810869",
"0.67964685",
"0.67603344",
"0.67090696",
"0.6679631",
"0.66717803",
"0.6670068",
"0.66585845",
"0.6644336",
"0.6640907",
"0.66185313",
"0.66050905",
"0.65966... | 0.0 | -1 |
Returns all subclasses of this base class. The dictionary poses as Backend registry. | def get_subclasses(cls) -> dict:
return dict(cls._subclasses) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_all(cls):\r\n # BaseProvider does so have __subclassess__. pylint: disable-msg=no-member\r\n return {klass.NAME: klass for klass in BaseProvider.__subclasses__()}",
"def get_all_object_classes(cls) -> Dict[str, Type[objects.BaseObject]]:\n cls._refresh_registry()\n return cop... | [
"0.7478175",
"0.715127",
"0.70746803",
"0.70010734",
"0.66492534",
"0.6618857",
"0.6606922",
"0.6604169",
"0.65711075",
"0.65670526",
"0.6564629",
"0.6552424",
"0.6425689",
"0.6420186",
"0.638971",
"0.6376375",
"0.6374097",
"0.6343866",
"0.6304094",
"0.62940854",
"0.6286731",... | 0.7372407 | 1 |
Method to wrap the backend strategy. | def detect(
self, img: Union[np.ndarray, List[np.ndarray]], *args, **kwargs
) -> Tuple[torch.Tensor, np.ndarray]:
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wrap_strategy(self): \n return self._wrap_strategy",
"def _backend(self) -> Backend:\n return self.__backend",
"def fake_backend_init(obj, *args, **kwargs):\n\n from armstrong.apps.embeds.backends import get_backend\n super(Backend, obj).__init__(*args, **kwargs)\n\n # patching this... | [
"0.7227032",
"0.69040304",
"0.64009994",
"0.6367698",
"0.6356445",
"0.6216431",
"0.61890733",
"0.60283273",
"0.586486",
"0.580149",
"0.5751558",
"0.5739716",
"0.5683213",
"0.56797254",
"0.5676801",
"0.56158113",
"0.5596493",
"0.55426824",
"0.5518247",
"0.54800737",
"0.5476997... | 0.0 | -1 |
Minimum brightness, 0, that is, totally dark, read only | def min_brightness(self):
return .0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_max_brightness(self) -> float:\n return max(self._color)",
"def brightness(value):\n value = int(value)\n if value < 1 or value > 254:\n raise ValueError('Minimum brightness is 1, to the maximum 254')\n return value",
"def brightness(self) -> float:\n # http://alienryderfl... | [
"0.67517716",
"0.66309625",
"0.6602429",
"0.6565702",
"0.65619093",
"0.65543157",
"0.6543305",
"0.64708745",
"0.6433429",
"0.64129823",
"0.6346434",
"0.6346434",
"0.6346434",
"0.6346434",
"0.6346434",
"0.6346434",
"0.6346434",
"0.6346434",
"0.6346434",
"0.6346434",
"0.6346434... | 0.8576602 | 0 |
Multichannel short time fourier transform | def wpe_stft(data, frame_size=512, overlap=0.75, window=None):
assert(data.ndim == 2)
if window == None:
window = np.hanning(frame_size)
frame_shift = int(frame_size - np.floor(overlap * frame_size))
cols = int(np.ceil((data.shape[1] - frame_size) / frame_shift)) + 1
data = np.concatenate(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_fourier_transform(chunked_audio):\n pass",
"def fourier(img):\n return fourierCV(img)",
"def _irfft2d(f_x) :",
"def fourier(data, temp_freq, axis, output = 'amplitude'):\n\t\t\n\t\n\t# take largest possible multiple of F1 from PSTH.\n\t# Generate freq and fft\n\t# generate amplitude\n\t# ... | [
"0.7064482",
"0.66905",
"0.65036297",
"0.64643455",
"0.6447374",
"0.6149582",
"0.60905504",
"0.6070598",
"0.59986216",
"0.5901727",
"0.589078",
"0.5863174",
"0.5843375",
"0.5842394",
"0.58308554",
"0.5829032",
"0.5818499",
"0.58096373",
"0.58095837",
"0.5797135",
"0.5791208",... | 0.0 | -1 |
Multichannel inverse short time fourier transform | def wpe_istft(data, frame_size=None, overlap=0.75, window=None):
assert(data.ndim == 3)
real_data = np.fft.irfft(data)
if frame_size == None:
frame_size = real_data.shape[-1]
frame_num = data.shape[-2]
frame_shift = int(frame_size - np.floor(frame_size * overlap))
length = (frame_num - 1... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _irfft2d(f_x) :",
"def fourier(img):\n return fourierCV(img)",
"def apply_fourier_transform(chunked_audio):\n pass",
"def IDFT2(fourier_image):\n return IDFT(IDFT(fourier_image).transpose()).transpose()",
"def fourier_transform2d(self):\n\n zerofill = np.zeros(1024 * np.array([1... | [
"0.68281204",
"0.66871434",
"0.6438106",
"0.6370882",
"0.63578653",
"0.6244935",
"0.6174011",
"0.6111227",
"0.59716445",
"0.59715253",
"0.5963575",
"0.5936594",
"0.5902908",
"0.58940446",
"0.58899385",
"0.5874245",
"0.58656013",
"0.5858009",
"0.5849362",
"0.58263624",
"0.5824... | 0.0 | -1 |
Frequencydomain variancenormalized delayed liner prediction This is the core part of the WPE method. The variancenormalized linear prediciton algorithm is implemented in each frequency bin separately. Both the input and output signals are in timedomain. | def __fdndlp(self, data):
freq_data = wpe_stft(
data / np.abs(data).max(),
frame_size=self.frame_size, overlap=self.overlap)
self.freq_num = freq_data.shape[-1]
drv_freq_data = freq_data[0:self.out_num].copy()
for i in range(self.freq_num):
xk = freq... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n np.set_printoptions(threshold=25)\n ts_length = 1000\n window_size = 50\n\n print('\\nSimple single timeseries vector prediction')\n timeseries = np.arange(ts_length) # The timeseries f(t) = t\n evaluate_timeseries(timeseries, window_size)\n\n print('\\nMultiple... | [
"0.60069335",
"0.5729496",
"0.57247895",
"0.56926006",
"0.5640804",
"0.55693763",
"0.5462862",
"0.545068",
"0.5437306",
"0.54234403",
"0.54046506",
"0.54024243",
"0.5400062",
"0.53954995",
"0.53901184",
"0.53728026",
"0.5367973",
"0.5359561",
"0.53073376",
"0.5297493",
"0.529... | 0.5413295 | 10 |
Variancenormalized delayed liner prediction Here is the specific WPE algorithm implementation. The input should be the reverberant timefrequency signal in a single frequency bin and the output will be the dereverberated signal in the corresponding frequency bin. | def __ndlp(self, xk):
cols = xk.shape[0] - self.d
xk_buf = xk[:,0:self.out_num]
xk = np.concatenate(
(np.zeros((self.p - 1, self.channels)), xk),
axis=0)
xk_tmp = xk[:,::-1].copy()
frames = stride_tricks.as_strided(
xk_tmp,
shape=(s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wvd(fx,nh=2**8-1,tstep=2**5,nfbins=2**10,df=1.0):\r\n \r\n if type(fx) is list:\r\n fx=np.array(fx)\r\n try:\r\n fn,fm=fx.shape\r\n if fm>fn:\r\n fm,fn=fx.shape\r\n except ValueError:\r\n fn=len(fx)\r\n fm=1\r\n if fm>1:\r\n fn=fn[0]\r\n ... | [
"0.58324814",
"0.5825792",
"0.57535493",
"0.5751042",
"0.57346576",
"0.57223755",
"0.56215954",
"0.5614654",
"0.5592262",
"0.5591481",
"0.5540872",
"0.5534909",
"0.55345464",
"0.5412012",
"0.54105526",
"0.5396924",
"0.539593",
"0.5393846",
"0.53916824",
"0.5389656",
"0.538042... | 0.0 | -1 |
Put items randomly on the map and check if it's possible | def put_items(self,*maplist):
self.position_x = random.randint(0, (len(maplist) - 1))
self.position_y = random.randint(1, (len(maplist[0]) - 2))
while maplist[self.position_y][self.position_x] == "x":
self.position_x = random.randint(0, (len(maplist) - 1))
self.position_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_sample_mapped_keys(self):\r\n\r\n # With num_coverage=1 only the keys will be sampled\r\n actual = sample_mapped_keys(self.test_map, 1)\r\n self.assertEqual(actual, {'1': ['1'], '2': ['2']})\r\n\r\n actual = sample_mapped_keys(self.test_map, 3)\r\n for key in actual.keys... | [
"0.6235295",
"0.6196126",
"0.61928105",
"0.6118452",
"0.60727566",
"0.6048035",
"0.6003166",
"0.5947445",
"0.5936345",
"0.59303933",
"0.58924127",
"0.586839",
"0.58570385",
"0.58383924",
"0.5817358",
"0.5806295",
"0.58048785",
"0.57672346",
"0.5725036",
"0.5725036",
"0.572503... | 0.6995374 | 0 |
return the current position of the item | def get_position(self):
position = (self.position_x * SPRITE_SIZE, self.position_y * SPRITE_SIZE)
return position | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getPos(self):\n return self.__current_pos",
"def get_pos(self):\r\n return self.pos",
"def _get_pos(self):\n return self._pos",
"def get_pos(self):\n return self.pos",
"def position(self):\n return self._position",
"def get_next_position(self):",
"def pos(self):\n ... | [
"0.7483784",
"0.7428687",
"0.7375483",
"0.7348983",
"0.73047084",
"0.7303938",
"0.7247497",
"0.7247497",
"0.7199979",
"0.715942",
"0.71504045",
"0.71359575",
"0.7133087",
"0.7122779",
"0.7103176",
"0.70612854",
"0.70489836",
"0.7041392",
"0.7037722",
"0.70246315",
"0.7022811"... | 0.0 | -1 |
Creates an AdvObject from the specified properties. | def __init__(self, name, description, location):
self._name=name
self._description=description
self._location = location | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *properties):\n self._properties = properties",
"def __init__(self, props):\n if props.has_key('tags'):\n for tag in props['tags']:\n self.tags.append(Tag(tag))\n del props['tags']\n\n if props.has_key('impress'):\n for imp i... | [
"0.5741443",
"0.54022276",
"0.5395443",
"0.5392113",
"0.53685415",
"0.5281179",
"0.52164215",
"0.5166432",
"0.5139286",
"0.51178515",
"0.51087105",
"0.5067166",
"0.5053501",
"0.49764574",
"0.4967905",
"0.49215397",
"0.49170443",
"0.49132085",
"0.49040744",
"0.49028632",
"0.48... | 0.0 | -1 |
Converts an AdvObject to a string. | def __str__(self):
return self._name+self._description | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_str(self, obj):\n if self.pretty:\n return pprint.pformat(obj)\n else:\n return str(obj)",
"def value_to_string(self, obj):\n value = self.value_from_object(obj)\n return value",
"def value_to_string(self, obj):\n value = self._get_val_from_obj(o... | [
"0.6920051",
"0.691676",
"0.68165755",
"0.68165755",
"0.68165755",
"0.6777115",
"0.6751077",
"0.6725503",
"0.6705754",
"0.6672747",
"0.6669665",
"0.6566048",
"0.6535063",
"0.65277386",
"0.6492304",
"0.6480443",
"0.6470456",
"0.6397102",
"0.6383064",
"0.6383064",
"0.63526213",... | 0.0 | -1 |
Returns the name of this object. | def getName(self):
return self._name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_name(self):\n\n\t\treturn self.__name",
"def get_object_name(self):\n return self.obj_name",
"def get_name(self):\n return self.__name",
"def get_name(self):\n return self.__name",
"def get_name(self):\n return self.__name",
"def get_name(self):\n\t\treturn self.__name... | [
"0.89701015",
"0.895701",
"0.89562804",
"0.89562804",
"0.89562804",
"0.89102674",
"0.8910035",
"0.8910035",
"0.8910035",
"0.8910035",
"0.8873486",
"0.8873486",
"0.8873486",
"0.8873486",
"0.8873486",
"0.8873486",
"0.8873486",
"0.8873486",
"0.8873486",
"0.8873486",
"0.886717",
... | 0.0 | -1 |
Returns the description of this object. | def getDescription(self):
return self._description | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_description(self):\r\n return self.__description",
"def get_description(self):\n return self.__description",
"def description(self) -> str:\n raise NotImplementedError",
"def description(self) -> str:\n raise NotImplementedError",
"def description(self) -> str:\n ... | [
"0.89162534",
"0.8913889",
"0.8760129",
"0.8760129",
"0.8760129",
"0.87569624",
"0.87569624",
"0.8748838",
"0.8726684",
"0.8726684",
"0.8726684",
"0.8726684",
"0.8726684",
"0.8726684",
"0.8726684",
"0.8726684",
"0.8683328",
"0.8674301",
"0.8674301",
"0.8674301",
"0.86682856",... | 0.0 | -1 |
Returns the initial location of this object. | def getInitialLocation(self):
return self._location | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_default_alt_loc(self):\n return self.default_alt_loc",
"def get_initial_point(self):\r\n return self._studio.get_initial_point()",
"def get_origin(self):\n return self.zero",
"def start_loc(self) -> str:\n return self._start_loc",
"def get_origin(self):\n return s... | [
"0.7558399",
"0.73375237",
"0.73054683",
"0.7235104",
"0.71608335",
"0.7137725",
"0.7113328",
"0.7026934",
"0.6992983",
"0.6913296",
"0.68974197",
"0.6893482",
"0.6890375",
"0.6888621",
"0.68663657",
"0.68411374",
"0.68411374",
"0.68146896",
"0.6788716",
"0.6781255",
"0.67809... | 0.8698698 | 0 |
Reads and returns the next object from the file. | def readObject(f):
name = f.readline().rstrip()
if name == "":
name = f.readline().rstrip()
if name == "":
return None
description = f.readline().rstrip()
location = f.readline().rstrip()
return AdvObject(name, description, location ) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_next_file(self):\n\n if self._file_ptr == len(self.files):\n raise pipeline.PipelineStopIteration\n\n # Collect garbage to remove any prior data objects\n gc.collect()\n\n # Fetch and remove the next item in the list\n file_ = self.files[self._file_ptr]\n ... | [
"0.72583795",
"0.7027254",
"0.68285656",
"0.67972666",
"0.67273176",
"0.6713927",
"0.6641655",
"0.65415096",
"0.64786977",
"0.6464034",
"0.64639145",
"0.64511824",
"0.6437354",
"0.64324224",
"0.6382865",
"0.625156",
"0.62444645",
"0.6218984",
"0.6084731",
"0.5925621",
"0.5919... | 0.650625 | 8 |
Draws a circle with the given center point and radius. | def drawCircle(t, x, y, radius):
t.up()
t.goto(x + radius, y)
t.setheading(90)
t.down()
for count in range(120):
t.left(3)
t.forward(2.0 * math.pi * radius / 120.0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def circle(self, center, radius, color=(255, 255, 255), width=0):\n center = self._transform(center)\n pygame.draw.circle(self.screen, color, center, radius, width)",
"def draw_circle(self, color, center, radius, width):\n _c = self.T.itrans(center)\n pg.draw.circle(self.screen, color... | [
"0.86338115",
"0.85009205",
"0.83613294",
"0.83170444",
"0.82574344",
"0.82180214",
"0.81991607",
"0.81948245",
"0.81408536",
"0.8098403",
"0.807575",
"0.7977794",
"0.7959704",
"0.79416144",
"0.78637886",
"0.77105397",
"0.77105397",
"0.7669779",
"0.7632818",
"0.76300377",
"0.... | 0.7293385 | 30 |
Allows the user to enter the center point and the radius. | def main():
x = int(input("Enter the x coordinate of the center point: "))
y = int(input("Enter the y coordinate of the center point: "))
radius = int(input("Enter the radius: "))
drawCircle(Turtle(), x, y, radius)
sleep(5) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, center=None, radius=1):\n if center is None:\n center = Point()\n self.center = center\n self.radius = radius",
"def __init__( self , center , radius ):\r\n self.center = center\r\n self.radius = radius",
"def objects_radius(self, centre, r... | [
"0.71296966",
"0.7125274",
"0.67846715",
"0.6770878",
"0.64596057",
"0.6245679",
"0.62237734",
"0.6174636",
"0.6130969",
"0.6080135",
"0.6042969",
"0.59949976",
"0.59806263",
"0.59674543",
"0.5946548",
"0.5903731",
"0.58795375",
"0.5849122",
"0.58323336",
"0.5830168",
"0.5830... | 0.64534515 | 5 |
Divide trees according to type of topology. | def main():
arg = parse_args()
print('Start.')
arg.folder = Path(arg.folder)
trees = list(arg.folder.glob('*'))
trees = [i.absolute() for i in trees]
info = parse_info(arg)
types = [arg.folder/i for i in info.keys()]
types_dict = dict(zip(info.keys(), types))
for i in types:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split(root, Dk, maxDepth, minRows, currDepth):\n \n left, right = root['branches']\n del(root['branches'])\n \n# if not left and not right:\n# return\n \n # Check if the node is a leaf\n if not len(left): \n root['left'] = root['right'] = getLeafClass(right)\n ... | [
"0.5453626",
"0.5452636",
"0.518309",
"0.5146686",
"0.5118012",
"0.51089513",
"0.51027083",
"0.5078505",
"0.5066417",
"0.5044864",
"0.5033552",
"0.50323814",
"0.50138044",
"0.5011849",
"0.49989843",
"0.49979243",
"0.49885964",
"0.49885964",
"0.49619004",
"0.493714",
"0.492690... | 0.48425135 | 32 |
Create an EasyOCR Reader. | def __init__(
self, lang_list: List[str], gpu: bool = True, model_storage_directory: str = None, download_enabled: bool = True
):
self._set_device(gpu)
self._set_model_lang(lang_list)
self._set_character_choices()
self._set_lang_char(lang_list) # self.lang_list doesn't seem... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_reader_instantiates(self):\n cr = CaseReader(self.filename)\n self.assertTrue(isinstance(cr, HDF5CaseReader), msg='CaseReader not'\n ' returning the correct subclass.')",
"def runOcr(input, output, verbose):\n pOcr = performOCR()\n pOcr.performOCR(input, output... | [
"0.5260699",
"0.50356466",
"0.50144494",
"0.4956128",
"0.49238893",
"0.49137166",
"0.4909198",
"0.4838459",
"0.48022503",
"0.47904193",
"0.47768283",
"0.47762477",
"0.47688955",
"0.47371775",
"0.47360316",
"0.47072673",
"0.46999484",
"0.4683058",
"0.46523178",
"0.46151334",
"... | 0.44355845 | 37 |
Reads the energy. returns energies found in the diracoutput files in filelist. | def readenergy(self, filelist):
energy=[]
tmpenergy=[]
for filename in filelist:
if not(os.path.exists(filename)):
if self._resultfile: self._resultfile.write('Output file: "'+filename+'" does not exist. Restart your calculation. \n')
else: print 'Output file: "'+filename+'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_energy(self, fname):\n outfile = open(fname)\n lines = outfile.readlines()\n outfile.close()\n\n energy = None\n for line in lines:\n if line.find('HEAT OF FORMATION') != -1:\n words = line.split()\n energy = float(words[5])\n ... | [
"0.7086508",
"0.708285",
"0.6795043",
"0.6768917",
"0.6695373",
"0.6663242",
"0.65436995",
"0.652793",
"0.6472127",
"0.6311504",
"0.6298959",
"0.6152937",
"0.61389047",
"0.61037445",
"0.60946065",
"0.59737444",
"0.5941638",
"0.5932472",
"0.5913029",
"0.5901953",
"0.58484244",... | 0.7640516 | 0 |
Makes a dictonary with how to read the output files. Returns nothing. For the easy to use character strings in keys the function reads the datafile. With this information a list of dictonaries is built and put into the variable _keydict. The useable names can be listed with the function keynames() | def set_keys(self, keys):
self._keydict=[]
self._keys=[]
# Connect userfriendly keywords to the characters that indicates the energy in Dirac.
for key in keys:
tmpdat=[]
infile=open(self._datafile, 'r')
if not infile:
if self._resultfile:
self._result... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def DataLoad(filename,path,keys_to_search=['dstr','ORT'],text_file = False):\n\n OUTPUT_DICT = {}\n\n if not text_file:\n\n rdr = EafReader(filename, path, text_file=False)\n\n for key in keys_to_search:\n\n annot, annot_df = rdr.parser(key)\n DF = rdr.dataframe_creator(an... | [
"0.6992537",
"0.63537943",
"0.63483447",
"0.63251376",
"0.6192821",
"0.60494673",
"0.6024493",
"0.59666574",
"0.59539443",
"0.5948677",
"0.5942385",
"0.59367585",
"0.59194607",
"0.59025496",
"0.5849234",
"0.5810317",
"0.5801417",
"0.5754932",
"0.5750282",
"0.573261",
"0.56992... | 0.69034344 | 1 |
Writes the names of the keys that could be used to STDOUT or to _resultfile. Returns nothing | def keynames(self):
infile=open(self._datafile, 'r')
if self._resultfile: self._resultfile.write("Keys in datafile: "+self._datafile+'\n')
else: print ("Keys in datafile: "+self._datafile+'\n')
for tmpc in infile:
for i in range(0, len(tmpc)):
if tmpc[i:i+1]=='#': break
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _write_keypoint_results(keypoint_results, gt_folder, pred_folder):",
"def export_file(self):\n if self.args.keyfilter:\n self.filter_keys()\n if self.args.datafilter:\n self.filter_values()\n json.dump(self.outputdata, self.outfile, indent=self.args.indent)\n ... | [
"0.672782",
"0.62190783",
"0.59323156",
"0.58724725",
"0.58682984",
"0.57954323",
"0.5761679",
"0.5730018",
"0.57159007",
"0.5712536",
"0.5676965",
"0.56695795",
"0.5650905",
"0.564897",
"0.5632195",
"0.56272215",
"0.560844",
"0.55824125",
"0.55570793",
"0.5553363",
"0.553443... | 0.6835899 | 0 |
Returns the keylist. Accessed through .keys | def get_keys(self):
return self._keys | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keys(self) -> List:\n pass",
"def get_key_list(self) -> list:\n return self.key_functs.keys()",
"def getkeys(self):\n return list(self.keys)",
"def keys(self):\r\n return [k for k in self]",
"def keys(self):\n return [ x for x in self ]",
"def keys(self):\n retur... | [
"0.86689055",
"0.8622244",
"0.85591614",
"0.83134896",
"0.8216067",
"0.82127815",
"0.82086694",
"0.8187642",
"0.81670517",
"0.81668127",
"0.81624645",
"0.8070637",
"0.8067892",
"0.8002373",
"0.7960686",
"0.7943611",
"0.7939778",
"0.79254633",
"0.79254633",
"0.79252243",
"0.79... | 0.8493084 | 3 |
Set the list of files to be read Accessed through .files. Returns nothing. | def setfiles(self, filelist):
self._filelist=filelist
self._energy=self.readenergy(filelist) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def change_files(self, files: list = None):\n if not is_empty_arr(files):\n self._files = files",
"def listFiles(self):\n pass",
"def fileset(self):\n pass",
"def update(self):\n if os.path.isdir(self.full_path):\n self.file_list = os.listdir(self.full_path)\... | [
"0.7024085",
"0.68313926",
"0.6823761",
"0.6700469",
"0.6691884",
"0.6609458",
"0.6593145",
"0.65463704",
"0.65022755",
"0.64708245",
"0.63540703",
"0.63521343",
"0.6350075",
"0.62795043",
"0.6271418",
"0.62625027",
"0.624582",
"0.6244804",
"0.6167253",
"0.61467445",
"0.61424... | 0.708177 | 0 |
Add files to the end of the filelist. Returns their read energies. | def addfiles(self, filelist):
for tmpc in filelist:
self._filelist.append(tmpc)
tmp_energy=self.readenergy(filelist)
for tmpdat in tmp_energy:
self._energy.append(tmpdat)
return tmp_energy | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insertfiles(self, pos, filelist):\r\n for i in range(0, len(filelist)):\r\n self._filelist.insert(pos+i, filelist[i])\r\n tmp_energy=self.readenergy(filelist)\r\n for i in range(0, len(tmp_energy)):\r\n self._energy.insert(pos+i, tmp_energy[i])\r\n return tmp_energy",
"def add_files(sel... | [
"0.6711196",
"0.6418432",
"0.62716985",
"0.6196659",
"0.6169911",
"0.6086327",
"0.59367085",
"0.58788455",
"0.58760184",
"0.57898587",
"0.5785641",
"0.57034767",
"0.57004327",
"0.5663165",
"0.56618965",
"0.5629544",
"0.56114274",
"0.56029123",
"0.55897784",
"0.55780524",
"0.5... | 0.8065469 | 0 |
Insert file at position pos in the file list. Returns it's energies/ | def insertfile(self, pos, file):
self._filelist.insert(pos, file)
tmp_energy=self.readenergy([file])
for i in range(0, len(tmp_energy)):
self._energy.insert(pos+i, tmp_energy[i])
return tmp_energy[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insertfiles(self, pos, filelist):\r\n for i in range(0, len(filelist)):\r\n self._filelist.insert(pos+i, filelist[i])\r\n tmp_energy=self.readenergy(filelist)\r\n for i in range(0, len(tmp_energy)):\r\n self._energy.insert(pos+i, tmp_energy[i])\r\n return tmp_energy",
"def addfiles(self... | [
"0.8262362",
"0.5946468",
"0.5841547",
"0.5443106",
"0.519077",
"0.5129954",
"0.5110636",
"0.50919867",
"0.5073317",
"0.5017984",
"0.49988976",
"0.49755192",
"0.49303234",
"0.49288973",
"0.49170265",
"0.48991424",
"0.4895956",
"0.48913643",
"0.48766756",
"0.48552522",
"0.4853... | 0.81386596 | 1 |
Insert a list of files at position pos in the file list. Returns their energies. | def insertfiles(self, pos, filelist):
for i in range(0, len(filelist)):
self._filelist.insert(pos+i, filelist[i])
tmp_energy=self.readenergy(filelist)
for i in range(0, len(tmp_energy)):
self._energy.insert(pos+i, tmp_energy[i])
return tmp_energy | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insertfile(self, pos, file):\r\n self._filelist.insert(pos, file)\r\n tmp_energy=self.readenergy([file])\r\n for i in range(0, len(tmp_energy)):\r\n self._energy.insert(pos+i, tmp_energy[i])\r\n return tmp_energy[0]",
"def addfiles(self, filelist):\r\n for tmpc in filelist:\r\n self.... | [
"0.7297772",
"0.62299746",
"0.54402405",
"0.5370709",
"0.53008914",
"0.5247944",
"0.52219343",
"0.51347685",
"0.5120666",
"0.50602365",
"0.50350565",
"0.4997518",
"0.49373466",
"0.48963982",
"0.4895969",
"0.48752096",
"0.48604277",
"0.48215386",
"0.48195642",
"0.47813186",
"0... | 0.8478526 | 0 |
Delete the named files in filelist from the _filelist. | def delfiles(self, filelist=[]):
for tmpc in filelist:
i=index(tmpc, self._filelist)
if i:
del self._filelist[i]
del self._energy[i]
else:
if self._resultfile:
self._resultfile.write('WARNING (parsedirac.py): File not a member of previously read files. Fil... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_files(file_list):\n###############################################################################\n for fpath in file_list:\n if os.path.exists(fpath):\n os.remove(fpath)\n # End if\n # End for",
"def remove_old_files(filelist):\n\n for filename in filelist:\n ... | [
"0.7808194",
"0.7382932",
"0.73729557",
"0.73168314",
"0.7110893",
"0.6884143",
"0.6740297",
"0.6702584",
"0.63560486",
"0.6355671",
"0.623873",
"0.6167311",
"0.6138595",
"0.6092599",
"0.60532045",
"0.603099",
"0.6018269",
"0.6012796",
"0.6004903",
"0.6002885",
"0.5966825",
... | 0.69262415 | 5 |
Delete all files between max and min from the _filelist. | def delfiles(self, max=0, min=0):
# Removes the files from min up to max
for i in range(max-1, min-1, -1):
if i<len(self._filelist):
del self._filelist[i]
if i<len(self._energy):
del self._energy[i] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_files(file_list):\n###############################################################################\n for fpath in file_list:\n if os.path.exists(fpath):\n os.remove(fpath)\n # End if\n # End for",
"def DeleteFiles(self, min_size=0):\n\n ndeleted = 0\n for f... | [
"0.6221175",
"0.6209422",
"0.60798913",
"0.6001565",
"0.59255946",
"0.5850927",
"0.5819805",
"0.58054554",
"0.579091",
"0.5698838",
"0.5651804",
"0.5651673",
"0.56408966",
"0.5640656",
"0.56275594",
"0.5618696",
"0.5604296",
"0.55829805",
"0.5527234",
"0.547274",
"0.546802",
... | 0.78210205 | 0 |
Returns the current _filelist. Accessed through .files | def get_files(self):
return self._filelist | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def listFiles(self):\n pass",
"def get_file_list(self):\n try:\n for filename in os.listdir(SHARED_DIR):\n self.file_list.append(filename)\n except Exception as e:\n print \"Error: retriving file list, %s\" % e",
"def __init__(self):\n self.filel... | [
"0.7358803",
"0.734229",
"0.71822",
"0.70319045",
"0.702763",
"0.70001733",
"0.69906056",
"0.69851583",
"0.68934256",
"0.68574464",
"0.6807691",
"0.6791865",
"0.67466885",
"0.6745575",
"0.66323113",
"0.6553671",
"0.65483415",
"0.6502841",
"0.64942795",
"0.6484744",
"0.6462570... | 0.8797185 | 0 |
Returns the current energies corresponding to the files in _filelist. Accessed through .energy | def get_energy(self):
return self._energy | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def readenergy(self, filelist):\r\n \r\n energy=[]\r\n tmpenergy=[]\r\n for filename in filelist:\r\n if not(os.path.exists(filename)):\r\n if self._resultfile: self._resultfile.write('Output file: \"'+filename+'\" does not exist. Restart your calculation. \\n')\r\n else: print 'Outp... | [
"0.726632",
"0.7143525",
"0.68418056",
"0.6825345",
"0.66456926",
"0.6384233",
"0.63572055",
"0.6276068",
"0.623991",
"0.6229059",
"0.6221391",
"0.61953986",
"0.61786455",
"0.6164679",
"0.6097344",
"0.609421",
"0.6084577",
"0.603048",
"0.6016905",
"0.5996694",
"0.59754694",
... | 0.6180556 | 12 |
Change the resultfile. Accessed through .resultfile | def set_resultfile(self, file):
self._resultfile=file | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_result(self, file_name):\n f = file(file_name, \"w\")\n f.write(self.m_result)\n f.close()",
"def set_result_file(self, file_name):\n if file_name is not None:\n self.opts[\"result_file_name\"] = file_name\n else:\n self.opts[\"result_file_name\"... | [
"0.72395635",
"0.70098424",
"0.6764218",
"0.66742396",
"0.6625944",
"0.6565123",
"0.6525431",
"0.64383346",
"0.63236547",
"0.6314388",
"0.62754613",
"0.62360525",
"0.61103517",
"0.61034817",
"0.59743166",
"0.5973691",
"0.59708005",
"0.5964662",
"0.592152",
"0.58801514",
"0.58... | 0.7958902 | 0 |
Return the current resultfile. Accessed through .resultfile | def get_resultfile(self):
return self._resultfile | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetResultFile(self):\n\n file_path = self.configfile.map['ResultFilePath']\n\n # Check if several entrie\n if file_path is not None:\n if len(file_path) > 1:\n warning(\n 'Many path for the result file are setted ({}), I will take the first one'... | [
"0.7389495",
"0.68382645",
"0.6615491",
"0.64539397",
"0.6348082",
"0.63120145",
"0.6282585",
"0.62605387",
"0.6229086",
"0.6192739",
"0.61694807",
"0.6115375",
"0.60991883",
"0.6087382",
"0.6084712",
"0.60831773",
"0.6068043",
"0.6031894",
"0.60297304",
"0.6025069",
"0.60184... | 0.88122743 | 0 |
This method returns a list with the names of all the files contained in the folder received by parameter. | def get_files(folder="", extension=""):
return sorted(glob.glob(folder + "*" + extension), reverse=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_files_in_given_folder(path_to_folder):\r\n file_names_list = []\r\n for file_name in glob.glob(path_to_folder+\"/*\"):\r\n file_names_list.append(file_name)\r\n assert file_names_list != [], \"failed to populate folder\"+path_to_folder\r\n return file_names_list",
"def get_files(folde... | [
"0.81181633",
"0.7643659",
"0.7529215",
"0.74416965",
"0.7414604",
"0.74022275",
"0.7395162",
"0.73642397",
"0.7356729",
"0.73449916",
"0.73329365",
"0.73275936",
"0.7327072",
"0.726896",
"0.7265691",
"0.72462016",
"0.72434044",
"0.7230354",
"0.7224685",
"0.72200924",
"0.7214... | 0.69553655 | 48 |
load class name from a file. id is the index, i.e. the line number. | def read_class_names(class_file_name):
names = {}
with open(class_file_name, 'r') as f:
for idx, name in enumerate(f):
names[idx] = name.strip('\n')
return names | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(self, file_id):\n pass",
"def load(cls, file_id):\n if not isinstance(file_id, file):\n handle = open(\n \"{:s}{:s}-{:d}.pckl\".format(\n DUMP_PATH,\n cls.__name__,\n file_id\n ),\n ... | [
"0.6877691",
"0.63064736",
"0.62377626",
"0.5860321",
"0.58437896",
"0.5836224",
"0.57929134",
"0.5779981",
"0.57380307",
"0.56598276",
"0.56458116",
"0.5641869",
"0.55397636",
"0.55302477",
"0.55169445",
"0.54928064",
"0.54847777",
"0.54553765",
"0.5414059",
"0.5370731",
"0.... | 0.0 | -1 |
Load the anchors from a file. | def get_anchors(anchors_path):
with open(anchors_path) as f:
anchors = f.readline()
anchors = np.array(anchors.split(','), dtype=np.float32)
return anchors.reshape(3, 3, 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_anchors_blocks(path):\t\t\n\t#TODO : automatization\n\tleft = Building_Block(abbrev=\"l\", num_atoms=2,origin=0, para_pos=0, para_angle=0, meta_pos=0 , meta_angle = 0., ortho_pos=0, ortho_angle=-2.*np.pi/3, fixed_left = 0,complexity=1, path=path+\"/anchor_small_left.xyz\")\n\tright = Building_Block(abbrev... | [
"0.6599627",
"0.6420055",
"0.60779434",
"0.6073252",
"0.6073252",
"0.5879717",
"0.58786225",
"0.5859779",
"0.5848837",
"0.58253086",
"0.58215725",
"0.5762048",
"0.5753838",
"0.565818",
"0.56508386",
"0.5645677",
"0.56223",
"0.56137466",
"0.56039727",
"0.55983424",
"0.5587017"... | 0.61724406 | 2 |
Ensures that the provided object path conforms to the DBus standard. Throws a L{error.MarshallingError} if nonconformant | def validateObjectPath(p):
if not p.startswith('/'):
raise MarshallingError('Object paths must begin with a "/"')
if len(p) > 1 and p[-1] == '/':
raise MarshallingError('Object paths may not end with "/"')
if '//' in p:
raise MarshallingError('"//" is not allowed in object paths"')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_pathlib_obj(self):\n \"\"\"\n We do this because pygame functions internally use pg_EncodeString\n to decode the filenames passed to them. So if we test that here, we\n can safely assume that all those functions do not have any issues\n with pathlib objects\n \"\"... | [
"0.54732823",
"0.5256893",
"0.5144109",
"0.4995298",
"0.49384198",
"0.4835352",
"0.478868",
"0.47768828",
"0.4728277",
"0.47244215",
"0.471736",
"0.47147894",
"0.46644646",
"0.4659947",
"0.465669",
"0.4590839",
"0.45773673",
"0.45689",
"0.45658988",
"0.45398143",
"0.4528572",... | 0.59882015 | 0 |
Verifies that the supplied name is a valid DBus Interface name. Throws an L{error.MarshallingError} if the format is invalid | def validateInterfaceName(n):
try:
if '.' not in n:
raise Exception('At least two components required')
if '..' in n:
raise Exception('".." not allowed in interface names')
if len(n) > 255:
raise Exception('Name exceeds maximum length of 255')
if n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validateBusName(n):\n try:\n if '.' not in n:\n raise Exception('At least two components required')\n if '..' in n:\n raise Exception('\"..\" not allowed in bus names')\n if len(n) > 255:\n raise Exception('Name exceeds maximum length of 255')\n i... | [
"0.6249034",
"0.6138677",
"0.5944746",
"0.5854724",
"0.5783322",
"0.5767728",
"0.5706411",
"0.5702007",
"0.5684922",
"0.5588679",
"0.55774987",
"0.5547274",
"0.5466605",
"0.5456653",
"0.544468",
"0.54201376",
"0.5366448",
"0.5361167",
"0.5352273",
"0.534587",
"0.5299094",
"... | 0.7287379 | 0 |
Verifies that the supplied name is a valid DBus Bus name. Throws an L{error.MarshallingError} if the format is invalid | def validateBusName(n):
try:
if '.' not in n:
raise Exception('At least two components required')
if '..' in n:
raise Exception('".." not allowed in bus names')
if len(n) > 255:
raise Exception('Name exceeds maximum length of 255')
if n[0] == '.':
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _verify_name(name):\n if isinstance(name, str):\n name = name.encode(\"utf-8\")\n\n if not isinstance(name, bytes):\n raise TypeError(\n \"Name {!r} is not a string or byte string\".format(name)\n )\n\n if b\".\" in name:\n raise V... | [
"0.6328239",
"0.60769504",
"0.6054338",
"0.6011703",
"0.5934793",
"0.5782472",
"0.57623523",
"0.574703",
"0.57247126",
"0.5692703",
"0.5543336",
"0.55390483",
"0.5524516",
"0.5497659",
"0.54381436",
"0.543146",
"0.539284",
"0.5378268",
"0.53725094",
"0.53675413",
"0.5350507",... | 0.7423474 | 0 |
Verifies that the supplied name is a valid DBus member name. Throws an L{error.MarshallingError} if the format is invalid | def validateMemberName(n):
try:
if len(n) < 1:
raise Exception('Name must be at least one byte in length')
if len(n) > 255:
raise Exception('Name exceeds maximum length of 255')
if n[0].isdigit():
raise Exception('Names may not begin with a digit')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isValidDataTypeName(name: unicode) -> bool:\n ...",
"def validateBusName(n):\n try:\n if '.' not in n:\n raise Exception('At least two components required')\n if '..' in n:\n raise Exception('\"..\" not allowed in bus names')\n if len(n) > 255:\n ... | [
"0.6429723",
"0.62362033",
"0.6177577",
"0.6054941",
"0.6011524",
"0.58804786",
"0.58333224",
"0.58264023",
"0.57906777",
"0.57682234",
"0.5758976",
"0.57252425",
"0.57006663",
"0.5695194",
"0.5691282",
"0.56714183",
"0.56466067",
"0.56451",
"0.564391",
"0.560903",
"0.5603861... | 0.77475756 | 0 |
Returns the DBus signature type for the argument. If the argument is an instance of one of the type wrapper classes, the exact type signature corresponding to the wrapper class will be used. If the object has a variable named 'dbusSignature', the value of that variable will be used. Otherwise, a generic type will be us... | def sigFromPy(pobj):
sig = getattr(pobj, 'dbusSignature', None)
if sig is not None:
return sig
elif isinstance(pobj, bool):
return 'b'
elif isinstance(pobj, int):
return 'i'
elif isinstance(pobj, int):
return 'x'
elif isinstance(pobj, float):
return 'd'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_type ( self, object ):\n return self.type",
"def get_type ( self, object ):\n return self.type",
"def type_signature(self) -> computation_types.Type:\n raise NotImplementedError",
"def serialize_to_signature(value):\n serialization_cls = _get_serializer_for_value(value, serializin... | [
"0.5474694",
"0.5474694",
"0.5409444",
"0.5328905",
"0.52887535",
"0.521691",
"0.51724213",
"0.5155565",
"0.51536465",
"0.51384646",
"0.50888366",
"0.50765437",
"0.5045696",
"0.49954993",
"0.49776474",
"0.49498105",
"0.49469578",
"0.49323153",
"0.49192646",
"0.4914251",
"0.49... | 0.629868 | 0 |
Generator function used to iterate over each complete, | def genCompleteTypes(compoundSig):
i = 0
end = len(compoundSig)
def find_end(idx, b, e):
depth = 1
while idx < end:
subc = compoundSig[idx]
if subc == b:
depth += 1
elif subc == e:
depth -= 1
if depth == 0:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def completion_processor(self):\n while True:\n _ = (yield)\n self.solve_completed = True",
"def iterator(self):\n yield",
"def __iter__(self):\n for x in self.seq: yield x",
"def __iter__(self):\n yield from self.gen",
"def __iter__():",
"def __iter__():... | [
"0.6746244",
"0.66019744",
"0.6573459",
"0.6568486",
"0.6484661",
"0.6484661",
"0.6484661",
"0.6484661",
"0.6419667",
"0.6364976",
"0.63338614",
"0.63023585",
"0.62807107",
"0.6278938",
"0.62711823",
"0.6243261",
"0.6229426",
"0.6216627",
"0.61497426",
"0.61286175",
"0.609107... | 0.0 | -1 |
Encodes the Python objects in variableList into the DBus wireformat matching the supplied compoundSignature. This function retuns a list of binary strings is rather than a single string to simplify the recursive marshalling algorithm. A single string may be easily obtained from the | def marshal(compoundSignature, variableList,
startByte=0, lendian=True, oobFDs=None):
chunks = []
bstart = startByte
if hasattr(variableList, 'dbusOrder'):
order = variableList.dbusOrder
variableList = [getattr(variableList, attr_name)
for attr_name in or... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def serialize_list(list_raw):\n list_serialized = []\n for value in list_raw:\n if isinstance(value, list):\n list_serialized.append(serialize_list(value))\n elif isinstance(value, dict):\n list_serialized.append(serialize_dict(value))\n else:\n list_seri... | [
"0.5918284",
"0.5918284",
"0.5766241",
"0.550993",
"0.54382807",
"0.5433743",
"0.53844094",
"0.5381437",
"0.53691435",
"0.5350298",
"0.52913684",
"0.52551824",
"0.5226429",
"0.5210715",
"0.52086335",
"0.51800555",
"0.51722974",
"0.51387507",
"0.512357",
"0.51076096",
"0.50836... | 0.7213802 | 0 |
Unmarshals DBus encoded data. | def unmarshal(compoundSignature, data, offset=0, lendian=True, oobFDs=None):
values = []
start_offset = offset
for ct in genCompleteTypes(compoundSignature):
tcode = ct[0]
offset += len(pad[tcode](offset))
nbytes, value = unmarshallers[tcode](ct, data, offset, lendian, oobFDs)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decode(data): #@NoSelf",
"def decode(data):\n raise NotImplementedError",
"def decode_raw(data):\n return RawWire().decode(data)",
"def deserialize(self, data):",
"def unmarshal(self):\n ...",
"def unpack_from(self, data, is_hexen): \n \n raise Exception('Undefined unp... | [
"0.6241722",
"0.61459947",
"0.6119787",
"0.5970028",
"0.59508336",
"0.5886634",
"0.5710169",
"0.57082635",
"0.5660874",
"0.56222504",
"0.56127256",
"0.5612168",
"0.5533577",
"0.5531806",
"0.5487332",
"0.5375555",
"0.5372124",
"0.53650254",
"0.53354865",
"0.52957386",
"0.52777... | 0.51850396 | 30 |
Yield successive nsized chunks from l. | def __chunks(l, n):
for i in range(0, len(l), n):
yield l[i:i + n] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _chunk(self, l, n):\n for i in range(0, len(l) + 1, n):\n yield l[i:i + n]",
"def chunks(self, l, n):\n for i in range(0, len(l), n):\n yield l[i:i + n]",
"def get_chunks(self, l, n):\r\n for i in range(0, len(l), n):\r\n yield l[i:i+n]",
"def chunks(... | [
"0.80379355",
"0.79237956",
"0.78840584",
"0.7876208",
"0.78144675",
"0.77643776",
"0.77544284",
"0.7743112",
"0.7730491",
"0.772761",
"0.7723601",
"0.7701434",
"0.768797",
"0.768797",
"0.7662925",
"0.765581",
"0.765473",
"0.765473",
"0.76447",
"0.76447",
"0.76447",
"0.7635... | 0.7922027 | 2 |
The method returns dictionary contains degree each vertex in graph. | def vertice_degree(self):
if(self.is_empty()):
raise ValueError("Graph is empty.")
else:
if(self.__directed):
degrees = {}
l = list(self.__graph_dict.values())
flatter = []
for x in l:
fo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_degrees_dictionary(edges):\n dd = {} # degrees dictionary for vertexes\n\n def append_vertex(vertex, edge_index):\n if vertex not in dd.keys():\n dd[vertex] = [1, edge_index]\n else:\n dd[vertex][0] += 1\n dd[vertex].append(edge_index)\n\n e = edges\... | [
"0.7764501",
"0.75081825",
"0.74249536",
"0.73860043",
"0.7194386",
"0.7127516",
"0.70553905",
"0.70345974",
"0.70215124",
"0.6976104",
"0.6976104",
"0.6976104",
"0.69607127",
"0.6951132",
"0.69395113",
"0.69182175",
"0.6895664",
"0.68444467",
"0.6802162",
"0.6783748",
"0.673... | 0.81927633 | 0 |
Visualization of the result. | def display_graph(self, color_of_vertex):
import matplotlib.pyplot
import networkx
G = networkx.Graph()
color_set = ['#FF0000', '#32CD32', '#FFD700', '#6B8E23', '#40E0D0', '#BA55D3', '#C0C0C0', '#A0522D', '#6A5ACD']
color_map = []
for k in self.__graph_dict.keys():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot(self):\n pass",
"def visualize(self):\n\n self.check_model()\n show(prepare(self.model, self.vectorized_data, self.vectorizer, mds='tsne'))",
"def show_plot(self):\n if self.result is None:\n print('目前無結果。')\n else:\n self.plot_output_result.set... | [
"0.7273451",
"0.7236823",
"0.7192504",
"0.7152819",
"0.71324956",
"0.7096867",
"0.7055198",
"0.70482737",
"0.694442",
"0.6910525",
"0.68705297",
"0.66824",
"0.66695374",
"0.6665365",
"0.66381747",
"0.6632695",
"0.662455",
"0.66179216",
"0.6610647",
"0.6606984",
"0.6605635",
... | 0.0 | -1 |
This function returns dictionary of vertices and their color, the function uses SL algorithm and greedily coloring. The Result visualization uses the networkx and matplotlib libraries. | def vertex_coloring(self, display = False):
stack = self.SL_algorithm()
color_of_vertex = self.greedily_coloring(stack)
if(display):
self.display_graph(color_of_vertex)
return color_of_vertex
else:
return color_of_vertex | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hash_colors(vertex):\n\n def calculate_colors(v):\n \"\"\"\n Calculate the color for name of the given vertex v.\n :param v: Name of vertex to be hashed.\n :return: Tuple of (hue, saturation, lightness) values.\n \"\"\"\n\n # Define constant color values\n li... | [
"0.62638813",
"0.6236624",
"0.6217388",
"0.61086094",
"0.60408974",
"0.6028744",
"0.601162",
"0.58705133",
"0.5859937",
"0.58007324",
"0.57782114",
"0.57776314",
"0.5769344",
"0.5746869",
"0.57331896",
"0.573234",
"0.57293206",
"0.57200795",
"0.5713795",
"0.5711248",
"0.56534... | 0.6867616 | 0 |
Removes tags from post title and adds them to a set. Any tags such as [FRESH], (feat. JBobby), etc. will be removed from the title and placed in a set (without surrounding punctuation). Titles are also lowercased and any dashes/extra white space are removed. | def filter_tags(title):
tags = set()
filtered_title = []
# separate tags from title
# assumes there are no erroneous parentheses/brackets
# ex. [FRESH] Lil Pump - Nice 2 Yeet ya [prod. by D4NNY]
# there may be issues if song name contains parentheses
tag = []
last_pun = None
add_to... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_title(self):\n # split into tokens by white space\n tokens = self.title.split(\" \")\n # remove punctuation from each token\n table = str.maketrans('', '', punctuation)\n tokens = [w.translate(table) for w in tokens] # type: List[Any]\n # remove remaining tokens... | [
"0.6937355",
"0.66450447",
"0.64621973",
"0.6377635",
"0.6275683",
"0.6235725",
"0.6164819",
"0.61293006",
"0.60720676",
"0.6012441",
"0.5995282",
"0.59429306",
"0.59248",
"0.5892935",
"0.5872065",
"0.58714795",
"0.58687013",
"0.58097196",
"0.5798257",
"0.5796392",
"0.5791276... | 0.7703674 | 0 |
Get the first Spotify track url from a given search. Extended description of function. | def extract_track_url(search):
if 'tracks' in search:
tracks = search['tracks']
if 'items' in tracks:
items = tracks['items']
# take the first url we can find
for item in items:
if 'external_urls' in item:
external_urls = item[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search_song(title, artist):\n\ttitle = quote(title, safe='')\n\tartist = quote(artist, safe='')\n\tbase_url = SPOTIFY_API_HOST + 'search/' + '?q=track:{0}+artist:{1}&type=track&limit=1'\n\turl = base_url.format(title, artist)\n\tresults = requests.get(url).json()\n\n\ttry:\n\t\tif results['tracks']['total'] ==... | [
"0.6630882",
"0.61365277",
"0.6100608",
"0.60191",
"0.59961325",
"0.5867838",
"0.58076715",
"0.5792723",
"0.5750998",
"0.568006",
"0.56769896",
"0.567169",
"0.5664377",
"0.560161",
"0.55912936",
"0.5582274",
"0.5577718",
"0.5554772",
"0.55373526",
"0.553512",
"0.5527581",
"... | 0.81856936 | 0 |
Main routine to execute to download, extract, reconstruct and plot COVID data | def Main_script(X_axis_inc = 1, Y_axis_inc = 7, Z_axis_inc = 12, Date_start = None, Date_end = None):
Timer_start = time.perf_counter()
print('Collecting data from Our World in Data')
COVID_data, Date_start_raw_data, Date_end_raw_data = Extract_data() # Download and extract raw COVID data
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download(self, verbose):\n # Download datasets\n if verbose:\n print(\"Retrieving datasets from Our World In Data https://github.com/owid/covid-19-data/\")\n # Vaccinations\n v_rec_cols = [\n \"date\", \"location\", \"iso_code\", \"total_vaccinations\", \"peopl... | [
"0.676124",
"0.66143477",
"0.6422769",
"0.6366506",
"0.63597494",
"0.63453686",
"0.63231117",
"0.6260672",
"0.6257344",
"0.62265724",
"0.6193278",
"0.6168252",
"0.6147743",
"0.6106444",
"0.6098195",
"0.6088481",
"0.6082504",
"0.6042868",
"0.60369",
"0.60305005",
"0.59734946",... | 0.64706695 | 2 |
Extracts and formats data in dictionnaries from Our World in Data CSV files | def Extract_data():
chdir(Datafiles_directory) # Empty the datafiles directory
File_list = listdir()
for File in File_list:
remove(File)
COVID_data_path = Datafiles_directory + '\\OWID COVID data %s.csv' % (date.today().isoformat()) # String with path of COVID data (wher... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_trick_ascii(csv_file):\n data_file = csv.DictReader(open(csv_file))\n single_run_data_dict = {'altitude' : [0.0],\n 'latitude' : [0.0],\n 'longitude' : [0.0]}\n # Your code here\n # ...\n # return the dict\n return single_run_data_di... | [
"0.65972245",
"0.65949285",
"0.657538",
"0.6556348",
"0.65216136",
"0.639683",
"0.6318729",
"0.62956554",
"0.62589234",
"0.62322074",
"0.61776733",
"0.61724085",
"0.615015",
"0.6124557",
"0.6119837",
"0.61124694",
"0.6111998",
"0.61089385",
"0.6104878",
"0.61042136",
"0.61000... | 0.6641062 | 0 |
Reconstructs missing chunks of data by linear interpolation | def Reconstruct_COVID_data(COVID_data):
COVID_data_reconstructed = {}
COVID_data_reconstructed['_Country'] = COVID_data['_Country']
Countries_list = list(COVID_data.keys())[1:]
for Country in Countries_list: # For each country...
COVID_data_single_country = list(COVID_data[Count... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fill_missing_data_points(data):\n return data.interpolate()",
"def pad(input_data):\n # source : https://stackoverflow.com/questions/6518811/interpolate-nan-values-in-a-numpy-array \n data = input_data.copy()\n bad_indexes = np.isnan(data)\n good_indexes = np.l... | [
"0.70413935",
"0.687088",
"0.66340077",
"0.6370503",
"0.6215303",
"0.61976016",
"0.61492",
"0.614894",
"0.6125289",
"0.6101999",
"0.60120773",
"0.5932861",
"0.58526456",
"0.5823751",
"0.5819537",
"0.57982516",
"0.57957566",
"0.57912254",
"0.5780939",
"0.5774986",
"0.5719053",... | 0.5555438 | 34 |
Exports the raw and reconstructed data in seperate files | def Export_in_files(COVID_data, COVID_data_reconstructed):
F_data_file = open(Datafiles_directory + '\\OWID COVID data %s formatted.csv' % (date.today().isoformat()), 'w')
FR_data_file = open(Datafiles_directory + '\\OWID COVID data %s formatted reconstructed.csv' % (date.today().isoformat()), 'w')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def export_file(self):\n if self.args.keyfilter:\n self.filter_keys()\n if self.args.datafilter:\n self.filter_values()\n json.dump(self.outputdata, self.outfile, indent=self.args.indent)\n self.outfile.write('\\n')",
"def write_data_files(self):\n # build our... | [
"0.6854881",
"0.65517116",
"0.64988494",
"0.6373401",
"0.6348319",
"0.633782",
"0.62861234",
"0.6257868",
"0.6209314",
"0.61787605",
"0.6174007",
"0.6167421",
"0.61625797",
"0.6160978",
"0.6130941",
"0.6127147",
"0.6127147",
"0.6126146",
"0.60960144",
"0.6093455",
"0.6092773"... | 0.66929203 | 1 |
Extract data from recontructed COVID data in order to only keep data that will be plotted | def Extract_data_for_plotting(COVID_data, X_Axis_inc, Y_Axis_inc, Z_Axis_inc, Date_start, Date_end, Keep_no_PR = True):
Date_start_obj = datetime.strptime(Date_start, '%Y-%m-%d') # Create a list of all the dates to extract
Date_end_obj = datetime.strptime(Date_end, '%Y-%m-%d')
Date_difference = (Date_end... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_data():\n raw_data = pd.read_csv(\"../../../resource/DataVisualization/vaccinations.csv\")\n raw_data = raw_data[[\"location\", \"date\", \"people_fully_vaccinated_per_hundred\"]]\n raw_data.date = pd.to_datetime(raw_data.date, format=\"%Y-%m-%d\")\n min_date = raw_data.date.min()\n raw_... | [
"0.57332987",
"0.55896175",
"0.5566017",
"0.5560256",
"0.5542593",
"0.5458466",
"0.5445852",
"0.5408674",
"0.5361703",
"0.53353846",
"0.5209567",
"0.5194203",
"0.5185767",
"0.5149763",
"0.5145616",
"0.5144321",
"0.51424706",
"0.5139271",
"0.512649",
"0.5118692",
"0.5095719",
... | 0.58592325 | 0 |
Tells which countries to annotate and which not to. Since the lists in parameters are sorted by descending order of positivity rate, the countries with higher positivity rates will be examined first and thus annotatd with more priority | def Annotations_frame(Points_to_display, Countries_displayed, Frame_limits):
X_list_frame, Y_list_frame = zip(*Points_to_display) # Transform tuples of (X, Y) into 2 distinct lists of X and Y coordinates
Frame_limits_log = list(map(np.log10, Frame_limits))
X_min_log, X_max_log, Y_min_log, Y_max_log... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def country_hint(self, value):\n return None",
"def SuggestGeoTargetConstants(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')",
"def annotate(self, op_list=None):\n... | [
"0.5223514",
"0.47812617",
"0.47808456",
"0.47056314",
"0.46838796",
"0.46759918",
"0.4672632",
"0.466754",
"0.4616049",
"0.46070912",
"0.46006083",
"0.45805907",
"0.4577782",
"0.45505515",
"0.45467195",
"0.45305893",
"0.45272925",
"0.45201805",
"0.45035627",
"0.44953334",
"0... | 0.48259857 | 1 |
Plots data entered in parameters | def Scatter_graph(COVID_data_scatter, Display_annotations_mask = False):
COVID_data_scatter_names = COVID_data_scatter.pop('0Date')['Country'] # Extract names of columns plotted
X_axis, Y_axis, Z_axis = [], [], [] # Separate the axes in COVID_data_scatter in order to find the minimum and maximum along e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_data(self):",
"def plot(self, *args, **kwargs):\n pass",
"def display_plot(self, parameter):\n values = list(self.dataframe[parameter])\n #Begining and ending date of the dataset\n beg = self.beg\n end = self.end\n #Settings of the plot\n if parameter =... | [
"0.7607247",
"0.74195784",
"0.7169947",
"0.71379995",
"0.70588946",
"0.68634605",
"0.68371975",
"0.678551",
"0.6773931",
"0.67145234",
"0.66850895",
"0.6678228",
"0.6637928",
"0.6627586",
"0.66084194",
"0.65903",
"0.6587534",
"0.65140045",
"0.6475009",
"0.64048374",
"0.640192... | 0.0 | -1 |
Add headers to both force latest IE rendering engine or Chrome Frame, and also to cache the rendered page for 10 minutes. | def add_header(r):
r.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
r.headers["Pragma"] = "no-cache"
r.headers["Expires"] = "0"
r.headers['Cache-Control'] = 'public, max-age=0'
return r | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_header(response):\n response.headers['X-UA-Compatible'] = 'IE=Edge,chrome=1'\n response.headers['Cache-Control'] = 'public, max-age=60'\n return response",
"def add_header(response):\n response.headers['X-UA-Compatible'] = 'IE=Edge,chrome=1'\n response.headers['Cache-Control'] = 'public, m... | [
"0.8221727",
"0.8220911",
"0.8220911",
"0.8220911",
"0.8220911",
"0.81940746",
"0.8161616",
"0.8161616",
"0.8161616",
"0.8161616",
"0.8161616",
"0.8161616",
"0.8161616",
"0.8161616",
"0.8161616",
"0.8161616",
"0.8161616",
"0.8161616",
"0.8161616",
"0.8161616",
"0.8161616",
... | 0.7126684 | 66 |
Selects the given stream ID for output. | def select(self, stream):
if stream not in self._selectedStreams:
self._selectedStreams.append(stream) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def select(self, stream):\n\n # TODO: Ensure section 10.2.4, so that while stream 1 is selected,\n # the only text printed to it is that of the player's commands and\n # keypresses (as read by read_char). Not sure where this logic\n # will ultimately go, however.\n\n self._selectedStream = stream",
... | [
"0.6556641",
"0.57983565",
"0.57682925",
"0.5695478",
"0.5601869",
"0.5586684",
"0.5173582",
"0.5119291",
"0.50920683",
"0.5044393",
"0.50269234",
"0.50198567",
"0.5000961",
"0.4981254",
"0.4974197",
"0.49709654",
"0.49602035",
"0.49532992",
"0.49346712",
"0.49329248",
"0.490... | 0.625652 | 1 |
Unselects the given stream ID for output. | def unselect(self, stream):
if stream in self._selectedStreams:
self._selectedStreams.remove(stream) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unsetId(self):\n return _libsbml.Output_unsetId(self)",
"def unsetId(self):\n return _libsbml.Port_unsetId(self)",
"def unsetId(self):\n return _libsbml.Input_unsetId(self)",
"def unsubscribe(id, userId):\n db = core.connect()\n theUser = db[userId]\n if id in theUser[\"stre... | [
"0.617944",
"0.5672837",
"0.55219626",
"0.54870343",
"0.5482912",
"0.5464178",
"0.53850687",
"0.5304198",
"0.52740335",
"0.5231818",
"0.52296126",
"0.5224535",
"0.51276076",
"0.51187307",
"0.50885695",
"0.5000303",
"0.5000303",
"0.49989292",
"0.49881366",
"0.49865478",
"0.497... | 0.71225864 | 0 |
Retrieves the given stream ID. | def get(self, stream):
return self._streams[stream] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_stream_id(self) -> str:\n return self.id",
"def get_stream_id(self) -> str:",
"def get(self, id_stream):\n\n session = current_app.session\n\n stream = session.query(StreamDao).filter(StreamDao.id == id_stream).first()\n\n if stream is None:\n return None, 204\n\n... | [
"0.7862512",
"0.7689381",
"0.72383416",
"0.6438061",
"0.632346",
"0.6052766",
"0.5950043",
"0.58918774",
"0.58647907",
"0.5814538",
"0.56721425",
"0.56676686",
"0.56534684",
"0.56308675",
"0.56229955",
"0.5555997",
"0.5555997",
"0.5523179",
"0.54925346",
"0.5450699",
"0.54480... | 0.69341683 | 3 |
Writes the given unicode string to all currently selected output streams. | def write(self, string):
# TODO: Implement section 7.1.2.2 of the Z-Machine Standards
# Document, so that while stream 3 is selected, no text is
# sent to any other output streams which are selected. (However,
# they remain selected.).
# TODO: Implement section 7.1.2.2.1, so that newlines are writ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write(self, ucs, encoding='ascii'):\n self.lock.acquire()\n self.oqueue.send(('output', (ucs, encoding)))\n self.lock.release()",
"def write(self, string):\n\n if not self.enabled:\n return\n\n try:\n print(string, end=\"\", file=self.fp)\n exce... | [
"0.6019549",
"0.58811754",
"0.5840764",
"0.58179307",
"0.56729674",
"0.55562913",
"0.54668236",
"0.546056",
"0.54414606",
"0.5426918",
"0.5381758",
"0.53490806",
"0.53453517",
"0.5334099",
"0.52888536",
"0.5281868",
"0.52776235",
"0.5273485",
"0.5263722",
"0.52095383",
"0.520... | 0.67882425 | 0 |
Selects the given stream ID as the currently active input stream. | def select(self, stream):
# TODO: Ensure section 10.2.4, so that while stream 1 is selected,
# the only text printed to it is that of the player's commands and
# keypresses (as read by read_char). Not sure where this logic
# will ultimately go, however.
self._selectedStream = stream | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def select(self, stream):\n\n if stream not in self._selectedStreams:\n self._selectedStreams.append(stream)",
"def getSelected(self):\n\n return self._streams[self._selectedStream]",
"def select_stream(self, index=None, name=None, raw_name=None, update=True):\r\n stream = None\r\n try... | [
"0.7090956",
"0.63077545",
"0.5944891",
"0.56851655",
"0.5507112",
"0.5483096",
"0.53433263",
"0.53100574",
"0.52421796",
"0.52342975",
"0.5193063",
"0.517651",
"0.5166759",
"0.5165178",
"0.51437676",
"0.5016381",
"0.50112075",
"0.4981479",
"0.49758804",
"0.49596596",
"0.4958... | 0.7003565 | 1 |
Returns the input stream object for the currently active input stream. | def getSelected(self):
return self._streams[self._selectedStream] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_stream(self):\n self.lock.acquire()\n stream=self.stream\n self.lock.release()\n return stream",
"def set_input(self, in_stream):\n self._in = self._wrap_stream(in_stream, 'in')\n return self._in",
"def stream(self) -> interface.Stream:\n return cast(int... | [
"0.6819047",
"0.67934316",
"0.6680337",
"0.6518098",
"0.6492424",
"0.6492424",
"0.6459986",
"0.64151335",
"0.63618785",
"0.6321766",
"0.6298022",
"0.62467617",
"0.60943204",
"0.60503983",
"0.6026703",
"0.5984099",
"0.59127194",
"0.5908785",
"0.5908785",
"0.5908785",
"0.590878... | 0.5414463 | 50 |
Calculate the great circle distance between two points on the earth (specified in decimal degrees) | def haversine(lat1, lon1, lat2, lon2):
# convert decimal degrees to radians
lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])
# haversine formula
dlon = lon2 - lon1
dlat = lat2 - lat1
a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
c = 2 * asin(sqrt(a))
r ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def great_circle(lat_1, long_1, lat_2, long_2):\n long_1 = m.radians(long_1)\n lat_1 = m.radians(lat_1)\n long_2 = m.radians(long_2)\n lat_2 = m.radians(lat_2)\n\n d = 2 * 6367.45 * m.asin(\n m.sqrt(haversine(lat_2 - lat_1)\n + m.cos(lat_1)*m.cos(lat_2) *\n haversine(long... | [
"0.8146062",
"0.78638023",
"0.7632202",
"0.7604661",
"0.7595527",
"0.75950956",
"0.7592873",
"0.757031",
"0.7564319",
"0.75560796",
"0.75300086",
"0.7516366",
"0.7493803",
"0.746558",
"0.7450864",
"0.7432722",
"0.7391925",
"0.7355981",
"0.7347892",
"0.7330029",
"0.73271745",
... | 0.0 | -1 |
Converts all occurrences of Complexes (resp. sub trees named agent) with its vector representation. These are directly replaced within the tree expression. Moreover, in the process parameters are replaces with their values (if given). | def vectorize(self, ordering: SortedList, definitions: dict) -> list:
vec = Vectorizer(ordering, definitions)
self.expression = vec.transform(self.expression)
return vec.visited | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def express(expr, system, system2=None, variables=False):\n\n if expr in (0, Vector.zero):\n return expr\n\n if not isinstance(system, CoordSys3D):\n raise TypeError(\"system should be a CoordSys3D \\\n instance\")\n\n if isinstance(expr, Vector):\n if system2 i... | [
"0.5212036",
"0.52045906",
"0.51515454",
"0.5148588",
"0.51139396",
"0.50830597",
"0.50787544",
"0.5040814",
"0.50208473",
"0.50208473",
"0.50208473",
"0.50208473",
"0.50208473",
"0.50208473",
"0.50208473",
"0.4996494",
"0.4929204",
"0.48569438",
"0.4855723",
"0.48394084",
"0... | 0.52657586 | 0 |
Evaluates all occurrences of States to a float using Evaluater. It is done as intersection of particular state with given state and sum of resulting elements. If the result is nan, None is returned instead. | def evaluate(self, state) -> float:
evaluater = Evaluater(state)
result = evaluater.transform(self.expression)
try:
value = sympy.sympify("".join(tree_to_string(result)), locals=evaluater.locals)
if value == sympy.nan:
return None
return value... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate(self, state):\n\n fitness = np.sum(state)\n self.num_evals += 1\n #print(self.num_evals)\n return fitness",
"def evaluate(self, state):\n\n if self.is_coords and len(state) != len(self.coords):\n raise Exception(\"\"\"state must have the same length as c... | [
"0.63039607",
"0.6107048",
"0.6043089",
"0.59678954",
"0.59345084",
"0.59076506",
"0.5898974",
"0.5843427",
"0.5723326",
"0.5705815",
"0.5685411",
"0.5680647",
"0.5665845",
"0.56275225",
"0.55861384",
"0.5577219",
"0.5554043",
"0.554357",
"0.55327356",
"0.55058116",
"0.550581... | 0.670078 | 0 |
Translates rate from vector representation to symbolic one as a sum of particular components. e.g. [1, 0, 1] > (x_0 + x_2) | def to_symbolic(self):
transformer = SymbolicAgents()
self.expression = transformer.transform(self.expression) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ExpU(x):\n\treturn sum(x * lambdas)",
"def relative_rate(self):\n return _add_vector_swig.add_vector_2_cpp_sptr_relative_rate(self)",
"def _eval(self, v):\n if v.dtype == np.complex64 or v.dtype == np.complex128:\n return ne.evaluate('sum(real(v * conj(v)))')\n else:\n ... | [
"0.58277977",
"0.5783349",
"0.57700616",
"0.57329583",
"0.56626755",
"0.5629675",
"0.5581536",
"0.55512124",
"0.54802674",
"0.5467065",
"0.5376773",
"0.5362954",
"0.5352122",
"0.53469217",
"0.5333205",
"0.53328913",
"0.5313943",
"0.5284388",
"0.52732974",
"0.52684164",
"0.526... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.