Log message:
Update py-sympy to 1.2

Highlights

   There are many changes in 1.2 (see below). Some of the highlights are
     * Python 3.3 is no longer supported. If you require Python 3.3
       support, use SymPy 1.1.1. See our [518]policy on dropping support
       for major Python versions.
     * Experimental LaTeX parsing with sympy.parsing.latex.parse_latex()
       has been added, based on the latex2sympy project. This requires
       antlr-python-runtime to be installed. [519]#13706
     * The vector module has been improved to support orthogonal
       curvilinear coordinate systems ([520]Szymon Mieszczak's GSoC
       project)
     * New module sympy.integrals.intpoly for integrating uni/bivariate
       polynomials over 2-polytopes. ([521]Arif Ahmed's GSoC project)
     * Improvements to the code generation module. ([522]Bj?rn Dahlgren's
       GSoC project)
     * Improvements to the group theory module. See below for more
       information. ([523]Valeriia Gladkova's GSoC project)
     * New module sympy.discrete for operating on discrete sequences.
       polynomials over 2-polytopes. ([521]Arif Ahmed's GSoC project)
     * Improvements to the code generation module. ([522]Bj?rn Dahlgren's
       GSoC project)
     * Improvements to the group theory module. See below for more
       information. ([523]Valeriia Gladkova's GSoC project)
     * New module sympy.discrete for operating on discrete sequences.
       ([524]Sidhant Nagpal's GSoC project)

Complete release notes at:
https://github.com/sympy/sympy/wiki/release-notes-for-1.2

Log message:
py-sympy: update to 1.1.1

Changes 1.1.1:

Units
-----
Fix an issue with the Quantity Add postprocessor in Python 3.6.
Support functions with quantities and dimensions.
Fix addition of a quantity and a number.
Workaround power of a quantity.
Fix SI prefix definitions

Core
----
Fix the Add/Mul postprocessor logic for subclasses.
Fix various recursion issues in the Add assumptions that prevented isympy from \ 
working with the cache off.
Fix some test failures on 32-bit systems.
Allow for complex NumPy scalars in sympify.

Code generation
---------------
Only call asarray in lambdify on Python builtin numeric types. Fixes lambdify \ 
for array subclasses such as xarray.
Fix using preprocessor_statements kwarg in CCodeGen.

Matrices
--------
Fix stacking of empty matrices.

Other
-----
Build the docs with the latest version of Sphinx. Fixes the search functionality \ 
being broken in the docs.
Fix the language classifiers in setup.py

Log message:
Remove unnecessary PLIST_SUBST and FILES_SUBST that are now provided
by the infrastructure.

Mark a couple more packages as not ready for python-3.x.

Log message:
Switch to egg.mk.
Fix PLIST for python-3.x.

Log message:
py-sympy: use python pkg version for man page in PLIST

Log message:
Update py-sympy to 1.0

Release Notes for 1.0

Major changes

As a 1.0 release, there are some major changes, many of which are breaking. See \ 
also the "backwards compatibility breaks and deprecations" section \ 
below.

    mpmath is now a hard external dependency for SymPy. sympy.mpmath will no \ 
longer work (use import mpmath). See \ 
http://docs.sympy.org/latest/install.html#mpmath for more information on how to \ 
install mpmath.

    The galgebra Geometric Algebra module has been removed. The module is now \ 
maintained separately at https://github.com/brombo/galgebra.

    The new solveset function is a planned replacement for solve. solve is not \ 
yet deprecated, since solveset hasn't yet fully replicated all the functionality \ 
of solve. solveset offers an improved interface to solve. See \ 
http://docs.sympy.org/latest/modules/solvers/solveset.html for more information \ 
on solveset vs. solve.

    This will be the last version of SymPy to support Python 2.6 and 3.2. Both \ 
of these Python versions have reached end-of-life. Support for other Python \ 
versions will continue at least until they have reached end-of-life.

Backwards compatibility breaks and deprecations

    In sympy.geometry, Line.equal() has been deprecated in favor of Line.equals().
    The dup_inner_subresultants and dmp_inner_subresultants now only return 2 \ 
arguments instead of 3. Only those building their own routines from these very \ 
low-level functions need to be aware of this.
    This release doesn't include copy of the mpmath library, see PR #2192. \ 
Please see new installation instructions for SymPy.

    The release no longer includes the galgebra subumodule. This module is now \ 
maintained separately at https://github.com/brombo/galgebra. See PR #10046.

    ClassRegistry is deprecated. It's unlikely that anybody ever used it; it is \ 
scheduled for removal for the next version of SymPy after 1.0.
    sympy.C is deprecated and scheduled for removal after 1.0, too. For those \ 
users who followed some erroneous SymPy documentation and used C as in C.log, \ 
just import sympy and use sympy.log instead: this is compatible with SymPy \ 
before and after we remove C.
    Q.bounded has been deprecated. Use Q.finite instead.
    Q.infinity has been deprecated. Use Q.infinite instead.
    Q.infinitesimal has been deprecated. Use Q.zero instead.
    ask(Q.nonzero(non-real)) now returns False. Note that Q.nonzero is \ 
equivalent to ~Q.zero & Q.real. If you intend to find whether x is a \ 
non-zero number irrespective of the fact that x is real or not, you should use \ 
ask(~Q.zero(x)).
    x.is_nonzero now returns True iff x is real and has a non-zero value. If you \ 
intend to find whether x is a non-zero number irrespective of the fact that x is \ 
real or not, you should use fuzzy_not(x.is_zero).
    isprime(Float) now returns False.
    ask(Q.integer(Float)) now returns False.
    ask(Q.prime(Float)) now returns False.
    ask(Q.composite(Float)) now returns False.
    ask(Q.even(Float)) now returns False.
    ask(Q.odd(Float)) now returns False.

New features

    The module sympy.series.ring_series has been updated. New methods for series \ 
inversion, expansion of hyperbolic and inverse functions, etc have been added. \ 
PR #9262

    New module sympy.series.sequences for generating finite/infinite lazily \ 
evaluated lists. [PR #9435]

    The string representation function srepr() now displays the assumptions used \ 
to create a Symbol. For example, srepr(Symbol('x', real=True)) now returns the \ 
string "Symbol('x', real=True)" instead of merely \ 
"Symbol('x')".

    not_empty_in function added to util.py in calculus module which finds the \ 
domain for which the FiniteSet is not-empty for a given Union of Sets. [PR \ 
#9779]

    A new and fast method rs_series has been added for calculating series \ 
expansions. It can handle multivariate Puiseux series with symbolic \ 
coefficients. It is especially optimized for large series, with speedup over the \ 
older series method being in the range 20-1000 times. PR #9775

In [37]: %timeit rs_series(cos(a+b*a**QQ(3,2)), a, 10)
100 loops, best of 3: 5.59 ms per loop

In [38]: %timeit cos(a+b*a**QQ(3,2)).series(a, 0, 10)
1 loops, best of 3: 997 ms per loop

    Complex Sets has been added here: sympy.sets.fancysets, use S.Complexes for \ 
singleton ComplexRegion class. PR #9463

    GeometryEntity now subclasses from sets.Set, so sets.Intersection and \ 
sets.Union can be used with GeometryEntitys. For example \ 
Intersection(Line((-1,-1),(1,1)), Line((-1,1), (1,-1))) == \ 
FiniteSet(Point2D(0,0)).

    New module sympy.series.fourier for computing fourier sine/cosine series. \ 
[PR #9523]

    Linsolve: General Linear System Solver in sympy.solvers.solveset, use \ 
linsolve() for solving all types of linear systems. PR #9438

    New assumption system is now able to read the assumptions set over Symbol \ 
object. For e.g.:

In [7]: x = Symbol('x', positive=True)

In [8]: ask(Q.positive(x))
Out[8]: True

    A new handler system has been added as sympy.assumptions.satask which uses \ 
satisfiable to answer queries related to assumptions. In case the legacy ask \ 
doesn't know the answer, it falls back on satask.

For e.g.

Earlier

>>> ask(Q.zero(x) | Q.zero(y), Q.zero(x*y))
>>> ask(Implies(Q.zero(x), Q.zero(x*y)))
>>> ask(Q.zero(x) | Q.zero(y), Q.nonzero(x*y))

Now

>>> ask(Q.zero(x) | Q.zero(y), Q.zero(x*y))
True
>>> ask(Implies(Q.zero(x), Q.zero(x*y)))
True
>>> ask(Q.zero(x) | Q.zero(y), Q.nonzero(x*y))
False

    New module sympy.series.formal for computing formal power series. [PR #9639]

    New set class ConditionSet was implemented. [PR #9696]

    Differential calculus Methods, like is_increasing, is_monotonic, etc were \ 
implemented in sympy.calculus.singularities in [PR #9820]

    New module sympy.series.limitseq for finding limits of terms containing \ 
sequences. [PR #9836]

    New module sympy/polys/subresultants_qq_zz.py :: contains various functions \ 
for computing Euclidean, Sturmian and (modified) subresultant polynomial \ 
remainder sequences in Q[x] or Z[x]. All methods are based on the recently \ 
discovered theorem by Pell and Gordon of 1917 and an extension/generalization of \ 
it of 2015. [PR #10374]

Minor changes

    limit(sin(x), x, oo) now returns AccumulationBound object instead of \ 
un-evaluated sin(oo). Implemented in [PR #10051].

    Point is now an n-dimensional point and subclassed to Point2D and Poin3D \ 
where appropriate. Point is also now enumerable and can be indexed (e.g., \ 
x=Point(1,2,3); x[0])

    roots_cubic will no longer raise an error when the sign of certain \ 
expressions is unknown. It will return a generally valid solution instead.

    Relational.canonical will put a Relational into canonical form which is \ 
useful for testing whether two Relationals are trivially the same.

    Relational.reversed gives the Relational with lhs and rhs reversed and the \ 
symbol updated accordingly (e.g. (x < 1).reversed -> 1 > x

    Simplification of Relationals will, if the threshold for simplification is \ 
met, also return the Relational in canonical form. One of the criteria of being \ 
in canonical form is that the Number will be on the rhs. This makes writing \ 
tests a little easier so S(1) > x can be entered as 1 > x or x < 1 (the \ 
former being turned into the latter by Python).

    boolalg functions And, Or, Implies, Xor, Equivalent are aware of Relational \ 
complements and trivial equalities, so, for example, And(x=1) will reduce to \ 
False while And(S(1)>x,x<1) reduces to x < 1. This leads to some \ 
simplifications in statistical expressions.

    Polynomials created using ring now accept negative and fractional exponents. \ 
For e.g,

In [1]: R, x, y = ring('x, y', QQ)

In [2]: x**(-2) + y**Rational(2,3)
Out[2]: y**(2/3) + x**(-2)

    The function used to test connectivity in Min and Max has been altered to \ 
use the weaker form of a relationship since this applies to arguments like \ 
floor(x) and x: though, in generally, we cannot say that floor(x) < x, if x \ 
is real we do know that floor(x) <= x. This allows Min(x, floor(x)) -> \ 
floor(x) without loss of generality when x is real.

    Float has changed its default behaviour on string/int/long to use at least \ 
15 digits of precision and to increase the precision automatically. This enables \ 
sympify('1.23456789012345678901234567890') to return a high-precision Float. It \ 
also means N('1.23456789012345678901234567890', 20) does the right thing (where \ 
it previously lost precision because an intermediate calculation had only \ 
precision 15). See Issue #8821

    The unicode pretty printer now uses a compact single-character square root \ 
symbol for simple expressions like sqrt(x) and sqrt(17). You can disable this \ 
new behaviour with pprint(sqrt(2), use_unicode_sqrt_char=False).

    ask(Q.finite(x), Q.infinite(x)) now returns False.

    You can now read the definition of assumption predicates in the docs.

    ask(Q.composite(1)) now returns False.

    exp(expr) won't simplify automatically based on assumptions on expr. \ 
Autosimplification works for numbers and Symbol, though. You'll have to call \ 
refine on exp for simplification.

    Idx objects can now be summation variables of Sum and Product.

    The keyword argument of GramSchmidt was renamed from "orthog" to \ 
"orthonormal". This is because GramSchmidt always returns an \ 
orthogonal set of vectors but only if that argument is True does it return an \ 
orthonormal set of vectors.

    RootOf now has a new subclass ComplexRootOf (abbreviated CRootOf). All \ 
currently defined functionality is in the subclass. There is a new function \ 
rootof with the same call interface as that of RootOf. It will create objects of \ 
CRootOf. New code should use rootof instead of RootOf which is planned to become \ 
an abstract class.

    The vector module has a new function orthogonalize which applies the Gram \ 
Schmidt orthogonalization on a sequence of linearly independent vectors and \ 
returns a sequence of orthogonal (or orthonormal) vectors. The projection method \ 
has been added to compute the vector (or scalar) projection of one vector on \ 
another vector. (See https://github.com/sympy/sympy/pull/10474#)

Update by K.I.A.Derouiche in PR pkg/51270

Log message:
Update to 0.7.6.1, based on PR 50382 by derouiche.

0.7.6.1

This is a small bugfix release over SymPy 0.7.6, primarily to fix issues with \ 
printing in the Jupyter notebook.
Changes

    Fix pretty printing in the Jupyter notebook and Jupyter qtconsole for \ 
Jupyter 4.0.

    The deprecated linearization method in the mechanics module no longer fails \ 
to execute.

0.7.6

Major changes

    New module calculus.finite_diff for generating finite difference formulae \ 
approximating derivatives of arbitrary order on arbitrarily spaced grids.

    New module physics.optics for symbolic computations related to optics.

    geometry module now supports 3D geometry.

    Support for series expansions at a point other then 0 or oo. See PR #2427.

    Rules for the intersection of integer ImageSets were added. See PR #7587. We \ 
can now do things like {2⋅m | m ∊ ℤ} ∩ {3⋅n | n ∊ \ 
ℤ} = {6⋅t | t ∊ ℤ} and {2⋅m | m ∊ ℤ} ∩ \ 
{2⋅n + 1 | n ∊ ℤ} = ∅

    dsolve module now supports system of ODEs including linear system of ODEs of \ 
1st order for 2 and 3 equations and of 2nd order for 2 equations. It also \ 
supports homogeneous linear system of n equations.

    New support for continued fractions, including iterators for partial \ 
quotients and convergents, and reducing a continued fraction to a Rational or a \ 
quadratic irrational.

    Support for Egyptian fraction expansions, using several different algorithms.

    Addition of generalized linearization methods to physics.mechanics.

    Use an LRU cache by default instead of an unbounded one. See PR #7464. \ 
Control cache size by the environment variable SYMPY_CACHE_SIZE (default is \ 
500). SYMPY_CACHE_SIZE=None restores the unbounded cache.

    Added fastcache as an optional dependency. Requires v0.4 or newer. Control \ 
via SYMPY_CACHE_SIZE. May result in significant speedup. See PR #7737.

    New experimental module physics.unitsystems for computation with dimensions, \ 
units and quantities gathered into systems. This opens the way to dimensional \ 
analysis and better quantity calculus. The old module physics.units will stay \ 
available until the new one reaches a mature state. See PR #2628.

    New Complement class to represent relative complements of two sets. See Pr #7462.

    New trigonometric functions (asec, acsc), many enhancements for other \ 
trigonometric functions (PR #7500).

    New Contains class to represent the relation "is an element of" \ 
(see PR #7989).

    The code generation tools (code printers, codegen, autowrap, and ufuncify) \ 
have been updated to support a wider variety of constructs, and do so in a more \ 
robust way. Major changes include added support for matrices as inputs/outputs, \ 
and more robust handling of conditional (Piecewise) statements.

    ufuncify now uses a backend that generates actual numpy.ufuncs by default \ 
through the use of the numpy C api. This allows broadcasting on all arguments. \ 
The previous cython and f2py backends are still accessible through the use of \ 
the backend kwarg.

    CodeGen now generates code for Octave and Matlab from SymPy expressions. \ 
This is supported by a new CodePrinter with interface octave_code. For example \ 
octave_code(Matrix([[x**2, sin(pi*x*y), ceiling(x)]])) gives the string [x.^2 \ 
sin(pi*x.*y) ceil(x)].

    New general 3D vector package at sympy.vector. This package provides a 3D \ 
vector object with the Del, gradient, divergence, curl, and operators. It \ 
supports arbitrary rotations of Cartesian coordinate systems and arbitrary \ 
locations of points.

Backwards compatibility breaks and deprecations

    All usage of inequalities (>, >=, <, <=) on SymPy objects will \ 
now return SymPy's S.true or S.false singletons instead of Python's True or \ 
False singletons. Code that checks for, e.g., (a < b) is True should be \ 
changed to (a < b) == True or (a < b) == S.true. Use of is is not \ 
recommended here.

    The subset() method in sympy.core.sets is marked as being deprecated and \ 
will be removed in a future release (issue). Instead, the is_subset() method \ 
should be used.

    Previously, if you compute the series expansion at a point other than 0, the \ 
result was shifted to 0. Now SymPy returns the usual series expansion, see PR \ 
#2427.

    In physics.mechanics, KanesMethod.linearize has a new interface. Old code \ 
should be changed to use this instead. See docstring for information.

    physics.gaussopt has been moved to physics.optics.gaussopt. You can still \ 
import it from the previous location but it may result in a deprecation warning.

    This is the last release with the bundled mpmath library. In the next \ 
release you will have to install this library from the official site.

    Previously lambdify would convert Matrix to numpy.matrix by default. This \ 
behavior is being deprecated, and will be completely phased out with the release \ 
of 0.7.7. To use the new behavior now set the modules kwarg to \ 
[{'ImmutableMatrix': numpy.array}, 'numpy']. If lambdify will be used frequently \ 
it is recommended to wrap it with a partial as so: lambdify = \ 
functools.partial(lambdify, modules=[{'ImmutableMatrix': numpy.array}, \ 
'numpy']). For more information see #7853 and the lambdify doc string.

    Set.complement doesn't exists as an attribute anymore. Now we have a method \ 
Set.complement(<universal_set>) which complements the given universal set.

    Removed is_finite assumption (see #7891). Use instead a combination of \ 
"is_bounded and is_nonzero" assumptions.

    is_bounded and is_unbounded assumptions were renamed to is_finite and \ 
is_infinite (see #7947).

    Removed is_infinitesimal assumption (see #7995).

    Removed is_real property for Sets, use set.is_subset(Reals) instead (see #7996).

    For generic symbol x (SymPy's symbols are not bounded by default), \ 
inequalities with oo are no longer evaluated as they were before, e.g. x < oo \ 
no longer evaluates to True). See #7861.

    CodeGen has been refactored to make it easier to add other languages. The \ 
main high-level tool is still utilities.codegen.codegen. But if you previously \ 
used the Routine class directly, note its __init__ behaviour has changed; the \ 
new utilities.codegen.make_routine is recommended instead and by default retains \ 
the previous C/Fortran behaviour. If needed, you can still instantiate Routine \ 
directly; it only does minimal sanity checking on its inputs. See #8082.

    FiniteSet([1, 2, 3, 4]) syntax not supported anymore, use FiniteSet(1, 2, 3, \ 
4) instead See #7622.

Minor changes

    Updated the parsing module to allow sympification of lambda statements to \ 
their SymPy equivalent.
    Lambdify can now use numexpr by specifying modules='numexpr'
    Use with evaluate(False) context manager to control automatic evaluation. \ 
E.g. with evaluate(False): x + x is actually x + x, not 2*x
    IndexedBase and Indexed are changed to be commutative by default
    sympy.core.sets moved to sympy.sets
    Changes in sympy.sets:
        Infinite Range is now allowed. See PR #7741
        is_subset(): The is_subset() method deprecates the subset() method. \ 
self.is_subset(other) checks if self is a subset of other. This is different \ 
from self.subset(other), which checked if other is a subset of self.
        is_superset(): A new method is_superset() method is now available. \ 
self.is_superset(other) checks if self is a superset of other.
        is_proper_subset and is_proper_superset: Two new methods allow checking \ 
if one set is the proper subset and proper superset of another respectively. For \ 
eg. self.is_proper_subset(other) and self.is_proper_superset(other) checks if \ 
self is the proper subset of other and if self is the proper superset of other \ 
respectively.
        is_disjoint(): A new method for checking if two sets are disjoint.
        powerset(): A new method powerset() has been added to find the power set \ 
of a set.
        The cardinality of a ProductSet can be found using the len() function.
    Changes in sympy.plot.plot_implicit:
        The plot_implicit function now also allows explicitly specifying the \ 
symbols to plot on the X and Y axes. If not specified, the symbols will be \ 
assigned in the order they are sorted.
        The plot_implicit function also allows axes labels for the plot to be \ 
specified.
    rules for simplification of ImageSet were added PR#7625. As a result {x | x \ 
∊ ℤ} now simplifies to ℤ and {sin(n) | n ∊ {tan(m) | m \ 
∊ ℤ}} automatically simplifies to {sin(tan(m)) | m ∊ ℤ}
    coth(0) now returns Complex Infinity. See #7634
    dioptre is added to physics.units #7782
    replace now respects commutativity #7752
    The CCodePrinter gracefully handles Symbols which have string \ 
representations that match C reserved words. #8199
    limit function now returns an unevaluated Limit instance if it can't compute \ 
given limit, see #8213

0.7.5

Major changes

    The version of mpmath included in SymPy has been updated to 0.18.

    New routines for efficiently compute the dispersion of a polynomial or a \ 
pair thereof.

    Fancy indexing of matrices is now provided, e.g. A[:, [1, 2, 5]] selects all \ 
rows and only 3 columns.

    Enumeration of multiset partitions is now based on an implementation of \ 
Algorithm 7.1.2.5M from Knuth's The Art of Computer Programming. The new version \ 
is much faster, and includes fast methods for enumerating only those partitions \ 
with a restricted range of sizes, and counting multiset partitions. (See the new \ 
file sympy.utilities.enumerative.py.)

    distance methods were added to Line and Ray to compute the shortest distance \ 
to them from a point.

    The normal_lines method was added to Ellipse to compute the lines from a \ 
point that strike the Ellipse at a normal angle.

    inv_quick and det_quick were added as functions in solvers.py to facilitate \ 
fast solution of small symbolic matrices; their use in solve has reduced greatly \ 
the time needed to solve such systems.

    solve_univariate_inequality has been added to sympy.solvers.inequalities.py.

    as_set attribute for Relationals and Booleans has been added.

    Several classes and functions strictly associated with vector calculus were \ 
moved from sympy.physics.mechanics to a new package sympy.physics.vector. (PRs \ 
#2732 #2862 #2894)

    New implementation of the Airy functions Ai and Bi and their derivatives Ai' \ 
and Bi' (called airyai, airybi, airyaiprime and airybiprime, respectively). Most \ 
of the usual features of SymPy special function are present. Notable exceptions \ 
are Gruntz limit computation helpers and meijerg special functions integration \ 
code.

    Euler-Lagrange equations (function euler_equations) in a new package \ 
sympy.calculus (PR #2431).

Minor changes

    Some improvements to the gamma function.

    generate_bell now generates correct permutations for any number of elements.

    It is no longer necessary to provide nargs to objects subclassed from \ 
Function unless an eval class method is not defined. (If eval is defined, the \ 
number of arguments will be inferred from its signature.)

    geometric Point creation will be faster since simplification is done only on \ 
Floats

    Some improvements to the intersection method of the Ellipse.

    solutions from solve of equations involving multiple log terms are more robust

    idiff can now return higher order derivatives

    Added to_matrix() method to sympy.physics.vector.Vector and \ 
sympy.physics.dyadic.Dyadic. (PR #2686).

    Printing improvements for sympy.physics.vector objects and mechanics \ 
printing. (PRs #2687, #2728, #2772, #2862, #2894)

    Functions with LaTeX symbols now print correct LaTeX. (PR #2772)

    init_printing has several new options, including a flag print_builtin to \ 
prevent SymPy printing of basic Python types (PR #2683), and flags to let you \ 
supply custom printers (PR #2894).

    improvements in evaluation of imageset for Intervals (PR #2723).

    Set properties to determine boundary and interior (PR #2744).

    input to a function created by lambdify no longer needs to be flattened.

Backwards compatibility breaks and deprecations

    the submatrix method of matrices was removed; access the functionality by \ 
providing slices or list of rows/columns to matrix directly, e.g. A[:, [1, 2]].

    Matrix([]) and Matrix([[]]) now both return a 0x0 matrix

    terms_gcd no longer removes a -1.0 from expressions

    extract_multiplicatively will not remove a negative Number from a positive \ 
one, so (4*x*y).extract_multiplicatively(-2*x) will return None.

    the shape of the result from M.cross(B) now has the same shape as matrix M.

    The factorial of negative numbers is now zoo instead of 0. This is \ 
consistent with the definition factorial(n) = gamma(n + 1).

    1/0 returns zoo, not oo (PR #2813).

    zoo.is_number is True (PR #2823).

    oo < I raises TypeError, just as for finite numbers (PR #2734).

    1**oo == nan instead of 1, better documentation for Pow class (PR #2606).

Log message:
Remove unused patch.

Log message:
Update to 0.7.4.1:

0.7.4.1

These are the release notes for SymPy 0.7.4.1, which was released
on December 15, 2013.

This version of SymPy has been tested on Python 2.6, 2.7, 3.2, 3.3,
and PyPy.

This was a small bugfix release to fix an import issue on Windows
(https://github.com/sympy/sympy/issues/2681).

0.7.4

These are the release notes for SymPy 0.7.4, which was released on
December 9, 2013.

This version of SymPy has been tested on Python 2.6, 2.7, 3.2, 3.3,
and PyPy.
Major changes
Python 3

SymPy now uses a single code-base for Python 2 and Python 3.
Geometric Algebra

The internal representation of a multivector has been changes to
more fully use the inherent capabilities of SymPy. A multivector
is now represented by a linear combination of real commutative
SymPy expressions and a collection of non-commutative SymPy symbols.
Each non-commutative symbol represents a base in the geometric
algebra of an N-dimensional vector space. The total number of
non-commutative bases is 2**N - 1 (N of which are a basis for the
vector space) which when including scalars give a dimension for
the geometric algebra of 2**N. The different products of geometric
algebra are implemented as functions that take pairs of bases
symbols and return a multivector for each pair of bases.

The LaTeX printing module for multivectors has been rewritten to
simply extend the existing sympy LaTeX printing module and the
sympy LaTeX module is now used to print the bases coefficients in
the multivector representation instead of writing an entire LaTeX
printing module from scratch.

The main change in the geometric algebra module from the viewpoint
of the user is the inteface for the gradient operator and the
implementation of vector manifolds:

The gradient operator is now implemented as a special vector (the
user can name it grad if they wish) so the if F is a multivector
field all the operations of grad on F can be written grad*F, F*grad,
grad^F, F^grad, grad|F, F|grad, grad<F, F<grad, grad>F, and F>grad
where **, ^, |, <, and > are the geometric product, outer product,
inner product, left contraction, and right contraction, respectively.

The vector manifold is defined as a parametric vector field in an
embedding vector space. For example a surface in a 3-dimensional
space would be a vector field as a function of two parameters. Then
multivector fields can be defined on the manifold. The operations
available to be performed on these fields are directional derivative,
gradient, and projection. The weak point of the current manifold
representation is that all fields on the manifold are represented
in terms of the bases of the embedding vector space.
Classical Cryptography

Implements:

    Affine ciphers
    Vigenere ciphers
    Bifid ciphers
    Hill ciphers
    RSA and "kid RSA"
    linear feedback shift registers.

Common Subexpression Elimination (CSE)

Major changes have been done in cse internals resulting in a big
speedup for larger expressions. Some changes reflect on the user
side:

    Adds and Muls are now recursively matched ([w*x, w*x*y, w*x*y*z]
    ǹow turns into [(x0, w*x), (x1, x0*y)], [x0, x1, x1*z])
    CSE is now not performed on the non-commutative parts of
    multiplications (it avoids some bugs).
    Pre and post optimizations are not performed by default anymore.
    The optimizations parameter still exists and optimizations='basic'
    can be used to apply previous default optimizations. These
    optimizations could really slow down cse on larger expressions
    and are no guarantee of better results.
    An order parameter has been introduced to control whether Adds
    and Muls terms are ordered independently of hashing implementation.
    The default order='canonical' will independently order the
    terms. order='none' will not do any ordering (hashes order is
    used) and will represent a major performance improvement for
    really huge expressions.
    In general, the output of cse will be slightly different from
    the previous implementation.

Diophantine Equation Module

This is a new addition to SymPy as a result of a GSoC project. With
the current release, following five types of equations are supported.

    Linear Diophantine equation, a_{1}x_{1} + a_{2}x_{2} + . . .
    + a_{n}x_{n} = b
    General binary quadratic equation, ax^2 + bxy + cy^2 + dx + ey
    + f = 0
    Homogeneous ternary quadratic equation, ax^2 + by^2 + cz^2 +
    dxy + eyz + fzx = 0
    Extended Pythagorean equation, a_{1}x_{1}^2 + a_{2}x_{2}^2 +
    . . . + a_{n}x_{n}^2 = a_{n+1}x_{n+1}^2
    General sum of squares, x_{1}^2 + x_{2}^2 + . . . + x_{n}^2 =
    k

Unification of Sum, Product, and Integral classes

A new superclass has been introduced to unify the treatments of
indexed expressions, such as Sum, Product, and Integral. This
enforced common behavior accross the objects, and provides more
robust support for a number of operations. For example, Sums and
Integrals can now be factored or expanded. S.subs() can be used to
substitute for expressions inside a Sum/Integral/Product that are
independent of the index variables, including unknown functions,
for instance, Integral(f(x), (x, 1, 3)).subs(f(x), x**2), while
Sum.change_index() or Integral.transform are now used for other
changes of summation or integration variables. Support for finite
and infinite sequence products has also been restored.

In addition there were a number of fixes to the evaluation of nested
sums and sums involving Kronecker delta functions, see issue 3924
and issue 3987.
Series

    The Order object used to represent the growth of a function in
    series expansions as a variable tend to zero can now also
    represent growth as a variable tend to infinity. This also
    fixed a number of issues with limits. See issue 234 and issue
    2670.

    Division by Order is disallowed, see issue 1756.

    Addition of Order object is now commutative, see issue 1180.

Physics

    Initial work on gamma matrices, depending on the tensor module.

Logic

    New objects true and false which are Basic versions of the
    Python builtins True and False.

Other

    Arbitrary comparisons between expressions (like x < y) no longer
    have a boolean truth value. This means code like if x < y or
    sorted(exprs) will raise TypeError if x < y is symbolic. A
    typical fix of the former is if (x < y) is True (assuming the
    if block should be skipped if x < y is symbolic), and of the
    latter is sorted(exprs, key=default_sort_key), which will order
    the expressions in an arbitrary, but consistent way, even across
    platforms and Python versions. See issue 2832.

    Arbitrary comparisons between complex numbers (for example, I
    > 1) now raise TypeError as well (see PR #2510).

    minpoly now works with algebraic functions, like minpoly(sqrt(x)
    + sqrt(x + 1), y).

    exp can now act on any matrix, even those which are not
    diagonalizable. It is also more comfortable to call it, exp(m)
    instead of just m.exp(), as was required previously.

    sympify now has an option evaluate=False that will not
    automatically simplify expressions like x+x.

    Deep processing of cancel and simplify functions. simplify is
    now recursive through the expression tree. See e.g. issue 3923.

    Improved the modularity of the codebase for potential subclasses,
    see issue 3652.

    The SymPy cheatsheet was cleaned up.

Backwards compatibility breaks and deprecations

    Removed deprecated Real class and is_Real property of Basic,
    see issue 1721.
    Removed deprecated 'each_char' option for symbols(), see issue
    1919.
    The viewer="StringIO" option to preview() has been deprecated.
    Use viewer="BytesIO" instead. See issue 3984.
    TransformationSet has been renamed to ImageSet. Added public
    facing imageset function.

0.7.3

These are the release notes for SymPy 0.7.3, which was released on
July 13, 2013. It can be downloaded from
https://github.com/sympy/sympy/releases/tag/sympy-0.7.3.

This version of SymPy has been tested on Python 2.5, 2.6, 2.7, 3.2,
3.3, and PyPy.
Major changes
Integration

This release includes Risch integration algorithm from Aaron Meurer's
2010 Google Summer of Code project. This makes integrate much more
powerful and much faster for the supported functions. The algorithm
is called automatically from integrate(). For now, only transcendental
elementary functions containing exp or log are supported. To access
the algorithm directly, use integrate(expr, x, risch=True). The
algorithm has the ability to prove that integrals are nonelementary.
To determine if a function is nonelementary, integrate using
risch=True. If the resulting Integral class is an instance of
NonElementaryIntegral, then it is not elementary (otherwise, that
part of the algorithm has just not been implemented yet).

Here is an example integral that could not be computed before:

>>> f = x*(x + 1)*(2*x*(x - (2*x**3 + 2*x**2 + x + 1)*log(x +
1))*exp(3*x**2) + (x**2*exp(2*x**2) - log(x + 1)**2)**2)/((x +
1)*log(x + 1)**2 - (x**3 + x**2)*exp(2*x**2))**2
>>> integrate(f, x)
x + x*exp(x**2)*log(x + 1)/(x**2*exp(2*x**2) - log(x + 1)**2) -
log(x + 1) - log(exp(x**2) - log(x + 1)/x)/2 + log(exp(x**2) +
log(x + 1)/x)/2

ODE

    Built basic infrastructure of the PDE module (PR #1970)

Theano Interaction

SymPy expressions can now be translated into Theano expressions
for numeric evaluation. This includes most standard scalar operations
(e.g. sin, exp, gamma, but not beta or MeijerG) and matrices. This
system generally outperforms lambdify and autowrap but does require
Theano to be installed.
Matrix Expressions
Assumptions

Matrix expressions now support inference using the new assumptions
system. New predicates include invertible, symmetric, positive_definite,
orthogonal, ....
New Operators

New operators include Adjoint, HadamardProduct, Determinant,
MatrixSlice, DFT. Also, preliminary support exists for factorizations
like SVD and LU.
Context manager for New Assumptions

Added the with assuming(*facts) context manager for new assumptions.
See blogpost
Backwards compatibility breaks and deprecations

    This is the last version of SymPy to support Python 2.5.

    The IPython extension, i.e., %load_ext
    sympy.interactive.ipythonprinting is deprecated. Use from sympy
    import init_printing; init_printing() instead. See issue 3914.

    The viewer='file' option to preview without a file name is
    deprecated. Use filename='name' in addition to viewer='file'.
    See issue 3919.

    The deprecated syntax Symbol('x', dummy=True), which had been
    deprecated since 0.7.0, has been removed. Use Dummy('x') or
    symbols('x', cls=Dummy) instead. See issue 3378.

    The deprecated Expr methods as_coeff_terms and as_coeff_factors,
    which have been deprecated in favor of as_coeff_mul and
    as_coeff_add, respectively (see also as_coeff_Mul and as_coeff_Add),
    were removed. The methods had been deprecated since SymPy 0.7.0.
    See issue 3377.

    The spherical harmonics have been completely rewritten. See PR
    #1510.

Minor changes
Solvers

    Added enhancements and improved the methods of solving exact
    differential equation ((PR #1955)) and ((PR #1823))
    Support for differential equations with linear coefficients
    and those that can be reduced to separable and linear form ((PR
    #1940), (PR #1864), (PR #1883))
    Support for first order linear general PDE's with constant
    coefficients ((PR #2109))
    Return all found independent solutions for underdetermined
    systems.
    Handle recursive problems for which y(0) = 0.
    Handle matrix equations.

Integration

    integrate will split out integrals into Piecewise expressions
    when conditions must hold for the answer to be true. For example,
    integrate(x**n, x) now gives Piecewise((log(x), Eq(n, -1),
    (x**(n + 1)/(n + 1), True)) (previously it just gave x**(n +
    1)/(n + 1))
    Calculate Gauss-Legendre and Gauss-Laguerre points and weights
    (PR #1497)
    Various new error and inverse error functions (PR #1703)
    Use in heurisch for more symmetric and nicer results
    Gruntz for expintegrals and all new erf*
    Li, li logarithmic integrals (PR #1708)
    Integration of li/Li by heurisch (PR #1712)
    elliptic integrals, complete and incomplete
    Integration of complete elliptic integrals by meijerg
    Integration of Piecewise with symbolic conditions.
    Fixed many wrong results of DiracDelta integrals.

Logic

    Addition of SOPform and POSform functions to sympy.logic to
    generate boolean expressions from truth tables.
    Addition of simplify_logic function and enabling simplify() to
    reduce logic expressions to their simplest forms.
    Addition of bool_equals function to check equality of boolean
    expressions and return a mapping of variables from one expr to
    other that leads to the equality.
    Addition of disjunctive normal form methods - to_dnf, is_dnf

Others

    gmpy version 2 is now supported
    Added is_algebraic_expr() method (PR #2176)
    Many improvements to the handling of noncommutative symbols:
	Better support in simplification functions, e.g. factor,
	trigsimp
	Better integration with Order()
	Better pattern matching
    Improved pattern matching including matching the identity.
    normalizes Jacobi polynomials
    Quadrature rules for orthogonal polynomials in arbitrary
    precision (hermite, laguerre, legendre, gen_legendre, jacobi)
    summation of harmonic numbers
    Many improvements of the polygamma functions
    evaluation at special arguments
    Connections to harmonic numbers
    structured full partial fraction decomposition (mainly interesting
    for developers)
    besselsimp improvements
    Karr summation convention
    New spherical harmonics
    improved minimal_polynomial using composition of algebraic
    numbers (PR #2038)
    faster integer polynomial factorization (PR #2148)
    Euler-Descartes method for quartic equations (PR #1947)
    algebraic operations on tensors (PR #1700)
    tensor canonicalization (PR #1644)
    Handle the simplification of summations and products over a
    KroneckerDelta.
    Implemented LaTeX printing of DiracDelta, Heaviside, KroneckerDelta
    and LeviCivita, also many Matrix expressions.
    Improved LaTeX printing of fractions, Mul in general.
    IPython integration and printing issues have been ironed out.
    Stats now supports discrete distributions (e.g. Poisson) by
    relying on Summation objects
    Added DOT printing for visualization of expression trees
    Added information about solvability and nilpotency of named
    groups.

Log message:
Update to 0.7.2

Upstream changes:
Release Notes for 0.7.2New Page Edit Page Page History
These are the release notes for SymPy 0.7.2. SymPy 0.7.2 was released on October \ 
16, 2012.

Major Changes
Python 3 support

SymPy now supports Python 3. The officially supported versions are 3.2 and 3.3, \ 
but 3.1 should also work in a pinch. The Python 3-compatible tarballs will be \ 
provided separately, but it is also possible to download Python 2 code and \ 
convert it manually, via the bin/use2to3 utility. See the README for more

PyPy support

All SymPy tests pass in recent nightlies of PyPy, and so it should have full \ 
support as of the next version after 1.9.

Combinatorics

A new module called Combinatorics was added which is the result of a successful \ 
GSoC project. It attempts to replicate the functionality of Combinatorica and \ 
currently has full featured support for Permutations, Subsets, Gray codes and \ 
Prufer codes.

In another GSoC project, facilities from computational group theory were added \ 
to the combinatorics module, mainly following the book "Handbook of \ 
computational group theory". Currently only permutation groups are \ 
supported. The main functionalities are: basic properties (orbits, stabilizers, \ 
random elements...), the Schreier-Sims algorithm (three implementations, in \ 
increasing speed: with Jerrum's filter, incremental, and randomized (Monte \ 
Carlo)), backtrack searching for subgroups with certain properties.

Definite Integration

A new module called meijerint was added, which is also the result of a \ 
successful GSoC project. It implements a heuristic algorithm for (mainly) \ 
definite integration, similar to the one used in Mathematica. The code is \ 
automatically called by the standard integrate() function. This new algorithm \ 
allows computation of important integral transforms in many interesting cases, \ 
so helper functions for Laplace, Fourier and Mellin transforms were added as \ 
well.

Random Variables

A new module called stats was added. This introduces a RandomSymbol type which \ 
can be used to model uncertainty in expressions.

Matrix Expressions

A new matrix submodule named expressions was added. This introduces a \ 
MatrixSymbol type which can be used to describe a matrix without explicitly \ 
stating its entries. A new family of expression types were also added: \ 
Transpose, Inverse, Trace, and BlockMatrix. ImmutableMatrix was added so that \ 
explicitly defined matrices could interact with other SymPy expressions.

Sets

A number of new sets were added including atomic sets like FiniteSet, Reals, \ 
Naturals, Integers, UniversalSet as well as compound sets like ProductSet and \ 
TransformationSet. Using these building blocks it is possible to build up a \ 
great variety of interesting sets.

Classical Mechanics

A physics submodule named machanics was added which assists in formation of \ 
equations of motion for constrained multi-body systems. It is the result of 3 \ 
GSoC projects. Some nontrivial systems can be solved, and examples are provided.

Quantum Mechanics

Density operator module has been added. The operator can be initialized with \ 
generic Kets or Qubits. The Density operator can also work with TensorProducts \ 
as arguments. Global methods are also added that compute entropy and fidelity of \ 
states. Trace and partial-trace operations can also be performed on these \ 
density operators.

To enable partial trace operations a Tr module has been added to the core \ 
library. While the functionality should remain same, this module is likely to be \ 
relocated to an alternate folder in the future. One can currently also use \ 
sympy.core.Tr to work on general trace operations, but this module is what is \ 
needed to work on trace and partial-trace operations on any \ 
sympy.physics.quantum objects.

The Density operators, Tr and Partial trace functionality was implemented as \ 
part of student participation in GSoC 2012

Expanded angular momentum to include coupled-basis states and product-basis \ 
states. Operators can also be treated as acting on the coupled basis (default \ 
behavior) or on one component of the tensor product states. The methods for \ 
coupling and uncoupling these states can work on an arbitrary number of states. \ 
Representing, rewriting and applying states and operators between bases has been \ 
improved.

Commutative Algebra

A new module agca was started which seeks to support computations in commutative \ 
algebra (and eventually algebraic geometry) in the style of Macaulay2 and \ 
Singular. Currently there is support for computing Groebner bases of modules \ 
over a (generalized) polynomial ring over a field. Based on this, there are \ 
algorithms for various standard problems in commutative algebra, e.g., computing \ 
intersections of submodules, equality tests in quotient rings, etc....

Plotting Module

A new plotting module has been added which uses Matplotlib as its back-end. The \ 
plotting module has functions to plot the following:

2D line plots
2D parametric plots.
2D implicit and region plots.
3D surface plots.
3D parametric surface plots.
3D parametric line plots.
Differential Geometry

Thanks to a GSoC project the beginning of a new module covering the theory of \ 
differential geometry was started. It can be imported with sympy.diffgeom. It is \ 
based on "Functional Differential Geometry" by Sussman and Wisdom. \ 
Currently implemented are scalar, vector and form fields over manifolds as well \ 
as covariant and other derivatives.