A computer algebra system written in Python | Hacker News Reader

A computer algebra system written in Python

github.com

142 pointsrbanffy30 comments

Sympy is AWESOME! In particular, http://live.sympy.org is a great way to learn and teach math... I often send links to my students with an entire sequence of steps to find the solution. Can you factor x^2-5x+6 ? (find numbers a,b such that (x-a)(x-b)=x^2-5x+6) http://live.sympy.org/?evaluate=solve(%20x**2-5*x%2B6%2C%20x... (it's like an entire iPython notebook in a URL)

On the topic of sympy, I'm working on this short tutorial---an introduction to sympy based around topics from the standard high school and first-year university curriculum: http://minireference.com/static/sympy_tutorial.pdf

Please don't post the tutorial on HN yet---I'm working out some last typos and I want to time the "official" announcement on HN with the beginning of the school year.

SymPy Gamma is also very interesting. Yes, it's no real competitor to WolframAlpha, but it still has quite a few useful features.

http://www.sympygamma.com/input/?i=integrate+log%28x^2%29

For instance, as you can see in the link above, it can provide steps for derivatives and integrals. WA has the same feature, but you need to subscribe to actually use it without limits.

I'm a Google Summer of Code mentor for SymPy. There's a number of good additions to it being done this summer. My student is working on systems of ODEs. There's 10 different projects in total, including work on optics, 3D geometry, and vectors (and hopefully vector calculus).

The optics and the 3D geometry should help a lot with teaching and learning.

Seconded!

I used Sympy recently to solve the rocket equation. It involved some integrals that my rusty math skills couldn't solve so I used Sympy to solve them.

Then I ran a side by side comparison between the integrals I solved with Sympy against a numerical solution using Scipy and Numpy to verify that my results are correct.

The only negative thing about Sympy is that it's rather slow.

Here's the code if you're interested: https://gist.github.com/rikusalminen/6d6bb834d48b9664b38d

Just FYI, Sage also has the Sage Cell Server, which is similar in that you can do calculations on a webpage, but also allows embedding live cells in webpages easily, sage interacts, 3d graphics, etc. For example, here is your calculation: http://sagecell.sagemath.org/?q=mthhin. Click the "About" link in the upper right for more information.

How is it different from Sage[1]?

(Quickstart here http://www.sagemath.org/tour-quickstart.html, and really awesome cloud version (that requires an account, but is very worth it here: https://cloud.sagemath.com/)

[1]: http://www.sagemath.org/

The Sympy guys have a good comparison:

https://github.com/sympy/sympy/wiki/SymPy-vs.-Sage

Sage uses sympy, among many other tools.

I would say the main difference is scope: SymPy is aiming for traditional CAS territory: algebra with elementary functions, calculus, ODEs, elementary number theory, plotting. Sage aims to include tools for computations in all parts of mathematics, including all of the above but also more advanced things like group theory, representation theory, homological algebra, commutative algebra, homology of simplicial complexes, graph theory, Galois theory, algebraic number theory, etc.

I highly recommend looking at the comparison of the two mentioned in response to this. It's a bit out of date, though. It has a reference to SymPy 0.7.2 upcoming, but it's already past that.

Basically, Sage is more comprehensive as it pulls in a lot of different packages. SymPy is designed to be a Python CAS that you can use with other Python projects. Also, Sage doesn't directly support Windows, it requires the use of a VM image instead.

Sage is a collection of math tools for Python nicely packaged. The Sage collection includes Sympy.

If you use sympy, I would strongly recommend using ipython qtconsole:

http://ipython.org/ipython-doc/2/interactive/qtconsole.html

One of the big advantages is that you can print your expressions using LaTeX:

http://docs.sympy.org/dev/tutorial/printing.html

Why not the ipython notebook, in that case?

I went through this same thought process about two years ago.

IPython's notebook allows you to easily publish results. They include all you want and need: latex, imshow and nice code with many languages. But it's not good for generating results.

Perhaps the area it lacks most in is querying variables. In QtConsole, you just type `plot(x)` and see a plot with no side effects. In the notebook on the other hand, you have to type `plot(x)` into a new cell unless you want to rerun your code again and you have to delete that cell later (otherwise you have an unreadable notebook). Plus, the default keybindings (while easy to see) are not intuitive; I don't instinctively know how to jump back a cell.

I don't agree. In the notebook, you can use "%pylab inline" or "%matplotlib inline" magic to have plots inline, but you can also not use it and have plots output to a separate window without any side effects in the notebook itself. Or use any other backend of your choice.

To select a previous cell just press UP in command mode (or press Esc-UP in any mode). Ref: http://nbviewer.ipython.org/github/ipython/ipython/blob/2.x/...

Why would you link to the Github page instead of the project’s home page (http://sympy.org/)? Is this a thing now?

Yeah, upon seeing the github link I was thinking some poor sod had implemented some polynomial expansion algorithm, and had never heard of sympy. The it turned out to be sympy.

Soon people will post links to the gnome repos with the title "A open source desktop environment for linux" ... now I'm tempted to do it myself.

Sorry. I can't edit it anymore. Maybe the moderators still can. Also, the original submission failed to generate a discussion.

A Github URL may have never been submitted before, but the home page had been.

When looking at Computer Algebra, you can't go past the original example of MacSyma (written in LISP).

You can see an explanation of the MacSyma system in Peter Norvig's (head of Google researcyh) Paradigms of Artificial Intelligence (PAIP).

http://norvig.com/paip/README.html

http://norvig.com/paip/macsyma.lisp

http://norvig.com/paip/macsymar.lisp

http://norvig.com/paip/cmacsyma.lisp

The original development of the MacSyma system influenced Mathematica: http://en.wikipedia.org/wiki/Macsyma

Another good algebra system written in lisp is Axiom (http://en.wikipedia.org/wiki/Axiom_%28computer_algebra_syste...), which is interesting for another reason too - it's probably the best example of literate programming around.

How does it compare to Maxima? http://maxima.sourceforge.net/

GNU Calc (M-x calc in Emacs) is also a fairly capable CAS, and I love its RPN interface.

Thanks for that! I didn't know it had some algebra integrated. However, it wouldn't simplify (x+1)/(-x-1) (it does simplify -x/x though).

Try the "a n" command.

As a standalone CAS, Maxima is more fully featured than SymPy. But, it's harder to use with other packages. With SymPy, you can do your work with the CAS and then use the results with NumPy, SciPy, or Theano.

How does this compare with SAGE? I want to show this to my old math teacher who taught using that instead.

Sympy is included in Sage. Sage is just a collection of math tools in nice packaging.

Sage also has its own 1.5 million line python/cython library that is part of Sage (https://github.com/sagemath/sage/tree/master/src/sage)

I just read some of the tutorial and I must say this is some incredible work. Very powerful tool, and what a great choice of license (BSD). This benefits everyone; I'm very curious to read the source.

Reply on news.ycombinator.com