def test_curry_call(): @curry def add(x, y): return x + y assert raises(TypeError, lambda: add.call(1)) assert add(1)(2) == add.call(1, 2) assert add(1)(2) == add(1).call(2)
def pout(gen, indi) : print name(indi) cols("",10) ndots = 0 while lt(ndots, gen) : out(". ") ndots = add(1,ndots) out("* "+name(indi)) e = birth(indi) if e : out(", b. "+long(e)) nl() (sp,fam,num,iter) = spouses(indi) while sp : cols("",10) ndots = 0 while lt(ndots, gen) : out(" ") ndots = add(1,ndots) out(" m. "+name(sp)) nl() (sp,fam,num) = spouses(iter) next = add(1,gen) if lt(next,15) : (fam,sp,num,iter) = families(indi) while fam : for (no0,child) in children(fam) : pout(next, child) (fam,sp,num) = families(iter)
def twenty_fourteen(): """Come up with the most creative expression that evaluates to 2014, using only numbers and the functions add(. . .) and mul(. . .). >>> twenty_fourteen() 2014 """ "*** YOUR CODE HERE ***" return add(mul(20, mul(10,10)), add(mul(5,2), 4))
def pedout(indi, gen, max, top, bot) : if indi and le(gen,max) : gen = add(1,gen) fath = father(indi) moth = mother(indi) height = add(1,sub(bot,top)) offset = div(sub(height,8),2) block(indi,add(top,offset),mul(10,sub(gen,2))) half = div(height,2) pedout(fath,gen,max,top,sub(add(top,half),1)) pedout(moth,gen,max,add(top,half),bot)
def a_plus_b(a,b): """Return a+abs(b),but without calling abs. >>> a_plus_b(2,3) 5 >>>a_plus_b(2,-3) 5 """ if b < 0: sub(a,b) else: add(a,b)
def sort_(list1, list2, sorted_=None): if not list1 and not list2: return sorted_ elif not list1: return sort_(list1, list2[1:], add(sorted_, list2[:1])) elif not list2: return sort_(list1[1:], list2, add(sorted_, list1[:1])) else: return (sort_(list1[1:], list2, add(sorted_, list1[:1])) if list1[0] < list2[0] else sort_(list1, list2[1:], add(sorted_, list2[:1])))
def adjusted_thickness(self, thickness): # TODO: This seems...unsystematic big_sum = op.add( PRODUCTION_QUALITY_CAMERA_CONFIG["pixel_height"], PRODUCTION_QUALITY_CAMERA_CONFIG["pixel_width"], ) this_sum = op.add( self.get_pixel_height(), self.get_pixel_width(), ) factor = fdiv(big_sum, this_sum) return 1 + (thickness - 1) / factor
def pout(gen, indi) : message(name(indi)+"\n") cols("",add(5,mul(4,gen)),d(add(gen,1))+"-- ") outp(indi) next = add(1,gen) (fam,sp,num,iter) = families(indi) while fam : cols("",add(5,mul(4,gen))," sp-") outp(sp) if lt(next,15) : for (no0,child) in children(fam) : pout(next,child) (fam,sp,num) = families(iter)
def a_plus_abs_b(a, b): """Return a+abs(b), but without calling abs. >>> a_plus_abs_b(2, 3) 5 >>> a_plus_abs_b(2, -3) 5 """ if b < 0: f = lambda a,b: add(a,-b) else: f = lambda a,b: add(a,b) return f(a, b)
def test_addition(self, input_tuple, expected): self.ureg.autoconvert_offset_to_baseunit = False qin1, qin2 = input_tuple q1, q2 = self.Q_(*qin1), self.Q_(*qin2) # update input tuple with new values to have correct values on failure input_tuple = q1, q2 if expected == 'error': self.assertRaises(OffsetUnitCalculusError, op.add, q1, q2) else: expected = self.Q_(*expected) self.assertEqual(op.add(q1, q2).units, expected.units) self.assertQuantityAlmostEqual(op.add(q1, q2), expected, atol=0.01)
def test_curry_subclassable(): class mycurry(curry): pass add = mycurry(lambda x, y: x+y) assert isinstance(add, curry) assert isinstance(add, mycurry) assert isinstance(add(1), mycurry) assert isinstance(add()(1), mycurry) assert add(1)(2) == 3 # Should we make `_should_curry` public? """
def _lis(seq, subseqs=None): if not seq: return max(subseqs, key=len) else: head, tail = seq[0], seq[1:] if lt_all(subseqs, head): return _lis(tail, add(subseqs, [[head]])) elif gt_all(subseqs, head): expanded = largest_seq(subseqs) + [head] return _lis(tail, add(subseqs, [expanded])) else: expanded = largest_end_seq(subseqs, head) + [head] return _lis(tail, add(filter_seqs(subseqs, len(expanded)), [expanded]))
def two_of_three(a, b, c): """Return x*x + y*y, where x and y are the two largest of a, b, c. >>> two_of_three(1, 2, 3) 13 >>> two_of_three(5, 3, 1) 34 >>> two_of_three(10, 2, 8) 164 >>> two_of_three(5, 5, 5) 50 """ return add(add(a*a, b*b), (c*c))-min(a*a, b*b, c*c)
def new_value(): av, bv, cv = [connector['has_val']() for connector in (a, b, c)] #关键还是在于这一句看不懂!!!! # connector['has_val']()是一句调用那个dict中的匿名函数的call expression. # 所以它们三个的值要么是True,要么是False print("....") print(av) print(bv) print(cv) if av and bv: c['set_val'](constraint, add(a['val'], b['val'])) elif av and cv: b['set_val'](constraint, add(c['val'], a['val'])) elif bv and cv: a['set_val'](constraint, add(c['val'], b['val']))
def block(indi, row, col) : print ".", row = add(3,row) col = add(3,col) pos(row,col) out(name(indi)) row = add(row,1) pos(row,col) e = birth(indi) out(" b. ") if e and date(e) : out(date(e)) row = add(row,1) pos(row,col) out(" bp. ") if e and place(e) : out(place(e))
def filtered_accumulate(combiner, base, pred, n, term): """Return the result of combining the terms in a sequence of N terms that satisfy the predicate PRED. COMBINER is a two-argument function. If v1, v2, ..., vk are the values in TERM(1), TERM(2), ..., TERM(N) that satisfy PRED, then the result is BASE COMBINER v1 COMBINER v2 ... COMBINER vk (treating COMBINER as if it were a binary operator, like +). The implementation uses accumulate. >>> filtered_accumulate(add, 0, lambda x: True, 5, identity) # 0 + 1 + 2 + 3 + 4 + 5 15 >>> filtered_accumulate(add, 11, lambda x: False, 5, identity) # 11 11 >>> filtered_accumulate(add, 0, odd, 5, identity) # 0 + 1 + 3 + 5 9 >>> filtered_accumulate(mul, 1, greater_than_5, 5, square) # 1 * 9 * 16 * 25 3600 >>> # Do not use while/for loops or recursion >>> from construct_check import check >>> check(HW_SOURCE_FILE, 'filtered_accumulate', ... ['While', 'For', 'Recursion', 'FunctionDef']) True """ # x if C else y modify_combiner = lambda x,y : combiner(x,y) if pred(y) else add(x,0) return accumulate(modify_combiner, base, n, term)
def _phonewords(numbers): if not numbers: return [[]] else: return [add([n], x) for n in DIGIT_TO_WORDS.get(numbers[0], [numbers[0]]) for x in _phonewords(numbers[1:])]
def index_view(request): print(request.POST) try: if request.POST: first_number_input = float(request.POST['first_number_input']) second_number_input = float(request.POST['second_number_input']) operation = request.POST["operator"] if operation == "+ (add)": answer = operator.add(first_number_input, second_number_input) operation = "+" elif operation == "- (subtract)": answer = operator.sub(first_number_input, second_number_input) operation = "-" elif operation == "x (multiply)": answer = operator.mul(first_number_input, second_number_input) operation = "x" else: try: answer = operator.truediv(first_number_input, second_number_input) except ZeroDivisionError: answer = "Answer is Undefined (You can't divide by zero)" operation = "/" return render(request, 'index.html', {'answer': answer, 'operation': operation, 'first_number': first_number_input, 'second_number': second_number_input}) else: return render(request,'index.html',{}) except (ValueError, TypeError): answer = "INVALID ENTRY" return render(request, "index.html",{'answer':answer})
def updateFunction(newValues, oldValues): # for the first time, initialize with newValues if oldValues is None: return newValues # return a list of elements return add(newValues, oldValues)
def generate_message(cj, cij, incoming): ''' Compute max-sum message from xi to xj. ''' # Compute max over xj for the message to xi. if cj.names[0] == cij.names[0]: edge = lambda xi, xj: (xj, xi) else: edge = lambda xi, xj: (xi, xj) incoming_tab = np.array([ add(cj((xj,)), reduce(add, (m(xj) for m in incoming), 0.)) for xj in range(cj.nstates[0])]) # Memoize message. cache = dict() def message(xi): if xi not in cache: cache[xi] = max( add(cij(edge(xi, xj)), incoming_tab[xj]) for xj in range(cj.nstates[0])) return cache[xi] return message
def declare_policies(self, _policies, pi_p, matrix_nd): """ this function receives dictionary of state action pairs an related vector value improvements and returns back dictionary of policies related to given pairs and the same vector value improvement :param _policies: dictionary of this form : {0: ((1, 0), (0, 1)), [ 1.20030463, 0. ]) :param pi: the given policy without counting improvement in accounts :return: dictionary of new policies and related improved vector values """ _pi_p = pi_p.copy() V_append_d = np.zeros(self.mdp.d, dtype= ftype) new_policies = {} _pi_old = copy.deepcopy(_pi_p) for k, policy in _policies.iteritems(): for key, val in _pi_p.iteritems(): tempo = [item[1] for item in policy[0] if item[0] == key] if tempo: _pi_p[key] = tempo #else: # adv_d = self.get_initial_distribution()[key]*(self.mdp.get_vec_Q(key, _pi_old[key][0], matrix_nd)-matrix_nd[key]) # V_append_d = operator.add(V_append_d, adv_d) #V_append_d = np.zeros(self.mdp.d, dtype=ftype) new_policies[k] = (_pi_p,np.float32(operator.add(policy[1], V_append_d)) ) #np.float32(policy[1])) _pi_p = copy.deepcopy(_pi_old) return new_policies
def condition_no(name): from math import sqrt h=0.001 f=[] fh=[] ab=[] conditi=[] x=list for x in nup.arange(-1,1.1,0.1): for y in nup.arange(-1,1.1,0.1): try: f.append(eval(name)) ab.append(sqrt(add(x**2,y**2))) except ValueError: pass for x in nup.arange(-1,1.1,0.1): try: x=x+h for y in nup.arange(-1,1.1,0.1): try: y=y+h fh.append(eval(name)) except ValueError: pass except ValueError: pass for num in range(0,len(f)): if f[num]!=0: D=abs(f[num])*sqrt(2)*h N=abs(fh[num]-f[num])*ab[num] conditi.append(N/D) else: conditi.append(None) return conditi
def main(sc): # Load the airlines lookup dictionary airlines = dict(sc.textFile("ontime/airlines.csv").map(split).collect()) # Broadcast the lookup dictionary to the cluster airline_lookup = sc.broadcast(airlines) # Read the CSV Data into an RDD flights = sc.textFile("ontime/flights.csv").map(split).map(parse) # Map the total delay to the airline (joined using the broadcast value) delays = flights.map(lambda f: (airline_lookup.value[f.airline], add(f.dep_delay, f.arv_delay))) # Reduce the total delay for the month to the airline delays = delays.reduceByKey(add).collect() delays = sorted(delays, key=itemgetter(1)) # Provide output from the driver for d in delays: print ("%0.0f minutes delayed\t%s" % (d[1], d[0])) # Show a bar chart of the delays plot(delays)
def run(): primes = prime_reader.read_primes_default() last_prime = primes.next() prime_count = 0 diag_total = 1 current = 1 for ring in eu.numbers(2): incr = (ring - 1) * 2 for corner in xrange(3): current = op.iadd(current, incr) while current > last_prime: last_prime = primes.next() if current == last_prime: prime_count = op.iadd(prime_count, 1) current = op.add(current, incr) diag_total = op.iadd(diag_total, 4) perc = op.div(float(prime_count), diag_total) # print ring, side_length(ring), last_prime, diag_total, perc if op.lt(perc, 0.1): return side_length(ring)
def CalculateHashRounds(password, bonus): # Accepts a user password and bonus value, and calculates # the number of iterative rounds required. This function will # always return a value between 8 and 16,777,216. # Identify the number of Unicode characters. characters = len(password.decode("utf-8")) # Calculate the difficulty exponent by subtracting 1 # for each Unicode character in a password. dynamic = operator.sub(24, characters) # Use a minimum exponent value of 1 for passwords # equal to, or greater than, 24 characters. dynamic = max(1, dynamic) # Derive the variable number of rounds based on the length. # Raise 2 using the dynamic exponent determined above. variable = pow(2, dynamic) # If applicable, add the fixed number of bonus rounds. total = operator.add(variable, bonus) # If the value of rounds is smaller than 8, reset # the value to 8. total = max(8, total) # If the value of rounds is larger than 16,777,216, reset # the value to 16,777,216. total = min(pow(2, 24), total) return total
def getSum(self, a, b): """ :type a: int :type b: int :rtype: int """ return operator.add(a,b)
def evaluate(self): result = None left = self.left.evaluate() right = self.right.evaluate() if self.operation == '+': result = operator.add(left, right) elif self.operation == '-': result = operator.sub(left, right) elif self.operation == '*': result = operator.mul(left, right) elif self.operation == '/': result = operator.div(left, right) elif self.operation == '^': result = operator.pow(left, right) elif self.operation == 'and': result = left and right elif self.operation == 'or': result = left or right elif self.operation == '<': result = operator.lt(left, right) elif self.operation == '<=': result = operator.le(left, right) elif self.operation == '==': result = operator.eq(left, right) elif self.operation == '!=': result = operator.ne(left, right) elif self.operation == '>': result = operator.gt(left, right) elif self.operation == '>=': result = operator.ge(left, right) elif self.operation == 'in': result = (left in right) return result
def _call(self, arguments, delta_time, computing_context): try: result = OperatorComputingResult(add(*arguments), NoneComputingContext()) except: result = NoneComputingResult() return result
def _build_paths(files, system_bitness): """Build paths of the files based on the system bitness. Chooses different directories depending on the value of the system_bitness. If the bitness is neither 32 nor 64 then the USER_DIR directory will be used. Args: files (list): The names of the files themselves. system_bitness (int): The system bitness. """ file_paths = ["" for file in files] file_paths = Classifier._extend_paths(file_paths, DATA_PATH) if system_bitness == SYSTEM_BITNESS_32: file_paths = Classifier._extend_paths(file_paths, HARDCODED_32BIT_DIR) elif system_bitness == SYSTEM_BITNESS_64: file_paths = Classifier._extend_paths(file_paths, HARDCODED_64BIT_DIR) else: file_paths = Classifier._extend_paths(file_paths, USER_DIR) file_paths = [operator.add(l, r) for l, r in zip(file_paths, files)] return file_paths
def p_expression_binop(self, p): """expression : expression PLUS expression | expression MINUS expression | expression TIMES expression | expression DIVIDE expression | expression MODULUS expression | expression EXPONENT expression""" op = p[2] left = self._sumDiceRolls(p[1]) right = self._sumDiceRolls(p[3]) if op == '+': p[0] = operator.add(left, right) elif op == '-': p[0] = operator.sub(left, right) elif op == '*': p[0] = operator.mul(left, right) elif op == '/': p[0] = operator.floordiv(left, right) elif op == '%': p[0] = operator.mod(left, right) elif op == '^': if -self._MAX_EXPONENT <= left <= self._MAX_EXPONENT and -self._MAX_EXPONENT <= right <= self._MAX_EXPONENT: p[0] = operator.pow(left, right) else: raise InvalidOperandsException(u'operand or exponent is larger than the maximum {}' .format(self._MAX_EXPONENT))
def topla(ilk_sayi, ikinci_sayi): return add(ilk_sayi, ikinci_sayi)
def generate(self, gen_cat=True): print('--Beginning Fast build--') # Drawing causes self.causes = [i for i in range(np.random.randint( 2, self.nodes / np.floor(np.sqrt(self.nodes))))] self.causes = list(set(self.causes)) self.data = pd.DataFrame(None) layer = [[]] for i in self.causes: self.data['V' + str(i)] = cause(self.n_points) layer[0].append(i) generated_nodes = len(self.causes) links = [] while generated_nodes < self.nodes: print( '--Generating nodes : {} out of ~{}'.format(generated_nodes, self.nodes)) layer.append([]) # new layer num_nodes_layer = np.random.randint(2, len(layer[-2]) + 2) for i in range(num_nodes_layer): layer[-1].append(generated_nodes) # draw causes last_idx = layer[-2][-1] parents = list(set([np.random.randint(0, last_idx) for i in range( self.num_max_parents)])) # np.random.randint(self.num_max_parents - 1, self.num_max_parents))])) child = [] # Compute each cause's contribution for par in parents: links.append(['V' + str(par), 'V' + str(generated_nodes)]) child.append( effect(self.data['V' + str(par)], self.n_points, self.noise)) # Combine contributions shuffle(child) result = child[0] for i in child[1:]: rd_func = self.joint_functions[np.random.randint( 0, len(self.joint_functions))] result = op.add(result, i) # Add a final noise rd_func = self.joint_functions[np.random.randint( 0, len(self.joint_functions))] if rd_func == op.mul: noise_var = noise(self.n_points, self.noise).flatten() result = rd_func(result + abs(min(result)), noise_var + abs(min(noise_var))) # +abs(min(result)) else: result = rd_func(result, noise( self.n_points, self.noise).flatten()) result = scale(result) self.data['V' + str(generated_nodes)] = result generated_nodes += 1 self.result_links = pd.DataFrame(links, columns=["Cause", "Effect"]) print('--Dataset Generated--') if gen_cat: print('--Converting variables to categorical--') actual_cat_rate = 0.0 self.cat_var = [] self.cat_data = self.data.copy() while actual_cat_rate < self.cat_rate: print( '--Converting, Actual rate: {:3.3f}/{}--'.format(actual_cat_rate, self.cat_rate)) var = np.random.randint(0, self.nodes) while var in self.cat_var: var = np.random.randint(0, self.nodes) self.cat_var.append(var) self.cat_data['V' + str(var)] = rand_bin( list(self.cat_data['V' + str(var)])) actual_cat_rate = float(len(self.cat_var)) / self.nodes self.cat_var = pd.DataFrame(self.cat_var) print('Build Directed Graph') self.graph = DirectedGraph() self.graph.add_multiple_edges( [list(i) + [1] for i in self.result_links.as_matrix()]) print('--Done !--') return self.get_data()
def __add__(self, y): return NonStandardInteger(operator.add(self.val, y))
def __radd__(self, y): return NonStandardInteger(operator.add(y, self.val))
def __add__(self, other: Any) -> Any: return operator.add(*self._get_operands(other))
def add(self, a, b): return operator.add(a, b)
#https://docs.python.org/3/library/operator.html import operator a,b,c,d,e,f=1,3,7,'hello','world',' ' h=['a','b','c'] g=operator.iadd(d,f) print(operator.iadd(h,g)) print(operator.add(a,b)) print(operator.iadd(g,e))
# # primitive expressions and statements, which represent the simplest building blocks that the language provides, # means of combination, by which compound elements are built from simpler ones, and # means of abstraction, by which compound elements can be named and manipulated as units. x = max(min(1, -2), min(pow(3, 5), -4)) print(x) from math import sqrt, pi print('square of 256:', sqrt(256)) print('100 * pi:', pi * 100) from operator import add, sub, mul print('14 + 28:', add(14, 28)) print('100 - 7 * (8 + 4) = ', sub(100, mul(7, add(8, 4)))) print(max) f = max print(f) print(f(2, 3, 4)) f = 2 print(f) max = 5 print(max) # max(2, 3, 4), bind built-in names to new values # TypeError: 'int' object is not callable x = 2
def test_not_numerical_offset(self): u = Unit('meter') with self.assertRaisesRegexp(TypeError, 'unsupported operand type'): operator.add(u, 'not_a_number')
def test_no_unit(self): u = Unit('no unit') with self.assertRaisesRegexp(ValueError, 'Cannot offset'): operator.add(u, 10)
def join(one, two): """ Join two objects owning the same inner representation. """ return list(map(lambda z: operator.add(*z), zip(one, two)))
# -*- coding: utf-8 -*- # Programación funcional # Lección 4 # Módulo operator import operator operator.add(1, 2) operator.sub(1, 2) operator.mul(1, 2) operator.pow(1, 2) operator.mod(1, 2) operator.eq(1, 2) operator.lt(1, 2) operator.gt(1, 2)
def test_add(self): self.failUnlessRaises(TypeError, operator.add) self.failUnlessRaises(TypeError, operator.add, None, None) self.failUnless(operator.add(3, 4) == 7)
def test_operator(): print(operator.add(1, 2)) print(operator.mul(3, 10)) print(operator.pow(2, 3)) print(operator.itemgetter(1)([1, 2, 3]))
# published by the Free Software Foundation, either version 3 of # the License, or (at your option) any later version. # # SCOOP is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with SCOOP. If not, see <http://www.gnu.org/licenses/>. # """ SCOOP also works on lambda functions even if they aren't picklable by default. """ from scoop import futures, shared from math import cos import operator if __name__ == "__main__": # Standard lambda function myFunc = lambda x: x * 2 # Lambda function using a globally defined function myFunc2 = lambda x: cos(x) # Lambda function using a function through a module definition myFunc3 = lambda x: operator.add(x, 1) # Calls to SCOOP print(list(futures.map(myFunc, range(10)))) print(list(futures.map(myFunc2, range(10)))) print(list(futures.map(myFunc3, range(10))))
import operator num1 = 10 num2 = 3 operator.add(num1, num2) # num1 + num2 operator.sub(num1, num2) # num1 - num2 operator.mul(num1, num2) # num1 * num2 operator.truediv(num1, num2) # num1 / num2 operator.mod(num1, num2) # num1 % num2 operator.floordiv(num1, num2) # num1 // num2 operator.pow(num1, num2) # num1 ** num2
:param x: euro/dollar/shekel :param y: euro/dollar/shekel :return: amount in shekels. """ return x + y type_tags = {Dollar: "dollar", Euro: "euro", Shekel: "nis"} rates = {("dollar", "nis"): 3.82, ("euro", "nis"): 4.07} s = Shekel(50) d = Dollar(50) e = Euro(50) print(d.amount()) print(e.amount()) print(d + s) print(add(e, d)) z = eval(repr(d)) print(z) print(s) print(e) def apply(func_name, x, y): """ generic func that gets an opertion name and do the operation on x and y uses implementation to choose the necessary func and operate it on x and y :param func_name: add,sub :param x: euro/dollar/shekel :param y: euro/dollar/shekel :return: x+y,x-y in the type of x """
# Numeric expressions 2016 2000 + 16 1 + 2 * ((3 * 4 * 5 // 6)**3) + 7 + 8 # Call expressions max(3, 4.5) pow(100, 2) pow(2, 100) max(1, -2, 3, -4) max(pow(10, 2), pow(2, 10), 1010) # Importing and arithmetic with call expressions from operator import add, mul add(1, 2) mul(4, 6) mul(add(4, mul(4, 6)), add(3, 5)) mul(9, mul(add(4, mul(4, 6)), add(3, 5))) from math import sqrt sqrt(169) # Objects # Note: Download from http://composingprograms.com/shakespeare.txt shakes = open('shakespeare.txt') text = shakes.read().split() len(text) text[:25] text.count('the')