342 lines
11 KiB
Python
342 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 # noqa: F401
| |||
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()
|