query stringlengths 9 9.05k | document stringlengths 10 222k | negatives listlengths 19 20 | metadata dict |
|---|---|---|---|
L{client.URI.originForm} produces an absolute I{URI} path including the I{URI} path. | def test_originForm(self):
uri = client.URI.fromBytes(self.makeURIString(b"http://HOST/foo"))
self.assertEqual(b"/foo", uri.originForm) | [
"def test_originFormNoPath(self):\n uri = client.URI.fromBytes(self.makeURIString(b\"http://HOST\"))\n self.assertEqual(b\"/\", uri.originForm)",
"def test_originFormEmptyPath(self):\n uri = client.URI.fromBytes(self.makeURIString(b\"http://HOST/\"))\n self.assertEqual(b\"/\", uri.orig... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
L{client.URI.originForm} produces a path of C{b'/'} when the I{URI} specifies no path. | def test_originFormNoPath(self):
uri = client.URI.fromBytes(self.makeURIString(b"http://HOST"))
self.assertEqual(b"/", uri.originForm) | [
"def test_originFormEmptyPath(self):\n uri = client.URI.fromBytes(self.makeURIString(b\"http://HOST/\"))\n self.assertEqual(b\"/\", uri.originForm)",
"def test_originForm(self):\n uri = client.URI.fromBytes(self.makeURIString(b\"http://HOST/foo\"))\n self.assertEqual(b\"/foo\", uri.ori... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
L{client.URI.originForm} produces a path of C{b'/'} when the I{URI} specifies an empty path. | def test_originFormEmptyPath(self):
uri = client.URI.fromBytes(self.makeURIString(b"http://HOST/"))
self.assertEqual(b"/", uri.originForm) | [
"def test_originFormNoPath(self):\n uri = client.URI.fromBytes(self.makeURIString(b\"http://HOST\"))\n self.assertEqual(b\"/\", uri.originForm)",
"def test_originForm(self):\n uri = client.URI.fromBytes(self.makeURIString(b\"http://HOST/foo\"))\n self.assertEqual(b\"/foo\", uri.originF... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
L{client.URI.fromBytes} parses the scheme, host, and path elements into L{bytes}, even when passed an URL which has previously been passed to L{urlparse} as a L{unicode} string. | def test_externalUnicodeInterference(self):
goodInput = self.makeURIString(b"http://HOST/path")
badInput = goodInput.decode("ascii")
urlparse(badInput)
uri = client.URI.fromBytes(goodInput)
self.assertIsInstance(uri.scheme, bytes)
self.assertIsInstance(uri.host, bytes)
... | [
"def urlunparse(parts):\n scheme, netloc, path, params, query, fragment = parts\n\n # Avoid encoding the windows drive letter colon\n if RE_DRIVE_LETTER_PATH.match(path):\n quoted_path = path[:3] + parse.quote(path[3:])\n else:\n quoted_path = parse.quote(path)\n\n return parse.urlunpar... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Brackets around IPv6 addresses are stripped in the host field. The host field is then exported with brackets in the output of L{client.URI.toBytes}. | def test_hostBracketIPv6AddressLiteral(self):
uri = client.URI.fromBytes(b"http://[::1]:80/index.html")
self.assertEqual(uri.host, b"::1")
self.assertEqual(uri.netloc, b"[::1]:80")
self.assertEqual(uri.toBytes(), b"http://[::1]:80/index.html") | [
"def ipv6_str_with_prefix(self):\n return f\"{self.ipv6}/{self.ipv6_network.prefixlen}\"",
"def reverse_ipv6(ipv6):\n reverse_chars = ipaddress_local.ip_address(ipv6).exploded[::-1].replace(':', '')\n return '.'.join(reverse_chars) + '.ip6.arpa'",
"def test_ip_address_ipv6_ipv4_mapped(self):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Error metrics for an entire fold as defined in the preprocessing parameters. fold Fold.fold_1, Fold.fold_2, Fold.fold_3, Fold.fold_4, Fold.fold_benchmark mode 'train', 'valid' or 'test' to address the correct config parameter norm Flag if the spectrogram should be normed to 1 net The network used for classification, e.... | def compute_all_error_metrics(fold, mode, net, model_dir, save_dir, save_file, norm=False, n_onset_plus=25, offset=0):
config = ppp.get_preprocessing_parameters(fold.value)
audio_config = config['audio_config']
# load fold
filenames = open(config[mode + '_fold'], 'r').readlines()
filenames = [f.str... | [
"def kfold(current_path,target_path,property_name,num_fold):\n \n with open(os.path.join(current_path,'SISSO.in'),'r') as f:\n input_file=f.read()\n task_number=int(re.findall(r'ntask\\s*=\\s*(\\d+)',input_file)[0])\n samples_number=re.findall(r'nsample\\s*=\\s*([\\d,]+)',inpu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return the minimum temperature 4.5 means off. | def min_temp(self):
return convert(4.5, TEMP_CELSIUS, self.unit_of_measurement) | [
"def minwatertemperature(self):\n return self._minwatertemperature",
"def minairtemperature(self):\n return self._minairtemperature",
"def lower_temperature(self) -> float:\n\n return self._get_temperature(_MCP9808_REG_LOWER_TEMP)",
"def low_temperature(self):\r\n low_temperature_l... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return the maximum temperature 30.5 means on. | def max_temp(self):
return convert(30.5, TEMP_CELSIUS, self.unit_of_measurement) | [
"def max_temp(self):\n temp = self.device.away_temperature.high\n if temp is None:\n return super().max_temp\n else:\n return temp",
"def maxwatertemperature(self):\n return self._maxwatertemperature",
"def max_temp(self):\n # pylint: disable=no-member\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Check if possible to use the HM Object as this HA type. | def _check_hm_to_ha_object(self):
from pyhomematic.devicetypes.thermostats import HMThermostat\
as pyHMThermostat
# Check compatibility from HMDevice
if not super()._check_hm_to_ha_object():
return False
# Check if the homematic device correct for this HA device... | [
"def has_hm(self) -> bool:\n return self.halo_profile is not None",
"def __is(self, object_instance: WashBase, rule_class) -> bool:\n return textx_isinstance(object_instance, self.__metamodel[rule_class])",
"def check(cls, obj):\n # An object is 'missing' if it has an attribute 'moya_missin... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns a list of random, unique playing cards | def randomCardList(cardCount):
return random.sample(cardSpace(), k=cardCount) | [
"def get_cards():\n return random.randint(1, 10)",
"def total_cards_list(self):\n cartesian_product = product(self.suit, self.rank)\n list_of_cards = list(cartesian_product)\n return random.sample(list_of_cards, 36)",
"def players_having_no_tie_card_sample():\n player1_cards = [Card('... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Executes Proj1Test for a given guess. | def runGuess(answer, logger, display=True):
timeStarted = time.time()
output = subprocess.getoutput(["Proj1Test.exe"] + answer)
try:
timeDelta = round(time.time() - timeStarted, ACCURACY)
guesses = round(float(re.findall(GUESS_REGEX, output)[0]), ACCURACY)
quality = round(float(re.fi... | [
"def test_guess_learner():\n\n assert update_guess(1, 0.3, 0.1, 0.2) > \\\n update_guess(1, 0.3, 0.1, 0.8)\n assert update_guess(1, 0.01, 0.01, 0.01) > \\\n update_guess(1, 0.01, 0.01, 0.99)\n assert update_guess(1, 0.49, 0.49, 0.01) > \\\n update_guess(1, 0.49, 0.49, 0.99)",
"def puzzle_1() -> None:\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test that the sorting function works for empty list | def test_empty():
empty_list = []
assert bubble_sort(empty_list) == empty_list | [
"def test_default_sort(self):\n self.run_on_lists(default_sort)",
"def test_unsortedlist(self) -> None:\n test_list = [9, 7, 5, 2, 4, 5, 3, 3, 2, 1, 10, 200]\n\n actual = self.algorithm(test_list)\n expected = sorted(test_list)\n\n assert actual == expected",
"def test_quick_s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test that the sorting function works for singleelement list | def test_single():
single_element_list = [2]
assert bubble_sort(single_element_list) == single_element_list | [
"def test_single():\n\n single_element_list = [5]\n\n assert single_element_list == bubble_sort(single_element_list)",
"def test_sortedlist(self) -> None:\n test_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n\n actual = self.algorithm(test_list)\n expected = sorted(test_list)\n\n as... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test that sorting leaves the original data unchanged. | def test_original_unchanged():
data = [3, 2, 1]
sorted_data = bubble_sort(data)
assert data == [3, 2, 1] and sorted_data != [3, 2, 1] | [
"def test_original_unchanged():\n\n data = [3, 2, 1]\n bubble_sort(data)\n\n assert data == [3, 2, 1]",
"def test_sort_list_should_not_change_input_list():\n simple = [\"bb\", \"cc\", \"dd\"]\n correct = simple.copy()\n assert filter.sort_list(correct) == correct",
"def test_sort_sorted():\n\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test that sorting works on sorted data. | def test_sort_sorted():
data = [1, 2, 3, 4, 6, 9]
sorted_data = bubble_sort(data)
for small, large in zip(sorted_data[:-1], sorted_data[1:]):
assert small < large | [
"def test_sort_sorted():\n\n data = [1, 2, 3]\n sorted_data = bubble_sort(data)\n\n assert data == sorted_data",
"def test(sort):\n print \"Testing sort functionality for {}...\".format(sort.__name__)\n\n # Shuffle the data, testing various ways to sort\n data = nprnd.randint(-1000, 1000, size=1... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test that sorting works on reversesorted data. | def test_sort_reversed():
data = [9, 6, 4, 3, 2, 1]
sorted_data = bubble_sort(data)
for small, large in zip(sorted_data[:-1], sorted_data[1:]):
assert small < large | [
"def test_reverse_basic():\n assert sort_arr([1, 5, 4, 3, 2, 6]) == (\"reverse\", 2, 5)",
"def test_sort_sorted():\n\n data = [1, 2, 3]\n sorted_data = bubble_sort(data)\n\n assert data == sorted_data",
"def test_original_unchanged():\n\n data = [3, 2, 1]\n bubble_sort(data)\n\n assert data... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test that sorting handles data with identical elements. | def test_sort_all_equal():
data = [9, 2, 3, 5, 8, 9]
sorted_data = bubble_sort(data)
assert sorted_data == [2, 3, 5, 8, 9, 9] | [
"def test_sort_all_equal():\n\n data = [2, 2, 2, 2]\n\n sorted_data = bubble_sort(data)\n\n assert sorted_data == [2, 2, 2, 2]",
"def test_sort_sorted():\n\n data = [1, 2, 3]\n sorted_data = bubble_sort(data)\n\n assert data == sorted_data",
"def test_original_unchanged():\n data = [3, 2, 1... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Computes the average success probability of running a specific configuration for the number of plays specified. | def discriminate_channel(configuration: ChannelConfiguration, plays: Optional[int] = 100) -> float:
return OneShotCircuit().compute_average_success_probability(configuration, plays) | [
"def probability(self):\r\n batcoins = arrayofcoins(1000) #code can be messed with to make a custom value for x in arrayofcoins(x), but theoretical probability calculation must also be changed\r\n for m in range(0,self.trials):\r\n if batcoins.successnumber() == 1:\r\n self.s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Compute the final state reshaped coordinates from a given amplitudes | def _compute_finale_state_vector_coords_reshaped(self,
amplitudes_vector: List[float],
angles_phase: List[float],
n_points_theta: int,
... | [
"def raw_amp_to_amp(rawamp2d: np.ndarray, probes: np.ndarray):\n return -np.imag(rawamp2d)*np.pi*2*np.pi*probes/4/C.epsilon_0/C.c",
"def actuator_coords(self):\n\n mask = np.ones((11, 11), np.bool)\n for i in range(0, 3):\n for j in range(3 - i):\n mask[i, j] = False\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test module hotspots2006.py by downloading hotspots2006.csv and testing shape of extracted data has 10 rows and 6 columns | def test_hotspots2006():
test_path = tempfile.mkdtemp()
x_train, metadata = hotspots2006(test_path)
try:
assert x_train.shape == (10, 6)
except:
shutil.rmtree(test_path)
raise() | [
"def test_read_short_data() -> None:\n fo = open('data/short_data.csv', \"r\")\n e = Election(date(2000, 2, 8))\n e.read_results(fo)",
"def get_features(year):",
"def import_data():\n PROJECT_DIR = path.dirname( path.dirname( path.dirname( __file__ ) ) )\n \n geoplaces = pd.read_csv( \n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Tests whether ``ScheduledEventEntityMetadataLocation.copy`` works as intended. | def test__ScheduledEventEntityMetadataLocation__copy():
location = 'Koishi WonderLand'
entity_metadata = ScheduledEventEntityMetadataLocation(
location = location,
)
copy = entity_metadata.copy()
_assert_fields_set(copy)
vampytest.assert_eq(copy, entity_metadata)
vampytest.... | [
"def test__ScheduledEventEntityMetadataLocation__copy_with__0():\n location = 'Koishi WonderLand'\n \n entity_metadata = ScheduledEventEntityMetadataLocation(\n location = location,\n )\n copy = entity_metadata.copy_with()\n \n _assert_fields_set(copy)\n vampytest.assert_eq(copy, enti... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Tests whether ``ScheduledEventEntityMetadataLocation.copy_with`` works as intended. | def test__ScheduledEventEntityMetadataLocation__copy_with__0():
location = 'Koishi WonderLand'
entity_metadata = ScheduledEventEntityMetadataLocation(
location = location,
)
copy = entity_metadata.copy_with()
_assert_fields_set(copy)
vampytest.assert_eq(copy, entity_metadata)
... | [
"def test__ScheduledEventEntityMetadataLocation__copy_with__1():\n old_location = 'Koishi WonderLand'\n \n new_location = 'Orin\\'s dance house'\n \n entity_metadata = ScheduledEventEntityMetadataLocation(\n location = old_location,\n )\n copy = entity_metadata.copy_with(\n locati... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Tests whether ``ScheduledEventEntityMetadataLocation.copy_with`` works as intended. | def test__ScheduledEventEntityMetadataLocation__copy_with__1():
old_location = 'Koishi WonderLand'
new_location = 'Orin\'s dance house'
entity_metadata = ScheduledEventEntityMetadataLocation(
location = old_location,
)
copy = entity_metadata.copy_with(
location = new_locati... | [
"def test__ScheduledEventEntityMetadataLocation__copy_with__0():\n location = 'Koishi WonderLand'\n \n entity_metadata = ScheduledEventEntityMetadataLocation(\n location = location,\n )\n copy = entity_metadata.copy_with()\n \n _assert_fields_set(copy)\n vampytest.assert_eq(copy, enti... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Tests whether ``ScheduledEventEntityMetadataLocation.copy_with_keyword_parameters`` works as intended. | def test__ScheduledEventEntityMetadataLocation__copy_with_keyword_parameters__0():
location = 'Koishi WonderLand'
entity_metadata = ScheduledEventEntityMetadataLocation(
location = location,
)
copy = entity_metadata.copy_with_keyword_parameters({})
_assert_fields_set(copy)
vamp... | [
"def test__ScheduledEventEntityMetadataLocation__copy_with_keyword_parameters__1():\n old_location = 'Koishi WonderLand'\n \n new_location = 'Orin\\'s dance house'\n \n entity_metadata = ScheduledEventEntityMetadataLocation(\n location = old_location,\n )\n copy = entity_metadata.copy_wi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Tests whether ``ScheduledEventEntityMetadataLocation.copy_with_keyword_parameters`` works as intended. | def test__ScheduledEventEntityMetadataLocation__copy_with_keyword_parameters__1():
old_location = 'Koishi WonderLand'
new_location = 'Orin\'s dance house'
entity_metadata = ScheduledEventEntityMetadataLocation(
location = old_location,
)
copy = entity_metadata.copy_with_keyword_par... | [
"def test__ScheduledEventEntityMetadataLocation__copy_with_keyword_parameters__0():\n location = 'Koishi WonderLand'\n \n entity_metadata = ScheduledEventEntityMetadataLocation(\n location = location,\n )\n copy = entity_metadata.copy_with_keyword_parameters({})\n \n _assert_fields_set(c... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Locks a file using POSIX locks. | def LockFile(fd):
try:
fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
except IOError as err:
if err.errno == errno.EAGAIN:
raise errors.LockError("File already locked")
raise | [
"def lockfile(fileobj, blocking=True, exclusive=True):\n import fcntl, time, random\n if exclusive:\n flags = fcntl.LOCK_EX\n else:\n flags = fcntl.LOCK_SH\n\n if blocking:\n fcntl.lockf(fileobj.fileno(), flags)\n else:\n flags |= fcntl.LOCK_NB\n fcntl.lockf(fileobj... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Locks the file in exclusive mode. | def Exclusive(self, blocking=False, timeout=None):
self._flock(fcntl.LOCK_EX, blocking, timeout,
"Failed to lock %s in exclusive mode" % self.filename) | [
"def lockfile(fileobj, blocking=True, exclusive=True):\n import fcntl, time, random\n if exclusive:\n flags = fcntl.LOCK_EX\n else:\n flags = fcntl.LOCK_SH\n\n if blocking:\n fcntl.lockf(fileobj.fileno(), flags)\n else:\n flags |= fcntl.LOCK_NB\n fcntl.lockf(fileobj... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Locks the file in shared mode. | def Shared(self, blocking=False, timeout=None):
self._flock(fcntl.LOCK_SH, blocking, timeout,
"Failed to lock %s in shared mode" % self.filename) | [
"def _lock( self, fileref=None, filehash=None ):\n\t\treturn self.__setlock( True, fileref=fileref, filehash=filehash )",
"def lockfile(fileobj, blocking=True, exclusive=True):\n import fcntl, time, random\n if exclusive:\n flags = fcntl.LOCK_EX\n else:\n flags = fcntl.LOCK_SH\n\n if blo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Initializes the hat by creating channel mask and returning all important information. | def initHat(channels):
mcc = mcc118(0)
options = OptionFlags.CONTINUOUS
channel_mask = chan_list_to_mask(channels)
numberOfChannels = len(channels)
return mcc, channel_mask, options, numberOfChannels | [
"def _init_h(self):\n self.H = np.random.random((self._num_bases, self._num_samples)) + 0.2",
"def _initialize_heatmap(self):\n return np.zeros(shape=self.shape).astype(np.uint8)",
"def _hash_init(self):\r\n # Initialize the indices and data dependencies.\r\n self.rotor = 1\r\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Function to take in a set of Baxter paths, with joint angles ordered in MoveIt fashion, and reorder all the waypoints in the path for the Baxter interface joint angle order, and normalize using the joint ranges | def moveit_unscramble(self, paths):
new_paths = []
for path in paths:
new_path = np.zeros((path.shape[0], 7))
new_path[:, 0:2] = path[:, 0:2] #replace proper indices in each path
new_path[:, 2:5] = path[:, 4:]
new_path[:, 5:] = path[:, 2:4]
new_path = np.divide(new_path, self.joint_range) #normalize... | [
"def reorder_trajectory_joints(trajectory, joint_names):\n order = [trajectory.joint_names.index(j) for j in joint_names]\n new_points = []\n for point in trajectory.points:\n new_points.append(JointTrajectoryPoint(\n positions=[point.positions[i] for i in order],\n velocities=... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Import all paths from a file with paths from all environments, ofand return into a single a dictionary keyed by environment name. Unscramle the path data and normalize it in the process | def paths_import_all(self, path_fname):
with open (path_fname, "rb") as paths_f:
paths_dict = pickle.load(paths_f)
# keyed by environment name
unscrambled_dict = {}
for key in paths_dict.keys():
unscrambled_dict[key] = self.moveit_unscramble(paths_dict[key])
return unscrambled_dict | [
"def paths_import_single(self, path_fname, env_name, single_env=False):\n\t\tif not single_env:\n\t\t\twith open (path_fname, \"rb\") as paths_f:\n\t\t\t\tpaths_dict = pickle.load(paths_f)\n\n\t\t\t# for non single environment, need to use the environment name as a dictionary key to get the right path list\n\t\t\te... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Import the paths from a single environment. File to load from may contain data from many environments, or just a single one, indicated by the single_env (True/False) flag | def paths_import_single(self, path_fname, env_name, single_env=False):
if not single_env:
with open (path_fname, "rb") as paths_f:
paths_dict = pickle.load(paths_f)
# for non single environment, need to use the environment name as a dictionary key to get the right path list
env_paths = self.moveit_unscr... | [
"def load_local(env_script, env):\n # pylint: disable=unused-argument\n SConscript(env_script, exports=['env'])",
"def environments_import(self, envs_fname):\n\t\twith open (envs_fname, \"rb\") as env_f:\n\t\t\tenvs = pickle.load(env_f)\n\t\tenv_names = envs['poses'].keys() # also has obstacle meta data\n\t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Import the pointcloud data from a file, and flatten it into a vector | def pointcloud_import(self, pcd_fname):
print('pointcloud filename:')
print(pcd_fname)
pc = pypcd.PointCloud.from_path(pcd_fname)
# flatten into vector
temp = []
temp.append(pc.pc_data['x'][~np.isnan(pc.pc_data['x'])])
temp.append(pc.pc_data['y'][~np.isnan(pc.pc_data['x'])])
temp.append(pc.pc_data['z']... | [
"def load_vectors(filename):\n\n vectors = []\n with open(filename, 'r') as f:\n reader = csv.reader(f, quoting=csv.QUOTE_NONNUMERIC)\n for v in reader:\n vectors.append(v)\n return vectors",
"def loadData(self, file_path: str): \n # Open the file, load the data and reshap... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get number of points in the pointcloud file pcd_fname | def pontcloud_length_check(self, pcd_fname):
pc = self.pointcloud_import(pcd_fname)
return pc.shape[0] | [
"def compute_number_of_geometries(file_name: str | os.PathLike[str]) -> int:\n with open(file_name, 'r') as f:\n numat = int(f.readline())\n\n cmd = f\"wc -l {os.fspath(file_name)}\"\n wc = subprocess.getoutput(cmd).split()[0]\n\n lines_per_geometry = numat + 2\n\n return int(wc) // lines_per_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Import environments from files with description of where obstacles reside, dictionary keyed by 'poses' and 'obsData'. This function uses the poses key, which has the positions of all the environment obstacles | def environments_import(self, envs_fname):
with open (envs_fname, "rb") as env_f:
envs = pickle.load(env_f)
env_names = envs['poses'].keys() # also has obstacle meta data
return env_names | [
"def edit_world(file_name, poses):\n\n # Open world file\n tree = ET.parse(file_name)\n\n root = tree.getroot()\n root_state = root.findall('world')[0].findall('state')[0]\n\n objects_pose = poses\n models = {} \n\n for model in root_state.iter('model'):\n if model.attrib['name'] in obje... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Reads in a file, f, using a configurable block size, block_size. Returns an md5 hash of the content of the file | def md5_for_file(f, block_size=2**20):
m = hashlib.md5()
with open(f , "rb" ) as f:
while True:
buf = f.read(block_size)
if not buf:
break
m.update( buf )
return m.hexdigest() | [
"def checksum_md5 (filename) :\n fname = filename\n block_size = 0x10000\n fd = open(fname, \"rb\")\n try:\n block = [ fd.read(block_size) ]\n while len(block[-1]) > 0 :\n block.append ( fd.read(block_size) )\n contents = block\n zero = hashlib.md5()\n i = ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Recursively walks the target directory and removes all but one copy of files that share an md5 hash | def deduplicate_directory(target):
dedupe_walk = os.walk(target)
dupes = {}
for w in dedupe_walk:
src_files = product([w[0]], w[2])
for file in src_files:
target_f = join(file[0], file[1])
hash = md5_for_file(join(file[0], file[1]))
try:
du... | [
"def remove_file_hash(f_path):\n\tf_path = stringutil.normalize_file(f_path)\n\twith lock('w'), closing(conn.cursor()) as cur:\n\t\tcur.execute('DELETE FROM hashes WHERE file_path=:fp',{'fp':f_path})\n\t\tconn.commit()",
"def remove_dup(self):\n duplicates = []\n hash_keys = dict()\n\n os.chd... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Retrieve files generated by PureCN_Dx | def _get_purecn_dx_files(paired, out):
out_base = "%s-dx" % utils.splitext_plus(out["rds"])[0]
all_files = []
for key, ext in [[("mutation_burden",), "_mutation_burden.csv"],
[("plot", "signatures"), "_signatures.pdf"],
[("signatures",), "_signatures.csv"]]:
... | [
"def get_files_to_generate(self):\r\n pass",
"def getFiles(self) -> List[ghidra.framework.model.DomainFile]:\n ...",
"def generate_files(self) -> List[Tuple[str, str, str]]:\n raise NotImplementedError() # NOQA",
"def _get_purecn_files(paired, work_dir, require_exist=False):\n out_bas... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Run PureCN.R wrapper with presegmented CNVkit or GATK4 inputs. | def _run_purecn(paired, work_dir):
segfns = {"cnvkit": _segment_normalized_cnvkit, "gatk-cnv": _segment_normalized_gatk}
out_base, out, all_files = _get_purecn_files(paired, work_dir)
failed_file = out_base + "-failed.log"
cnr_file = tz.get_in(["depth", "bins", "normalized"], paired.tumor_data)
if n... | [
"def main(args):\n model, ensemble = setup_gnina_model(args.cnn, args.dimension, args.resolution)\n model.eval() # Ensure models are in evaluation mode!\n\n device = utils.set_device(args.gpu)\n model.to(device)\n\n example_provider = setup.setup_example_provider(args.input, args, training=False)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Segmentation of normalized inputs using GATK4, converting into standard input formats. | def _segment_normalized_gatk(cnr_file, work_dir, paired):
work_dir = utils.safe_makedir(os.path.join(work_dir, "gatk-cnv"))
seg_file = gatkcnv.model_segments(cnr_file, work_dir, paired)["seg"]
std_seg_file = seg_file.replace(".cr.seg", ".seg")
if not utils.file_uptodate(std_seg_file, seg_file):
... | [
"def normalise(self):\n if not self.inputs:\n self.auto_detect_inputs()\n max_r = self.depth() - 1\n if max_r <= 2: \n for o in self.outputs:\n self.set_row(o,4)\n max_r = self.depth() -1\n claimed = []\n for q,i in enumerate(sorted(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Retrieve organized structure of PureCN output files. | def _get_purecn_files(paired, work_dir, require_exist=False):
out_base = os.path.join(work_dir, "%s-purecn" % (dd.get_sample_name(paired.tumor_data)))
out = {"plot": {}}
all_files = []
for plot in ["chromosomes", "local_optima", "segmentation", "summary"]:
if plot == "summary":
cur_f... | [
"def output_components(output_dir):\n if output_dir is None:\n return\n\n component = 0\n paths_by_start = {}\n for path in Read.known_paths:\n if path[0] not in paths_by_start:\n paths_by_start[path[0]] = []\n paths_by_start[path[0]].append(path)\n\n with open(output_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Convert LOH output into standardized VCF. | def _loh_to_vcf(cur):
cn = int(float(cur["C"]))
minor_cn = int(float(cur["M"]))
if cur["type"].find("LOH"):
svtype = "LOH"
elif cn > 2:
svtype = "DUP"
elif cn < 1:
svtype = "DEL"
else:
svtype = None
if svtype:
info = ["SVTYPE=%s" % svtype, "END=%s" % c... | [
"def parse_haplotype_to_vcf(haplotype_to_vcf): \n haplotype_to_vcf.add_argument(\n \"-haplotypeFormat\", default = 'iupac',\n help = \"report which format (numeric vs. iupac) the haplotype file is in.\\n\" \n \"Default = iupac\", \n metavar = '')",
"def _convert_o... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Binaryencode categorical column `target_colname` separated by `value_sep` in data frame `dfm` to multiple binary columns with the same prefix `dest_colname_prefix` MySQL returns `GROUP_CONCAT(tf.name)` in `tfName` column in a commaseparated string. E.g. `ARID3A,ATF1,ATF2` stands for 3 TFs This function separates this s... | def binary_encode_tfbs(dfm, target_colname="tfName", value_sep=',', dest_colname_prefix=None):
dummies = dfm.loc[:, target_colname].str.get_dummies(sep=value_sep)
if dest_colname_prefix is not None:
# Add a prefix to all column names
dummies = dummies.add_prefix(dest_colname_prefix)
dfm = ... | [
"def replace_labels(dataframe, id_col_name='FBbt_id', label_col_name='FBbt_name', sep='|'):\n col_order = dataframe.columns\n dataframe['converted_ids'] = dataframe.loc[:,id_col_name].apply(\n lambda x: (str(x).replace(':', '_')).split(sep))\n FBbt_list = list(dataframe.loc[:,'converted_ids'])\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Set fixed parameter values. Examples >>> from cymr import parameters >>> param_def = parameters.Parameters() >>> param_def.set_fixed(a=1, b=2) | def set_fixed(self, *args: dict[str, float], **kwargs: float):
self.fixed.update(*args, **kwargs) | [
"def set_fixed(self, section, name, value):\n i = self.parameter_index(section, name)\n self.parameters[i].limits = (value, value)\n self.reset_fixed_varied_parameters()",
"def set_parameter_fixed(parameter_dictionary, param_name, fix):\n if 'parameter_info' not in parameter_dictionary:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Set free parameter ranges. Examples >>> from cymr import parameters >>> param_def = parameters.Parameters() >>> param_def.set_free(a=[0, 1], b=[1, 10]) | def set_free(
self, *args: dict[str, Iterable[float]], **kwargs: Iterable[float]
) -> None:
self.free.update(*args, **kwargs) | [
"def setRegularizationParameter(self, beta) -> None:\n ...",
"def set_free(self, num):\n self.fixed[num] = False",
"def set_params_range(self):\n pass",
"def _validate_and_set_permitted_range(self, params):\r\n self.permitted_range = None\r\n if 'permitted_range' in params:\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Set dependent parameters in terms of other parameters. Examples >>> from cymr import parameters >>> param_def = parameters.Parameters() >>> param_def.set_dependent(a='exp(b 2)') | def set_dependent(self, *args: dict[str, str], **kwargs: str) -> None:
self.dependent.update(*args, **kwargs) | [
"def eval_dependent(self, param: dict[str, float]) -> dict[str, float]:\n return set_dependent(param, self.dependent)",
"def test_dependent(param_def):\n param = {'a': 1, 'b': 2}\n param = param_def.eval_dependent(param)\n assert param == {'a': 1, 'b': 2, 'd': 3.5}",
"def set_dependency(a, b):\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Evaluate dependent parameters based on input parameters. | def eval_dependent(self, param: dict[str, float]) -> dict[str, float]:
return set_dependent(param, self.dependent) | [
"def test_dependent(param_def):\n param = {'a': 1, 'b': 2}\n param = param_def.eval_dependent(param)\n assert param == {'a': 1, 'b': 2, 'd': 3.5}",
"def evaluate(self,*args,**kwargs):\n \n \n params = self.params.deepcopy()\n \n if len(args)>0 and len(kwargs)>0: raise V... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Evaluate dynamic parameters based on data fields. | def eval_dynamic(
self,
param: dict[str, Any],
study: Optional[dict[str, list[ArrayLike]]] = None,
recall: Optional[dict[str, list[ArrayLike]]] = None
) -> dict[str, Union[float, list[ArrayLike]]]:
if 'study' in self.dynamic and study is not None:
param = set_dyna... | [
"def test_dynamic(param_def, split_data):\n param = {'c': 2}\n param = param_def.eval_dynamic(param, study=split_data['study'])\n np.testing.assert_array_equal(param['e'][0], np.array([0.5, 1, 1.5]))\n np.testing.assert_array_equal(param['e'][1], np.array([1.5, 1, 0.5]))",
"def test_get_dynamic(param_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Tests downloads multiple files based on file names strings. | def test_downloading_two_named_files(self):
files = ("Gp_xr_1m.txt", "Gp_xr_5m.txt")
expected = [call(files[0], self.fmanager.remote),
call(files[1], self.fmanager.remote)]
self.fmanager.download(files)
self.assertEqual(expected, self.mocked_method.call_args_list) | [
"def check_files_by_urls(tmpdir, base_url, url_iterable):\n # checking files by url\n download_dir = tmpdir.mkdir(\"download_url\")\n for url in url_iterable:\n _, filename = os.path.split(os.path.relpath(url, base_url))\n download_file = download_dir.join(filename)\n wget.download(url... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Tests downloads a single file based on a template generated name. | def test_downloading_a_single_file_with_template(self):
self.fmanager.download_by_template('1')
self.mocked_method.assert_called_once_with('Gp_xr_1m.txt',
self.fmanager.remote) | [
"def test_download_file(self):\r\n purchase_url = '/' + self.purchase_uuid\r\n response = self.app.get(purchase_url)\r\n assert response.data == 'Test content\\n'\r\n assert response.status_code == 200",
"def test_correct_request_returns_file_download(self):\n response = self.cl... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Tests downloads multiple files based on template generated names. | def test_downloading_two_files_with_template(self):
strings = ('1', '2')
expected = [call('Gp_xr_1m.txt', self.fmanager.remote),
call('Gp_xr_2m.txt', self.fmanager.remote)]
self.fmanager.download_by_template(strings)
self.assertEqual(expected, self.mocked_method.call_arg... | [
"def test_downloading_a_single_file_with_template(self): \n self.fmanager.download_by_template('1')\n self.mocked_method.assert_called_once_with('Gp_xr_1m.txt', \n self.fmanager.remote)",
"def pressurcooker_test_files():\n return download_fixture_files(PRESSURECOOKER_SUBS_FIXTURES)"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Method called when unhooking this callback. | def doUnhook(self, handler):
pass | [
"def unhook(self):\n raise NotImplementedError",
"def remove_callback(self):\n\n\t\tself.callback = None\n\n\t\treturn",
"def onDeinit(self):",
"def __disconnect_hook(self, hook_name):\n p = getattr(self, \"__%s\" % hook_name, None)\n if p:\n GPS.Hook(hook_name).remove(p)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get the path of the tests directory. | def tests_dir():
return Path(os.path.realpath(__file__)).parent | [
"def get_tests_dir_path(): \n fmod_path = ctbto.tests.__path__\n \n test_dir = \"%s/conf_tests\" % fmod_path[0]\n \n return test_dir",
"def unit_test_dir(self):\n return os.path.join(self.output_dir, 'unit_tests')",
"def tests_root_directory(path: Optional[PathOrString] = None) ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create a generator object which will assist the tests object creation. | def generator(mocker):
return Generator(mocker) | [
"def prepare_example_generator(self):\n generator = self.example_iterator_type()\n generator.configure(self)\n return generator;",
"def test_custom_global_generator_multiple():\n c = TestClient()\n for num in range(3):\n generator = textwrap.dedent(f\"\"\"\n class MyGe... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
decr(self, size_t n = 1) > SwigPyIterator | def decr(self, n = 1):
return _digital_swig.SwigPyIterator_decr(self, n) | [
"def decr(self, n=1):\r\n return _osgDB.SwigPyIterator_decr(self, n)",
"def advance(self, n):\n return _core.SwigPyIterator_advance(self, n)",
"def advance(self, n):\n return _almathswig.SwigPyIterator_advance(self, n)",
"def incr(self, n=1):\r\n return _osgDB.SwigPyIterator_incr(s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_chunks_to_symbols_bf_sptr __init__(self, p) > digital_chunks_to_symbols_bf_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_chunks_to_symbols_bf_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_chunks_to_symbols_bc_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _digital_swig.new_digital_chunks_to_symbols_sc_sptr(*args)\n try: self.this.append(this... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
chunks_to_symbols_bf(__dummy_4__ symbol_table, int D = 1) > digital_chunks_to_symbols_bf_sptr Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex constellation points in D dimensions (D = 1 by default) | def chunks_to_symbols_bf(*args, **kwargs):
return _digital_swig.chunks_to_symbols_bf(*args, **kwargs) | [
"def chunks_to_symbols_sf(*args, **kwargs):\n return _digital_swig.chunks_to_symbols_sf(*args, **kwargs)",
"def chunks_to_symbols_ic(*args, **kwargs):\n return _digital_swig.chunks_to_symbols_ic(*args, **kwargs)",
"def chunks_to_symbols_bc(*args, **kwargs):\n return _digital_swig.chunks_to_symbols_bc(*args, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_chunks_to_symbols_bc_sptr __init__(self, p) > digital_chunks_to_symbols_bc_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_chunks_to_symbols_bc_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_chunks_to_symbols_bf_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _digital_swig.new_digital_chunks_to_symbols_sc_sptr(*args)\n try: self.this.append(this... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
chunks_to_symbols_bc(gr_complex_vector symbol_table, int D = 1) > digital_chunks_to_symbols_bc_sptr Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex constellation points in D dimensions (D = 1 by default) | def chunks_to_symbols_bc(*args, **kwargs):
return _digital_swig.chunks_to_symbols_bc(*args, **kwargs) | [
"def chunks_to_symbols_bf(*args, **kwargs):\n return _digital_swig.chunks_to_symbols_bf(*args, **kwargs)",
"def chunks_to_symbols_sc(*args, **kwargs):\n return _digital_swig.chunks_to_symbols_sc(*args, **kwargs)",
"def chunks_to_symbols_ic(*args, **kwargs):\n return _digital_swig.chunks_to_symbols_ic(*args, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_chunks_to_symbols_sf_sptr __init__(self, p) > digital_chunks_to_symbols_sf_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_chunks_to_symbols_sf_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_chunks_to_symbols_sc_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _digital_swig.new_digital_chunks_to_symbols_bf_sptr(*args)\n try: self.this.append(this... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
chunks_to_symbols_sf(__dummy_4__ symbol_table, int D = 1) > digital_chunks_to_symbols_sf_sptr Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex constellation points in D dimensions (D = 1 by default) | def chunks_to_symbols_sf(*args, **kwargs):
return _digital_swig.chunks_to_symbols_sf(*args, **kwargs) | [
"def chunks_to_symbols_sc(*args, **kwargs):\n return _digital_swig.chunks_to_symbols_sc(*args, **kwargs)",
"def chunks_to_symbols_ic(*args, **kwargs):\n return _digital_swig.chunks_to_symbols_ic(*args, **kwargs)",
"def chunks_to_symbols_bf(*args, **kwargs):\n return _digital_swig.chunks_to_symbols_bf(*args, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_chunks_to_symbols_sc_sptr __init__(self, p) > digital_chunks_to_symbols_sc_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_chunks_to_symbols_sc_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_chunks_to_symbols_sf_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _digital_swig.new_digital_chunks_to_symbols_ic_sptr(*args)\n try: self.this.append(this... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
chunks_to_symbols_sc(gr_complex_vector symbol_table, int D = 1) > digital_chunks_to_symbols_sc_sptr Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex constellation points in D dimensions (D = 1 by default) | def chunks_to_symbols_sc(*args, **kwargs):
return _digital_swig.chunks_to_symbols_sc(*args, **kwargs) | [
"def chunks_to_symbols_sf(*args, **kwargs):\n return _digital_swig.chunks_to_symbols_sf(*args, **kwargs)",
"def chunks_to_symbols_ic(*args, **kwargs):\n return _digital_swig.chunks_to_symbols_ic(*args, **kwargs)",
"def setup_symbols_for_species_pKs(self, sid_list):\n new_variable_index = 0\n sel... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_chunks_to_symbols_if_sptr __init__(self, p) > digital_chunks_to_symbols_if_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_chunks_to_symbols_if_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_chunks_to_symbols_sc_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _digital_swig.new_digital_chunks_to_symbols_ic_sptr(*args)\n try: self.this.append(this... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_chunks_to_symbols_ic_sptr __init__(self, p) > digital_chunks_to_symbols_ic_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_chunks_to_symbols_ic_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_chunks_to_symbols_sc_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _digital_swig.new_digital_chunks_to_symbols_bc_sptr(*args)\n try: self.this.append(this... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
chunks_to_symbols_ic(gr_complex_vector symbol_table, int D = 1) > digital_chunks_to_symbols_ic_sptr Map a stream of symbol indexes (unpacked bytes or shorts) to stream of float or complex constellation points in D dimensions (D = 1 by default) | def chunks_to_symbols_ic(*args, **kwargs):
return _digital_swig.chunks_to_symbols_ic(*args, **kwargs) | [
"def chunks_to_symbols_sc(*args, **kwargs):\n return _digital_swig.chunks_to_symbols_sc(*args, **kwargs)",
"def chunks_to_symbols_sf(*args, **kwargs):\n return _digital_swig.chunks_to_symbols_sf(*args, **kwargs)",
"def chunks_to_symbols_bc(*args, **kwargs):\n return _digital_swig.chunks_to_symbols_bc(*args, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_additive_scrambler_bb_sptr __init__(self, p) > digital_additive_scrambler_bb_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_additive_scrambler_bb_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_scrambler_bb_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _digital_swig.new_digital_descrambler_bb_sptr(*args)\n try: self.this.append(this)\n exc... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
additive_scrambler_bb(int mask, int seed, int len, int count = 0) > digital_additive_scrambler_bb_sptr Scramble an input stream using an LFSR. This block works on the LSB only of the input data stream, i.e., on an "unpacked binary" stream, and produces the same format on its output. The scrambler works by XORing the in... | def additive_scrambler_bb(*args, **kwargs):
return _digital_swig.additive_scrambler_bb(*args, **kwargs) | [
"def scrambler_bb(*args, **kwargs):\n return _digital_swig.scrambler_bb(*args, **kwargs)",
"def descrambler_bb(*args, **kwargs):\n return _digital_swig.descrambler_bb(*args, **kwargs)",
"def __init__(self, *args):\n this = _digital_swig.new_digital_additive_scrambler_bb_sptr(*args)\n try: self.t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_bytes_to_syms_sptr __init__(self, p) > digital_bytes_to_syms_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_bytes_to_syms_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def bytes_to_syms():\n return _digital_swig.bytes_to_syms()",
"def __init__(self, *args):\n this = _digital_swig.new_digital_chunks_to_symbols_bc_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _digital_swig.new_digital_ch... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
bytes_to_syms() > digital_bytes_to_syms_sptr Convert stream of bytes to stream of +/ 1 symbols | def bytes_to_syms():
return _digital_swig.bytes_to_syms() | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_bytes_to_syms_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def chunks_to_symbols_bc(*args, **kwargs):\n return _digital_swig.chunks_to_symbols_bc(*args, **kwargs)",
"def chunks_to_symbols_sc(*args, **... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_binary_slicer_fb_sptr __init__(self, p) > digital_binary_slicer_fb_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_binary_slicer_fb_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_scrambler_bb_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _digital_swig.new_digital_diff_encoder_bb_sptr(*args)\n try: self.this.append(this)\n ex... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
binary_slicer_fb() > digital_binary_slicer_fb_sptr slice float binary symbol outputting 1 bit output x 0 x >= 0 > 1 | def binary_slicer_fb():
return _digital_swig.binary_slicer_fb() | [
"def linear_fb(fn, sr, filter_num):\n # build the triangle filter bank\n f = (sr / 2) * torch.linspace(0, 1, fn//2+1)\n filter_bands = torch.linspace(min(f), max(f), filter_num+2)\n \n filter_bank = torch.zeros([fn//2+1, filter_num])\n for idx in range(filter_num):\n filter_bank[:, idx] = trimf(\n f... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_clock_recovery_mm_cc_sptr __init__(self, p) > digital_clock_recovery_mm_cc_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_clock_recovery_mm_cc_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_pfb_clock_sync_ccf_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _digital_swig.new_digital_pfb_clock_sync_fff_sptr(*args)\n try: self.this.append(this)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
clock_recovery_mm_cc(float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit) > digital_clock_recovery_mm_cc_sptr Mueller and M?ller (M&M) based clock recovery block with complex input, complex output. This implements the Mueller and M?ller (M&M) discretetime errortracking synchronizer. | def clock_recovery_mm_cc(*args, **kwargs):
return _digital_swig.clock_recovery_mm_cc(*args, **kwargs) | [
"def DMFNeuFluxMCDet(ch,DMm,DMsig,param):\n import os\n # FIX SCALING\n ## include years\n DM_annihilation_rate_Sun = DMSunAnnihilationRate(DMm,DMsig,param) # [eV]\n #DM_annihilation_rate_Sun = 1.6e21/param.sec\n normalization = np.sum((DM_annihilation_rate_Sun/(4.0*np.pi*param.AU**2))) # [... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_clock_recovery_mm_ff_sptr __init__(self, p) > digital_clock_recovery_mm_ff_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_clock_recovery_mm_ff_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_pfb_clock_sync_fff_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _digital_swig.new_digital_pfb_clock_sync_ccf_sptr(*args)\n try: self.this.append(this)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
clock_recovery_mm_ff(float omega, float gain_omega, float mu, float gain_mu, float omega_relative_limit = 0.001) > digital_clock_recovery_mm_ff_sptr Mueller and M?ller (M&M) based clock recovery block with float input, float output. This implements the Mueller and M?ller (M&M) discretetime errortracking synchronizer. | def clock_recovery_mm_ff(*args, **kwargs):
return _digital_swig.clock_recovery_mm_ff(*args, **kwargs) | [
"def DMFNeuFluxMCDet(ch,DMm,DMsig,param):\n import os\n # FIX SCALING\n ## include years\n DM_annihilation_rate_Sun = DMSunAnnihilationRate(DMm,DMsig,param) # [eV]\n #DM_annihilation_rate_Sun = 1.6e21/param.sec\n normalization = np.sum((DM_annihilation_rate_Sun/(4.0*np.pi*param.AU**2))) # [... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_cma_equalizer_cc_sptr __init__(self, p) > digital_cma_equalizer_cc_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_cma_equalizer_cc_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_diff_phasor_cc_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _digital_swig.new_digital_pn_correlator_cc_sptr(*args)\n try: self.this.append(this)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
cma_equalizer_cc(int num_taps, float modulus, float mu, int sps) > digital_cma_equalizer_cc_sptr Implements constant modulus adaptive filter on complex stream | def cma_equalizer_cc(*args, **kwargs):
return _digital_swig.cma_equalizer_cc(*args, **kwargs) | [
"def closure_amplitudes(amps, n=7):\n arr = populate_symmamparray(amps, n=n) # fringe amp array\n nn = 0\n\n cas = np.zeros(int(comb(n, 4)))\n\n for ii in range(n - 3):\n for jj in range(n - ii - 3):\n for kk in range(n - jj - ii - 3):\n for ll in range(n - jj - ii - kk... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__getslice__(self, difference_type i, difference_type j) > __dummy_6__ | def __getslice__(self, *args, **kwargs):
return _digital_swig.gr_complex_vector___getslice__(self, *args, **kwargs) | [
"def __getslice__(self, *args, **kwargs):\n return _digital_swig.unsigned_int_vector___getslice__(self, *args, **kwargs)",
"def __getslice__(self, i, j): \n ids = numpy.where((self.id_list >= i) & (self.id_list < j))[0]\n return self.id_slice(ids)",
"def _slice(self, shallow_copy, sl... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > gr_complex_vector __init__(self, gr_complex_vector arg0) > gr_complex_vector __init__(self, size_type size) > gr_complex_vector __init__(self, size_type size, value_type value) > gr_complex_vector | def __init__(self, *args):
this = _digital_swig.new_gr_complex_vector(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n _vnl_vectorPython.vnl_vector_vcl_complexD_swiginit(self,_vnl_vectorPython.new_vnl_vector_vcl_complexD(*args))",
"def __init__(self, *args):\n _vnl_vectorPython.vnl_vector_vcl_complexF_swiginit(self,_vnl_vectorPython.new_vnl_vector_vcl_complexF(*args))",
"def __init__(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__getslice__(self, difference_type i, difference_type j) > unsigned_int_vector | def __getslice__(self, *args, **kwargs):
return _digital_swig.unsigned_int_vector___getslice__(self, *args, **kwargs) | [
"def __getslice__(self, i, j): \n ids = numpy.where((self.id_list >= i) & (self.id_list < j))[0]\n return self.id_slice(ids)",
"def __getitem__(self, *args):\n return _digital_swig.unsigned_int_vector___getitem__(self, *args)",
"def __getslice__(self, *args):\n return _wali.Tr... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__getitem__(self, PySliceObject slice) > unsigned_int_vector __getitem__(self, difference_type i) > value_type | def __getitem__(self, *args):
return _digital_swig.unsigned_int_vector___getitem__(self, *args) | [
"def __getitem__(self, *args) -> \"int const &\":\n return _ida_pro.intvec_t___getitem__(self, *args)",
"def __getitem__(self, *args) -> \"unsigned int const &\":\n return _ida_pro.uintvec_t___getitem__(self, *args)",
"def __getslice__(self, *args, **kwargs):\n return _digital_swig.unsigned... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__setitem__(self, PySliceObject slice, unsigned_int_vector v) __setitem__(self, PySliceObject slice) __setitem__(self, difference_type i, value_type x) | def __setitem__(self, *args):
return _digital_swig.unsigned_int_vector___setitem__(self, *args) | [
"def __setitem__(self, i, new):\n if isinstance(i, int):\n self.remove(self[i])\n self.add(new)\n elif isinstance(i, slice):\n for interval in self[i]:\n self.remove(interval)\n self.update(new)\n else:\n message = \"Indices ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > unsigned_int_vector __init__(self, unsigned_int_vector arg0) > unsigned_int_vector __init__(self, size_type size) > unsigned_int_vector __init__(self, size_type size, value_type value) > unsigned_int_vector | def __init__(self, *args):
this = _digital_swig.new_unsigned_int_vector(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n _ida_pro.uintvec_t_swiginit(self, _ida_pro.new_uintvec_t(*args))",
"def __init__(self, *args):\n _ida_pro.intvec_t_swiginit(self, _ida_pro.new_intvec_t(*args))",
"def __init__(self, *args):\n _ida_pro.ulonglongvec_t_swiginit(self, _ida_pro.new_ulonglongvec_t(*a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_constellation_sptr __init__(self, digital_constellation p) > digital_constellation_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_constellation_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_diff_phasor_cc_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self):\n self.port=Config.PortPrinter # Assign the name of the port written in Config.py to s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
s_points(self) > gr_complex_vector Returns the vector of points in this constellation. Raise error if dimensionality is not one. | def s_points(self):
return _digital_swig.digital_constellation_sptr_s_points(self) | [
"def points(self):\n if self._points is None:\n _points = self.soma.points.tolist()\n for n in self.neurites:\n _points.extend(n.points.tolist())\n self._points = np.array(_points)\n\n return self._points",
"def soma_points(self):\n db = self.da... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
decision_maker(self, gr_complex sample) > unsigned int Returns the constellation point that matches best. | def decision_maker(self, *args, **kwargs):
return _digital_swig.digital_constellation_sptr_decision_maker(self, *args, **kwargs) | [
"def Cuffme(rpoint, cuff_sites, strand):\n for cuff in cuff_sites:\n if int(cuff[1])-50 < rpoint < int(cuff[2])+50:\n return 1\n\n return 0",
"def _calc_matching_prob(self):\n if not self.professional:\n return 1",
"def selectXClassifierT(self):\r\n \r\n a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
rotational_symmetry(self) > unsigned int Returns the order of rotational symmetry. | def rotational_symmetry(self):
return _digital_swig.digital_constellation_sptr_rotational_symmetry(self) | [
"def get_symmetry_number(self):\n if self.symmetry_number < 1:\n cython.declare(resonanceHybrid=Molecule, maxSymmetryNum=cython.short)\n resonance_hybrid = self.get_resonance_hybrid()\n try:\n self.symmetry_number = resonance_hybrid.get_symmetry_number()\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
points(self) > gr_complex_vector Returns the set of points in this constellation. | def points(self):
return _digital_swig.digital_constellation_points(self) | [
"def points(self):\n if self._points is None:\n _points = self.soma.points.tolist()\n for n in self.neurites:\n _points.extend(n.points.tolist())\n self._points = np.array(_points)\n\n return self._points",
"def points(self):\n return [self.poin... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
s_points(self) > gr_complex_vector Returns the vector of points in this constellation. Raise error if dimensionality is not one. | def s_points(self):
return _digital_swig.digital_constellation_s_points(self) | [
"def points(self):\n if self._points is None:\n _points = self.soma.points.tolist()\n for n in self.neurites:\n _points.extend(n.points.tolist())\n self._points = np.array(_points)\n\n return self._points",
"def soma_points(self):\n db = self.da... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
decision_maker_v(self, gr_complex_vector sample) > unsigned int Takes a vector rather than a pointer. Better for SWIG wrapping. | def decision_maker_v(self, *args, **kwargs):
return _digital_swig.digital_constellation_decision_maker_v(self, *args, **kwargs) | [
"def Vector(*args, **kwargs): # real signature unknown\r\n pass",
"def make_sparse_vector(*args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args):\n this = _digital_swig.new_unsigned_int_vector(*args)\n try: self.this.append(this)\n except... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
map_to_points_v(self, unsigned int value) > gr_complex_vector | def map_to_points_v(self, *args, **kwargs):
return _digital_swig.digital_constellation_map_to_points_v(self, *args, **kwargs) | [
"def pointvectors(self):\n return np.stack([self.x, self.y], axis=-1)",
"def project_complex_point_to_canvas(self, z):\n return self.project_point_to_canvas([ z.real, z.imag ])",
"def point_at(self, u, v):\n point = self.rhino_surface.PointAt(u, v)\n return point_to_compas(point)",
"de... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
bits_per_symbol(self) > unsigned int | def bits_per_symbol(self):
return _digital_swig.digital_constellation_bits_per_symbol(self) | [
"def bitness():\n pass",
"def __int__(self):\n return self.bits",
"def __len__(self):\n return self._bits",
"def bits_per_register(cls) -> int:\n return cls._bits_per_register",
"def max_symbols (self):\n \n raise NotImplementedError",
"def symbol_type(self):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
apply_pre_diff_code(self) > bool Whether to apply an encoding before doing differential encoding. (e.g. gray coding) | def apply_pre_diff_code(self):
return _digital_swig.digital_constellation_apply_pre_diff_code(self) | [
"def pre_encode(fxn):\n unclaimed[fxn] = 'pre_encode'\n return fxn",
"def preprocessing():",
"def recode(self, new_encoding: dict):\n self.edges = set(map(lambda edge: edge.recode(self.states_encoding, new_encoding), self.edges))",
"def apply_precoders(self, precoders, ref_sig, num_data_symb):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
set_pre_diff_code(self, bool a) Whether to apply an encoding before doing differential encoding. (e.g. gray coding) | def set_pre_diff_code(self, *args, **kwargs):
return _digital_swig.digital_constellation_set_pre_diff_code(self, *args, **kwargs) | [
"def recode(self, new_encoding: dict):\n self.edges = set(map(lambda edge: edge.recode(self.states_encoding, new_encoding), self.edges))",
"def pre_encode(fxn):\n unclaimed[fxn] = 'pre_encode'\n return fxn",
"def set_precommit(c):\n c.run(\n 'cp githooks/pre-commit .git/hooks/pre-commit '... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
pre_diff_code(self) > unsigned_int_vector Returns the encoding to apply before differential encoding. | def pre_diff_code(self):
return _digital_swig.digital_constellation_pre_diff_code(self) | [
"def get_coded_string(self):\n if not self._coded_string:\n self._coded_string = self._encode_string(self._input_string) \n return self._coded_string",
"def pre_encode(fxn):\n unclaimed[fxn] = 'pre_encode'\n return fxn",
"def encoding_table(self):\n return self._character_t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
rotational_symmetry(self) > unsigned int Returns the order of rotational symmetry. | def rotational_symmetry(self):
return _digital_swig.digital_constellation_rotational_symmetry(self) | [
"def get_symmetry_number(self):\n if self.symmetry_number < 1:\n cython.declare(resonanceHybrid=Molecule, maxSymmetryNum=cython.short)\n resonance_hybrid = self.get_resonance_hybrid()\n try:\n self.symmetry_number = resonance_hybrid.get_symmetry_number()\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
dimensionality(self) > unsigned int Returns the number of complex numbers in a single symbol. | def dimensionality(self):
return _digital_swig.digital_constellation_dimensionality(self) | [
"def cardinality(self):\n from sage.rings.all import ZZ\n return ZZ.prod(self.degrees())",
"def _is_complex(input):\n return input.shape[-1] == 2",
"def complex_type(self):\n return self._complex_type",
"def complex_frequencies(self):\n return self._get_frequencies(cplx=... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_constellation_calcdist_sptr __init__(self, p) > digital_constellation_calcdist_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_constellation_calcdist_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_diff_phasor_cc_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _digital_swig.new_digital_pfb_clock_sync_ccf_sptr(*args)\n try: self.this.append(this)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
map_to_points_v(self, unsigned int value) > gr_complex_vector | def map_to_points_v(self, *args, **kwargs):
return _digital_swig.digital_constellation_calcdist_sptr_map_to_points_v(self, *args, **kwargs) | [
"def pointvectors(self):\n return np.stack([self.x, self.y], axis=-1)",
"def project_complex_point_to_canvas(self, z):\n return self.project_point_to_canvas([ z.real, z.imag ])",
"def point_at(self, u, v):\n point = self.rhino_surface.PointAt(u, v)\n return point_to_compas(point)",
"de... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |