The Official SymPy Blog

Google Summer of Code 2011 Wrap-Up

2011-12-12T16:03:00.000-08:00

(Cross-posted on the Google Open Source Blog)

SymPy is a computer algebra system (CAS) written in pure Python. The core allows basic manipulation of expressions (like differentiation or expansion) and it contains many modules for common tasks (limits, integrals, differential equations, series, matrices, quantum physics, geometry, plotting, and code generation).

SymPy has participated in the Google Summer of Code program in previous years under the umbrellas of Python Software Foundation, Portland State University, and the Space Telescope Science Institute, where we were very successful. In fact, several of our core developers, including four of the mentors from this year, started working with SymPy as Google Summer of Code students. This was our first year participating as a standalone organization, and we would like to share our experience.

As part of the application process we required each student to submit a patch (as a GitHub pull request) that had to be reviewed and accepted. This allowed us to see that each applicant knew how to use git as well as communicate effectively during the review process.This also encouraged only serious applicants to apply. We had over 10 mentors available and we ended up with 9 students, all of whom were successful at final evaluations.

Tom Bachmann - Definite Integration using Meijer G-functions, mentored by Aaron Meurer
Tom implemented an algorithm for computing symbolic definite integrals that uses so-called Meijer G-functions. This is the state-of-the-art algorithm for computing definite integrals, and indeed the results of his project are very impressive. This project has pushed SymPy forward a long way to becoming the strongest open source computer algebra system with respect to symbolic definite integration.

Vladimir Peric - Porting to Python 3, mentored by Ronan Lamy
Vladimir ported SymPy to work on Python 3 and ported all testing infrastructure so that SymPy gets regularly tested in Python 2.x, 3.2 and PyPy. Thanks to Vladimir’s work, the next version of SymPy, 0.7.2, which will hopefully be released later this year, will work in both Python 2 and Python 3, and it may support PyPy as well.

Gilbert Gede - PyDy, mentored by Luke Peterson
Gilbert implemented a physics module to assist in generating symbolic equations of motion for complex multibody systems using Kane's Method. He expanded on the code written by his mentor, Luke, in 2009, and the module can now generate equations of motion for a bicycle. Gilbert also wrote very thorough documentation both for the Kane’s Method and the module in SymPy.

Tomo Lazovich - Position and Momentum Bases for Quantum Mechanics, mentored by Brian Granger
Tomo has greatly improved the quantum mechanics module by implementing position/momentum representations for operators and eigenstates in various coordinate systems (including cartesian, cylindrical, and spherical) that allows you to easily represent many of the "textbook" quantum mechanics systems, including particle in a box, simple harmonic oscillator, hydrogen atom, etc.

Saptarshi Mandal - Combinatorics package for Sympy, mentored by Christian Muise
Saptarshi’s project was to mimic the various capabilities of Combinatorica, a Mathematica package for combinatorics. Most of the functionality involving elementary combinatorial objects such as Permutations, Partitions, Subsets, Gray codes and Prufer codes are complete.

Sherjil Ozair - Symbolic Linear Algebra, mentored by Vinzent Steinberg
Sherjil improved the speed of the linear algebra module by using efficient coefficient types for values of entries of matrices. Previously, SymPy used generic expressions in this place, which slowed down computations considerably and caused trouble with solving of the zero equivalence problem. He also implemented sparse matrix representation and unified the API with dense matrices. In addition, Sherjil also added a few linear algebra related algorithms (e.g. Cholesky decomposition).

Matthew Rocklin - SymPy Stats: Random Variables, mentored by Andy Terrel
Matthew improved the statistics module to use symbolics and introduced a Random Variable type, with support for finite, continuous, and multivariable normal random variables. With these you can symbolically compute things like probabilities of a given condition, conditional spaces, and expectation values. As a side consequence of this project, he also improved some of our Sets classes and implemented a MatrixExpr class, which allows you to compute with matrices symbolically, including computing with block matrices.

Sean Vig - Symbolic Clebsch-Gordon coefficients/Wigner symbols and Implementing Addition of Spin Angular Momenta, mentored by Ondřej Čertík
Sean was working on the quantum mechanics module and has implemented symbolic Clebsch-Gordan coefficients, Wigner D function, and related mathematical concepts that are used very often in quantum physics when dealing with angular momentum and then the necessary classes to support coupled spin algebra.

Jeremias Yehdegho - Implementing F5, mentored by Mateusz Paprocki
Jeremias worked on implementing algorithms related to Groebner bases. Groebner bases are a useful tool in many areas of computer algebra. He implemented the F5B algorithm, which is an improved version of the classical Buchberger’s algorithm that was previously implemented in SymPy, and an algorithm for converting Groebner bases between different orders of monomials and worked on applications of Groebner bases. This allowed for handling problems of much larger size in SymPy.

The full report can be found here, where each student wrote a wiki page about their experience during the summer and you can also find their blogs and links to applications. Each student was required to blog about their progress each week and all blogs were synchronized at planet.sympy.org.

In previous years, there was usually one student from each summer who became a regular contributor and also a mentor for the next year. It has been a rewarding experience for the whole SymPy community.

SymPy 0.7.1 Released

2011-07-29T22:11:00.000-07:00

SymPy 0.7.1 has been released on July 29, 2011. It is available at

http://sympy.org

The source distribution can be downloaded from:
http://code.google.com/p/sympy/downloads/detail?name=sympy-0.7.1.tar.gz

You can get the Windows installer here:
http://code.google.com/p/sympy/downloads/detail?name=sympy-0.7.1.win32.exe

And the html documentation here:
http://code.google.com/p/sympy/downloads/detail?name=sympy-0.7.1-docs-html.zip

About SymPy

SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python.

Release notes

Major changes

- Python 2.4 is no longer supported. SymPy will not work at all in
Python 2.4. If you still need to use SymPy under Python 2.4 for some
reason, you will need to use SymPy 0.7.0 or earlier.

- The Pyglet plotting library is now an (optional) external dependency.
Previously, we shipped a version of Pyglet with SymPy, but this was
old and buggy. The plan is to eventually make the plotting in SymPy
much more modular, so that it supports many backends, but this has not
been done yet. For now, still only Pyglet is directly supported.
Note that Pyglet is only an optional dependency and is only needed for
plotting. The rest of SymPy can still be used without any dependencies
(except for Python).

- isympy now works with the new IPython 0.11.

- mpmath has been updated to 0.17. See the corresponding mpmath release
notes at http://mpmath.googlecode.com/svn/trunk/CHANGES.

- Added a Subs object for representing unevaluated substitutions. This
finally lets us represent derivatives evaluated at a point, i.e.,
`diff(f(x), x).subs(x, 0)` returns `Subs(Derivative(f(_x), _x), (_x,), (0,))`.
This also means that SymPy can now correctly compute the chain rule
when this functionality is required, such as with `f(g(x)).diff(x)`.

Hypergeometric functions/Meijer G-Functions

- Added classes hyper() and meijerg() to represent Hypergeometric and Meijer G-functions, respectively. They support numerical evaluation (using mpmath) and symbolic differentiation (not with respect to the parameters).

- Added an algorithm for rewriting hypergeometric and meijer g-functions in terms of more familiar, named special functions. It is accessible via the function hyperexpand(), or also via expand_func(). This algorithm recognises many elementary functions, and also complete and incomplete gamma functions, bessel functions, and error functions. It can easily be extended to handle more classes of special functions.

Sets

- Added FiniteSet class to mimic python set behavior while also interacting with existing Intervals and Unions

- FiniteSets and Intervals interact so that, for example `Interval(0, 10) - FiniteSet(0, 5)` produces `(0, 5) U (5, 10]`

- FiniteSets also handle non-numerical objects so the following is possible `{1, 2, 'one', 'two', {a, b}}`

- Added ProductSet to handle Cartesian products of sets

- Create using the `*` operator, i.e. `twodice = FiniteSet(1, 2, 3, 4, 5, 6) * FiniteSet(1, 2, 3, 4, 5, 6) or square = Interval(0, 1) * Interval(0, 1)`

- pow operator also works as expected: `R3 = Interval(-oo, oo)**3 ; (3, -5, 0) in R3 == True`

- Subtraction, union, measurement all work taking complex intersections into account.

- Added as_relational method to sets, producing boolean statements using And, Or, Eq, Lt, Gt, etc...

- Changed reduce_poly_inequalities to return unions of sets rather than lists of sets

Iterables

- Added generating routines for integer partitions and binary partitions. The routine for integer partitions takes 3 arguments, the number itself, the maximum possible element allowed in the partitions generated and the maximum possible number of elements that will be in the partition. Binary partitions are characterized by containing only powers of two.

- Added generating routine for multi-set partitions. Given a multiset, the algorithm implemented will generate all possible partitions of that multi-set.

- Added generating routines for bell permutations, derangements, and involutions. A bell permutation is one in which the cycles that compose it consist of integers in a decreasing order. A derangement is a permutation such that the ith element is not at the ith position. An involution is a permutation that when multiplied by itself gives the identity permutation.

- Added generating routine for unrestricted necklaces. An unrestricted necklace is an a-ary string of n characters, each of a possible types. These have been characterized by the parameters n and k in the routine.

- Added generating routine for oriented forests. This is an implementation of algorithm S in TAOCP Vol 4A.

xyz Spin bases

- The represent, rewrite and InnerProduct logic has been improved to work between any two spin bases. This was done by utilizing the Wigner-D matrix, implemented in the WignerD class, in defining the changes between the various bases. Representing a state, i.e. `represent(JzKet(1,0), basis=Jx)`, can be used to give the vector representation of any get in any of the x/y/z bases for numerical values of j and m in the spin eigenstate. Similarly, rewriting states into different bases, i.e. `JzKet(1,0).rewrite('Jx')`, will write the states as a linear combination of elements of the given basis. Because this relies on the represent function, this only works for numerical j and m values. The inner product of two eigenstates in different bases can be evaluated, i.e. `InnerProduct(JzKet(1,0),JxKet(1,1))`. When two different bases are used, one state is rewritten into the other basis, so this requires numerical values of j and m, but innerproducts of states in the same basis can still be done symbolically.

- The `Rotation.D` and `Rotation.d` methods, representing the Wigner-D function and the Wigner small-d function, return an instance of the WignerD class, which can be evaluated with the `doit()` method to give the corresponding matrix element of the Wigner-D matrix.

Other changes

- We now use MathJax in our docs. MathJax renders LaTeX math entierly in
the browser using Javascript. This means that the math is much more
readable than the previous png math, which uses images. MathJax is
only supported on modern browsers, so LaTeX math in the docs may not
work on older browsers.

- nroots() now lets you set the precision of computations

- Added support for gmpy and mpmath's types to sympify()

- Fix some bugs with lambdify()

- Fix a bug with as_independent and non-commutative symbols.

- Fix a bug with collect (issue 2516)

- Many fixes relating to porting SymPy to Python 3. Thanks to our GSoC
student Vladimir Perić, this task is almost completed.

- Some people were retroactively added to the AUTHORS file.

- Added a solver for a special case of the Riccati equation in the ODE
module.

- Iterated derivatives are pretty printed in a concise way.

- Fix a bug with integrating functions with multiple DiracDeltas.

- Add support for Matrix.norm() that works for Matrices (not just vectors).

- Improvements to the Groebner bases algorithm.

- Plot.saveimage now supports a StringIO outfile

- Expr.as_ordered_terms now supports non lex orderings.

- diff now canonicalizes the order of differentiation symbols. This is
so it can simplify expressions like `f(x, y).diff(x, y) - f(x,
y).diff(y, x)`. If you want to create a Derivative object without
sorting the args, you should create it explicitly with `Derivative`,
so that you will get `Derivative(f(x, y), x, y) != Derivative(f(x, y), y, x)`.
Note that internally, derivatives that can be computed are always
computed in the order that they are given in.

- Added functions `is_sequence()` and `iterable()` for determining if
something is an ordered iterable or normal iterable, respectively.

- Enabled an option in Sphinx that adds a `source` link next to each function, which links to a copy of the source code for that function.

In addition to the more noticeable changes listed above, there have been numerous other smaller additions, improvements and bug fixes in the ~300 commits in this release. See the git log for a full list of all changes. The command `git log sympy-0.7.0..sympy-0.7.1` will show all commits made between this release and the last. You can also see the issues closed since the last release [here](http://code.google.com/p/sympy/issues/list?can=1&q=closed-after%3A2010%2F6%2F13+closed-before%3A2011%2F7%2F30&sort=-closed&colspec=ID+Type+Status+Priority+Milestone+Owner+Summary+Stars+Closed&cells=tiles).

Authors

The following people contributed at least one patch to this release (names are given in alphabetical order by last name). A total of 26 people contributed to this release. People with a * by their names contributed a patch for the first time for this release. Five people contributed for the first time for this release.

Thanks to everyone who contributed to this release!

* Tom Bachmann
* Ondřej Čertík
* Renato Coutinho
* Bill Flynn
* Bradley Froehle*
* Gilbert Gede
* Brian Granger
* Emma Hogan*
* Yuri Karadzhov
* Stefan Krastanov*
* Ronan Lamy
* Tomo Lazovich
* Sam Magura*
* Saptarshi Mandal
* Aaron Meurer
* Sherjil Ozair
* Mateusz Paprocki
* Vladimir Perić
* Mario Pernici
* Nicolas Pourcelot
* Min Ragan-Kelley*
* Matthew Rocklin
* Chris Smith
* Vinzent Steinberg
* Sean Vig
* Thomas Wiecki

SymPy 0.7.0 released

2011-06-29T00:46:00.000-07:00

SymPy 0.7.0 has been released on June 28, 2011. It is available at

http://sympy.org

The source distribution can be downloaded from:
http://code.google.com/p/sympy/downloads/detail?name=sympy-0.7.0.tar.gz

You can get the Windows installer here:
http://code.google.com/p/sympy/downloads/detail?name=sympy-0.7.0.win32.exe

And the html documentation here:
http://code.google.com/p/sympy/downloads/detail?name=sympy-0.7.0-docs-html.zip

About SymPy

SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python.

Changes since last stable release

(from https://github.com/sympy/sympy/wiki/Release-Notes-for-0.7.0)

Backwards compatibility breaks

This will be the last release of SymPy to support Python 2.4. Dropping support for Python 2.4 will let us move forward with things like supporting Python 3, and will let us use things that were introduced in Python 2.5, like with-statement context managers.
no longer support creating matrices without brackets (see: issue 930)
Renamed sum() to summation() (see: 3e763a8, issues 1376, 1727). This was changed so that it no longer overrides the built-in sum(). The unevaluated summation is still called Sum().
Renamed abs() to Abs() (see: 64a12a4, issue 1727). This was also changed so that it no longer overrides the built-in abs(). Note that because of __abs__ magic, you can still do abs(expr) with the built-in abs(), and it will return Abs(expr).
Renamed max_() and min_() to now Max() and Min() (see: 99a271e, issue 2153)
Changed behaviour of symbols(). symbols('xyz') gives now a single symbol ('xyz'), not three ('x', 'y' and 'z') (see: f6452a8). Usesymbols('x,y,z') or symbols('x y z') to get three symbols. The 'each_char' option will still work but is being deprecated.
Split class Basic into new classes Expr, Boolean (see: a0ab479, 635d89c). Classes that are designed to be part of standard symbolic expressions (like x**2*sin(x)) should subclass from Expr. More generic objects that do not work in symbolic expressions but still want the basic SymPy structure like .args and basic methods like .subs() should only subclass from Basic.
as_basic() method was renamed to as_expr() to reflect changes in the core (see: e61819d, 80dfe91)
Methods as_coeff_terms and as_coeff_factors were renamed to as_coeff_mul and as_coeff_add, respectively.
Removed the trim() function. The function is redundant with the new polys (see below). Use the cancel() function instead.
Major Changes
Polys
New internal representations of dense and sparse polynomials (see: 6aecdb7, 31c9aa4)
Implemented algorithms for real and complex root isolation and counting (see: 3acac67, 4b75dae, fa1206e, 103b928, 45c9b22, 8870c8b, b348b30)
Improved Gröbner bases algorithm (see: ff65e9f, 891e4de, 310a585)
Field isomorphism algorithm (see: b097b01, 08482bf)
Implemented efficient orthogonal polynomials (see: b8fbd59)
Added configuration framework for polys (see: 33d8cdb, 7eb81c9)
Function for computing minimal polynomials (see: 88bf187, f800f95)
Function for generating Viete's formulas (see: 1027408)
roots() supports more classes of polynomials (e.g. cyclotomic) (see: d8c8768, 75c8d2d)
Added a function for recognizing cyclotomic polynomials (see: b9c2a9a)
Added a function for computing Horner form of polynomials (see: 8d235c7)
Added a function for computing symmetric reductions of polynomials (see: 6d560f3)
Added generators of Swinnerton-Dyer, cyclotomic, symmetric, random and interpolating polynomials (see: dad03dd, 6ccf20c, dc728d6, 2f17684, 3004db8)
Added a function computing isolation intervals of algebraic numbers (see: 37a58f1)
Polynomial division (div(), rem(), quo()) now defaults to a field (see: a72d188)
Added wrappers for numerical root finding algorithms (see: 0d98945, f638fcf)
Added symbolic capabilities to factor(), sqf() and related functions (see: d521c7f, 548120b, f6f74e6, b1c49cd, 3527b64)
together() was significantly improved (see: dc327fe)
Added support for iterable containers to gcd() and lcm() (see: e920870)
Added a function for constructing domains from coefficient containers (see: a8f20e6)
Implemented greatest factorial factorization (see: d4dbbb5)
Added partial fraction decomposition algorithm based on undetermined coefficient approach (see: 9769d49, 496f08f)
RootOf and RootSum were significantly improved (see: f3e432, 4c88be6, 41502d7)
Added support for gmpy (GNU Multiple Precision Arithmetic Library) (see: 38e1683)
Allow to compile sympy.polys with Cython (see: afb3886)
Improved configuration of variables in Poly (see: 22c4061)
Added documentation based on Wester's examples (see: 1c23792)
Irreducibility testing over finite fields (see: 17e8f1f)
Allow symmetric and non-symmetric representations over finite fields (see: 60fbff4)
More consistent factorization forms from factor() and sqf() (see: 5df77f5)
Added support for automatic recognition algebraic extensions (see: 7de602c)
Implemented Collins' modular algorithm for computing resultants (see: 950969b)
Implemented Berlekamp's algorithm for factorization over finite fields (see: 70353e9)
Implemented Trager's algorithm for factorization over algebraic number fields (see: bd0be06)
Improved Wang's algorithm for efficient factorization of multivariate polynomials (see: 425e225)
Quantum
Symbolic, abstract dirac notation in sympy.physics.quantum. This includes operators, states (bras and kets), commutators, anticommutators, dagger, inner products, outer products, tensor products and Hilbert spaces
Symbolic quantum computing framework that is based on the general capabilities in sympy.physics.quantum. This includes qubits (sympy.physics.quantum.qubit), gates (sympy.physics.quantum.gate), Grover's algorithm (sympy.physics.quantum.grover), the quantum Fourier transform (sympy.physics.quantum.qft), Shor's algorithm (sympy.physics.quantum.shor) and circuit plotting (sympy.physics.quantum.circuitplot)
Second quantization framework that inclues creation/anihilation operators for both Fermions and Bosons and Wick's theorem for Fermions (sympy.physics.secondquant).
Symbolic quantum angular momentum (spin) algebra (sympy.physics.quantum.spin)
Hydrogen wave functions (Schroedinger) and energies (both Schroedinger and Dirac)
Wave functions and energies for 1D harmonic oscillator
Wave functions and energies for 3D spherically symmetric harmonic oscillator
Wigner and Clebsch Gordan coefficients
Everything else
Implement symarray, providing numpy nd-arrays of symbols.
update mpmath to 0.16
Add a tensor module (see: http://code.google.com/p/sympy/wiki/CodeGenerationReport)
A lot of stuff was being imported with from sympy import * that shouldn't have been (like sys). This has been fixed.
Assumptions:
Refine
Added predicates (see: 7c0b857, 53f0e1a, d1dd6a3..)
Added query handlers for algebraic numbers (see: f3bee7a)
Implement a SAT solver (see: http://code.google.com/p/sympy/wiki/SuperchargingAssumptionsReport, 2d96329, acfbe75, etc.)
Concrete
Finalized implementation of Gosper's algorithm (see: 0f187e5, 5888024)
Removed redundant Sum2 and related classes (see: ef1f6a7)
Core:
Split Atom into Atom and AtomicExpr (see: 965aa91)
Various sympify() improvements
Added functionality for action verbs (many functions can be called both as global functions and as methods e.g. a.simplify() == simplify(a))
Improve handling of rational strings (see: 053a045, issue 1778)
Major changes to factoring of integers (see: 273f450, issue 2003)
Optimized .has() (see: c83c9b0, issue 1980; d86d08f)
Improvements to power (see: c8661ef, issue 1963)
Added range and lexicographic syntax to symbols() and var() (see: f6452a8, 9aeb220, 957745a)
Added modulus argument to expand() (see: 1ea5be8)
Allow to convert Interval to relational form (see: 4c269fe)
SymPy won't manipulate minus sign of expressions any more (see: 6a26941, 9c6bf0f, e9f4a0a)
Real and .is_Real were renamed to Float and .is_Float. Real and .is_Real still remain as deprecated shortcuts to Float andis_Float for backwards compatibility. (see: abe1c49)
Methods coeff and as_coefficient are now non-commutative aware. (see a4ea170)
Geometry:
Various improvements to Ellipse
Updated documentation to numpy standard
Polygon and Line improvements
Allow all geometry objects to accept a tuple as Point args
Integrals:
Various improvements (see eg. issues 1772, 1999, 1992, 1987.. etc)
isympy
Fixed the -p switch (see: e8cb04a)
Caching can be disabled using -C switch (see: 0d8d748)
Ground types can be set using -t switch (see: 75734f8)
Printing ordering can be set using -o switch (see: fcc6b13, 4ec9dc5)
Logic
implies object adheres to negative normal form
Create new boolean class, logic.boolalg.Boolean
Added XOR operator (^) support
Added If-then-else (ITE) support
Added the dpll algorithm
Functions:
Added Piecewise, B-splines
Spherical Bessel function of the second kind implemented
Add series expansions of multivariate functions (see: d4d351d)
Matrices:
Add elementwise product (Hadamard product)
Extended QR factorization for general full ranked mxn matrices
Remove deprecated functions zero(), zeronm(), one() (see: 5da0884)
Added cholesky and LDL factorizations, and respective solves.
Added functions for efficient triangular and diagonal solves.
SMatrix was renamed to SparseMatrix (see: acd1685)
Physics
See the Quantum section
Printing:
Implemented pretty printing of binomials (see: 58c1dad)
Implemented pretty printing of Sum() (see: 84f2c22, 95b4321)
sympy.printing now supports ordering of terms and factors (see: 859bb33)
Lexicographic order is now the default. Now finally things will print as x**2 + x + 1 instead of 1 + x + x**2, however series still print using reversed ordering, e.g. x - x**3/6 + O(x**5). You can get the old order (and other orderings) by setting the -o option to isympy (see: 08b4932, a30c5a3)
Series:
Implement a function to calculate residues, residue()
Implement nseries and lseries to handle x0 != 0, series should be more robust now (see: 2c99999, issues 2122-2124)
Improvements to Gruntz algorithm
Simplify:
Added use() (see: 147c142)
ratsimp() now uses cancel() and reduced() (see: 108fb41)
Implemented EPath (see: 696139d, bf90689)
a new keyword rational was added to nsimplify which will replace Floats with Rational approximations. (see: 053a045)
Solvers:
ODE improvements (see: d12a2aa, 3542041; 73fb9ac)
Added support for solving inequalities (see: 328eaba, 8455147, f8fcaa7)
Utilities:
Improve cartes, for generating the Cartesian product (see: b1b10ed)
Added a function computing topological sort of graphs (see: b2ce27b)
Allow to setup a customized printer in lambdify() (see: c1ad905)
flatten() was significantly improved (see: 31ed8d7)
Major improvements to the Fortran code generator (see: http://code.google.com/p/sympy/wiki/CodeGenerationReport, 3383aa3, 7ab2da2, etc.)
In addition to the more noticeable changes listed above, there have been numerous other smaller additions, improvements and bug fixes in the ~2000 commits in this release. See the git log for a full list of all changes. The command git log sympy-0.6.7..sympy-0.7.0 will show all commits made between this release and the last. You can also see the issues closed since the last release here.
Authors
The following people contributed at least one patch to this release (names are given in alphabetical order by last name). A total of 64 people contributed to this release. People with a * by their names contributed a patch for the first time for this release. Thirty-seven people contributed for the first time for this release. Over half of the people who contributed to this release contributed for the first time!
Thanks to everyone who contributed to this release!
Tom Bachmann*
Tomas Bambas*
Matthew Brett*
Ondřej Čertík
Renato Coutinho
Addison Cugini*
Matt Curry*
Raffaele De Feo*
Mark Dewing
Thomas Dixon*
Harold Erbin
Pavel Fedotov*
Gilbert Gede*
Oleksandr Gituliar*
Brian Granger
Alexey U. Gudchenko*
Øyvind Jensen
Fredrik Johansson
Felix Kaiser
Yuri Karadzhov*
Gary Kerr*
Kibeom Kim*
Nicholas J.S. Kinar*
Anatolii Koval*
Sebastian Krämer
Ryan Krauss
Gregory Ksionda*
Priit Laes
Vladimir Lagunov
Ronan Lamy
Tomo Lazovich*
Saptarshi Mandal*
David Marek
Jack McCaffery*
Benjamin McDonald*
Aaron Meurer
Christian Muise*
Óscar Nájera*
Jezreel Ng*
Sherjil Ozair*
Mateusz Paprocki
James Pearson
Fernando Perez
Vladimir Perić*
Mario Pernici*
Nicolas Pourcelot
rayman*
Matthew Rocklin*
Christian Schubert
Andre de Fortier Smit*
Chris Smith
Cristóvão Sousa*
Akshay Srinivasan
Vinzent Steinberg
Prafullkumar P. Tale*
Andy R. Terrel
Kazuo Thow*
Toon Verstraelen
Sean Vig*
Luca Weihs*
Thomas Wiecki
Shai 'Deshe' Wyborski*
Jeremias Yehdegho*

Accepted GSoC Students Announced

2011-04-27T12:41:00.000-07:00

So Google has announced the results of Google Summer of Code. I am proud to announce that we got nine slots from Google. The following projects have been accepted:

(Project, Student, Mentor, Link to proposal on the wiki)

Definite Integration using Meijer G-functions, Tom Bachmann, Aaron Meurer, Proposal
PyDy, Gilbert Gede, Luke Peterson, Proposal
Position and Momentum Bases for Quantum Mechanics, Tomo Lazovich, Brian Granger, Proposal
Combinatorics package for Sympy, Saptarshi Mandal, Christian Muise, Proposal
Symbolic Linear Algebra, Sherjil Ozair, Vinzent Steinberg, Proposal
Porting to Python 3, Vladimir Perić, Ronan Lamy, Proposal
SymPy Stats: Random Variables, Matthew Rocklin, Andy Terrel, Proposal
Symbolic Clebsch-Gordon coefficients/Wigner symbols and Implementing Addition of Spin Angular Momenta, Sean Vig, Ondřej Čertík, Proposal
Implementing F5, Jeremias Yehdegho, Mateusz Paprocki, Proposal

Join me in congratulating these students on their acceptance.

In case you don't know for some reason, Google Summer of Code is a program where Google pays students to write code for open source projects. SymPy was accepted as a mentoring organization this year. The goal of the summer is to help the students learn new skills, in particular in our case:

contributing to open source
working with the community
learn git, pull requests, reviews
teach them how to review other's people patches
do useful work for SymPy
have fun, and encourage the students to stay around

Also see the previous blog post about it.

SymPy is a Google Summer of Code 2011 Mentoring Organization

2011-03-18T20:12:00.001-07:00

I am proud to announce that SymPy has been accepted as a mentoring organization for Google Summer of Code 2011. This is great news for the project. Although we have participated in the past under the umbrella of the Python Software Foundation and Portland State University mentoring organizations, this is the first time that we have been accepted as a mentoring organization. Out of 417 organizations that applied to Google, 175 were accepted, 50 of which were new.

In case you don't know, Google Summer of Code is a program run by Google every year where they pay college students all around the world to write code for open source projects. Each student has a mentor assigned to him/her, who helps the student get started with interacting with open source (most students who are accepted have never participated in open source before).

So now that were are accepted, students are open to applications. The actual application period opens on March 28, and closes on April 8 (see the program timeline).

To students:

If you are interested in applying, please write the to mailing list and introduce yourself. The program is open to anyone worldwide who is 18 years of age or older who is enrolled in a higher education institution (this includes undergraduate and graduate). If you are interested in applying, here is what you should do (if you have not already):

- As I said above, write to the list and introduce yourself. You might also join our IRC channel, which is #sympy on freenode.

- Start thinking about what you want to apply to do. See our ideas page. However, we are open to ideas that are not on that page. Anything that fits in a computer algebra system would fit in SymPy. If you have an idea not on that page, please discuss it on our mailing list, so we can see if it has not already be implemented, and if it is fitting for SymPy and for a project. I recommend you apply to do something that you are interested in personally.

- We require for any student to be accepted that he/she submit at least one patch to SymPy, which gets reviewed and pushed in. See issues labeled EasyToFix in our issue tracker for some easy to fix issues that are a good place to start. Don't worry if you do not know how to send in a patch or use git. We will help you (that is the whole point of the program). Just ask on the mailing list, on the issue page, or on IRC.

- You should start thinking about your application. See our application template (it will also be at our page on the Google site). If you like, you can start a page on our wiki to write your proposal. If you do this, we will help you edit it (though understand that we will not help you write it). Remember that we want you to get accepted just as much as you do, so you can help improve SymPy!

To SymPy developers:

- We need people who are willing to mentor students. If you are willing to mentor, please add your name to the bottom of the ideas page.

- Please edit the ideas page to improve formatting and add new ideas.

Good luck to all students who plan on applying!

SymPy 0.6.6 released

2009-12-28T13:23:00.000-08:00

SymPy 0.6.6 has been released on December 20, 2009. It is available at

http://sympy.org

The source distribution can be downloaded from:
http://sympy.googlecode.com/files/sympy-0.6.6.tar.gz

You can get the Windows installer here:
http://sympy.googlecode.com/files/sympy-0.6.6.win32.exe

And the html documentation here:
http://sympy.googlecode.com/files/sympy-0.6.6-docs-html.zip

About SymPy

SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python.

Changes since last stable release

many documentation improvements, including docstrings and doctests
new assumptions system (GSoC) (See assumptions documentation for more information or have a look at Fabian's blog.)

Note: This is going to replace the old assumption system. It is encouraged to use it for new code, however it is not completely finished and parts of sympy have yet to be rewritten to use it; this scheduled for the 0.7 release.

improvements to test runner
printing improvements (especially LaTeX, but also mathml and pretty printing)
discriminant of polys
block diagonal methods for matrices
vast improvements to solving of ODEs (GSoC) (See ODE documentation for full details or Aaron's blog).
logcombine function
improvements to sets
better trigonometric simplification
improvements to piecewise functions
improvements to solve() and nsolve()
improvements to as_numer_denom()
much better quartic and cubic polynomial rootfinding
code refactoring and cleanup
physics: coupled clusters and wick expansion
matrices: symbolic QR solving
mpmath updated
pyglet updated
many, many bug fixes and small improvements

The following 22 people have contributed patches to this release (sorted alphabetically):

Aaron Meurer
Alan Bromborsky
Andy R. Terrel
Bill Flynn
Chris Smith
Eh Tan
Fabian Pedregosa
Fredrik Johansson
Jorn Baayen
Julio Idichekop Filho
Kevin Goodsell
Łukasz Pankowski
Luke Peterson
Øyvind Jensen
Ondrej Certik
Oscar Benjamin
Priit Laes
Renato Coutinho
Ronan Lamy
Ryan Krauss
Ted Horst
Toon Verstraelen
Vinzent Steinberg

The following 10 people helped reviewing patches:

Aaron Meurer
Andy R. Terrel
Chris Smith
Fabian Pedregosa
Fredrik Johansson
Luke Peterson
Mateusz Paprocki
Ondrej Certik
Ronan Lamy
Vinzent Steinberg

SymPy 0.6.5 released

2009-07-16T15:01:00.000-07:00

SymPy 0.6.5 has been released on July 17, 2009. It is available at

http://sympy.org

Source distribution can be downloaded from
http://sympy.googlecode.com/files/sympy-0.6.5.tar.gz

Windows binaries can be downloaded from
http://sympy.googlecode.com/files/sympy-0.6.5.win32.exe

About SymPy

SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python and does not require any external libraries.

Changes since last stable release

This release has been marked by improved documentation,
C code generation, solve and dsolve improvements, mpath update, a new
logic module and the start of Google's Summer of Code program.

Major changes include:

- Geometric Algebra Improvements
- Upgrade GA module with left and right contraction operations
- Add intersection test for the vertical segment,
reimplementation of convex_hull (Florian Mickler)

- Implement series() as function (Barry Wardell)

- Core improvements
- Refactor Number._eval_power (Fabian Pedregosa)
- fix bugs in Number._eval_power (Chris Smith)

- Matrix improvements:
- Improve jacobian function, introduce vec and vech (Ben
Goodrich)

- Solver improvements:
- solutions past linear factor found in tsolve (Chris Smith)
- refactor sympy.solvers.guess_solve_strategy (Fabian Pedregosa)
- Small cleanups to the ODE solver and tests. (Priit Laes)
- Fix corner case for Bernoulli equation. (Priit Laes)

- Improvements on partial differential equations solvers (Priit
Laes)
- Added separation of variables for PDEs (Priit Laes)

- Expand improvements (Aaron Meurer)
- Refactoring
- exp(x)*exp(y) is no longer automatically combined into
exp(x+y), use powsimp for that

- Documentation improvements:
- Test also documentation under doc/ (Fabian Pedregosa)
- Added many docstrings
- Fix Sphinx complaints/warnings/errors (Priit Laes)
- Doctest coverage (Ondrej Certik)

- New logic module (Fabian Pedregosa)
- Efficient DPLL algorithm (Fabian Pedregosa)

- LaTeX printer improvements:
- Handle standard form in the LaTeX printer correctly (Freddie
Witherde)
- Latex: _print_Mul fix (issue 1282) (Nicolas Pourcelot)
- Robust printing of latex sub and superscripts (Toon Verstraelen)
- sorting _print_Add output using a main variable (Ryan Krauss)
- Matrix printing improvements (Ryan Krauss)

- MathML printing improvements:
- MathML's printer extended (Thomas Sidoti)

- Testing framework improvements
- Make tests pass without the "py" module (Ondrej Certik)

- Polynomial module improvements:
- Fixed subresultant PRS computation and ratint() (Mateusz
Paprocki)
- Removed old module sympy.polynomials (Priit Laes)

- limit fixes:
Compute the finite parts of the limit of a sum by direct
substitution (Ronan Lamy)

- Test coverage script (Ronan Lamy)

- Code quality improvements (remove string exceptions, code quality
test improvements) (Tomasz Buchert)

- C code generation (Toon Verstraelen)

- Update mpmath (Fredrik Johansson, Vinzent Steinberg)

The following people submitted code for this release (sorted by number
of patches):

* Fabian Pedregosa
* Ondrej Certik
* Priit Laes
* Vinzent Steinberg
* Toon Verstraelen
* Tomasz Buchert
* Nicolas Pourcelot
* Aaron Meurer
* Florian Mickler
* Jochen Voss
* Alan Bromborsky
* Barry Wardell
* Riccardo Gori
* Chris Smith
* Freddie Witherden
* Ben Goodrich
* Ronan Lamy
* Akshay Srinivasan
* Johann Cohen-Tanugi
* Luke Peterson
* Mateusz Paprocki
* Ted Horst
* Thomas Sidoti
* Vinay Kumar

SymPy 0.6.4 released

2009-04-05T01:12:00.000-07:00

SymPy 0.6.4 has been released on April 4, 2009. It is available at

http://code.google.com/p/sympy/

About SymPy

SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python and does not require any external libraries.

Major changes in this release:

robust and fast (still pure Python) multivariate factorization
sympy works with pickle protocol 2 (thus works in ipython parallel)
./sympy test now uses our testing suite and it tests both regular tests and doctests
examples directory tidied up
more trigonometric simplifications
polynomial roots finding and factoring vastly improved
mpmath updated
many bugfixes (more than 200 patches since the last release)

The following 21 people have contributed patches to this release (sorted by the number of patches):

Ondrej Certik
Mateusz Paprocki
Fabian Seoane
Andy R. Terrel
Freddie Witherden
Robert Kern
Priit Laes
Riccardo Gori
Fredrik Johansson
Aaron Meurer
Alan Bromborsky
Brian E. Granger
Felix Kaiser
Kirill Smelkov
Vinzent Steinberg
Akshay Srinivasan
Andrew Docherty
Andrew Straw
Henrik Johansson
Kaifeng Zhu
Ted Horst

The following people helped review patches:

Riccardo Gori
Fabian Seoane
Vinzent Steinberg
Gael Varoquaux
Fredrik Johansson
Robert Kern
Alan Bromborsky
Ondrej Certik

There were 218 new patches since 0.6.3:

$ git log --pretty=oneline sympy-0.6.3..sympy-0.6.4 | wc -l
218

Plans for the future:

Our roadmap: http://wiki.sympy.org/wiki/Plan_for_SymPy_1.0

SymPy 0.6.3 released

2008-11-19T14:07:00.000-08:00

SymPy 0.6.3 has been released on November 19, 2008. It is available at

http://code.google.com/p/sympy/

About SymPy

SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python and does not require any external libraries.

Major changes in this release:

port to python2.6 (all tests pass)
port to jython (all tests pass except those depending on the "ast" module)
true division fixed (all tests pass with "-Qnew" Python option)
buildbot.sympy.org created, sympy is now regularly tested on python2.4, 2.5, 2.6 on both i386 and amd64 architectures.
py.bench -- py.test based benchmarking added
bin/test -- simple py.test like testing framework, without external dependencies, nice colored output
most limits now work
factorization over Z[x] greatly improved
Piecewise function added
nsimplify() implemented
symbols and var syntax unified
C code printing
many bugfixes

The following 17 people have contributed patches to this release:

Andy R. Terrel
Kirill Smelkov
Stepan Roucka
Riccardo Gori
Fabian Seoane
Fredrik Johansson
Mateusz Paprocki
Sebastian Kreft
Sebastian Krämer
Vinzent Steinberg
Boris Timokhin
Alan Bromborsky
Henrik Johansson
Hubert Tsang
Konrad Meyer
Robert (average.programmer)
Ondrej Certik

The following people helped review patches:

Andy R. Terrel
Riccardo Gori
Fredrik Johansson
Vinzent Steinberg
Fabian Seoane
Kirill Smelkov
Sebastian Krämer
Mateusz Paprocki
Stepan Roucka
Friedrich Hagedorn
Brian Granger
Ondrej Certik

There were 256 new patches since 0.6.2:

$ git log --pretty=oneline sympy-0.6.2..sympy-0.6.3 | wc -l
258

Plans for the future:

Our roadmap: http://wiki.sympy.org/wiki/Plan_for_SymPy_1.0

The last big missing piece of the puzzle are assumptions, that we are implementing in the issue 1047. Besides that we should port sympy to Python 3.0, add more tests to our buildbot and start using the pure Python mode in Cython to speed SymPy up using ideas from sympyx (sympy core written in Cython). And improve our documentation continuously.

SymPy 0.6.2 released

2008-08-17T13:58:00.000-07:00

SymPy 0.6.2 has been released on August 17, 2008. It is available at

http://code.google.com/p/sympy/

About SymPy

SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python and does not require any external libraries.

user-visible changes:

SymPy is now 50% faster on average (cache:on) and 130% (cache:off) compared to previous release.
adaptive and faster evalf() (commit 1, 2, 3, 4, 5)
evalf: numerical summation of hypergeometric series (commit)
evalf: fast and accurate numerical summation (commit 1, 2, 3)
evalf: oscillatory quadrature (commit)
integrals now support variable transformation (commit)
we can now integrate(f(x)⋅diff(f(x),x), x) (commit 1, 2, 3)
we can now solve a⋅cos(x)=y (comit) and exp(x)+exp(-x)=y (commit 1, 2)
printing system refactored (commit 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)
pprint: new symbol for multiply in unicode mode(x*y -> x⋅y) (commit)
pprint: matrices now look much better (commit) + example (commit 1, 2)
printing of dicts and sets are now more human-friendly (commit 1, 2, 3, 5)
latex: now supports sub- and superscripts in symbol names (commit)
RootSum.doit, now works on all roots (commit)
Wild can now have additional predicates (commit)
numpy-like zeros and ones functions (commit 1, 2, 3, 4)
var('x,y,z') now works (commit)
many bug fixes

changes that affected speed:

((x+y+z)**50).expand() is now 4.8x faster (commit 1, 2 + other commits which all summed up)
big assumptions cleanup and rewrite (commit1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25)
access to all object attributes is now ~2.5 times faster (commit)
we try not to let 'is_commutative' to go through (slow) assumptions path (commit 1, 2)
Add/Mul were optimized (for some cases significantly) (commit 1, 2, 3, 4, 5, 6)

general cleanup:

isympy and sympy.interactive code were merged (commit)
multiple inheritance removed (NoArithMeths, NoRelMeths, RelMeths, ArithMeths are gone) (commit 1, 2, 3, 4, 5, 6)
.nseries() is now used as default in .series()
doctesting was made more robust (commit 1, 2, 3, 4, 5)

The following 11 people have contributed patches to this release:

Sebastian Krämer
Fredrik Johansson
Ondřej Čertík
Mateusz Paprocki
Stefano Maggiolo
Robert Cimrman
Sebastian Krause
Bastian Weber
Sebastian Kreft
Štěpán Roučka
Kirill Smelkov

The following people helped review patches:

Riccardo Gori
Fredrik Johansson
Kirill Smelkov
Ondřej Čertík
Mateusz Paprocki

Other news: we wrote a new core sympyx in Cython that is an order of magnitude faster than the current SymPy, yet it uses the same architecture, so it's our priority now to merge it back and then gradualy speedup things, so that SymPy is as fast as any other symbolic package.

SymPy will remain pure Python by default, but it will be possible to use Cythonized core optionally to gain speed.

SymPy 0.6.1 released

2008-07-22T13:48:00.000-07:00

SymPy 0.6.1 has been released on July 22, 2008. It is available at

http://code.google.com/p/sympy/

About SymPy

SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python and does not require any external libraries.

user-visible changes:

almost all functions and constants can be converted to Sage (commit 1, 2)
univariate factorization algorithm was fixed (commit)
.evalf() method fixed, pi.evalf(106) calculates 1 000 000 digits of pi (commit 1)
@threaded decorator (commit 1, 2, 3)
more robust solvers, polynomials and simplification (about 60 patches from Mateusz, see the hg history)
better simplify, that makes a solver more robust (commit)
optional compiling of functions to machine code (commit)
msolve: solving of nonlinear equation systems using Newton's method (commit)

changes that affected speed:

((x+y+z)**50).expand() is now 3 times faster (commit)
caching was removed from the Order class: 1.5x speedups in series tests (commit 1, 2, 3, 4, 5)

The following 8 people have contributed patches to this release:

Mateusz Paprocki
Vinzent Steinberg
Fredrik Johansson
Riccardo Gori
Kirill Smelkov
Štěpán Roučka
Ali Raza Syed
Ondřej Čertík

The following people helped review patches:

Riccardo Gori
Fredrik Johansson
Kirill Smelkov
Ondřej Čertík
Mateusz Paprocki

See our hg history for all patches. In the 0.6.x series we concentrate on much better integration with Sage and NumPy. And also improving our docs. See our roadmap:

http://wiki.sympy.org/wiki/Plan_for_SymPy_1.0

SymPy will remain pure Python by default, but for people that do install additional packages, SymPy should be able to use them. Currently SymPy can already use gmpy, NumPy and compile functions to machine code using tcc.

SymPy 0.6.0 released

2008-07-08T10:23:00.000-07:00

SymPy 0.6.0 has been released on July 7, 2008. It is available at

http://code.google.com/p/sympy/

About SymPy

SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python and does not require any external libraries.

user-visible changes:

all documentation wiki pages moved to docs.sympy.org
mpmath was integrated in SymPy, numerics module removed
mpmath can use gmpy optionally, thus calculating 1000000 digits of pi in 7.5s
Common subexpression elimination implemented (commit 1, 2, 3, 4), see docs
roots, RootsOf, RootSum implemented (commit)
lambdify() now accepts Matrices (commit)
Matrices polished and spedup (commit 1, 2, 3, 4, 5, 6, 7, 8, 9)
source command implemented (commit 1, 2)
Polys were made the default polynomials in SymPy (commit 1, + many following commits)
Add, Mul, Pow now accept evaluate=False argument (commit)

Plus a lot of smaller bugfixes, you can browse our Mercurial history for details.

We have consolidated and improved all our docs, you can find it in the package and also online here:

http://docs.sympy.org/

and we also created a road map for the future releases of SymPy:

http://wiki.sympy.org/wiki/Plan_for_SymPy_1.0

As you can see, we have finally moved from the 0.5.0 era by consolidating the docs and you can read there what is planned for the 0.6.0 series and further.

The following 12 people have contributed patches to this release:

Mateusz Paprocki
Fredrik Johansson
Robert Kern
Riccardo Gori
Sebastian Krämer
Case Van Horsen
Vinzent Steinberg
Roberto Nobrega
Friedrich Hagedorn
David Roberts
Kirill Smelkov
Ondrej Certik

Many thanks to all of you who helped review patches:

Kirill Smelkov
Mateusz Paprocki
Robert Kern
Vinzent Steinberg
Fredrik Johansson
Sebastian Krämer

And all the others who helped on our mailinglists.

We welcome any comments, questions, bug reports, patches. Any contribution you do is very useful.

You can also read Fredrik's progress on his GSoC project here:

http://planet.sympy.org/

there are a lot of interesting posts.

SymPy 0.5.15 released

2008-05-24T12:24:00.000-07:00

SymPy 0.5.15 has been released on May 24, 2008. It is available at

http://code.google.com/p/sympy/

About SymPy

SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python and does not require any external libraries.

user-visible changes:

all SymPy functions support vector arguments, e.g. sin([1, 2, 3]) (commit 1, 2)
lambdify can now use numpy/math/mpmath (1, 2, 3)
the order of lambdify arguments has changed (commit)
all SymPy objects are pickable (commit 1, 2, 3)
simplify improved and made more robust (commit)
broken limit_series was removed, we now have just one limit implementation (commit 1, 2, 3)
limits now use .nseries (commit)
.nseries() improved a lot (commit 1, 2, 3)
Polys improved (commit)
Basic kronecker delta and Levi-Civita implementation (commit)

Plus a lot of smaller bugfixes, you can browse our Mercurial history for details.

Apart from the actual code, we have also launched an online SymPy shell:

http://live.sympy.org/

The following 8 people have contributed patches to this release:

Sebastian Krämer
Friedrich Hagedorn
Mateusz Paprocki
Saroj Adhikari
Vinzent Steinberg
David Roberts
Nimish Telang
Ondřej Čertík

SymPy 0.5.14 released

2008-04-26T14:50:00.000-07:00

SymPy 0.5.14 has been released on April 26, 2008. It is available at

http://code.google.com/p/sympy/

About SymPy

SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python and does not require any external libraries.

user-visible changes:

SymPy is now 25% faster on average compared to the previous release (see below)
Documentation was improved a lot (commit 1, 2, 3). See http://docs.sympy.org/
rsolve_poly & rsolve_hyper fixed (commit 1, 2)
subs and subs_dict unified to .subs() (commit 1, 2)
faster and more robust polynomials module (commit 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, ..., look into the hg history)
improved Matrix.det(), implemented Berkowitz algorithm (commit 1, 2)
improved isympy (interactive shell for SymPy) (commit 1, 2, 3, 4, 5, 6)
pretty-printing improved (commit 1, 2, 3)
Rel, Eq, Ne, Lt, Le, Gt, Ge implemented (commit 1)
Limit class represents unevaluated limits now (commit 1)
Bailey-Borwein-Plouffe algorithm (finds the nth hexidecimal digit of pi without calculating the previous digits) implemented (commit 1)
solver for transcendental equations added (commit 1)
.nseries() methods implemented (more robust/faster than .oseries) (commit 1, 2)
multivariate Lambdas implemented (commit 1)

changes that affected speed:

__eq__/__ne__/__nonzero__ returns True/False directly so dict lookups are not expensive anymore (commit 1, 2, 3, 4, 5, 6)
sum(x**i/i,i=1..400) is now 4.8x faster (commit 1, 2, 3, 4, 5)
isinstance(term, C.Mul) was replaced by term.is_Mul and similarly for other basic classes (commit 1, 2)

Plus a lot of smaller bugfixes, you can browse our Mercurial history for details.

This release contains patches from 15 developers, which is so far the highest number of people/release (33 people have sent patches to SymPy so far, see the list of contributors):

Mateusz Paprocki
Fredrik Johansson
James Aspnes
Friedrich Hagedorn
Pan Peng
Abderrahim Kitouni
Nimish Telang
Jurjen N.E. Bos
Elrond der Elbenfuerst
Rizgar Mella
Felix Kaiser
Roberto Nobrega
David Roberts
Ondřej Čertík
Kirill Smelkov

If you'd like to contribute too, you can browse our open issues here:

http://code.google.com/p/sympy/issues/list

and then we suggest you to read the SymPy Patches Tutorial, that explains how to work with Mercurial effectively and how to create and send patches easily (not only) to SymPy. Any contribution is welcome, be it documentation, code, or just hanging out on our mailinglist or IRC (#sympy at freenode).

SymPy 0.5.13 released

2008-03-06T14:57:00.000-08:00

It took us a little longer to release, so we have a longer changelog this time:

user-visible changes:

SymPy is now 2x faster in average compared to the previous release (see below)
integrate() can handle most of the basic integrals now (commit)
interactive experience with isympy was improved through adding support for [], () and {} to pretty-printer, and switching to it as the default ipython printer (commit 1, 2, 3)
new trim() function to map all non-atomic expressions, ie. functions, derivatives and more complex objects, to symbols and remove common factors from numerator and denominator. also cancel() was improved (commit 1, 2)
.expand() for noncommutative symbols fixed (commit)
bug in (x+y+sin(x)).as_independent() fixed (commit)
.subs_dict() improved (commit)
support for plotting geometry objects added (commit)
bug in .tangent_line() of ellipse fixed (commit 1, 2)
new atan2 function and assotiated fixes for .arg() and expanding rational powers (commit 1, 2, 3)
new .coeff() method for returning coefficient of a poly (commit 1, 2, 3)
pretty-printer now uses unicode by default (commit)
recognition of geometric sums were generalized (commit)
.is_positive and .is_negative now fallback to evalf() when appropriate (commit)
as the result oo*(pi-1) now correctly simplifies to oo (commit)
support for objects which provide __int__ method was added (commit)
we finally started SymPy User's Guide (commit 1, 2)

changes that affected speed:

first patches with 25% speedup (commit 1, 2, 3, 4)
Basic.cos et. al. removed, use C.cos instead (commit 1, 2, 3, 4)
sympy.core now uses direct imports (commit 1, 2)
sympifyit decorator (commit 1, 2, 3, 4, 5, 6, 7)
speedup Integers creation and arithmetic (commit 1, 2)
speedup unary operations for singleton numbers (commit)
remove silly slowdowns from fast-path of mul and div (commit 1, 2)
significant speedup was achieved by reusing dummy variables (commit 1, 2, 3, 4)
is_dummy is not an assumption anymore (commit 1, 2)
Symbols & Wilds are cached (commit 1, 2, 3)
((2+3*I)**1000).expand() is now at least 100x faster (commit)
.expand() was made faster for cases where an expression is already expanded (commit)
rational powers of integers are now computed more efficiently (commit)
unknown assumptions are now cached as well as known assumptions (commit)

general cleanup:

BasicMeths merged into Basic (commit 1, 2, 3, 4, 5, 6, 7, 8)
cache subsystem was cleaned up -- now it supports only immutable objects (commit 1, 2, 3, 4, 5)

The following people have contributed to this release:

Kirill Smelkov
Mateusz Paprocki
Saroj Adhikari
Fredrik Johansson
Jaroslaw Tworek
Robert Kern
Pauli Virtanen
Ondřej Čertík

SymPy 0.5.12 released

2008-01-27T15:36:00.000-08:00

Quite a lot has changed, SymPy now works with NumPy arrays, you can convert back and forth using numpy.array() and sympy.Matrix(). The integration algorithm has been improved significantly, it can handle a lot of common integrals already (some examples).

More detailed changelog:

SymPy works with NumPy out of the box (commit 1, 2)
RootOf implemented (commit)
Lambda support works now (commit)
heuristic Risch method improved (commit 1, 2, 3, 4, 5)
cancel function implemented (commit)
sqrt(x) is now equivalent to x**(1/2) (commit 1, 2)
Derivative is now unevaluated (commit)
list2numpy() implemented (commit)
series expansion of hyperbolic functions fixed (commit)
sympify('lambda x: 2*x') works, plus other fixes (commit 1, 2, 3)
simple maxima parser implemented (commit)
sin(x)[0] idiom changed to sin(x).args[0] (commit)
sin(x).series(x, 5) idiom changed to sin(x).series(x, 0, 5) (commit)
caching refactored (commit 1, 2, 3, 4, 5, 6, 7, 8, 9)
2D plots now don't rotate in 3D, but translate instead (commit)
many bug fixes, see the Mercurial history for details

The following people have contributed to this release:

Kirill Smelkov
Mateusz Paprocki
Fredrik Johansson
Jaroslaw Tworek
Saroj Adhikari
Andrej Tokarčík
David Marek
Or Dvory
Bernhard R. Link
Ondřej Čertík

public wiki

2008-01-10T06:32:00.001-08:00

We created a public wiki:

http://wiki.sympy.org/

That everyone is encouraged to participate in. The google code wiki has a huge disadvantage, that only the members of the google code sympy project are allowed to edit it. wiki.sympy.org can be edited by anyone and we hope that it will encourage SymPy users to help improve SymPy documentation and take part in the project.

We plan to move all tutorials and docs in there. Only things, that are relevant to developers, like how to do a release, etc., will stay in the google wiki.

SymPy 0.5.11 released

2008-01-07T07:02:00.000-08:00

This is just a bugfix release, that fixed a problem with pyglet in the 0.5.10.

Changes:

./setup.py install installs pyglet correctly now (commit)
var("k") fixed (commit)
script for automatic testing of plotting in pure environment added (commit 1, 2)

SymPy 0.5.10 released

2008-01-04T07:02:00.000-08:00

Changes:

view renamed to preview, pngview, pdfview, dviview added (commit)
latex printer was rewritten, preview uses builtin pyglet instead of pygame (commit 1, 2)
square root denesting implemented (commit)
parser of simple Mathematica expressions added (commit)
TeXmacs interface written (commit)
some integration fixes (commit 1, 2, 3)
line width in 2D plotting can be specified (commit)
README was updated (commit 1, 2)
pyglet and mpmath were updated and moved to sympy/thirdparty (commit 1, 2, 3, 4, 5)
all sys.path hacks were moved to just 2 places - pyglet and examples (commit 1, 2, 3)
SymPy objects should work in numpy arrays now (commit 1, 2)
hand written sympify() parser was rewritten and simplified using Python AST (commit)

Google Highly Open Participation Contest 2007-8

2007-12-22T04:57:00.000-08:00

SymPy participates in the Google Highly Open Participation Contest 2007-8, if you are a high school student, go for it. Last chance to claim a task is January 22!

SymPy 0.5.9 released

2007-12-21T16:19:00.000-08:00

Changes:

* Differential solvers were polished
* isympy now predefines f as a function
* Matrix printing improved
* Printing internals were documented

See Changes for more info.

Blogs

2007-12-17T00:40:00.000-08:00

We'll use this blog for official announcements only from now on. Personal opinions will be on people's blogs, all of which are synchronised at planet.sympy.org.

We have implemented some new cool features in the Mercurial repository, so a new release will soon come out.

If you are curious, you can always find what code has been committed here:

http://hg.sympy.org/sympy

SAGE Days 6 wrap-up

2007-11-16T08:26:00.000-08:00

SD6 is over, here are my final notes about the conference:

http://ondrejcertik.blogspot.com/2007/11/sage-days-6.html

SAGE is an exciting project. On SD6 I managed with the help of other SAGE developers to make SymPy play more nicely (after my patches are accepted, you will be able to freely mix SymPy and SAGE expressions and it will work).

SAGE Days 6

2007-11-10T15:48:00.000-08:00

I am at SAGE Days 6, you can watch the progress on my blog.

Unicode printing

2007-11-05T06:50:00.000-08:00

One very cool feature of SymPy, that Kirill recently committed, is a unicode printing. Start isympy and see for yourself:


$ bin/isympy 
Python 2.4.4 console for SymPy 0.5.6-hg. These commands were executed:
>>> from __future__ import division
>>> from sympy import *
>>> x, y, z = symbols('xyz')
>>> k, m, n = symbols('kmn', integer=True)
>>> Basic.set_repr_level(2)     # 2D output
>>> pprint_try_use_unicode()    # try to setup unicode pprint


In [1]: sqrt((sqrt(x+1))+1)
Out[1]: 
   ⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽
  ╱       ⎽⎽⎽⎽⎽⎽⎽ 
╲╱  1 + ╲╱ 1 + x  

In [2]: th, ph = Symbol("theta"), Symbol("phi")

In [3]: Integral(sin(th)/cos(ph), (th,0,pi), (ph, 0, 2*pi))
Out[3]: 
2*π π             
 ⌠  ⌠             
 ⎮  ⎮ sin(θ)      
 ⎮  ⎮ ────── dθ dφ
 ⎮  ⎮ cos(φ)      
 ⌡  ⌡             
 0  0

More examples can be found on the wiki page PrettyPrinting.

Fredrik also played with the idea of ascii plotting. I am a huge fan of a terminal, because this is very versatile - I can use it over ssh, I can copy & paste, save the results to a file etc. I can easily script it. And the most important - I just prefer to write my programs in vim and execute them as a simple script. Any GUI, even the best one (or in the browser), is not giving me such a power. So I like the idea of making the terminal experience as pleasant as possible.

Google stopped showing sympy's webpage

2007-10-18T15:27:00.001-07:00

This was written on October 18:

I was used to finding the sympy webpage by googling "sympy". When I did that today, the http://code.google.com/p/sympy/ isn't shown in the results (instead the sympy's freshmeat page, or sympy's Debian page is shown). I tried yahoo and msn, and sympy webpage always shows as the first or second link in there (as it used to in google).

It's interesting and it reminds me how important it is to have several search engines and do not depend on only one, so that one can switch to a different one if the first one is apparently not working correctly.

Update (October 21): Google fixed the problem and sympy's webpage is the first link again.

New SymPy release and beyond

2007-10-06T03:05:00.000-07:00

Things have been a little quiet on planet.sympy.org, but the less we talk, the more we work. :) With 468 svn commits in September and 89 in October (till October 5) [1], we are working hard. We made a new release yesterday, where we simplified the internals of SymPy a lot and I also fixed the limits finally.

What remains is to fix some problematic series expansion (that also makes some limits fail, but the limit algorithm itself seems to be bugfree so far) and then I'll concentrate on making SymPy more SAGE friendly. SymPy will remain as a small Python library, doing one job and doing it well. But when used inside SAGE, it will know how to convert expressions to and from SAGE, so that people can use SymPy from SAGE ideally the same way as they can now use Maxima.

I think there are already things that SymPy is better than Maxima in terms of pure functionality, like pattern matching, limits (after I'll fix the series code, hopefully in the next release). There are however things, where Maxima is better, it still has a lot more features (more integrals, more differential equations, tensors) and it's faster. Except for the speed, all the other things are really easy to implement in SymPy. The main advantage of SymPy over Maxima is that it is written in Python and it is really easy to implement new features in it.

A huge deficiency of Maxima is that it uses lisp and it's own language for doing the calculations. SAGE fixes this problem (but it doesn't support all features of Maxima yet, for example substitutions of subexpressions, that is needed in the Gruntz limit algorithm), so SAGE is in fact like a platform, a common ground for all these mathematical libraries, allowing them to be used using the same interface and thus one can compare the real features (and speed), instead of some possibly good libraries being disqualified just because they use an unfortunate language/interface (for whatever historical reasons), which is great and I want SymPy to compete in the same ground as well, because only this will tell, if it is good or not and which things to improve. Competition is very healthy, it's always good to have a choice.

[1] http://groups.google.com/group/sympy-commits/about

Summer of Code summary

2007-08-23T10:47:00.000-07:00

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 -l
64
ondra@fuji:~/sympy$ svn log |grep inferno | wc -l
48
ondra@fuji:~/sympy$ svn log |grep fredrik | wc -l
39
ondra@fuji:~/sympy$ svn log |grep mattpap | wc -l
39
ondra@fuji:~/sympy$ svn log |grep lethargo | wc -l
29
ondra@fuji:~/sympy$ svn log |grep brian | wc -l
44
ondra@fuji:~/sympy$ svn log |grep pearu | wc -l
14
ondra@fuji:~/sympy$ svn log |grep Chris.Wu | wc -l
3

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 974
Fabian 335
Jason 227
Fredrik 151
Robert 104
Mateusz 88
Pearu 76
Brian 65
Chris 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.

Progress

2007-08-01T08:42:00.001-07:00

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/r
1/r
-sin(\theta)*cos(\theta)

1/sin(\theta)*cos(\theta)
1/sin(\theta)*cos(\theta)
1/r
1/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 0
0 1/(C1 + C2/r) 0 0
0 0 r**2 0
0 0 0 r**2*sin(\theta)**2

real    0m1.092s
user    0m1.024s
sys     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.

USA plans

2007-07-06T08:54:00.000-07:00

Last 8 days I spent in Porto at a workshop and my plans for August are:
from August 13 to August 19 I am at Caltech at the SciPy2007 conference and from August 20 till August 25 at Berkeley at a workshop. Let me know if anyone is going to be around, we can meet and do some coding together.

Next direction in SymPy is to try to merge the sympy-research with the trunk, this should make SymPy a lot faster.

RISC and coding

2007-06-17T15:57:00.000-07:00

I just returned from the workshop at RISC where I was with Mateusz. We met a lot of interesting people there and did some coding together, so I really enjoyed that. And we decided we should try to come together again and do some coding. I checked with Robert and he also likes the idea.

So the preliminary proposition is to meet in Prague at the end of August or the beginning of September, currently me, Mateusz and Robert should be able to make it. It's a lot more enjoyable to work together, because you can discuss things more quickly and more work is done. We will join it with sightseeing and pubs of course. Let us know, if anyone else would like to attend. We will discuss the details later. Most of you are in the US, but those in Europe could take it as a trip to Prague. :)

The topic will be anyting that interests us, from fixing bugs, to discussing features, implementing new things, creating some nice examples or nontrivial new usages of SymPy.

As to less distant future - most of the most urgent bugs are fixed, so I will release 0.4.0 tomorrow.

relativity.py is working

2007-04-29T03:50:00.000-07:00

I finally got it working. :)

If you want to try it, go to the examples directory and:


ondra@syslik:~/sympy/examples$ python relativity.py
----------------------------------------
Christoffel symbols:
1/2*\nu'(r)
1/2*\nu'(r)

1/2*exp(\lambda(r))**(-1)*exp(\nu(r))*\nu'(r)
1/2*\lambda'(r)
-exp(\lambda(r))**(-1)*r
-exp(\lambda(r))**(-1)*sin(\theta)**2*r

r**(-1)
r**(-1)
-cos(\theta)*sin(\theta)

sin(\theta)**(-1)*cos(\theta)
sin(\theta)**(-1)*cos(\theta)
r**(-1)
r**(-1)
----------------------------------------
Ricci tensor:
-1/4*exp(\lambda(r))**(-1)*exp(\nu(r))*\lambda'(r)*\nu'(r)+1/2*exp(\lambda(r))**(-1)*exp(\nu(r))*(\nu'(r))'+exp(\lambda(r))**(-1)*exp(\nu(r))*r**(-1)*\nu'(r)+1/4*exp(\lambda(r))**(-1)*exp(\nu(r))*\nu'(r)**2
-1/4*\nu'(r)**2-1/2*(\nu'(r))'+r**(-1)*\lambda'(r)+1/4*\nu'(r)*\lambda'(r)
-exp(\lambda(r))**(-1)-1/2*exp(\lambda(r))**(-1)*r*\nu'(r)-(-1-sin(\theta)**(-2)*cos(\theta)**2)-sin(\theta)**(-2)*cos(\theta)**2+1/2*exp(\lambda(r))**(-1)*r*\lambda'(r)
1/2*exp(\lambda(r))**(-1)*sin(\theta)**2*r*\lambda'(r)-exp(\lambda(r))**(-1)*sin(\theta)**2+sin(\theta)**2-1/2*exp(\lambda(r))**(-1)*sin(\theta)**2*r*\nu'(r)
----------------------------------------
solve the Einstein's equations:
\lambda(r)  =  -log(C1+C2*r**(-1))
metric:
-(C1+C2*r**(-1)) 0 0 0
0 (C1+C2*r**(-1))**(-1) 0 0
0 0 r**2 0
0 0 0 r**2*sin(\theta)**2

It will start with a general, spherically symmetric metric:


gdd=Matrix((
  (-exp(nu(r)),0,0,0),
  (0, exp(lam(r)), 0, 0),
  (0, 0, r**2, 0),
  (0, 0, 0, r**2*sin(theta)**2)
  ))

notice the two unknown functions nu(r) and lam(r) and it calculates the Christoffel symbols, Riemann and Ricci tensors, then solves the differential (Einstein) equations for nu and lam and substitute it back to the metric to get the Schwarzschild metric (last matrix in the output from relativity.py).

If you look into the relativity.py, you will see, that when solving the equations, I am a little cheating in that I am assuming

nu(r) == -lam(r)

that can be shown by playing with the equations. That is so that I get just one differential equation for just one unknown function and then I plug it into the dsolve() and I am done.

Some more ideas what I want SymPy to do

2007-04-24T08:40:00.000-07:00

Today I found several Mathematica packages for doing things in general relativity and quantum field theory, I updated the links here. I found xTensor, SusyMath and cadabra (this one is written in C++). Many more can be found in the Computer Physics Communications journal (CPC). Those packages are opensource, but depend on a proprietary product. And I cannot help myself, but when I look at the sources, I just find the Mathematica language completely messy.

So now I am concentrating to get the relativity.py working and then calculate something that they did. And if it turns out that it is reasonably fast (i.e. I will get the correct result in minutes, or hours) and if the source code is going to be short and nice (I hope so), I'll try to write an article about it to CPC. As a side effect, it will be a real world test for SymPy. Also I would like then to do the same calculation in SAGE, to see how it compares to SymPy. What I don't like in SAGE is that I prefer to import the library as a normal python module and I don't want to be trapped in another environment (SAGE is actually preproccessing the input a little, like converting ^ to ** etc, which I don't like at all). I think the symbolic package should be a regular standard python library. And who knows python, should easily understand how to work with that.

Right now I am struggling with the mattern matching (issue 82) in order for the dsolve() to be able to solve the differential equations that arise in relativity.py.
I would like to make it into 0.4. I think we can release a little after sympy gets into debian unstable (hopefuly in a week or two), so that we can check how it behaves etc. and fix everything for 0.4.

I know that there are still some issues, that are quite embarrassing they still don't work in SymPy, but I think more important is to "release early, release often".

some future plans

2007-04-19T03:57:00.000-07:00

If everything goes well, SymPy should be quite well tested when the summer is over and GSoC projects will improve it in the areas: geometry, graphing, concrete mathematics, linear algebra and polynomial equations (and stuff).

For me SymPy starts to be usable enough so that I can actually calculate something interesting. I started with the Schwarzschild solution to the Einstein's equations of the general relativity. So I start with a diagonal metric tensor, and calculate the Ricci tensor using SymPy and this works remarkably well and I get the correct differential equations. Now I am trying to make the SymPy's dsolve() to solve them. And then I would like to make pictures like this one using the graphing module. The code is in examples/relativity.py

My other application is the Quantum Field Theory, where I am trying to calculate some simple cross sections, however, SymPy is pretty slow on that, but when we optimize the polynomials stuff, it should work just fine. The code is in examples/qft.py

Being able to use symbolic manipulation in the Python language allows me to be really productive. And also it's fun, because it's a pleasure, like any other programming in Python. Programming in Maple is not a pleasure for me at all.

So over the summer, I'll try to make SymPy calculate the above things because that will show, if SymPy is usable, or not. Besides that, I want to polish the web page, and documentation and installation especially. And get it to Debian and Ubuntu.

Is any of you using something else than Debian/Ubuntu/Windows? If so, would you be willing to create a package for your distribution? :)

SymPy

2007-04-15T04:12:00.000-07:00

This blog will be used to coordinate the Google Summer of Code for the SymPy project.

I'm Ondrej Certik, the author of SymPy, and together with Fabian Seoane (who joined SymPy in February 2007), Jim Jewett and Mike Haertel we'll be mentoring 5 students: Robert, Mateusz, Brian, Chris and Jason.

Here is a picture of me in Prague:

and in Washington: