def __init__(self, master, file_name, input_info, output_info,
duration_estimate):
self.master = master
border_width = 15
self.canvas_width = master.winfo_width()
self.canvas_height = master.winfo_height()
self.output_info = output_info
arrow_width = self.canvas_height / 200
border = 0
#processor must be initialized first
OutTop.OutTop(master, self.canvas_width, self.canvas_height, border,
border_width)
OutBottom.OutBottom(master, self.canvas_width, self.canvas_height,
border, border_width)
OutLeft.OutLeft(master, self.canvas_width, self.canvas_height, border,
border_width)
OutRight.OutRight(master, self.canvas_width, self.canvas_height,
border, border_width)
self.processor = Processor.Processor(master, self.canvas_width,
self.canvas_height, arrow_width,
border)
self.wheel = Wheel.Wheel(master, self.canvas_width, self.canvas_height,
border, arrow_width)
self.register = Register.Register(master, self.canvas_width,
self.canvas_height, border,
self.processor.exit_height,
arrow_width)
self.memory = Memory.Memory(master, self.canvas_width,
self.canvas_height, border)
self.memory_op = MemoryOp.MemoryOp(master, self.canvas_width,
self.canvas_height, arrow_width,
border)
self.cable = Cable.Cable(master, self.canvas_width, self.canvas_height,
arrow_width, border,
self.processor.entry_width,
self.memory_op.entry_width,
self.wheel.exit_height, self)
self.controls = Controls.Controls(master, self.canvas_width,
self.canvas_height, self, input_info,
duration_estimate)
## TODO : MEANINGFUL EXCEPTIONS
# file_name = sys.argv[1]
self.command_sequence = []
memory_preset = []
input_file = open(file_name, 'r')
for line in input_file:
line = line.strip()
if line.strip().startswith('#') or line == '':
continue
elif line.strip().startswith('['):
memory_preset = line[1:-1].split(',')
else:
self.command_sequence.append(line.strip().upper())
self.memory.init(memory_preset, self.command_sequence)
self.wheel.init(self.command_sequence)
input_file.close()
def write_3bit_ckt(self, bits, theta):
"""
This function writes, without the left and right endcaps, a gate
representing
exp(i \sum_{k1 < k2} \sum{k3 != k1, k2}
theta(k1, k2, k3) a^\dag(k1) a(k2) n(k3) + h.c.)
Parameters
----------
bits : list[int]
theta : float
Returns
-------
None
"""
assert len(bits) == 3
assert bits[0] < bits[1]
trols02 = Controls(self.data.num_orbitals + 1)
trols02.bit_pos_to_kind = {bits[0]: True, bits[2]: True}
trols02.refresh_lists()
self.write_controlled_one_bit_gate(bits[1], trols02,
OneBitGates.rot_ax, [theta, 1])
def read_multi_controls(self, tokens, allow_only_TF=False):
"""
Given a list of tokens of the form:
* an int followed by either T or F,
* int, colon, int,
construct a control out of it.
Parameters
----------
tokens : list[str]
allow_only_TF : bool
Returns
-------
Controls
"""
# safe to use when no "IF"
# when no "IF", will return controls with _numControls=0
controls = Controls(self.num_bits)
if tokens:
for t in tokens:
t_end = t[-1]
if allow_only_TF:
assert t_end in ['T', 'F']
if t_end == 'T':
controls.set_control(int(t[:-1]), True)
elif t_end == 'F':
controls.set_control(int(t[:-1]), False)
else:
k1, k2 = t.split(':')
controls.set_control(int(k1), int(k2))
controls.refresh_lists()
return controls
def __init__(self, x, z, theta, pos):
self.trans_vel = x
self.ang_vel = z
self.orientation = theta
self.curr_pos = pos
self.state = np.array([[pos[0]], [0], [pos[1]], [0], [theta], [0]])
self.__wheel_dist = 0.43
self.kalman = Kalman.Kalman()
self.controls = Controls.Controls()
def write_bit_swap(self, bit1, bit2):
"""
Write a line in eng & pic files for a 'SWAP' with no controls.
Parameters
----------
bit1 : int
bit2 : int
Returns
-------
None
"""
trols = Controls(2) # dummy with zero controls
self.write_controlled_bit_swap(bit1, bit2, trols)
def __init__(self, num, node_type):
"""
:param num: Number of nodes including base and end nodes
:param node_type: Type of node: Base, End, Robot
:return:
"""
if node_type == "Base":
self.type = "Base"
self.right_neighbor = num + 1
self.left_neighbor = -1
elif node_type == "End":
self.type = "End"
self.right_neighbor = -1
self.left_neighbor = num - 1
else:
self.type = "Robot"
self.left_neighbor = num - 1
self.right_neighbor = num + 1
self.node = num
# All positions measured with UWB-radios.
self.measured_positions = np.array([], dtype=np.float32)
self.measured_x_positions = np.array([], dtype=np.float32)
self.measured_y_positions = np.array([], dtype=np.float32)
# All positions corrected with kalman + measurements.
self.corrected_positions = np.array([], dtype=np.float32)
self.corrected_x_positions = np.array([], dtype=np.float32)
self.corrected_y_positions = np.array([], dtype=np.float32)
# Target positions storage, for align1.0 the node knows the target positions
self.target_positions = np.array([], dtype=np.float32)
self.target_x_positions = np.array([], dtype=np.float32)
self.target_y_positions = np.array([], dtype=np.float32)
# Controls storage
self.contplot_x = np.array([], dtype=np.float64)
self.contplot_z = np.array([], dtype=np.float64)
self.x = 0 # velocity
self.z = 0 # angular velocity
self.state = np.array([[0.0], [0.0], [0.0], [0.0], [0.0], [
0.0]]) # state = x_position, x_velocity, y_position, y_velocity, theta, theta_velocity(rotation velocity)
self.kalman = Kalman.Kalman()
self.controls = Controls.Controls()
def write_bit_swap(self, bit1, bit2, rads_list=None):
"""
Write a line in eng & pic files for a 'SWAP' if rads_list=None or
'SWAY' if rads_list!=None, with no controls.
Parameters
----------
bit1 : int
bit2 : int
rads_list : list[float | str] | None
Returns
-------
None
"""
trols = Controls(2) # dummy with zero controls
self.write_controlled_bit_swap(bit1, bit2, trols, rads_list)
def write_global_phase_fac(self, ang_rads):
"""
Write a line in eng & pic files for a global phase factor 'PHAS'
with no controls.
Parameters
----------
ang_rads : float
Returns
-------
None
"""
tar_bit_pos = 0 # anyone will do
trols = Controls(2) # dummy with zero controls
gate_fun = OneBitGates.phase_fac
self.write_controlled_one_bit_gate(tar_bit_pos, trols, gate_fun,
[ang_rads])
def __init__(self, num_bits_bef, num_bits_aft, bit_map=None):
"""
Constructor
Parameters
----------
num_bits_bef : int
num_bits_aft : int
Returns
-------
"""
self.num_bits_bef = num_bits_bef
self.num_bits_aft = num_bits_aft
assert num_bits_bef <= num_bits_aft
if num_bits_aft > num_bits_bef:
assert bit_map, "must give a bit_map"
self.bit_map = bit_map
self.extra_controls = Controls(num_bits_aft)
def write_4bit_ckt(self, bits, thetas):
"""
This function writes, without the left and right endcaps, a gate
representing
exp(i sum_{k1 < k2 < k3 < k4}
theta_0(k1, k2, k3, k4) a^\dag(k1) a^\dag(k2) a(k3) a(k4) + h.c.
theta_1(k1, k2, k3, k4) a^\dag(k1) a(k2) a^\dag(k3) a(k4) + h.c.
theta_2(k1, k2, k3, k4) a^\dag(k1) a(k2) a(k3) a^\dag(k4) + h.c.
Parameters
----------
bits : list[int]
thetas : list[float]
Returns
-------
None
"""
assert len(bits) == 4
assert len(thetas) == 3
assert bits[0] < bits[1] < bits[2] < bits[3]
for theta_index in range(0, 3):
theta = ut.centered_rads(thetas[theta_index])
if theta_index == 1:
sign = +1
else:
sign = -1
if abs(theta) > ut.TOL:
trols = Controls(self.data.num_orbitals + 1)
for r in range(0, 3):
if r == 2 - theta_index:
trols.set_control(bits[r], False)
else:
trols.set_control(bits[r], True)
trols.refresh_lists()
self.write_controlled_one_bit_gate(bits[3], trols,
OneBitGates.rot_ax,
[sign * theta, 1])
def write_one_bit_gate(self,
tar_bit_pos,
one_bit_gate_fun,
fun_arg_list=None):
"""
Write a line in eng & pic files for a one qubit gate (from class
OneBitGates) with no controls.
Parameters
----------
tar_bit_pos : int
one_bit_gate_fun : function
fun_arg_list : list
Returns
-------
None
"""
trols = Controls(2) # dummy with zero controls
self.write_controlled_one_bit_gate(tar_bit_pos, trols,
one_bit_gate_fun, fun_arg_list)
from Peter import *
from Controls import *
from time import sleep
from gpiozero import PWMOutputDevice
joy = Controls()
sol = DoubleSolenoid(21, 20, 16, 13, 26, 19)
tilt = Motor(25, 24, 23)
pan = PWMOutputDevice(pin=12, frequency=500)
#comp = Compressor(12, 5)
#comp.start()
trigger_timer = 0
trigger_bool = False
while True:
#comp.update()
joy.update()
if joy.z > 0.7: pan.value = 0.77
elif joy.z < -0.7: pan.value = 0.68
else: pan.value = 0
tilt.set(joy.y)
if joy.trigger == 1:
trigger_bool = True
if trigger_bool:
if trigger_timer < 0.5:
sol.set(1)
elif trigger_timer < 0.8:
sol.set(-1)
def __init__(self, leftW, rightW):
self.leftW = leftW
self.rightW = rightW
self.robot = Robot(self.leftW, self.rightW)
self.controls = Controls()
from random import randint
import serial # used for serial communications. came from <pip3.6 install pyserial>
import RR_CommandGenerator # class developed to generate a limited number of TT robot commands
import time
import pickle
root = tk.Tk()
root.withdraw()
state = RuntimeState.RuntimeState()
# Setup main window
main_image = Image.open("C:\\Users\\Finlay\\Documents\\Images\\MAIN.jpg")
main_image_tk = ImageTk.PhotoImage(main_image)
background = tk.Toplevel(root, background='black', width=640, height=480)
background.title("PxlRT Studio")
background.geometry("640x480")
# Create 4 windows that can be displayed in the info panel
initialise_panel = Initialise.Initialise(background, state)
manual_panel = Manual.Manual(background, state)
settings_panel = Settings.Settings(background, state)
tileprint_panel = TilePrint.TilePrint(background, state)
# Create main controls
controls = Controls.Controls(background, initialise_panel, manual_panel, settings_panel, tileprint_panel, state)
root.mainloop()
Returns
-------
None
"""
num_controls = len(controls.bit_pos)
assert num_controls == controls.get_num_int_controls(),\
"some of the controls of this multiplexor are not half-moons"
self.write_controlled_multiplexor_gate(tar_bit_pos, controls,
with_minus, rad_angles)
if __name__ == "__main__":
num_bits = 5
emb = CktEmbedder(num_bits, num_bits)
trols = Controls(num_bits)
trols.bit_pos_to_kind = {3: True, 4: False}
trols.refresh_lists()
ang_rads = 30 * np.pi / 180
for zf in [False, True]:
wr = SEO_writer('io_folder//wr_test', emb, zero_bit_first=zf)
wr.write_NOTA('zero bit first = ' + str(zf))
wr.write_LOOP(10, 15)
wr.write_NEXT(10)
wr.write_controlled_bit_swap(0, 2, trols)
truetheta[:, 0] = 2*np.pi*np.random.rand(n_robots)
measpos[:, :, 0] = truepos[:, :, 0]
currpos[:, :, 0] = truepos[:, :, 0]
currtheta[:, 0] = truetheta[:, 0]
"""
truepos[:, :, 0] = np.array([[-6, 7, 1],
[7, -2, -8]]).T
truetheta[:, 0] = 2*np.pi*np.random.rand(n_robots)
currpos[:, :, 0] = truepos[:, :, 0]
currtheta[:, 0] = truetheta[:, 0]
"""
kal = [Kalman.Kalman(sigma_meas, sigma_X, sigma_Z, currtheta[0, 0]),
Kalman.Kalman(sigma_meas, sigma_X, sigma_Z, currtheta[1, 0]),
Kalman.Kalman(sigma_meas, sigma_X, sigma_Z, currtheta[2, 0])]
ctrl = [Controls.Controls(0.05, 1, 0, 1),
Controls.Controls(0.05, 1, 0, 1),
Controls.Controls(0.05, 1, 0, 1)]
basepos = 10*np.random.rand(2)-5
endnodepos = 10*np.random.rand(2)-5
"""
basepos = np.array([8, 7])
endnodepos = np.array([-7, -8])
"""
X = np.zeros((n_robots, n_iter_no_corr*iterations))
Z = np.zeros((n_robots, n_iter_no_corr*iterations))
for j in range(0, iterations):
controlnoiset = np.random.normal(0, sigma_X)
controlnoiser = np.random.normal(0, sigma_Z)
def qubiter_pic_file_to_tiny_word_list(file_path, num_bits, ZL):
"""
Reads Qubiter native pic file and returns a tiny word list, which is
a list of words all of which have the same number (=num_bits) of
characters.
Parameters
----------
file_path : str
Path to Qubiter native pic file.
num_bits : int
Number of qubits. The name of every native pic file generated by
Qubiter states the value of num_bits.
ZL : bool
Set to True iff file is using Zero bit Last convention. Opposite
of ZL is ZF (Zero First). The name of every native pic file
generated by Qubiter states either ZL or ZF.
Returns
-------
list[str]
"""
tiny_word_list = []
inside_if_m_block = False
pic_file_in = open(file_path)
while not pic_file_in.closed:
line = pic_file_in.readline()
if not line:
pic_file_in.close()
break
line = line.replace('-', ' ')
split_line = line.split()
ch_list = []
# print("..", split_line)
if not inside_if_m_block:
m_block_controls = Controls(num_bits)
for vtx in split_line:
# print('vtx', vtx)
if vtx in [
'@', '<', '>', '|', ':', '%', '+', 'H', 'M', 'O', 'Ph',
'Rx', 'Ry', 'Rz', 'R', 'X', 'Y', 'Z'
]:
ch_list.append(vtx[0])
elif vtx in ['OP', '@P']:
ch_list.append('?')
elif vtx in ['M1', 'M2']:
assert False, "unsupported measurement type"
elif vtx in ['LOOP', 'NEXT']:
assert False, "loops not supported by Tiny"
elif vtx in ['NOTA', 'PRINT']:
break
elif vtx == 'IF_M(':
inside_if_m_block = True
# m_block_controls should be empty at this point
assert not m_block_controls.bit_pos_to_kind
trols = split_line[1:-1]
# print('trols', trols)
trol_bits = [int(x[:-1]) for x in trols]
trol_kinds = \
[True if x[-1] == 'T' else False for x in trols]
for bit, kind in zip(trol_bits, trol_kinds):
m_block_controls.bit_pos_to_kind[bit] = kind
m_block_controls.refresh_lists()
break
elif vtx == '}IF_M':
inside_if_m_block = False
break
else:
assert False, "unexpected circuit node: '" + vtx + "'"
# print("split_line", split_line)
# ch_list may be empty in cases where broke out of vtx loop
if ch_list:
# give controls of if_m block to gates inside block
assert len(ch_list) == num_bits, str(ch_list)
if inside_if_m_block:
for bit, kind in m_block_controls.bit_pos_to_kind.items():
if not ZL:
ch_list[bit] = '@' if kind else 'O'
else:
ch_list[num_bits - bit - 1] = '@' if kind else 'O'
# replace : by |
ch_list = [ch if ch != ':' else '|' for ch in ch_list]
# replace | by + when justified
gate_has_inter_qubit_wires = False
for ch in ch_list:
if ch in ['@', 'O', '<', '>', '+']:
gate_has_inter_qubit_wires = True
break
if gate_has_inter_qubit_wires:
non_vertical_pos = [
k for k in range(num_bits) if ch_list[k] != '|'
]
min_non_vert = min(non_vertical_pos)
max_non_vert = max(non_vertical_pos)
for k in range(min_non_vert + 1, max_non_vert):
if ch_list[k] == '|':
ch_list[k] = '+'
tiny_word_list.append(''.join(ch_list))
return tiny_word_list
def __init__(self):
display = Display()
controls = Controls()
turn = Turn()
turn.takeTurn(controls)
pass
def main():
num_bits = 5
emb = CktEmbedder(num_bits, num_bits)
trols = Controls(num_bits)
trols.bit_pos_to_kind = {3: True, 4: False}
trols.refresh_lists()
ang_rads = 30 * np.pi / 180
for ZL in [False, True]:
wr = SEO_writer('io_folder/wr_test', emb, ZL=ZL)
wr.write_NOTA('zero bit last = ' + str(ZL))
wr.write_IF_M_beg(trols)
wr.write_IF_M_end()
wr.write_LOOP(10, 15)
wr.write_NEXT(10)
tar_bit_pos = 1
for kind in [0, 1, 2]:
wr.write_MEAS(tar_bit_pos, kind)
wr.write_PRINT('F2')
wr.write_controlled_bit_swap(0, 2, trols)
wr.write_bit_swap(1, 2)
gate = OneBitGates.phase_fac
wr.write_controlled_one_bit_gate(2, trols, gate, [ang_rads])
wr.write_global_phase_fac(30 * np.pi / 180)
gate = OneBitGates.P_0_phase_fac
wr.write_controlled_one_bit_gate(2, trols, gate, [ang_rads])
gate = OneBitGates.P_1_phase_fac
wr.write_controlled_one_bit_gate(2, trols, gate, [ang_rads])
gate = OneBitGates.sigx
wr.write_controlled_one_bit_gate(2, trols, gate)
gate = OneBitGates.sigy
wr.write_controlled_one_bit_gate(2, trols, gate)
gate = OneBitGates.sigz
wr.write_controlled_one_bit_gate(2, trols, gate)
gate = OneBitGates.had2
wr.write_controlled_one_bit_gate(2, trols, gate)
gate = OneBitGates.rot_ax
wr.write_controlled_one_bit_gate(2, trols, gate, [ang_rads, 1])
gate = OneBitGates.rot_ax
wr.write_controlled_one_bit_gate(2, trols, gate, [ang_rads, 2])
gate = OneBitGates.rot_ax
wr.write_controlled_one_bit_gate(2, trols, gate, [ang_rads, 3])
gate = OneBitGates.rot
wr.write_controlled_one_bit_gate(
2, trols, gate, [ang_rads / 3, ang_rads * 2 / 3, ang_rads])
gate = OneBitGates.sigx
wr.write_one_bit_gate(2, gate)
wr.write_cnot(2, 1)
tar_bit_pos = 0
trols1 = Controls(num_bits)
trols1.bit_pos_to_kind = {1: 0, 2: 1, 3: True, 4: False}
trols1.refresh_lists()
wr.write_controlled_multiplexor_gate(
tar_bit_pos, trols1,
[ang_rads / 3, ang_rads * 2 / 3, ang_rads, ang_rads * 4 / 3])
trols2 = Controls(num_bits)
trols2.bit_pos_to_kind = {1: 0, 2: 1}
trols2.refresh_lists()
wr.write_multiplexor_gate(
tar_bit_pos, trols2,
[ang_rads / 3, ang_rads * 2 / 3, ang_rads, ang_rads * 4 / 3])
wr.close_files()
def __init__(self):
self.controls = Controls()
self.sensors = Sensors()
self.brains = AI()
def ControlsTool(self):
import Controls
reload(Controls)
controlsTool = Controls.Controls()
controlsTool.CreateUI()
