## Thursday, August 23, 2007

### Summer of Code summary

Summer of Code deadline has passed, now is the evaluation period, however I think I can already say, that it was a success, since all projects were finished.

Here is some statistics
ondra@fuji:~/sympy$svn log |grep ondrej | wc -l64ondra@fuji:~/sympy$ svn log |grep inferno | wc -l48ondra@fuji:~/sympy$svn log |grep fredrik | wc -l39ondra@fuji:~/sympy$ svn log |grep mattpap | wc -l39ondra@fuji:~/sympy$svn log |grep lethargo | wc -l29ondra@fuji:~/sympy$ svn log |grep brian | wc -l44ondra@fuji:~/sympy$svn log |grep pearu | wc -l14ondra@fuji:~/sympy$ svn log |grep Chris.Wu | wc -l3
But one shouldn't draw too many conclusions from that, because people like me prefer to commit very often and people like Mateusz prefer to work offline and then commit when they have a bigger debugged chunk of code ready. Also the logs start with the sympy-merge branch, that was created on July 19. So everything before that (Pearu's contribution and everything that happened before the merging) is not present in the statistics. Another statistics are the Issues changes mailinglist, I did a search for all the names:
Ondrej 974Fabian 335Jason 227Fredrik 151Robert 104Mateusz 88Pearu 76Brian 65Chris 28

The above table are all issues from the beginning of the project. Fabian was the most active and then Jason is catching up recently. :)

One should have in mind the old joke though: There are three kinds of lies: lies, damned lies, and statistics.

I'd like to thank all of you for bringing SymPy this far. Basically all major things are working, now comes the phase of polishing things and reducing the number of open Issues and improving doctests, so that SymPy is very easy to use for newcomers.

## Wednesday, August 1, 2007

### Progress

The midterm evaluation is over and noone has failed, which is great. We started to work more closely on the #sympy at freenode IRC channel and SymPy has made a tremendous progress in past couple of weeks.

Our team was joined by Fredrik and Pearu, so now there are 8 regular contributors.

Fredrik wrote fast floating point arithmetic (in pure Python), faster than the python Decimal module. For example 10 000 decimal digits of Pi can be computed in 0.3s (and one million in less than 20 minutes) with SymPy - just run the pidigits.py in the examples directory. He among other things wrote a fast algorithm for calculating the gamma function, that in some cases is faster than in Mathematica.

We moved to the new core written by Pearu, that has made everything 10x faster or more. Basically, Pearu very cleverly designed everything so that no operation is made in vain. For example my little hobby relativity.py for calculating the Schwarzschild solution now calculates it in 1s (compared to more than 10s before)!

ondra@pc232:~/sympy/examples\$ time python relativity.py----------------------------------------Christoffel symbols:(1/2)*(FD(1,)(nu))(r)(1/2)*(FD(1,)(nu))(r)(1/2)*exp(-lam(r) + nu(r))*(FD(1,)(nu))(r)(1/2)*(FD(1,)(lam))(r)-r/exp(lam(r))-r*sin(\theta)**2/exp(lam(r))1/r1/r-sin(\theta)*cos(\theta)1/sin(\theta)*cos(\theta)1/sin(\theta)*cos(\theta)1/r1/r----------------------------------------Ricci tensor:(1/2)*exp(-lam(r) + nu(r))*(FD(1, 1)(nu))(r) - 1/4*exp(-lam(r) + nu(r))*(FD(1,)(nu))(r)**2 + 1/r*exp(-lam(r) + nu(r))*(FD(1,)(nu))(r) + (1/2)*exp(-lam(r) + nu(r))*(-(FD(1,)(lam))(r) + (FD(1,)(nu))(r))*(FD(1,)(nu))(r) + (1/4)*exp(-lam(r) + nu(r))*(FD(1,)(lam))(r)*(FD(1,)(nu))(r)-1/2*(FD(1, 1)(nu))(r) - 1/4*(FD(1,)(nu))(r)**2 + 1/r*(FD(1,)(lam))(r) + (1/4)*(FD(1,)(nu))(r)*(FD(1,)(lam))(r)1 - 1/exp(lam(r)) + (1/2)*r/exp(lam(r))*(FD(1,)(lam))(r) - 1/2*r/exp(lam(r))*(FD(1,)(nu))(r)sin(\theta)**2 - sin(\theta)**2/exp(lam(r)) + (1/2)*r*sin(\theta)**2/exp(lam(r))*(FD(1,)(lam))(r) - 1/2*r*sin(\theta)**2/exp(lam(r))*(FD(1,)(nu))(r)----------------------------------------solve the Einstein's equations:lam(r) = -log(C1 + C2/r)metric:-C1 - C2/r 0 0 00 1/(C1 + C2/r) 0 00 0 r**2 00 0 0 r**2*sin(\theta)**2real 0m1.092suser 0m1.024ssys 0m0.068s

Now we are in the phase of polishing things so that everything that used to work before works in the new core the same way (or better). Things that remain are printing and some limits are failing, everything else was already fixed.

One conclusion that can be made is, that Python on today computers is already fast enough to do something useful. Concerning the Pi, it's amusing to read some articles about people trying to calculate many digits, for example in one article, it took them a day to calculate one million digits on Pentium 90 (SymPy can do that in 20 minutes).

Also I found some page, that I cannot rediscover at the moment, that stated it took like 15 minutes to calculate the Schwarzschild with Maple on some older computer, so I am glad SymPy can do that in 1s (and actually the code is very slow, I am doing some calculations again and again, but I didn't find time yet to optimize it).

Anyway, the overall progress on SymPy looks very promising, I have no doubts that it will become a useful symbolic python library.