Warning

This documents an unmaintained version of NetworkX. Please upgrade to a maintained version and see the current NetworkX documentation.

Source code for networkx.readwrite.sparse6

"""Sparse6

Read and write graphs in sparse6 format.

Format
------

"graph6 and sparse6 are formats for storing undirected graphs in a
compact manner, using only printable ASCII characters. Files in these
formats have text type and contain one line per graph."

See http://cs.anu.edu.au/~bdm/data/formats.txt for details.
"""
# Original author: D. Eppstein, UC Irvine, August 12, 2003.
# The original code at http://www.ics.uci.edu/~eppstein/PADS/ is public domain.
#    Copyright (C) 2004-2015 by
#    Aric Hagberg <hagberg@lanl.gov>
#    Dan Schult <dschult@colgate.edu>
#    Pieter Swart <swart@lanl.gov>
#    Tomas Gavenciak <gavento@ucw.cz>
#    All rights reserved.
#    BSD license.
import networkx as nx
from networkx.exception import NetworkXError
from networkx.utils import open_file, not_implemented_for
from networkx.readwrite.graph6 import data_to_graph6, graph6_to_data,\
    data_to_n, n_to_data
__author__ = """\n""".join(['Tomas Gavenciak <gavento@ucw.cz>',
                            'Aric Hagberg <aric.hagberg@lanl.gov'])
__all__ = ['read_sparse6', 'parse_sparse6',
           'generate_sparse6', 'write_sparse6']

[docs]def parse_sparse6(string): """Read an undirected graph in sparse6 format from string. Parameters ---------- string : string Data in sparse6 format Returns ------- G : Graph Raises ------ NetworkXError If the string is unable to be parsed in sparse6 format Examples -------- >>> G = nx.parse_sparse6(':A_') >>> sorted(G.edges()) [(0, 1), (0, 1), (0, 1)] See Also -------- generate_sparse6, read_sparse6, write_sparse6 References ---------- Sparse6 specification: http://cs.anu.edu.au/~bdm/data/formats.txt """ if string.startswith('>>sparse6<<'): string = string[11:] if not string.startswith(':'): raise NetworkXError('Expected leading colon in sparse6') n, data = data_to_n(graph6_to_data(string[1:])) k = 1 while 1<<k < n: k += 1 def parseData(): """Return stream of pairs b[i], x[i] for sparse6 format.""" chunks = iter(data) d = None # partial data word dLen = 0 # how many unparsed bits are left in d while 1: if dLen < 1: d = next(chunks) dLen = 6 dLen -= 1 b = (d>>dLen) & 1 # grab top remaining bit x = d & ((1<<dLen)-1) # partially built up value of x xLen = dLen # how many bits included so far in x while xLen < k: # now grab full chunks until we have enough d = next(chunks) dLen = 6 x = (x<<6) + d xLen += 6 x = (x >> (xLen - k)) # shift back the extra bits dLen = xLen - k yield b,x v = 0 G = nx.MultiGraph() G.add_nodes_from(range(n)) multigraph = False for b,x in parseData(): if b == 1: v += 1 # padding with ones can cause overlarge number here if x >= n or v >= n: break elif x > v: v = x else: if G.has_edge(x,v): multigraph = True G.add_edge(x,v) if not multigraph: G = nx.Graph(G) return G
@open_file(0,mode='rt')
[docs]def read_sparse6(path): """Read an undirected graph in sparse6 format from path. Parameters ---------- path : file or string File or filename to write. Returns ------- G : Graph/Multigraph or list of Graphs/MultiGraphs If the file contains multple lines then a list of graphs is returned Raises ------ NetworkXError If the string is unable to be parsed in sparse6 format Examples -------- >>> nx.write_sparse6(nx.Graph([(0,1),(0,1),(0,1)]), 'test.s6') >>> G = nx.read_sparse6('test.s6') >>> sorted(G.edges()) [(0, 1)] See Also -------- generate_sparse6, read_sparse6, parse_sparse6 References ---------- Sparse6 specification: http://cs.anu.edu.au/~bdm/data/formats.txt """ glist = [] for line in path: line = line.strip() if not len(line): continue glist.append(parse_sparse6(line)) if len(glist) == 1: return glist[0] else: return glist
@not_implemented_for('directed')
[docs]def generate_sparse6(G, nodes=None, header=True): """Generate sparse6 format string from an undirected graph. Parameters ---------- G : Graph (undirected) nodes: list or iterable Nodes are labeled 0...n-1 in the order provided. If None the ordering given by G.nodes() is used. header: bool If True add '>>sparse6<<' string to head of data Returns ------- s : string String in sparse6 format Raises ------ NetworkXError If the graph is directed Examples -------- >>> G = nx.MultiGraph([(0, 1), (0, 1), (0, 1)]) >>> nx.generate_sparse6(G) '>>sparse6<<:A_' See Also -------- read_sparse6, parse_sparse6, write_sparse6 Notes ----- The format does not support edge or node labels. References ---------- Sparse6 specification: http://cs.anu.edu.au/~bdm/data/formats.txt for details. """ n = G.order() k = 1 while 1<<k < n: k += 1 def enc(x): """Big endian k-bit encoding of x""" return [1 if (x & 1 << (k-1-i)) else 0 for i in range(k)] if nodes is None: ns = list(G.nodes()) # number -> node else: ns = list(nodes) ndict = dict(((ns[i], i) for i in range(len(ns)))) # node -> number edges = [(ndict[u], ndict[v]) for (u, v) in G.edges()] edges = [(max(u,v), min(u,v)) for (u, v) in edges] edges.sort() bits = [] curv = 0 for (v, u) in edges: if v == curv: # current vertex edge bits.append(0) bits.extend(enc(u)) elif v == curv + 1: # next vertex edge curv += 1 bits.append(1) bits.extend(enc(u)) else: # skip to vertex v and then add edge to u curv = v bits.append(1) bits.extend(enc(v)) bits.append(0) bits.extend(enc(u)) if k < 6 and n == (1 << k) and ((-len(bits)) % 6) >= k and curv < (n - 1): # Padding special case: small k, n=2^k, # more than k bits of padding needed, # current vertex is not (n-1) -- # appending 1111... would add a loop on (n-1) bits.append(0) bits.extend([1] * ((-len(bits)) % 6)) else: bits.extend([1] * ((-len(bits)) % 6)) data = [(bits[i+0]<<5) + (bits[i+1]<<4) + (bits[i+2]<<3) + (bits[i+3]<<2) + (bits[i+4]<<1) + (bits[i+5]<<0) for i in range(0, len(bits), 6)] res = (':' + data_to_graph6(n_to_data(n)) + data_to_graph6(data)) if header: return '>>sparse6<<' + res else: return res
@open_file(1, mode='wt')
[docs]def write_sparse6(G, path, nodes=None, header=True): """Write graph G to given path in sparse6 format. Parameters ---------- G : Graph (undirected) path : file or string File or filename to write nodes: list or iterable Nodes are labeled 0...n-1 in the order provided. If None the ordering given by G.nodes() is used. header: bool If True add '>>sparse6<<' string to head of data Raises ------ NetworkXError If the graph is directed Examples -------- >>> G = nx.Graph([(0, 1), (0, 1), (0, 1)]) >>> nx.write_sparse6(G, 'test.s6') See Also -------- read_sparse6, parse_sparse6, generate_sparse6 Notes ----- The format does not support edge or node labels. References ---------- Sparse6 specification: http://cs.anu.edu.au/~bdm/data/formats.txt for details. """ path.write(generate_sparse6(G, nodes=nodes, header=header)) path.write('\n')
def teardown_module(test): import os if os.path.isfile('test.s6'): os.unlink('test.s6')