project III (Sage)

evaluate

G = Graph(g, loops=True)

from sage.misc.prandom import random
from sage.structure.sage_object import SageObject
from sage.graphs.graph import Graph
import sage.graphs.graph_fast as graph_fast
from sage.graphs.base.all import SparseGraph, DenseGraph
from sage.rings.integer import Integer
from sage.rings.integer_ring import ZZ
from sage.rings.rational import Rational
from copy import copy

def weighted(self, new=None):
   if new is not None:
      if new:
         self._weighted = new
      else:
         return self._weighted
   if weighted is None:
      weighted = self._weighted

def copy(self):
   if self._directed:
      G = DiGraph(self, name=self.name(), pos=self._pos, boundary=self._boundary)
   else:
      G = Graph(self, name=self.name(), pos=self._pos, boundary=self._boundary)
   if hasattr(self, '_assoc'):
      from copy import copy
      G._assoc = {}
      for v in self._assoc:
         try:
            G._assoc[v] = self._assoc[v].copy()
         except:
            G._assoc[v] = copy(self._assoc[v])
   if hasattr(self, '_embedding'):
         G._embedding = self._embedding
         G._weighted = self._weighted
   return G

def loops(self):
   return self.loops()

def multiple_edges(self):
   return self.multiple_edges()

def loop_vertices(self):
   if self.loops():
      return [v for v in self if self.has_edge(v,v)]
   else:
      return []

G = Graph(g, loops=True)

def plot2(G, pos=None, layout=None, vertex_labels=True,
            edge_labels=False, vertex_size=200, graph_border=False,
            vertex_colors=None, partition=None, edge_colors=None,
            scaling_term=0.05, iterations=50, loop_size=.1, talk=False,
            color_by_label=False, heights=None, edge_style=None):
   if edge_style is None:
      edge_style={}
      edge_style.setdefault('width', 0.02) # pretty default
   if talk:
      vertex_size = 500
      if partition is None:
         vertex_colors = {'#FFFFFF':G.vertices()}
   from sage.plot.plot import networkx_plot, Graphics, rainbow
   if vertex_colors is None:
      if partition is not None:
         l = len(partition)
         R = rainbow(l)
         vertex_colors = {}
         for i in range(l):
            vertex_colors[R[i]] = partition[i]
      elif len(G._boundary) != 0:
         vertex_colors = {}
         bdy_verts = []
         int_verts = []
         for v in G.vertex_iterator():
            if v in G._boundary:
               bdy_verts.append(v)
            else:
               int_verts.append(v)
         vertex_colors['#ffffff'] = bdy_verts
         vertex_colors['#999999'] = int_verts
   if pos is None and layout is None and heights is None:
      if not G._pos is None:
         pos = G._pos
   elif layout == 'circular':
      from math import sin, cos, pi
      n = G.order()
      verts = G.vertices()
      pos = {}
      for i in range(n):
         x = float(cos((pi/2) + ((2*pi)/n)*i))
         y = float(sin((pi/2) + ((2*pi)/n)*i))
         pos[verts[i]] = [x,y]
   elif heights is not None:
      pos = {}
      mmax = max([len(ccc) for ccc in heights.values()])
      ymin = min(heights.keys())
      ymax = max(heights.keys())
      dist = ((ymax-ymin)/(mmax+1.0))
#      for height in heights:
#         num_xes = len(heights[height])
#            if num_xes == 0: continue
#            j = (mmax - num_xes)/2.0
#            for k in range(num_xes):
#               pos[heights[height][k]] = [ dist * (j+k+1), height ]
   if pos is None or layout == 'spring':
      pos = graph_fast.spring_layout_fast(G, iterations=iterations, vpos=pos)
   else:
      for v in pos:
         for a in range(len(pos[v])):
            pos[v][a] = float(pos[v][a])

if color_by_label:
      edge_colors = G._color_by_label()
        
   G = networkx_plot(G.networkx_graph(copy=False), pos=pos, vertex_labels=vertex_labels, \
      vertex_size=vertex_size, vertex_colors=vertex_colors, \
      edge_colors=edge_colors, graph_border=graph_border, \
      scaling_term=scaling_term, draw_edges=(not G._directed))
#   if G._directed:
#      from sage.plot.plot import arrow
#      P = Graphics()
   if edge_colors is None:
      edge_style.setdefault('rgbcolor', (0,0,0))
#      for u,v,_ in G.edge_iterator():
#         if u != v:
#            P += arrow((pos[u][0],pos[u][1]),(pos[v][0],pos[v][1]), **edge_style)
#         else:
#            for color in edge_colors:
#               for u,v,_ in edge_colors[color]:
#                  if u != v:
#                     this_edge=edge_style.copy()
#                     this_edge['rgbcolor']=color
#                     P += arrow((pos[u][0],pos[u][1]),(pos[v][0],pos[v][1]), **this_edge)
#         limits = (G.xmin(), G.xmax(), G.ymin(), G.ymax())
#         G = P + G
#         G.xmin(limits[0])
#         G.xmax(limits[1])
#         G.ymin(limits[2])
#         G.ymax(limits[3])
   if edge_labels:
      from sage.plot.plot import text
      K = Graphics()
      for u,v,l in G.edges():
         if not l is None:
            K += text(str(l), [(pos[u][0] + pos[v][0])/2, (pos[u][1] + pos[v][1])/2])
      K.axes_range(xmin=G.xmin(), xmax=G.xmax(), ymin=G.ymin(), ymax=G.ymax())
      G += K
   if G.loops:
      from sage.plot.plot import circle
      L = []
      for v in loop_vertices(G):
         L.append(circle((pos[v][0],pos[v][1]-loop_size), loop_size, rgbcolor=(0,0,0)))
      G = sum(L) + G
   G.axes(False)
   return G

evaluate

Traceback (click to the left for traceback)
...
AttributeError: 'Graphics' object has no attribute 'loops'

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/Users/ashleysaunders/.sage/sage_notebook/worksheets/admin/7/code/4.py", line 6, in <module>
    plot2(G)
  File "/Volumes/sage-3.0-osx10.5-intel-i386-Darwin/sage/local/lib/python2.5/site-packages/sympy/plotting/", line 1, in <module>
    
  File "/Users/ashleysaunders/.sage/sage_notebook/worksheets/admin/7/code/3.py", line 156, in plot2
    if G.loops:
AttributeError: 'Graphics' object has no attribute 'loops'

evaluate

def multiple_edges(self):
   return self.multiple_edges()
   if find_all_paths(g, u, v) <= 1:
      show2(G)
   if find_all_paths(g, u, v) > 1:
      for u,v in G:
         midpt(u,v) = (u+v)/2
         perpen(u,v) =

G = Graph(g, loops=True, multiple_edges=True)
def show2(self, pos=None, layout=None, vertex_labels=True,
             edge_labels=False, vertex_size=200, graph_border=False,
             vertex_colors=None, edge_colors=None, partition=None,
             scaling_term=0.05, talk=False, iterations=50, loop_size=.1,
             color_by_label=False, heights=None, edge_style=None, **kwds):

kwds.setdefault('figsize', [4,4])
   self.plot(pos=pos, layout=layout, vertex_labels=vertex_labels,
             edge_labels=edge_labels, vertex_size=vertex_size,
             vertex_colors=vertex_colors, edge_colors=edge_colors,
             graph_border=graph_border, partition=partition, talk=talk,
             scaling_term=scaling_term, iterations=iterations,
             color_by_label=color_by_label, loop_size=loop_size,
             heights=heights, edge_style=edge_style).show(**kwds)

show2(G)

evaluate

True

True

evaluate

[0, 1, 2, 3, 4]

[0, 1, 2, 3, 4]

evaluate

[[1, 1, 2], [1, 2, 4], [1], [0], [1, 3]]

[[1, 1, 2], [1, 2, 4], [1], [0], [1, 3]]

evaluate

[(0, [1, 1, 2]), (1, [1, 2, 4]), (2, [1]), (3, [0]), (4, [1, 3])]

[(0, [1, 1, 2]), (1, [1, 2, 4]), (2, [1]), (3, [0]), (4, [1, 3])]

evaluate

[(0, 1, None), (0, 1, None), (0, 2, None), (0, 3, None), (1, 1, None),
(1, 2, None), (1, 4, None), (3, 4, None)]

[(0, 1, None), (0, 1, None), (0, 2, None), (0, 3, None), (1, 1, None), (1, 2, None), (1, 4, None), (3, 4, None)]

evaluate

project III last edited on June 02, 2008 10:47 AM by admin
Typeset	Print Use Edit Text Revisions Share Publish