returns edges that are in both old and new
177419
def _find_unchanged(old, new):
    
    edges = []
    old_edges = [set(edge) for edge in old.edges()]
    new_edges = [set(edge) for edge in new.edges()]
    for old_edge in old_edges:
        if old_edge in new_edges:
            edges.append(set(old_edge))
    return edges
1064731
def to_edges(*args)
      selected = args.collect do |arg|
        case arg
          when Integer
            [@edges[arg]]
          when EdgeSet
            arg
          when Array
            arg.collect{|v| to_edges(v)}.flatten.uniq
          when Digraph::Edge
            [arg]
          else
            pred = Predicate.to_predicate(arg)
            edges(pred)
        end
      end.flatten.uniq
      EdgeSet.new(selected)
    end
462167
def edges
      result = []
      c = edge_class
      each_edge { |u,v| result << c.new(u,v) }
      result
    end
1121226
def get_c2ps(self):
        """"""
        c2ps = defaultdict(set)
        for goid_child, goid_parent in self.edges:
            c2ps[goid_child].add(goid_parent)
        return c2ps
954056
def build_edges(self):
        
        self.edges = [
            edge if isinstance(edge, Edge) else Edge(*edge)
            for node in self.nodes.values()
            for edge in getattr(node, "edges", [])
            if edge[0] in self.nodes and edge[1] in self.nodes
        ]
        return self
153449
def sort_edge(edges):
        
        return sorted(edges, key=lambda x: (x.L, x.R))
765230
def getedges(fname, iddfile):
    """"""
    data, commdct, _idd_index = readidf.readdatacommdct(fname, iddfile=iddfile)
    edges = makeairplantloop(data, commdct)
    return edges
541102
def edges
	    points = self.vertices
	    points.each_cons(2).map {|p1,p2| Edge.new(p1,p2) } + [Edge.new(points.last, points.first)]
	end
1310407
def restore_all_edges(self):
        
        for edge in self.hidden_edges.keys():
            try:
                self.restore_edge(edge)
            except GraphError:
                pass
1147924
def getBothEdges(self, label=None):
        """"""
        if label:
            for edge in self.neoelement.relationships.all(types=[label]):
                yield Edge(edge)
        else:
            for edge in self.neoelement.relationships.all():
                yield Edge(edge)
729985
def list_edges(self, *, axis: int) -> List[str]:
		
		deprecated("'list_edges' is deprecated. Use 'ds.row_graphs.keys()' or 'ds.col_graphs.keys()' instead")
		if axis == 0:
			return self.row_graphs.keys()
		elif axis == 1:
			return self.col_graphs.keys()
		else:
			return []
881494
def getOutEdges(self, vertex, rawResults = False) :
        """"""
        return self.getEdges(vertex, inEdges = False, outEdges = True, rawResults = rawResults)
60824
def edges(self):
        
        edges, index = geometry.faces_to_edges(self.faces.view(np.ndarray),
                                               return_index=True)
        self._cache['edges_face'] = index
        return edges
757849
def get_edge_ids_by_node_ids(self, node_a, node_b):
        """"""
        # Check if the nodes are adjacent
        if not self.adjacent(node_a, node_b):
            return []

        # They're adjacent, so pull the list of edges from node_a and determine which ones point to node_b
        node = self.get_node(node_a)
        return [edge_id for edge_id in node['edges'] if self.get_edge(edge_id)['vertices'][1] == node_b]
85219
def get_irregular_edge_by_vertex(graph, vertex):
    
    for edge in graph.get_edges_by_vertex(vertex):
        if edge.is_irregular_edge:
            return edge
    return None
1306948
def hasEdge(self, diff):
        
        return diff.toVol in [d.toVol for d in self.diffs[diff.fromVol]]
450345
def in_edges(filter=nil, &block)
      r = self.collect {|v| v.in_edges(filter, &block) }
      EdgeSet.new(r).flatten.uniq
    end