query stringlengths 9 9.05k | document stringlengths 10 222k | negatives listlengths 19 20 | metadata dict |
|---|---|---|---|
constellation_calcdist(gr_complex_vector constellation, unsigned_int_vector pre_diff_code, unsigned int rotational_symmetry, unsigned int dimensionality) > digital_constellation_calcdist_sptr Calculate Euclidian distance for any constellation Constellation which calculates the distance to each point in the constellatio... | def constellation_calcdist(*args, **kwargs):
return _digital_swig.constellation_calcdist(*args, **kwargs) | [
"def calculate_particle_critical_diameter(mean_molecular_speed,\n diffusion_constant,\n accommodation_coefficient):\n\n return 8 * diffusion_constant / (\n accommodation_coefficient * mean_molecular_speed * dfl[\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_constellation_rect_sptr __init__(self, p) > digital_constellation_rect_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_constellation_rect_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, ptOrigin, connection):\n self.ptOrigin = ptOrigin\n self.connection = connection\n self.leftBound = 0\n self.leftTop = None\n self.leftBottom = None\n self.rightBound = connection.rightBound\n self.rightTop = None\n self.rightBot... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
constellation_rect(gr_complex_vector constellation, unsigned_int_vector pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors) > digital_constellation_rect_sptr | def constellation_rect(*args, **kwargs):
return _digital_swig.constellation_rect(*args, **kwargs) | [
"def rc2rect(self, r, c):\n return [(c - 1) * self._block_width, (r - 1) * self._block_height,\n c * self._block_width, r * self._block_height]",
"def concrete_rectangular_section(\n b: float,\n d: float,\n dia_top: float,\n n_top: int,\n dia_bot: float,\n n_bot: int,\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_constellation_psk_sptr __init__(self, p) > digital_constellation_psk_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_constellation_psk_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _wali.new_KeyPair(*args)\n try: self.this.append(this)\n 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",
"d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
constellation_psk(gr_complex_vector constellation, unsigned_int_vector pre_diff_code, unsigned int n_sectors) > digital_constellation_psk_sptr digital_constellation_psk Constellation space is divided into pie slices sectors. Each slice is associated with the nearest constellation point. Works well for PSK but nothing e... | def constellation_psk(*args, **kwargs):
return _digital_swig.constellation_psk(*args, **kwargs) | [
"def pks_peptide(peptide_chain):\r\n\r\n\tlargo_cadena = len(peptide_chain)\r\n\tpk = []\r\n\tion = []\r\n\tionizado = []\r\n\r\n\r\n\tfor aa in range(largo_cadena):\r\n\t\tif aa == 0:\r\n\t\t\tamino_terminal = peptide_chain[aa]\r\n\t\t\tpk.append(aminoacidos[amino_terminal][2])\r\n\t\t\tion.append(\"basic\")\r\n\t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_constellation_bpsk_sptr __init__(self, p) > digital_constellation_bpsk_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_constellation_bpsk_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_additive_scrambler_bb_sptr(*args)\n try: self.this.append(this)\n ... | {
"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_bpsk_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"
]
]
}
} |
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_bpsk_sptr_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"
]
]
}
} |
constellation_bpsk() > digital_constellation_bpsk_sptr Digital constellation for BPSK. | def constellation_bpsk():
return _digital_swig.constellation_bpsk() | [
"def bpsk(input_bits, noise):\n modulator = Modulator()\n demodulator = Demodulator()\n channel = Channel()\n signal = modulator.make_bpsk_mod(input_bits)\n\n signal = channel.send_signal(signal, noise)\n\n result_bits = demodulator.make_bpsk_demod(signal, channel)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_constellation_qpsk_sptr __init__(self, p) > digital_constellation_qpsk_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_constellation_qpsk_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def construct_sk(public_key):\n point = public_key.pointQ\n x = int(point.x).to_bytes(PUBLIC_KEY_SIZE // 2, 'big')\n y = int(point.y).to_bytes(PUBLIC_KEY_SIZE // 2, 'big')\n sk = x + y\n return H(sk)",
"def __init__(self, *args):\n this = _digital_swig.new_digital_scramb... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
bits_per_symbol(self) > unsigned int | def bits_per_symbol(self):
return _digital_swig.digital_constellation_qpsk_sptr_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"
]
]
}
} |
constellation_qpsk() > digital_constellation_qpsk_sptr Digital constellation for QPSK. | def constellation_qpsk():
return _digital_swig.constellation_qpsk() | [
"def pc_nproduced(self):\n return _radio_astro_swig.dedispersion_sptr_pc_nproduced(self)",
"def pc_nproduced(self):\n return _OFDM_Cyclic_Prefix_swig.vamsi_OFDMCP_ff_sptr_pc_nproduced(self)",
"def qpsk(input_bits, noise):\n modulator = Modulator()\n demodulator = Demodulator()\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_constellation_dqpsk_sptr __init__(self, p) > digital_constellation_dqpsk_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_constellation_dqpsk_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n _itkOptimizerParametersPython.itkOptimizerParametersD_swiginit(self, _itkOptimizerParametersPython.new_itkOptimizerParametersD(*args))",
"def __init__(self, *args):\n _itkOptimizerParametersPython.itkOptimizerParametersHelperD_swiginit(self, _itkOptimizerParametersPytho... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
constellation_dqpsk() > digital_constellation_dqpsk_sptr Digital constellation for DQPSK. | def constellation_dqpsk():
return _digital_swig.constellation_dqpsk() | [
"def pc_nproduced(self):\n return _radio_astro_swig.dedispersion_sptr_pc_nproduced(self)",
"def pDpk(self, x, k):\n k = np.array(k)\n return 2*c*c*k/(self._omega*self._omega)",
"def GradSimplex3DP(a, b, c, id, jd, kd):\n\n fa = JacobiP(a, 0, 0, id).reshape(len(a),1)\n dfa = GradJacob... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_constellation_8psk_sptr __init__(self, p) > digital_constellation_8psk_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_constellation_8psk_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _wali.new_KeyPair(*args)\n try: self.this.append(this)\n 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",
"d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
constellation_8psk() > digital_constellation_8psk_sptr Digital constellation for 8PSK. | def constellation_8psk():
return _digital_swig.constellation_8psk() | [
"def psk8(input_bits, noise):\n modulator = Modulator()\n demodulator = Demodulator()\n channel = Channel()\n signal = modulator.make_8psk_mod(input_bits)\n\n signal = channel.send_signal(signal, noise)\n\n result_bits = demodulator.make_8psk_demod(signal, channel)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_constellation_decoder_cb_sptr __init__(self, p) > digital_constellation_decoder_cb_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_constellation_decoder_cb_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_diff_decoder_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 ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
constellation_decoder_cb(digital_constellation_sptr constellation) > digital_constellation_decoder_cb_sptr Constellation Decoder. | def constellation_decoder_cb(*args, **kwargs):
return _digital_swig.constellation_decoder_cb(*args, **kwargs) | [
"def decode_func():\n dec_outputs, _, dec_lengths = contrib_seq2seq.dynamic_decode(\n decoder=self.decoder(\n embeddings=embeddings,\n inputs=inputs,\n inputs_length=inputs_length,\n hiddens=hiddens,\n hiddens_length=hiddens_length,\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_constellation_receiver_cb_sptr __init__(self, p) > digital_constellation_receiver_cb_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_constellation_receiver_cb_sptr(*args)
try: self.this.append(this)
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 except: self.this = this",
"def __init__(self):\n this = _coin.new_SoCallback()\n try:\n self.this.append(this)\n except __builtin__.Exce... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
constellation_receiver_cb(digital_constellation_sptr constellation, float loop_bw, float fmin, float fmax) > digital_constellation_receiver_cb_sptr This block takes care of receiving generic modulated signals through phase, frequency, and symbol synchronization. This block takes care of receiving generic modulated sign... | def constellation_receiver_cb(*args, **kwargs):
return _digital_swig.constellation_receiver_cb(*args, **kwargs) | [
"def set_loop_bandwidth(self, *args, **kwargs):\n return _digital_swig.digital_pfb_clock_sync_ccf_sptr_set_loop_bandwidth(self, *args, **kwargs)",
"def receiver_block(self):\n\t\t\n\t\t# first create a list of received signals\n\t\treceived_signals = list()\n\t\tfor src in self.sources:\n\t\t\tif (isinstan... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_correlate_access_code_bb_sptr __init__(self, p) > digital_correlate_access_code_bb_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_correlate_access_code_bb_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_correlate_access_code_tag_bb_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(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
set_access_code(self, string access_code) > bool | def set_access_code(self, *args, **kwargs):
return _digital_swig.digital_correlate_access_code_bb_sptr_set_access_code(self, *args, **kwargs) | [
"def set_access_code(self, *args, **kwargs):\n return _digital_swig.digital_correlate_access_code_tag_bb_sptr_set_access_code(self, *args, **kwargs)",
"def set_code(self, code):\n self._code = code",
"def setCode(self, c):\n\t\t\n\t\tself.code = c",
"def setCode(self, code):\n if not util... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
correlate_access_code_bb(string access_code, int threshold) > digital_correlate_access_code_bb_sptr Examine input for specified access code, one bit at a time. | def correlate_access_code_bb(*args, **kwargs):
return _digital_swig.correlate_access_code_bb(*args, **kwargs) | [
"def correlate_access_code_tag_bb(*args, **kwargs):\n return _digital_swig.correlate_access_code_tag_bb(*args, **kwargs)",
"def set_access_code(self, *args, **kwargs):\n return _digital_swig.digital_correlate_access_code_tag_bb_sptr_set_access_code(self, *args, **kwargs)",
"def test_03_bandpass_calibrat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_correlate_access_code_tag_bb_sptr __init__(self, p) > digital_correlate_access_code_tag_bb_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_correlate_access_code_tag_bb_sptr(*args)
try: self.this.append(this)
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 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 exc... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
set_access_code(self, string access_code) > bool | def set_access_code(self, *args, **kwargs):
return _digital_swig.digital_correlate_access_code_tag_bb_sptr_set_access_code(self, *args, **kwargs) | [
"def set_code(self, code):\n self._code = code",
"def setCode(self, c):\n\t\t\n\t\tself.code = c",
"def setCode(self, code):\n if not utils.is_valid_code(code)[0]:\n raise ValueError, utils.mapping(_(\"Invalid code: $1\"),(str(code),))\n self.__code = code",
"def UseCode(code):... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
correlate_access_code_tag_bb(string access_code, int threshold, string tag_name) > digital_correlate_access_code_tag_bb_sptr Examine input for specified access code, one bit at a time. | def correlate_access_code_tag_bb(*args, **kwargs):
return _digital_swig.correlate_access_code_tag_bb(*args, **kwargs) | [
"def set_access_code(self, *args, **kwargs):\n return _digital_swig.digital_correlate_access_code_tag_bb_sptr_set_access_code(self, *args, **kwargs)",
"def __init__(self, *args):\n this = _digital_swig.new_digital_correlate_access_code_tag_bb_sptr(*args)\n try: self.this.append(this)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_costas_loop_cc_sptr __init__(self, p) > digital_costas_loop_cc_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_costas_loop_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_scrambler_bb_sptr(*args)\n try: self.this.append(this)\n exc... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
costas_loop_cc(float loop_bw, int order) > digital_costas_loop_cc_sptr Carrier tracking PLL for QPSK | def costas_loop_cc(*args, **kwargs):
return _digital_swig.costas_loop_cc(*args, **kwargs) | [
"def set_loop_bandwidth(self, *args, **kwargs):\n return _digital_swig.digital_pfb_clock_sync_ccf_sptr_set_loop_bandwidth(self, *args, **kwargs)",
"def set_loop_bandwidth(self, *args, **kwargs):\n return _digital_swig.digital_pfb_clock_sync_fff_sptr_set_loop_bandwidth(self, *args, **kwargs)",
"def... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_cpmmod_bc_sptr __init__(self, p) > digital_cpmmod_bc_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_cpmmod_bc_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_chunks_to_symbols_bc_sptr(*args)\n try: self.this.append(this)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
primitive_connect(self, gr_basic_block_sptr block) primitive_connect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, int dst_port) | def primitive_connect(self, *args):
return _digital_swig.digital_cpmmod_bc_sptr_primitive_connect(self, *args) | [
"def connect_wire( self, dest=None, src=None ):\n\n self._connect_signal( src, dest ) # expects the src first",
"def _connect_signal( self, left_port, right_port ):\n\n # Can't connect a port to itself!\n assert left_port != right_port\n # Create the connection\n connection_edge = ConnectionEdge(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
primitive_disconnect(self, gr_basic_block_sptr block) primitive_disconnect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, int dst_port) | def primitive_disconnect(self, *args):
return _digital_swig.digital_cpmmod_bc_sptr_primitive_disconnect(self, *args) | [
"def disconnect(self, device):",
"def disconnect(self, *args) -> \"void\":\n return _coin.SoField_disconnect(self, *args)",
"def l2cap_disconnect(self, conn_handle: memoryview, cid: memoryview, /) -> None:",
"def disconnect(self, endpoint):\n raise NotImplementedError",
"def test_DisconnectNod... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
cpmmod_bc(int type, float h, unsigned int samples_per_sym, unsigned int L, double beta = 0.3) > digital_cpmmod_bc_sptr Generic CPM modulator. | def cpmmod_bc(*args, **kwargs):
return _digital_swig.cpmmod_bc(*args, **kwargs) | [
"def update_bc(\n betas,\n ses,\n err_corr,\n C,\n M,\n delta_m,\n bc,\n scales,\n Theta_0_inv,\n iteration,\n annot_len,\n annot_vec,\n annot_map,\n Vjm_scale,\n):\n\n for c in range(1, C):\n count = 0\n mu_lhs = 0\n var_q = 0\n mu_rhs = 0 * ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
update_crc32(unsigned int crc, string buf) > unsigned int update running CRC32 Update a running CRC with the bytes buf[0..len1] The CRC should be initialized to all 1's, and the transmitted value is the 1's complement of the final running CRC. The resulting CRC should be transmitted in big endian order. | def update_crc32(*args, **kwargs):
return _digital_swig.update_crc32(*args, **kwargs) | [
"def crc32(self, val):\n\t\treturn binascii.crc32(str(self)+str(self.getCoord()), val)",
"def calc_crc32(data):\n return binascii.crc32(data) & 0xFFFFFFFF",
"def CRC32data(data):\n from binascii import crc32\n buf = (crc32(data) & 0xFFFFFFFF)\n return \"{:08X}\".format(buf)",
"def crc32_hash(value... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_descrambler_bb_sptr __init__(self, p) > digital_descrambler_bb_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_descrambler_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_additive_scrambler_bb_sptr(*args)\n try: self.this.append(this)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
descrambler_bb(int mask, int seed, int len) > digital_descrambler_bb_sptr Descramble 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. | def descrambler_bb(*args, **kwargs):
return _digital_swig.descrambler_bb(*args, **kwargs) | [
"def scrambler_bb(*args, **kwargs):\n return _digital_swig.scrambler_bb(*args, **kwargs)",
"def bpsk(input_bits, noise):\n modulator = Modulator()\n demodulator = Demodulator()\n channel = Channel()\n signal = modulator.make_bpsk_mod(input_bits)\n\n signal = channel.send_signal... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_diff_decoder_bb_sptr __init__(self, p) > digital_diff_decoder_bb_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_diff_decoder_bb_sptr(*args)
try: self.this.append(this)
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 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 ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
diff_decoder_bb(unsigned int modulus) > digital_diff_decoder_bb_sptr y[0] = (x[0] x[1]) % M Uses current and previous symbols and the alphabet modulus to perform differential decoding. | def diff_decoder_bb(*args, **kwargs):
return _digital_swig.diff_decoder_bb(*args, **kwargs) | [
"def diff_encoder_bb(*args, **kwargs):\n return _digital_swig.diff_encoder_bb(*args, **kwargs)",
"def decode(self, y):\n assert(y.size == self.p.n)\n # Setup!\n beta = np.zeros(self.p.M * self.p.L) # beta_0 = 0\n z = y # z_0 = y\n s = beta + self.Ay(z)\n tau_sq = np.do... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_diff_encoder_bb_sptr __init__(self, p) > digital_diff_encoder_bb_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_diff_encoder_bb_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_diff_decoder_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 ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
diff_encoder_bb(unsigned int modulus) > digital_diff_encoder_bb_sptr y[0] = (x[0] + y[1]) % M Uses current and previous symbols and the alphabet modulus to perform differential encoding. | def diff_encoder_bb(*args, **kwargs):
return _digital_swig.diff_encoder_bb(*args, **kwargs) | [
"def diff_decoder_bb(*args, **kwargs):\n return _digital_swig.diff_decoder_bb(*args, **kwargs)",
"def encB(self, enc, m1=1, m2=1):\n print('Moving '+str((enc/18))+ ' rotations(s) backwards')\n enc_tgt(m1, m2, enc)\n bwd()\n time.sleep(1 * (enc / 18)+.4)",
"def decrypt_key(e1, modulu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_diff_phasor_cc_sptr __init__(self, p) > digital_diff_phasor_cc_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_diff_phasor_cc_sptr(*args)
try: self.this.append(this)
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 except: self.this = this",
"def __init__(self, *args):\n this = _digital_swig.new_digital_diff_decoder_bb_sptr(*args)\n try: self.this.append(this)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_fll_band_edge_cc_sptr __init__(self, p) > digital_fll_band_edge_cc_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_fll_band_edge_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_pfb_clock_sync_ccf_sptr(*args)\n try: self.this.append(this)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
set_samples_per_symbol(self, float sps) Set the number of samples per symbol. Set's the number of samples per symbol the system should use. This value is uesd to calculate the filter taps and will force a recalculation. | def set_samples_per_symbol(self, *args, **kwargs):
return _digital_swig.digital_fll_band_edge_cc_sptr_set_samples_per_symbol(self, *args, **kwargs) | [
"def set_sample_number(self):\r\n self.n_samples = self.exprs.shape[0]",
"def change_sampling_rate(self, sampling_rate):\n\n self.sampling_rate = sampling_rate",
"def SetNumberOfSpatialSamples(self, num: 'unsigned int') -> \"void\":\n return _itkMutualInformationImageToImageMetricPython.itk... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
set_rolloff(self, float rolloff) Set the rolloff factor of the shaping filter. This sets the rolloff factor that is used in the pulse shaping filter and is used to calculate the filter taps. Changing this will force a recalculation of the filter taps. This should be the same value that is used in the transmitter's puls... | def set_rolloff(self, *args, **kwargs):
return _digital_swig.digital_fll_band_edge_cc_sptr_set_rolloff(self, *args, **kwargs) | [
"def rolloff_curvefit(self, angles, rolloff):\n\n return curve_fit(self.rolloff_polynomial, angles, rolloff)",
"def rolloff(self):\n absSpectrum = abs(self)\n spectralSum = numpy.sum(absSpectrum)\n\n rolloffSum = 0\n rolloffIndex = 0\n for i in range(0, len(self)):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
set_filter_size(self, int filter_size) Set the number of taps in the filter. This sets the number of taps in the bandedge filters. Setting this will force a recalculation of the filter taps. This should be about the same number of taps used in the transmitter's shaping filter and also not very large. A large number of ... | def set_filter_size(self, *args, **kwargs):
return _digital_swig.digital_fll_band_edge_cc_sptr_set_filter_size(self, *args, **kwargs) | [
"def smooth(self,size=10):\n from scipy.ndimage import median_filter\n self.n = median_filter(self.n,size)\n self.k = median_filter(self.k,size)",
"def features_size(self, features_size):\n\n self._features_size = features_size",
"def sampled_frame_size_test(self, sampled_frame_size_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get_samples_per_symbol(self) > float Returns the number of sampler per symbol used for the filter. | def get_samples_per_symbol(self):
return _digital_swig.digital_fll_band_edge_cc_sptr_get_samples_per_symbol(self) | [
"def sample_frequency(self):\n return self._sample_frequency",
"def n_profile_samples(self):\n return self.__n_profile_samples",
"def packet_get_samples_per_frame(cls, data: bytes) -> int:\n return _lib.opus_packet_get_samples_per_frame(data, cls.SAMPLING_RATE)",
"def getSamplingRate(self... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get_rolloff(self) > float Returns the rolloff factor used for the filter. | def get_rolloff(self):
return _digital_swig.digital_fll_band_edge_cc_sptr_get_rolloff(self) | [
"def rolloff(self):\n absSpectrum = abs(self)\n spectralSum = numpy.sum(absSpectrum)\n\n rolloffSum = 0\n rolloffIndex = 0\n for i in range(0, len(self)):\n rolloffSum = rolloffSum + absSpectrum[i]\n if rolloffSum > (0.85 * spectralSum):\n roll... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get_filter_size(self) > int Returns the number of taps of the filter. | def get_filter_size(self):
return _digital_swig.digital_fll_band_edge_cc_sptr_get_filter_size(self) | [
"def size(self) -> \"unsigned int\":\n return _coin.SbFifo_size(self)",
"def input_filters(self) -> int:\n return self.__input_filters",
"def incoming_spike_buffer_size(self):\n return self.__incoming_spike_buffer_size",
"def get_size():\n l = self.linfeats.get_size()\n retu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
print_taps(self) Print the taps to screen. | def print_taps(self):
return _digital_swig.digital_fll_band_edge_cc_sptr_print_taps(self) | [
"def print_tiles(self, tiles_to_print):\r\n for cur_tile in tiles_to_print:\r\n print(cur_tile)",
"def print(self, *args):\n print(*args, file=self.dump_file)",
"def print_board(self):\n for cell in self.board:\n print(\"current step: {}, ladder top: {}, snake_tail: {}... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
fll_band_edge_cc(float samps_per_sym, float rolloff, int filter_size, float bandwidth) > digital_fll_band_edge_cc_sptr Frequency Lock Loop using bandedge filters. The frequency lock loop derives a bandedge filter that covers the upper and lower bandwidths of a digitallymodulated signal. The bandwidth range is determine... | def fll_band_edge_cc(*args, **kwargs):
return _digital_swig.fll_band_edge_cc(*args, **kwargs) | [
"def set_loop_bandwidth(self, *args, **kwargs):\n return _digital_swig.digital_pfb_clock_sync_ccf_sptr_set_loop_bandwidth(self, *args, **kwargs)",
"def set_loop_bandwidth(self, *args, **kwargs):\n return _digital_swig.digital_pfb_clock_sync_fff_sptr_set_loop_bandwidth(self, *args, **kwargs)",
"def... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_framer_sink_1_sptr __init__(self, p) > digital_framer_sink_1_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_framer_sink_1_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_packet_sink_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, sink):\n\n self.sink = sink",
"def __init__(self, *args):\n this = _digital_swig.new_digital_simple_framer_sptr... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
framer_sink_1(gr_msg_queue_sptr target_queue) > digital_framer_sink_1_sptr Given a stream of bits and access_code flags, assemble packets. | def framer_sink_1(*args, **kwargs):
return _digital_swig.framer_sink_1(*args, **kwargs) | [
"def __init__(self, gain=None, samp_rate=None, ppm=None, arfcn=None, capture_id=None, udp_ports=[], max_timeslot=0, store_capture=True, verbose=False, band=None, rec_length=None, test=False, args=\"\"):\n\n gr.top_block.__init__(self, \"Gr-gsm Capture\")\n\n ###########################################... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_glfsr_source_b_sptr __init__(self, p) > digital_glfsr_source_b_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_glfsr_source_b_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_glfsr_source_f_sptr(*args)\n try: self.this.append(this)\n 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 exc... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
glfsr_source_b(int degree, bool repeat = True, int mask = 0, int seed = 1) > digital_glfsr_source_b_sptr Galois LFSR pseudorandom source. | def glfsr_source_b(*args, **kwargs):
return _digital_swig.glfsr_source_b(*args, **kwargs) | [
"def glfsr_source_f(*args, **kwargs):\n return _digital_swig.glfsr_source_f(*args, **kwargs)",
"def __init__(self, *args):\n this = _digital_swig.new_digital_glfsr_source_b_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_glfsr_source_f_sptr __init__(self, p) > digital_glfsr_source_f_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_glfsr_source_f_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_glfsr_source_b_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, src):\n self.src = src",
"def __init__(self, *args):\n this = _digital_swig.new_digital_scrambler_bb_sptr(*a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
glfsr_source_f(int degree, bool repeat = True, int mask = 0, int seed = 1) > digital_glfsr_source_f_sptr Galois LFSR pseudorandom source generating float outputs 1.0 1.0. | def glfsr_source_f(*args, **kwargs):
return _digital_swig.glfsr_source_f(*args, **kwargs) | [
"def glfsr_source_b(*args, **kwargs):\n return _digital_swig.glfsr_source_b(*args, **kwargs)",
"def sample_exponential(lambd: float) -> float:\n return -log(random.random()) / lambd",
"def gen_samples(f, duration, fs=44100):\n\n samples = (np.sin(2*np.pi*np.arange(fs*duration)*f/fs)).astype(np.float32)\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_gmskmod_bc_sptr __init__(self, p) > digital_gmskmod_bc_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_gmskmod_bc_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_chunks_to_symbols_bc_sptr(*args)\n try: self.this.append(this)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
primitive_connect(self, gr_basic_block_sptr block) primitive_connect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, int dst_port) | def primitive_connect(self, *args):
return _digital_swig.digital_gmskmod_bc_sptr_primitive_connect(self, *args) | [
"def connect_wire( self, dest=None, src=None ):\n\n self._connect_signal( src, dest ) # expects the src first",
"def _connect_signal( self, left_port, right_port ):\n\n # Can't connect a port to itself!\n assert left_port != right_port\n # Create the connection\n connection_edge = ConnectionEdge(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
primitive_disconnect(self, gr_basic_block_sptr block) primitive_disconnect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, int dst_port) | def primitive_disconnect(self, *args):
return _digital_swig.digital_gmskmod_bc_sptr_primitive_disconnect(self, *args) | [
"def disconnect(self, device):",
"def disconnect(self, *args) -> \"void\":\n return _coin.SoField_disconnect(self, *args)",
"def l2cap_disconnect(self, conn_handle: memoryview, cid: memoryview, /) -> None:",
"def disconnect(self, endpoint):\n raise NotImplementedError",
"def test_DisconnectNod... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
gmskmod_bc(unsigned int samples_per_sym = 2, double bt = 0.3, unsigned int L = 4) > digital_gmskmod_bc_sptr GMSK modulator. The input of this block are symbols from an Mary alphabet +/1, +/3, ..., +/(M1). Usually, M = 2 and therefore, the valid inputs are +/1. The modulator will silently accept any other inputs, though... | def gmskmod_bc(samples_per_sym = 2, bt = 0.3, L = 4):
return _digital_swig.gmskmod_bc(samples_per_sym, bt, L) | [
"def scrambler_bb(*args, **kwargs):\n return _digital_swig.scrambler_bb(*args, **kwargs)",
"def bpsk(input_bits, noise):\n modulator = Modulator()\n demodulator = Demodulator()\n channel = Channel()\n signal = modulator.make_bpsk_mod(input_bits)\n\n signal = channel.send_signal... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_kurtotic_equalizer_cc_sptr __init__(self, p) > digital_kurtotic_equalizer_cc_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_kurtotic_equalizer_cc_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, coeff):\n self.coeff = coeff",
"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, coefs_tup, setpoint_value, range_tup, integration_samples = 5, d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
kurtotic_equalizer_cc(int num_taps, float mu) > digital_kurtotic_equalizer_cc_sptr Implements a kurtosisbased adaptive equalizer on complex stream Y. Guo, J. Zhao, Y. Sun, "Sign kurtosis maximization based blind equalization algorithm," IEEE Conf. on Control, Automation, Robotics and Vision, Vol. 3, Dec. 2004, pp. 2052... | def kurtotic_equalizer_cc(*args, **kwargs):
return _digital_swig.kurtotic_equalizer_cc(*args, **kwargs) | [
"def kcdetect(data, sf, proba_thr, amp_thr, hypno, nrem_only, tmin, tmax,\n kc_min_amp, kc_max_amp, fmin=.5, fmax=4., delta_thr=.75,\n smoothing_s=20, spindles_thresh=2., range_spin_sec=20,\n min_distance_ms=500.):\n # Find if hypnogram is loaded :\n hyploaded = True if np.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_lms_dd_equalizer_cc_sptr __init__(self, p) > digital_lms_dd_equalizer_cc_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_lms_dd_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_diff_encoder_bb_sptr(*args)\n try: self.this.append(this)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
lms_dd_equalizer_cc(int num_taps, float mu, int sps, digital_constellation_sptr cnst) > digital_lms_dd_equalizer_cc_sptr LeastMeanSquare Decision Directed Equalizer (complex in/out) This block implements an LMSbased decisiondirected equalizer. It uses a set of weights, w, to correlate against the inputs, u, and a decis... | def lms_dd_equalizer_cc(*args, **kwargs):
return _digital_swig.lms_dd_equalizer_cc(*args, **kwargs) | [
"def expected_feedback_effort(controller: PenaltyController, sensory_noise_magnitude: cas.DM) -> cas.MX:\n n_tau = controller.controls[\"tau\"].cx_start.shape[0]\n n_q = controller.states[\"q\"].cx_start.shape[0]\n n_qdot = controller.states[\"qdot\"].cx_start.shape[0]\n n_stochastic = controller.stocha... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_map_bb_sptr __init__(self, p) > digital_map_bb_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_map_bb_sptr(*args)
try: self.this.append(this)
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 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 exc... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
map_bb(__dummy_3__ map) > digital_map_bb_sptr output[i] = map[input[i]] This block maps an incoming signal to the value in the map. The block expects that the incoming signal has a maximum value of len(map)1. > output[i] = map[input[i]] | def map_bb(*args, **kwargs):
return _digital_swig.map_bb(*args, **kwargs) | [
"def process_output(output_data, label_mapping):\n idx = np.argmax(output_data[0])\n\n return label_mapping[idx]",
"def after_map(self, map):",
"def calcMap(self, p):\n\n mapping = dict()\n for i in range(2 ** p):\n if isUniform(i, p):\n mapping[i] = i\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_mpsk_receiver_cc_sptr __init__(self, p) > digital_mpsk_receiver_cc_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_mpsk_receiver_cc_sptr(*args)
try: self.this.append(this)
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 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 e... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
modulation_order(self) > float Returns the modulation order (M) currently set. | def modulation_order(self):
return _digital_swig.digital_mpsk_receiver_cc_sptr_modulation_order(self) | [
"def calc_mod(self):\n if self.proficiency:\n self.mod = self.attribute.mod + 2\n else:\n self.mod = self.attribute.mod",
"def get_partialOrdering(self):\n return self.partialOrdering",
"def maximal_order(self):\n if self._maximal_order is None:\n sel... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
gain_mu(self) > float Returns mu gain factor. | def gain_mu(self):
return _digital_swig.digital_mpsk_receiver_cc_sptr_gain_mu(self) | [
"def get_mu(self):\n return self.mu",
"def gain(self, g):\n return self.normalize(0, 1, scale=g)",
"def process_gain(self):\n return 1",
"def mag_gain(self, gain=0x20):\n self._mag_gain = gain\n self.i2c.writeto_mem(self.ADDRESS_MAG, self.REGISTER_MAG_CRB_REG_M, self._mag_ga... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
gain_omega(self) > float Returns omega gain factor. | def gain_omega(self):
return _digital_swig.digital_mpsk_receiver_cc_sptr_gain_omega(self) | [
"def get_omega(self):\n return self.omega_",
"def angular_velocity(self):\r\n\r\n self.omega += self.angular_acceleration*self.dt\r\n return self.omega",
"def _set_gain(self, adjustment: int) -> int:\n return _lib.opus_decoder_ctl(self._state, CTL_SET_GAIN, adjustment)",
"def omega... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
gain_omega_rel(self) > float Returns the relative omega limit. | def gain_omega_rel(self):
return _digital_swig.digital_mpsk_receiver_cc_sptr_gain_omega_rel(self) | [
"def get_omega(self):\n return self.omega_",
"def wavelength_rel(self) -> float:\n wavelength_rel = (\n sc.h\n / np.sqrt(\n 2 * sc.m_e * sc.e * 1000 * self.voltage * (1 + (sc.e * 1000 * self.voltage) / (2 * sc.m_e * sc.c**2))\n )\n * (10**10... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
set_modulation_order(self, unsigned int M) Sets the modulation order (M) currently. | def set_modulation_order(self, *args, **kwargs):
return _digital_swig.digital_mpsk_receiver_cc_sptr_set_modulation_order(self, *args, **kwargs) | [
"def setOrder(order):\n ierr = c_int()\n lib.gmshModelMeshSetOrder(\n c_int(order),\n byref(ierr))\n if ierr.value != 0:\n raise ValueError(\n \"gmshModelMeshSetOrder returned non-zero error code: \",\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
set_omega(self, float omega) Sets value of omega and its min and max values. | def set_omega(self, *args, **kwargs):
return _digital_swig.digital_mpsk_receiver_cc_sptr_set_omega(self, *args, **kwargs) | [
"def set_omega(self, omega):\n np.copyto(self.omega_, omega)",
"def get_omega(self):\n return self.omega_",
"def omega(self):\n\n return xroms.omega(self.ds.u, self.ds.v)",
"def valuation(self, omega):\n raise NotImplementedError('Override in Place subtype')",
"def servo_set_acce... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
set_gain_mu(self, float gain_mu) Sets value for mu gain factor. | def set_gain_mu(self, *args, **kwargs):
return _digital_swig.digital_mpsk_receiver_cc_sptr_set_gain_mu(self, *args, **kwargs) | [
"def set_gain(self, gain):\n if gain is None:\n r = self.subdev.gain_range()\n gain = (r[0] + r[1])/2 # set gain to midpoint\n self.gain = gain\n return self.subdev.set_gain(gain)",
"def setGain(self, gain: 'float') -> \"void\":\n return _coin.SoAudi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
set_gain_omega(self, float gain_omega) Sets value for omega gain factor. | def set_gain_omega(self, *args, **kwargs):
return _digital_swig.digital_mpsk_receiver_cc_sptr_set_gain_omega(self, *args, **kwargs) | [
"def set_gain(self, gain):\n if gain is None:\n r = self.subdev.gain_range()\n gain = (r[0] + r[1])/2 # set gain to midpoint\n self.gain = gain\n return self.subdev.set_gain(gain)",
"def set_omega(self, omega):\n np.copyto(self.omega_, omega)",
"de... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
set_gain_omega_rel(self, float omega_rel) Sets the relative omega limit and resets omega min/max values. | def set_gain_omega_rel(self, *args, **kwargs):
return _digital_swig.digital_mpsk_receiver_cc_sptr_set_gain_omega_rel(self, *args, **kwargs) | [
"def set_omega(self, omega):\n np.copyto(self.omega_, omega)",
"def set_gain(self, gain):\n if gain is None:\n r = self.subdev.gain_range()\n gain = (r[0] + r[1])/2 # set gain to midpoint\n self.gain = gain\n return self.subdev.set_gain(gain)",
"de... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
mpsk_receiver_cc(unsigned int M, float theta, float loop_bw, float fmin, float fmax, float mu, float gain_mu, float omega, float gain_omega, float omega_rel) > digital_mpsk_receiver_cc_sptr This block takes care of receiving MPSK modulated signals through phase, frequency, and symbol synchronization. This block takes c... | def mpsk_receiver_cc(*args, **kwargs):
return _digital_swig.mpsk_receiver_cc(*args, **kwargs) | [
"def _my_cNR(self, DM_mass, NLO=None):\n if NLO is None:\n NLO = False\n\n ### Input parameters ####\n\n mpi = self.ip['mpi0']\n mp = self.ip['mproton']\n mn = self.ip['mneutron']\n mN = (mp+mn)/2\n\n alpha = 1/self.ip['alowinv']\n GF = self.ip['GF'... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_mpsk_snr_est_cc_sptr __init__(self, p) > digital_mpsk_snr_est_cc_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_mpsk_snr_est_cc_sptr(*args)
try: self.this.append(this)
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 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 e... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
tag_nsample(self) > int Return how many samples between SNR tags. | def tag_nsample(self):
return _digital_swig.digital_mpsk_snr_est_cc_sptr_tag_nsample(self) | [
"def n_samples(self):\n return len(self.sampler)",
"def num_samples(self):\r\n return self.snapshots[0].num_samples",
"def n_profile_samples(self):\n return self.__n_profile_samples",
"def n_samples(self):\n if self.isempty:\n return 0\n return utils.PrettyInt(len... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
set_tag_nsample(self, int n) Set the number of samples between SNR tags. | def set_tag_nsample(self, *args, **kwargs):
return _digital_swig.digital_mpsk_snr_est_cc_sptr_set_tag_nsample(self, *args, **kwargs) | [
"def nr_tags(self, nr_tags):\n\n self._nr_tags = nr_tags",
"def set_sample_number(self):\r\n self.n_samples = self.exprs.shape[0]",
"def set_sample(self, data, nid):\n self.sample = Sample(self, data, nid)",
"def resample(self, n):\n if n==len(self.times):\n return\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
mpsk_snr_est_cc(snr_est_type_t type, int tag_nsamples = 10000, double alpha = 0.001) > digital_mpsk_snr_est_cc_sptr A block for computing SNR of a signal. This block can be used to monitor and retrieve estimations of the signal SNR. It is designed to work in a flowgraph and passes all incoming data along to its output.... | def mpsk_snr_est_cc(*args, **kwargs):
return _digital_swig.mpsk_snr_est_cc(*args, **kwargs) | [
"def type(self):\n return _digital_swig.digital_probe_mpsk_snr_est_c_sptr_type(self)",
"def set_type(self, *args, **kwargs):\n return _digital_swig.digital_probe_mpsk_snr_est_c_sptr_set_type(self, *args, **kwargs)",
"def rmse_and_cramer_rao(SNR_range, N_samples_range, iteration, A, angles, locatio... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_ofdm_cyclic_prefixer_sptr __init__(self, p) > digital_ofdm_cyclic_prefixer_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_ofdm_cyclic_prefixer_sptr(*args)
try: self.this.append(this)
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 except: self.this = this",
"def __init__(self, prefix_set):\n self.prefix_set = prefix_set",
"def __init__(self, *args):\n this = _digital_swig.new_digit... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
ofdm_cyclic_prefixer(size_t input_size, size_t output_size) > digital_ofdm_cyclic_prefixer_sptr adds a cyclic prefix vector to an input size long ofdm symbol(vector) and converts vector to a stream output_size long. | def ofdm_cyclic_prefixer(*args, **kwargs):
return _digital_swig.ofdm_cyclic_prefixer(*args, **kwargs) | [
"def vamsi_OFDMCP_ff_make(*args, **kwargs):\n return _OFDM_Cyclic_Prefix_swig.vamsi_OFDMCP_ff_make(*args, **kwargs)",
"def gen_bin(length:int, prefix=\"\"):\n if length == 0:\n print(prefix)\n return\n\n gen_bin(length - 1, prefix + \"0\")\n gen_bin(length - 1, prefix + \"1\")",
"def mak... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_ofdm_frame_acquisition_sptr __init__(self, p) > digital_ofdm_frame_acquisition_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_ofdm_frame_acquisition_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, description, framecount=None):\n super().__init__(description)\n if 'parameters' in description:\n parameters = description['parameters']\n has_s2mm = parameters['C_INCLUDE_S2MM'] == '1'\n has_mm2s = parameters['C_INCLUDE_MM2S'] == '1'\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
ofdm_frame_acquisition(unsigned int occupied_carriers, unsigned int fft_length, unsigned int cplen, gr_complex_vector known_symbol, unsigned int max_fft_shift_len = 4) > digital_ofdm_frame_acquisition_sptr take a vector of complex constellation points in from an FFT and performs a correlation and equalization. This blo... | def ofdm_frame_acquisition(*args, **kwargs):
return _digital_swig.ofdm_frame_acquisition(*args, **kwargs) | [
"def __init__(self, fft_length, cp_length, occupied_tones, snr, ks, carrier_map_bin, nc_filter, logging=False):\n\n\tgr.hier_block2.__init__(self, \"ofdm_receiver\",\n\t\t\t\tgr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature\n gr.io_signature2(2, 2, gr.sizeof_gr_complex*o... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_ofdm_frame_sink_sptr __init__(self, p) > digital_ofdm_frame_sink_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_ofdm_frame_sink_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_framer_sink_1_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _digital_swig.new_digital_packet_sink_sptr(*args)\n try: self.this.append(this)\n excep... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
ofdm_frame_sink(gr_complex_vector sym_position, __dummy_0__ sym_value_out, gr_msg_queue_sptr target_queue, unsigned int occupied_tones, float phase_gain = 0.25, float freq_gain = 0.250.25/4) > digital_ofdm_frame_sink_sptr Takes an OFDM symbol in, demaps it into bits of 0's and 1's, packs them into packets, and sends to... | def ofdm_frame_sink(*args, **kwargs):
return _digital_swig.ofdm_frame_sink(*args, **kwargs) | [
"def ofdm_modulate(self, num_data_symb, freq_bin_data):\n min_pow = 1e-30\n time_ofdm_symbols = zeros((self.num_ant, num_data_symb * self.OFDMsymb_len), dtype=complex)\n for symb in range(num_data_symb):\n freq_data_start = symb * self.num_data_bins\n freq_data_end = freq_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_ofdm_insert_preamble_sptr __init__(self, p) > digital_ofdm_insert_preamble_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_ofdm_insert_preamble_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_chunks_to_symbols_if_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"
]
]
}
} |
__init__(self) > digital_ofdm_mapper_bcv_sptr __init__(self, p) > digital_ofdm_mapper_bcv_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_ofdm_mapper_bcv_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_map_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 except: s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
ofdm_mapper_bcv(gr_complex_vector constellation, unsigned int msgq_limit, unsigned int bits_per_symbol, unsigned int fft_length) > digital_ofdm_mapper_bcv_sptr take a stream of bytes in and map to a vector of complex constellation points suitable for IFFT input to be used in an ofdm modulator. Abstract class must be su... | def ofdm_mapper_bcv(*args, **kwargs):
return _digital_swig.ofdm_mapper_bcv(*args, **kwargs) | [
"def _convert_to_cbf_convention(self, xparm_filename):\n # Create a coordinate frame converter and extract other quantities\n cfc = coordinate_frame_converter(xparm_filename)\n self._detector_origin = cfc.get(\"detector_origin\")\n self._rotation_axis = cfc.get(\"rotation_axis\")\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_ofdm_sampler_sptr __init__(self, p) > digital_ofdm_sampler_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_ofdm_sampler_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_probe_density_b_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 ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
ofdm_sampler(unsigned int fft_length, unsigned int symbol_length, unsigned int timeout = 1000) > digital_ofdm_sampler_sptr does the rest of the OFDM stuff | def ofdm_sampler(*args, **kwargs):
return _digital_swig.ofdm_sampler(*args, **kwargs) | [
"def __init__(self, fft_length, cp_length, occupied_tones, snr, ks, carrier_map_bin, nc_filter, logging=False):\n\n\tgr.hier_block2.__init__(self, \"ofdm_receiver\",\n\t\t\t\tgr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature\n gr.io_signature2(2, 2, gr.sizeof_gr_complex*o... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_packet_sink_sptr __init__(self, p) > digital_packet_sink_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_packet_sink_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _digital_swig.new_digital_framer_sink_1_sptr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, sink):\n\n self.sink = sink",
"def __deref__(self):\n return _wmbus_swig.wmbus_packet_sink_sptr___deref__(sel... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
carrier_sensed(self) > bool return true if we detect carrier | def carrier_sensed(self):
return _digital_swig.digital_packet_sink_sptr_carrier_sensed(self) | [
"def is_cisco(self):\n # Initialize key variables\n value = False\n\n # Checks system object ID\n if self.enterprise_id == 9:\n value = True\n\n # Return\n return value",
"def is_saloon(self):\n return self.car_type == 'saloon'",
"def _carrier_supports... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > digital_pfb_clock_sync_ccf_sptr __init__(self, p) > digital_pfb_clock_sync_ccf_sptr | def __init__(self, *args):
this = _digital_swig.new_digital_pfb_clock_sync_ccf_sptr(*args)
try: self.this.append(this)
except: self.this = this | [
"def pfb_clock_sync_ccf(*args, **kwargs):\n return _digital_swig.pfb_clock_sync_ccf(*args, **kwargs)",
"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 ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get_taps(self) > __dummy_11__ Returns all of the taps of the matched filter | def get_taps(self):
return _digital_swig.digital_pfb_clock_sync_ccf_sptr_get_taps(self) | [
"def get_taps(self):\n return _digital_swig.digital_pfb_clock_sync_fff_sptr_get_taps(self)",
"def get_diff_taps(self):\n return _digital_swig.digital_pfb_clock_sync_fff_sptr_get_diff_taps(self)",
"def get_swaps(self, t: int) -> list:\n swaps = []\n for (i, j) in self._arcs:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get_diff_taps(self) > __dummy_11__ Returns all of the taps of the derivative filter | def get_diff_taps(self):
return _digital_swig.digital_pfb_clock_sync_ccf_sptr_get_diff_taps(self) | [
"def get_diff_taps(self):\n return _digital_swig.digital_pfb_clock_sync_fff_sptr_get_diff_taps(self)",
"def get_diff_channel_taps(self, *args, **kwargs):\n return _digital_swig.digital_pfb_clock_sync_fff_sptr_get_diff_channel_taps(self, *args, **kwargs)",
"def get_diff_channel_taps(self, *args, **... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get_channel_taps(self, int channel) > __dummy_4__ Returns the taps of the matched filter for a particular channel | def get_channel_taps(self, *args, **kwargs):
return _digital_swig.digital_pfb_clock_sync_ccf_sptr_get_channel_taps(self, *args, **kwargs) | [
"def get_channel_taps(self, *args, **kwargs):\n return _digital_swig.digital_pfb_clock_sync_fff_sptr_get_channel_taps(self, *args, **kwargs)",
"def get_diff_channel_taps(self, *args, **kwargs):\n return _digital_swig.digital_pfb_clock_sync_ccf_sptr_get_diff_channel_taps(self, *args, **kwargs)",
"d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get_diff_channel_taps(self, int channel) > __dummy_4__ Returns the taps in the derivative filter for a particular channel | def get_diff_channel_taps(self, *args, **kwargs):
return _digital_swig.digital_pfb_clock_sync_ccf_sptr_get_diff_channel_taps(self, *args, **kwargs) | [
"def get_diff_channel_taps(self, *args, **kwargs):\n return _digital_swig.digital_pfb_clock_sync_fff_sptr_get_diff_channel_taps(self, *args, **kwargs)",
"def get_channel_taps(self, *args, **kwargs):\n return _digital_swig.digital_pfb_clock_sync_ccf_sptr_get_channel_taps(self, *args, **kwargs)",
"d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get_taps_as_string(self) > string Return the taps as a formatted string for printing | def get_taps_as_string(self):
return _digital_swig.digital_pfb_clock_sync_ccf_sptr_get_taps_as_string(self) | [
"def get_taps_as_string(self):\n return _digital_swig.digital_pfb_clock_sync_fff_sptr_get_taps_as_string(self)",
"def get_diff_taps_as_string(self):\n return _digital_swig.digital_pfb_clock_sync_fff_sptr_get_diff_taps_as_string(self)",
"def get_diff_taps_as_string(self):\n return _digital_s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get_diff_taps_as_string(self) > string Return the derivative filter taps as a formatted string for printing | def get_diff_taps_as_string(self):
return _digital_swig.digital_pfb_clock_sync_ccf_sptr_get_diff_taps_as_string(self) | [
"def get_diff_taps_as_string(self):\n return _digital_swig.digital_pfb_clock_sync_fff_sptr_get_diff_taps_as_string(self)",
"def get_taps_as_string(self):\n return _digital_swig.digital_pfb_clock_sync_ccf_sptr_get_taps_as_string(self)",
"def get_taps_as_string(self):\n return _digital_swig.d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |