Coverage for local/lib/python2.7/site-packages/sage/matrix/operation

'{\\setlength{\\arraycolsep}{2ex}\n\\begin{array}{r|*{3}{r}}\n\\multicolumn{1}{c|}{\\times}&a&b&c\\\\\\hline\n{}a&a&b&c\\\\\n{}b&b&c&a\\\\\n{}c&c&a&b\\\\\n\\end{array}}'

TESTS::

sage: from sage.matrix.operation_table import OperationTable

sage: G=AlternatingGroup(3)

sage: T=OperationTable(G, operator.mul)

sage: T.set_print_symbols('@', 5)

Traceback (most recent call last):

...

ValueError: LaTeX symbol must be a string, not 5

sage: T.set_print_symbols('@x@', '\\times')

Traceback (most recent call last):

...

ValueError: ASCII symbol should be a single character, not @x@

sage: T.set_print_symbols(5, '\\times')

Traceback (most recent call last):

...

ValueError: ASCII symbol should be a single character, not 5

"""

if not isinstance(ascii, six.string_types) or not len(ascii)==1:

raise ValueError('ASCII symbol should be a single character, not %s' % ascii)

if not isinstance(latex, six.string_types):

raise ValueError('LaTeX symbol must be a string, not %s' % latex)

self._ascii_symbol = ascii

self._latex_symbol = latex

return None

def column_keys(self):

r"""

Returns a tuple of the elements used to build the table.

.. note:: ``column_keys`` and ``row_keys`` are identical.

Both list the elements in the order used to label the table.

OUTPUT:

The elements of the algebraic structure used to build

the table, as a list. But most importantly, elements are

present in the list in the order which they appear in

the table's column headings.

EXAMPLES::

sage: from sage.matrix.operation_table import OperationTable

sage: G=AlternatingGroup(3)

sage: T=OperationTable(G, operator.mul)

sage: T.column_keys()

((), (1,2,3), (1,3,2))

"""

return self._elts

# The ordered list of row and column elements are identical

# given the current design, so these methods are aliases. If

# expanded to allow different orderings (maybe interesting in

# non-commutative cases?), then these will need to be

# implemented separately.

row_keys = column_keys

def translation(self):

r"""

Returns a dictionary associating names with elements.

OUTPUT:

A dictionary whose keys are strings used as names

for entries of the table and values that are the

actual elements of the algebraic structure.

EXAMPLES::

sage: from sage.matrix.operation_table import OperationTable

sage: G=AlternatingGroup(3)

sage: T=OperationTable(G, operator.mul, names=['p','q','r'])

sage: sorted(T.translation().items())

[('p', ()), ('q', (1,2,3)), ('r', (1,3,2))]

"""

return self._name_dict

def table(self):

r"""

Returns the table as a list of lists,

using integers to reference the elements.

OUTPUT:

The rows of the table, as a list of rows, each row

being a list of integer entries. The integers correspond

to the order of the elements in the headings of the table

and the order of the output of the :meth:`list` method.

EXAMPLES::

sage: from sage.matrix.operation_table import OperationTable

sage: C=CyclicPermutationGroup(3)

sage: T=OperationTable(C, operator.mul)

sage: T.table()

[[0, 1, 2], [1, 2, 0], [2, 0, 1]]

"""

return self._table

def change_names(self, names):

r"""

For an existing operation table, change the names used for the elements.

INPUT:

- ``names`` - the type of names used, values are:

* ``'letters'`` - lowercase ASCII letters are used

for a base 26 representation of the elements'

positions in the list given by :meth:`list`,

padded to a common width with leading 'a's.

* ``'digits'`` - base 10 representation of the

elements' positions in the list given by

:meth:`list`, padded to a common width

with leading zeros.

* ``'elements'`` - the string representations

of the elements themselves.

* a list - a list of strings, where the length

of the list equals the number of elements.

OUTPUT:

``None``. This method changes the table "in-place",

so any printed version will change and the output of

the :meth:`dict` will also change. So any items of

interest about a particular table need to be copied/saved

prior to calling this method.

EXAMPLES:

More examples can be found in the documentation for

:class:`OperationTable` since creating a new

operation table uses the same routine. ::

sage: from sage.matrix.operation_table import OperationTable

sage: D=DihedralGroup(2)

sage: T=OperationTable(D, operator.mul)

sage: T

* a b c d

+--------

a| a b c d

b| b a d c

c| c d a b

d| d c b a

sage: T.translation()['c']

(1,2)

sage: T.change_names('digits')

sage: T

* 0 1 2 3

+--------

0| 0 1 2 3

1| 1 0 3 2

2| 2 3 0 1

3| 3 2 1 0

sage: T.translation()['2']

(1,2)

sage: T.change_names('elements')

sage: T

* () (3,4) (1,2) (1,2)(3,4)

+--------------------------------------------

()| () (3,4) (1,2) (1,2)(3,4)

(3,4)| (3,4) () (1,2)(3,4) (1,2)

(1,2)| (1,2) (1,2)(3,4) () (3,4)

(1,2)(3,4)| (1,2)(3,4) (1,2) (3,4) ()

sage: T.translation()['(1,2)']

(1,2)

sage: T.change_names(['w', 'x', 'y', 'z'])

sage: T

* w x y z

+--------

w| w x y z

x| x w z y

y| y z w x

z| z y x w

sage: T.translation()['y']

(1,2)

"""

self._width, self._names, self._name_dict = self._name_maker(names)

return None

def matrix_of_variables(self):

r"""

This method provides some backward compatibility for

Cayley tables of groups, whose output was

restricted to this single format.

EXAMPLES:

The output here is from the doctests for the old

``cayley_table()`` method for permutation groups. ::

sage: from sage.matrix.operation_table import OperationTable

sage: G=PermutationGroup(['(1,2,3)', '(2,3)'])

sage: T=OperationTable(G, operator.mul)

sage: T.matrix_of_variables()

[x0 x1 x2 x3 x4 x5]

[x1 x0 x3 x2 x5 x4]

[x2 x5 x4 x1 x0 x3]

[x3 x4 x5 x0 x1 x2]

[x4 x3 x0 x5 x2 x1]

[x5 x2 x1 x4 x3 x0]

sage: T.column_keys()[3]*T.column_keys()[3] == T.column_keys()[0]

True

"""

from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing

from sage.matrix.matrix_space import MatrixSpace

from sage.rings.rational_field import QQ

R = PolynomialRing(QQ, 'x', self._n)

MS = MatrixSpace(R, self._n, self._n)

entries = [R('x'+str(self._table[i][j])) for i in range(self._n) for j in range(self._n)]

return MS( entries )

#def color_table():

#r"""

#Returns a graphic image as a square grid where entries are color coded.

#"""

#pass

#return None

#def gray_table():

#r"""

#Returns a graphic image as a square grid where entries are coded as grayscale values.

#"""

#pass

#return None

def _ascii_table(self):

r"""

Returns a string that is an ASCII version of the table.

EXAMPLES::

sage: from sage.matrix.operation_table import OperationTable

sage: R=Integers(5)

sage: T=OperationTable(R, operator.add)

sage: print(T._ascii_table())

+ a b c d e

+----------

a| a b c d e

b| b c d e a

c| c d e a b

d| d e a b c

e| e a b c d

The table should adjust its column width to accomodate the width of the

strings used to represent elements. ::

sage: from sage.matrix.operation_table import OperationTable

sage: R=Integers(10)

sage: T=OperationTable(R, operator.mul, names='digits')

sage: print(T._ascii_table())

* 0 1 2 3 4 5 6 7 8 9

+--------------------

0| 0 0 0 0 0 0 0 0 0 0

1| 0 1 2 3 4 5 6 7 8 9

2| 0 2 4 6 8 0 2 4 6 8

3| 0 3 6 9 2 5 8 1 4 7

4| 0 4 8 2 6 0 4 8 2 6

5| 0 5 0 5 0 5 0 5 0 5

6| 0 6 2 8 4 0 6 2 8 4

7| 0 7 4 1 8 5 2 9 6 3

8| 0 8 6 4 2 0 8 6 4 2

9| 0 9 8 7 6 5 4 3 2 1

sage: from sage.matrix.operation_table import OperationTable

sage: R=Integers(11)

sage: T=OperationTable(R, operator.mul, names='digits')

sage: print(T._ascii_table())

* 00 01 02 03 04 05 06 07 08 09 10

+---------------------------------

00| 00 00 00 00 00 00 00 00 00 00 00

01| 00 01 02 03 04 05 06 07 08 09 10

02| 00 02 04 06 08 10 01 03 05 07 09

03| 00 03 06 09 01 04 07 10 02 05 08

04| 00 04 08 01 05 09 02 06 10 03 07

05| 00 05 10 04 09 03 08 02 07 01 06

06| 00 06 01 07 02 08 03 09 04 10 05

07| 00 07 03 10 06 02 09 05 01 08 04

08| 00 08 05 02 10 07 04 01 09 06 03

09| 00 09 07 05 03 01 10 08 06 04 02

10| 00 10 09 08 07 06 05 04 03 02 01

sage: from sage.matrix.operation_table import OperationTable

sage: R=Integers(4)

sage: T=OperationTable(R, operator.mul, names=['x','y','wwww', 'z'])

sage: print(T._ascii_table())

* x y wwww z

+--------------------

x| x x x x

y| x y wwww z

wwww| x wwww x wwww

z| x z wwww y

"""

n = self._n

width = self._width

widenames = []

for name in self._names:

widenames.append('{0: >{1}s}'.format(name, width))

# Headers

table = ['{0: >{1}s} '.format(self._ascii_symbol,width)]

table += [' '+widenames[i] for i in range(n)]+['\n']

table += [' ']*width + ['+'] + ['-']*(n*(width+1))+['\n']

# Row labels, body of table

for g in range(n):

table.append(widenames[g]+'|')

for h in range(n):

table.append(' '+widenames[self._table[g][h]])

table.append('\n')

return ''.join(table)

def _latex_(self):

r"""

Returns a `LaTeX` version of the operation table as a string,

using a `LaTeX` ``array`` environment.

EXAMPLES::

sage: from sage.matrix.operation_table import OperationTable

sage: R=Integers(2)

sage: T=OperationTable(R, operation=operator.mul)

sage: T._latex_()

'{\\setlength{\\arraycolsep}{2ex}\n\\begin{array}{r|*{2}{r}}\n\\multicolumn{1}{c|}{\\ast}&a&b\\\\\\hline\n{}a&a&a\\\\\n{}b&a&b\\\\\n\\end{array}}'

"""

n = self._n

names = self._names

# Headers

table = ['{\\setlength{\\arraycolsep}{2ex}\n']

table.append('\\begin{array}{r|*{'+str(n)+'}{r}}\n')

table.append('\\multicolumn{1}{c|}{'+self._latex_symbol+'}')

table += ['&'+names[i] for i in range(n)]

table.append('\\\\\\hline\n')

# Row label and body of table

for g in range(n):

table.append('{}') # Interrupts newline and [], so not line spacing

table.append(names[g])

for h in range(n):

table.append('&'+names[self._table[g][h]])

table.append('\\\\\n')

# Finish

table.append('\\end{array}')

table.append('}')

return ''.join(table)

Coverage for local/lib/python2.7/site-packages/sage/matrix/operation_table.py : 97%

169 statements 164 run 5 missing 0 excluded