def enclose(function, variable, name=None): """Given a function f(x0, x1...), write a function f(x0, x1...) - variable. For example, if the argument function corresponds to 'x**2 + sin(y) + c', the return function will correspond to '(x**2 + sin(y) + c) - variable'. This is useful if, for instance, we have a model with a constraint or objective function g(x0, x1...) and need to introduce a new variable which is constrained to be equal to the value of g. If the argument function is linear (that is, an instance of functions.Linear,) so is the return function. Otherwise, the first and second derivative caches are preserved, and the first derivative wrt variable is filled in. """ if isinstance(function, Linear): new_coefficients = {'variable': -1} new_coefficients.update(function.coefficients) return Linear(new_coefficients, name=name) new_expr = '(%s) - %s' % (function.math, variable) new_variables = function.variables.copy() new_variables.add(variable) new_function = Function(new_expr, variables=new_variables, first_derivatives=function._first_derivatives, second_derivatives=function._second_derivatives, name=name) new_function._first_derivatives[variable] = '-1.' return new_function
def set_objective(self, objective_id, expression): """ Set the objective function of the problem. The existing objective function will be lost. """ self.objective_function = Function(expression, name=objective_id)
def make_function(inputs, outputs, updates=None, givens=None): if isinstance(outputs, list): return Function(inputs, outputs, updates, givens=givens) elif isinstance(outputs, (dict, collections.OrderedDict)): raise NotImplemented() else: f = Function(inputs, [outputs], updates, givens=givens) return lambda *args, **kwargs: f(*args, **kwargs)[0]
def takeFactor(self, tokens): now = tokens.front() if now == '(': try: tokens.popFront() exp = self.takeExpression(tokens) tokens.popFront() except IndexError: raise InvalidFormula() return Paranthesis(exp) elif Function.isSingleParamFunction(now) == True: try: self.functions.add(now) tokens.popFront() lparan = tokens.popFront() exp = self.takeExpression(tokens) rparan = tokens.popFront() if (lparan == '(' and rparan == ')') == False: raise InvalidFormula() except IndexError: raise InvalidFormula() return Function.determine(now, param=exp) elif Function.isDoubleParamFunction(now) == True: try: self.functions.add(now) tokens.popFront() lparan = tokens.popFront() exp1 = self.takeExpression(tokens) tokens.popFront() exp2 = self.takeExpression(tokens) rparan = tokens.popFront() if (lparan == '(' and rparan == ')') == False: raise InvalidFormula() except IndexError: raise InvalidFormula() return Function.determine(now, base=exp1, exponential=exp2) elif Number.isNumber(now) == True: tokens.popFront() return Number.determine(now) elif now == '-': try: tokens.popFront() fac = self.takeFactor(tokens) term = Term([Number(-1), fac], ['*']) expr = Expression([term], []) except IndexError: raise InvalidFormula() return Paranthesis(expr) elif Variable.isVariable(now) == True: tokens.popFront() return Variable(now) else: raise InvalidFormula()
def takeFactor(self, tokens): now = tokens.front() if now == '(': try: tokens.popFront() exp = self.takeExpression(tokens) tokens.popFront() except IndexError: raise InvalidFormula() return Paranthesis(exp) elif Function.isSingleParamFunction(now)==True: try: self.functions.add(now) tokens.popFront() lparan=tokens.popFront() exp = self.takeExpression(tokens) rparan=tokens.popFront() if (lparan=='(' and rparan==')')==False: raise InvalidFormula() except IndexError: raise InvalidFormula() return Function.determine(now, param=exp) elif Function.isDoubleParamFunction(now)==True: try: self.functions.add(now) tokens.popFront() lparan=tokens.popFront() exp1 = self.takeExpression(tokens) tokens.popFront() exp2 = self.takeExpression(tokens) rparan=tokens.popFront() if (lparan=='(' and rparan==')')==False: raise InvalidFormula() except IndexError: raise InvalidFormula() return Function.determine(now, base=exp1, exponential=exp2) elif Number.isNumber(now)==True: tokens.popFront() return Number.determine(now) elif now == '-': try: tokens.popFront() fac = self.takeFactor(tokens) term=Term([Number(-1),fac],['*']) expr=Expression([term],[]) except IndexError: raise InvalidFormula() return Paranthesis(expr) elif Variable.isVariable(now)==True: tokens.popFront() return Variable(now) else: raise InvalidFormula()
def set_unitary(self, V): """Parse input and set the unitary operator attributes. This also sets up the potential function attributes in the process. """ if isinstance(V, str): try: if V.strip().replace(".", "").replace("-", "").replace("e", "").isnumeric(): self.V_name = "" self.V_latex = str(np.round(float(V), 2)) if float(V) == 0: V = 1e-30 V_f = float(V) * np.ones([self.N]) self.U_t = UnitaryOperator1D(np.copy(V_f)) self.V_x = 0.0 * V_f else: V_f = scale(float(V) * np.ones([self.N]), 15) self.V_x = V_f self.U_t = UnitaryOperator1D(np.copy(V_f)) self.V_latex = "%sk" % (self.V_latex) if V_f[0] > 0\ else " %sk" % (self.V_latex) self.V_params = {} self.V_base = None else: V = V.replace("^", "**") f = Function(V, "x") self.V = lambda x: f(x, *f.get_tupled_default_values()) self.V_x = scale(self.V(self.x), 15) self.V_name = str(f) self.V_latex = "$" + f.multiply_latex_string("k") + "$" self.U_t = UnitaryOperator1D(self.V) self.V_base = f self.V_params = f.get_enumerated_default_values() except (TypeError, AttributeError, SyntaxError, ValueError, NameError) as E: print(E) elif isinstance(V, np.ndarray): self.V_params = {} self.V_base = None self.V = None self.V_x = scale(V, 15) self.V_name = "V(x)" self.V_latex = "$V(x)$" self.U_t = UnitaryOperator1D(V) else: print("Unable to parse input") if hasattr(self, "lines"): self.update_draw_potential()
def __init__(self): self.functions = { 'EXP': Function(np.exp), 'LOG': Function(np.log), 'SIN': Function(np.sin), 'COS': Function(np.cos), 'SQRT': Function(np.sqrt) } self.operators = { 'PLUSS': Operator(np.add, 0), 'GANGE': Operator(np.multiply, 1), 'DELE': Operator(np.divide, 1), 'MINUS': Operator(np.subtract, 0) }
class Layout_Aesthetics(object): layout_theme = { "margin": 0, "border_width": 1 if Function.screen_count() > 1 else 2, "border_focus": Colors.yellow[0], "border_normal": Colors.grey[0], "fontsize": 12 if Function.screen_count() > 1 else 22, "section_fontsize": 12 if Function.screen_count() > 1 else 22, } floating_layout = Floating( border_width=1 if Function.screen_count() > 1 else 2, border_focus=Colors.yellow[0], border_normal=Colors.black[0], )
def iter_test(self, func_name, dim_count): ''' Runs the PSO algorithm given the initialization parameters, outputting a list of the best values from the run ''' bests = [] func = Function(func_name)(dim_count) self.pop = self._generate_pop(self.size, func) p_min = min(self.pop) self.best = np.copy(p_min.position) self.best_val = p_min.val bests.append(self.best_val) for _ in xrange(self.gen): self.pop = [ p.map_eval(self.best, self.alpha, self.beta) for p in self.pop ] p_min = min(self.pop) if p_min.val < self.best_val: self.best = np.copy(p_min.position) self.best_val = p_min.val bests.append(self.best_val) return np.array(bests)
def test(func_name, dimension_count, iteration_count, sample_count, cpu_count): ''' this function will run all metaheurstic algorithms against the given function for the specified amount of samples. the mean value will be output in a file for each algorithm for each iteration, showcasing the convergence over time ''' fun = Function(func_name)(dimension_count) xstar = fun.eval(fun.xstar) f_n = Population(iteration_count, 40, 0.1, 1.0, 1.0) f_b = Population(iteration_count, 40, 0.5, 1.0, 1.0) f_c = Population(iteration_count, 40, 1.0, 1.0, 1.0) pso = PSO(iteration_count, 40, 2.0, 2.0) sma = SA(1000, 0.01) samples = [[], [], [], [], []] calc_mean = lambda a: np.mean(np.array(a), axis=0) with open('./data/' + func_name + '.dat', 'w') as out_file: try: out_file.write('iters xstar fa faboltz facauchy pso sa\n') for _ in range(sample_count): samples[0].append( f_n.iter_test(func_name, dimension_count, Population.NONE, cpu_count)) samples[1].append( f_b.iter_test(func_name, dimension_count, Population.BOLTZMANN, cpu_count)) samples[2].append( f_c.iter_test(func_name, dimension_count, Population.CAUCHY, cpu_count)) samples[3].append(pso.iter_test(func_name, dimension_count)) samples[4].append( sma.iter_test(func_name, dimension_count, iteration_count, SA.CAUCHY)) # we add 1 to count for the initial case final = np.array([np.arange(iteration_count + 1)] + [np.array([xstar] * (iteration_count + 1))] + [calc_mean(data) for data in samples]) for line in final.T: line.toout_file(file, sep='\t') out_file.write('\n') except Exception as exc: out_file.write(str(exc))
def set_wavefunction(self, psi, normalize=True): """Parse input to set the wavefunction attributes. """ if isinstance(psi, str): try: if psi.strip().replace(".", "").replace("-", "").replace("e", "").isnumeric(): psi_x = float(psi) * np.ones([self.N]) self.psi_name = psi self.psi_latex = "$%s$" % psi self.psi = Wavefunction1D(psi_x) self._msg = "$\psi(x, 0) =$ %s" % self.psi_latex self._msg_i = 45 if normalize: self.psi.normalize() self.psi_base = None self.psi_params = {} else: psi = psi.replace("^", "**") f = Function(psi, "x") self.psi_base = f psi_func = lambda x: f(x, *f.get_tupled_default_values()) self.psi_name = str(f) self.psi_latex = "$" + f.latex_repr + "$" self.psi = Wavefunction1D(psi_func) self.psi_params = f.get_enumerated_default_values() self._msg = r"$\psi(x, 0) =$ %s" % self.psi_latex self._msg_i = 45 if normalize: self.psi.normalize() except (TypeError, AttributeError, SyntaxError, ValueError, NameError) as E: print(E) elif isinstance(psi, np.ndarray): # self.psi_base = None # self.psi_params = {} self.psi = Wavefunction1D(psi) self.psi_name = "wavefunction" self.psi_latex = "$\psi(x)$" if normalize: self.psi.normalize() else: print("Unable to parse input")
class Widget_Aesthetics(object): widget_defaults = dict( font=Fonts.base, fontsize=12 if Function.screen_count() > 1 else 22, padding=0, foreground=Colors.white, background=Colors.black, )
def iter_test(self, func_name, dim, iterations, style=BOLTZMANN): ''' initialize our simulated annealing machine ''' objfunc = Function(func_name)(dim) schedule = self._get_schedule(style) prob = self._get_prob_distr(style) return self._test_anneal(objfunc, schedule, prob, iterations)
def run(self, func_name, dim, style=BOLTZMANN): ''' initialize our simulated annealing machine ''' objfunc = Function(func_name)(dim) schedule = self._get_schedule(style) prob = self._get_prob_distr(style) state_final = self._anneal(objfunc, schedule, prob) return state_final
def find_matching_function(self, name, param_count, must_return): """Finds and returns the function definition which matches with the given 'name' and parameter count. If 'must_return' is True, then the function must also return some value to be valid """ f = self.functions.get(Function.mangle(name, param_count)) if f and (not must_return or f.returns is not None): return f return None
def add_constraint(self, function_id, expression, value=None): """ Add the expression to the problem as a constraint function. Optionally, set the value to which the function is constrained, (a scalar, or (lower bound, upper bound) tuple of scalars or Nones.) """ self.constraints.set(function_id, Function(expression, name=function_id)) if value is not None: if isinstance(value, tuple): self.set_inequality(function_id, *value) else: self.set_equality(function_id, value)
def test(func_name, dimension_count, iteration_count, sample_count, cpu_count): ''' this function will run all metaheurstic algorithms against the given function for the specified amount of samples. the mean value will be output in a file for each algorithm for each iteration, showcasing the convergence over time ''' fun = Function(func_name)(dimension_count) xstar = fun.eval(fun.xstar) f_n = Population(iteration_count, 40, 0.1, 1.0, 1.0) f_b = Population(iteration_count, 40, 0.5, 1.0, 1.0) f_c = Population(iteration_count, 40, 1.0, 1.0, 1.0) pso = PSO(iteration_count, 40, 2.0, 2.0) sma = SA(1000, 0.01) samples = [[], [], [], [], []] calc_mean = lambda a: np.mean(np.array(a), axis=0) with open('./data/' + func_name + '.dat', 'w') as out_file: try: out_file.write('iters xstar fa faboltz facauchy pso sa\n') for _ in range(sample_count): samples[0].append(f_n.iter_test(func_name, dimension_count, Population.NONE, cpu_count)) samples[1].append(f_b.iter_test(func_name, dimension_count, Population.BOLTZMANN, cpu_count)) samples[2].append(f_c.iter_test(func_name, dimension_count, Population.CAUCHY, cpu_count)) samples[3].append(pso.iter_test(func_name, dimension_count)) samples[4].append(sma.iter_test(func_name, dimension_count, iteration_count, SA.CAUCHY)) # we add 1 to count for the initial case final = np.array([np.arange(iteration_count+1)] + [np.array([xstar]*(iteration_count + 1))] + [calc_mean(data) for data in samples]) for line in final.T: line.toout_file(file, sep='\t') out_file.write('\n') except Exception as exc: out_file.write(str(exc))
def functiondef(c, m): """Function definition. For instance: function myMethod(ax) returns dx { ; code } """ f = Function(name=m.group(1), params=m.group(2), returns=m.group(3)) # Ensure that the function doesn't have repeated parameters for i in range(len(f.params)): for j in range(i + 1, len(f.params)): if f.params[i] == f.params[j]: raise ValueError(f'Parameter "{f.params[i]}" used twice on ' f'"{f.name}" definition (positions {i+1} ' f'and {j+1})') c.begin_function(f)
def run(self, func_name, dim_count): ''' runs the simulation given the function name and dimension count ''' func = Function(func_name)(dim_count) self.pop = self._generate_pop(self.size, func) self.best = min(self.pop) for _ in xrange(self.gen): self.pop = [ p.map_eval(self.best.position, self.alpha, self.beta) for p in self.pop ] self.best = min(self.pop) return self.best
def _prepare_run(self, func_name, dimension_count, style): ''' this prepares the environment before we begin a simulation run ''' # get the objective function func = Function(func_name)(dimension_count) # create our populations self.pop = self._generate_pop(self.size, func) self.oldpop = self._generate_pop(self.size, func) # scale our gamma self.gamma = self.gamma0 / ((func.maxs[0] - func.mins[0])**self.m) # create our schedule for alpha update = self._get_schedule(style) # return coords and schedule function return update
def runTest(self): script = kScript(r'E:\packages\file.txt', 'myscript', max_line_length=70, compact=True) with self.assertRaises(RuntimeError): script._generate_code() def foo(): kLog(kLog.array, path=r'E:\packages\pyksp\LogFileReader-master/mylog.nka') mw = kMainWindow() buttons_area = kWidget(parent=mw) buttons_area.place_pct(20, 10, 50, 80) ba_bg = kLabel(parent=buttons_area) ba_bg.pack(sticky='nswe') ba_bg.text <<= '' lvl = kLevelMeter(parent=ba_bg, width=20) lvl.pack(sticky='nse') buttons_area.add_grid(3, 2, 20, 20, 20, 20) buttons = [kButton(parent=buttons_area) for b in range(3 * 2)] def b_callback(control): self.switch(kButton.ids, control.id) message(control.id) for idx, b in enumerate(buttons): b.grid(idx % 3, idx // 3) b.bound_callback(b_callback) with For(arr=kButton.ids) as seq: for item in seq: set_control_par_str(item, 'text', 'mybutton') script.main = foo localtime = time.asctime(time.localtime(time.time())) init_line = '{ Compiled on %s }' % localtime self.maxDiff = None self.assertEqual( unpack_lines(script._generate_code()), generated_code.format(init_line=init_line, fname=Function.get_func_name(self.switch)))
def define_set_cursor(c): """Defines the 'setcursor' built-in function. DH contains the row and DL contains the column. Returns the Function header. """ fname = '_f_setc' function = Function(fname, params=['dx'], mangle=False) # Early exit if it's already defined if fname in c.functions: return function c.begin_function(function) c.add_code('''push ax push bx mov ah, 2 mov bh, 0 int 10h pop bx pop ax''') c.close_block() return function
def functions(self, funcObjects): fos = (f if hasattr(f, 'isFunction') else Function.fromCppDictionary(f) for f in funcObjects) self.values['functions'] = OrderedDict() for f in fos: self.values['functions'].update(f.values)
def __init__(self, name, abbrev=()): Function.__init__(self, name) self.abbrev = abbrev
import numpy as np from functions import Function from dataset.mnist import load_mnist from layers import Affine, SoftmaxWithLoss, Relu import matplotlib.pyplot as plt from collections import OrderedDict # 有序字典 fun = Function() class DeepLearn: def __init__(self): (self.x_train, self.t_train), (self.x_test, self.t_test) = load_mnist(flatten=True, normalize=True, one_hot_label=True) self.train_acc_list = [] self.test_acc_list = [] def predict(self, x): raise NotImplemented def cross_entropy_loss(self, x, t): y = self.predict(x) return fun.cross_entropy_error(y, t) def accuracy(self, x, t): y = np.argmax(self.predict(x), axis=1) t = np.argmax(t, axis=1) return np.sum(y == t) / float(x.shape[0])
pygame.display.set_caption("River Crossing") # FONTS TEXT_FONT = pygame.font.SysFont('comics san', 30) ANNOUNCE_FONT = pygame.font.SysFont('comics san', 200) RIVER = pygame.rect.Rect(gm_set.RIVER_X, gm_set.RIVER_Y, gm_set.RIVER_WIDTH, gm_set.RIVER_HEIGHT) AI_BUTTON = pygame.rect.Rect(gm_set.WIDTH - gm_set.OBJECT_WIDTH, 0, gm_set.OBJECT_WIDTH, gm_set.OBJECT_HEIGHT) # NAMES names = {"F": "Farmer", "W": "Wolf", "G": "Goat", "C": "Cabbage", "R": "River"} # GAME func = Function() forbidden_states = ({'W', 'G'}, {'G', 'C'}, {'W', 'G', 'C'}) goal = {'F', 'G', 'C', 'W'} left_bank = {'F', 'G', 'C', 'W'} right_bank = set() answer = '' # ANSWER GET FROM COLLIDE POINT # AI MODE AI_MODE = False AI_DRAW = True COUNT = 0
def __init__(self, f): Function.__init__(self, None, ["other"], BinaryPyExpr(f))
AUDIOAPP = TERM + " -e pulsemixer" # spawn audio control app TODOLIST = "dtodo" # show a list of todos SPAWNTERM = "via" # spawn term in specfic wd NETWORKSELECT = "" BRIGHUP = "brightnessctl set +5%" BRIGHDOWN = "brightnessctl set 5%-" # # Keys Config {{{ keymap = { # ~: System Control: ------------------------------------------------------ "M-C-r": lazy.restart(), # Restart Qtile "M-C-x": lazy.shutdown(), # Exit Qtile "M-C-d": lazy.spawn("displayselect"), # Configure Display "M-C-a": lazy.spawn(AUDIOAPP), # Audio controler "M-<equal>": Function.volume_ctl(10), # Audio (+10) "M-<minus>": Function.volume_ctl(-10), # Audio (-10) "M-<F2>": lazy.spawn(BRIGHUP), # brightness (+5) "M-<F1>": lazy.spawn(BRIGHDOWN), # brightness (-5) # ~: Windows, Groups and Layout Contol : ---------------------------------- "M-j": lazy.group.prev_window(), # Window Focus up "M-k": lazy.group.next_window(), # Window Focus Down "M-C-j": lazy.layout.shuffle_up(), # Window Move up "M-C-k": lazy.layout.shuffle_down(), # Window Move Down "M-C-q": lazy.window.kill(), # Quit Force "M-q": lazy.window.kill(), # Quit Normal "M-f": lazy.window.toggle_fullscreen(), # Window Fullscreen "M-i": lazy.layout.shrink(), # Window Shrink "M-o": lazy.layout.grow(), # Window Grow "M-n": lazy.layout.normalize(),
def my_function(self, vector): self.fcount += 1 tmp = Function(self.name)(dim) return tmp.eval(list(vector))
def generate_one(target): SYSCALL_NAMES = [c for c in dir(constants) if c.startswith('SYS_')] for syscall in SYSCALL_NAMES: name = syscall[4:] # Skip anything with uppercase if name.lower() != name: print 'Skipping %s' % name continue # Skip anything that starts with 'unused' or 'sys' after stripping if name.startswith('unused'): print 'Skipping %s' % name continue function = functions.get(name, None) if name.startswith('rt_'): name = name[3:] # If we can't find a function, just stub it out with something # that has a vararg argument. if function is None: print 'Stubbing out %s' % name args = [Argument('int', 0, 'vararg')] function = Function('long', 0, name, args) # Some syscalls have different names on different architectures, # or are superceded. We try to do the "best" thing at runtime. syscalls = fix_syscall_names(syscall) # Set up the argument string for Mako argument_names = [] argument_defaults = [] # for arg in function.args: argname = fix_bad_arg_names(function, arg) default = get_arg_default(arg) # Mako is unable to use *vararg and *kwarg, so we just stub in # a whole bunch of additional arguments. if argname == 'vararg': for j in range(5): argname = 'vararg_%i' % j argument_names.append(argname) argument_defaults.append('%s=%s' % (argname, None)) break argument_names.append(argname) argument_defaults.append('%s=%s' % (argname, default)) arguments_default_values = ', '.join(argument_defaults) arguments_comma_separated = ', '.join(argument_names) string_arguments = [] array_arguments = [] arg_docs = [] for arg in function.args: if can_be_array(arg): array_arguments.append(arg.name) if can_be_string(arg): string_arguments.append(arg.name) argname = arg.name argtype = str(arg.type) + ('*' * arg.derefcnt) arg_docs.append(' {argname}({argtype}): {argname}'.format( argname=argname, argtype=argtype)) return_type = str(function.type) + ('*' * function.derefcnt) arg_docs = '\n'.join(arg_docs) template_variables = { 'name': name, 'arg_docs': arg_docs, 'syscalls': syscalls, 'arguments_default_values': arguments_default_values, 'arguments_comma_separated': arguments_comma_separated, 'return_type': return_type, 'string_arguments': string_arguments, 'array_arguments': array_arguments, 'argument_names': argument_names, } lines = [ HEADER, DOCSTRING.format(**template_variables), ARGUMENTS.format(**template_variables), CALL.format(**template_variables) ] with open(os.path.join(target, name + '.asm'), 'wt+') as f: f.write('\n'.join(map(str.strip, lines)))
def init_keys(self, my_term, script_path, mod): return [ # Window manager controls Key([mod, 'control'], 'r', lazy.restart()), # Key([mod, 'control'], 'q', lazy.shutdown()), Key([mod], 'r', lazy.spawn(script_path + 'dmenu_recent.sh')), Key([mod, "mod1"], 'r', lazy.spawn(script_path + 'dmenu_removeRecent.sh')), Key([mod], 'Return', lazy.spawn(my_term)), Key([mod], 'q', lazy.window.kill()), Key([mod], 'Tab', lazy.layout.next()), #Key([mod], 'Left', lazy.screen.prev_group()), #Key([mod], 'Right', lazy.screen.next_group()), Key([mod], "Left", lazy.prev_screen()), Key([mod], "Right", lazy.next_screen()), Key([mod, "shift"], "Left", Function.window_to_prev_screen()), Key([mod, "shift"], "Right", Function.window_to_next_screen()), # Layout modification Key([mod, 'control'], 'f', lazy.window.toggle_floating()), # Switch between windows in current stack pane Key([mod], 'k', lazy.layout.down()), Key([mod], 'j', lazy.layout.up()), # Move windows up or down in current stack Key([mod, 'shift'], 'k', lazy.layout.shuffle_down()), Key([mod, 'shift'], 'j', lazy.layout.shuffle_up()), # Switch window focus to other pane(s) of stack # Key([mod], 'space', lazy.layout.next()), Key([mod], 'space', lazy.spawn(script_path + 'dmenu_recent.sh')), # Toggle between different layouts as defined below Key([mod], 'Tab', lazy.next_layout()), ############################################################################# # Own shortcuts # ############################################################################# # # emacs Key(['control', 'mod1'], 'e', lazy.spawn('emacs')), # pcmanfm Key([mod], 'e', lazy.spawn(script_path + 'dmenu_filemanager.sh')), # firefox Key([mod, 'control'], 'Return', lazy.spawn('firefox')), # logout Key([mod, 'shift'], 'q', lazy.spawn(script_path + 'dmenu_exit.sh')), Key([mod], 'l', lazy.spawn(script_path + 'lockscreen.sh')), # brightness control Key([], 'XF86MonBrightnessDown', lazy.spawn(script_path + 'brightness.sh -')), Key([], 'XF86MonBrightnessUp', lazy.spawn(script_path + 'brightness.sh +')), # volume control Key([], 'XF86AudioRaiseVolume', lazy.spawn(script_path + 'adjust_volume.sh +')), Key([], 'XF86AudioLowerVolume', lazy.spawn(script_path + 'adjust_volume.sh -')), Key([], 'XF86AudioMute', lazy.spawn(script_path + 'adjust_volume.sh m')), # screenshots Key([mod], 's', lazy.spawn(script_path + 'screenshot_full.sh')), Key([mod, 'shift'], 's', lazy.spawn(script_path + 'screenshot_region.sh')), Key([], 'XF86AudioPlay', lazy.spawn(script_path + 'mpc_playpause.sh')), Key([], 'XF86AudioNext', lazy.spawn('mpc next')), Key([], 'XF86AudioPrev', lazy.spawn('mpc prev')), # screens and monitors Key([mod], 'p', lazy.spawn(script_path + 'dmenu_displayselect.sh')), ]
def define_integer_to_string(c): """Defines the 'integer_to_string' built-in function. AX is used to pass the input parameter, number to convert, and is lost in the progress. Caller is responsibe to save it. Returns the Function header. """ vname = '_v_itos' fname = '_f_itos' function = Function(fname, params=['ax'], returns=vname, mangle=False) # Early exit if it's already defined if fname in c.functions: return function maxlen = len(f'-{0x7FFF}$') c.add_variable(Variable(vname, 'byte', '?', vector_size=maxlen)) c.begin_function(function) c.add_code('''push bx push cx push dx push di xor cx, cx ; Digit counter mov bx, 10 ; Cannot divide by inmediate lea di, _v_itos ; Destination string index ; Special case, number is negative cmp ax, 0 jge _f_itos_loop1 mov [di], '-' inc di neg ax _f_itos_loop1: ; DX is considered on division, reset it to zero xor dx, dx div bx add dl, '0' ; From less significant to most significant (use stack to reverse) push dx inc cx cmp ax, 0 jg _f_itos_loop1 _f_itos_loop2: ; Reverse the stored digits back from the stack pop [di] inc di loop _f_itos_loop2 ; Strings must end with the dollar sing mov [di], '$' pop di pop dx pop cx pop bx''') c.close_block() return function
def eval(self, env, memory): passedFunc = Function(self.paramID, self.expr) return env.putFunc(self.funcID, passedFunc)
def test_RPN_solve(self): r = RPN_solver() value = r.solve([1, 2, 3, Operator(np.multiply,1), Operator(np.add,0), Function(np.exp)]) self.assertEqual(value, np.exp(7))