:param symbol: Bit to modulate
        :return: Modulated signal in baseband
        :rtype: Complex
180240
def main(self, symbol):
        
        if symbol:
            phase_step = self.sensitivity_pos
        else:
            phase_step = self.sensitivity_neg

        cout = self.nco.main(phase_step)
        return cout
302910
def tone(self):
        
        if self.pwm_device.pin.frequency is None:
            return None
        else:
            return Tone.from_frequency(self.pwm_device.pin.frequency)
289798
def __decodeModifier(self, keyCode):
        
        keyName = self.lookup_string(keyCode, False, False, False)
        if keyName in MODIFIERS:
            return keyName

        return None
1233083
def delta(self, above):
        
        return self.activation.delta(self.incoming, self.outgoing, above)
602810
def _call(self, x):
        """"""
        if self.impl == 'pywt':
            coeffs = pywt.wavedecn(
                x, wavelet=self.pywt_wavelet, level=self.nlevels,
                mode=self.pywt_pad_mode, axes=self.axes)
            return pywt.ravel_coeffs(coeffs, axes=self.axes)[0]
        else:
            raise RuntimeError("bad `impl` '{}'".format(self.impl))
800536
def _ret8(ins):
    
    output = _8bit_oper(ins.quad[1])
    output.append('#pragma opt require a')
    output.append('jp %s' % str(ins.quad[2]))
    return output
1037201
def main(self, c):
        
        phase = Sfix(0.0, 0, -17)

        abs, _, angle = self.core.main(c.real, c.imag, phase)

        # get rid of CORDIC gain and extra bits
        self.y_abs = abs * (1.0 / 1.646760)
        self.y_angle = angle
        return self.y_abs, self.y_angle
685445
def get_op_symbol(obj, fmt='%s', symbol_data=symbol_data, type=type):
    
    return fmt % symbol_data[type(obj)]
1296908
def filter(self, s, method='exact', order=None):
        
        if self._modulation_first:
            return super(Modulation, self).filter(s, method='exact')
        else:
            # The dot product with each modulated kernel is equivalent to the
            # GFT, as for the localization and the IGFT.
            y = np.empty((self.G.n_vertices, self.G.n_vertices))
            for i in range(self.G.n_vertices):
                x = s * self._kernels.localize(i)
                y[i] = np.sqrt(self.G.n_vertices) * self.G.gft(x)
            return y
1235989
def enable_signals(self):
        '''
        
        '''
        signal_dict = self.settings[self.signal_key] or {}
        for i in signal_dict.keys():
            sig_module, signal_class = self.import_class_from_path(i)
            for j in signal_dict[i]:
                recv_module, recv_coro = self.import_class_from_path(j)
                signal_class.register(recv_coro)
1167511
def op_symbol(op_node):
    """"""
    ops = {
        # TODO(nicholasbishop): other unary ops
        ast.UAdd: '+',
        ast.USub: '-',

        # TODO(nicholasbishop): FloorDiv, Pow, LShift, RShift,
        # BitOr, BitXor, BitAnd
        ast.Add: '+',
        ast.Sub: '-',
        ast.Mult: '*',
        ast.Div: '/',
        ast.Mod: '%',

        # Comparison
        ast.Eq: '=',
        ast.NotEq: '!=',
        ast.Lt: '<',
        ast.LtE: '<=',
        ast.Gt: '>',
        ast.GtE: '>=',
    }
    # Python3 matrix multiplication
    if hasattr(ast, 'MatMult'):
        ops[ast.MatMult] = '*'
    return ops[op_node.__class__]
1104614
def _handle_signals(self):
        
        signal.signal(signal.SIGTERM, signal.SIG_DFL)
        signal.signal(signal.SIGINT, signal.SIG_IGN)
816741
def get_symbol(units) -> str:
    
    if kind(units) == "energy":
        d = {}
        d["nm"] = r"\lambda"
        d["wn"] = r"\bar\nu"
        d["eV"] = r"\hslash\omega"
        d["Hz"] = r"f"
        d["THz"] = r"f"
        d["GHz"] = r"f"
        return d.get(units, "E")
    elif kind(units) == "delay":
        return r"\tau"
    elif kind(units) == "fluence":
        return r"\mathcal{F}"
    elif kind(units) == "pulse_width":
        return r"\sigma"
    elif kind(units) == "temperature":
        return r"T"
    else:
        return kind(units)
124443
def symbol(self) -> str:
        
        symbol = piece_symbol(self.piece_type)
        return symbol.upper() if self.color else symbol
978889
def _receive_signal(self, progress_subscript):
        

        self.progress = self._estimate_progress()
        self.updateProgress.emit(int(self.progress))
1051220
def get_by_symbol(self, symbol: str) -> Commodity:
        
        assert isinstance(symbol, str)

        query = (
            self.currencies_query
                .filter(Commodity.mnemonic == symbol)
        )
        return query.one()
622897
def get_over_current(self, channel):
        '''
        '''
        try:
            bit = self._ch_map[channel]['GPIOOC']['bit']
        except KeyError:
            raise ValueError('get_over_current() not supported for channel %s' % channel)
        return not self._get_power_gpio_value(bit)