1201829bad8d505251d2db7defb24c6a0d0b1170 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/6b6bc5bb13c06d3fd55ddc6fe42e980e0219f18d 6b6bc5bb13c06d3fd55ddc6fe42e980e0219f18d 2009-08-18T09:42:05-07:00 2009-08-18T09:42:05-07:00 Implemented function for generating Swinnerton-Dyer polynomials 377e905b15efe57a21461816c749f18a71481d62 Mateusz Paprocki mattpap mattpap@gmail.com 218bebfc6b13e965d5cb72da09c4aa6daab77ad1 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/1201829bad8d505251d2db7defb24c6a0d0b1170 1201829bad8d505251d2db7defb24c6a0d0b1170 2009-08-18T07:17:26-07:00 2009-08-18T07:17:26-07:00 New polynomials now work with all three ZZ types 44c3e23c516e0a5894f5e93e06009cacea5c83c3 Mateusz Paprocki mattpap mattpap@gmail.com d7779f8068d1d5fbacee6321846b5cc35862e85e Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/218bebfc6b13e965d5cb72da09c4aa6daab77ad1 218bebfc6b13e965d5cb72da09c4aa6daab77ad1 2009-08-18T07:12:40-07:00 2009-08-18T07:12:40-07:00 Fixed Integer.__mod__, now returns Integer instance 33a3888dc542a487f0f8170bb97cef65d1826177 Mateusz Paprocki mattpap mattpap@gmail.com b5d2f9e1c0c6ef691cdda6c934a570b174267d38 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/d7779f8068d1d5fbacee6321846b5cc35862e85e d7779f8068d1d5fbacee6321846b5cc35862e85e 2009-08-18T04:53:20-07:00 2009-08-18T02:59:46-07:00 Improved ordering of variables in Poly and functions In mathematics we are acustomed to specify orderings of variables different than lexicographic, like x < y < a < b, e.g. to ephasize that a polynomial is in x and y variables and a, b are symbols of the ground domain. Now we use similar concept when creating a Poly: In [1]: var('p,q,r,s,t,u,v,w') Out[1]: (p, q, r, s, t, u, v, w) In [2]: Poly((x-p)*(x-q)) Out[2]: Poly(x**2 - x*p - x*q + p*q, x, p, q, domain='ZZ') Above 'x' is the main variable, which is important when computing division or resultant of polynomials. You can also specify that one of variables is the main one, by using `wrt` (with respect to) keyword argument: In [3]: Poly((x-p)*(x-q), wrt='p') Out[3]: Poly(-p*x + p*q + x**2 - x*q, p, x, q, domain='ZZ') In [4]: Poly((x-p)*(x-q), wrt='q') Out[4]: Poly(-q*x + q*p + x**2 - x*p, q, x, p, domain='ZZ') If `wrt` is specified, Poly will override all rules it has for sorting variables and let this chosen variable to be the main one. Note this is very different from specifying explicit generators, because it does not touch domain analysis algorithms (generators and domain are still figured out using automatic tools). If this is not enough, one can specify explicit order of variables, e.g.: In [6]: Poly((x-p)*(x-q), sort='q < p < x') Out[6]: Poly(q*p - q*x - p*x + x**2, q, p, x, domain='ZZ') or even combine `wrt` and `sort` keyword arguments: In [7]: Poly((x-p)*(x-q), wrt='q', sort='p < x') Out[7]: Poly(q*p - q*x - p*x + x**2, q, p, x, domain='ZZ') Poly is now also much more intelligent when unifying polynomials: In [12]: f = (x-p)*(x-q) In [13]: g = (x-r)*(x-s)*(x-t) In [14]: factor(resultant(f, g)) Out[14]: (p - r)⋅(q - r)⋅(p - s)⋅(q - s)⋅(p - t)⋅(q - t) resultant() of f and g was computed with respect to `x` variable, which is intuitive, but failed in the previous implementation. And more examples: In [15]: factor(resultant(f, g, wrt='x')) Out[15]: (p - r)⋅(q - r)⋅(p - s)⋅(q - s)⋅(p - t)⋅(q - t) In [16]: factor(resultant(f, g, wrt='p')) Out[16]: (x - r)⋅(x - s)⋅(x - t) In [17]: factor(resultant(f, g, wrt='q')) Out[17]: (x - r)⋅(x - s)⋅(x - t) In [18]: factor(resultant(f, g, wrt='r')) Out[18]: (x - p)⋅(x - q) In [19]: factor(resultant(f, g, wrt='s')) Out[19]: (x - p)⋅(x - q) In [20]: factor(resultant(f, g, wrt='t')) Out[20]: (x - p)⋅(x - q) 543d05cad635a3cb34a0bcadfbc1ea2eb5d09840 Mateusz Paprocki mattpap mattpap@gmail.com 0c7e701921a8fb83139ae4a26f79cbea1189ef6f Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/b5d2f9e1c0c6ef691cdda6c934a570b174267d38 b5d2f9e1c0c6ef691cdda6c934a570b174267d38 2009-08-17T04:19:23-07:00 2009-08-17T04:15:32-07:00 Improved _analyze_power to work with Real arguments 230495cdf439d6f126751b74f424732148de4cf0 Mateusz Paprocki mattpap mattpap@gmail.com 95f9296df2fa86f4026094a17215035b93c788f3 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/0c7e701921a8fb83139ae4a26f79cbea1189ef6f 0c7e701921a8fb83139ae4a26f79cbea1189ef6f 2009-08-17T04:19:23-07:00 2009-08-16T15:48:56-07:00 Implemented Collins's modular resultant algorithm 1ee798b4a80200ed264f1b8d4f8f2f9855324af8 Mateusz Paprocki mattpap mattpap@gmail.com bfcb3ae53bf91d2ec0b37115a58177e8d8a49cbc Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/95f9296df2fa86f4026094a17215035b93c788f3 95f9296df2fa86f4026094a17215035b93c788f3 2009-08-17T04:19:23-07:00 2009-08-16T15:50:18-07:00 Enabled and fixed tests for dmp_content() function 0da8ad9d5e1c64410e6c068e0891f5bb52189926 Mateusz Paprocki mattpap mattpap@gmail.com 4043b2f7ef1a29a54a0ba8a28be882045d34b1d8 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/bfcb3ae53bf91d2ec0b37115a58177e8d8a49cbc bfcb3ae53bf91d2ec0b37115a58177e8d8a49cbc 2009-08-17T04:19:23-07:00 2009-08-16T16:00:03-07:00 Implemented dmp_apply_pairs() function in densebasic.py 778756944b880c27414886bc4feda8c0b1001b77 Mateusz Paprocki mattpap mattpap@gmail.com 4c13373e7fe722979e4fa8391c272767e37c2b54 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/4043b2f7ef1a29a54a0ba8a28be882045d34b1d8 4043b2f7ef1a29a54a0ba8a28be882045d34b1d8 2009-08-17T04:19:23-07:00 2009-08-16T16:01:13-07:00 Slightly improved efficiency of DUP and DMP arithmetics 325946d120cdae5d71023e7d0fc1b6612ad94e3d Mateusz Paprocki mattpap mattpap@gmail.com be1a0fd40b66db956a4b89c8232254d888500e35 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/4c13373e7fe722979e4fa8391c272767e37c2b54 4c13373e7fe722979e4fa8391c272767e37c2b54 2009-08-17T04:18:45-07:00 2009-08-16T15:43:38-07:00 Implemented Berlekamp's factorization algorithm over GF(p) 839fe35c9136376c99ec719867153fab0826ccae Mateusz Paprocki mattpap mattpap@gmail.com 82cb57e052eb2e180c61f1ec35fda3075eb73e5a Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/be1a0fd40b66db956a4b89c8232254d888500e35 be1a0fd40b66db956a4b89c8232254d888500e35 2009-08-13T11:00:17-07:00 2009-08-13T03:40:41-07:00 Fixed sympy.solvers.recurr to work with new polynomials 3eb7ba6a85339a85daea1153c1ff1b749287ff71 Mateusz Paprocki mattpap mattpap@gmail.com 10f3bf59cc0b63eeaac2de70ca07d8c6caa1b812 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/82cb57e052eb2e180c61f1ec35fda3075eb73e5a 82cb57e052eb2e180c61f1ec35fda3075eb73e5a 2009-08-13T11:00:06-07:00 2009-08-13T02:47:49-07:00 Fixed sympy.solvers.solvers to work with new polynomials c0bd2615e082f750d04f402796c201d303a21793 Mateusz Paprocki mattpap mattpap@gmail.com df0086f22211d02ae1ff3a67eac9d97efe649e4b Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/10f3bf59cc0b63eeaac2de70ca07d8c6caa1b812 10f3bf59cc0b63eeaac2de70ca07d8c6caa1b812 2009-08-13T10:59:03-07:00 2009-08-13T02:48:36-07:00 Fixed sympy.solvers.polysys to work with new polynomials a2c219ef8ab9efe5fc4303cada817ac96e8d190d Mateusz Paprocki mattpap mattpap@gmail.com d36eae38ead613e7b0d206c3ac21b32eba51d4ae Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/df0086f22211d02ae1ff3a67eac9d97efe649e4b df0086f22211d02ae1ff3a67eac9d97efe649e4b 2009-08-13T10:59:03-07:00 2009-08-13T03:27:02-07:00 Fixed sympy.statistics to work with new polynomials 1ddd0becee5667f78eda5fac30a84c77adce3518 Mateusz Paprocki mattpap mattpap@gmail.com 9b74b78526f7a2485eb3e99205c8bb88e0bd8ee2 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/d36eae38ead613e7b0d206c3ac21b32eba51d4ae d36eae38ead613e7b0d206c3ac21b32eba51d4ae 2009-08-13T10:59:03-07:00 2009-08-13T00:25:54-07:00 Fixed sympy.concrete to work with new polynomials dd44fab43e475be74bbf9007242368af7dfaf91d Mateusz Paprocki mattpap mattpap@gmail.com 6252fab1b20d145b63b79148608148dc10d83bc0 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/9b74b78526f7a2485eb3e99205c8bb88e0bd8ee2 9b74b78526f7a2485eb3e99205c8bb88e0bd8ee2 2009-08-13T10:59:03-07:00 2009-08-13T03:24:07-07:00 Fixed sympy.integrals to work with new polynomials b36c72277ba467237c08ec2cdc49259098ed091b Mateusz Paprocki mattpap mattpap@gmail.com c435c76e4344cf3554462897b2e4e92bc1bfb979 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/6252fab1b20d145b63b79148608148dc10d83bc0 6252fab1b20d145b63b79148608148dc10d83bc0 2009-08-13T10:59:03-07:00 2009-08-11T13:36:39-07:00 Fixed sympy.matrices to work with new polynomials 74da0d51ed683bb44df12b40a058b167e907cf90 Mateusz Paprocki mattpap mattpap@gmail.com c09d4c4d53162b79efe968caa22b06844bc64f6d Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/c435c76e4344cf3554462897b2e4e92bc1bfb979 c435c76e4344cf3554462897b2e4e92bc1bfb979 2009-08-13T10:59:03-07:00 2009-08-13T04:29:56-07:00 Fixed sympy.simplify to work with new polynomials 0ee01bbef5f359bd048c676869698b476ca7d944 Mateusz Paprocki mattpap mattpap@gmail.com 3e49284371c2724b3e976d1ef19a361ec0eebd52 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/c09d4c4d53162b79efe968caa22b06844bc64f6d c09d4c4d53162b79efe968caa22b06844bc64f6d 2009-08-13T10:59:03-07:00 2009-08-11T05:03:37-07:00 Fixed sympy.core to use new polynomials properly 88a1c5378c9323fa791416726a96275d0814230d Mateusz Paprocki mattpap mattpap@gmail.com 7f4e5466414302c3106b2ac9e2224eac2f4d75d2 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/3e49284371c2724b3e976d1ef19a361ec0eebd52 3e49284371c2724b3e976d1ef19a361ec0eebd52 2009-08-13T10:59:03-07:00 2009-08-10T12:24:27-07:00 Updated printing code and tests for Poly class 0a15c028222d529e86cf9398f2295935177cdf18 Mateusz Paprocki mattpap mattpap@gmail.com abda494150f90fa7ee659bd1ca9d8d792a1397df Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/7f4e5466414302c3106b2ac9e2224eac2f4d75d2 7f4e5466414302c3106b2ac9e2224eac2f4d75d2 2009-08-13T10:45:05-07:00 2009-04-30T10:23:57-07:00 New module for computing in polynomial algebras This is the second complete rewrite, and hopefully the last one, of polynomials module. The new module implements, new to SymPy, philosophy of performing complicated computations in a multilevel environment, where basic operations are done efficiently without user interface overhead and UI does not mess with any algorithms. Three levels were introduced: L0. Is implemented in procedural style and uses raw polynomial representations as arguments to functions. Most algorithms are implemented on this level including GCD and factorization. There are several sets of functions with special prefixes: 1. gf_ --- polynomials over Galois fields 2. dup_ --- Dense Univariate Polynomials over any domain 3. dmp_ --- Dense Multivariate Polynomials over any domain 4. d(u|m)p_zz_ --- DUP or DMP over integers 5. d(u|m)p_qq_ --- DUP or DMP over rationals 6. d(u|m)p_rr_ --- DUP or DMP over a ring 7. d(u|m)p_ff_ --- DUP or DMP over a field 8. sdp_ --- Sparse Distributed Polynomials over any domain Each type of polynomial: GFP, DUP, DMP, SDP, has a raw representation and function call specification associated: 1. GFP repr: [c_n, ..., c_0] spec: gf_some_function(f, g, p, K) where p is prime >= 2, type int K is any ZZ algebra 2. DUP repr: [c_n, ..., c_0] spec: dup_some_function(f, g, K) where K is any algebra 3. DMP repr: [[...], [...], ..., [...]] spec: dup_some_function(f, g, u, K) where u is number of nested levels - 1 K is any algebra DMP for u = 0 is DUP 4. SDP repr: [(M_n, c_n), ..., (M_0, c_0)] spec: dup_some_function(f, g, u, O, K) where u is number of variables - 1 O is monomial order function K is any algebra L1. Is implemented using OO paradigm and wraps up functionality provided by L0. For each type of polynomial there is a class implemented: GFP, DUP, DMP, SDP. There are additional classes for multivariate rational functions DMF and algebraic number polynomials ANP (a representation of algebraic numbers). Each class is constructed using an explicit representation and algebra specification. Method calls will unify arguments by coercing their ground domains (e.g. ZZ + QQ -> QQ), so there is no need to specify any extra arguments. Note that unification rules on this level are very simple so e.g. operations on a univariate polynomial as one argument and a multivariate polynomial as the other aren't allowed, unless you make any coercions explicitly. For efficiency, every class in L1 doesn't derive from Basic, which allows to use those classes as representations of composite ground domains e.g. ZZ[x,y,z], QQ(x,y). L2. User-level interface to polynomial manipulation algorithms. If you are a user, then you choose this level, which provides you convenient Poly class which wraps L1 classes as internal poly representations but provides user-friendly interface. There is also a set of public functions exported: gcd, lcm, factor and many others. Poly class allows you to convert a SymPy expression into a polynomial. There is no need to specify symbols, Poly class will parse the expression and figure out what are symbols and what are members of the coefficient domain. Note also that you can create polynomials using not only symbols but any expressions, this way Poly.symbols was renamed to Poly.gens, to emphasize this fact, so Poly(sin(x)**2 + 1, sin(x)) are valid arguments to Poly.__init__ and computing e.g. gcd(sin(x)**2 - 1, sin(x) - 1) is also allowed. Polynomial manipulation algorithms understand algebraic properties of elements of a ground domain (polynomial coefficients). For this purpose additional module was implemented to define all important coefficient domains (the only missing is for algebraic numbers). Basically the world is divided into to parts: types and categories (here algebras or domains). Type is an object which caries data and is equipped with algorithms for processing this data in some way using some paradigm for this purpose. Different types have different algorithms and use different paradigms. However from mathematical point of view there are categories which have some properties and don't care about internal behavior of a data type. So, lets suppose we want to compute in integers ring. Then we have a category ZZ, which is supposed to have binary operations +, - *, functions like gcd(), lcm() etc. and some properties. On the other side we have several data types for integers: Python (int), SymPy (Integer) or gmpy (mpz), or maybe even something else. Each of these has different algorithms implemented and have different interfaces, e.g. int does not implement gcd(), which is however implemented by Integer and mpz. On the other hand int and mpz are fast, but Integer is very slow. To have one source base of algorithms we specify a category for a mathematical concept for each data type we want to have, e.g. we have (in algebratools.py) ZZ_python, ZZ_sympy and ZZ_gmpy which implement Ring interface which is based on Algebra abstract class. You can use any of ZZ_* classes as coefficient domains in new polynomials module, by creating instances of those classes. Or you can just from sympy.polys.algebratools import ZZ to get optimal solution for your system (ZZ is an instance). Then if a function gets as parameter K algebra ZZ, then it knows that all coefficients given in a polynomial representation to this function have type ZZ.dtype (e.g. int) and know that int is supposed to provide some methods, e.g. __add__ and that ZZ wraps some other methods, e.g. ZZ.gcd is really igcd from sympy.core.numbers. The same is for other domains: QQ, ZZ[x,y], ZZ(x,y,z), QQ('x') ... There is also one category above all others: EX, which is a wrapper for SymPy expressions. If Poly can't figure out an optimal domain or such domain in not yet implemented (e.g. algebraic numbers), then it uses EX. EX is slow, but tries to do its best to solve zero equivalence problem in a symbolic way (by calling simplify). On L2 level you don't have to care about domains at all. Poly will figure out a domain or fallback to EX. However, when implementing algorithms that require certain algebraic properties to be met, be specific or you loose the battle. The most important thing is to see a difference between computations over a ring and a field, which can cause you a lot of trouble. So, don't hack and use the interface, e.g. don't gcd(), div(), div() but cancel() and it will take care of all weird cases. To specify a domain simply add `domain` keyword argument. Note you need also to specify generators when this kwarg is given (this will change in future) e.g. Poly(x**2*y + z, x, y, domain='ZZ[z]') Domain can be specified as a string or explicit algebra. Allowed strings are 'GF(p)' where p is prime, 'ZZ' or 'Z', 'QQ' or 'Q', 'ZZ[x,y,z]', 'QQ[x,y,z]', 'ZZ(x,y,z'), 'QQ(x,y,z)' and 'EX'. Or from sympy.polys.algebratools import ZZ and ZZ[x,y,z] or even ZZ['x','y','z'] will work. Each algebra implements __getitem__ for this, which fallbacks to poly_ring method. Note that __call__ is used for very different purpose, so don't get tricked, use ZZ.frac_field(x,y,z) or a convenient string representation. If you don't want to specify an exact domain but you know computation has to be done in a field then pass `field=True` to Poly or any polynomial function to force a Field to be chosen rather than a Ring. By default if Poly sees that coefficients fall into a Ring it will choose it, e.g. Poly(x**2 + 1) will have the domain ZZ but Poly(x**2 + 1, field=True) will have QQ Despite that if a function needs a field then it will silently convert to field and continue computations. To disable this set `auto=False`. Don't complain if you get DomainError or ExactQuotientFailed exceptions. This automatic behaviour is available only on L2 level. On other levels no auto-games are played by polynomial manipulation algorithms and if there is an inappropriate domain of computation specified, algorithm will just fail, raising an exception. If you want to compute in Galois fields then specify `modulus` keyword argument. Note that only univariate polynomials are supported and some methods might not be implemented (you will get OperationNotSupported exception). Alternatively specify `domain='GF(p)'` where `p` is a prime integer. Note that when parsing expressions Poly will treat everything which is not a number as a generator. This way gcd(x**2 - 2, x - sqrt(2)) is 1, not x - sqrt(2). Specify generators to override this behaviour. In future `extension` keyword might be included to notify algorithms about algebraic relations between coefficients. 56ea8e9800909f65c38473756a7671f8f49a1910 Mateusz Paprocki mattpap mattpap@gmail.com 239f1c679069e40a8e9d73520350b19a76e1f144 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/abda494150f90fa7ee659bd1ca9d8d792a1397df abda494150f90fa7ee659bd1ca9d8d792a1397df 2009-08-13T09:56:41-07:00 2009-08-11T05:00:56-07:00 Test integrate() interface in core, not integration algorithm 34db54a76c097b47eeb87efb867d713505255876 Mateusz Paprocki mattpap mattpap@gmail.com a3a13442e4075fef494c25065203d0a151ea76ec Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/239f1c679069e40a8e9d73520350b19a76e1f144 239f1c679069e40a8e9d73520350b19a76e1f144 2009-08-13T09:56:41-07:00 2009-08-07T14:04:12-07:00 Added new methods to Integer: gcdex(), gcd(), lcm(), invert() ... e524d74cca135f370618fa948044ad4cdeef128b Mateusz Paprocki mattpap mattpap@gmail.com 1563b13361c06a83b82779e735a8d27eedec47c5 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/a3a13442e4075fef494c25065203d0a151ea76ec a3a13442e4075fef494c25065203d0a151ea76ec 2009-08-13T09:56:41-07:00 2009-08-13T03:07:50-07:00 Added as_Pow() method to exponential function class c61021680ffd1d82866fff66f1d310abeb1811d3 Mateusz Paprocki mattpap mattpap@gmail.com da02a6db743d682b2bedd461839d79c8208217cc Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/1563b13361c06a83b82779e735a8d27eedec47c5 1563b13361c06a83b82779e735a8d27eedec47c5 2009-08-13T09:56:41-07:00 2009-08-07T14:08:16-07:00 Implemented as_Add(), as_Mul() and as_Pow() in sympy.core 6e5ac06e88c96ed618ffdbad6f8b363a1329f9fe Mateusz Paprocki mattpap mattpap@gmail.com 5be916dd1875cff5a1159acc1edb54d0dae9d322 Mateusz Paprocki mattpap mattpap@gmail.com http://github.com/mattpap/sympy-polys/commit/da02a6db743d682b2bedd461839d79c8208217cc da02a6db743d682b2bedd461839d79c8208217cc 2009-08-13T09:56:41-07:00 2009-08-10T11:29:50-07:00 Import any() and all() in runtests.py 46c43d10326288d9c8076955864b68332cf27eaf Mateusz Paprocki mattpap mattpap@gmail.com e47d58e338fb379341eda76abfc5744e723871b0 Ondrej Certik certik ondrej@certik.cz http://github.com/mattpap/sympy-polys/commit/5be916dd1875cff5a1159acc1edb54d0dae9d322 5be916dd1875cff5a1159acc1edb54d0dae9d322 2009-08-10T16:33:31-07:00 2009-08-09T17:53:35-07:00 Install assumptions and queries in setup.py Signed-off-by: Ondrej Certik <ondrej@certik.cz> 0e9a94b019b74228849d8e38d2cef58e86a669f8 Ondrej Certik certik ondrej@certik.cz f695f92dfe1e45e88eff5c14e22aebb39dfbf2a4 Vinzent Steinberg vks Vinzent.Steinberg@gmail.com http://github.com/mattpap/sympy-polys/commit/e47d58e338fb379341eda76abfc5744e723871b0 e47d58e338fb379341eda76abfc5744e723871b0 2009-08-10T11:44:33-07:00 2009-08-10T10:58:44-07:00 Add an option to run tests in random order Just run >>> sympy.test(sort=False) or $ bin/test --random This is to make sure that the test are independent of each other. The motivation to do this is that sometimes tests in sympy are failing if not executed in a certain order, see [1]. [1] http://groups.google.com/group/sympy/browse_thread/thread/a0900b89e7b5000f Signed-off-by: Vinzent Steinberg <Vinzent.Steinberg@gmail.com> Signed-off-by: Ondrej Certik <ondrej@certik.cz> 25d45f3f9cfa016a74ecb1c857787c53a261c42a Vinzent Steinberg vks Vinzent.Steinberg@gmail.com dd61378e16470448084b4935d359d5d20bdc8989 Aaron Meurer asmeurer asmeurer@gmail.com http://github.com/mattpap/sympy-polys/commit/f695f92dfe1e45e88eff5c14e22aebb39dfbf2a4 f695f92dfe1e45e88eff5c14e22aebb39dfbf2a4 2009-08-09T22:25:28-07:00 2009-07-24T21:24:48-07:00 Changed discriminant so that it requires a symbol. This allows you to find the discriminant of a multivariate polynomial with respect to one of the variables. Also allowed symbolic polynomials, instead of just Poly's. Signed-off-by: Ondrej Certik <ondrej@certik.cz> 417c27c050f3537c00455c9ed213e26bd6cd25c4 Ondrej Certik certik ondrej@certik.cz 707238ace690990983cc9b2b8f6997e494d09b13 Aaron Meurer asmeurer asmeurer@gmail.com http://github.com/mattpap/sympy-polys/commit/dd61378e16470448084b4935d359d5d20bdc8989 dd61378e16470448084b4935d359d5d20bdc8989 2009-08-09T22:25:28-07:00 2009-07-23T23:00:02-07:00 Added discriminant function for Polys. The discriminant of a univariate polynomial p of degree n is defined as n**(n*(n-1)/2)/a_n*resultant(p, p'), where p' is the derivative of p and a_n. is the leading coefficient of p. See <http://en.wikipedia.org/wiki/Discriminant> for more info. This is useful because the discriminant of a polynomial vanishes identically iff the polynomial has repeated roots. For example, a quadratic a*x**2 + b*x + c has repeated roots iff the discriminant, b**2 - 4*a*c is equal to 0. This also adds tests. Signed-off-by: Ondrej Certik <ondrej@certik.cz> dd54bed74c9123600dc47db93ee7f859e2e61157 Ondrej Certik certik ondrej@certik.cz