def _get_events(self): """Get all events. """ images = all_images(self.data_path) num_frames = len(images) input_ts = np.linspace(0, num_frames / self.input_fps, num_frames, dtype=np.float) base_frame = read_image(images[0]) logger.info('base frame shape: {}'.format(base_frame.shape)) height = base_frame.shape[0] width = base_frame.shape[1] emulator = EventEmulator(pos_thres=self.pos_thres, neg_thres=self.neg_thres) event_list = list() time_list = list() pos_list = list() # index of the first element at timestamp t. pos = 0 for idx in range(1, num_frames): new_frame = read_image(images[idx]) t_start = input_ts[idx - 1] t_end = input_ts[idx] tmp_events = emulator.generate_events(new_frame, t_start) if tmp_events is not None: event_list.append(tmp_events) pos_list.append(pos) time_list.append(t_end) # update pos pos += tmp_events.shape[0] if (idx + 1) % 20 == 0: logger.info("Image2Events processed {} frames".format( EngNumber(idx + 1))) event_arr = np.vstack(event_list) logger.info("generated {} events".format(EngNumber( event_arr.shape[0]))) return event_arr, time_list, pos_list, num_frames, height, width
def formKiCadFootprint(self): din = self.din trackWidth = self.w s = self.s n = self.n via_size = self.via_size_x x, y = self.getXYPositions() l = self.getLengths() widths = self.getWidths(l, trackWidth) heights = self.getHeights(widths) footprint = textwrap.dedent("""\ (module mohan (layer F.Cu) (tedit 5E1D9573) (fp_text reference REF** (at 0 0) (layer F.SilkS) (effects (font (size 1 1) (thickness 0.15))) ) (fp_text value mohan (at 0 0) (layer F.Fab) (effects (font (size 1 1) (thickness 0.15))) ) """) line_txt = ' (pad {} smd rect (at {:.3f} {:.3f}) (size {:.3f} {:.3f}) (layers F.Cu F.Paste F.Mask))\n' for i in range(len(x)): footprint += line_txt.format(i + 3, x[i], y[i], widths[i], heights[i]) l1 = din - s + trackWidth p = x[0] - l1 / 2 q = -(din / 2 + n * trackWidth + (n - 1) * s) + trackWidth / 2 pad = ' (pad {} thru_hole rect (at {:.3f} {:.3f})(size {} {}) (drill 0.3)(layers *.Cu))\n' footprint += pad.format(1, p + via_size / 2, y[0] - via_size / 2, via_size, via_size) footprint += pad.format(2, q - via_size / 2 + trackWidth / 2, -q + trackWidth / 2 + via_size / 4, via_size, via_size) line_txt = ' (fp_line (start {:.3f} {:.3f}) (end {:.3f} {:.3f}) (layer F.CrtYd) (width 0.12))\n' q = (2 * n * trackWidth + 2 * (n - 1) * s + din) / 2 + s + via_size # basis for corner coordinates footprint += line_txt.format(-q, -q, q, -q) footprint += line_txt.format(q, -q, q, q) footprint += line_txt.format(q, q, -q, q) footprint += line_txt.format(-q, q, -q, -q) line_txt = ' (fp_line (start {:.3f} {:.3f}) (end {:.3f} {:.3f}) (layer F.SilkS) (width 0.12))\n' footprint += line_txt.format(-q, -q, q, -q) footprint += line_txt.format(q, -q, q, q) footprint += line_txt.format(q, q, -q, q) footprint += line_txt.format(-q, q, -q, -q) footprint += \ '(fp_text user "din={:.3f} dout={:.3f} n={} w={:.3f} s={:.3f} L={}H rho={:.3f}" (at 0 {})(layer Cmts.User) (effects(font(size 1 1)(thickness 0.15))))\n'.format( self.din, self.dout, self.n, self.w, self.s, EngNumber(self.inductance, precision=3), self.rho, q + 1) footprint += ")\n" return footprint
def testImplicitConversion(self): """Arithmetic involving an EngNumber and an int should return an EngNumber""" c = Calculator() c.execute('2k') c.execute('2000') c.execute('+') (result, ) = c.stack self.assertEqual(EngNumber('4k'), result)
def set_value(self, value): if value < self._min_value: value = self._min_value elif value >= self._max_value: value = self._max_value * 0.99 self._value = EngNumber(value) self._redraw()
def main(args): sk = Scikic() lmw, lgmd, lmon = sk.calculateInductance() if sk.v: print( 'lmw = {}H, lgmd={}H. lmon={}H'.format(EngNumber(lmw, precision=3), EngNumber(lgmd, precision=3), EngNumber(lmon, precision=3))) sk.determineImpedanceOfSquarePlanarInductorUsingFasthenry() footprint = sk.formKiCadFootprint() if sk.o: sk.runOptimization() if sk.f: filename = 'planar_inductor_{:.3f}_{:.3f}_{:.3f}_{}.kicad_mod'.format(sk.din, sk.w, sk.s, sk.n) f = open(filename, 'w+') f.write(footprint) f.close() if sk.v: print('Footprint saved to file {}'.format(filename)) return 0
def test_enum_to_str_small(): # positive_numbers assert str(EngNumber('220m')) == '220m' assert str(EngNumber('0.220')) == '220m' assert str(EngNumber(0.220)) == '220m' assert str(EngNumber(0.220000125)) == '220m' # negative_numbers assert str(EngNumber('-220m')) == '-220m' assert str(EngNumber('-0.220')) == '-220m' assert str(EngNumber(-0.220)) == '-220m' assert str(EngNumber(-0.220000125)) == '-220m'
def print_run_info(self, y): final_stator_current_d = np.real(y[0, -1]) final_stator_current_q = np.imag(y[0, -1]) final_rotor_flux_d = np.real(y[1, -1]) mutual_inductance = self.get_mutual_inductance() coupling_factor = mutual_inductance / self.params[ ACMotor.pl['rotor_inductance']] final_torque_per_q_amp = pole_pairs * coupling_factor * final_rotor_flux_d print() print('Final values:') print('final_rotor_flux_d = {}Wb'.format( EngNumber(final_rotor_flux_d))) print('final_stator_current_d = {}A'.format( EngNumber(final_stator_current_d))) print('final_stator_current_q = {}A'.format( EngNumber(final_stator_current_q))) print('final_torque_per_q_amp = {}Nm/A'.format( EngNumber(final_torque_per_q_amp)))
def runOctaveScript(self): if self.N >= 2 and self.N <= 20: self.generateOctaveScript() else: print("Octave script is only valid for N>=2 and N<=20!") return if os.path.exists('./L_SquarePlanarSpiral.m'): output_to_logfile = open('octave.log', 'w+') script = '' script += 'N={};\n'.format(self.N) script += 'A={};\n'.format(self.Ai + 2 * (self.N - 1) * (self.w)) script += 'w={};\n'.format(self.w) script += 's={};\n'.format(self.s) script += 'h={};\n'.format(self.h) script += '[L, rho] = L_SquarePlanarSpiral (N, A, w, s, h);\n' script += 'fprintf("%e,%f",L, rho);' f = open('doit.m', 'w+') f.write(script) f.close() if os.path.exists('./doit.m'): p = Popen(["octave", 'doit.m'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True) p.wait() output, errors = p.communicate() if output != None: L, rho = output.split(',') if 'NaN' in L: print('{}'.format( '** Invalid parameter combination reported from Octave script. **' )) print( '** Calculated value of rho = {} **\n'.format(rho)) else: print('\nCalculated value of L = {}H'.format( EngNumber(float(L) / 1000, precision=3))) print('Calculated value of rho = {:.4f}\n'.format( float(rho))) elif errors != None: print(errors) sys.exit() else: print('No calculated output available!') sys.exit() else: print('doit.m does not exist!') sys.exit() else: print('L_SquarePlanarSpiral.m does not exist!') sys.exit() return
def errfunc(x, grad): if grad.size > 0: grad = None self.s = x[0] self.w = x[1] self.din = x[2] self.n = int(x[3]) self.dout = self.din + 2 * self.n * self.w + 2 * (self.n - 1) * self.s self.rho = (self.dout - self.din)/(self.dout + self.din) print('\n=====> s={}'.format(EngNumber(x[0], precision=3))) print('=====> w={}'.format(EngNumber(x[1], precision=3))) print('=====> din={}'.format(EngNumber(x[2], precision=3))) print('=====> n={}'.format(EngNumber(x[3], precision=3))) print('=====> dout={}'.format(self.dout)) print('=====> rho={:.4f}'.format(self.rho)) ind = self.determineImpedanceOfSquarePlanarInductorUsingFasthenry() print('=====> ind={}'.format(ind)) self.L = ind err = math.fabs(ind - targetInd) return err
def _tryEngNotation(self, command): if self._engineeringNotation: try: value = EngNumber(command) except decimal.InvalidOperation: return None except NameError: self.err('Failed to use engineering notation. Please install ' 'the engineering_notation python package') return None else: return value
def print_data_time_elaboration(self): try: self.time except AttributeError: print("Error, Call set_Vs_time_signal before") sys.exit() print("Remember that time axes have order : {0}".format( EngNumber(10**self.time_order))) self.plot_Vs() self.plot_d_Vs() self.plot_d_Vne() self.plot_d_Vfe()
def __init__(self, parent, width=200, height=100, min_value=0.0, max_value=100.0, label='', unit='', divisions=8, yellow=50, red=80, yellow_low=0, red_low=0, bg='lightgrey'): self._parent = parent self._width = width self._height = height self._label = label self._unit = unit self._divisions = divisions self._min_value = EngNumber(min_value) self._max_value = EngNumber(max_value) self._average_value = EngNumber((max_value + min_value) / 2) self._yellow = yellow * 0.01 self._red = red * 0.01 self._yellow_low = yellow_low * 0.01 self._red_low = red_low * 0.01 super().__init__(self._parent) self._canvas = tk.Canvas(self, width=self._width, height=self._height, bg=bg) self._canvas.grid(row=0, column=0, sticky='news') self._min_value = EngNumber(min_value) self._max_value = EngNumber(max_value) self._value = self._min_value self._redraw()
def test_to_pn_with_letter(): # positive_numbers assert EngNumber('1.2').to_pn('R') == '1R20' assert EngNumber(22.0).to_pn('C') == '22' assert EngNumber(22.1).to_pn('C') == '22C10' # negative_numbers assert EngNumber('-1.2').to_pn('R') == '-1R20' assert EngNumber(-22.0).to_pn('C') == '-22' assert EngNumber(-22.1).to_pn('C') == '-22C10'
def generateEventsFromFramesAndExportEventsToHDF5( self, outputFileName: str, imageFileNames: List[str], frameTimesS: np.array) -> None: """Export events to a HDF5 file. TODO: not sure if we should still keep this function Parameters ---------- outputFileName : str file name of the HDF5 file """ event_dataset = self.event_file.create_dataset( name="event", shape=(0, 4), maxshape=(None, 4), dtype="uint32") # generating events num_events = 0 for i in tqdm(range(frameTimesS.shape[0] - 1), desc="export_events: ", unit='fr'): new_frame = read_image(imageFileNames[i + 1]) if self.emulator is None: self.emulator = EventEmulator( pos_thres=self.pos_thres, neg_thres=self.neg_thres, sigma_thres=self.sigma_thres) tmp_events = self.emulator.generate_events( new_frame, frameTimesS[i]) if tmp_events is not None: # convert data to uint32 (microsecs) format tmp_events[:, 0] = tmp_events[:, 0] * 1e6 tmp_events[tmp_events[:, 3] == -1, 3] = 0 tmp_events = tmp_events.astype(np.uint32) # save events event_dataset.resize( event_dataset.shape[0] + tmp_events.shape[0], axis=0) event_dataset[-tmp_events.shape[0]:] = tmp_events self.event_file.flush() num_events += tmp_events.shape[0] logger.info("Generated {} events".format(EngNumber(num_events)))
def _tryEvalExec(self, command, modifiers, count): errors = [] possibleWhiteSpace = False try: value = eval(command, globals(), self._variables) except BaseException as e: err = str(e) errors.append('Could not eval(%r): %s' % (command, err)) if (self._splitLines and err.startswith( 'unexpected EOF while parsing (<string>, line 1)')): possibleWhiteSpace = True try: value = EngNumber(command) except decimal.InvalidOperation: try: exec(command, globals(), self._variables) except BaseException as e: err = str(e) errors.append('Could not exec(%r): %s' % (command, err)) if (not possibleWhiteSpace and self._splitLines and err.startswith( 'unexpected EOF while parsing (<string>, ' 'line 1)')): possibleWhiteSpace = True if possibleWhiteSpace: errors.append('Did you accidentally include ' 'whitespace in a command line?') raise CalculatorError(*errors) else: self.debug('exec(%r) worked.' % command) return True, self.NO_VALUE else: self.debug('EngNumber(%s) worked: %r' % (command, value)) count = 1 if count is None else count self._finalize(value, modifiers=modifiers, repeat=count) return True, value else: self.debug('eval %s worked: %r' % (command, value)) count = 1 if count is None else count self._finalize(value, modifiers=modifiers, repeat=count) return True, value
def formKicadPCBFootprint(self, start_x, start_y, end_x, end_y): L = float(self.L) header_text = \ """ (module planar_inductance (layer F.Cu) (tedit 5E123001) (fp_text reference REF** (at 0 0.5) (layer F.SilkS) (effects (font (size 1 1) (thickness 0.15))) ) (fp_text value planar_inductance_{0} (at 0 {8}) (layer F.Fab) (effects (font (size 1 1) (thickness 0.15))) ) (fp_text user N={1}_Ai={2}_s={3}_g={4}_h={5}__{0} (at {6} {7}) (layer Cmts.User) (effects (font (size 1 1) (thickness 0.15))) ) """.format(str(EngNumber(L, precision=4)) + 'H', self.N, self.Ai, self.s, self.g, self.h, 0, end_y[-2] - 2 * self.w, -1 * (end_y[-2] - 2 * self.w)) footprint = '' footprint += header_text footprint += self.formCourtYard(abs(start_x[-2]), abs(start_y[-2])) footprint += self.formForwardSilk(abs(start_x[-2]), abs(start_y[-2])) line_format = '(fp_line (start {} {}) (end {} {}) (layer F.Cu) (width {}))' for i in range(len(start_x)): footprint += line_format.format(start_x[i], start_y[i], end_x[i], end_y[i], self.s) footprint += \ """ (pad 2 thru_hole circle (at {:.4f} {:.4f}) (size 0.6 0.6) (drill 0.3) (layers *.Cu) (zone_connect 2)) (pad 1 thru_hole circle (at {:.4f} {:.4f}) (size 0.6 0.6) (drill 0.3) (layers *.Cu) (zone_connect 2)) """.format(start_x[0], start_y[0], end_x[-1], end_y[-1]) footprint += ')' filename = "planar_inductor_{}_{}_{}_{}.kicad_mod".format( self.Ai, self.s, self.g, self.N) f = open(filename, "w+") f.write(footprint) f.close() return footprint
def determineImpedanceOfSquarePlanarInductorUsingFasthenry(self): nodes = self.getStartEndCoords() x, y = self.nodes2XAndY(nodes) self.generateFasthenryInputFile(x, y) inp = "planar_inductor.inp" if os.path.exists(inp): logfile = 'logfile.txt' output_to_logfile = open(logfile, 'w+') if os.path.exists('Zc.mat'): os.remove('Zc.mat') p = Popen(["fasthenry", inp], stdout=output_to_logfile, stderr=subprocess.PIPE, universal_newlines=True) p.wait() if os.path.exists('Zc.mat'): lines = [] f = open('Zc.mat', 'r') for line in f: lines.append(line) f.close() z = lines[-1].split() z = complex(float(z[0]), float(z[1][:-1])) self.inductance = z.imag / (2 * math.pi * 200000) if self.v: print('Zc.mat successfully created.') print('real part of impedance = {}'.format(z.real)) print('imag part of impedance = {}'.format(z.imag)) print('Fasthenry determined Inductance of the planar inductor to be: {}H'.format( EngNumber(self.inductance, precision=3))) else: print(self.inductance) else: print('Zc.mat NOT generated!') sys.exit() else: print("The file 'planar_inductor.inp' the input file to Fasthenry doesn't exist!") sys.exit() return self.inductance
def print_parameter_info(self): print() print('Given parameters:') print('rotor_resistance = {}ohm'.format( EngNumber(assumed_rotor_resistance))) print() print('Fitted parameters:') for i, r in enumerate(ACMotor.parameter_definitions): print('{} = {}{}'.format(r[0], EngNumber(self.params[i]), r[2])) print() print('Derived parameters:') mutual_inductance = motor.get_mutual_inductance() coupling_factor = mutual_inductance / self.params[ ACMotor.pl['rotor_inductance']] torque_constant = pole_pairs * coupling_factor * mutual_inductance motor_constant = torque_constant / ( 3.0 * self.params[ACMotor.pl['stator_resistance']]) print('mutual_inductance = {}H'.format(EngNumber(mutual_inductance))) print('coupling_factor = {}'.format(EngNumber(coupling_factor))) print('torque_constant = {}Nm/A^2'.format(EngNumber(torque_constant))) print('motor_constant = {}Nm/W'.format(EngNumber(motor_constant)))
def test_enum_lt(): # positive_numbers assert EngNumber('220k') < 221000 # negative_numbers assert EngNumber('-220k') > -221000
def print_data_freq_elaboration(self, xtalk_freq): print("Not shilded circuit!!") print("lm: {0}, l1: {1}, l2:{2}".format(EngNumber(self.lm), EngNumber(self.l1), EngNumber(self.l2))) print("cm: {0}, c1: {1}, c2:{2}".format(EngNumber(self.cm), EngNumber(self.c1), EngNumber(self.c2))) [Mne_ind, Mne_cap, Mfe_ind, Mfe_cap, dominating_effect] = self.xtalk() print("Mne_ind: {0} Mne_cap:{1} \nMfe_ind:{2} Mfe_cap:{3}\nDominating_effect:{4}".\ format(EngNumber(Mne_ind), EngNumber(Mne_cap), EngNumber(Mfe_ind),EngNumber(Mfe_cap), dominating_effect)) print("frequence validity: {0}".format(EngNumber( self.freq_validity()))) xtalk = self.Vne_Vfe_xtalk([xtalk_freq]) print("Linear Vne and Vfe values") print(" Vne at {1}Hz: {0}".format(EngNumber(xtalk["Vne"][0]), EngNumber(xtalk_freq))) print(" Vfe at {1}Hz: {0}".format(EngNumber(xtalk["Vfe"][0]), EngNumber(xtalk_freq))) xtalk = self.Vne_Vfe_xtalk_dB([xtalk_freq]) print("Vne and Vfe values n dB") print(" Vne at {1}Hz: {0}dB".format(EngNumber(xtalk["Vne"][0]), EngNumber(xtalk_freq))) print(" Vfe at {1}Hz: {0}dB".format(EngNumber(xtalk["Vfe"][0]), EngNumber(xtalk_freq)))
def test_enum_sub(): # positive_numbers assert str(EngNumber('220m') - EngNumber('10m')) == '210m' assert str(EngNumber('220m') - 0.01) == '210m' assert str(EngNumber('220m') - EngNumber('220u')) == '219.78m' assert str(EngNumber('220m') - EngNumber('220n')) == '220m' assert str(0.220 - EngNumber('0.01')) == '210m' # negative_numbers assert str(EngNumber('-220m') - EngNumber('-10m')) == '-210m' assert str(EngNumber('-220m') - -0.01) == '-210m' assert str(EngNumber('-220m') - EngNumber('-220u')) == '-219.78m' assert str(EngNumber('-220m') - EngNumber('-220n')) == '-220m' assert str(-0.220 - EngNumber('-0.01')) == '-210m'
def test_enum_add(): # positive_numbers assert str(EngNumber('220m') + EngNumber('10m')) == '230m' assert str(EngNumber('220m') + 0.01) == '230m' assert str(0.01 + EngNumber('220m')) == '230m' assert str(EngNumber('220m') + EngNumber('220u')) == '220.22m' assert str(EngNumber('220m') + EngNumber('220n')) == '220m' # negative_numbers assert str(EngNumber('-220m') + EngNumber('-10m')) == '-230m' assert str(EngNumber('-220m') + -0.01) == '-230m' assert str(-0.01 + EngNumber('-220m')) == '-230m' assert str(EngNumber('-220m') + EngNumber('-220u')) == '-220.22m' assert str(EngNumber('-220m') + EngNumber('-220n')) == '-220m'
def test_new_units(): """ any new units - such as femto, atto, zepto, etc. should have some basic testing added here """ # testing femto assert str(EngNumber('220f')) == '220f' assert str(EngNumber(0.000000000000220)) == '220f' # testing atto assert str(EngNumber('220a')) == '220a' assert str(EngNumber(0.000000000000000220)) == '220a' # testing zepto assert str(EngNumber('220z')) == '220z' assert str(EngNumber(0.000000000000000000220)) == '220z' # testing yocto assert str(EngNumber('220y')) == '220y' assert str(EngNumber(0.000000000000000000000220)) == '220y' # wrap it all up assert str(EngNumber('1f') + EngNumber('330a')) == '1.33f' assert str(EngNumber('3z') + EngNumber('440y')) == '3.44z'
def set_value(self, value): self._value = EngNumber(value) if self._min_value * 1.02 < value < self._max_value * 0.98: self._redraw() # refresh all else: # OFF limits refresh only readout self.readout(self._value, 'red') # on RED BackGround
def test_to_pn(): # positive_numbers assert EngNumber('1.2M').to_pn() == '1M20' assert EngNumber('220M').to_pn() == '220M' assert EngNumber('220k').to_pn() == '220k' assert EngNumber('1.2k').to_pn() == '1k20' assert EngNumber('220').to_pn() == '220' assert EngNumber('1.2').to_pn() == '1.20' assert EngNumber('220m').to_pn() == '220m' assert EngNumber('1.2m').to_pn() == '1m20' # negative_numbers assert EngNumber('-1.2M').to_pn() == '-1M20' assert EngNumber('-220M').to_pn() == '-220M' assert EngNumber('-220k').to_pn() == '-220k' assert EngNumber('-1.2k').to_pn() == '-1k20' assert EngNumber('-220').to_pn() == '-220' assert EngNumber('-1.2').to_pn() == '-1.20' assert EngNumber('-220m').to_pn() == '-220m' assert EngNumber('-1.2m').to_pn() == '-1m20'
def test_enum_gt(): # positive_numbers assert EngNumber('220k') > 219000 # negative_numbers assert EngNumber('-220k') < -219000
def test_enum_eq(): # positive_numbers assert EngNumber('220k') == EngNumber(220000) assert EngNumber('220k') == 220000 assert EngNumber('220k') == 220000.0 assert 220000 == EngNumber('220k') assert 220000.0 == EngNumber('220k') # positive_numbers assert EngNumber('-220k') == EngNumber(-220000) assert EngNumber('-220k') == -220000 assert EngNumber('-220k') == -220000.0 assert -220000 == EngNumber('-220k') assert -220000.0 == EngNumber('-220k')
def test_enum_div(): # positive_numbers assert str(EngNumber('220m') / EngNumber('2')) == '110m' assert str(EngNumber('220m') / 2) == '110m' assert str(EngNumber('220m') / 2.0) == '110m' assert str(2 / EngNumber('220m')) == '9.09' assert str(2.0 / EngNumber('220m')) == '9.09' # negative_numbers assert str(EngNumber('-220m') / EngNumber('-2')) == '110m' assert str(EngNumber('-220m') / -2) == '110m' assert str(EngNumber('-220m') / -2.0) == '110m' assert str(-2 / EngNumber('-220m')) == '9.09' assert str(-2.0 / EngNumber('-220m')) == '9.09'
def validation(self): dic1 = {0:20, 1:10, 2:5, 3:2, 4:1, 5:0.5} f=self.label3Edit.text() A=self.label4Edit.text() Q=self.label5Edit.text() C=self.label6Edit.text() indx_C_tol = self.label10Edit.currentIndex() C_tol_aux = dic1[indx_C_tol] str1 = "Alerta:" error = False if f !="": try: fn = EngNumber(f) if fn>EngNumber("100G") or fn < EngNumber("0"): str1 += "\n" + "fo-Error: La frecuencia debe estar en el intervalo [0,100G]" error = True else: self.fn = float(fn) except decimal.InvalidOperation: str1 += "\n" + "fo-Error: Tipo de dato erroneo" error = True else: str1 += "\n" + "fo-Error: Introduzca un valor" error = True if A !="": try: An = EngNumber(A) if An>EngNumber("10k") or An < EngNumber("0"): str1 += "\n" + "A-Error: La ganancia debe estar en el intervalo [0,10k]" error = True else: self.An = float(An) except decimal.InvalidOperation: str1 += "\n" + "A-Error: Tipo de dato erroneo" error = True else: str1 += "\n" + "A-Error: Introduzca un valor" error = True if Q !="": try: Qn = EngNumber(Q) if Qn>EngNumber("1k") or Qn < EngNumber("0"): str1 += "\n" + "Q-Error: El factor de calidad debe estar en el intervalo [0,1k]" error = True else: self.Qn = float(Qn) except decimal.InvalidOperation: str1 += "\n" + "Q-Error: Tipo de dato erroneo" error = True else: str1 += "\n" + "Q-Error: Introduzca un valor" error = True if C !="": try: Cn = EngNumber(C) if Cn>EngNumber("10m") or Cn < EngNumber("10p"): str1 += "\n" + "C-Error: El valor del condensador debe estar en el intervalo [10p,10m]" error = True else: if self.count: Cn = float(Cn) self.KK = Cn """print("KK:{}".format(self.KK))""" g = str(EngNumber(self.standardValueEquivalent(Cn,C_tol_aux))) self.label6Edit.setText(g) self.count = False self.Cn = self.KK else: g = EngNumber(self.standardValueEquivalent(self.KK,C_tol_aux)) """print("g:{}".format(g)) print("KK2:{}".format(self.KK))""" self.Cn = float(g) self.label6Edit.setText(str(g)) except decimal.InvalidOperation: str1 += "\n" + "C-Error: Tipo de dato erroneo" error = True else: str1 += "\n" + "C-Error: Introduzca un valor" error = True if error: self.labelbd.setText(str1) else: self.labelbd.setText("Datos válidos") self.validat = True
def test_enum_mul(): # positive_numbers assert str(EngNumber('220m') * EngNumber('2')) == '440m' assert str(EngNumber('220m') * 2) == '440m' assert str(EngNumber('220m') * 2.0) == '440m' assert str(2 * EngNumber('220m')) == '440m' assert str(2.0 * EngNumber('220m')) == '440m' # negative_numbers assert str(EngNumber('-220m') * EngNumber('-2')) == '440m' assert str(EngNumber('-220m') * -2) == '440m' assert str(EngNumber('-220m') * -2.0) == '440m' assert str(-2 * EngNumber('-220m')) == '440m' assert str(-2.0 * EngNumber('-220m')) == '440m'