343 lines
11 KiB
Python
343 lines
11 KiB
Python
|
"""
|
||
|
|
Python shell for SymPy.
|
||
|
|
|
||
|
|
This is just a normal Python shell (IPython shell if you have the
|
||
|
|
IPython package installed), that executes the following commands for
|
||
|
|
the user:
|
||
|
|
|
||
|
|
>>> from __future__ import division
|
||
|
|
>>> from sympy import *
|
||
|
|
>>> x, y, z, t = symbols('x y z t')
|
||
|
|
>>> k, m, n = symbols('k m n', integer=True)
|
||
|
|
>>> f, g, h = symbols('f g h', cls=Function)
|
||
|
|
>>> init_printing()
|
||
|
|
|
||
|
|
So starting 'isympy' is equivalent to starting Python (or IPython) and
|
||
|
|
executing the above commands by hand. It is intended for easy and quick
|
||
|
|
experimentation with SymPy. isympy is a good way to use SymPy as an
|
||
|
|
interactive calculator. If you have IPython and Matplotlib installed, then
|
||
|
|
interactive plotting is enabled by default.
|
||
|
|
|
||
|
|
COMMAND LINE OPTIONS
|
||
|
|
--------------------
|
||
|
|
|
||
|
|
-c CONSOLE, --console=CONSOLE
|
||
|
|
|
||
|
|
Use the specified shell (Python or IPython) shell as the console
|
||
|
|
backend instead of the default one (IPython if present, Python
|
||
|
|
otherwise), e.g.:
|
||
|
|
|
||
|
|
$isympy -c python
|
||
|
|
|
||
|
|
CONSOLE must be one of 'ipython' or 'python'
|
||
|
|
|
||
|
|
-p PRETTY, --pretty PRETTY
|
||
|
|
|
||
|
|
Setup pretty-printing in SymPy. When pretty-printing is enabled,
|
||
|
|
expressions can be printed with Unicode or ASCII. The default is
|
||
|
|
to use pretty-printing (with Unicode if the terminal supports it).
|
||
|
|
When this option is 'no', expressions will not be pretty-printed
|
||
|
|
and ASCII will be used:
|
||
|
|
|
||
|
|
$isympy -p no
|
||
|
|
|
||
|
|
PRETTY must be one of 'unicode', 'ascii', or 'no'
|
||
|
|
|
||
|
|
-t TYPES, --types=TYPES
|
||
|
|
|
||
|
|
Setup the ground types for the polys. By default, gmpy ground types
|
||
|
|
are used if gmpy2 or gmpy is installed, otherwise it falls back to python
|
||
|
|
ground types, which are a little bit slower. You can manually
|
||
|
|
choose python ground types even if gmpy is installed (e.g., for
|
||
|
|
testing purposes):
|
||
|
|
|
||
|
|
$isympy -t python
|
||
|
|
|
||
|
|
TYPES must be one of 'gmpy', 'gmpy1' or 'python'
|
||
|
|
|
||
|
|
Note that the ground type gmpy1 is primarily intended for testing; it
|
||
|
|
forces the use of gmpy version 1 even if gmpy2 is available.
|
||
|
|
|
||
|
|
This is the same as setting the environment variable
|
||
|
|
SYMPY_GROUND_TYPES to the given ground type (e.g.,
|
||
|
|
SYMPY_GROUND_TYPES='gmpy')
|
||
|
|
|
||
|
|
The ground types can be determined interactively from the variable
|
||
|
|
sympy.polys.domains.GROUND_TYPES.
|
||
|
|
|
||
|
|
-o ORDER, --order ORDER
|
||
|
|
|
||
|
|
Setup the ordering of terms for printing. The default is lex, which
|
||
|
|
orders terms lexicographically (e.g., x**2 + x + 1). You can choose
|
||
|
|
other orderings, such as rev-lex, which will use reverse
|
||
|
|
lexicographic ordering (e.g., 1 + x + x**2):
|
||
|
|
|
||
|
|
$isympy -o rev-lex
|
||
|
|
|
||
|
|
ORDER must be one of 'lex', 'rev-lex', 'grlex', 'rev-grlex',
|
||
|
|
'grevlex', 'rev-grevlex', 'old', or 'none'.
|
||
|
|
|
||
|
|
Note that for very large expressions, ORDER='none' may speed up
|
||
|
|
printing considerably but the terms will have no canonical order.
|
||
|
|
|
||
|
|
-q, --quiet
|
||
|
|
|
||
|
|
Print only Python's and SymPy's versions to stdout at startup.
|
||
|
|
|
||
|
|
-d, --doctest
|
||
|
|
|
||
|
|
Use the same format that should be used for doctests. This is
|
||
|
|
equivalent to -c python -p no.
|
||
|
|
|
||
|
|
-C, --no-cache
|
||
|
|
|
||
|
|
Disable the caching mechanism. Disabling the cache may slow certain
|
||
|
|
operations down considerably. This is useful for testing the cache,
|
||
|
|
or for benchmarking, as the cache can result in deceptive timings.
|
||
|
|
|
||
|
|
This is equivalent to setting the environment variable
|
||
|
|
SYMPY_USE_CACHE to 'no'.
|
||
|
|
|
||
|
|
-a, --auto-symbols (requires at least IPython 0.11)
|
||
|
|
|
||
|
|
Automatically create missing symbols. Normally, typing a name of a
|
||
|
|
Symbol that has not been instantiated first would raise NameError,
|
||
|
|
but with this option enabled, any undefined name will be
|
||
|
|
automatically created as a Symbol.
|
||
|
|
|
||
|
|
Note that this is intended only for interactive, calculator style
|
||
|
|
usage. In a script that uses SymPy, Symbols should be instantiated
|
||
|
|
at the top, so that it's clear what they are.
|
||
|
|
|
||
|
|
This will not override any names that are already defined, which
|
||
|
|
includes the single character letters represented by the mnemonic
|
||
|
|
QCOSINE (see the "Gotchas and Pitfalls" document in the
|
||
|
|
documentation). You can delete existing names by executing "del
|
||
|
|
name". If a name is defined, typing "'name' in dir()" will return True.
|
||
|
|
|
||
|
|
The Symbols that are created using this have default assumptions.
|
||
|
|
If you want to place assumptions on symbols, you should create them
|
||
|
|
using symbols() or var().
|
||
|
|
|
||
|
|
Finally, this only works in the top level namespace. So, for
|
||
|
|
example, if you define a function in isympy with an undefined
|
||
|
|
Symbol, it will not work.
|
||
|
|
|
||
|
|
See also the -i and -I options.
|
||
|
|
|
||
|
|
-i, --int-to-Integer (requires at least IPython 0.11)
|
||
|
|
|
||
|
|
Automatically wrap int literals with Integer. This makes it so that
|
||
|
|
things like 1/2 will come out as Rational(1, 2), rather than 0.5. This
|
||
|
|
works by preprocessing the source and wrapping all int literals with
|
||
|
|
Integer. Note that this will not change the behavior of int literals
|
||
|
|
assigned to variables, and it also won't change the behavior of functions
|
||
|
|
that return int literals.
|
||
|
|
|
||
|
|
If you want an int, you can wrap the literal in int(), e.g. int(3)/int(2)
|
||
|
|
gives 1.5 (with division imported from __future__).
|
||
|
|
|
||
|
|
-I, --interactive (requires at least IPython 0.11)
|
||
|
|
|
||
|
|
This is equivalent to --auto-symbols --int-to-Integer. Future options
|
||
|
|
designed for ease of interactive use may be added to this.
|
||
|
|
|
||
|
|
-D, --debug
|
||
|
|
|
||
|
|
Enable debugging output. This is the same as setting the
|
||
|
|
environment variable SYMPY_DEBUG to 'True'. The debug status is set
|
||
|
|
in the variable SYMPY_DEBUG within isympy.
|
||
|
|
|
||
|
|
-- IPython options
|
||
|
|
|
||
|
|
Additionally you can pass command line options directly to the IPython
|
||
|
|
interpreter (the standard Python shell is not supported). However you
|
||
|
|
need to add the '--' separator between two types of options, e.g the
|
||
|
|
startup banner option and the colors option. You need to enter the
|
||
|
|
options as required by the version of IPython that you are using, too:
|
||
|
|
|
||
|
|
in IPython 0.11,
|
||
|
|
|
||
|
|
$isympy -q -- --colors=NoColor
|
||
|
|
|
||
|
|
or older versions of IPython,
|
||
|
|
|
||
|
|
$isympy -q -- -colors NoColor
|
||
|
|
|
||
|
|
See also isympy --help.
|
||
|
|
"""
|
||
|
|
|
||
|
|
import os
|
||
|
|
import sys
|
||
|
|
|
||
|
|
# DO NOT IMPORT SYMPY HERE! Or the setting of the sympy environment variables
|
||
|
|
# by the command line will break.
|
||
|
|
|
||
|
|
def main() -> None:
|
||
|
|
from argparse import ArgumentParser, RawDescriptionHelpFormatter
|
||
|
|
|
||
|
|
VERSION = None
|
||
|
|
if '--version' in sys.argv:
|
||
|
|
# We cannot import sympy before this is run, because flags like -C and
|
||
|
|
# -t set environment variables that must be set before SymPy is
|
||
|
|
# imported. The only thing we need to import it for is to get the
|
||
|
|
# version, which only matters with the --version flag.
|
||
|
|
import sympy
|
||
|
|
VERSION = sympy.__version__
|
||
|
|
|
||
|
|
usage = 'isympy [options] -- [ipython options]'
|
||
|
|
parser = ArgumentParser(
|
||
|
|
usage=usage,
|
||
|
|
description=__doc__,
|
||
|
|
formatter_class=RawDescriptionHelpFormatter,
|
||
|
|
)
|
||
|
|
|
||
|
|
parser.add_argument('--version', action='version', version=VERSION)
|
||
|
|
|
||
|
|
parser.add_argument(
|
||
|
|
'-c', '--console',
|
||
|
|
dest='console',
|
||
|
|
action='store',
|
||
|
|
default=None,
|
||
|
|
choices=['ipython', 'python'],
|
||
|
|
metavar='CONSOLE',
|
||
|
|
help='select type of interactive session: ipython | python; defaults '
|
||
|
|
'to ipython if IPython is installed, otherwise python')
|
||
|
|
|
||
|
|
parser.add_argument(
|
||
|
|
'-p', '--pretty',
|
||
|
|
dest='pretty',
|
||
|
|
action='store',
|
||
|
|
default=None,
|
||
|
|
metavar='PRETTY',
|
||
|
|
choices=['unicode', 'ascii', 'no'],
|
||
|
|
help='setup pretty printing: unicode | ascii | no; defaults to '
|
||
|
|
'unicode printing if the terminal supports it, otherwise ascii')
|
||
|
|
|
||
|
|
parser.add_argument(
|
||
|
|
'-t', '--types',
|
||
|
|
dest='types',
|
||
|
|
action='store',
|
||
|
|
default=None,
|
||
|
|
metavar='TYPES',
|
||
|
|
choices=['gmpy', 'gmpy1', 'python'],
|
||
|
|
help='setup ground types: gmpy | gmpy1 | python; defaults to gmpy if gmpy2 '
|
||
|
|
'or gmpy is installed, otherwise python')
|
||
|
|
|
||
|
|
parser.add_argument(
|
||
|
|
'-o', '--order',
|
||
|
|
dest='order',
|
||
|
|
action='store',
|
||
|
|
default=None,
|
||
|
|
metavar='ORDER',
|
||
|
|
choices=['lex', 'grlex', 'grevlex', 'rev-lex', 'rev-grlex', 'rev-grevlex', 'old', 'none'],
|
||
|
|
help='setup ordering of terms: [rev-]lex | [rev-]grlex | [rev-]grevlex | old | none; defaults to lex')
|
||
|
|
|
||
|
|
parser.add_argument(
|
||
|
|
'-q', '--quiet',
|
||
|
|
dest='quiet',
|
||
|
|
action='store_true',
|
||
|
|
default=False,
|
||
|
|
help='print only version information at startup')
|
||
|
|
|
||
|
|
parser.add_argument(
|
||
|
|
'-d', '--doctest',
|
||
|
|
dest='doctest',
|
||
|
|
action='store_true',
|
||
|
|
default=False,
|
||
|
|
help='use the doctest format for output (you can just copy and paste it)')
|
||
|
|
|
||
|
|
parser.add_argument(
|
||
|
|
'-C', '--no-cache',
|
||
|
|
dest='cache',
|
||
|
|
action='store_false',
|
||
|
|
default=True,
|
||
|
|
help='disable caching mechanism')
|
||
|
|
|
||
|
|
parser.add_argument(
|
||
|
|
'-a', '--auto-symbols',
|
||
|
|
dest='auto_symbols',
|
||
|
|
action='store_true',
|
||
|
|
default=False,
|
||
|
|
help='automatically construct missing symbols')
|
||
|
|
|
||
|
|
parser.add_argument(
|
||
|
|
'-i', '--int-to-Integer',
|
||
|
|
dest='auto_int_to_Integer',
|
||
|
|
action='store_true',
|
||
|
|
default=False,
|
||
|
|
help="automatically wrap int literals with Integer")
|
||
|
|
|
||
|
|
parser.add_argument(
|
||
|
|
'-I', '--interactive',
|
||
|
|
dest='interactive',
|
||
|
|
action='store_true',
|
||
|
|
default=False,
|
||
|
|
help="equivalent to -a -i")
|
||
|
|
|
||
|
|
parser.add_argument(
|
||
|
|
'-D', '--debug',
|
||
|
|
dest='debug',
|
||
|
|
action='store_true',
|
||
|
|
default=False,
|
||
|
|
help='enable debugging output')
|
||
|
|
|
||
|
|
(options, ipy_args) = parser.parse_known_args()
|
||
|
|
if '--' in ipy_args:
|
||
|
|
ipy_args.remove('--')
|
||
|
|
|
||
|
|
if not options.cache:
|
||
|
|
os.environ['SYMPY_USE_CACHE'] = 'no'
|
||
|
|
|
||
|
|
if options.types:
|
||
|
|
os.environ['SYMPY_GROUND_TYPES'] = options.types
|
||
|
|
|
||
|
|
if options.debug:
|
||
|
|
os.environ['SYMPY_DEBUG'] = str(options.debug)
|
||
|
|
|
||
|
|
if options.doctest:
|
||
|
|
options.pretty = 'no'
|
||
|
|
options.console = 'python'
|
||
|
|
|
||
|
|
session = options.console
|
||
|
|
|
||
|
|
if session is not None:
|
||
|
|
ipython = session == 'ipython'
|
||
|
|
else:
|
||
|
|
try:
|
||
|
|
import IPython
|
||
|
|
ipython = True
|
||
|
|
except ImportError:
|
||
|
|
if not options.quiet:
|
||
|
|
from sympy.interactive.session import no_ipython
|
||
|
|
print(no_ipython)
|
||
|
|
ipython = False
|
||
|
|
|
||
|
|
args = {
|
||
|
|
'pretty_print': True,
|
||
|
|
'use_unicode': None,
|
||
|
|
'use_latex': None,
|
||
|
|
'order': None,
|
||
|
|
'argv': ipy_args,
|
||
|
|
}
|
||
|
|
|
||
|
|
if options.pretty == 'unicode':
|
||
|
|
args['use_unicode'] = True
|
||
|
|
elif options.pretty == 'ascii':
|
||
|
|
args['use_unicode'] = False
|
||
|
|
elif options.pretty == 'no':
|
||
|
|
args['pretty_print'] = False
|
||
|
|
|
||
|
|
if options.order is not None:
|
||
|
|
args['order'] = options.order
|
||
|
|
|
||
|
|
args['quiet'] = options.quiet
|
||
|
|
args['auto_symbols'] = options.auto_symbols or options.interactive
|
||
|
|
args['auto_int_to_Integer'] = options.auto_int_to_Integer or options.interactive
|
||
|
|
|
||
|
|
from sympy.interactive import init_session
|
||
|
|
init_session(ipython, **args)
|
||
|
|
|
||
|
|
if __name__ == "__main__":
|
||
|
|
main()
|