| | from sympy.core.containers import Tuple |
| | from sympy.core.singleton import S |
| | from sympy.core.symbol import Symbol |
| | from sympy.core.sympify import SympifyError |
| |
|
| | from types import FunctionType |
| |
|
| |
|
| | class TableForm: |
| | r""" |
| | Create a nice table representation of data. |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy import TableForm |
| | >>> t = TableForm([[5, 7], [4, 2], [10, 3]]) |
| | >>> print(t) |
| | 5 7 |
| | 4 2 |
| | 10 3 |
| | |
| | You can use the SymPy's printing system to produce tables in any |
| | format (ascii, latex, html, ...). |
| | |
| | >>> print(t.as_latex()) |
| | \begin{tabular}{l l} |
| | $5$ & $7$ \\ |
| | $4$ & $2$ \\ |
| | $10$ & $3$ \\ |
| | \end{tabular} |
| | |
| | """ |
| |
|
| | def __init__(self, data, **kwarg): |
| | """ |
| | Creates a TableForm. |
| | |
| | Parameters: |
| | |
| | data ... |
| | 2D data to be put into the table; data can be |
| | given as a Matrix |
| | |
| | headings ... |
| | gives the labels for rows and columns: |
| | |
| | Can be a single argument that applies to both |
| | dimensions: |
| | |
| | - None ... no labels |
| | - "automatic" ... labels are 1, 2, 3, ... |
| | |
| | Can be a list of labels for rows and columns: |
| | The labels for each dimension can be given |
| | as None, "automatic", or [l1, l2, ...] e.g. |
| | ["automatic", None] will number the rows |
| | |
| | [default: None] |
| | |
| | alignments ... |
| | alignment of the columns with: |
| | |
| | - "left" or "<" |
| | - "center" or "^" |
| | - "right" or ">" |
| | |
| | When given as a single value, the value is used for |
| | all columns. The row headings (if given) will be |
| | right justified unless an explicit alignment is |
| | given for it and all other columns. |
| | |
| | [default: "left"] |
| | |
| | formats ... |
| | a list of format strings or functions that accept |
| | 3 arguments (entry, row number, col number) and |
| | return a string for the table entry. (If a function |
| | returns None then the _print method will be used.) |
| | |
| | wipe_zeros ... |
| | Do not show zeros in the table. |
| | |
| | [default: True] |
| | |
| | pad ... |
| | the string to use to indicate a missing value (e.g. |
| | elements that are None or those that are missing |
| | from the end of a row (i.e. any row that is shorter |
| | than the rest is assumed to have missing values). |
| | When None, nothing will be shown for values that |
| | are missing from the end of a row; values that are |
| | None, however, will be shown. |
| | |
| | [default: None] |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy import TableForm, Symbol |
| | >>> TableForm([[5, 7], [4, 2], [10, 3]]) |
| | 5 7 |
| | 4 2 |
| | 10 3 |
| | >>> TableForm([list('.'*i) for i in range(1, 4)], headings='automatic') |
| | | 1 2 3 |
| | --------- |
| | 1 | . |
| | 2 | . . |
| | 3 | . . . |
| | >>> TableForm([[Symbol('.'*(j if not i%2 else 1)) for i in range(3)] |
| | ... for j in range(4)], alignments='rcl') |
| | . |
| | . . . |
| | .. . .. |
| | ... . ... |
| | """ |
| | from sympy.matrices.dense import Matrix |
| |
|
| | |
| | if isinstance(data, Matrix): |
| | data = data.tolist() |
| | _h = len(data) |
| |
|
| | |
| | pad = kwarg.get('pad', None) |
| | ok_None = False |
| | if pad is None: |
| | pad = " " |
| | ok_None = True |
| | pad = Symbol(pad) |
| | _w = max(len(line) for line in data) |
| | for i, line in enumerate(data): |
| | if len(line) != _w: |
| | line.extend([pad]*(_w - len(line))) |
| | for j, lj in enumerate(line): |
| | if lj is None: |
| | if not ok_None: |
| | lj = pad |
| | else: |
| | try: |
| | lj = S(lj) |
| | except SympifyError: |
| | lj = Symbol(str(lj)) |
| | line[j] = lj |
| | data[i] = line |
| | _lines = Tuple(*[Tuple(*d) for d in data]) |
| |
|
| | headings = kwarg.get("headings", [None, None]) |
| | if headings == "automatic": |
| | _headings = [range(1, _h + 1), range(1, _w + 1)] |
| | else: |
| | h1, h2 = headings |
| | if h1 == "automatic": |
| | h1 = range(1, _h + 1) |
| | if h2 == "automatic": |
| | h2 = range(1, _w + 1) |
| | _headings = [h1, h2] |
| |
|
| | allow = ('l', 'r', 'c') |
| | alignments = kwarg.get("alignments", "l") |
| |
|
| | def _std_align(a): |
| | a = a.strip().lower() |
| | if len(a) > 1: |
| | return {'left': 'l', 'right': 'r', 'center': 'c'}.get(a, a) |
| | else: |
| | return {'<': 'l', '>': 'r', '^': 'c'}.get(a, a) |
| | std_align = _std_align(alignments) |
| | if std_align in allow: |
| | _alignments = [std_align]*_w |
| | else: |
| | _alignments = [] |
| | for a in alignments: |
| | std_align = _std_align(a) |
| | _alignments.append(std_align) |
| | if std_align not in ('l', 'r', 'c'): |
| | raise ValueError('alignment "%s" unrecognized' % |
| | alignments) |
| | if _headings[0] and len(_alignments) == _w + 1: |
| | _head_align = _alignments[0] |
| | _alignments = _alignments[1:] |
| | else: |
| | _head_align = 'r' |
| | if len(_alignments) != _w: |
| | raise ValueError( |
| | 'wrong number of alignments: expected %s but got %s' % |
| | (_w, len(_alignments))) |
| |
|
| | _column_formats = kwarg.get("formats", [None]*_w) |
| |
|
| | _wipe_zeros = kwarg.get("wipe_zeros", True) |
| |
|
| | self._w = _w |
| | self._h = _h |
| | self._lines = _lines |
| | self._headings = _headings |
| | self._head_align = _head_align |
| | self._alignments = _alignments |
| | self._column_formats = _column_formats |
| | self._wipe_zeros = _wipe_zeros |
| |
|
| | def __repr__(self): |
| | from .str import sstr |
| | return sstr(self, order=None) |
| |
|
| | def __str__(self): |
| | from .str import sstr |
| | return sstr(self, order=None) |
| |
|
| | def as_matrix(self): |
| | """Returns the data of the table in Matrix form. |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy import TableForm |
| | >>> t = TableForm([[5, 7], [4, 2], [10, 3]], headings='automatic') |
| | >>> t |
| | | 1 2 |
| | -------- |
| | 1 | 5 7 |
| | 2 | 4 2 |
| | 3 | 10 3 |
| | >>> t.as_matrix() |
| | Matrix([ |
| | [ 5, 7], |
| | [ 4, 2], |
| | [10, 3]]) |
| | """ |
| | from sympy.matrices.dense import Matrix |
| | return Matrix(self._lines) |
| |
|
| | def as_str(self): |
| | |
| | return str(self) |
| |
|
| | def as_latex(self): |
| | from .latex import latex |
| | return latex(self) |
| |
|
| | def _sympystr(self, p): |
| | """ |
| | Returns the string representation of 'self'. |
| | |
| | Examples |
| | ======== |
| | |
| | >>> from sympy import TableForm |
| | >>> t = TableForm([[5, 7], [4, 2], [10, 3]]) |
| | >>> s = t.as_str() |
| | |
| | """ |
| | column_widths = [0] * self._w |
| | lines = [] |
| | for line in self._lines: |
| | new_line = [] |
| | for i in range(self._w): |
| | |
| | s = str(line[i]) |
| | if self._wipe_zeros and (s == "0"): |
| | s = " " |
| | w = len(s) |
| | if w > column_widths[i]: |
| | column_widths[i] = w |
| | new_line.append(s) |
| | lines.append(new_line) |
| |
|
| | |
| | if self._headings[0]: |
| | self._headings[0] = [str(x) for x in self._headings[0]] |
| | _head_width = max(len(x) for x in self._headings[0]) |
| |
|
| | if self._headings[1]: |
| | new_line = [] |
| | for i in range(self._w): |
| | |
| | s = str(self._headings[1][i]) |
| | w = len(s) |
| | if w > column_widths[i]: |
| | column_widths[i] = w |
| | new_line.append(s) |
| | self._headings[1] = new_line |
| |
|
| | format_str = [] |
| |
|
| | def _align(align, w): |
| | return '%%%s%ss' % ( |
| | ("-" if align == "l" else ""), |
| | str(w)) |
| | format_str = [_align(align, w) for align, w in |
| | zip(self._alignments, column_widths)] |
| | if self._headings[0]: |
| | format_str.insert(0, _align(self._head_align, _head_width)) |
| | format_str.insert(1, '|') |
| | format_str = ' '.join(format_str) + '\n' |
| |
|
| | s = [] |
| | if self._headings[1]: |
| | d = self._headings[1] |
| | if self._headings[0]: |
| | d = [""] + d |
| | first_line = format_str % tuple(d) |
| | s.append(first_line) |
| | s.append("-" * (len(first_line) - 1) + "\n") |
| | for i, line in enumerate(lines): |
| | d = [l if self._alignments[j] != 'c' else |
| | l.center(column_widths[j]) for j, l in enumerate(line)] |
| | if self._headings[0]: |
| | l = self._headings[0][i] |
| | l = (l if self._head_align != 'c' else |
| | l.center(_head_width)) |
| | d = [l] + d |
| | s.append(format_str % tuple(d)) |
| | return ''.join(s)[:-1] |
| |
|
| | def _latex(self, printer): |
| | """ |
| | Returns the string representation of 'self'. |
| | """ |
| | |
| | if self._headings[1]: |
| | new_line = [] |
| | for i in range(self._w): |
| | |
| | new_line.append(str(self._headings[1][i])) |
| | self._headings[1] = new_line |
| |
|
| | alignments = [] |
| | if self._headings[0]: |
| | self._headings[0] = [str(x) for x in self._headings[0]] |
| | alignments = [self._head_align] |
| | alignments.extend(self._alignments) |
| |
|
| | s = r"\begin{tabular}{" + " ".join(alignments) + "}\n" |
| |
|
| | if self._headings[1]: |
| | d = self._headings[1] |
| | if self._headings[0]: |
| | d = [""] + d |
| | first_line = " & ".join(d) + r" \\" + "\n" |
| | s += first_line |
| | s += r"\hline" + "\n" |
| | for i, line in enumerate(self._lines): |
| | d = [] |
| | for j, x in enumerate(line): |
| | if self._wipe_zeros and (x in (0, "0")): |
| | d.append(" ") |
| | continue |
| | f = self._column_formats[j] |
| | if f: |
| | if isinstance(f, FunctionType): |
| | v = f(x, i, j) |
| | if v is None: |
| | v = printer._print(x) |
| | else: |
| | v = f % x |
| | d.append(v) |
| | else: |
| | v = printer._print(x) |
| | d.append("$%s$" % v) |
| | if self._headings[0]: |
| | d = [self._headings[0][i]] + d |
| | s += " & ".join(d) + r" \\" + "\n" |
| | s += r"\end{tabular}" |
| | return s |
| |
|
