def sensitivity_sample_qoi(exp_q, dofhandler):
"""
Sample QoI by means of Taylor expansion
J(q+dq) ~= J(q) + dJdq(q)dq
"""
# Basis
phi = Basis(dofhandler, 'v')
phi_x = Basis(dofhandler, 'vx')
# Define problem
exp_q_fn = Nodal(data=exp_q, basis=phi)
primal = [Form(exp_q_fn, test=phi_x, trial=phi_x), Form(1, test=phi)]
adjoint = [Form(exp_q_fn, test=phi_x, trial=phi_x), Form(0, test=phi)]
qoi = [Form(exp_q_fn, test=phi_x)]
problems = [primal, adjoint, qoi]
# Define assembler
assembler = Assembler(problems)
#
# Dirichlet conditions for primal problem
#
assembler.add_dirichlet('left', 0, i_problem=0)
assembler.add_dirichlet('right', 1, i_problem=0)
# Dirichlet conditions for adjoint problem
assembler.add_dirichlet('left', 0, i_problem=1)
assembler.add_dirichlet('right', -1, i_problem=1)
# Assemble system
assembler.assemble()
# Compute solution and qoi at q (primal)
u = assembler.solve(i_problem=0)
# Compute solution of the adjoint problem
v = assembler.solve(i_problem=1)
# Evaluate J
J = u.dot(assembler.get_vector(2))
#
# Assemble gradient
#
ux_fn = Nodal(data=u, basis=phi_x)
vx_fn = Nodal(data=v, basis=phi_x)
k_int = Kernel(f=[exp_q_fn, ux_fn, vx_fn],
F=lambda exp_q, ux, vx: exp_q * ux * vx)
problem = [Form(k_int, test=phi)]
assembler = Assembler(problem)
assembler.assemble()
dJ = -assembler.get_vector()
return dJ
def test_pop_static():
translator = VM2ASM(annotate=True, no_init=True)
asm = translator.translate('pop static 1').dumps()
Assembler().assemble(asm)
print('pop static 1\n', asm)
translator = VM2ASM(annotate=True, no_init=True)
asm = translator.translate('pop static 0').dumps()
Assembler().assemble(asm)
print('pop static 0\n', asm)
def test_compat():
ASM.set_compat(True)
asm = EQ_Operation(compat=True).resolve()
Assembler(compat=True).assemble(str(asm))
try:
ASM.set_compat(False)
asm = EQ_Operation().resolve()
Assembler(compat=True).assemble(str(asm))
except:
pass
else:
assert False, 'Should have failed'
def test_push_static():
translator = VM2ASM(None, annotate=True, no_init=True)
translator.translate('push static 1')
asm = translator.dumps()
Assembler().assemble(asm)
print(asm)
translator = VM2ASM(None, annotate=True, no_init=True)
translator.translate('''
function foo 0
push static 1
return
''')
asm = translator.dumps()
Assembler().assemble(asm)
print(asm)
def test_add():
asm = ADD_Operation().resolve()
print(asm)
expected = ASM('''
// MACRO=LOAD_SP
@SP
A=M
// MACRO_END
// pop y into D
A=A-1
D=M
// pop x into M
A=A-1
// do the operation
M=M+D
// MACRO=DEC_SP
@SP
M=M-1
// MACRO_END
''')
assert str(asm) == str(expected)
# make sure it output valid assembly
assembler = Assembler()
assembler.assemble(str(asm))
def set_IR(
self,
TI=15
): #, REC=1000): # Function to modify SE -- call whenever acquiring a SE
params.ti = TI
self.change_IR(params.ti, self.seq_ir) #, REC)
self.assembler = Assembler()
byte_array = self.assembler.assemble(self.seq_ir)
# Implement new concept:
# com.set_sequence(byte_array)
socket.write(struct.pack('<I', 4 << 28))
socket.write(byte_array)
while (True): # Wait until bytes written
if not socket.waitForBytesWritten(): break
socket.setReadBufferSize(8 * self.size)
self.ir_flag = True
self.se_flag = False
self.fid_flag = False
print("\nIR sequence uploaded with TI = ", TI,
" ms.") #" and REC = ", REC, " ms.")
def test_subroutine(self):
"""
Verifies subroutine calls are assembled correctly
"""
instance = Assembler()
return_value = '../input/test11.asm' if sys.platform == 'win32' else 'input/test11.asm'
with mock.patch('builtins.input', return_value=return_value):
self.binary_content = [
('1010100000000010', 0), # JMPADDR start
('0000100100000101', 2), # LOADIM R1, #5
('0000101100000010', 4), # LOADIM R3, #2
('0000110100001010', 6), # LOADIM R5, #0A
('1111000000001100', 8), # call multiply_by_four
('1010010100000000', 10), # JMPRIND R5
('1000101000101100', 12), # SHIFTL R2, R1, R3
('1111100000000000', 14), # RETURN
]
self.hex_content = [
('A802', 0), # JMPADDR start
('0905', 2), # LOADIM R1, #5
('0B02', 4), # LOADIM R3, #2
('0D0A', 6), # LOADIM R5, #0A
('F00C', 8), # call multiply_by_four
('A500', 10), # JMPRIND R5
('8A2C', 12), # SHIFTL R2, R1, R3
('F800', 14), # RETURN
]
verify_ram_content_helper(self, instance)
self.binary_content.clear()
self.hex_content.clear()
def test_assembler_result_in_path(self):
assembler = Assembler(asm_path=self.ADD_ASM_FILE)
self.assertEqual(
assembler.hack_path,
self.EXPECTED_ADD_HACK_FILE,
)
def assembleClicked(self):
if not self.assemblyFilePath:
self.assemblyFilePath = os.path.dirname(
os.path.abspath(__file__)) + "\\assembly.asm"
self.binaryFilePath = self.assemblyFilePath[:self.assemblyFilePath.
rfind('/') +
1] + "binaryInstructions.txt"
with open(self.assemblyFilePath, 'w') as asmFile:
asmFile.write(self.assemblyEditor.toPlainText())
errorFlag = False
try:
Assembler(self.assemblyFilePath, self.binaryFilePath)
except:
errorFlag = True
print("Syntax error")
with open(self.binaryFilePath, 'r') as binaryFile:
self.machineCode.setPlainText(binaryFile.read())
if errorFlag is True:
count = 0
with open(self.binaryFilePath, 'r') as binaryFile:
for line in binaryFile:
count += 1
error_dialog = QtWidgets.QErrorMessage()
error_dialog.showMessage("Syntax error at {}".format(
int(count / 4 + 1)))
error_dialog.exec_()
def experiment01():
"""
Compute the quantity of interest, it's expectation and variance
"""
#
# FE Discretization
#
# Computational mesh
mesh = Mesh1D(resolution=(64, ))
# Element
element = QuadFE(mesh.dim(), 'DQ0')
dofhandler = DofHandler(mesh, element)
dofhandler.distribute_dofs()
# Linear Functional
mesh.mark_region('integrate',
lambda x: x > 0.75,
entity_type='cell',
strict_containment=False)
phi = Basis(dofhandler)
assembler = Assembler(Form(1, test=phi, flag='integrate'))
assembler.assemble()
L = assembler.get_vector()
def __init__(self,
sequencefile: seq.SequenceFile = None,
f_Ex: float = None,
T_val: int = None,
numSamples: int = 2000,
shim: list = None):
"""
Initialization of spectrum operation class
@param sequencefile: given sequence
@param f_Ex: excitation frequency
@param T_val: time value (TE, TI...)
@param numSamples: number of samples to be acquired
@param shim: Shim values for operation
@return: None
"""
# make sure, shim is a len=4 array
if shim is None:
shim = [0, 0, 0, 0]
while len(shim) < 4:
shim += [0]
# set class variables
self.f_Ex: float = f_Ex
self.T_val: int = T_val
self.numSamples: int = numSamples
self.sequencefile = sequencefile
self.sequencebytestream = Assembler().assemble(self.sequencefile.path)
self.shim_x: int = shim[0]
self.shim_y: int = shim[1]
self.shim_z: int = shim[2]
self.shim_z2: int = shim[3]
def __init__(self,
sequencefile: seq.SequenceFile = None,
relaxationtype: relaxtyp = None,
f_Ex: float = None,
Tval_min: int = None,
Tval_max: int = None,
numTimeValues=20,
numSamplesPerTimeValue: int = 2000,
numAveragesPerTimeValue: int = 5):
"""
Initialization of spectrum operation class
@param sequencefile: given sequence
@param relaxationtype: type of relaxation to be measured (T1, T2)
@param f_Ex: excitation frequency
@param Tval_min: lowest time value (TI, TE)
@param Tval_max: max time value (logarithmic scaling between Tval_min/max)
@param numTimeValues: number of time values (TI, TE) to be measured
@param numSamplesPTV: sample size for each T_val
@param numAveragesPTV: number of measurements for each T_val (get averaged)
@return: None
"""
# set class variables
self.sequencefile = sequencefile
self.sequencebytestream = Assembler().assemble(self.sequencefile.path)
self.relaxationtype = relaxationtype
self.f_Ex: float = f_Ex
self.numTimeValues: int = numTimeValues
self.numSamplesPerTimeValue: int = numSamplesPerTimeValue
self.numAveragesPerTimeValue: int = numAveragesPerTimeValue
self.tval_min: int = Tval_min
self.tval_max: int = Tval_max
def assembler(self):
i = 0
# Obtains last name on path string using ntpath and then
# strips file extension using os.path.splitext
# Should work across different OS
filename = os.path.splitext(ntpath.basename(EVENTS['FILE_PATH']))[0]
try:
asm = Assembler(filename=EVENTS['FILE_PATH'])
asm.read_source()
asm.store_instructions_in_ram()
verify_ram_content()
hexify_ram_content()
output_file_location = 'output/' + filename + '.obj'
f = open(output_file_location, 'w')
while i < 100:
f.write(f'{RAM[i]} {RAM[i + 1]}' + '\n')
i += 2
f.close()
# Runs simulator using generated .obj file
self.run_micro_sim(output_file_location)
except (AssertionError, FileNotFoundError, ValueError, MemoryError,
KeyError, SyntaxError) as e:
traceback.print_exc()
toast(f'{e}')
def test_assemble_iiform(self):
mesh = Mesh1D(resolution=(1, ))
Q1 = QuadFE(1, 'DQ1')
dofhandler = DofHandler(mesh, Q1)
dofhandler.distribute_dofs()
phi = Basis(dofhandler, 'u')
k = Explicit(lambda x, y: x * y, n_variables=2, dim=1)
kernel = Kernel(k)
form = IIForm(kernel, test=phi, trial=phi)
assembler = Assembler(form, mesh)
assembler.assemble()
Ku = Nodal(lambda x: 1 / 3 * x, basis=phi)
#af = assembler.af[0]['bilinear']
M = assembler.get_matrix().toarray()
u = Nodal(lambda x: x, basis=phi)
u_vec = u.data()
self.assertTrue(np.allclose(M.dot(u_vec), Ku.data()))
def test_assemble_ipform(self):
# =====================================================================
# Test 7: Assemble Kernel
# =====================================================================
mesh = Mesh1D(resolution=(10, ))
Q1 = QuadFE(1, 'DQ1')
dofhandler = DofHandler(mesh, Q1)
dofhandler.distribute_dofs()
phi = Basis(dofhandler, 'u')
k = Explicit(lambda x, y: x * y, n_variables=2, dim=1)
kernel = Kernel(k)
form = IPForm(kernel, test=phi, trial=phi)
assembler = Assembler(form, mesh)
assembler.assemble()
#af = assembler.af[0]['bilinear']
M = assembler.get_matrix().toarray()
u = Nodal(lambda x: x, basis=phi)
v = Nodal(lambda x: 1 - x, basis=phi)
u_vec = u.data()
v_vec = v.data()
I = v_vec.T.dot(M.dot(u_vec))
self.assertAlmostEqual(I[0, 0], 1 / 18)
def get_elite(generation, board):
elits = []
_elits = generation[:Const.ELITE_Q]
for hunter in _elits:
elite_hunter = Assembler(hunter.orig_memory, board)
elits.append(elite_hunter)
return elits
def ensamblar(self):
if not self.fileOpener(): return
ens = Assembler(self.filename)
ens.leerArchivo()
try:
ens.first_pass()
ens.Second_pass()
ens.print_tabla()
except Exception as ex:
self.newWindow = tk.Toplevel(self.master)
self.pop = PopUP(self.newWindow)
self.pop.addMessage("Error", str(ex))
return
fileOut = open(self.directory + "out.obj", "w+")
for line in ens.CO:
fileOut.write(line + "\n")
fileOut.close()
self.newWindow = tk.Toplevel(self.master)
self.pop = PopUP(self.newWindow)
self.pop.addMessage("Información",
"Archivo .obj creado en: \n" + self.directory)
def start(self):
print("Starting MRI_SE_Widget")
# send 2 as signal to start MRI_SE_Widget
gsocket.write(struct.pack('<I', 2))
# enable/disable GUI elements
self.startButton.setEnabled(False)
self.stopButton.setEnabled(True)
self.gradOffset_x.setEnabled(True)
self.gradOffset_y.setEnabled(True)
self.gradOffset_z.setEnabled(True)
self.gradOffset_z2.setEnabled(True)
self.acquireButton.setEnabled(True)
self.saveShimButton.setEnabled(True)
self.loadShimButton.setEnabled(True)
self.zeroShimButton.setEnabled(True)
self.zoomCheckBox.setEnabled(True)
self.peakWindowCheckBox.setEnabled(True)
self.cycAcqBtn.setEnabled(False)
self.cyclesValue.setEnabled(False)
# setup global socket for receive data
gsocket.readyRead.connect(self.read_data)
# send the sequence to the backend
ass = Assembler()
seq_byte_array = ass.assemble(self.seq_filename)
print(len(seq_byte_array))
gsocket.write(struct.pack('<I', len(seq_byte_array)))
gsocket.write(seq_byte_array)
self.load_shim()
self.idle = False
def deobfuscate(codestring):
# Instructions are stored as a string, we need
# to convert it to an array of the raw bytes
insBytes = bytearray(codestring)
oep = find_oep(insBytes)
logger.info('Original code entrypoint at {}'.format(oep))
logger.info('Starting control flow analysis...')
disasm = Disassembler(insBytes, oep)
disasm.find_leaders()
disasm.construct_basic_blocks()
disasm.build_bb_edges()
logger.info('Control flow analysis completed.')
logger.info('Starting simplication of basic blocks...')
render_graph(disasm.bb_graph, 'before.svg')
simplifier = Simplifier(disasm.bb_graph)
simplifier.eliminate_forwarders()
render_graph(simplifier.bb_graph, 'after_forwarder.svg')
simplifier.merge_basic_blocks()
logger.info('Simplification of basic blocks completed.')
simplified_graph = simplifier.bb_graph
render_graph(simplified_graph, 'after.svg')
logger.info('Beginning verification of simplified basic block graph...')
if not verify_graph(simplified_graph):
logger.error('Verification failed.')
raise SystemExit
logger.info('Verification succeeded.')
logger.info('Assembling basic blocks...')
asm = Assembler(simplified_graph)
codestring = asm.assemble()
logger.info('Successfully assembled. ')
return codestring
def test_assemble(self):
from assembler import Assembler
assbl = Assembler(sequences, identifiers)
assbl._find_matching_pairs = MagicMock(return_value=(map_top_bottom,
map_bottom_top))
assbl._determine_order = MagicMock(return_value=order)
self.assertEqual(assbl.assemble(), assembled_seq)
def start(self):
print("Starting MRI_FID_Widget")
# send 1 as signal to start MRI_FID_Widget
gsocket.write(struct.pack('<I', 1))
# enable/disable GUI elements
self.startButton.setEnabled(False)
self.stopButton.setEnabled(True)
self.applyFreqButton.setEnabled(True)
self.gradOffset_x.setEnabled(True)
self.gradOffset_y.setEnabled(True)
self.gradOffset_z.setEnabled(True)
self.gradOffset_z2.setEnabled(True)
self.acquireButton.setEnabled(True)
self.saveShimButton.setEnabled(True)
self.loadShimButton.setEnabled(True)
self.zeroShimButton.setEnabled(True)
self.openFlipangletoolBtn.setEnabled(True)
# setup global socket for receive data
gsocket.setReadBufferSize(8 * self.size)
gsocket.readyRead.connect(self.read_data)
# send the sequence to the backend
ass = Assembler()
seq_byte_array = ass.assemble(self.seq_filename)
print(len(seq_byte_array))
gsocket.write(struct.pack('<I', len(seq_byte_array)))
gsocket.write(seq_byte_array)
self.load_shim()
self.idle = False
def reset(self):
###
#self.generate_routefile_two_intersections()
self.generate_routefile()
traci.load([
"-c", "one_lane/one_lane4.sumocfg", "--collision.check-junctions",
"1", "--start", '--no-step-log', 'true'
])
###
#traci.load(["-c", "one_intersection_w_priority/one_intersection_w_priority.sumocfg", "--collision.check-junctions", "1", "--start"])
run = Assembler(self.carID)
terminate = False
while terminate == False:
num_vec = traci.vehicle.getIDList()
for i in range(len(num_vec)):
if num_vec[i] != 'ego':
traci.vehicle.setLaneChangeMode(num_vec[i], 512)
self.output = run.getTensor()
if self.output is not None:
terminate = True
traci.simulationStep()
return self.getObservation()
def test_determine_order(self):
from assembler import Assembler
assbl = Assembler(sequences, identifiers)
c = map_top_bottom
d = map_bottom_top
o = assbl._determine_order(c, d)
self.assertEqual(o, order)
def sub_test_ALU(self, name, opcode):
code = f'''
{name} A,B
{name} D
{name} (HL)
{name} A, (HL)
{name} A, A
{name} A
{name} L
{name} A, 9
{name} $90
{name} lab
{name} A, lab
lab:
'''
p = Assembler(code).get_patch()
self.assertEqual({
0: opcode | 0x80,
1: opcode | 0x82,
2: opcode | 0x86,
3: opcode | 0x86,
4: opcode | 0x87,
5: opcode | 0x87,
6: opcode | 0x85,
7: opcode | 0xC6, 8: 9,
9: opcode | 0xC6, 10: 0x90,
11: opcode | 0xC6, 12: 15,
13: opcode | 0xC6, 14: 15,
}, p)
def test_goto():
translator = VM2ASM(no_init=True)
asm = translator.translate('''
label abc
goto abc
''').dumps()
Assembler().assemble(asm)
def main():
p = open('demo.s', 'r')
a = Assembler(p)
print('')
test_func1(a)
print('')
test_func2(a)
print('')
def test_find_matching_pairs(self):
from assembler import Assembler
assbl = Assembler(sequences)
a, b, c, d = assbl._find_matching_pairs()
self.assertEqual(c, top_ranges_dict)
self.assertEqual(d, bottom_ranges_dict)
self.assertEqual(a, top_seq_dict)
self.assertEqual(b, bottom_seq_dict)
def make_top(self, args):
if args.E:
return None
from assembler import Assembler
assembler = Assembler()
assembler.parse(self.text_file().read(), self.infile.name)
assembler.finish()
return assembler.top
def test_call():
translator = VM2ASM(no_init=True)
asm = translator.translate('''
function FOO 3
call FOO 3
''').dumps()
Assembler().assemble(asm)
print(asm)
def test_label_in_function():
translator = VM2ASM(no_init=True)
asm = translator.translate('''
function HELLO 0
label WORLD
''').dumps()
assert '_in_memory_.HELLO.WORLD' in asm
Assembler().assemble(asm)
