Skip to content
Fetching contributors…
Cannot retrieve contributors at this time
executable file 358 lines (271 sloc) 11.4 KB
#!/usr/bin/env python
# XXX: Don't put a newline here, or it will add an extra line with
# isympy --help
# |
# v
"""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
# hook in-tree SymPy into Python path, if possible
isympy_path = os.path.abspath(__file__)
isympy_dir = os.path.dirname(isympy_path)
sympy_top = os.path.split(isympy_dir)[0]
sympy_dir = os.path.join(sympy_top, 'sympy')
if os.path.isdir(sympy_dir):
sys.path.insert(0, sympy_top)
# DO NOT IMPORT SYMPY HERE!
def main():
from optparse import OptionParser
if '-h' in sys.argv or '--help' in sys.argv:
# XXX: We can't use description=__doc__ in the OptionParser call
# below because optparse line wraps it weird. The argparse module
# allows you to disable this, though, but it's only available in
# Python 2.7+.
print(__doc__) # the docstring of this module above
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 = 'usage: isympy [options] -- [ipython options]'
parser = OptionParser(
usage=usage,
version=VERSION,
# XXX: We need a more centralized place to store the version.
# It is currently stored in sympy.__version__, but we can't yet
# import sympy at this point.
)
parser.add_option(
'-c', '--console',
dest='console',
action='store',
default=None,
choices=['ipython', 'python'],
help='select type of interactive session: ipython | python; defaults '
'to ipython if IPython is installed, otherwise python')
parser.add_option(
'-p', '--pretty',
dest='pretty',
action='store',
default=None,
choices=['unicode', 'ascii', 'no'],
help='setup pretty printing: unicode | ascii | no; defaults to '
'unicode printing if the terminal supports it, otherwise ascii')
parser.add_option(
'-t', '--types',
dest='types',
action='store',
default=None,
choices=['gmpy', 'gmpy1', 'python'],
help='setup ground types: gmpy | gmpy1 | python; defaults to gmpy if gmpy2 '
'or gmpy is installed, otherwise python')
parser.add_option(
'-o', '--order',
dest='order',
action='store',
default=None,
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_option(
'-q', '--quiet',
dest='quiet',
action='store_true',
default=False,
help='print only version information at startup')
parser.add_option(
'-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_option(
'-C', '--no-cache',
dest='cache',
action='store_false',
default=True,
help='disable caching mechanism')
parser.add_option(
'-a', '--auto-symbols',
dest='auto_symbols',
action='store_true',
default=False,
help='automatically construct missing symbols')
parser.add_option(
'-i', '--int-to-Integer',
dest='auto_int_to_Integer',
action='store_true',
default=False,
help="automatically wrap int literals with Integer")
parser.add_option(
'-I', '--interactive',
dest='interactive',
action='store_true',
default=False,
help="equivalent to -a -i")
parser.add_option(
'-D', '--debug',
dest='debug',
action='store_true',
default=False,
help='enable debugging output')
(options, ipy_args) = parser.parse_args()
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()
Something went wrong with that request. Please try again.