public State(Graph g, int maxidx) { this.g = g; this.visit = new boolean[g.order()]; this.map = new int[maxidx + 1]; this.nMaps = 0; } }
private Traversal(Graph g) { this.g = g; this.visited = new boolean[g.order()]; this.ordering = new int[g.order()]; BitSet dbAtoms = new BitSet(); for (int u = 0; u < g.order(); u++) { if (!visited[u]) dbAtoms.or(visit(u, u)); } Collections.sort(doubleBonds, new Comparator<Edge>() { @Override public int compare(Edge e, Edge f) { int u1 = e.either(); int v1 = e.other(u1); int u2 = f.either(); int v2 = f.other(u2); int min1 = Math.min(ordering[u1], ordering[v1]); int min2 = Math.min(ordering[u2], ordering[v2]); int cmp = min1 - min2; if (cmp != 0) return cmp; int max1 = Math.max(ordering[u1], ordering[v1]); int max2 = Math.max(ordering[u2], ordering[v2]); return max1 - max2; } }); for (Edge e : doubleBonds) { if (acc.containsKey(e)) continue; flip(g, e, dbAtoms); } }
/** * Reverse the atom order of the provided chemical graph. * * @param g chemical graph * @return a copy of the original graph with the order of the atoms * reversed */ public static Graph reverse(Graph g) { return g.permute(reverse(g.order())); }
/** * Randomise the atom order of the provided chemical graph. * * @param g chemical graph * @return a copy of the original graph with the order of the atoms * randomised */ public static Graph randomise(Graph g) { return g.permute(random(g.order())); }
private List<Edge> doubleBondLabelledEdges(Graph g) { List<Edge> es = new ArrayList<Edge>(); for (int u = 0; u < g.order(); u++) { for (Edge e : g.edges(u)) { if (e.other(u) > u && e.bond() == Bond.DOUBLE) { es.add(e); } } } return es; }
/** * Transform all explicit to implicit bonds. The original graph is * unmodified. * * @param g a chemical graph * @return new chemical graph but with all explicit bonds */ public Graph apply(final Graph g) { Graph h = new Graph(g.order()); // atom/topology information doesn't change for (int u = 0; u < g.order(); u++) { h.addAtom(g.atom(u)); h.addTopology(g.topologyOf(u)); } // transform edges for (int u = 0; u < g.order(); u++) { for (final Edge e : g.edges(u)) { if (e.other(u) > u) h.addEdge(toImplicitEdge(g, e)); } } return h; }
/** * Transform all implicit to explicit bonds. The original graph is * unmodified * * @param g a chemical graph * @return new chemical graph but with all explicit bonds */ public Graph apply(final Graph g) { Graph h = new Graph(g.order()); // copy atom/topology information for (int u = 0; u < g.order(); u++) { h.addAtom(g.atom(u)); h.addTopology(g.topologyOf(u)); } // apply edges for (int u = 0; u < g.order(); u++) { for (final Edge e : g.edges(u)) { if (e.other(u) > u) h.addEdge(toExplicitEdge(g, e)); } } return h; }
public Graph apply(final Graph g) throws InvalidSmilesException { Graph h = new Graph(g.order()); for (int u = 0; u < g.order(); u++) { h.addAtom(g.atom(u)); h.addTopology(g.topologyOf(u)); for (int u = 0; u < g.order(); u++) { for (final Edge e : g.edges(u)) { if (e.other(u) > u && e.bond() == Bond.DOUBLE) { for (int u = 0; u < g.order(); u++) { for (Edge e : g.edges(u)) { if (e.other(u) > u) {
public Graph apply(Graph g) { Graph h = new Graph(g.order()); // copy atom/topology information this is unchanged for (int u = 0; u < g.order(); u++) { if (g.topologyOf(u).type() == DoubleBond) { h.addAtom(reducedAtom(g, u)); } else { h.addAtom(g.atom(u)); h.addTopology(g.topologyOf(u)); } } Map<Edge, Edge> replacements = new Traversal(g).replacement; // append the edges, replacing any which need to be changed for (int u = 0; u < g.order(); u++) { for (Edge e : g.edges(u)) { if (e.other(u) > u) { Edge replacement = replacements.get(e); if (replacement != null) e = replacement; h.addEdge(e); } } } return h; }
@Override public Graph apply(Graph g) { Traversal traversal = new Traversal(g); Graph h = new Graph(g.order()); h.addFlags(g.getFlags(0xffffffff)); // copy atom/topology information this is unchanged for (int u = 0; u < g.order(); u++) { h.addAtom(g.atom(u)); h.addTopology(g.topologyOf(u)); } // change edges (only changed added to replacement) for (int u = 0; u < g.order(); u++) { final int d = g.degree(u); for (int j = 0; j < d; ++j) { final Edge e = g.edgeAt(u, j); if (e.other(u) > u) { if (traversal.acc.containsKey(e)) { h.addEdge(traversal.acc.get(e)); } else { h.addEdge(e); } } } } return h.sort(new Graph.CanOrderFirst()); }
public Graph apply(Graph g) { Graph h = new Graph(g.order()); for (int u = 0; u < g.order(); u++) { // only attempt subset conversion if no known topology Topology t = g.topologyOf(u); if (t.type() == None) { h.addAtom(toSubset(g.atom(u), g, u)); } else { h.addAtom(g.atom(u)); h.addTopology(t); } } // edges are unchanged for (Edge e : g.edges()) h.addEdge(e); return h; }
public Graph apply(Graph g) { Graph h = new Graph(g.order()); for (int u = 0; u < g.order(); u++) { h.addTopology(g.topologyOf(u)); for (int u = 0; u < g.order(); u++) { for (final Edge e : g.edges(u)) { if (e.other(u) > u && e.bond() == Bond.UP || e for (int u = 0; u < g.order(); u++) { Atom a = g.atom(u); if (a.subset() && h.topologyOf(u) != Topology.unknown()) { for (int u = 0; u < g.order(); u++) { for (Edge e : g.edges(u)) { if (e.other(u) > u) {
for (int u = 0; u < g.order(); u++) { final int d = g.degree(u); for (int j = 0; j < d; ++j) { Graph h = new Graph(g.order()); h.addFlags(g.getFlags(0xffffffff)); for (int u = 0; u < g.order(); u++) { h.addAtom(g.atom(u)); h.addTopology(g.topologyOf(u)); for (int u = 0; u < g.order(); u++) { final int d = g.degree(u); for (int j = 0; j < d; ++j) {
int numAtoms = g.order(); IAtom[] atoms = new IAtom[numAtoms]; IBond[] bonds = new IBond[g.size()]; boolean checkBondStereo = false; for (int i = 0; i < g.order(); i++) { checkAtomStereo = checkAtomStereo || g.configurationOf(i).type() != Configuration.Type.None; atoms[i] = toCDKAtom(g.atom(i), g.implHCount(i)); for (int i = 0; i < g.order(); i++) atoms[i] = ac.getAtom(i); for (Edge edge : g.edges()) { for (int u = 0; u < g.order(); u++) {