Symata.jl

Language for symbolic mathematics
Popularity
144 Stars
Updated Last
5 Months Ago
Started In
January 2015

Symata.jl

Symbolic mathematics language

Linux, OSX: Build Status   Windows: Build Status       Coverage Status codecov.io

Examples and help

What is Symata?

  • a language for symbolic computations and mathematics, where, for the most part, "mathematics" means what it typically does for a scientist or engineer.

  • a language based mostly on expressions, on "evaluating" and rewriting them, like Wolfram, Maple, or Maxima. It is neither a language, nor an extension of a language, that is mostly procedural, or designed around data types and functions, or a hierarchy of classes, etc., like C or Python or Java. Nor is it language like Sage; that is, one meant to provide a unifying interface to a number of mathematics languages with various programming models.

  • meant to be useful to people who do not like to program computers, as well as those who do. The former includes people who prefer not to think about classes, methods, objects, dispatch, stack traces, etc.

Symata is largely modeled on the pattern matching and evaluation sequence of Mathematica. Evaluation, pattern matching, flow control, etc. are written in Julia. Much of the mathematics and symbolic manipulation is achieved by wrapping SymPy. There are more than 600 functions implemented, including integration, transformation of special functions, expression manipulation, writing and reading expressions to and from a file etc.

Installing

Symata is a registered module. It can be installed like this

(v0.7) pkg> add Symata
julia> using Symata
symata> Help()    # type '=' alone on a line to enter symata mode

Symata can be installed on Linux, OSX, and Windows.

Symata depends on the PyCall package and the python SymPy module. You can install SymPy via pip install sympy. Symata is compatible with SymPy v1.0 and v1.2 (and probably v1.1).

Alternatively, you may install SymPy via Conda.jl. When you load Symata with using Symata, sympy is installed automatically via PyCall, which uses Conda. However, to do this, PyCall must be configured to not use you system version of python. If you do not have PyCall installed, do this

julia> ENV["PYTHON"]=""
julia> Pkg.add("PyCall")

If you do have PyCall installed, but it is configured to use your system python, reconfigure it like this.

julia> ENV["PYTHON"]=""
julia> Pkg.build("PyCall")

If you use linux, you may have your distribution's sympy package installed and it may be out of date. In this case, try the procedure above, and/or try removing your distribution's sympy package.

note

SymPy, or sympy, here refers to the python SymPy distribution (sometimes called sympy), not the Julia package SymPy. Symata does not require the Julia package SymPy.jl, which has a different goal.

Symata requires mpmath package for python. This should be automatically installed when installing sympy via PyCall as described above. This also works on OSX. However, if you use pip, you should just be able to run pip install mpmath.

Running Symata

See below for instructions on precompiling Symata to get more-or-less instant start up and many precompiled function calls.

Three environments for running Symata are supported: the Julia REPL, Jupyter, and a dumb terminal.

Symata REPL mode

A Symata mode is added to the Julia REPL. Enter the mode by typing = as the first character. Exit the mode by typing backspace as the first character.

julia> using Symata

symata 1>     # after entering `=`

Under some circumstances, e.g. when using PackageCompiler, the Symata repl is not initialized after the module is loaded. You can initialize it with the exported Julia command run_repl. After this, the repl is entered with the = key. An executable ./scripts/symata is included. It is a (UNIX sh) shell script that just starts julia, loads the module, and enters Symata mode. There is also a script ./scripts/symatap for starting from an image with Symata precompiled. (See below.) Switch between Julia and Symata modes by typing =, or backspace, as the first character on a line. You can do tab completion to see a list of functions and symbols.

Jupyter / IJulia

In [1]:  using Symata

In [2]:  Expand((a+b)^2)

Out[2]:  a^2 + 2a*b + b^2

In [3]:  Julia()   # return to Julia mode

In Jupyter, the Symata expressions In(n) and Out(n) reevaluate the input and output cells. TAB completion works in Jupyter. To see a list of all possible completions, type *[TAB].

Dumb terminal

If you do using Symata in a dumb terminal, the Symata prompt should appear automatically.

sympy shell

From the julia prompt, type isympy() to enter the sympy shell.

NEW! Instant Symata

You can precompile Symata. It will load very quickly and be generally much more responsive. The script ./scripts/gen_compile_symata.sh writes a Julia image. The shell script ./scripts/symatap runs Julia with this image and immediately enters the Symata repl. See the contents of these files if you can't run shell scripts on your platform.

Instant Symata with Jupyter

You can install a Jupyter kernel using the precompiled image. You must not insert any whitespace between -J and the path to the image.

julia> using IJulia
julia> installkernel("Symata", "-J/home/username/path/to/symataimage.so")

Tests

Run the test suite from the symata prompt with Tests(). This runs tests in the symata_test directory Pkg.test("Symata") runs the same test suite from Julia and some Julia-level unit tests, as well.