SymPy 0.6.3 released

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

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

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

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

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

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

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

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

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

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

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)

See also Changes.