def plot(self, max_points=2500, **args):
r"""
Create a visualization of this `p`-adic ring as a fractal
similar to a generalization of the Sierpi\'nski
triangle.
The resulting image attempts to capture the
algebraic and topological characteristics of `\mathbb{Z}_p`.
INPUT:
- ``max_points`` -- the maximum number or points to plot,
which controls the depth of recursion (default 2500)
- ``**args`` -- color, size, etc. that are passed to the
underlying point graphics objects
REFERENCES:
- Cuoco, A. ''Visualizing the `p`-adic Integers'', The
American Mathematical Monthly, Vol. 98, No. 4 (Apr., 1991),
pp. 355-364
EXAMPLES::
sage: Zp(3).plot()
Graphics object consisting of 1 graphics primitive
sage: Zp(5).plot(max_points=625)
Graphics object consisting of 1 graphics primitive
sage: Zp(23).plot(rgbcolor=(1,0,0))
Graphics object consisting of 1 graphics primitive
"""
if 'pointsize' not in args:
args['pointsize'] = 1
from sage.misc.mrange import cartesian_product_iterator
from sage.rings.real_double import RDF
from sage.plot.all import points, circle, Graphics
p = self.prime()
phi = 2 * RDF.pi() / p
V = RDF**2
vs = [V([(phi * t).sin(), (phi * t).cos()]) for t in range(p)]
all = []
depth = max(RDF(max_points).log(p).floor(), 1)
scale = min(RDF(1.5 / p), 1 / RDF(3))
pts = [vs] * depth
if depth == 1 and 23 < p < max_points:
extras = int(max_points / p)
if p / extras > 5:
pts = [vs] * depth + [vs[::extras]]
for digits in cartesian_product_iterator(pts):
p = sum([v * scale**n for n, v in enumerate(digits)])
all.append(tuple(p))
g = points(all, **args)
# Set default plotting options
g.axes(False)
g.set_aspect_ratio(1)
return g
def plot(self, max_points=2500, **args):
r"""
Create a visualization of this `p`-adic ring as a fractal
similar to a generalization of the Sierpi\'nski
triangle.
The resulting image attempts to capture the
algebraic and topological characteristics of `\mathbb{Z}_p`.
INPUT:
- ``max_points`` -- the maximum number or points to plot,
which controls the depth of recursion (default 2500)
- ``**args`` -- color, size, etc. that are passed to the
underlying point graphics objects
REFERENCES:
- Cuoco, A. ''Visualizing the `p`-adic Integers'', The
American Mathematical Monthly, Vol. 98, No. 4 (Apr., 1991),
pp. 355-364
EXAMPLES::
sage: Zp(3).plot()
Graphics object consisting of 1 graphics primitive
sage: Zp(5).plot(max_points=625)
Graphics object consisting of 1 graphics primitive
sage: Zp(23).plot(rgbcolor=(1,0,0))
Graphics object consisting of 1 graphics primitive
"""
if 'pointsize' not in args:
args['pointsize'] = 1
from sage.misc.mrange import cartesian_product_iterator
from sage.rings.real_double import RDF
from sage.plot.all import points, circle, Graphics
p = self.prime()
phi = 2*RDF.pi()/p
V = RDF**2
vs = [V([(phi*t).sin(), (phi*t).cos()]) for t in range(p)]
all = []
depth = max(RDF(max_points).log(p).floor(), 1)
scale = min(RDF(1.5/p), 1/RDF(3))
pts = [vs]*depth
if depth == 1 and 23 < p < max_points:
extras = int(max_points/p)
if p/extras > 5:
pts = [vs]*depth + [vs[::extras]]
for digits in cartesian_product_iterator(pts):
p = sum([v * scale**n for n, v in enumerate(digits)])
all.append(tuple(p))
g = points(all, **args)
# Set default plotting options
g.axes(False)
g.set_aspect_ratio(1)
return g
def circle_plot(self):
pts = []
pi = RR.pi()
for angle in self.angles:
angle = RR(angle) * pi
c = angle.cos()
s = angle.sin()
if abs(s) < 0.00000001:
pts.append((c, s))
else:
pts.extend([(c, s), (c, -s)])
P = points(pts, size=100) + circle((0, 0), 1, color='black')
P.axes(False)
P.set_aspect_ratio(1)
return encode_plot(P)
def circle_plot(self):
pts = []
pi = RR.pi()
for angle in self.angles:
angle = RR(angle)*pi
c = angle.cos()
s = angle.sin()
if abs(s) < 0.00000001:
pts.append((c,s))
else:
pts.extend([(c,s),(c,-s)])
P = points(pts,size=100) + circle((0,0),1,color='black')
P.axes(False)
P.set_aspect_ratio(1)
return encode_plot(P)
def circle_plot(self):
pts = []
pi = RR.pi()
for angle in self.angles:
angle = RR(angle) * pi
c = angle.cos()
s = angle.sin()
if abs(s) < 0.00000001:
pts.append((c, s))
else:
pts.extend([(c, s), (c, -s)])
P = circle((0, 0), 1, color="black", thickness=2.5)
P[0].set_zorder(-1)
P += points(pts, size=300, rgbcolor="darkblue")
P.axes(False)
P.set_aspect_ratio(1)
return encode_plot(P, pad=0, pad_inches=None, transparent=True, axes_pad=0.04)
def geomrep(M1, B1=None, lineorders1=None, pd=None, sp=False):
"""
Return a sage graphics object containing geometric representation of
matroid M1.
INPUT:
- ``M1`` -- A matroid.
- ``B1`` -- (optional) A list of elements in ``M1.groundset()`` that
correspond to a basis of ``M1`` and will be placed as vertices of the
triangle in the geometric representation of ``M1``.
- ``lineorders1`` -- (optional) A list of ordered lists of elements of
``M1.grondset()`` such that if a line in geometric representation is
setwise same as any of these then points contained will be traversed in
that order thus overriding internal order deciding heuristic.
- ``pd`` - (optional) A dictionary mapping ground set elements to their
(x,y) positions.
- ``sp`` -- (optional) If True, a positioning dictionary and line orders
will be placed in ``M._cached_info``.
OUTPUT:
A sage graphics object of type <class 'sage.plot.graphics.Graphics'> that
corresponds to the geometric representation of the matroid.
EXAMPLES::
sage: from sage.matroids import matroids_plot_helpers
sage: M=matroids.named_matroids.P7()
sage: G=matroids_plot_helpers.geomrep(M)
sage: G.show(xmin=-2, xmax=3, ymin=-2, ymax=3)
sage: M=matroids.named_matroids.P7()
sage: G=matroids_plot_helpers.geomrep(M,lineorders1=[['f','e','d']])
sage: G.show(xmin=-2, xmax=3, ymin=-2, ymax=3)
.. NOTE::
This method does NOT do any checks.
"""
G = Graphics()
# create lists of loops and parallel elements and simplify given matroid
[M, L, P] = slp(M1, pos_dict=pd, B=B1)
if B1 is None:
B1 = list(M.basis())
M._cached_info = M1._cached_info
if M.rank() == 0:
limits = None
loops = L
looptext = ", ".join([str(l) for l in loops])
rectx = -1
recty = -1
rectw = 0.5 + 0.4*len(loops) + 0.5 # controlled based on len(loops)
recth = 0.6
G += polygon2d([[rectx, recty], [rectx, recty+recth],
[rectx+rectw, recty+recth], [rectx+rectw, recty]],
color='black', fill=False, thickness=4)
G += text(looptext, (rectx+0.5, recty+0.3), color='black',
fontsize=13)
G += point((rectx+0.2, recty+0.3), color=Color('#BDBDBD'), size=300,
zorder=2)
G += text('Loop(s)', (rectx+0.5+0.4*len(loops)+0.1, recty+0.3),
fontsize=13, color='black')
limits = tracklims(limits, [rectx, rectx+rectw], [recty, recty+recth])
G.axes(False)
G.axes_range(xmin=limits[0]-0.5, xmax=limits[1]+0.5,
ymin=limits[2]-0.5, ymax=limits[3]+0.5)
return G
elif M.rank() == 1:
if M._cached_info is not None and \
'plot_positions' in M._cached_info.keys() and \
M._cached_info['plot_positions'] is not None:
pts = M._cached_info['plot_positions']
else:
pts = {}
gnd = sorted(M.groundset())
pts[gnd[0]] = (1, float(2)/3)
G += point((1, float(2)/3), size=300, color=Color('#BDBDBD'), zorder=2)
pt = [1, float(2)/3]
if len(P) == 0:
G += text(gnd[0], (float(pt[0]), float(pt[1])), color='black',
fontsize=13)
pts2 = pts
# track limits [xmin,xmax,ymin,ymax]
pl = [list(x) for x in pts2.values()]
lims = tracklims([None, None, None, None], [pt[0] for pt in pl],
[pt[1] for pt in pl])
elif M.rank() == 2:
nB1 = list(set(list(M.groundset())) - set(B1))
bline = []
for j in nB1:
if M.is_dependent([j, B1[0], B1[1]]):
bline.append(j)
interval = len(bline)+1
if M._cached_info is not None and \
'plot_positions' in M._cached_info.keys() and \
M._cached_info['plot_positions'] is not None:
pts2 = M._cached_info['plot_positions']
else:
pts2 = {}
pts2[B1[0]] = (0, 0)
pts2[B1[1]] = (2, 0)
lpt = list(pts2[B1[0]])
rpt = list(pts2[B1[1]])
for k in range(len(bline)):
cc = (float(1)/interval)*(k+1)
pts2[bline[k]] = (cc*lpt[0]+(1-cc)*rpt[0],
cc*lpt[1]+(1-cc)*rpt[1])
if sp is True:
M._cached_info['plot_positions'] = pts2
# track limits [xmin,xmax,ymin,ymax]
pl = [list(x) for x in pts2.values()]
lims = tracklims([None, None, None, None], [pt[0] for pt in pl],
[pt[1] for pt in pl])
bline.extend(B1)
ptsx, ptsy, x_i, y_i = createline(pts2, bline, lineorders1)
lims = tracklims(lims, x_i, y_i)
G += line(zip(x_i, y_i), color='black', thickness=3, zorder=1)
pels = [p for p in pts2.keys() if any([M1.rank([p, q]) == 1
for q in P])]
allpts = [list(pts2[i]) for i in M.groundset()]
xpts = [float(k[0]) for k in allpts]
ypts = [float(k[1]) for k in allpts]
G += points(zip(xpts, ypts), color=Color('#BDBDBD'), size=300,
zorder=2)
for i in pts2:
if i not in pels:
pt = list(pts2[i])
G += text(i, (float(pt[0]), float(pt[1])), color='black',
fontsize=13)
else:
if M._cached_info is None or \
'plot_positions' not in M._cached_info.keys() or \
M._cached_info['plot_positions'] is None:
(pts, trilines,
nontripts, curvedlines) = it(M1, B1,
list(set(M.groundset())-set(B1)),
list(set(L) | set(P)))
pts2 = addnontripts([B1[0], B1[1], B1[2]], nontripts, pts)
trilines.extend(curvedlines)
else:
pts2 = M._cached_info['plot_positions']
trilines = [list(set(list(x)).difference(L | P))
for x in M1.flats(2)
if len(list(x)) >= 3]
pl = [list(x) for x in pts2.values()]
lims = tracklims([None, None, None, None], [pt[0] for pt in pl],
[pt[1] for pt in pl])
j = 0
for ll in trilines:
if len(ll) >= 3:
ptsx, ptsy, x_i, y_i = createline(pts2, ll, lineorders1)
lims = tracklims(lims, x_i, y_i)
G += line(zip(x_i, y_i), color='black', thickness=3, zorder=1)
pels = [p for p in pts2.keys() if any([M1.rank([p, q]) == 1
for q in P])]
allpts = [list(pts2[i]) for i in M.groundset()]
xpts = [float(k[0]) for k in allpts]
ypts = [float(k[1]) for k in allpts]
G += points(zip(xpts, ypts), color=Color('#BDBDBD'), size=300,
zorder=2)
for i in pts2:
if i not in pels:
pt = list(pts2[i])
G += text(i, (float(pt[0]), float(pt[1])), color='black',
fontsize=13)
if sp is True:
M1._cached_info['plot_positions'] = pts2
M1._cached_info['plot_lineorders'] = lineorders1
# deal with loops and parallel elements
G, lims = addlp(M1, M, L, P, pts2, G, lims)
G.axes(False)
G.axes_range(xmin=lims[0]-0.5, xmax=lims[1]+0.5, ymin=lims[2]-0.5,
ymax=lims[3]+0.5)
return G
def addlp(M, M1, L, P, ptsdict, G=None, limits=None):
"""
Return a graphics object containing loops (in inset) and parallel elements
of matroid.
INPUT:
- ``M`` -- A matroid.
- ``M1`` -- A simple matroid corresponding to ``M``.
- ``L`` -- List of elements in ``M.groundset()`` that are loops of matroid
``M``.
- ``P`` -- List of elements in ``M.groundset()`` not in
``M.simplify.groundset()`` or ``L``.
- ``ptsdict`` -- A dictionary containing elements in ``M.groundset()`` not
necessarily containing elements of ``L``.
- ``G`` -- (optional) A sage graphics object to which loops and parallel
elements of matroid `M` added .
- ``limits``-- (optional) Current axes limits [xmin,xmax,ymin,ymax].
OUTPUT:
A 2-tuple containing:
1. A sage graphics object containing loops and parallel elements of
matroid ``M``
2. axes limits array
EXAMPLES::
sage: from sage.matroids import matroids_plot_helpers
sage: M=Matroid(ring=GF(2), matrix=[[1, 0, 0, 0, 1, 1, 1,0,1],
....: [0, 1, 0, 1, 0, 1, 1,0,0],[0, 0, 1, 1, 1, 0, 1,0,0]])
sage: [M1,L,P]=matroids_plot_helpers.slp(M)
sage: G,lims=matroids_plot_helpers.addlp(M,M1,L,P,{0:(0,0)})
sage: G.show(axes=False)
.. NOTE::
This method does NOT do any checks.
"""
if G is None:
G = Graphics()
# deal with loops
if len(L) > 0:
loops = L
looptext = ", ".join([str(l) for l in loops])
if(limits is None):
rectx = -1
recty = -1
else:
rectx = limits[0]
recty = limits[2]-1
rectw = 0.5 + 0.4*len(loops) + 0.5 # controlled based on len(loops)
recth = 0.6
G += polygon2d([[rectx, recty], [rectx, recty+recth],
[rectx+rectw, recty+recth], [rectx+rectw, recty]],
color='black', fill=False, thickness=4)
G += text(looptext, (rectx+0.5, recty+0.3), color='black',
fontsize=13)
G += point((rectx+0.2, recty+0.3), color=Color('#BDBDBD'), size=300,
zorder=2)
G += text('Loop(s)', (rectx+0.5+0.4*len(loops)+0.1, recty+0.3),
fontsize=13, color='black')
limits = tracklims(limits, [rectx, rectx+rectw], [recty, recty+recth])
# deal with parallel elements
if len(P) > 0:
# create list of lists where inner lists are parallel classes
pcls = []
gnd = sorted(list(M1.groundset()))
for g in gnd:
pcl = [g]
for p in P:
if M.rank([g, p]) == 1:
pcl.extend([p])
pcls.append(pcl)
ext_gnd = list(M.groundset())
for pcl in pcls:
if len(pcl) > 1:
basept = list(ptsdict[pcl[0]])
if len(pcl) <= 2:
# add side by side
ptsdict[pcl[1]] = (basept[0], basept[1]-0.13)
G += points(zip([basept[0]], [basept[1]-0.13]),
color=Color('#BDBDBD'), size=300, zorder=2)
G += text(pcl[0], (float(basept[0]),
float(basept[1])), color='black',
fontsize=13)
G += text(pcl[1], (float(basept[0]),
float(basept[1])-0.13), color='black',
fontsize=13)
limits = tracklims(limits, [basept[0]], [basept[1]-0.13])
else:
# add in a bracket
pce = sorted([str(kk) for kk in pcl])
l = newlabel(set(ext_gnd))
ext_gnd.append(l)
G += text(l+'={ '+", ".join(pce)+' }', (float(basept[0]),
float(basept[1]-0.2)-0.034), color='black',
fontsize=13)
G += text(l, (float(basept[0]),
float(basept[1])), color='black',
fontsize=13)
limits = tracklims(limits, [basept[0]],
[(basept[1]-0.2)-0.034])
return G, limits
def geomrep(M1, B1=None, lineorders1=None, pd=None, sp=False):
"""
Return a sage graphics object containing geometric representation of
matroid M1.
INPUT:
- ``M1`` -- A matroid.
- ``B1`` -- (optional) A list of elements in ``M1.groundset()`` that
correspond to a basis of ``M1`` and will be placed as vertices of the
triangle in the geometric representation of ``M1``.
- ``lineorders1`` -- (optional) A list of ordered lists of elements of
``M1.grondset()`` such that if a line in geometric representation is
setwise same as any of these then points contained will be traversed in
that order thus overriding internal order deciding heuristic.
- ``pd`` - (optional) A dictionary mapping ground set elements to their
(x,y) positions.
- ``sp`` -- (optional) If True, a positioning dictionary and line orders
will be placed in ``M._cached_info``.
OUTPUT:
A sage graphics object of type <class 'sage.plot.graphics.Graphics'> that
corresponds to the geometric representation of the matroid.
EXAMPLES::
sage: from sage.matroids import matroids_plot_helpers
sage: M=matroids.named_matroids.P7()
sage: G=matroids_plot_helpers.geomrep(M)
sage: G.show(xmin=-2, xmax=3, ymin=-2, ymax=3)
sage: M=matroids.named_matroids.P7()
sage: G=matroids_plot_helpers.geomrep(M,lineorders1=[['f','e','d']])
sage: G.show(xmin=-2, xmax=3, ymin=-2, ymax=3)
.. NOTE::
This method does NOT do any checks.
"""
G = Graphics()
# create lists of loops and parallel elements and simplify given matroid
[M, L, P] = slp(M1, pos_dict=pd, B=B1)
if B1 is None:
B1 = list(M.basis())
M._cached_info = M1._cached_info
if M.rank() == 0:
limits = None
loops = L
looptext = ", ".join([str(l) for l in loops])
rectx = -1
recty = -1
rectw = 0.5 + 0.4 * len(loops) + 0.5 # controlled based on len(loops)
recth = 0.6
G += polygon2d(
[[rectx, recty], [rectx, recty + recth],
[rectx + rectw, recty + recth], [rectx + rectw, recty]],
color='black',
fill=False,
thickness=4)
G += text(looptext, (rectx + 0.5, recty + 0.3),
color='black',
fontsize=13)
G += point((rectx + 0.2, recty + 0.3),
color=Color('#BDBDBD'),
size=300,
zorder=2)
G += text('Loop(s)',
(rectx + 0.5 + 0.4 * len(loops) + 0.1, recty + 0.3),
fontsize=13,
color='black')
limits = tracklims(limits, [rectx, rectx + rectw],
[recty, recty + recth])
G.axes(False)
G.axes_range(xmin=limits[0] - 0.5,
xmax=limits[1] + 0.5,
ymin=limits[2] - 0.5,
ymax=limits[3] + 0.5)
return G
elif M.rank() == 1:
if M._cached_info is not None and \
'plot_positions' in M._cached_info.keys() and \
M._cached_info['plot_positions'] is not None:
pts = M._cached_info['plot_positions']
else:
pts = {}
gnd = sorted(M.groundset())
pts[gnd[0]] = (1, float(2) / 3)
G += point((1, float(2) / 3),
size=300,
color=Color('#BDBDBD'),
zorder=2)
pt = [1, float(2) / 3]
if len(P) == 0:
G += text(gnd[0], (float(pt[0]), float(pt[1])),
color='black',
fontsize=13)
pts2 = pts
# track limits [xmin,xmax,ymin,ymax]
pl = [list(x) for x in pts2.values()]
lims = tracklims([None, None, None, None], [pt[0] for pt in pl],
[pt[1] for pt in pl])
elif M.rank() == 2:
nB1 = list(set(list(M.groundset())) - set(B1))
bline = []
for j in nB1:
if M.is_dependent([j, B1[0], B1[1]]):
bline.append(j)
interval = len(bline) + 1
if M._cached_info is not None and \
'plot_positions' in M._cached_info.keys() and \
M._cached_info['plot_positions'] is not None:
pts2 = M._cached_info['plot_positions']
else:
pts2 = {}
pts2[B1[0]] = (0, 0)
pts2[B1[1]] = (2, 0)
lpt = list(pts2[B1[0]])
rpt = list(pts2[B1[1]])
for k in range(len(bline)):
cc = (float(1) / interval) * (k + 1)
pts2[bline[k]] = (cc * lpt[0] + (1 - cc) * rpt[0],
cc * lpt[1] + (1 - cc) * rpt[1])
if sp is True:
M._cached_info['plot_positions'] = pts2
# track limits [xmin,xmax,ymin,ymax]
pl = [list(x) for x in pts2.values()]
lims = tracklims([None, None, None, None], [pt[0] for pt in pl],
[pt[1] for pt in pl])
bline.extend(B1)
ptsx, ptsy, x_i, y_i = createline(pts2, bline, lineorders1)
lims = tracklims(lims, x_i, y_i)
G += line(zip(x_i, y_i), color='black', thickness=3, zorder=1)
pels = [
p for p in pts2.keys() if any([M1.rank([p, q]) == 1 for q in P])
]
allpts = [list(pts2[i]) for i in M.groundset()]
xpts = [float(k[0]) for k in allpts]
ypts = [float(k[1]) for k in allpts]
G += points(zip(xpts, ypts),
color=Color('#BDBDBD'),
size=300,
zorder=2)
for i in pts2:
if i not in pels:
pt = list(pts2[i])
G += text(i, (float(pt[0]), float(pt[1])),
color='black',
fontsize=13)
else:
if M._cached_info is None or \
'plot_positions' not in M._cached_info.keys() or \
M._cached_info['plot_positions'] is None:
(pts, trilines, nontripts,
curvedlines) = it(M1, B1, list(set(M.groundset()) - set(B1)),
list(set(L) | set(P)))
pts2 = addnontripts([B1[0], B1[1], B1[2]], nontripts, pts)
trilines.extend(curvedlines)
else:
pts2 = M._cached_info['plot_positions']
trilines = [
list(set(list(x)).difference(L | P)) for x in M1.flats(2)
if len(list(x)) >= 3
]
pl = [list(x) for x in pts2.values()]
lims = tracklims([None, None, None, None], [pt[0] for pt in pl],
[pt[1] for pt in pl])
j = 0
for ll in trilines:
if len(ll) >= 3:
ptsx, ptsy, x_i, y_i = createline(pts2, ll, lineorders1)
lims = tracklims(lims, x_i, y_i)
G += line(zip(x_i, y_i), color='black', thickness=3, zorder=1)
pels = [
p for p in pts2.keys() if any([M1.rank([p, q]) == 1 for q in P])
]
allpts = [list(pts2[i]) for i in M.groundset()]
xpts = [float(k[0]) for k in allpts]
ypts = [float(k[1]) for k in allpts]
G += points(zip(xpts, ypts),
color=Color('#BDBDBD'),
size=300,
zorder=2)
for i in pts2:
if i not in pels:
pt = list(pts2[i])
G += text(i, (float(pt[0]), float(pt[1])),
color='black',
fontsize=13)
if sp is True:
M1._cached_info['plot_positions'] = pts2
M1._cached_info['plot_lineorders'] = lineorders1
# deal with loops and parallel elements
G, lims = addlp(M1, M, L, P, pts2, G, lims)
G.axes(False)
G.axes_range(xmin=lims[0] - 0.5,
xmax=lims[1] + 0.5,
ymin=lims[2] - 0.5,
ymax=lims[3] + 0.5)
return G
def addlp(M, M1, L, P, ptsdict, G=None, limits=None):
"""
Return a graphics object containing loops (in inset) and parallel elements
of matroid.
INPUT:
- ``M`` -- A matroid.
- ``M1`` -- A simple matroid corresponding to ``M``.
- ``L`` -- List of elements in ``M.groundset()`` that are loops of matroid
``M``.
- ``P`` -- List of elements in ``M.groundset()`` not in
``M.simplify.groundset()`` or ``L``.
- ``ptsdict`` -- A dictionary containing elements in ``M.groundset()`` not
necessarily containing elements of ``L``.
- ``G`` -- (optional) A sage graphics object to which loops and parallel
elements of matroid `M` added .
- ``limits``-- (optional) Current axes limits [xmin,xmax,ymin,ymax].
OUTPUT:
A 2-tuple containing:
1. A sage graphics object containing loops and parallel elements of
matroid ``M``
2. axes limits array
EXAMPLES::
sage: from sage.matroids import matroids_plot_helpers
sage: M=Matroid(ring=GF(2), matrix=[[1, 0, 0, 0, 1, 1, 1,0,1],
....: [0, 1, 0, 1, 0, 1, 1,0,0],[0, 0, 1, 1, 1, 0, 1,0,0]])
sage: [M1,L,P]=matroids_plot_helpers.slp(M)
sage: G,lims=matroids_plot_helpers.addlp(M,M1,L,P,{0:(0,0)})
sage: G.show(axes=False)
.. NOTE::
This method does NOT do any checks.
"""
if G is None:
G = Graphics()
# deal with loops
if len(L) > 0:
loops = L
looptext = ", ".join([str(l) for l in loops])
if (limits is None):
rectx = -1
recty = -1
else:
rectx = limits[0]
recty = limits[2] - 1
rectw = 0.5 + 0.4 * len(loops) + 0.5 # controlled based on len(loops)
recth = 0.6
G += polygon2d(
[[rectx, recty], [rectx, recty + recth],
[rectx + rectw, recty + recth], [rectx + rectw, recty]],
color='black',
fill=False,
thickness=4)
G += text(looptext, (rectx + 0.5, recty + 0.3),
color='black',
fontsize=13)
G += point((rectx + 0.2, recty + 0.3),
color=Color('#BDBDBD'),
size=300,
zorder=2)
G += text('Loop(s)',
(rectx + 0.5 + 0.4 * len(loops) + 0.1, recty + 0.3),
fontsize=13,
color='black')
limits = tracklims(limits, [rectx, rectx + rectw],
[recty, recty + recth])
# deal with parallel elements
if len(P) > 0:
# create list of lists where inner lists are parallel classes
pcls = []
gnd = sorted(list(M1.groundset()))
for g in gnd:
pcl = [g]
for p in P:
if M.rank([g, p]) == 1:
pcl.extend([p])
pcls.append(pcl)
ext_gnd = list(M.groundset())
for pcl in pcls:
if len(pcl) > 1:
basept = list(ptsdict[pcl[0]])
if len(pcl) <= 2:
# add side by side
ptsdict[pcl[1]] = (basept[0], basept[1] - 0.13)
G += points(zip([basept[0]], [basept[1] - 0.13]),
color=Color('#BDBDBD'),
size=300,
zorder=2)
G += text(pcl[0], (float(basept[0]), float(basept[1])),
color='black',
fontsize=13)
G += text(pcl[1],
(float(basept[0]), float(basept[1]) - 0.13),
color='black',
fontsize=13)
limits = tracklims(limits, [basept[0]], [basept[1] - 0.13])
else:
# add in a bracket
pce = sorted([str(kk) for kk in pcl])
l = newlabel(set(ext_gnd))
ext_gnd.append(l)
G += text(
l + '={ ' + ", ".join(pce) + ' }',
(float(basept[0]), float(basept[1] - 0.2) - 0.034),
color='black',
fontsize=13)
G += text(l, (float(basept[0]), float(basept[1])),
color='black',
fontsize=13)
limits = tracklims(limits, [basept[0]],
[(basept[1] - 0.2) - 0.034])
return G, limits
