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'
