content stringlengths 42 6.51k |
|---|
def count_dict_dups(dictionary):
"""dict -> int
Returns a set of the integers that have duplicates.
>>>count_dict_dups({'red': 1, 'blue': 2, 'green': 1, 'orange': 1})
1
>>>count_dict_dups({'a': 2, 'b': 2, 'c': 4, 'd': 4})
2
"""
seen_values = set()
duplicates = set()
for i in d... |
def Re(F_mass, z_way, d_inner, n_pipe, mu_mix):
"""
Calculates the Reynold criterion.
Parameters
----------
F_mass : float
The mass flow rate of feed [kg/s]
z_way : float
The number of ways in heat exchanger [dimensionless]
d_inner : float
The diametr of inner pipe, [... |
def build_project(project_name):
"""Builds eclipse project file.
Uses a very simple template to generate an eclipse .project file
with a configurable project name.
Args:
project_name: Name of the eclipse project. When importing the project
into an eclipse workspace, this is the nam... |
def indent(string, prefix=" "):
"""Indent a paragraph of text"""
return "\n".join([prefix + line for line in string.split("\n")]) |
def build_aggregation(facet_name, facet_options, min_doc_count=0):
"""Specify an elasticsearch aggregation from schema facet configuration.
"""
exclude = []
if facet_name == 'type':
field = 'embedded.@type'
exclude = ['Item']
elif facet_name.startswith('audit'):
field = facet... |
def map_list_to_kwargs(file_names: list, mapping: dict):
"""
Maps a list of files to their corresponding *mrconvert* inputs kwargs.
Parameters
----------
file_names : list
A list of existing files.
Returns
-------
Tuple[str, str, str, str]
Four sorted outputs: *in_file*... |
def translate(c):
""" Turn upper case characters into a visible character, lower case into invisible. Maintain newlines """
if c == '\n':
return c
return 'X' if c.isupper() else ' ' |
def f1_acc(FN, TN, TP, FP):
"""
Returns:
0.5 * f1measure + 0.5 * accuracy
"""
acc = 1.0 * (TP + TN) / (TP + TN + FP + FN)
P = 0
if TP > 0:
P = 1.0 * TP / (TP + FP)
R = 0
if TP > 0:
R = 1.0 * TP / (TP + FN)
f1 = 0
if P > 0 and R > 0:
f1 = 2.0 * P * R ... |
def calc_ios(bbox_1, bbox_2):
"""Calculate intersection over small ratio
This is a variant of more commonly used IoU (intersection over union) metric
All coordinates are in the order of (ymin, xmin, ymax, xmax)
Args:
bbox_1:
bbox_2:
Returns:
"""
def cal_area(bbox):
... |
def calc_delta_shift(H, N, Href, Nref, f=5):
"""Find combined chem shift"""
import math
delta_shift = math.sqrt( math.pow(f*(H - Href),2) + math.pow(N - Nref, 2) )
return delta_shift |
def _str_to_list(s):
"""Converts a comma separated string to a list"""
_list = s.split(",")
return list(map(lambda i: i.lstrip(), _list)) |
def month(num):
"""
asks for user's birth month and checks if it is a master or not.
If not convert the input to digits and return the sum of the digits.
"""
# Tests for inputs greater than or equal 13, since no months exists above 12
if int(num) > 12:
print("Error! Enter the month numbe... |
def contig_lengths(contigs):
"""Return number of contigs greater than 'X'."""
return {
'1k': sum(i > 1000 for i in contigs),
'10k': sum(i > 10000 for i in contigs),
'100k': sum(i > 100000 for i in contigs),
'1m': sum(i > 1000000 for i in contigs)
} |
def _get_early_stopping_params(early_stopping):
"""Set default parameters if not already set in input.
"""
if early_stopping is not None:
if early_stopping['type'] == 'cost':
if 'threshold' not in early_stopping:
early_stopping['threshold'] = 0.005
if 'length_... |
def meters_to_feet(n):
"""
Convert a length from meters to feet.
"""
return float(n) * 3.28084 |
def define_orderers(orderer_names, orderer_hosts, domain=None):
"""Define orderers as connection objects.
Args:
orderer_names (Iterable): List of orderer names.
orderer_hosts (Iterable): List of orderer hosts.
domain (str): Domain used. Defaults to none.
Returns... |
def get_clusterID(filename):
"""given a file name return the cluster id"""
return filename.split(".")[0] |
def split_multiline(value):
"""Split a multiline string into a list, excluding blank lines."""
return [element for element in (line.strip() for line in value.split('\n'))
if element] |
def user_name_to_file_name(user_name):
"""
Provides a standard way of going from a user_name to something that will
be unique (should be ...) for files
NOTE: NO extensions are added
See Also:
utils.get_save_root
"""
#Create a valid save name from the user_name (email)
#---... |
def best_calc_method(in_dict, maximum):
""" Calculates the number of time steps supply is
under demand
Parameters
----------
in_dict: keys => calc methods, values => results from
tests of each calc method (chi2 goodness of fit etc)
max: true/false boolean, true => find max of in_dict,
fa... |
def as_segments(polyline):
"""Returns for a polyline a list of segments (start/end point"""
segments = []
l = len(polyline)
for i in range(l - 1):
j = i + 1
segments.append((polyline[i], polyline[j]))
return segments |
def scan_critical(fname):
""" Find critical path and Fmax from VPR log (if any).
Returns
-------
critical_path : str
Critical path delay in nsec
fmax : str
Fmax in MHz.
"""
try:
with open(fname, 'r') as f:
final_cpd = 0.0
final_fmax = 0.0
... |
def get_channel_from_filename(data_filename):
"""
Args:
data_filename (str)
Returns:
int
"""
channel_str = data_filename.lstrip('channel_').rstrip('.dat')
return int(channel_str) |
def AnimateNameCheck(animate_name):
"""
make sure the file name is valid
"""
if animate_name.find(r"/")>=0:
animate_name = animate_name.replace(r"/","")
if animate_name.find(r":")>=0:
animate_name = animate_name.replace(r":","")
if animate_name.find(r"?")>=0:
animate_name... |
def methodArgs(item):
"""Returns a dictionary formatted as a string given the arguments in item.
Args:
item: dictionary containing key 'args' mapping to a list of strings
Returns:
dictionary formatted as a string, suitable for printing as a value
"""
args = ["'%s': %s" % (arg, arg)... |
def _append_to_final_data(final_data: dict, raw_data: dict, sample: dict):
"""Parsing raw data. Appending to final_data"""
for key, val in raw_data.items():
if key in final_data.keys():
category = f"{sample['category']}_{'_'.join(sample['workflows'])}"
if category not in final_d... |
def _build_selector(selectors, separator):
"""
Build a selector defined by the selector and separator
:param selectors: a list of strings that are selector
:param separator: the char that separates the different selectors
:return: the resulting selector
"""
selector = ""
for i, sel in en... |
def indent_block(s, amt=1):
"""
Intend the lines of a string.
:param s: The string
:param amt: The amount, how deep the string block should be intended (default 1)
:return: The indented string
"""
indent_string = " "
res = s
for i in range(0, amt):
res = indent_string + ind... |
def normalize(vector):
""" Takes a vector and reduces each entry to 1, -1, or 0.
Returns a tuple"""
return tuple([1 if ele > 0 else -1 if ele < 0 else 0 for ele in vector]) |
def bounds_overlap(*bounds):
"""
"""
# get same element across each array
min_x_vals, min_y_vals, max_x_vals, max_y_vals = zip(*bounds)
overlaps = max(min_x_vals) < min(max_x_vals) and max(min_y_vals) < min(max_y_vals)
return overlaps |
def is_list_empty(in_list):
""" Code from stack overflow: https://stackoverflow.com/a/1605679"""
if isinstance(in_list, list):
return all(map(is_list_empty, in_list))
return False |
def key_by_path_dict(in_dict, path):
""" Path-based dictionary lookup.
Args:
in_dict (dict): Input dict.
path (str): Full path to the key (key.subkey1.subkey2).
Returns:
Value for key at ``path`` if found in ``in_dict``.
>>> key_by_path_dict(
..... |
def reformat_seq(res_list):
"""Joins list of characters and removes gaps e.g. ['T', 'V', '-', 'Y'] -> 'TVY'"""
return ''.join(res_list).replace('-', '') |
def _py_single_source_complete_paths(source, N, paths):
"""
From the dict of node parent paths, recursively return the complete path from the source to all targets
Args:
source (int/string): the source node.
N (dict): the set of nodes in the network.
paths (dict): a dict of nodes and their distance to the pa... |
def XlaLaunchOpCount(labels):
"""Count how many XlaLaunch labels are present."""
return sum("XlaLaunch(" in x for x in labels) |
def index_map(array):
"""Given an array, returns a dictionary that allows quick access to the
indices at which a given value occurs.
Example usage:
>>> by_index = index_map([3, 5, 5, 7, 3])
>>> by_index[3]
[0, 4]
>>> by_index[5]
[1, 2]
>>> by_index[7]
[3]
"""
d = {}
... |
def cell_background_test(val,max):
"""Creates the CSS code for a cell with a certain value to create a heatmap effect
Args:
val ([int]): the value of the cell
Returns:
[string]: the css code for the cell
"""
opacity = 0
try:
v = abs(val)
color = '193, 57, 43'
... |
def move_vowels(x):
"""Removes vowels from single word. Places them at end of new word."""
vowel_str = 'aeiou'
con_string = ''
vowel_string = ''
for item in x:
if vowel_str.find(item) >= 0:
vowel_string = vowel_string + item
else:
con_string = con_string + it... |
def fixed_XOR(hex_bytes1: bytes, hex_bytes2: bytes) -> bytes:
""" Compute the XOR combination of hex_bytes1 and hex_bytes2, two
equal-length buffers.
"""
if len(hex_bytes1) != len(hex_bytes2):
raise ValueError("The two buffers need to be of equal-length")
return bytes(x ^ y for (x, y... |
def property_names(cls):
"""Get the properties of a class.
Parameters
----------
cls : type
An arbitrary class.
Returns
-------
List[str]
A list of the properties defined by the input class.
"""
return [name for name in dir(cls) if isinstance(getattr(cls, name), pro... |
def square_area(side):
"""Returns the area of a square"""
side = float(side)
if (side < 0.0):
raise ValueError('Negative numbers are not allowed')
return side**2.0 |
def is_string(arg):
"""
purpose:
check is the arg is a string
arguments:
arg: varies
return value: Boolean
"""
if arg is None:
return False
try:
str(arg)
return True
except Exception:
return False |
def normalize_bcast_dims(*shapes):
"""
Normalize the lengths of the input shapes to have the same length.
The shapes are padded at the front by 1 to make the lengths equal.
"""
maxlens = max([len(shape) for shape in shapes])
res = [[1] * (maxlens - len(shape)) + list(shape) for shape in shapes]
... |
def bubble_sort(alist):
"""Implement a bubble sort."""
potato = True
while potato:
potato = False
for idx in range(len(alist) - 1):
if alist[idx] > alist[idx + 1]:
temp = alist[idx]
alist[idx] = alist[idx + 1]
alist[idx + 1] = temp
... |
def find_name(function):
"""
Given a function string in the proper format, traces out the name of the
function.
>>> find_name("f(a,b,c) = a+b+c")
'f'
>>> find_name("apple(a,e,g) = ~a")
'apple'
"""
rv = ""
for c in function:
if c != "(":
rv += c
else:... |
def count_syllables_in_word(word):
""" This function takes a word in the form of a string
and return the number of syllables. Note this function is
a heuristic and may not be 100% accurate.
"""
count = 0
endings = '.,;!?:-'
last_chair = word[-1]
if last_chair in endings:
... |
def create_magic_packet(macaddress):
"""
Create a magic packet.
A magic packet is a packet that can be used with the for wake on lan
protocol to wake up a computer. The packet is constructed from the
mac address given as a parameter.
Args:
macaddress (str): the mac address tha... |
def wrap_text(new_text, width, f, old_text = [], start_new_line = False, return_height = False, line_height = None):
"""
Break a string into lines on a screen.
Parameters:
new_text: words to convert to lines; if list or tuple, each element is
a list of words from a paragraph, with l... |
def get_task_parameter(task_parameters, name):
"""Get task parameter.
Args:
task_parameters (list): task parameters.
name (str): parameter name.
Returns:
Task parameter
"""
for param in task_parameters:
param_name = param.get('name')
if param_name == name:
... |
def try_to_access_dict(base_dct, *keys, **kwargs):
"""
A helper method that accesses base_dct using keys, one-by-one. Returns None if a key does not exist.
:param base_dct: dict, a dictionary
:param keys: str, int, or other valid dict keys
:param kwargs: can specify default using kwarg default_retu... |
def class_if_errors(error_list, classname):
"""
siplet tool to check if
>>> class_if_errors([{},{}],"class")
""
>>> class_if_errors([{1:1},{}],"class")
"class"
"""
for el in error_list:
if el != {}:
return classname
return "" |
def is_sequence(numberlist: list) -> bool:
"""Is sequence
Can take a list returned by :meth:`get_numbers` and determine if
it is a sequence based on the property
``list_length == (last_element - first_element + 1)``.
Args:
numberlist: List containing integers to check for a sequence.
... |
def merge_fields(base, attach={}):
"""
>>> merge_fields({'a': 1})
{'a': 1}
>>> merge_fields({'a': 1}, {'b': 2})
{'a': 1, 'b': 2}
"""
base.update(attach)
return base |
def valToIndexMap(arr):
"""
A map from a value to the index at which it occurs
"""
return dict((x[1], x[0]) for x in enumerate(arr)) |
def describe_humidity(humidity):
"""Convert relative humidity into good/bad description."""
if 40 < humidity < 60:
description = "good"
else:
description = "bad"
return description |
def get(name):
"""
Returns a selection by name, this can be a function or a class name, in cases of a class name then an instance of that class will be returned.
Parameters
-----------
name: str
The name of the function or class.
Returns
--------
out: function or instan... |
def public_url(method: str) -> str:
"""Return the private URL for a given method."""
return f"public/{method}" |
def adj(a):
"""
Calculates the adjugate of A via just swapping the values.
The formula is [[a,b],[c,d]] => [[d,-b],[-c,a]]
:param a: the matrix A(2x2)
:return:
"""
B=[[0,0],[0,0]]
B[0][0]=a[1][1]
B[0][1]=-a[0][1]
B[1][0]=-a[1][0]
B[1][1]=a[0][0]
return B |
def gen_comment_id(reddit_obj_id):
"""
Generates the Elasticsearch document id for a comment
Args:
reddit_obj_id (int|str): The id of a reddit object as reported by PRAW
Returns:
str: The Elasticsearch document id for this object
"""
return "c_{}".format(reddit_obj_id) |
def numel_from_size(size):
"""Multiplies all the dimensions in a torch.Size object."""
s = 1
for i in size:
s *= i
return s |
def _istradiationalfloat(value):
"""
Checks if the string can be converted to a floating point value
Does not allow for fortran style floats, i.e -2.34321-308
only standard floats.
"""
try:
float(value)
return True
except ValueError:
return False |
def top_files(query, files, idfs, n):
"""
Given a `query` (a set of words), `files` (a dictionary mapping names of
files to a list of their words), and `idfs` (a dictionary mapping words
to their IDF values), return a list of the filenames of the the `n` top
files that match the query, ranked accord... |
def lines_coincide(begin1, end1, begin2, end2):
""" Returns true if the line segments intersect. """
A1 = end1[1] - begin1[1]
B1 = -end1[0] + begin1[0]
C1 = - (begin1[1] * B1 + begin1[0] * A1)
A2 = end2[1] - begin2[1]
B2 = -end2[0] + begin2[0]
C2 = - (begin2[1] * B2 + begin2[0] * A2)
if ... |
def is_cspm_view(view):
""" True if the view has a cspm file loaded"""
if view is None or view.file_name() is None:
return False
return 'cspm' in view.settings().get('syntax').lower() |
def fetch_base_path(dir_path: str) -> str:
"""Module to fetch base path of a given path.
Parameters
----------
dir_path*: string variable representing the actual path variable (absolute/relative)
(* - Required parameters)
Returns
-------
base path as string
"""
# Re... |
def bisect(f, target, interval, args=()):
"""Finds target intersection with f within an interval using the bisect method"""
iterations = 0
low, high = interval
while low <= high:
iterations += 1
mid = low + (high-low)//2
f_mid = f(mid, *args)
if f_mid == target:
... |
def cat(input_files, output_file):
"""Just concatenates files with the ``cat`` command"""
return {
"name": "cat: "+output_file,
"actions": ["cat %s > %s" %(" ".join(input_files), output_file)],
"file_dep": input_files,
"targets": [output_file]
} |
def _select_cols(a_dict, keys):
"""Filters out entries in a dictionary that have a key which is not part of 'keys' argument. `a_dict` is not
modified and a new dictionary is returned."""
if keys == list(a_dict.keys()):
return a_dict
else:
return {field_name: a_dict[field_name] for field_... |
def get_picard_max_records_string(max_records: str) -> str:
"""Get the max records string for Picard.
Create the 'MAX_RECORDS_IN_RAM' parameter using `max_records`. If
`max_records` is empty, an empty string is returned.
"""
if max_records is None or max_records == "":
return ""
else:
... |
def split_schema_obj(obj, sch=None):
"""Return a (schema, object) tuple given a possibly schema-qualified name
:param obj: object name or schema.object
:param sch: schema name (defaults to 'public')
:return: tuple
"""
qualsch = sch
if sch == None:
qualsch = 'public'
if '.' in ob... |
def getMinUnvisited(unvisited, dist):
"""
return the minimum distance vertex from
the set of vertices not yet processed.
Parameters:
unvisited (set): the set containing all the vertex not yet processed
dist (dict): a dictionary with vertex as ... |
def _ge_from_lt(self, other):
"""Return a >= b. Computed by @total_ordering from (not a < b)."""
op_result = self.__lt__(other)
if op_result is NotImplemented:
return NotImplemented
return not op_result |
def isBoolean(s):
""" Checks to see if this is a JSON bool """
if (s == 'true') or (s == 'false'):
return True
else:
return False |
def twoNumberSum_s1(array, targetSum):
"""
Time Complexity : O(n^2)
Space Complexity : O(1)
When going with the approch of having two for loops, the confusing part is what are th conditions
for the loop.
The trick lies here, vola !
Two arrays, its obvious from the above Rule that ... |
def _FindFeaturesOverriddenByArgs(args):
"""Returns a list of the features enabled or disabled by the flags in args."""
overridden_features = []
for arg in args:
if (arg.startswith('--enable-features=')
or arg.startswith('--disable-features=')):
_, _, arg_val = arg.partition('=')
overridde... |
def WHo_mt(dist, sigma):
"""
Speed Accuracy model for generating finger movement time.
:param dist: euclidian distance between points.
:param sigma: speed-accuracy trade-off variance.
:return: mt: movement time.
"""
x0 = 0.092
y0 = 0.0018
alpha = 0.6
x_min = 0.006
x_max = 0.... |
def subreddit_in_grouping(subreddit: str, grouping_key: str) -> bool:
"""
:param subreddit: subreddit name
:param grouping_key: example: "askreddit~-~blackburn"
:return: if string is within the grouping range
"""
bounds = grouping_key.split("~-~")
if len(bounds) == 1:
print(subreddit... |
def is_colored(page, colored):
""" O(1) !! """
h = hash(page)
return (h in colored) and (page in colored[h]) |
def get_link_props(props):
"""Return subset of iterable props that are links"""
return [val for val in props if "." in val] |
def insert_clause(table_name, keys):
""" Create a insert clause string for SQL.
Args:
table_name: The table where the insertion will happen.
keys: An iterator with strings specifying the fields to change.
Returns:
The query as a string
"""
fields... |
def wc(iterable):
"""
wc(iter: iterable)
return size of "iter"
args:
iter = [[1,2], [2,3], [3,4]] iter = {}
return:
3 0
"""
i = 0
for x in iterable:
i += 1
return i |
def filter_by_cusine(names_matching_price,cusine_to_names,cusine_list):
""" (list of str, dict of {str: list of str}, list of str) -> list of str
>>> names = ['Queen St. Cafe', 'Dumplings R Us', 'Deep Fried Everything']
>>> cuis = 'Canadian': ['Georgie Porgie'],
'Pub Food': ['Georgie Porgie', 'Deep Fr... |
def lorentzian(x, x0, gamma, alpha):
"""alpha * gamma / ((x-x0)**2 + gamma ** 2)"""
return alpha * gamma / ((x-x0)**2 + gamma ** 2) |
def hex_to_rgb(hex):
"""
Convert a hex colour to(r, g, b).
Arguments:
hex: Hexidecimal colour code, i.e. '#abc123'.
Returns: (r, g, b) tuple with values 0 - 1000.
"""
scalar = 3.9215 # 255 * 3.9215 ~= 1000.
r = int(int(hex[1:3], 16) * scalar)
g = int(int(hex[3:5], 16) * scalar)
... |
def matches(filename_, filenames_to_exclude_):
"""
Matches
:param filename_:
:param filenames_to_exclude_:
:return:
"""
for filename_to_exclude_ in filenames_to_exclude_:
if filename_ == filename_to_exclude_:
return True
return False |
def is_vcf_call_line(line):
"""
Returns ``True`` if ``line`` is a VCF SNP call line, ``False`` otherwise.
:param line: line from VCF file
:return: ``bool``
"""
if line.startswith('##contig='):
return True
else:
return False |
def header_lookup(headers):
"""The header lookup table. Assign the index for
each candidate as follow, i.e.,
var_id[patient id] = 0
var_id[survival rate] = 1
Args:
headers: the name list of candidate causal variables,
outcome, patien id, ,etc.
"""
var_id = dict... |
def sort_score(modelScore):
"""
param1: Dictionary
return: Dictionary
Function returns a sorted dictionary on the basis of values.
"""
sorted_dict=dict(sorted(modelScore.items(), key=lambda item: item[1],reverse=True))
return sorted_dict |
def relu(x, c = 0):
"""
Compute the value of the relu function with parameter c, for a given point x.
:param x: (float) input coordinate
:param c: (float) shifting parameter
:return: (float) the value of the relu function
"""
return c + max(0.0, x) |
def parse_timedelta_from_api(data_dict, key_root):
"""Returns a dict with the appropriate key for filling a two-part timedelta
field where the fields are named <key_root>_number and <key_root>_units.
Parameters
----------
data_dict: dict
API json response containing a key matching the key_r... |
def fibonacci(i):
"""
This function finds the ith number in the Fibonaci series, -1 otherwise.
"""
if i <= 0:
return -1
#Fixing the code to see if test cases go through
if i <= 2:
return 1
prev = 1
curr = 1
for k in range(i-2):
temp = curr
curr += prev
prev = temp
return curr |
def is_prime(number):
"""
>>> is_prime(3)
True
>>> is_prime(90)
False
>>> is_prime(67)
True
"""
if number <= 1:
return False
for i in range(2, number - 1):
if number % i == 0:
return False
return True |
def is_partition(device):
"""
Check is a device is a partition
"""
if device[-1].isdigit():
return True
return False |
def hashable_index(tuple_idx):
"""Return an hashable representation of a tuple of slice object
We add this because the slice object in python is not hashable.
Parameters
----------
tuple_idx : tuple
A tuple of slice/int objects
Returns
-------
ret : tuple
A hashable re... |
def get_epoch(ckpt_name):
"""Get epoch from checkpoint name"""
start = ckpt_name.find('-')
start += len('-')
end = ckpt_name.find('_', start)
epoch = eval(ckpt_name[start:end].strip())
return epoch |
def replace(given_text: str, sub_string: str, replacable_str: str) -> str:
"""Replace a substring with another string from a given text.
Args:
given_text (str): the full text where to be replaced
sub_string (str): the string to be replaced
replacable_str (str): the new replaced string
... |
def hex_to_rgb(color):
"""Convert hex color format to rgb color format.
Args:
color (int): The hex representation of color.
Returns:
The rgb representation of color.
"""
r, g, b = (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff
return r / 255, g / 255, b / 255 |
def tes2numpy(msb_type, num_bytes, nelems=1):
"""
Converts a MSB data type to a numpy datatype
"""
valid_bytes = {
'MSB_UNSIGNED_INTEGER': [1,2,4,8,16,32,64],
'MSB_INTEGER': [1,2,4,8,16,32,64],
'IEEE_REAL': [1,2,4,8,16,32,64],
'CHARACTER': range(1,128),
'MSB_BIT_... |
def match_hex(key: str) -> str:
"""Returns a string containing a regex matching key=<hex_or_integer_string>"""
return f"{key}=((?:0x)?[0-9a-fA-F]+)" |
def in_SCAT_box(x, y, low_bound, high_bound, x_max, y_max):
"""determines if a particular point falls within a box"""
passing = True
upper_limit = high_bound(x)
lower_limit = low_bound(x)
if x > x_max or y > y_max:
passing = False
if x < 0 or y < 0:
passing = False
if y > upp... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.