PR/1823 CVS commit: pkgsrc/math/py-sympy

["Thomas Klausner" <wiz%netbsd.org@localhost>]

The following reply was made to PR misc/1823; it has been noted by GNATS.

From: "Thomas Klausner" <wiz%netbsd.org@localhost>
To: gnats-bugs%gnats.NetBSD.org@localhost
Cc: 
Subject: PR/1823 CVS commit: pkgsrc/math/py-sympy
Date: Tue, 21 Jan 2014 08:38:04 +0000

 Module Name:   pkgsrc
 Committed By:  wiz
 Date:          Tue Jan 21 08:38:04 UTC 2014
 
 Modified Files:
        pkgsrc/math/py-sympy: Makefile PLIST distinfo
 
 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.
 
 
 To generate a diff of this commit:
 cvs rdiff -u -r1.13 -r1.14 pkgsrc/math/py-sympy/Makefile
 cvs rdiff -u -r1.8 -r1.9 pkgsrc/math/py-sympy/PLIST
 cvs rdiff -u -r1.7 -r1.8 pkgsrc/math/py-sympy/distinfo
 
 Please note that diffs are not public domain; they are subject to the
 copyright notices on the relevant files.