def compose(self, *others, backwards=False): """ Returns the composition of self with a list of other arrows. Parameters ---------- others : list Other arrows. backwards : bool, optional Whether to compose in reverse, default is :code`False`. Returns ------- arrow : cat.Arrow Such that :code:`arrow == self >> others[0] >> ... >> others[-1]` if :code:`backwards` else :code:`arrow == self << others[0] << ... << others[-1]`. Examples -------- >>> x, y, z = Ob('x'), Ob('y'), Ob('z') >>> f, g, h = Box('f', x, y), Box('g', y, z), Box('h', z, x) >>> assert Arrow.compose(f, g, h) == f >> g >> h >>> assert f.compose(g, h) == Id(x).compose(f, g, h) == f >> g >> h >>> assert h.compose(g, f, backwards=True) == h << g << f """ return fold(lambda f, g: f << g if backwards else f >> g, others, self)
def rec2(nVal: Value, xsVal: Value) -> Value: with VNil|xsVal: return mnVal with VCons|xsVal as (_, l, x, xs): return fold(vapp, [l, x, xs, rec2(l, xs)], mcVal) with VNeutral|xsVal as (n,): return VNeutral( NVecElim(evalC(a, env), evalC(m, env), mnVal, mcVal, nVal, n) ) raise TypeError(f"Unknown instance '{type(xsVal)}'")
def max_col_widths(xss): """ @return list of max width needed for columns (:: [Int]). see an example below. >>> xss = [['aaa', 'bbb', 'cccccccc', 'dd'], ['aa', 'b', 'ccccc', 'ddddddd'], ['aaaa', 'bbbb', 'c', 'dd']] >>> max_col_widths(xss) [4, 4, 8, 7] """ yss = [[len(x) for x in xs] for xs in xss] return fold(curry(zipWith, max), yss[1:], yss[0])
def main(): with open("input") as lines: snailfish_numbers = [parse(json.loads(line.strip())) for line in lines] result = fold(add, snailfish_numbers) print(magnitude(result)) print( max( magnitude(add(a, b)) for a, b in permutations(snailfish_numbers, 2)))
def rec2(nVal: Value, xsVal: Value) -> Value: if isinstance(xsVal, VNil): return mnVal if isinstance(xsVal, VCons): l, x, xs = (xsVal.n, xsVal.x, xsVal.xs) return fold(vapp, [l, x, xs, rec2(l, xs)], mcVal) if isinstance(xsVal, VNeutral): return VNeutral( NVecElim(evalC(a, env), evalC(m, env), mnVal, mcVal, nVal, xsVal.n)) raise TypeError(f"Unknown instance '{type(xsVal)}'")
def rec2(nVal: Value, xsVal: Value) -> Value: with _pm: xsVal >> VNil return mnVal with _pm: _, l, x, xs = xsVal >> VCons return fold(vapp, [l, x, xs, rec2(l, xs)], mcVal) with _pm: (n, ) = xsVal >> VNeutral return VNeutral( NVecElim(evalC(a, env), evalC(m, env), mnVal, mcVal, nVal, n)) raise TypeError(f"Unknown instance '{type(xsVal)}'")
def eager_parse(*words, target=Ty('s')): """ Tries to parse a given list of words in an eager fashion. """ result = fold(lambda x, y: x @ y, words) scan = result.cod while True: fail = True for i in range(len(scan) - 1): if scan[i:i + 1].r != scan[i + 1:i + 2]: continue cup = Cup(scan[i:i + 1], scan[i + 1:i + 2]) result = result >> Id(scan[:i]) @ cup @ Id(scan[i + 2:]) scan, fail = result.cod, False break if result.cod == target: return result if fail: raise NotImplementedError
def typeI(i: int, c: Context, term: TermI) -> Type: # with Ann|term as p: # reveal_type(p) with Ann|term as (e1,e2): typeC(i, c, e2, VStar()) t = evalC(e2, []) typeC(i, c, e1, t) return t with Free|term as (x,): return c[x] with App|term as (e1,e2): s = typeI(i, c, e1) with VPi|s as (v,f): typeC(i, c, e2, v) return f(evalC(e2, [])) raise TypeError(f"Illegal application: {e1}({e2})") with Star|term: return VStar() with Pi|term as (p,p1): typeC(i, c, p, VStar()) t = evalC(p, []) typeC( i + 1, dict_merge({Local(i): t}, c), substC(0, Free(Local(i)), p1), VStar() ) return VStar() with Nat|term: return VStar() with Zero|term: return VNat() with Succ|term: return VNat() with NatElim|term as (m,mz,ms,k): typeC(i, c, m, VPi(VNat(), lambda _: VStar())) mVal = evalC(m, []) typeC(i, c, mz, vapp(mVal, VZero())) typeC( i, c, ms, VPi(VNat(), lambda l: VPi(vapp(mVal, l), lambda _: vapp(mVal, VSucc(l)))), ) typeC(i, c, k, VNat()) kVal = evalC(k, []) return vapp(mVal, kVal) with Vec|term as (a,n): typeC(i, c, a, VStar()) typeC(i, c, n, VNat()) return VStar() with Nil|term as (a,): typeC(i, c, a, VStar()) aVal = evalC(a, []) return VVec(aVal, VZero()) with Cons|term as (a,k,x,xs): typeC(i, c, a, VStar()) aVal = evalC(a, []) typeC(i, c, k, VNat()) kVal = evalC(k, []) typeC(i, c, x, aVal) typeC(i, c, xs, VVec(aVal, kVal)) return VVec(aVal, VSucc(kVal)) with VecElim|term as (a,m,mn,mc,k,vs): typeC(i, c, a, VStar()) aVal = evalC(a, []) typeC(i, c, m, VPi(VNat(), lambda k: VPi(VVec(aVal, k), lambda _: VStar()))) mVal = evalC(m, []) typeC(i, c, mn, foldl(vapp, mVal, [VZero(), VNil(aVal)])) typeC( i, c, mc, VPi( VNat(), lambda l: VPi( aVal, lambda y: VPi( VVec(aVal, l), lambda ys: VPi( foldl(vapp, mVal, [l, ys]), lambda _: foldl( vapp, mVal, [VSucc(l), VCons(aVal, l, y, ys)] ), ), ), ), ), ) typeC(i, c, k, VNat()) kVal = evalC(k, []) typeC(i, c, vs, VVec(aVal, kVal)) vsVal = evalC(vs, []) return fold(vapp, [kVal, vsVal], mVal) raise TypeError(f"Unknown instance '{type(term)}'")
def typeI(i: int, c: Context, term: TermI) -> Type: check_argument_types() if isinstance(term, Ann): e1, e2 = term typeC(i, c, e2, VStar()) t = evalC(e2, []) typeC(i, c, e1, t) return t elif isinstance(term, Free): x, = term return c[x] elif isinstance(term, App): e1, e2 = term s = typeI(i, c, e1) if isinstance(s, VPi): typeC(i, c, e2, s.v) return s.f(evalC(e2, [])) elif isinstance(term, Star): return VStar() elif isinstance(term, Pi): p, p1 = term typeC(i, c, p, VStar()) t = evalC(p, []) typeC(i + 1, dict_merge({Local(i): t}, c), substC(0, Free(Local(i)), p1), VStar()) return VStar() elif isinstance(term, Nat): return VStar() elif isinstance(term, Zero): return VNat() elif isinstance(term, Succ): return VNat() elif isinstance(term, NatElim): m, mz, ms, k = term typeC(i, c, m, VPi(VNat(), lambda _: VStar())) mVal = evalC(m, []) typeC(i, c, mz, vapp(mVal, VZero())) typeC( i, c, ms, VPi(VNat(), lambda l: VPi(vapp(mVal, l), lambda _: vapp(mVal, VSucc(l))))) typeC(i, c, k, VNat()) kVal = evalC(k, []) return vapp(mVal, kVal) elif isinstance(term, Vec): a, n = term typeC(i, c, a, VStar()) typeC(i, c, n, VNat()) return VStar() elif isinstance(term, Nil): a, = term typeC(i, c, a, VStar()) aVal = evalC(a, []) return VVec(aVal, VZero()) elif isinstance(term, Cons): a, k, x, xs = term typeC(i, c, a, VStar()) aVal = evalC(a, []) typeC(i, c, k, VNat()) kVal = evalC(k, []) typeC(i, c, x, aVal) typeC(i, c, xs, VVec(aVal, kVal)) return VVec(aVal, VSucc(kVal)) elif isinstance(term, VecElim): a, m, mn, mc, k, vs = term typeC(i, c, a, VStar()) aVal = evalC(a, []) typeC(i, c, m, VPi(VNat(), lambda k: VPi(VVec(aVal, k), lambda _: VStar()))) mVal = evalC(m, []) typeC(i, c, mn, foldl(vapp, mVal, [VZero(), VNil(aVal)])) typeC( i, c, mc, VPi( VNat(), lambda l: VPi( aVal, lambda y: VPi( VVec(aVal, l), lambda ys: VPi( foldl(vapp, mVal, [l, ys]), lambda _: foldl( vapp, mVal, [VSucc(l), VCons(aVal, l, y, ys)])))))) typeC(i, c, k, VNat()) kVal = evalC(k, []) typeC(i, c, vs, VVec(aVal, kVal)) vsVal = evalC(vs, []) return fold(vapp, [kVal, vsVal], mVal) raise TypeError(f"Unknown instance '{type(term)}'")
def join_strings(listofwords): # joining list of words return fold(lambda item, running_total: item + running_total, listofwords)
from functools import reduce as fold #adding numbers to give a total total = fold(lambda item, running_total: item + running_total, [1, 2, 3, 4, 5]) print(total) def join_strings(listofwords): # joining list of words return fold(lambda item, running_total: item + running_total, listofwords) words = ["Johnson ", "is ", "great"] joinwords = join_strings(words) print(joinwords)
def lambda_align(data_rectified, query_unrectified, query_rectified, entrypoint_map): """ :param data_rectified: data path to be aligned to the query :param query_unrectified: query in its simplest triple formulation from the undirected representation :param entrypoint_map: Elements that need to be present as perfect matches within the data :return: It returns a pair ((a,b), c), where * a, is the data path that was be aligned * b, is the set of the node alignments to the query * c, is the score associated from both the vertex and edge edit distance """ ## First step: check how many paths were aligned ## This if a first approximation of the alignments that will still provide us the edge edit distance edge_label_align = {} query_edge_match = 0 edge_matches = 0 while (query_edge_match < len(query_unrectified)): noMatch = True for i in range(len(data_rectified)): ## If I have no more alignments, then I'm done if (query_edge_match >= len(query_unrectified)): noMatch = False break ## If the labels do match (I'm going to refine the alignment in the next step) if (data_rectified[i][1] == query_rectified[query_edge_match][1]): # try: # if (len(data_rectified) == 2) and (data_rectified[0][1] == 'Conflict.Attack_Place') and (data_rectified[1][1] == 'Conflict.Attack_Target'): # print("loco") # except: # pass noMatch = False edge_label_align[query_edge_match] = data_rectified[i] query_edge_match += 1 edge_matches += 1 if noMatch: query_edge_match += 1 edge_plus_distance = len(data_rectified) - edge_matches edge_minus_distance = len(query_unrectified) - edge_matches ## Evaluate the node alignment using the distinct variables from the query node_align = { vertex: set() for vertex in set( flatten(map(lambda x: [x[0], x[2]], query_unrectified))) } for query_edge_id in edge_label_align: datum_rectified = edge_label_align[query_edge_id] variables = query_rectified[query_edge_id] node_align[variables[0]].add(datum_rectified[0]) node_align[variables[2]].add(datum_rectified[2]) ## Now, evaluating the vertex edit distance. ## 1) The vertex key in node_align is not aligned with the path if either its associated value list is empty or the ## entrypoint was not matched with the entrypoint vertex_minus_distance = len( list( filter( lambda x: len(x[1]) == 0 or (x[0] in entrypoint_map and len( set.intersection(x[1], entrypoint_map[x[0]])) == 0), node_align.items()))) ## 2) The added vertices are the ones that are more than the parts that are already aligned. vertex_plus_distance = fold( operator.add, map(lambda x: len(x[1]) - 1, filter(lambda x: len(x[1]) > 1, node_align.items())), 0) ## In addition to that, I must add the vertices that have not been matched with the element from the query for subpath in noneReplace( map(lambda x: None if x in edge_label_align.values() else x, data_rectified)): vertex_plus_distance += len(set(flatten(subpath)[1:-1])) ## In addition to that, I must consider the nodes not aligned with the entrypoint #for ep in entrypoint_map: # if (ep in node_align.keys()): # s = set.difference(set(node_align[ep]), {ep}) # if (len(s) > 0): # vertex_plus_distance += len(s) # elif ((len(s) == 0) and (ep in entrypoint_map) and (ep not in entrypoint_map[ep])): # vertex_minus_distance += 1 finalScore = edge_plus_distance + edge_minus_distance + vertex_minus_distance + vertex_plus_distance #if (finalScore == 0): # #print ("SCORE="+str()+" --\t"+str(list(map(lambda x: x[1], data_rectified)))+" E+ = "+str(edge_plus_distance)+ " E- = "+str(edge_minus_distance)+ " V+ = "+str(vertex_plus_distance)+" V- ="+str(vertex_minus_distance)) #if (finalScore == 1): # print("Score of "+str(finalScore)+" for path "+str(data_rectified)+" for cluster "+str(query_rectified)) return (data_rectified, node_align, finalScore)
def typeI(i: int, c: Context, term: TermI) -> Type: # with _pm, Ann|term as p: # reveal_type(p) with _pm, term >> Ann as (e1, e2): typeC(i, c, e2, VStar()) t = evalC(e2, []) typeC(i, c, e1, t) return t with _pm, term >> Free as (x,): return c[x] with _pm, term >> App as (e1, e2): s = typeI(i, c, e1) with _pm, s >> VPi as (v, f): typeC(i, c, e2, v) return f(evalC(e2, [])) raise TypeError(f"Illegal application: {e1}({e2})") with _pm, term >> Star: return VStar() with _pm, term >> Pi as (p, p1): typeC(i, c, p, VStar()) t = evalC(p, []) typeC(i + 1, {Local(i): t, **c}, substC(0, Free(Local(i)), p1), VStar()) return VStar() with _pm, term >> Nat: return VStar() with _pm, term >> Zero: return VNat() with _pm, term >> Succ: return VNat() with _pm, term >> NatElim as (m, mz, ms, k): typeC(i, c, m, VPi(VNat(), lambda _: VStar())) mVal = evalC(m, []) typeC(i, c, mz, vapp(mVal, VZero())) typeC( i, c, ms, VPi(VNat(), lambda l: VPi(vapp(mVal, l), lambda _: vapp(mVal, VSucc(l)))), ) typeC(i, c, k, VNat()) kVal = evalC(k, []) return vapp(mVal, kVal) with _pm, term >> Vec as (a, n): typeC(i, c, a, VStar()) typeC(i, c, n, VNat()) return VStar() with _pm, term >> Nil as (a,): typeC(i, c, a, VStar()) aVal = evalC(a, []) return VVec(aVal, VZero()) with _pm, term >> Cons as (a, k, x, xs): typeC(i, c, a, VStar()) aVal = evalC(a, []) typeC(i, c, k, VNat()) kVal = evalC(k, []) typeC(i, c, x, aVal) typeC(i, c, xs, VVec(aVal, kVal)) return VVec(aVal, VSucc(kVal)) with _pm, term >> VecElim as (a, m, mn, mc, k, vs): typeC(i, c, a, VStar()) aVal = evalC(a, []) typeC(i, c, m, VPi(VNat(), lambda k: VPi(VVec(aVal, k), lambda _: VStar()))) mVal = evalC(m, []) typeC(i, c, mn, foldl(vapp, mVal, [VZero(), VNil(aVal)])) typeC( i, c, mc, VPi( VNat(), lambda l: VPi( aVal, lambda y: VPi( VVec(aVal, l), lambda ys: VPi( foldl(vapp, mVal, [l, ys]), lambda _: foldl( vapp, mVal, [VSucc(l), VCons(aVal, l, y, ys)] ), ), ), ), ), ) typeC(i, c, k, VNat()) kVal = evalC(k, []) typeC(i, c, vs, VVec(aVal, kVal)) vsVal = evalC(vs, []) return fold(vapp, [kVal, vsVal], mVal) raise TypeError(f"Unknown instance '{type(term)}'")
def typeI(i: int, c: Context, term: TermI) -> Type: # with _pm, Ann|term as p: # reveal_type(p) with _pm: e1, e2 = term >> Ann typeC(i, c, e2, VStar()) t = evalC(e2, []) typeC(i, c, e1, t) return t with _pm: (x, ) = term >> Free return c[x] with _pm: e1, e2 = term >> App s = typeI(i, c, e1) with _pm: v, f = s >> VPi typeC(i, c, e2, v) return f(evalC(e2, [])) raise TypeError(f"Illegal application: {e1}({e2})") with _pm: term >> Star return VStar() with _pm: p, p1 = term >> Pi typeC(i, c, p, VStar()) t = evalC(p, []) typeC(i + 1, dict_merge({Local(i): t}, c), substC(0, Free(Local(i)), p1), VStar()) return VStar() with _pm: term >> Nat return VStar() with _pm: term >> Zero return VNat() with _pm: term >> Succ return VNat() with _pm: m, mz, ms, k = term >> NatElim typeC(i, c, m, VPi(VNat(), lambda _: VStar())) mVal = evalC(m, []) typeC(i, c, mz, vapp(mVal, VZero())) typeC( i, c, ms, VPi(VNat(), lambda l: VPi(vapp(mVal, l), lambda _: vapp(mVal, VSucc(l)))), ) typeC(i, c, k, VNat()) kVal = evalC(k, []) return vapp(mVal, kVal) with _pm: a, n = term >> Vec typeC(i, c, a, VStar()) typeC(i, c, n, VNat()) return VStar() with _pm: (a, ) = term >> Nil typeC(i, c, a, VStar()) aVal = evalC(a, []) return VVec(aVal, VZero()) with _pm: a, k, x, xs = term >> Cons typeC(i, c, a, VStar()) aVal = evalC(a, []) typeC(i, c, k, VNat()) kVal = evalC(k, []) typeC(i, c, x, aVal) typeC(i, c, xs, VVec(aVal, kVal)) return VVec(aVal, VSucc(kVal)) with _pm: a, m, mn, mc, k, vs = term >> VecElim typeC(i, c, a, VStar()) aVal = evalC(a, []) typeC(i, c, m, VPi(VNat(), lambda k: VPi(VVec(aVal, k), lambda _: VStar()))) mVal = evalC(m, []) typeC(i, c, mn, foldl(vapp, mVal, [VZero(), VNil(aVal)])) typeC( i, c, mc, VPi( VNat(), lambda l: VPi( aVal, lambda y: VPi( VVec(aVal, l), lambda ys: VPi( foldl(vapp, mVal, [l, ys]), lambda _: foldl(vapp, mVal, [ VSucc(l), VCons(aVal, l, y, ys) ]), ), ), ), ), ) typeC(i, c, k, VNat()) kVal = evalC(k, []) typeC(i, c, vs, VVec(aVal, kVal)) vsVal = evalC(vs, []) return fold(vapp, [kVal, vsVal], mVal) raise TypeError(f"Unknown instance '{type(term)}'")