def __init__(self, surface, polygon_dictionary=None, glue_dictionary=None, base_label=None, ring=None):
r"""
Warning: No checks are made to make sure the surface is reasonable.
PARAMETERS::
surface: The surface this is based on.
polygon_dictionary: A dictionary mapping labels to polygons which will override whatever was on the original surface.
glue_dictionary: A dictionary mapping edges to edges, which will override whatever was on the original surface. It will automatically be made symmetric.
base_label: A label representing the base_label on the new surface.
ring: A new ring containing the vertices.
"""
self._s=surface
if polygon_dictionary is None:
self._pdict={}
else:
self._pdict=dict(polygon_dictionary)
self._gdict={}
if not glue_dictionary is None:
for edge1,edge2 in glue_dictionary.iteritems():
self._gdict[edge1]=edge2
self._gdict[edge2]=edge1
if base_label is None:
self._base_label = surface.base_label()
else:
self._base_label = base_label
if ring is None:
self._ring = surface.base_ring()
else:
self._ring = ring
self._is_finite = surface.is_finite()
Surface.__init__(self)
def __init__(self, surface, base_label):
r"""
Construct a copy of the provided surface with a new base label.
"""
self._s=surface
self._base_label = base_label
Surface.__init__(self)
def __init__(self, similarity_surface, direction=None, relabel=True):
r"""
Construct a lazy Delaunay triangulation of the provided similarity_surface.
"""
if similarity_surface.underlying_surface().is_mutable():
raise ValueError("Surface must be immutable.")
# This surface will converge to the Delaunay Decomposition
self._s = similarity_surface.copy(relabel=relabel, lazy=True, mutable=True)
self._setup_direction(direction)
# Set of labels corresponding to known delaunay polygons
self._certified_labels=set()
self._decomposition_certified_labels=set()
base_label=self._s.base_label()
# We will now try to get the base_polygon.
# Certify the base polygon (or apply flips...)
while not self._certify_or_improve(base_label):
pass
self._certify_decomposition(base_label)
Surface.__init__(self, self._s.base_ring(), base_label, \
finite=self._s.is_finite(), mutable=False)
def __init__(self, surface, m, ring=None):
if surface.is_mutable():
if surface.is_finite():
self._s=surface.copy()
else:
raise ValueError("Can not apply matrix to mutable infinite surface.")
else:
self._s=surface
det = m.determinant()
if det>0:
self._det_sign=1
elif det<0:
self._det_sign=-1
else:
raise ValueError("Can not apply matrix with zero determinant to surface.")
self._m=m
if ring is None:
if m.base_ring() == self._s.base_ring():
base_ring = self._s.base_ring()
else:
from sage.structure.element import get_coercion_model
cm = get_coercion_model()
base_ring = cm.common_parent(m.base_ring(), self._s.base_ring())
else:
base_ring=ring
self._P=Polygons(base_ring)
Surface.__init__(self, base_ring, self._s.base_label(), finite=self._s.is_finite())
def __init__(self, surface, m, ring=None):
if surface.is_mutable():
if surface.is_finite():
self._s=surface.copy()
else:
raise ValueError("Can not apply matrix to mutable infinite surface.")
else:
self._s=surface
det = m.determinant()
if det>0:
self._det_sign=1
elif det<0:
self._det_sign=-1
else:
raise ValueError("Can not apply matrix with zero determinant to surface.")
self._m=m
if ring is None:
if m.base_ring() == self._s.base_ring():
base_ring = self._s.base_ring()
else:
from sage.structure.element import get_coercion_model
cm = get_coercion_model()
base_ring = cm.common_parent(m.base_ring(), self._s.base_ring())
else:
base_ring=ring
self._P = ConvexPolygons(base_ring)
Surface.__init__(self, base_ring, self._s.base_label(), finite=self._s.is_finite())
def __init__(self, surface, matrix_function, ring=None):
self._s=surface
self._m=matrix_function
if ring is None:
self._base_ring = self._s.base_ring()
else:
self._base_ring=ring
self._P=Polygons(self._base_ring)
Surface.__init__(self)
def __init__(self, surface, matrix_function, ring=None):
self._s = surface
self._m = matrix_function
if ring is None:
self._base_ring = self._s.base_ring()
else:
self._base_ring = ring
self._P = ConvexPolygons(self._base_ring)
Surface.__init__(self)
def __init__(self, s, reindexmapping,new_base_label=None):
r"""
Represents a reindexed similarity surface.
"""
self._s=s
self._r=reindexmapping
if new_base_label is None:
self._base_label=self._r._f[self._s.base_label()]
else:
self._base_label=new_base_label
Surface.__init__(self)
def __init__(self, similarity_surface, relabel=True):
if similarity_surface.is_mutable():
raise ValueError("Surface must be immutable.")
# This surface will converge to the Delaunay Triangulation
self._s = similarity_surface.copy(relabel=relabel, lazy=True, \
mutable=True)
Surface.__init__(self, self._s.base_ring(), self._s.base_label(), \
mutable=False, finite=self._s.is_finite())
def __init__(self, s, reindexmapping, new_base_label=None):
r"""
Represents a reindexed similarity surface.
"""
if not s.is_finite():
raise ValueError("Only works for finite surfaces.")
if s.is_mutable():
raise ValueError("Only works for immutable surfaces.")
self._s=s
self._r=reindexmapping
if new_base_label is None:
new_base_label=self._r._f[self._s.base_label()]
Surface.__init__(self, self._s.base_ring(), new_base_label, finite=True)
def __init__(self, w=ZZ_1, r=ZZ_2, h1=ZZ_1, h2=ZZ_1):
from sage.structure.sequence import Sequence
from sage.combinat.words.words import Words
self._field = Sequence([w,r,h1,h2]).universe()
if not self._field.is_field():
self._field = self._field.fraction_field()
self._w = self._field(w)
self._r = self._field(r)
self._h1 = self._field(h1)
self._h2 = self._field(h2)
self._words = Words('LR', finite=True, infinite=False)
self._wL = self._words('L')
self._wR = self._words('R')
Surface.__init__(self)
def __init__(self, surface, m, ring=None):
self._s=surface
if m.determinant()<=0:
raise ValueError("Currently only works with matrices of positive determinant.""")
self._m=m
if ring is None:
if m.base_ring() == self._s.base_ring():
self._base_ring = self._s.base_ring()
else:
from sage.structure.element import get_coercion_model
cm = get_coercion_model()
self._base_ring = cm.common_parent(m.base_ring(), self._s.base_ring())
else:
self._base_ring=ring
self._P=Polygons(self._base_ring)
Surface.__init__(self)
def __init__(self,lambda_squared=None, field=None):
TranslationSurface_generic.__init__(self)
if lambda_squared==None:
from sage.rings.number_field.number_field import NumberField
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
R=PolynomialRing(ZZ,'x')
x = R.gen()
from sage.rings.qqbar import AA
self._field=NumberField(x**3-ZZ(5)*x**2+ZZ(4)*x-ZZ(1), 'r', embedding=AA(ZZ(4)))
self._l=self._field.gen()
else:
if field is None:
self._l=lambda_squared
self._field=lambda_squared.parent()
else:
self._field=field
self._l=field(lambda_squared)
Surface.__init__(self)
def __init__(self, alpha):
self._p = ChamanaraPolygon(alpha)
self._field = alpha.parent()
self.rename('Chamanara surface with parameter {}'.format(alpha))
Surface.__init__(self)
def __init__(self):
Surface.__init__(self)
