Examples with Node catdata.fql.decl.Node used on opensource projects

Example 41 with Node

use of catdata.fql.decl.Node in project fql by CategoricalData.

the class PSMCurry method exec.

@Override
public void exec(PSMInterp interp, Map<String, Set<Map<Object, Object>>> state) {
    try {
        Instance IJ = new Instance(sig, PSMGen.gather(trans_src, sig, state));
        Instance K = new Instance(sig, PSMGen.gather(trans_dst, sig, state));
        Transform t = new Transform(IJ, K, PSMGen.gather(trans, sig, state));
        Instance I = new Instance(sig, PSMGen.gather(inst_src, sig, state));
        Instance J = new Instance(sig, PSMGen.gather(exp, sig, state));
        Instance JK = new Instance(sig, PSMGen.gather(inst_dst, sig, state));
        Transform trans_src0_fst = new Transform(IJ, I, PSMGen.gather(trans_src + "_fst", sig, state));
        Transform trans_src0_snd = new Transform(IJ, J, PSMGen.gather(trans_src + "_snd", sig, state));
        Map<Node, List<Pair<Arr<Node, Path>, Attribute<Node>>>> obs = I.thesig.obs();
        List<Pair<String, List<Pair<Object, Object>>>> l = new LinkedList<>();
        Quad<Instance, Map<Pair<Node, LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object>>, Triple<Instance, Map<Node, Map<Object, Pair<Arr<Node, Path>, Object>>>, Map<Node, Map<Pair<Arr<Node, Path>, Object>, Object>>>>, Map<Node, Map<Object, Pair<LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object>, Transform>>>, Map<Node, Map<Pair<LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object>, Transform>, Object>>> kkk = interp.exps2.get(inst_dst);
        for (Node c : sig.nodes) {
            List<Pair<Object, Object>> s = new LinkedList<>();
            for (Pair<Object, Object> xx : I.data.get(c.string)) {
                Object x = xx.first;
                LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object> w = I.flag(c, x);
                Triple<Instance, Map<Node, Map<Object, Pair<Arr<Node, Path>, Object>>>, Map<Node, Map<Pair<Arr<Node, Path>, Object>, Object>>> HcJ = kkk.second.get(new Pair<>(c, w));
                // construct transform depending on x, lookup in kkk.second
                List<Pair<String, List<Pair<Object, Object>>>> tx = new LinkedList<>();
                for (Node d : sig.nodes) {
                    List<Pair<Object, Object>> tx0 = new LinkedList<>();
                    for (Arr<Node, Path> f : sig.toCategory2().first.hom(c, d)) {
                        for (Pair<Object, Object> y : J.data.get(d.string)) {
                            // only if y(p.a) = w(p.a)
                            if (!PropPSM.truncate2(I.thesig, w, f, obs.get(d)).equals(J.flag(d, y.first))) {
                                continue;
                            }
                            Object Ifx = lookup(I.evaluate(f.arr), x);
                            // Object Ifx = lookup(HcJ.first.evaluate(f.arr), x);
                            Object u = find(d, trans_src0_fst, trans_src0_snd, Ifx, y.first);
                            Object v = lookup(t.data.get(d.string), u);
                            Object iii = HcJ.third.get(d).get(new Pair<>(f, y.first));
                            tx0.add(new Pair<>(iii, v));
                        }
                    }
                    // I*J -> K
                    tx.add(new Pair<>(d.string, tx0));
                }
                Transform xxx = new Transform(HcJ.first, K, tx);
                Object yyy = kkk.fourth.get(c).get(new Pair<>(w, xxx));
                s.add(new Pair<>(x, yyy));
            }
            l.add(new Pair<>(c.string, s));
        }
        Transform zzz = new Transform(I, JK, l);
        PSMGen.shred(ret, zzz, state);
    } catch (FQLException fe) {
        fe.printStackTrace();
        throw new RuntimeException(fe.getMessage());
    }
}

Example 42 with Node

use of catdata.fql.decl.Node in project fql by CategoricalData.

the class FullSigmaTrans method exec.

@Override
public void exec(PSMInterp interp, Map<String, Set<Map<Object, Object>>> state) {
    Signature C = f.source;
    Signature D = f.target;
    List<Pair<String, List<Pair<Object, Object>>>> I0 = PSMGen.gather(srcH, C, state);
    List<Pair<String, List<Pair<Object, Object>>>> J0 = PSMGen.gather(dstH, C, state);
    List<Pair<String, List<Pair<Object, Object>>>> H0 = PSMGen.gather(h, C, state);
    List<Pair<String, List<Pair<Object, Object>>>> J0X = PSMGen.gather(dst, D, state);
    List<Pair<String, List<Pair<Object, Object>>>> tempI = new LinkedList<>();
    List<Pair<String, List<Pair<Object, Object>>>> tempH = new LinkedList<>();
    for (Node n : C.nodes) {
        Set<Map<Object, Object>> x2 = state.get(dst + "_" + n.string + "_e");
        tempH.add(new Pair<>(n.string, convX(x2)));
        Set<Map<Object, Object>> x1 = state.get(dst + "_" + f.nm.get(n).string);
        tempI.add(new Pair<>(n.string, conv(x1)));
    }
    for (Edge e : C.edges) {
        Set<Map<Object, Object>> x1 = eval(state, dst, f.em.get(e));
        tempI.add(new Pair<>(e.name, conv(x1)));
    }
    for (Attribute<Node> e : C.attrs) {
        Set<Map<Object, Object>> x1 = state.get(dst + "_" + f.am.get(e).name);
        tempI.add(new Pair<>(e.name, conv(x1)));
    }
    try {
        Instance I = new Instance(C, I0);
        Instance J = new Instance(C, J0);
        Transform H = new Transform(I, J, H0);
        // Instance IX = new Instance(D, I0X);
        Instance JX = new Instance(D, J0X);
        Instance temp = new Instance(C, tempI);
        Transform etaJ = new Transform(J, temp, tempH);
        Transform HX = Transform.composeX(H, etaJ);
        // should pass H, but compute etaJ after de-attr.
        // that way, HX.dst and delta JX have attr IDs in common
        // de-attr JX
        Integer current = interp.guid;
        interp.guid = interp.sigmas.get(src);
        Quad<Instance, Map<Node, Map<Object, Integer>>, Map<Node, Map<Integer, Object>>, Map<Object, List<Pair<String, Object>>>> xxx = LeftKanSigma.fullSigmaWithAttrs(interp, f, I, HX, JX, interp.sigmas2.get(src));
        interp.guid = current;
        for (Node n : D.nodes) {
            state.put(pre + "_" + n.string, conv0(xxx.third.get(n)));
        }
        for (Attribute<Node> a : D.attrs) {
            state.put(pre + "_" + a.name, new HashSet<>());
        }
        for (Edge a : D.edges) {
            state.put(pre + "_" + a.name, new HashSet<>());
        }
    } catch (FQLException e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    }
}

Example 43 with Node

use of catdata.fql.decl.Node in project fql by CategoricalData.

the class LeftKan method alpha.

private boolean alpha() {
    Pair<Integer, Edge> p = smallest();
    if (p == null) {
        return false;
    }
    Integer x = p.first;
    Edge g = p.second;
    Node b2 = g.target;
    Integer y = fresh();
    Pb.get(b2).add(new Pair<>(y, y));
    Pg.get(g).add(new Pair<>(x, y));
    updateLineage(g.name, x, y);
    if (alpha != null) {
        Object xxx = lookup(J.data.get(p.second.name), utables.get(p.second.source).get(p.first));
        utables.get(p.second.target).put(y, xxx);
    }
    return true;
}

Example 44 with Node

use of catdata.fql.decl.Node in project fql by CategoricalData.

the class LeftKan method beta1.

private boolean beta1() {
    boolean ret = false;
    for (Eq eq : B.eqs) {
        Set<Pair<Integer, Integer>> lhs = eval(eq.lhs);
        Set<Pair<Integer, Integer>> rhs = eval(eq.rhs);
        Node n = eq.lhs.target;
        ret = ret || addCoincidences(lhs, rhs, n);
    }
    return ret;
}

Example 45 with Node

use of catdata.fql.decl.Node in project fql by CategoricalData.

the class LeftKanSigma method fullSigmaWithAttrs.

public static Quad<Instance, Map<Node, Map<Object, Integer>>, Map<Node, Map<Integer, Object>>, Map<Object, List<Pair<String, Object>>>> fullSigmaWithAttrs(PSMInterp inter, Mapping f, Instance i, Transform t, Instance JJJ, Integer xxx) throws FQLException {
    Mapping F = deAttr(f);
    Pair<Instance, Map<Attribute<Node>, Map<Object, Object>>> I = deAttr(inter, i, F.source);
    Integer kkk = inter.guid;
    Instance JJJ0 = null;
    Transform ttt = null;
    if (JJJ != null) {
        inter.guid = xxx;
        Pair<Instance, Map<Attribute<Node>, Map<Object, Object>>> JJJ0X = deAttr(inter, JJJ, F.target);
        Pair<Instance, Map<Attribute<Node>, Map<Object, Object>>> qqq = delta(f, F, JJJ0X);
        ttt = deAttr(f.source, I, qqq, t);
        JJJ0 = JJJ0X.first;
        inter.guid = kkk;
    }
    // System.out.println("!!!!!!!!!!!!!!!");
    LeftKan D = new LeftKan(inter.guid, F, I.first, ttt, JJJ0);
    Pair<Instance, Map<Object, List<Pair<String, Object>>>> hhh = sigma(D);
    inter.guid = D.fresh;
    Map<Node, Map<Object, Integer>> etables = makeE(D.ua);
    Instance j = hhh.first;
    Instance ret = reAttr(etables, f.target, j, I.second);
    return new Quad<>(ret, etables, D.utables, hhh.second);
}