def test_load_circuit(self):
create_tmp_file()
circ = Circuit()
circ.load(path="tmp.circ")
self.assertEqual(len(circ.nodes), 2)
self.assertEqual(len(circ.components), 2)
def test_single_node(self):
circ = Circuit()
circ.add_node(Node("ground-node", True))
results = circ.ac_sweep({"frequency": 1e3})
self.assertEqual(0, results["ground-node"])
def two_node_circuit():
circ = Circuit()
n0 = Node("N0", True)
n1 = Node("N1")
circ.add_node(n0)
circ.add_node(n1)
return circ, n0, n1
def __lin2(self, circuito, d1, d2, d3):
equation = [[[0 for i in range(len(d1))], [0 for i in range(len(d1))], [0]]
for i in range(len(d1))]
R = []
r = []
for i in range(1, len(equation)+2):
R.append(i)
r.append(i)
r.extend(r)
m = []
for i in range(len(R)):
for j in range(len(d1)):
d1[j].setEquation([[[1], [-R[j]], [0]]])
c = Circuit(circuito)
voltage = []
current = []
for j in d1:
voltage.append(c.solution([d3[j]], [0], ["voltage"]))
current.append(c.solution([d3[j]], [0], ["current"]))
m.append([voltage, current])
for j in range(len(R)):
R[j] = r[j+i+1]
for i in range(1, len(m)):
for j in range(len(m[i][0])):
m[i][0][j] = m[0][0][j]-m[i][0][j]
m[i][1][j] = m[0][1][j]-m[i][1][j]
a = [m[i][1] for i in range(1, len(m))]
for i in range(0, len(m)-1):
b = []
for j in range(1, len(m)):
b.append(m[j][0][i])
A = np.array(a, dtype="float")
B = np.array(b, dtype="float")
y = np.linalg.solve(A, B)
equation[i][2][0] = m[0][0][i]
equation[i][0][i] = 1
for j in range(len(y)):
equation[i][1][j] = y[j]
equation[i][2][0] -= y[j]*m[0][1][j]
equation[i][2][0] = -equation[i][2][0]
return equation
def test_var(self):
cir = c.Circuit("circuit9.txt", 0, 2, 10)
x, y = cir.coordonneesWayPoint(1)
ve = v.VehiculeIAA(x, y, cir, 5)
self.assertEqual(ve.x, x)
self.assertEqual(ve.coords, (x, y))
def test_component_rejection(self):
circ = Circuit("Circ")
ground = Node("ground node", True)
node = Node("non-ground")
circ.add_node(ground)
try:
Resistor("R", node, ground, 1000)
except CircuitError as e:
self.assertEqual(str(e),
"node non-ground does not belong to a circuit",
"Incorrect exception type")
return
self.assertTrue(False, "Component was not rejected")
def create_tmp_file():
circ = Circuit("Circ")
n1 = Node("N1", True)
n2 = Node("N2")
circ.add_node(n1)
circ.add_node(n2)
Resistor("R1", n1, n2, 1000)
VoltageSource("V1", n1, n2, 5)
circ.save("tmp.circ", overwrite=True)
return circ
def test_component_circuit_1(self):
circ = Circuit("Circ")
ground = Node("ground node", True)
node = Node("non-ground")
circ.add_node(ground)
circ.add_node(node)
Resistor("R", node, ground, 1000)
VoltageSource("V0", ground, node, 5)
self.assertTrue(len(circ.nodes) == 2 and len(circ.components) == 2)
class Input:
qubits = 0
inputs = 0
circuit = Circuit.Circuit()
states = list()
def __init__(self):
self.qubits = 0
self.inputs = 0
#this function reads a file and stores the information within an input object
def readFile(self, filename):
i = 0
with open(filename) as fp:
for line in fp:
#trim line
line = line.strip()
#first line, how many qubits
if (i == 0):
self.qubits = int(line)
#for the number of bits, there will be a wire
elif (i <= self.qubits):
wire = Wire.Wire(line)
self.circuit.append(wire)
#the line after specifies number of inputs
elif (i == self.qubits + 1):
self.inputs = int(line)
#for the number of inputs
elif (i <= self.qubits + 1 + self.inputs):
state = State.State(line, self.qubits)
self.states.append(state)
i += 1
#returns the list of initial states
def getStates(self):
return self.states
def getCircuit(self):
return self.circuit
def __lin0(self, d1, d2, d3, circuito):
self.equation = [[[0 for i in range(len(d1))],
[1 if i == j else 0 for i in range(len(d1))],
[0]] for j in range(len(d1))]
c = Circuit(circuito)
for i in range(len(d1)):
self.equation[i][2][0] = -c.solution([d3[d1[i]]], [0], ["current"])
for i in range(len(d1)):
d2[d1[i]][0].setEquation([[[1], [0], [1]]])
c = Circuit(circuito)
for j in range(len(d1)):
self.equation[j][0][i] = +self.equation[j][2][0]+c.solution([d3[d1[j]]], [0], ["current"])
d2[d1[i]][0].setEquation([[[1], [0], [0]]])
return self.equation
def __lin3(self, circuito, d1, d2, d3):
self.equation = [[[1 if i == j else 0 for i in range(len(d1))],
[0 for i in range(len(d1))],
[0]] for j in range(len(d1))]
c = Circuit(circuito)
for i in range(len(d1)):
self.equation[i][2][0] = c.solution([d3[d1[i]]], [0], ["voltage"])
for i in range(len(d1)):
d1[i].setEquation([[[0], [1], [1]]])
c = Circuit(circuito)
for j in range(len(d1)):
self.equation[j][1][i] = +self.equation[j][2][0]-c.solution([d3[d1[j]]], [0], ["voltage"])
d1[i].setEquation([[[0], [1], [0]]])
return self.equation
def test_type(self):
cir = c.Circuit("circuit9.txt", 0, 2, 10)
self.assertIsInstance(cir, list)
def setParamValues(self, v=None, i=None):
"""
This methods get values for linearization, and gets the equivalent
equation.
Parameters
----------
v: list
v is a list with the voltage values of the elements port.
i: list
i is a list with the current values of the elements port.
"""
if v is None:
v = self.__v
else:
self.__v = v
self.__d1 = [i for i in self.__v]
self.__d2 = {}
for i in range(len(self.__d1)):
self.__d2[self.__d1[i]] = self.__FT[i]
self.d3 = {}
for i in range(len(self.__d1)):
self.d3[self.__d1[i]] = self.circuito.index(self.__d2[self.__d1[i]])
circuito = self.circuito
a = len(self.__d1)
self.equation = [[[0 for i in range(a)],
[1 if i == j else 0 for i in range(a)],
[0]] for j in range(a)]
for i in range(len(self.__d1)):
self.__d2[self.__d1[i]][0].setEquation([[[1], [0], [self.__d1[i]]]])
c = Circuit(circuito)
c.solution()
self.setCir(c)
for i in range(len(self.__d1)):
self.__d2[self.__d1[i]][0].setEquation([[[1], [0], [0]]])
nol = []
e = {}
for i in range(len(circuito)):
if circuito[i][0].getNL():
nol.append(i)
e[circuito[i][0]] = deepcopy(circuito[i][0].getEquation())
circuito[i][0].setDiscrete(True)
self.__lin0(self.__d1, self.__d2, self.d3, circuito)
for i in nol:
circuito[i][0].setEquation(e[circuito[i][0]])
circuito[i][0].setDiscrete(False)
if self.__discrete:
self.circuito = circuito
super().__init__(self.equation, nl=False)
]
inValuesStr = "".join([("1" if is_true(i) else "0") for i in inValues])
logging.info(log_info + inValuesStr)
else:
logging.info(log_info + "No test case possible")
atpg.removeFault()
logging.basicConfig(format='%(message)s',
filename='benchmark_results.log',
filemode='w',
level=logging.INFO)
for filename in os.listdir(DIRECTORY):
logging.info("START with " + filename)
c = Circuit()
p = Parser(c, os.path.join(DIRECTORY, filename))
p.parse()
atpg = ATPG(c)
logging.info("Inputs: " + " ".join(c.getInNodeNames()))
start = time.process_time()
for fault in [Circuit.STUCK_AT_0_FAULT, Circuit.STUCK_AT_1_FAULT]:
logging.info("START with stuck at " +
("1" if fault == Circuit.STUCK_AT_1_FAULT else "0") +
" fault")
for inputNodeName in c.inNodes:
run_test(atpg, fault, inputNodeName)
for gateName in c.gates:
# output of gate
run_test(atpg, fault, gateName)
def SingleRun(theta0, theta1, num_blocks, shot=None, style='expectation'):
C2 = Circuit(num_wires=5)
C2.extend(ArbitraryTwoQubitGate(params=theta0), wires=[1, 2])
C2.extend(BasicBlockTwoQubitGate(num_blocks=num_blocks, params=theta1),
wires=[3, 4])
C2.add(H(0))
C2.add(SWAP(ctrl=0, tgt1=[1, 2], tgt2=[3, 4]))
C2.add(H(0))
random2 = randomState(dim=2)
C2.setInitialState(
State(dim=5,
state=np.kron(np.kron(np.array([1, 0]).reshape(2, 1), random2),
random2)))
return C2.execute(measure_wires=[0], shot=shot, style=style)
def __init__(self, nbtour=5, Controle=0, nbv=4):
nbv = nbv
nbtour = nbtour
l = 20
L = 20
self.Controle = Controle # pour savoir si le joueur a le contrôle ou si c'est un trounoi entre les intelligences artificielles
self.cir = Circuit("circuit9.txt", nbv, nbtour)
if self.Controle == 1:
self.joueur = VehiculeControle(
self.cir.coordonneesWayPoint(len(self.cir))[0],
self.cir.coordonneesWayPoint(len(self.cir))[1], self.cir, 3)
self.joueur.id = "joueur1"
self.cir.append(self.joueur)
#
else:
self.joueur = self.cir[0]
self.angleCamera = 0
chemin = os.getcwd()
#on charge des images pour les voitures les obtacles ..
self.imvoiture = QImage(chemin + "\\images\\car\\V7.png")
self.imvoiture3 = QImage(chemin + "\\images\\car\\V7.png")
self.imvoiture4 = QImage(chemin + "\\images\\car\\V12.png")
self.imvoiture2 = QImage(chemin + "\\images\\car\\V6.png")
self.imCarbu = QImage(chemin + "\\images\\motifs\\tube1.png")
self.imWall = QImage(chemin + "\\images\\motifs\\A3.png") #A3.png
self.imSol = QImage(chemin + "\\images\\motifs\\mur.png") #herbe
self.imR = QImage(chemin + "\\images\\motifs\\pisteA.png")
self.imMoule = QImage(chemin + "\\images\\motifs\\Moule.png")
self.sprites = {}
self.sprites['A'] = self.imvoiture2
self.sprites['B'] = self.imvoiture
self.sprites['C'] = self.imvoiture4
self.sprites['P'] = self.imvoiture3
self.scalex, self.scaley = 110, 110
self.scalecarx, self.scalecary = 110, 110
# à chque voiture on associe une image dépendant de son type
self.voitures = dict()
self.periodeMiseAjour = 200
self.scene = QGraphicsScene()
self.listFoos = []
super(MyView, self).__init__()
self.initUI()
#self.scroll(500,500)
# on cache le scroll pour des fins esthétiques
self.setVerticalScrollBarPolicy(1)
self.setHorizontalScrollBarPolicy(1)
self.dessiner()
self.setScene(self.scene)
self.timer1 = QtCore.QTimer()
QtCore.QObject.connect(self.timer1, QtCore.SIGNAL("timeout()"),
self.unTour)
self.timer1.setInterval(self.periodeMiseAjour)
if g1 == 0:
g1 = gate0Input0
elif g1 == 1:
g1 = gate0Input1
if x0 == 0:
x0 = gate0Input0
elif x0 == 1:
x0 = gate0Input1
if x1 == 0:
x1 = gate0Output0
elif x1 == 1:
x1 = gate0Output1
# Send the GTTs & garbled inputs to server and get result
result = Circuit.createGarbledCircuit(garbledTruthTableList, g0, g1, x0, x1)
# Transform the garbled outputs into normal outputs
print "\nResult:"
if result[0] == gate3Output0:
print('2^1: 0')
elif result[0] == gate3Output1:
print('2^1: 1')
if result[1] == gate7Output0:
print('2^0: 0')
elif result[1] == gate7Output1:
print('2^0: 1')
def parse(filename):
mycircuit = Circuit.Circuit(title="", filename=filename)
file = open(filename, "r")
lines = []
line_number = 0
elements = []
if file is not None:
while True:
line = file.readline()
line_number = line_number + 1
line = line.strip().lower()
if line_number == 1:
mycircuit.title = line
elif len(line) == 0:
break
line = plus_line(file, line)
if line[0] == '.':
line_elements = line.lower().split()
if line_elements[0] == ".end":
print("End of the netlist file.")
elif line_elements[0] == ".op":
mycircuit.op = True
elif line_elements[0] == ".dc":
mycircuit.dc = True
mycircuit.dc_source = line_elements[1]
mycircuit.dc_start = unit_transform(line_elements[2])
mycircuit.dc_stop = unit_transform(line_elements[3])
mycircuit.dc_point_number = \
(mycircuit.dc_stop - mycircuit.dc_start) / unit_transform(line_elements[4])
# TODO:mycircuit.dc_type = line_elements[]
elif line_elements[0] == ".ac":
pattern = re.match(
r'.AC (.*) (.*) ([0-9.]*[FPNUMKGT]?)(Hz)? ([0-9.]*[FPNUMKGT]?)(Hz)?',
line, re.I)
mycircuit.ac = True
mycircuit.ac_type = pattern.group(1)
mycircuit.ac_point_number = int(
unit_transform(pattern.group(2)))
mycircuit.ac_start = unit_transform(pattern.group(3))
mycircuit.ac_stop = unit_transform(pattern.group(5))
elif line_elements[0] == ".tran":
pattern = re.match(
r'.tran ([0-9.]*[FPNUMKGT]?)(s)? ([0-9.]*[FPNUMKGT]?)(s)?',
line, re.I)
mycircuit.tran = True
mycircuit.tran_start = 0
mycircuit.tran_step = unit_transform(pattern.group(1))
mycircuit.tran_stop = unit_transform(pattern.group(3))
else:
pass
lines.append((line, line_number))
for line, line_number in lines:
if line_number > 1:
r_pattern = re.match(r'^R.*', line, re.I)
c_pattern = re.match(r'^C.*', line, re.I)
l_pattern = re.match(r'^L.*', line, re.I)
d_pattern = re.match(r'^D.*', line, re.I)
mos_pattern = re.match(r'^M.*', line, re.I)
v_pattern = re.match(r'^V.*', line, re.I)
ispulse = re.search(r'PULSE', line, re.I)
i_pattern = re.match(r'^I.*', line, re.I)
e_pattern = re.match(r'^E.', line, re.I)
f_pattern = re.match(r'^F.', line, re.I)
g_pattern = re.match(r'^G.', line, re.I)
h_pattern = re.match(r'^H.', line, re.I)
if r_pattern:
element = parse_resistor(line, mycircuit)
elif c_pattern:
element = parse_capacitor(line, mycircuit)
elif l_pattern:
element = parse_inductor(line, mycircuit)
elif d_pattern:
element = parse_diode(line, mycircuit)
mycircuit.has_nonlinear = True
elif mos_pattern:
element = parse_mos(line, mycircuit)
mycircuit.has_nonlinear = True
elif v_pattern:
if ispulse:
element = parse_v_pulse_src(line, mycircuit)
else:
element = parse_vsrc(line, mycircuit)
elif i_pattern:
element = parse_isrc(line, mycircuit)
elif e_pattern:
element = parse_vcvs(line, mycircuit)
elif f_pattern:
element = parse_cccs(line, mycircuit)
elif g_pattern:
element = parse_vccs(line, mycircuit)
elif h_pattern:
element = parse_ccvs(line, mycircuit)
else:
element = None
if element:
elements += [element]
return mycircuit, elements
def test_type(self):
cir = c.Circuit("circuit9.txt", 0, 2, 10)
x, y = cir.coordonneesWayPoint(1)
ve = vb.VehiculeIAB(x, y, cir, 5)
self.assertIsInstance(ve, vb.VehiculeIAB)
textrect = text.get_rect()
if posicion.upper() == "CENTRO":
textrect.midtop = (x, y)
elif posicion.upper() == "DERECHA":
textrect.topright = (x, y)
else:
textrect.topleft = (x, y)
superficie.blit(text, textrect)
return textrect
#Dibujando Circuito
display = pygame.Surface((500, 300))
display.fill((224, 224, 224))
display_rect = display.get_rect()
circuit = Circuit(400, 200)
circuit.draw_circuit(display, 50, 50)
#Creando Boton de simulacion
botonDisplay = pygame.Surface((500, 100))
botonDisplay.fill((224, 224, 224))
botonSimular = pygame.draw.rect(botonDisplay, (46, 204, 113),
(50, 25, 400, 50))
texto("Simular", font30, (0, 0, 0), botonDisplay, botonSimular.midtop[0],
botonSimular.midright[1] - 10, "CENTRO")
#Cargando imagenes
img_resistencia = pygame.image.load("resistencia.png").convert()
img_fuentePoder = pygame.image.load("FuentePoder.png").convert()
img_resistencia.set_colorkey((255, 255, 255))
img_fuentePoder.set_colorkey((255, 255, 255))
def test_multi_node_circuit(self):
circ = Circuit("Circ")
circ.add_node(Node("ground node", True))
circ.add_node(Node("non-ground"))
self.assertTrue(len(circ.nodes) == 2 and len(circ.components) == 0)
def test_single_node_circuit(self):
circ = Circuit("Circ")
circ.add_node(Node("ground node", True))
self.assertTrue(len(circ.nodes) == 1 and len(circ.components) == 0)
def setIVk(self, V=None, I=None):
"""
It is a method for the application of the Euler method in capacitors,
and inductors.
Parameters
----------
V: list
V contains the voltage solutions of the ports.
I: list
I contains the current solutions of the ports.
"""
dim1 = []
dim2 = []
for i in range(len(self.circuito)):
elemento = self.circuito[i]
if elemento[0].getSubcir() and elemento[0].getDif() and not elemento[0].getNL():
dim1.append(i)
elif elemento[0].getSubcir() and elemento[0].getDif() and elemento[0].getNL():
elemento[0].setIVk()
elif elemento[0].getDif():
dim2.append(i)
for i in dim1:
if not self.nl:
for j in range(len(self.__d1)):
r = self.__d2[self.__d1[j]][0]
if type(self.__d1[0]) == Resistance:
r.setEquation([[[1], [-V[j]/I[j]], [0]]])
else:
r.setEquation([[[0], [1], [I[j]]]])
self.setCir(Circuit(self.circuito))
# esta sentencia es tanto valida para los casos con circuito
# principal lineal como no lineal.
cir = self.getCir()
I = [cir.solution([i], [j], ["current"]) for j in range(len(elemento)-1)]
V = [cir.solution([i], [j], ["voltage"]) for j in range(len(elemento)-1)]
elemento[0].setIVk(V, I)
# caso de circuito principal lineal.
if not self.nl:
for i in range(len(self.__d1)):
r = self.__d2[self.__d1[i]][0]
if type(self.__d1[0]) == Resistance:
r.setEquation([[[1], [-V[i]/I[i]], [0]]])
else:
r.setEquation([[[0], [1], [I[i]]]])
self.setCir(Circuit(self.circuito))
cir = self.getCir()
for i in dim2:
elemento = self.circuito[i]
if elemento[0].getDifValue() == "v":
elemento[0].vk(cir.solution([i], [0], ["voltage"]))
elif elemento[0].getDifValue() == "i":
elemento[0].ik(cir.solution([i], [0], ["current"]))
for i in range(len(self.__d1)):
r = self.__d2[self.__d1[i]][0]
if type(self.__d1[0]) == Resistance:
r.setEquation([[[1], [-V[i]/I[i]], [0]]])
else:
r.setEquation([[[0], [1], [0]]])
else:
cir = self.getCir()
for i in dim2:
elemento = self.circuito[i]
if elemento[0].getDifValue() == "v":
elemento[0].vk(cir.solution([i], [0], ["voltage"]))
elif elemento[0].getDifValue() == "i":
elemento[0].ik(cir.solution([i], [0], ["current"]))
class MyView(QtGui.QGraphicsView):
def __init__(self, nbtour=5, Controle=0, nbv=4):
nbv = nbv
nbtour = nbtour
l = 20
L = 20
self.Controle = Controle # pour savoir si le joueur a le contrôle ou si c'est un trounoi entre les intelligences artificielles
self.cir = Circuit("circuit9.txt", nbv, nbtour)
if self.Controle == 1:
self.joueur = VehiculeControle(
self.cir.coordonneesWayPoint(len(self.cir))[0],
self.cir.coordonneesWayPoint(len(self.cir))[1], self.cir, 3)
self.joueur.id = "joueur1"
self.cir.append(self.joueur)
#
else:
self.joueur = self.cir[0]
self.angleCamera = 0
chemin = os.getcwd()
#on charge des images pour les voitures les obtacles ..
self.imvoiture = QImage(chemin + "\\images\\car\\V7.png")
self.imvoiture3 = QImage(chemin + "\\images\\car\\V7.png")
self.imvoiture4 = QImage(chemin + "\\images\\car\\V12.png")
self.imvoiture2 = QImage(chemin + "\\images\\car\\V6.png")
self.imCarbu = QImage(chemin + "\\images\\motifs\\tube1.png")
self.imWall = QImage(chemin + "\\images\\motifs\\A3.png") #A3.png
self.imSol = QImage(chemin + "\\images\\motifs\\mur.png") #herbe
self.imR = QImage(chemin + "\\images\\motifs\\pisteA.png")
self.imMoule = QImage(chemin + "\\images\\motifs\\Moule.png")
self.sprites = {}
self.sprites['A'] = self.imvoiture2
self.sprites['B'] = self.imvoiture
self.sprites['C'] = self.imvoiture4
self.sprites['P'] = self.imvoiture3
self.scalex, self.scaley = 110, 110
self.scalecarx, self.scalecary = 110, 110
# à chque voiture on associe une image dépendant de son type
self.voitures = dict()
self.periodeMiseAjour = 200
self.scene = QGraphicsScene()
self.listFoos = []
super(MyView, self).__init__()
self.initUI()
#self.scroll(500,500)
# on cache le scroll pour des fins esthétiques
self.setVerticalScrollBarPolicy(1)
self.setHorizontalScrollBarPolicy(1)
self.dessiner()
self.setScene(self.scene)
self.timer1 = QtCore.QTimer()
QtCore.QObject.connect(self.timer1, QtCore.SIGNAL("timeout()"),
self.unTour)
self.timer1.setInterval(self.periodeMiseAjour)
def initUI(self):
self.setViewport(QGLWidget())
self.setGeometry(500, 200, 1000, 800)
self.setWindowTitle('Course ')
def keyPressEvent(self, e):
print(e.key())
if self.Controle != 1: # si c'est une course entre les intelligence artificielle on n'a pas besoin de détecter les évènements
return
if e.key() == QtCore.Qt.Key_Left:
self.joueur.tournerGauche()
if e.key() == QtCore.Qt.Key_Right:
self.joueur.tournerDroite()
if e.key() == QtCore.Qt.Key_Up:
self.joueur.accelerer()
if e.key() == QtCore.Qt.Key_Down:
self.joueur.deccelerer()
if e.key() == QtCore.Qt.Key_Escape:
self.close()
def dessiner(self):
for j in range(len(self.cir.plateau)):
for i in range(len(self.cir.plateau[j])):
if self.cir.plateau[
j, i, Circuit.Couche_terrain].getCaractere() == 'C':
self.listFoos.append(
self.scene.addPixmap(
QPixmap.fromImage(
self.imSol.scaled(self.scalex, self.scaley))))
self.listFoos[-1].setPos(self.scalex * i, self.scaley * j)
self.listFoos.append(
self.scene.addPixmap(
QPixmap.fromImage(
self.imCarbu.scaled(self.scalex,
self.scaley))))
self.listFoos[-1].setPos(self.scalex * i, self.scaley * j)
elif self.cir.plateau[
j, i, Circuit.Couche_terrain].getCaractere() == 'M':
self.listFoos.append(
self.scene.addPixmap(
QPixmap.fromImage(
self.imSol.scaled(self.scalex, self.scaley))))
self.listFoos[-1].setPos(self.scalex * i, self.scaley * j)
self.listFoos.append(
self.scene.addPixmap(
QPixmap.fromImage(
self.imWall.scaled(self.scalex, self.scaley))))
self.listFoos[-1].setPos(self.scalex * i, self.scaley * j)
elif self.cir.plateau[
j, i, Circuit.Couche_terrain].getCaractere() == 'O':
self.listFoos.append(
self.scene.addPixmap(
QPixmap.fromImage(
self.imSol.scaled(self.scalex, self.scaley))))
self.listFoos[-1].setPos(self.scalex * i, self.scaley * j)
self.listFoos.append(
self.scene.addPixmap(
QPixmap.fromImage(
self.imMoule.scaled(self.scalex,
self.scaley))))
self.listFoos[-1].setPos(self.scalex * i, self.scaley * j)
elif self.cir.plateau[
j, i, Circuit.Couche_terrain].getCaractere() == 'H':
self.listFoos.append(
self.scene.addPixmap(
QPixmap.fromImage(
self.imSol.scaled(self.scalex, self.scaley))))
self.listFoos[-1].setPos(self.scalex * i, self.scaley * j)
else:
self.listFoos.append(
self.scene.addPixmap(
QPixmap.fromImage(
self.imR.scaled(self.scalex, self.scaley))))
self.listFoos[-1].setPos(self.scalex * i, self.scaley * j)
for v in self.cir:
self.voitures[v.id] = (self.scene.addPixmap(
QPixmap.fromImage(self.sprites[v.typeV].scaled(
self.scalecarx, self.scalecary))))
self.voitures[v.id].setTransformOriginPoint(
QPoint(self.scalecarx / 2, self.scalecarx / 2))
self.voitures[v.id].setPos(v.x * self.scalex, v.y * self.scaley)
self.voitures[v.id].setRotation(90 + v.orientation * (180 / 3.14))
self.centerOn(self.voitures[self.joueur.id])
self.textRang = QGraphicsTextItem(" rang {} tour {}/{}".format(
self.joueur.rang, self.joueur.nombreTourE,
self.joueur._circuit.nbtours))
font = QtGui.QFont('White Rabbit')
font.setPointSize(18)
font.setBold(True)
self.textRang.setFont(font)
self.textRang.setDefaultTextColor(QColor('lightgray'))
self.MarqueurCamera = QGraphicsRectItem(10, 10, 10, 10)
self.MarqueurCamera.setBrush(QBrush(Qt.yellow))
self.scene.addItem(self.textRang)
self.scene.addItem(self.MarqueurCamera)
#◘ self.scale(1,1)
def unTour(self):
for v in self.cir:
coord = v.coords
self.voitures[v.id].setRotation(90 + v.orientation * (180 / 3.14))
self.voitures[v.id].setPos(coord[0] * self.scalex,
coord[1] * self.scaley)
self.centerOn(self.voitures[self.joueur.id])
#self.rotate((10/3.14)*(self.joueur.orientation-self.angleCamera))
self.cir.unTour()
self.angleCamera = self.joueur.orientation
self.textRang.setHtml(" Rang {}/{} tours {}/{} v={} R={} L".format(
self.joueur.rang, len(self.cir), self.joueur.nombreTourE,
self.joueur._circuit.nbtours, self.joueur.vitesse,
self.joueur.reservoir))
self.textRang.setPos(self.mapToScene(QPoint(0, 0)))
# self.indicateurDeVitesse.setPos(self.voitures[self.joueur.id].x()-10,self.voitures[self.joueur.id].y()-10)
# self.setBaseSize((self.joueur.reservoir*50)/self.joueur.capacite_reservoir,10)
self.MarqueurCamera.setPos(self.voitures[self.joueur.id].x(),
self.voitures[self.joueur.id].y())
print("un tour de plus")
if (self.joueur.reservoir == 0):
self.timer1.stop()
self.cir.courseFinie = True
self.cir.Tri_finale()
msgBox = QMessageBox()
msgBox.setText("vous avez perdu faute de carburant")
msgBox.exec_()
if self.cir[
len(self.cir) -
1].nombreTourE > self.cir.nbtours: # si la course est terminée
self.timer1.stop()
self.cir.courseFinie = True
self.cir.Tri_finale()
def lancerCourse(self):
self.cir.heurede_depart = time.time()
self.timer1.start()
def SingleRun(theta0, theta1, shot=None):
random1 = randomState(dim=1)
C1 = Circuit(num_wires=3)
# U: unknown channel
C1.extend(ArbitraryOneQubitGate(params=theta0), wires=[1])
# \tilde U: estimated channel
C1.extend(ArbitraryOneQubitGate(params=theta1), wires=[2])
# C-SWAP test
C1.add(H(0))
C1.add(SWAP(ctrl=0, tgt1=[1], tgt2=[2]))
C1.add(H(0))
# prepare initial state as two same input
C1.setInitialState(
State(dim=3,
state=np.kron(np.kron(np.array([1, 0]).reshape(2, 1), random1),
random1)))
#return C1.execute(measure_wires=[0], shot=shot)
ans1 = C1.execute(measure_wires=[0], shot=shot)
C2 = Circuit(num_wires=3)
# U: unknown channel
#C2.extend(ArbitraryOneQubitGate(params=theta0), wires=[1])
# \tilde U: estimated channel
#C2.extend(ArbitraryOneQubitGate(params=theta1), wires=[2])
# C-SWAP test
C2.add(H(0))
C2.add(SWAP(ctrl=0, tgt1=[1], tgt2=[2]))
C2.add(H(0))
# prepare initial state as two same input
UnknownChannel = ArbitraryOneQubitGate(params=theta0)
TrueOutput = np.dot(UnknownChannel.calcUnitary(), random1)
EstimatedChannel = ArbitraryOneQubitGate(params=theta1)
EstimatedOutput = np.dot(EstimatedChannel.calcUnitary(), random1)
C2.setInitialState(
State(dim=3,
state=np.kron(
np.kron(np.array([1, 0]).reshape(2, 1), TrueOutput),
EstimatedOutput)))
# return C1.execute(measure_wires=[0], shot=shot)
ans2 = C2.execute(measure_wires=[0], shot=shot)
#print(ans1, ans2)
return ans1
BorD = BorD_prompt()
if (BorD == 'benchmarks'):
tensorTest()
input("\nPress any key for the next test...")
compareProbabilities()
input("\nPress any key for the next test...")
timeBenchmarks()
elif (BorD == 'demo'):
build = builder_prompt()
stop = False
while (not stop):
if (build != 'builder'):
circ = Circuit(build)
circ.run_circuit()
esc = input(
"\nPress any key for another circuit or 's' to stop... ")
if esc == "s":
stop = True
else:
build = circuit_prompt()
else:
toBuild = custom_builder_prompt()
actual_builder(toBuild)
esc = input(
"\nPress any key for another circuit or 's' to stop... ")
if esc == "s":
stop = True
