/

# Miscellaneous¶

Miscellaneous stuff that doesn’t really fit anywhere else.

sympy.utilities.misc.debug(*args)[source]

Print *args if SYMPY_DEBUG is True, else do nothing.

sympy.utilities.misc.default_sort_key(item, order=None)[source]

Return a key that can be used for sorting.

The key has the structure:

(class_key, (len(args), args), exponent.sort_key(), coefficient)

This key is supplied by the sort_key routine of Basic objects when item is a Basic object or an object (other than a string) that sympifies to a Basic object. Otherwise, this function produces the key.

The order argument is passed along to the sort_key routine and is used to determe how the terms within an expression are ordered. (See examples below) order options are: ‘lex’, ‘grlex’, ‘grevlex’, and reversed values of the same (e.g. ‘rev-lex’). The default order value is None (which translates to ‘lex’).

See also

sympy.core.expr.as_ordered_factors, sympy.core.expr.as_ordered_terms

Examples

>>> from sympy import Basic, S, I, default_sort_key
>>> from sympy.core.function import UndefinedFunction
>>> from sympy.abc import x


The following are eqivalent ways of getting the key for an object:

>>> x.sort_key() == default_sort_key(x)
True


Here are some examples of the key that is produced:

>>> default_sort_key(UndefinedFunction('f'))
((0, 0, 'UndefinedFunction'), (1, ('f',)), ((1, 0, 'Number'), (0, ()), (), 1), 1)
>>> default_sort_key('1')
((0, 0, 'str'), (1, ('1',)), ((1, 0, 'Number'), (0, ()), (), 1), 1)
>>> default_sort_key(S.One)
((1, 0, 'Number'), (0, ()), (), 1)
>>> default_sort_key(2)
((1, 0, 'Number'), (0, ()), (), 2)


While sort_key is a method only defined for SymPy objects, default_sort_key will accept anything as an argument so it is more robust as a sorting key. For the following, using key= lambda i: i.sort_key() would fail because 2 doesn’t have a sort_key method; that’s why default_sort_key is used. Note, that it also handles sympification of non-string items likes ints:

>>> a = [2, I, -I]
>>> sorted(a, key=default_sort_key)
[2, -I, I]


The returned key can be used anywhere that a key can be specified for a function, e.g. sort, min, max, etc...:

>>> a.sort(key=default_sort_key); a[0]
2
>>> min(a, key=default_sort_key)
2


Note

The key returned is useful for getting items into a canonical order that will be the same across platforms. It is not directly useful for sorting lists of expressions:

>>> a, b = x, 1/x


Since a has only 1 term, its value of sort_key is unaffected by order:

>>> a.sort_key() == a.sort_key('rev-lex')
True


If a and b are combined then the key will differ because there are terms that can be ordered:

>>> eq = a + b
>>> eq.sort_key() == eq.sort_key('rev-lex')
False
>>> eq.as_ordered_terms()
[x, 1/x]
>>> eq.as_ordered_terms('rev-lex')
[1/x, x]


But since the keys for each of these terms are independent of order‘s value, they don’t sort differently when they appear separately in a list:

>>> sorted(eq.args, key=default_sort_key)
[1/x, x]
>>> sorted(eq.args, key=lambda i: default_sort_key(i, order='rev-lex'))
[1/x, x]


The order of terms obtained when using these keys is the order that would be obtained if those terms were factors in a product.

sympy.utilities.misc.rawlines(s)[source]

Return a cut-and-pastable string that, when printed, is equivalent to the input. The string returned is formatted so it can be indented nicely within tests; in some cases it is wrapped in the dedent function which has to be imported from textwrap.

Examples

Note: because there are characters in the examples below that need to be escaped because they are themselves within a triple quoted docstring, expressions below look more complicated than they would be if they were printed in an interpreter window.

>>> from sympy.utilities.misc import rawlines
>>> from sympy import TableForm
>>> s = str(TableForm([[1, 10]], headings=(None, ['a', 'bee'])))
>>> print rawlines(s) # the \ appears as \ when printed
(
'a bee\n'
'-----\n'
'1 10 '
)
>>> print rawlines('''this
... that''')
dedent('''\
this
that''')

>>> print rawlines('''this
... that
... ''')
dedent('''\
this
that
''')

>>> s = """this
... is a triple '''
... """
>>> print rawlines(s)
dedent("""\
this
is a triple '''
""")

>>> print rawlines('''this
... that
...     ''')
(
'this\n'
'that\n'
'    '
)


Memoization

PKGDATA