def __init__(self, size):
self.size = size
self.__core = []
for _ in range(size):
def_ins = instruction.Instruction(None, self.size, "DAT", "F", "$",
0, "$", 0)
self.__core.append(def_ins) # fill core with DAT instructions
self.ins_reg = register.Register() # instruction register
self.src_reg = register.Register() # source register
self.dst_reg = register.Register() # destination register
self.wariors = []
self.curr_warior_index = 0
self.gui = None
def __init__(self):
if self.__initialized:
return
import register
self.__initialized = True
self.regs = register.Register()
self._read_status()
def __init__(self, parent, name, address, length_bytes,
device_info, ctrlreg_address):
"""
Make the QDR instance, given a parent, name and info from Simulink.
"""
super(Qdr, self).__init__(name=name, width_bits=32,
address=address, length_bytes=length_bytes)
self.parent = parent
self.block_info = device_info
self.which_qdr = self.block_info['which_qdr']
self.ctrl_reg = register.Register(
self.parent, self.which_qdr+'_ctrl', address=ctrlreg_address,
device_info={'tag': 'xps:sw_reg', 'mode': 'one\_value',
'io_dir': 'From\_Processor', 'io_delay': '0',
'sample_period': '1', 'names': 'reg',
'bitwidths': '32', 'arith_types': '0',
'bin_pts': '0', 'sim_port': 'on',
'show_format': 'off'})
self.memory = self.which_qdr + '_memory'
self.control_mem = self.which_qdr + '_ctrl'
# self.qdr_cal()
# some readability tweaks
self.p_write_int = self.parent.write_int
self.p_read_uint = self.parent.read_uint
self.p_bwrite = self.parent.blindwrite
self.p_read = self.parent.read
# print('QDR %s logger name(%s) id(%i) level(%i)' % ()
# self.name, LOGGER.name, id(LOGGER), LOGGER.level)
# print('qdr logger handlers:', LOGGER.handlers)
LOGGER.debug('New Qdr %s' % self)
def post(self):
print "UserRegAPI"
args = self.reqparse.parse_args()
logging.warning(args)
reg = register.Register(args['Username'], args['UserID'],
args['Email'], args['Password'])
msg = reg.doRegister()
if (msg == "Register successfully!"):
return {"state": msg}, 201
return {"state": msg}, 450
def __init__(self):
if self.__initialized:
return
self.__initialized = True
import register
import eder_status
import eder_logger
self.regs = register.Register()
self.status = eder_status.EderStatus()
self.logger = eder_logger.EderLogger()
def __init__(self):
if self.__initialized:
return
import register
import adc
import amux
self.__initialized = True
self.regs = register.Register()
self.amux = amux.Amux(self.regs)
self.adc = adc.Adc()
self.meas_amp_vcm = self._read_adc(0x80 | self.amux.amux_dco_cm)
def Grovers(nq, s, cOut, Sparse=False):
""" Actual function running grover's algorithm.
Capable of adapting gates dynamically depending on the target state and number of
qubits selected by user.
Parameters
----------
nq : type
Description of parameter `nq`.
s : type
Denary representation of state.
Returns
-------
register.Register, int
The custom register object starts as a uniform superposition of States
which is then put through Grover's algorithm 'it' times and the heavily
weighted (towards target state) register is returned at the end.
Dt is the time interval that it took to run Grovers 'it' times on
register.
"""
if cOut:
print('\n' + "-------Making gates------:")
print("Making Hadamard")
H = Hadamard(nq, Sparse)
if cOut:
print("Making Oracle")
Orac = Oracle(nq, s, Sparse)
if cOut:
print("Making Diffusion Operator" + '\n')
Diff = Diffuser(nq, Sparse)
#Initialising Register in a uniform superposition
if cOut:
print("-------Initialising Register-------" + '\n')
#pass an n-qbit determinate state 0
R = re.Register(qs.State((0, nq)))
start_time = time.time()
#n-dimensional hadamard creates uniform superposition of states up until state(2**nq)
R.applyGate(H, Sparse)
#Iterating -it times (most accurate order of iteration, ussually simply quoted as root(n))
it = int(np.pi / (4 * np.arcsin(1 / np.sqrt(2**nq))))
if cOut:
print('\n' + f"Running Grover's, {it} times:")
for i in range(it):
R.applyGate(Orac, Sparse)
R.applyGate(H, Sparse)
R.applyGate(Diff, Sparse)
R.applyGate(H, Sparse)
Dt = time.time() - start_time
return R, Dt
def registerform():
form = register.Register()
if form.validate_on_submit():
fd = form.data
del fd['submit']
del fd['csrf_token']
rc = register.Chapter(**fd)
db.add(rc)
db.commit()
flash("Added " + form.university.data + " Chapter")
return redirect(url_for("home"))
return render_template("register.html", form=form)
def __init__(self, encoder, encodeData=True, encodeWords=True):
self.encodeWord = encoder.encodeWord if encodeWords else lambda x: x
self.encodeData = encoder.encodeData if encodeData else lambda x: x
self.decodeData = encoder.decodeData if encodeData else lambda x: x
self.encodedPrevWord = None
# self.tagset = tagset
self.initialState = state.State()
self.register = register.Register()
self.label2Freq = {}
self.n = 0
self.closed = False
def __init__(self):
if self.__initialized:
return
import adc
import amux
import register
import eder_logger
self.regs = register.Register()
self.amux = amux.Amux(self.regs);
self.adc = adc.Adc();
self.logger = eder_logger.EderLogger()
self.__initialized = True
def __init__(self):
if self.__initialized:
return
import register
import rx_iq_meas
import temp
import eder_status
import eder_logger
self.__initialized = True
self.regs = register.Register()
self.rx_iq_meas = rx_iq_meas.RxIQMeas()
self.temp = temp.Temp()
self.status = eder_status.EderStatus()
self.logger = eder_logger.EderLogger()
def Register(self):
message = []
a = register.Register(message)
a.exec_()
if message == []:
return
if message[-1] == "用户":
self.DataBase.addpassenger(message[0], message[1], message[2],
int(message[3]), int(message[4]),
int(message[5]), message[6])
else:
self.DataBase.addadministrator(message[0], message[1], message[2],
int(message[3]), int(message[4]),
int(message[5]), message[6])
def __init__(self):
if self.__initialized:
return
import register
import rx_iq_meas
import rx
import eder_status
import eder_logger
self.__initialized = True
self.regs = register.Register()
self.iq_meas = rx_iq_meas.RxIQMeas()
self.rx = rx.Rx()
self._decToVolt = self.iq_meas._decToVolt
self.status = eder_status.EderStatus()
self.logger = eder_logger.EderLogger()
def main():
wifi.do_connect(True)
netTim = Timer(1)
netTim.init(period=60000, mode=Timer.PERIODIC, callback=checkWifi)
sn = 'ESP' + chipid()
title = 'Device' + sn
product_id = 'YourProductID'
regKey = 'YourEvnRegistKey'
url = 'http://api.heclouds.com/register_de?register_code=' + regKey
reg = register.Register(url=url, title=title, sn=sn)
if reg.regist()==0:
mq = mqtt.mqtt(client_id=reg.device_id, username=product_id, password=reg.key)
mq.connect()
else:
print('Error: No Client ID!')
def __init__(self):
if self.__initialized:
return
self.__initialized = True
import register
import amux
import adc
import temp
import eder_status
import eder_logger
self.regs = register.Register()
self.status = eder_status.EderStatus()
self.logger = eder_logger.EderLogger()
self.amux = amux.Amux(self.regs)
self.adc = adc.Adc()
self.temp = temp.Temp()
def __init__(self):
if self.__initialized:
return
self.__initialized = True
import register
import eder_status
import eder_logger
import adc
import amux
self.regs = register.Register()
self.adc = adc.Adc()
self.amux = amux.Amux(self.regs)
self.logger = eder_logger.EderLogger()
self.dcip = []
self.dcin = []
self.dcqp = []
self.dcqn = []
def __init__(self):
if self.__initialized:
return
self.__initialized = True
import ref
import vco
import register
import eder_status
import eder_logger
import temp
import adc
self.adc = adc.Adc()
self.temp = temp.Temp()
self.regs = register.Register()
self.ref = ref.Ref()
self.vco = vco.Vco()
self._status = eder_status.EderStatus()
self.logger = eder_logger.EderLogger()
def __init__(self, parent, name, address, length_bytes, device_info, ctrlreg_address):
"""
Make the QDR instance, given a parent, name and info from Simulink.
"""
super(Qdr, self).__init__(
name=name, width_bits=32, address=address, length_bytes=length_bytes)
self.parent = parent
self.block_info = device_info
self.which_qdr = self.block_info['which_qdr']
self.ctrl_reg = register.Register(
self.parent, self.which_qdr+'_ctrl', address=ctrlreg_address,
device_info={'tag': 'xps:sw_reg', 'mode': 'one\_value',
'io_dir': 'From\_Processor', 'io_delay': '0',
'sample_period': '1', 'names': 'reg', 'bitwidths': '32',
'arith_types': '0', 'bin_pts': '0', 'sim_port': 'on',
'show_format': 'off'})
self.memory = self.which_qdr + '_memory'
self.control_mem = self.which_qdr + '_ctrl'
# self.qdr_cal()
LOGGER.debug('New Qdr %s' % self)
def login(self):
if not self.valida_all_input():
self.fail_info.set('登录失败！')
self.login_fail.configure(foreground='red')
self.update()
return
reg = register.Register(self.host)
print(self.user.get(),self.password.get())
try:
self.fail_info.set('正在登录')
self.login_fail.configure(foreground='blue')
self.update()
time.sleep(3)
reg.login_session(self.user.get(),self.password.get())
self.destroy()
ui_work.CreateDataUi()
except:
print('登录失败')
self.fail_info.set('登录失败！')
self.login_fail.configure(foreground='red')
def __init__(self):
if self.__initialized:
return
self.__initialized = True
import register
import adc
import pll
import eder_status
import eder_logger
import rx
import tx
self.regs = register.Register()
self.adc = adc.Adc()
self.pll = pll.Pll()
self.status = eder_status.EderStatus()
self.logger = eder_logger.EderLogger()
self.rx = rx.Rx()
self.tx = tx.Tx()
def __init__(self):
if self.__initialized:
return
self.__initialized = True
import alc
import bf
import register
import memory
import gpio
import tx_dco
import eder_logger
import eder_status
self.regs = register.Register()
self.mems = memory.Memory()
self.gpio = gpio.EderGpio(self.regs.board_type)
self.alc = alc.Alc()
self.bf = bf.Bf(bf.Bf.TX)
self.dco = tx_dco.TxDco()
self.logger = eder_logger.EderLogger()
self.status = eder_status.EderStatus()
def __init__(self):
if self.__initialized:
return
self.__initialized = True
import bf
import agc
import pll
import rx_dco
import temp
import register
import memory
import gpio
import eder_logger
import eder_status
self.regs = register.Register()
self.mems = memory.Memory()
self.gpio = gpio.EderGpio(self.regs.board_type)
self.bf = bf.Bf(bf.Bf.RX)
self.agc = agc.Agc()
self.pll = pll.Pll()
self.dco = rx_dco.RxDco()
self.temp = temp.Temp()
self.logger = eder_logger.EderLogger()
self.status = eder_status.EderStatus()
def __init__(
self, program
): # accumulator extended register index register
self.Registers = [
register.Register(16, True, True, (0, 0), False),
register.Register(16, True, True, (0, 0), False),
register.Register(16, True, True, (0, 0), False)
]
# Flags = zero = one
self.Registers += [
register.Register(16, False, True, (0, 0), True),
register.Register(16, False, False, (0, 0), False),
register.Register(16, False, False, (0, 1), False)
]
# = all ones jump register
self.Registers += [
register.Register(16, False, False, (0, 0xffff), False),
register.Register(16, True, True, (0, 0), False)
]
# =General purpose regs
self.Registers += [
register.Register(16, True, True, (0, 0), False),
register.Register(16, True, True, (0, 0), False),
register.Register(16, True, True, (0, 0), False),
register.Register(16, True, True, (0, 0), False),
register.Register(16, True, True, (0, 0), False),
register.Register(16, True, True, (0, 0), False),
register.Register(16, True, True, (0, 0), False),
register.Register(16, True, True, (0, 0), False)
]
self.ALU = ALU.ALU(self.Registers[0], self.Registers[1],
self.Registers[3])
self.Memory = memory.Memory(program, self.Registers[2])
self.PC = ProgramCounter.PC(self.Memory, self.Registers[2])
self.Stack = stack.Stack(self.Registers[3], 64)
self.halt = 0
self.instr_count = 0
self.Output = OutputUnit.OutputUnit()
def register_show(self):
self.sign_up = register.Register()
self.sign_up.show()
def register(self):
import register
self.f.destroy()
register.Register(self.master)
#self.getQingdan_50(k)
#else:
#self.getAllContents(k)
#self.driver.page_source()
#print("开始写入ini文件......")
#if self.dataStyle == '100' and len(self.danpinIdList) > 0:
#for indexId in self.danpinIdList:
#self.set_data(self.dataStyle)
self.saveConfig()
self.tearDown()
except Exception as e:
logging.error('运行异常，异常信息：{}'.format(e))
self.tearDown()
def tearDown(self):
# 退出Chrome浏览器
self.driver.quit()
#os.system('taskkill /im chromedriver.exe /F')
if __name__ == '__main__':
#print(u"请输入首页ID号：")
#homeId = input(u"请输入首页ID号，然后回车：")
print(u"启动京东达人[oneKeyCopy],版本号:%s" % ver)
if register.Register() == 1:
cp = copyContents()
cp.startRun()
else:
logging.error('程序注册失败')
time.sleep(2)
sys.exit()
def __init__(self,program): # accumulator extended register index register
self.Registers = [register.Register(16,True,True,(0,0),False),register.Register(16,True,True,(0,0),False),register.Register(16,True,True,(0,0),False)]
# Flags = zero = one
self.Registers += [register.Register(16,False,True,(0,0),True),register.Register(16,False,False,(0,0),False),register.Register(16,False,False,(0,1),False)]
# = all ones jump register
self.Registers += [register.Register(16,False,False,(0,0xffff),False),register.Register(16,True,True,(0,0),False)]
# =General purpose regs
self.Registers += [register.Register(16,True,True,(0,0),False),register.Register(16,True,True,(0,0),False),register.Register(16,True,True,(0,0),False),
register.Register(16,True,True,(0,0),False),register.Register(16,True,True,(0,0),False),register.Register(16,True,True,(0,0),False),
register.Register(16,True,True,(0,0),False),register.Register(16,True,True,(0,0),False)]
self.ALU = ALU.ALU(self.Registers[0],self.Registers[1],self.Registers[3])
self.Memory = memory.Memory(program,self.Registers[2])
self.PC = ProgramCounter.PC(self.Memory,self.Registers[2])
self.Stack = stack.Stack(self.Registers[3],64)
self.halt = 0
self.instr_count = 0
self.Output = OutputUnit.OutputUnit()
self.instruction_list = [
"HLT",
"ADD",
"SUB",
"MUL",
"DIV",
"MOD",
"AND",
"ORR",
"XOR",
"NOT",
"NND",
"NOR",
"XNR",
"SHR",
"SHL",
"ROR",
"ROL",
"MOV",
"LOD",
"STR",
"PUS",
"POP",
"JMP",
"GTO",
"CMP",
"CJP",
"CGT",
"OUT"
]
def __init__(self, names, saldos):
self.accounts={k:register.Register(s) for k,s in zip(names, saldos)}
import falcon
import converter
import register
class CorsMiddleware(object):
def process_request(self, request, response):
origin = request.get_header('Origin')
response.set_header('Access-Control-Allow-Origin', '*')
response.set_header('Access-Control-Allow-Headers', 'X-Typeform-Key')
api = application = falcon.API(middleware=[CorsMiddleware()])
converter = converter.Converter()
api.add_route('/converter', converter)
register = register.Register()
api.add_route('/register', register)
def usr_register(self):
# print('开始注册')
register.Register(self.login_widget)
