Examples with Fn catdata.fql.Fn used on opensource projects

Example 6 with Fn

use of catdata.fql.Fn in project fql by CategoricalData.

the class InstOps method visit.

@Override
public Pair<List<PSM>, Object> visit(String dst, Plus e) {
    SigExp k = e.type(prog);
    Signature s = k.toSig(prog);
    List<PSM> ret = new LinkedList<>();
    for (Node n : s.nodes) {
        List<Flower> l = new LinkedList<>();
        l.add(new CopyFlower(e.a + "_" + n.string, "c0", "c1"));
        l.add(new CopyFlower(e.b + "_" + n.string, "c0", "c1"));
        ret.add(new InsertSQL(dst + "_" + n.string, new Union(l), "c0", "c1"));
    }
    for (Attribute<Node> n : s.attrs) {
        List<Flower> l = new LinkedList<>();
        l.add(new CopyFlower(e.a + "_" + n.name, "c0", "c1"));
        l.add(new CopyFlower(e.b + "_" + n.name, "c0", "c1"));
        ret.add(new InsertSQL(dst + "_" + n.name, new Union(l), "c0", "c1"));
    }
    for (Edge n : s.edges) {
        List<Flower> l = new LinkedList<>();
        l.add(new CopyFlower(e.a + "_" + n.name, "c0", "c1"));
        l.add(new CopyFlower(e.b + "_" + n.name, "c0", "c1"));
        ret.add(new InsertSQL(dst + "_" + n.name, new Union(l), "c0", "c1"));
    }
    ret.addAll(PSMGen.guidify(dst, s, true));
    ret.addAll(PSMGen.makeTables(dst + "_inl", s, false));
    ret.addAll(PSMGen.makeTables(dst + "_inr", s, false));
    for (Node n : s.nodes) {
        SQL f = PSMGen.compose(e.a + "_" + n.string, dst + "_" + n.string + "_subst");
        ret.add(new InsertSQL(dst + "_inl_" + n.string, f, "c0", "c1"));
        SQL f0 = PSMGen.compose(e.b + "_" + n.string, dst + "_" + n.string + "_subst");
        ret.add(new InsertSQL(dst + "_inr_" + n.string, f0, "c0", "c1"));
    }
    // (f+g) : A+B -> C f : A -> C g : B -> C
    Fn<Quad<String, String, String, String>, List<PSM>> fn = x -> {
        // e.a -> x.third
        String f = x.first;
        // e.b -> x.third
        String g = x.second;
        // String C = x.third;
        String dst0 = x.fourth;
        // must be a map dst -> x.third
        List<PSM> ret1 = new LinkedList<>();
        for (Node n : s.nodes) {
            Flower sql1 = PSMGen.compose(dst + "_" + n.string + "_subst_inv", f + "_" + n.string);
            Flower sql2 = PSMGen.compose(dst + "_" + n.string + "_subst_inv", g + "_" + n.string);
            List<Flower> flowers = new LinkedList<>();
            flowers.add(sql1);
            flowers.add(sql2);
            ret1.add(new InsertSQL(dst0 + "_" + n.string, new Union(flowers), "c0", "c1"));
        }
        return ret1;
    };
    return new Pair<>(ret, fn);
}

Example 7 with Fn

use of catdata.fql.Fn in project fql by CategoricalData.

the class InstOps method visit.

@Override
public Pair<List<PSM>, Object> visit(String dst, Times e) {
    try {
        SigExp k = e.type(prog);
        Signature s = k.toSig(prog);
        List<PSM> ret = new LinkedList<>();
        ret.addAll(PSMGen.makeTables(dst + "_fst", s, false));
        ret.addAll(PSMGen.makeTables(dst + "_snd", s, false));
        Pair<Map<Node, List<Pair<Path, Attribute<Node>>>>, List<PSM>> l_obs = Relationalizer.observations(s, dst + "_l_obs", e.a, false);
        Pair<Map<Node, List<Pair<Path, Attribute<Node>>>>, List<PSM>> r_obs = Relationalizer.observations(s, dst + "_r_obs", e.b, false);
        if (!(l_obs.first.equals(r_obs.first))) {
            throw new RuntimeException("Internal error, please report.");
        }
        ret.addAll(PSMGen.makeTables(dst + "_l_obs", s, false));
        ret.addAll(l_obs.second);
        ret.addAll(PSMGen.dropTables(dst + "_l_obs", s));
        ret.addAll(PSMGen.makeTables(dst + "_r_obs", s, false));
        ret.addAll(r_obs.second);
        ret.addAll(PSMGen.dropTables(dst + "_r_obs", s));
        for (Node n : s.nodes) {
            List<Pair<Path, Attribute<Node>>> lats = l_obs.first.get(n);
            // List<Pair<Path, Attribute<Node>>> rats = r_obs.first.get(n);
            LinkedHashMap<String, Pair<String, String>> select = new LinkedHashMap<>();
            Map<String, String> from = new HashMap<>();
            List<String> attrs = new LinkedList<>();
            Map<String, String> attrsM = new HashMap<>();
            List<Pair<Pair<String, String>, Pair<String, String>>> where = new LinkedList<>();
            from.put("lft", dst + "_l_obs_" + n.string + "_observables");
            from.put("rght", dst + "_r_obs_" + n.string + "_observables");
            attrs.add("lft");
            attrs.add("rght");
            attrsM.put("lft", PSM.VARCHAR());
            attrsM.put("rght", PSM.VARCHAR());
            select.put("lft", new Pair<>("lft", "id"));
            select.put("rght", new Pair<>("rght", "id"));
            int idx = 0;
            for (Pair<Path, Attribute<Node>> aa : lats) {
                Attribute<Node> a = aa.second;
                where.add(new Pair<>(new Pair<>("lft", "c" + idx), new Pair<>("rght", "c" + idx)));
                select.put("c" + idx, new Pair<>("lft", "c" + idx));
                attrs.add("c" + idx);
                attrsM.put("c" + idx, a.target.psm());
                idx++;
            }
            Flower f = new Flower(select, from, where);
            ret.add(new CreateTable(dst + "_prod_temp_" + n.string, attrsM, false));
            ret.add(new InsertSQL2(dst + "_prod_temp_" + n.string, f, attrs));
            Map<String, String> attrsM0 = new HashMap<>(attrsM);
            attrsM0.put("gguid", PSM.VARCHAR());
            ret.add(new CreateTable(dst + "_prod_guid_" + n.string, attrsM0, false));
            ret.add(new InsertKeygen(dst + "_prod_guid_" + n.string, "gguid", dst + "_prod_temp_" + n.string, attrs));
            List<Pair<Pair<String, String>, Pair<String, String>>> where0 = new LinkedList<>();
            from = new HashMap<>();
            from.put("t", dst + "_prod_guid_" + n.string);
            select = new LinkedHashMap<>();
            select.put("c0", new Pair<>("t", "gguid"));
            select.put("c1", new Pair<>("t", "lft"));
            f = new Flower(select, from, where0);
            ret.add(new InsertSQL(dst + "_fst_" + n, f, "c0", "c1"));
            from = new HashMap<>();
            from.put("t", dst + "_prod_guid_" + n.string);
            select = new LinkedHashMap<>();
            select.put("c0", new Pair<>("t", "gguid"));
            select.put("c1", new Pair<>("t", "rght"));
            f = new Flower(select, from, where0);
            ret.add(new InsertSQL(dst + "_snd_" + n, f, "c0", "c1"));
            LinkedHashMap<String, Pair<String, String>> select0 = new LinkedHashMap<>();
            select0.put("c0", new Pair<>("t", "gguid"));
            select0.put("c1", new Pair<>("t", "gguid"));
            Map<String, String> from0 = new HashMap<>();
            from0.put("t", dst + "_prod_guid_" + n.string);
            Flower sql = new Flower(select0, from0, where0);
            ret.add(new InsertSQL(dst + "_" + n.string, sql, "c0", "c1"));
            for (Attribute<Node> a : s.attrsFor(n)) {
                select0 = new LinkedHashMap<>();
                select0.put("c0", new Pair<>("t", "gguid"));
                Arr<Node, Path> ppp = s.toCategory2().first.id(n);
                int ppp0 = lats.indexOf(new Pair<>(ppp.arr, a));
                select0.put("c1", new Pair<>("t", "c" + ppp0));
                from0 = new HashMap<>();
                from0.put("t", dst + "_prod_guid_" + n.string);
                sql = new Flower(select0, from0, where0);
                ret.add(new InsertSQL(dst + "_" + a.name, sql, "c0", "c1"));
            }
        // ret.add(new DropTable(dst + "_prod_temp_" + n));
        }
        for (Edge edge : s.edges) {
            Map<String, String> from = new HashMap<>();
            from.put("leftEdge", e.a + "_" + edge.name);
            from.put("rightEdge", e.b + "_" + edge.name);
            from.put("srcGuid", dst + "_prod_guid_" + edge.source);
            from.put("dstGuid", dst + "_prod_guid_" + edge.target);
            List<Pair<Pair<String, String>, Pair<String, String>>> where = new LinkedList<>();
            where.add(new Pair<>(new Pair<>("leftEdge", "c0"), new Pair<>("srcGuid", "lft")));
            where.add(new Pair<>(new Pair<>("rightEdge", "c0"), new Pair<>("srcGuid", "rght")));
            where.add(new Pair<>(new Pair<>("leftEdge", "c1"), new Pair<>("dstGuid", "lft")));
            where.add(new Pair<>(new Pair<>("rightEdge", "c1"), new Pair<>("dstGuid", "rght")));
            LinkedHashMap<String, Pair<String, String>> select = new LinkedHashMap<>();
            select.put("c0", new Pair<>("srcGuid", "gguid"));
            select.put("c1", new Pair<>("dstGuid", "gguid"));
            Flower f = new Flower(select, from, where);
            ret.add(new InsertSQL(dst + "_" + edge.name, f, "c0", "c1"));
        }
        Fn<Quad<String, String, String, String>, List<PSM>> fn = x -> {
            // x.third -> e.a
            String f = x.first;
            // x.third -> e.b
            String g = x.second;
            // String C = x.third;
            String dst0 = x.fourth;
            // must be a map x.third -> dst
            List<PSM> ret1 = new LinkedList<>();
            for (Node n : s.nodes) {
                List<Pair<Pair<String, String>, Pair<String, String>>> where = new LinkedList<>();
                Map<String, String> from = new HashMap<>();
                from.put("f", f + "_" + n.string);
                from.put("g", g + "_" + n.string);
                from.put("lim", dst + "_prod_guid_" + n.string);
                where.add(new Pair<>(new Pair<>("f", "c0"), new Pair<>("g", "c0")));
                where.add(new Pair<>(new Pair<>("lim", "lft"), new Pair<>("f", "c1")));
                where.add(new Pair<>(new Pair<>("lim", "rght"), new Pair<>("g", "c1")));
                LinkedHashMap<String, Pair<String, String>> select = new LinkedHashMap<>();
                select.put("c0", new Pair<>("f", "c0"));
                select.put("c1", new Pair<>("lim", "gguid"));
                Flower flower = new Flower(select, from, where);
                ret1.add(new InsertSQL(dst0 + "_" + n.string, flower, "c0", "c1"));
            }
            return ret1;
        };
        return new Pair<>(ret, fn);
    } catch (FQLException fe) {
        throw new RuntimeException(fe.getLocalizedMessage());
    }
}

Example 8 with Fn

use of catdata.fql.Fn in project fql by CategoricalData.

the class SigOps method plus.

private static Quad<SigExp.Const, Const, Const, Fn<Triple<SigExp.Const, Const, Const>, Const>> plus(SigExp.Const a, SigExp.Const b) {
    int node_count = 0;
    Map<String, String> node_map_1 = new LinkedHashMap<>();
    Map<String, String> node_map_2 = new LinkedHashMap<>();
    List<Pair<String, String>> a_objs = new LinkedList<>();
    List<Pair<String, String>> b_objs = new LinkedList<>();
    for (String n : a.nodes) {
        node_map_1.put(n, "node" + node_count);
        a_objs.add(new Pair<>(n, "node" + node_count));
        node_count++;
    }
    for (String n : b.nodes) {
        node_map_2.put(n, "node" + node_count);
        b_objs.add(new Pair<>(n, "node" + node_count));
        node_count++;
    }
    List<String> nodes = new LinkedList<>();
    nodes.addAll(node_map_1.values());
    nodes.addAll(node_map_2.values());
    int attr_count = 0;
    Map<String, Triple<String, String, String>> attr_map_1 = new LinkedHashMap<>();
    Map<String, Triple<String, String, String>> attr_map_2 = new LinkedHashMap<>();
    List<Pair<String, String>> a_attrs = new LinkedList<>();
    List<Pair<String, String>> b_attrs = new LinkedList<>();
    for (Triple<String, String, String> n : a.attrs) {
        attr_map_1.put(n.first, new Triple<>("attr" + attr_count, node_map_1.get(n.second), n.third));
        a_attrs.add(new Pair<>(n.first, "attr" + attr_count));
        attr_count++;
    }
    for (Triple<String, String, String> n : b.attrs) {
        attr_map_2.put(n.first, new Triple<>("attr" + attr_count, node_map_2.get(n.second), n.third));
        b_attrs.add(new Pair<>(n.first, "attr" + attr_count));
        attr_count++;
    }
    List<Triple<String, String, String>> attrs = new LinkedList<>();
    attrs.addAll(attr_map_1.values());
    attrs.addAll(attr_map_2.values());
    int edge_count = 0;
    Map<String, Triple<String, String, String>> edge_map_1 = new LinkedHashMap<>();
    Map<String, Triple<String, String, String>> edge_map_2 = new LinkedHashMap<>();
    List<Pair<String, List<String>>> a_arrows = new LinkedList<>();
    List<Pair<String, List<String>>> b_arrows = new LinkedList<>();
    for (Triple<String, String, String> n : a.arrows) {
        edge_map_1.put(n.first, new Triple<>("edge" + edge_count, node_map_1.get(n.second), node_map_1.get(n.third)));
        List<String> x = new LinkedList<>();
        x.add(node_map_1.get(n.second));
        x.add("edge" + edge_count);
        a_arrows.add(new Pair<>(n.first, x));
        edge_count++;
    }
    for (Triple<String, String, String> n : b.arrows) {
        edge_map_2.put(n.first, new Triple<>("edge" + edge_count, node_map_2.get(n.second), node_map_2.get(n.third)));
        List<String> x = new LinkedList<>();
        x.add(node_map_2.get(n.second));
        x.add("edge" + edge_count);
        b_arrows.add(new Pair<>(n.first, x));
        edge_count++;
    }
    List<Triple<String, String, String>> arrows = new LinkedList<>();
    arrows.addAll(edge_map_1.values());
    arrows.addAll(edge_map_2.values());
    List<Pair<List<String>, List<String>>> eqs = new LinkedList<>();
    for (Pair<List<String>, List<String>> eq : a.eqs) {
        List<String> lhs = new LinkedList<>();
        lhs.add(node_map_1.get(eq.first.get(0)));
        for (int i = 1; i < eq.first.size(); i++) {
            lhs.add(edge_map_1.get(eq.first.get(i)).first);
        }
        List<String> rhs = new LinkedList<>();
        rhs.add(node_map_1.get(eq.second.get(0)));
        for (int i = 1; i < eq.second.size(); i++) {
            rhs.add(edge_map_1.get(eq.second.get(i)).first);
        }
        eqs.add(new Pair<>(lhs, rhs));
    }
    for (Pair<List<String>, List<String>> eq : b.eqs) {
        List<String> lhs = new LinkedList<>();
        lhs.add(node_map_2.get(eq.first.get(0)));
        for (int i = 1; i < eq.first.size(); i++) {
            lhs.add(edge_map_2.get(eq.first.get(i)).first);
        }
        List<String> rhs = new LinkedList<>();
        rhs.add(node_map_2.get(eq.second.get(0)));
        for (int i = 1; i < eq.second.size(); i++) {
            rhs.add(edge_map_2.get(eq.second.get(i)).first);
        }
        eqs.add(new Pair<>(lhs, rhs));
    }
    SigExp.Const sig = new SigExp.Const(nodes, attrs, arrows, eqs);
    Const inj1 = new Const(a_objs, a_attrs, a_arrows, a, sig);
    Const inj2 = new Const(b_objs, b_attrs, b_arrows, b, sig);
    Fn<Triple<SigExp.Const, Const, Const>, Const> match = x -> {
        SigExp.Const c = x.first;
        Const f = x.second;
        Const g = x.third;
        if (!f.dst.equals(g.dst)) {
            throw new RuntimeException("Targets don't agree: " + f.dst + " and " + g.dst);
        }
        if (!f.src.equals(a)) {
            throw new RuntimeException("Source of " + f + " is not " + a);
        }
        if (!g.src.equals(b)) {
            throw new RuntimeException("Source of " + g + "is not " + b);
        }
        List<Pair<String, String>> objs = new LinkedList<>();
        for (String obj_a : a.nodes) {
            objs.add(new Pair<>(node_map_1.get(obj_a), lookup(obj_a, f.objs)));
        }
        for (String obj_b : b.nodes) {
            objs.add(new Pair<>(node_map_2.get(obj_b), lookup(obj_b, g.objs)));
        }
        List<Pair<String, String>> attrs1 = new LinkedList<>();
        for (Triple<String, String, String> attr_a : a.attrs) {
            attrs1.add(new Pair<>(attr_map_1.get(attr_a.first).first, lookup(attr_a.first, f.attrs)));
        }
        for (Triple<String, String, String> attr_b : b.attrs) {
            attrs1.add(new Pair<>(attr_map_2.get(attr_b.first).first, lookup(attr_b.first, g.attrs)));
        }
        List<Pair<String, List<String>>> arrows1 = new LinkedList<>();
        for (Triple<String, String, String> edge_a : a.arrows) {
            arrows1.add(new Pair<>(edge_map_1.get(edge_a.first).first, lookup(edge_a.first, f.arrows)));
        }
        for (Triple<String, String, String> edge_b : b.arrows) {
            arrows1.add(new Pair<>(edge_map_2.get(edge_b.first).first, lookup(edge_b.first, g.arrows)));
        }
        return new Const(objs, attrs1, arrows1, sig, c);
    };
    return new Quad<>(sig, inj1, inj2, match);
}