## Monday, December 12, 2011

### Google Summer of Code 2011 Wrap-Up

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.

## Friday, July 29, 2011

### SymPy 0.7.1 Released

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

## Wednesday, June 29, 2011

### SymPy 0.7.0 released

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

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.

## 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). Use`symbols('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`

and`is_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*