# Substitutions over unit cube faces (Rauzy fractals)¶

This module implements the $$E_1^*(\sigma)$$ substitution associated with a one-dimensional substitution $$\sigma$$, that acts on unit faces of dimension $$(d-1)$$ in $$\RR^d$$.

This module defines the following classes and functions:

• Face - a class to model a face
• Patch - a class to model a finite set of faces
• E1Star - a class to model the $$E_1^*(\sigma)$$ application defined by the substitution sigma

The convention for the choice of the unit faces and the definition of $$E_1^*(\sigma)$$ varies from article to article. Here, unit faces are defined by

$\begin{split}\begin{array}{ccc} \,[x, 1]^* & = & \{x + \lambda e_2 + \mu e_3 : \lambda, \mu \in [0,1]\} \\ \,[x, 2]^* & = & \{x + \lambda e_1 + \mu e_3 : \lambda, \mu \in [0,1]\} \\ \,[x, 3]^* & = & \{x + \lambda e_1 + \mu e_2 : \lambda, \mu \in [0,1]\} \end{array}\end{split}$

and the dual substitution $$E_1^*(\sigma)$$ is defined by

$E_1^*(\sigma)([x,i]^*) = \bigcup_{k = 1,2,3} \; \bigcup_{s | \sigma(k) = pis} [M^{-1}(x + \ell(s)), k]^*,$

where $$\ell(s)$$ is the abelianized of $$s$$, and $$M$$ is the matrix of $$\sigma$$.

AUTHORS:

• Franco Saliola (2009): initial version
• Vincent Delecroix, Timo Jolivet, Stepan Starosta, Sebastien Labbe (2010-05): redesign
• Timo Jolivet (2010-08, 2010-09, 2011): redesign

REFERENCES:

 [AI] P. Arnoux, S. Ito, Pisot substitutions and Rauzy fractals, Bull. Belg. Math. Soc. 8 (2), 2001, pp. 181–207
 [SAI] Y. Sano, P. Arnoux, S. Ito, Higher dimensional extensions of substitutions and their dual maps, J. Anal. Math. 83, 2001, pp. 183–206

EXAMPLES:

We start by drawing a simple three-face patch:

sage: from sage.combinat.e_one_star import E1Star, Face, Patch
sage: x = [Face((0,0,0),1), Face((0,0,0),2), Face((0,0,0),3)]
sage: P = Patch(x)
sage: P
Patch: [[(0, 0, 0), 1]*, [(0, 0, 0), 2]*, [(0, 0, 0), 3]*]
sage: P.plot()                   #not tested


We apply a substitution to this patch, and draw the result:

sage: sigma = WordMorphism({1:[1,2], 2:[1,3], 3:[1]})
sage: E = E1Star(sigma)
sage: E(P)
Patch: [[(0, 0, 0), 1]*, [(0, 0, 0), 2]*, [(0, 0, 0), 3]*, [(0, 1, -1), 2]*, [(1, 0, -1), 1]*]
sage: E(P).plot()                #not tested


Note

• The type of a face is given by an integer in [1, ..., d] where d is the length of the vector of the face.
• The alphabet of the domain and the codomain of $$\sigma$$ must be equal, and they must be of the form [1, ..., d], where d is a positive integer corresponding to the length of the vectors of the faces on which $$E_1^*(\sigma)$$ will act.
sage: P = Patch([Face((0,0,0),1), Face((0,0,0),2), Face((0,0,0),3)])
sage: sigma = WordMorphism({1:[1,2], 2:[1,3], 3:[1]})
sage: E = E1Star(sigma)
sage: E(P)
Patch: [[(0, 0, 0), 1]*, [(0, 0, 0), 2]*, [(0, 0, 0), 3]*, [(0, 1, -1), 2]*, [(1, 0, -1), 1]*]


The application of an E1Star substitution assigns to each new face the color of its preimage. The repaint method allows us to repaint the faces of a patch. A single color can also be assigned to every face, by specifying a list of a single color:

sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: P = E(P, 5)
sage: P.repaint(['green'])
sage: P.plot()                   #not tested


A list of colors allows us to color the faces sequentially:

sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: P = E(P)
sage: P.repaint(['red', 'yellow', 'green', 'blue', 'black'])
sage: P = E(P, 3)
sage: P.plot()                   #not tested


All the color schemes from matplotlib.cm.datad.keys() can be used:

sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: P.repaint(cmap='summer')
sage: P = E(P, 3)
sage: P.plot()                   #not tested
sage: P.repaint(cmap='hsv')
sage: P = E(P, 2)
sage: P.plot()                   #not tested


It is also possible to specify a dictionary to color the faces according to their type:

sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: P = E(P, 5)
sage: P.repaint({1:(0.7, 0.7, 0.7), 2:(0.5,0.5,0.5), 3:(0.3,0.3,0.3)})
sage: P.plot()                   #not tested
sage: P.repaint({1:'red', 2:'yellow', 3:'green'})
sage: P.plot()                   #not tested


Let us look at a nice big patch in 3D:

sage: sigma = WordMorphism({1:[1,2], 2:[3], 3:[1]})
sage: E = E1Star(sigma)
sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: P = P + P.translate([-1,1,0])
sage: P = E(P, 11)
sage: P.plot3d()                 #not tested


Plotting with TikZ pictures is possible:

sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: s = P.plot_tikz()
sage: print s                    #not tested
\begin{tikzpicture}
[x={(-0.216506cm,-0.125000cm)}, y={(0.216506cm,-0.125000cm)}, z={(0.000000cm,0.250000cm)}]
\definecolor{facecolor}{rgb}{0.000,1.000,0.000}
\fill[fill=facecolor, draw=black, shift={(0,0,0)}]
(0, 0, 0) -- (0, 0, 1) -- (1, 0, 1) -- (1, 0, 0) -- cycle;
\definecolor{facecolor}{rgb}{1.000,0.000,0.000}
\fill[fill=facecolor, draw=black, shift={(0,0,0)}]
(0, 0, 0) -- (0, 1, 0) -- (0, 1, 1) -- (0, 0, 1) -- cycle;
\definecolor{facecolor}{rgb}{0.000,0.000,1.000}
\fill[fill=facecolor, draw=black, shift={(0,0,0)}]
(0, 0, 0) -- (1, 0, 0) -- (1, 1, 0) -- (0, 1, 0) -- cycle;
\end{tikzpicture}


sage: P = Patch([Face([0,0], 1), Face([0,0], 2)])
sage: E = E1Star(WordMorphism({1:[1,2],2:[1]}))
sage: F = E1Star(WordMorphism({1:[1,1,2],2:[2,1]}))
sage: E(P,5).plot()
sage: F(P,3).plot()


Everything works in any dimension (except for the plotting features which only work in dimension two or three):

sage: P = Patch([Face((0,0,0,0),1), Face((0,0,0,0),4)])
sage: sigma = WordMorphism({1:[1,2], 2:[1,3], 3:[1,4], 4:[1]})
sage: E = E1Star(sigma)
sage: E(P)
Patch: [[(0, 0, 0, 0), 3]*, [(0, 0, 0, 0), 4]*, [(0, 0, 1, -1), 3]*, [(0, 1, 0, -1), 2]*, [(1, 0, 0, -1), 1]*]

sage: sigma = WordMorphism({1:[1,2],2:[1,3],3:[1,4],4:[1,5],5:[1,6],6:[1,7],7:[1,8],8:[1,9],9:[1,10],10:[1,11],11:[1,12],12:[1]})
sage: E = E1Star(sigma)
sage: E
E_1^*(1->12, 10->1,11, 11->1,12, 12->1, 2->13, 3->14, 4->15, 5->16, 6->17, 7->18, 8->19, 9->1,10)
sage: P = Patch([Face((0,0,0,0,0,0,0,0,0,0,0,0),t) for t in [1,2,3]])
sage: for x in sorted(list(E(P)), key=lambda x : (x.vector(),x.type())): print x
[(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 1]*
[(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 2]*
[(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 12]*
[(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -1), 11]*
[(0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, -1), 10]*
[(0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, -1), 9]*
[(0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, -1), 8]*
[(0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1), 7]*
[(0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, -1), 6]*
[(0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, -1), 5]*
[(0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, -1), 4]*
[(0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, -1), 3]*
[(0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1), 2]*
[(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1), 1]*

class sage.combinat.e_one_star.E1Star(sigma, method='suffix')

A class to model the $$E_1^*(\sigma)$$ map associated with a unimodular substitution $$\sigma$$.

INPUT:

• sigma - unimodular WordMorphism, i.e. such that its incidence matrix has determinant $$\pm 1$$.
• method - ‘prefix’ or ‘suffix’ (optional, default: ‘suffix’) Enables to use an alternative definition $$E_1^*(\sigma)$$ substitutions, where the abelianized of the prefix is used instead of the suffix.

Note

The alphabet of the domain and the codomain of $$\sigma$$ must be equal, and they must be of the form [1, ..., d], where d is a positive integer corresponding to the length of the vectors of the faces on which $$E_1^*(\sigma)$$ will act.

EXAMPLES:

sage: from sage.combinat.e_one_star import E1Star, Face, Patch
sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: sigma = WordMorphism({1:[1,2], 2:[1,3], 3:[1]})
sage: E = E1Star(sigma)
sage: E(P)
Patch: [[(0, 0, 0), 1]*, [(0, 0, 0), 2]*, [(0, 0, 0), 3]*, [(0, 1, -1), 2]*, [(1, 0, -1), 1]*]

sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: sigma = WordMorphism({1:[1,2], 2:[1,3], 3:[1]})
sage: E = E1Star(sigma, method='prefix')
sage: E(P)
Patch: [[(0, 0, 0), 1]*, [(0, 0, 0), 2]*, [(0, 0, 0), 3]*, [(0, 0, 1), 1]*, [(0, 0, 1), 2]*]

sage: x = [Face((0,0,0,0),1), Face((0,0,0,0),4)]
sage: P = Patch(x)
sage: sigma = WordMorphism({1:[1,2], 2:[1,3], 3:[1,4], 4:[1]})
sage: E = E1Star(sigma)
sage: E(P)
Patch: [[(0, 0, 0, 0), 3]*, [(0, 0, 0, 0), 4]*, [(0, 0, 1, -1), 3]*, [(0, 1, 0, -1), 2]*, [(1, 0, 0, -1), 1]*]

inverse_matrix()

Returns the inverse of the matrix associated with self.

EXAMPLES:

sage: from sage.combinat.e_one_star import E1Star, Face, Patch
sage: sigma = WordMorphism({1:[1,2], 2:[1,3], 3:[1]})
sage: E = E1Star(sigma)
sage: E.inverse_matrix()
[ 0  1  0]
[ 0  0  1]
[ 1 -1 -1]

matrix()

Returns the matrix associated with self.

EXAMPLES:

sage: from sage.combinat.e_one_star import E1Star, Face, Patch
sage: sigma = WordMorphism({1:[1,2], 2:[1,3], 3:[1]})
sage: E = E1Star(sigma)
sage: E.matrix()
[1 1 1]
[1 0 0]
[0 1 0]

sigma()

Returns the WordMorphism associated with self.

EXAMPLES:

sage: from sage.combinat.e_one_star import E1Star, Face, Patch
sage: sigma = WordMorphism({1:[1,2], 2:[1,3], 3:[1]})
sage: E = E1Star(sigma)
sage: E.sigma()
WordMorphism: 1->12, 2->13, 3->1

class sage.combinat.e_one_star.Face(v, t, color=None)

A class to model a unit face of arbitrary dimension.

A unit face in dimension $$d$$ is represented by a $$d$$-dimensional vector v and a type t in $$\{1, \ldots, d\}$$. The type of the face corresponds to the canonical unit vector to which the face is orthogonal. The optional color argument is used in plotting functions.

INPUT:

• v - tuple of integers
• t - integer in [1, ..., len(v)], type of the face. The face of type $$i$$ is orthogonal to the canonical vector $$e_i$$.
• color - color (optional, default: None) color of the face, used for plotting only. If None, its value is guessed from the face type.

EXAMPLES:

sage: from sage.combinat.e_one_star import Face
sage: f = Face((0,2,0), 3)
sage: f.vector()
(0, 2, 0)
sage: f.type()
3

sage: f = Face((0,2,0), 3, color=(0.5, 0.5, 0.5))
sage: f.color()
RGB color (0.5, 0.5, 0.5)

color(color=None)

Returns or change the color of the face.

INPUT:

• color - string, rgb tuple, color (optional, default: None) the new color to assign to the face. If None, it returns the color of the face.

OUTPUT:

color

EXAMPLES:

sage: from sage.combinat.e_one_star import Face
sage: f = Face((0,2,0), 3)
sage: f.color()
RGB color (0.0, 0.0, 1.0)
sage: f.color('red')
sage: f.color()
RGB color (1.0, 0.0, 0.0)

type()

Returns the type of the face.

EXAMPLES:

sage: from sage.combinat.e_one_star import Face
sage: f = Face((0,2,0), 3)
sage: f.type()
3

sage: f = Face((0,2,0), 3)
sage: f.type()
3

vector()

Return the vector of the face.

EXAMPLES:

sage: from sage.combinat.e_one_star import Face
sage: f = Face((0,2,0), 3)
sage: f.vector()
(0, 2, 0)

class sage.combinat.e_one_star.Patch(faces, face_contour=None)

A class to model a collection of faces. A patch is represented by an immutable set of Faces.

Note

The dimension of a patch is the length of the vectors of the faces in the patch, which is assumed to be the same for every face in the patch.

Note

Since version 4.7.1, Patches are immutable, except for the colors of the faces, which are not taken into account for equality tests and hash functions.

INPUT:

• faces - finite iterable of faces
• face_contour - dict (optional, default:None) maps the face type to vectors describing the contour of unit faces. If None, defaults contour are assumed for faces of type 1, 2, 3 or 1, 2, 3. Used in plotting methods only.

EXAMPLES:

sage: from sage.combinat.e_one_star import Face, Patch
sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: P
Patch: [[(0, 0, 0), 1]*, [(0, 0, 0), 2]*, [(0, 0, 0), 3]*]

sage: face_contour = {}
sage: face_contour[1] = map(vector, [(0,0,0),(0,1,0),(0,1,1),(0,0,1)])
sage: face_contour[2] = map(vector, [(0,0,0),(0,0,1),(1,0,1),(1,0,0)])
sage: face_contour[3] = map(vector, [(0,0,0),(1,0,0),(1,1,0),(0,1,0)])
sage: Patch([Face((0,0,0),t) for t in [1,2,3]], face_contour=face_contour)
Patch: [[(0, 0, 0), 1]*, [(0, 0, 0), 2]*, [(0, 0, 0), 3]*]

difference(other)

Returns the difference of self and other.

INPUT:

• other - a finite iterable of faces or a single face

EXAMPLES:

sage: from sage.combinat.e_one_star import Face, Patch
sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: P.difference(Face([0,0,0],2))
Patch: [[(0, 0, 0), 1]*, [(0, 0, 0), 3]*]
sage: P.difference(P)
Patch: []

dimension()

Returns the dimension of the vectors of the faces of self

It returns None if self is the empty patch.

The dimension of a patch is the length of the vectors of the faces in the patch, which is assumed to be the same for every face in the patch.

EXAMPLES:

sage: from sage.combinat.e_one_star import Face, Patch
sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: P.dimension()
3


TESTS:

sage: from sage.combinat.e_one_star import Patch
sage: p = Patch([])
sage: p.dimension() is None
True


It works when the patch is created from an iterator:

sage: p = Patch(Face((0,0,0),t) for t in [1,2,3])
sage: p.dimension()
3

faces_of_color(color)

Returns a list of the faces that have the given color.

INPUT:

• color - color

EXAMPLES:

sage: from sage.combinat.e_one_star import Face, Patch
sage: P = Patch([Face((0,0,0),1, 'red'), Face((1,2,0),3, 'blue'), Face((1,2,0),1, 'red')])
sage: P.faces_of_color('red')
[[(0, 0, 0), 1]*, [(1, 2, 0), 1]*]

faces_of_type(t)

Returns a list of the faces that have type t.

INPUT:

• t - integer or any other type

EXAMPLES:

sage: from sage.combinat.e_one_star import Face, Patch
sage: P = Patch([Face((0,0,0),1), Face((1,2,0),3), Face((1,2,0),1)])
sage: P.faces_of_type(1)
[[(0, 0, 0), 1]*, [(1, 2, 0), 1]*]

faces_of_vector(v)

Returns a list of the faces whose vector is v.

INPUT:

• v - a vector

EXAMPLES:

sage: from sage.combinat.e_one_star import Face, Patch
sage: P = Patch([Face((0,0,0),1), Face((1,2,0),3), Face((1,2,0),1)])
sage: P.faces_of_vector([1,2,0])
[[(1, 2, 0), 3]*, [(1, 2, 0), 1]*]

occurrences_of(other)

Returns all positions at which other appears in self, that is, all vectors v such that set(other.translate(v)) <= set(self).

INPUT:

• other - a Patch

OUTPUT:

a list of vectors

EXAMPLES:

sage: from sage.combinat.e_one_star import Face, Patch, E1Star
sage: P = Patch([Face([0,0,0], 1), Face([0,0,0], 2), Face([0,0,0], 3)])
sage: Q = Patch([Face([0,0,0], 1), Face([0,0,0], 2)])
sage: P.occurrences_of(Q)
[(0, 0, 0)]
sage: Q = Q.translate([1,2,3])
sage: P.occurrences_of(Q)
[(-1, -2, -3)]

sage: E = E1Star(WordMorphism({1:[1,2], 2:[1,3], 3:[1]}))
sage: P = Patch([Face([0,0,0], 1), Face([0,0,0], 2), Face([0,0,0], 3)])
sage: P = E(P,4)
sage: Q = Patch([Face([0,0,0], 1), Face([0,0,0], 2)])
sage: L = P.occurrences_of(Q)
sage: sorted(L)
[(0, 0, 0), (0, 0, 1), (0, 1, -1), (1, 0, -1), (1, 1, -3), (1, 1, -2)]

plot(projmat=None, opacity=0.75)

Returns a 2D graphic object depicting the patch.

INPUT:

• projmat - matrix (optional, default: None) the projection matrix. Its number of lines must be two. Its number of columns must equal the dimension of the ambient space of the faces. If None, the isometric projection is used by default.
• opacity - float between 0 and 1 (optional, default: 0.75) opacity of the the face

Warning

Plotting is implemented only for patches in two or three dimensions.

EXAMPLES:

sage: from sage.combinat.e_one_star import E1Star, Face, Patch
sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: P.plot()

sage: sigma = WordMorphism({1:[1,2], 2:[1,3], 3:[1]})
sage: E = E1Star(sigma)
sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: P = E(P, 5)
sage: P.plot()


Plot with a different projection matrix:

sage: sigma = WordMorphism({1:[1,2], 2:[1,3], 3:[1]})
sage: E = E1Star(sigma)
sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: M = matrix(2, 3, [1,0,-1,0.3,1,-3])
sage: P = E(P, 3)
sage: P.plot(projmat=M)


Plot patches made of unit segments:

sage: P = Patch([Face([0,0], 1), Face([0,0], 2)])
sage: E = E1Star(WordMorphism({1:[1,2],2:[1]}))
sage: F = E1Star(WordMorphism({1:[1,1,2],2:[2,1]}))
sage: E(P,5).plot()
sage: F(P,3).plot()

plot3d()

Returns a 3D graphics object depicting the patch.

Warning

3D plotting is implemented only for patches in three dimensions.

EXAMPLES:

sage: from sage.combinat.e_one_star import E1Star, Face, Patch
sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: P.plot3d()                #not tested

sage: sigma = WordMorphism({1:[1,2], 2:[1,3], 3:[1]})
sage: E = E1Star(sigma)
sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: P = E(P, 5)
sage: P.repaint()
sage: P.plot3d()                #not tested

plot_tikz(projmat=None, print_tikz_env=True, edgecolor='black', scale=0.25, drawzero=False, extra_code_before='', extra_code_after='')

Returns a string containing some TikZ code to be included into a LaTeX document, depicting the patch.

Warning

Tikz Plotting is implemented only for patches in three dimensions.

INPUT:

• projmat - matrix (optional, default: None) the projection matrix. Its number of lines must be two. Its number of columns must equal the dimension of the ambient space of the faces. If None, the isometric projection is used by default.
• print_tikz_env - bool (optional, default: True) if True, the tikzpicture environment are printed
• edgecolor - string (optional, default: 'black') either 'black' or 'facecolor' (color of unit face edges)
• scale - real number (optional, default: 0.25) scaling constant for the whole figure
• drawzero - bool (optional, default: False) if True, mark the origin by a black dot
• extra_code_before - string (optional, default: '') extra code to include in the tikz picture
• extra_code_after - string (optional, default: '') extra code to include in the tikz picture

EXAMPLES:

sage: from sage.combinat.e_one_star import E1Star, Face, Patch
sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: s = P.plot_tikz()
sage: len(s)
602
sage: print s       #not tested
\begin{tikzpicture}
[x={(-0.216506cm,-0.125000cm)}, y={(0.216506cm,-0.125000cm)}, z={(0.000000cm,0.250000cm)}]
\definecolor{facecolor}{rgb}{0.000,1.000,0.000}
\fill[fill=facecolor, draw=black, shift={(0,0,0)}]
(0, 0, 0) -- (0, 0, 1) -- (1, 0, 1) -- (1, 0, 0) -- cycle;
\definecolor{facecolor}{rgb}{1.000,0.000,0.000}
\fill[fill=facecolor, draw=black, shift={(0,0,0)}]
(0, 0, 0) -- (0, 1, 0) -- (0, 1, 1) -- (0, 0, 1) -- cycle;
\definecolor{facecolor}{rgb}{0.000,0.000,1.000}
\fill[fill=facecolor, draw=black, shift={(0,0,0)}]
(0, 0, 0) -- (1, 0, 0) -- (1, 1, 0) -- (0, 1, 0) -- cycle;
\end{tikzpicture}

sage: sigma = WordMorphism({1:[1,2], 2:[1,3], 3:[1]})
sage: E = E1Star(sigma)
sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: P = E(P, 4)
sage: from sage.misc.latex import latex             #not tested
sage: view(P, tightpage=true)                       #not tested


Plot using shades of gray (useful for article figures):

sage: sigma = WordMorphism({1:[1,2], 2:[1,3], 3:[1]})
sage: E = E1Star(sigma)
sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: P.repaint([(0.9, 0.9, 0.9), (0.65,0.65,0.65), (0.4,0.4,0.4)])
sage: P = E(P, 4)
sage: s = P.plot_tikz()


Plotting with various options:

sage: sigma = WordMorphism({1:[1,2], 2:[1,3], 3:[1]})
sage: E = E1Star(sigma)
sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: M = matrix(2, 3, map(float, [1,0,-0.7071,0,1,-0.7071]))
sage: P = E(P, 3)
sage: s = P.plot_tikz(projmat=M, edgecolor='facecolor', scale=0.6, drawzero=True)


Adding X, Y, Z axes using the extra code feature:

sage: length = 1.5
sage: space = 0.3
sage: axes = ''
sage: axes += "\\draw[->, thick, black] (0,0,0) -- (%s, 0, 0);\n" % length
sage: axes += "\\draw[->, thick, black] (0,0,0) -- (0, %s, 0);\n" % length
sage: axes += "\\node at (%s,0,0) {$x$};\n" % (length + space)
sage: axes += "\\node at (0,%s,0) {$y$};\n" % (length + space)
sage: axes += "\\node at (0,0,%s) {$z$};\n" % (length + space)
sage: axes += "\\draw[->, thick, black] (0,0,0) -- (0, 0, %s);\n" % length
sage: cube = Patch([Face((0,0,0),1), Face((0,0,0),2), Face((0,0,0),3)])
sage: options = dict(scale=0.5,drawzero=True,extra_code_before=axes)
sage: s = cube.plot_tikz(**options)
sage: len(s)
986
sage: print s   #not tested
\begin{tikzpicture}
[x={(-0.433013cm,-0.250000cm)}, y={(0.433013cm,-0.250000cm)}, z={(0.000000cm,0.500000cm)}]
\draw[->, thick, black] (0,0,0) -- (1.50000000000000, 0, 0);
\draw[->, thick, black] (0,0,0) -- (0, 1.50000000000000, 0);
\node at (1.80000000000000,0,0) {$x$};
\node at (0,1.80000000000000,0) {$y$};
\node at (0,0,1.80000000000000) {$z$};
\draw[->, thick, black] (0,0,0) -- (0, 0, 1.50000000000000);
\definecolor{facecolor}{rgb}{0.000,1.000,0.000}
\fill[fill=facecolor, draw=black, shift={(0,0,0)}]
(0, 0, 0) -- (0, 0, 1) -- (1, 0, 1) -- (1, 0, 0) -- cycle;
\definecolor{facecolor}{rgb}{1.000,0.000,0.000}
\fill[fill=facecolor, draw=black, shift={(0,0,0)}]
(0, 0, 0) -- (0, 1, 0) -- (0, 1, 1) -- (0, 0, 1) -- cycle;
\definecolor{facecolor}{rgb}{0.000,0.000,1.000}
\fill[fill=facecolor, draw=black, shift={(0,0,0)}]
(0, 0, 0) -- (1, 0, 0) -- (1, 1, 0) -- (0, 1, 0) -- cycle;
\node[circle,fill=black,draw=black,minimum size=1.5mm,inner sep=0pt] at (0,0,0) {};
\end{tikzpicture}

repaint(cmap='Set1')

Repaints all the faces of self from the given color map.

This only changes the colors of the faces of self.

INPUT:

• cmap - color map (default: 'Set1'). It can be one of the following :
• string - A coloring map. For available coloring map names type: sorted(colormaps)
• list - a list of colors to assign cyclically to the faces. A list of a single color colors all the faces with the same color.
• dict - a dict of face types mapped to colors, to color the faces according to their type.
• {}, the empty dict - shorcut for {1:'red', 2:'green', 3:'blue'}.

EXAMPLES:

Using a color map:

sage: from sage.combinat.e_one_star import Face, Patch
sage: color = (0, 0, 0)
sage: P = Patch([Face((0,0,0),t,color) for t in [1,2,3]])
sage: for f in P: f.color()
RGB color (0.0, 0.0, 0.0)
RGB color (0.0, 0.0, 0.0)
RGB color (0.0, 0.0, 0.0)
sage: P.repaint()
sage: next(iter(P)).color()    #random
RGB color (0.498..., 0.432..., 0.522...)


Using a list of colors:

sage: P = Patch([Face((0,0,0),t,color) for t in [1,2,3]])
sage: P.repaint([(0.9, 0.9, 0.9), (0.65,0.65,0.65), (0.4,0.4,0.4)])
sage: for f in P: f.color()
RGB color (0.9, 0.9, 0.9)
RGB color (0.65, 0.65, 0.65)
RGB color (0.4, 0.4, 0.4)


Using a dictionary to color faces according to their type:

sage: P = Patch([Face((0,0,0),t) for t in [1,2,3]])
sage: P.repaint({1:'black', 2:'yellow', 3:'green'})
sage: P.plot()                   #not tested
sage: P.repaint({})
sage: P.plot()                   #not tested

translate(v)

Returns a translated copy of self by vector v.

INPUT:

• v - vector or tuple

EXAMPLES:

sage: from sage.combinat.e_one_star import Face, Patch
sage: P = Patch([Face((0,0,0),1), Face((1,2,0),3), Face((1,2,0),1)])
sage: P.translate([-1,-2,0])
Patch: [[(-1, -2, 0), 1]*, [(0, 0, 0), 1]*, [(0, 0, 0), 3]*]

union(other)

Returns a Patch consisting of the union of self and other.

INPUT:

• other - a Patch or a Face or a finite iterable of faces

EXAMPLES:

sage: from sage.combinat.e_one_star import Face, Patch
sage: P = Patch([Face((0,0,0),1), Face((0,0,0),2)])
sage: P.union(Face((1,2,3), 3))
Patch: [[(0, 0, 0), 1]*, [(0, 0, 0), 2]*, [(1, 2, 3), 3]*]
sage: P.union([Face((1,2,3), 3), Face((2,3,3), 2)])
Patch: [[(0, 0, 0), 1]*, [(0, 0, 0), 2]*, [(1, 2, 3), 3]*, [(2, 3, 3), 2]*]
`

#### Previous topic

The family of generalized Tamari lattices

#### Next topic

Finite combinatorial classes