Merge pull request #183 from skirpichev/misc

Misc fixes

LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2006-2015 SymPy Development Team,
-              2015 Sergey B Kirpichev
+              2015-2016 Sergey B Kirpichev
 
 All rights reserved.
 

docs/conf.py

@@ -44,7 +44,7 @@
 
 # General substitutions.
 project = 'SymPy'
-copyright = '2015 SymPy Development Team, Sergey B Kirpichev'
+copyright = '2016 SymPy Development Team, Sergey B Kirpichev'
 
 # The default replacements for |version| and |release|, also used in various
 # other places throughout the built documents.

sympy/assumptions/ask.py

@@ -269,7 +269,7 @@ def compute_known_facts(known_facts, known_facts_keys):
     mapping = single_fact_lookup(known_facts_keys, cnf)
     items = sorted(mapping.items(), key=str)
     keys = [str(i[0]) for i in items]
-    values = ['set(%s)' % sorted(i[1], key=str) for i in items]
+    values = ['{%s}' % ", ".join(str(a) for a in sorted(i[1], key=str)) for i in items]
     m = LINE.join(['\n'.join(
         wrap("%s: %s" % (k, v),
             subsequent_indent=HANG,

sympy/assumptions/ask_generated.py

@@ -92,67 +92,62 @@
 
 # -{ Known facts in compressed sets }-
 known_facts_dict = {
-    Q.algebraic: set([Q.algebraic, Q.complex, Q.finite]),
-    Q.antihermitian: set([Q.antihermitian]),
-    Q.commutative: set([Q.commutative]),
-    Q.complex: set([Q.complex, Q.finite]),
-    Q.complex_elements: set([Q.complex_elements]),
-    Q.composite: set([Q.composite]),
-    Q.diagonal: set([Q.diagonal, Q.lower_triangular, Q.normal, Q.square,
-        Q.symmetric, Q.triangular, Q.upper_triangular]),
-    Q.even: set([Q.algebraic, Q.complex, Q.even, Q.extended_real,
-        Q.finite, Q.hermitian, Q.integer, Q.rational, Q.real]),
-    Q.extended_real: set([Q.extended_real]),
-    Q.finite: set([Q.finite]),
-    Q.fullrank: set([Q.fullrank]),
-    Q.hermitian: set([Q.hermitian]),
-    Q.imaginary: set([Q.antihermitian, Q.complex, Q.finite, Q.imaginary]),
-    Q.infinite: set([Q.infinite, Q.nonzero]),
-    Q.infinitesimal: set([Q.infinitesimal]),
-    Q.integer: set([Q.algebraic, Q.complex, Q.extended_real, Q.finite,
-        Q.hermitian, Q.integer, Q.rational, Q.real]),
-    Q.integer_elements: set([Q.complex_elements, Q.integer_elements,
-        Q.real_elements]),
-    Q.invertible: set([Q.fullrank, Q.invertible, Q.square]),
-    Q.irrational: set([Q.complex, Q.extended_real, Q.finite, Q.hermitian,
-        Q.irrational, Q.noninteger, Q.nonzero, Q.real]),
-    Q.is_true: set([Q.is_true]),
-    Q.lower_triangular: set([Q.lower_triangular, Q.triangular]),
-    Q.negative: set([Q.extended_real, Q.negative, Q.nonpositive,
-        Q.nonzero]),
-    Q.noninteger: set([Q.complex, Q.extended_real, Q.finite, Q.hermitian,
-        Q.noninteger, Q.nonzero, Q.real]),
-    Q.nonnegative: set([Q.extended_real, Q.nonnegative]),
-    Q.nonpositive: set([Q.extended_real, Q.nonpositive]),
-    Q.nonzero: set([Q.nonzero]),
-    Q.normal: set([Q.normal, Q.square]),
-    Q.odd: set([Q.algebraic, Q.complex, Q.extended_real, Q.finite,
-        Q.hermitian, Q.integer, Q.nonzero, Q.odd, Q.rational, Q.real]),
-    Q.orthogonal: set([Q.fullrank, Q.invertible, Q.normal, Q.orthogonal,
-        Q.positive_definite, Q.square, Q.unitary]),
-    Q.positive: set([Q.extended_real, Q.nonnegative, Q.nonzero,
-        Q.positive]),
-    Q.positive_definite: set([Q.fullrank, Q.invertible,
-        Q.positive_definite, Q.square]),
-    Q.prime: set([Q.algebraic, Q.complex, Q.extended_real, Q.finite,
+    Q.algebraic: {Q.algebraic, Q.complex, Q.finite},
+    Q.antihermitian: {Q.antihermitian},
+    Q.commutative: {Q.commutative},
+    Q.complex: {Q.complex, Q.finite},
+    Q.complex_elements: {Q.complex_elements},
+    Q.composite: {Q.composite},
+    Q.diagonal: {Q.diagonal, Q.lower_triangular, Q.normal, Q.square,
+        Q.symmetric, Q.triangular, Q.upper_triangular},
+    Q.even: {Q.algebraic, Q.complex, Q.even, Q.extended_real, Q.finite,
+        Q.hermitian, Q.integer, Q.rational, Q.real},
+    Q.extended_real: {Q.extended_real},
+    Q.finite: {Q.finite},
+    Q.fullrank: {Q.fullrank},
+    Q.hermitian: {Q.hermitian},
+    Q.imaginary: {Q.antihermitian, Q.complex, Q.finite, Q.imaginary},
+    Q.infinite: {Q.infinite, Q.nonzero},
+    Q.infinitesimal: {Q.infinitesimal},
+    Q.integer: {Q.algebraic, Q.complex, Q.extended_real, Q.finite,
+        Q.hermitian, Q.integer, Q.rational, Q.real},
+    Q.integer_elements: {Q.complex_elements, Q.integer_elements,
+        Q.real_elements},
+    Q.invertible: {Q.fullrank, Q.invertible, Q.square},
+    Q.irrational: {Q.complex, Q.extended_real, Q.finite, Q.hermitian,
+        Q.irrational, Q.noninteger, Q.nonzero, Q.real},
+    Q.is_true: {Q.is_true},
+    Q.lower_triangular: {Q.lower_triangular, Q.triangular},
+    Q.negative: {Q.extended_real, Q.negative, Q.nonpositive, Q.nonzero},
+    Q.noninteger: {Q.complex, Q.extended_real, Q.finite, Q.hermitian,
+        Q.noninteger, Q.nonzero, Q.real},
+    Q.nonnegative: {Q.extended_real, Q.nonnegative},
+    Q.nonpositive: {Q.extended_real, Q.nonpositive},
+    Q.nonzero: {Q.nonzero},
+    Q.normal: {Q.normal, Q.square},
+    Q.odd: {Q.algebraic, Q.complex, Q.extended_real, Q.finite,
+        Q.hermitian, Q.integer, Q.nonzero, Q.odd, Q.rational, Q.real},
+    Q.orthogonal: {Q.fullrank, Q.invertible, Q.normal, Q.orthogonal,
+        Q.positive_definite, Q.square, Q.unitary},
+    Q.positive: {Q.extended_real, Q.nonnegative, Q.nonzero, Q.positive},
+    Q.positive_definite: {Q.fullrank, Q.invertible, Q.positive_definite,
+        Q.square},
+    Q.prime: {Q.algebraic, Q.complex, Q.extended_real, Q.finite,
         Q.hermitian, Q.integer, Q.nonnegative, Q.nonzero, Q.positive,
-        Q.prime, Q.rational, Q.real]),
-    Q.rational: set([Q.algebraic, Q.complex, Q.extended_real, Q.finite,
-        Q.hermitian, Q.rational, Q.real]),
-    Q.real: set([Q.complex, Q.extended_real, Q.finite, Q.hermitian,
-        Q.real]),
-    Q.real_elements: set([Q.complex_elements, Q.real_elements]),
-    Q.singular: set([Q.singular]),
-    Q.square: set([Q.square]),
-    Q.symmetric: set([Q.square, Q.symmetric]),
-    Q.transcendental: set([Q.complex, Q.finite, Q.nonzero,
-        Q.transcendental]),
-    Q.triangular: set([Q.triangular]),
-    Q.unit_triangular: set([Q.triangular, Q.unit_triangular]),
-    Q.unitary: set([Q.fullrank, Q.invertible, Q.normal, Q.square,
-        Q.unitary]),
-    Q.upper_triangular: set([Q.triangular, Q.upper_triangular]),
-    Q.zero: set([Q.algebraic, Q.complex, Q.even, Q.extended_real,
-        Q.finite, Q.hermitian, Q.integer, Q.nonnegative,
-        Q.nonpositive, Q.rational, Q.real, Q.zero]),
+        Q.prime, Q.rational, Q.real},
+    Q.rational: {Q.algebraic, Q.complex, Q.extended_real, Q.finite,
+        Q.hermitian, Q.rational, Q.real},
+    Q.real: {Q.complex, Q.extended_real, Q.finite, Q.hermitian, Q.real},
+    Q.real_elements: {Q.complex_elements, Q.real_elements},
+    Q.singular: {Q.singular},
+    Q.square: {Q.square},
+    Q.symmetric: {Q.square, Q.symmetric},
+    Q.transcendental: {Q.complex, Q.finite, Q.nonzero, Q.transcendental},
+    Q.triangular: {Q.triangular},
+    Q.unit_triangular: {Q.triangular, Q.unit_triangular},
+    Q.unitary: {Q.fullrank, Q.invertible, Q.normal, Q.square, Q.unitary},
+    Q.upper_triangular: {Q.triangular, Q.upper_triangular},
+    Q.zero: {Q.algebraic, Q.complex, Q.even, Q.extended_real, Q.finite,
+        Q.hermitian, Q.integer, Q.nonnegative, Q.nonpositive,
+        Q.rational, Q.real, Q.zero},
 }

sympy/assumptions/tests/test_assumptions_2.py

@@ -18,8 +18,7 @@ def test_equal():
 
 def test_pretty():
     assert pretty(Q.positive(x)) == "Q.positive(x)"
-    assert pretty(
-        {Q.positive, Q.integer}) == "set([Q.integer, Q.positive])"
+    assert pretty({Q.positive, Q.integer}) == "{Q.integer, Q.positive}"
 
 
 def test_extract_facts():

sympy/calculus/singularities.py

@@ -47,7 +47,7 @@ def singularities(f, x):
         guess |= singularities(log(f.base)*f.exp, x)
     elif f.func in (log, sign) and len(f.args) == 1:
         guess |= singularities(f.args[0], x)
-        guess |= set([v for v in solve(f.args[0], x) if v.is_real])
+        guess |= {v for v in solve(f.args[0], x) if v.is_real}
     else:
         raise NotImplementedError
 

sympy/combinatorics/partitions.py

@@ -332,7 +332,7 @@ def __new__(cls, partition, integer=None):
             integer, partition = partition, integer
         if isinstance(partition, (dict, Dict)):
             _ = []
-            for k, v in sorted(list(partition.items()), reverse=True):
+            for k, v in sorted(partition.items(), reverse=True):
                 if not v:
                     continue
                 k, v = as_int(k), as_int(v)

sympy/combinatorics/permutations.py

@@ -1448,7 +1448,7 @@ def from_sequence(self, i, key=None):
         >>> Permutation.from_sequence('SymPy', key=lambda x: x.lower())
         Permutation(4)(0, 2)(1, 3)
         """
-        ic = list(zip(i, list(range(len(i)))))
+        ic = list(zip(i, range(len(i))))
         if key:
             ic.sort(key=lambda x: key(x[0]))
         else:
@@ -2227,7 +2227,7 @@ def index(self):
         """
         a = self.array_form
 
-        return sum([j for j in range(len(a) - 1) if a[j] > a[j + 1]])
+        return sum(j for j in range(len(a) - 1) if a[j] > a[j + 1])
 
     def runs(self):
         """
@@ -2614,7 +2614,7 @@ def get_positional_distance(self, other):
         b = other.array_form
         if len(a) != len(b):
             raise ValueError("The permutations must be of the same size.")
-        return sum([abs(a[i] - b[i]) for i in range(len(a))])
+        return sum(abs(a[i] - b[i]) for i in range(len(a)))
 
     @classmethod
     def josephus(self, m, n, s=1):

sympy/combinatorics/tests/test_partitions.py

@@ -9,7 +9,7 @@
 def test_partition():
     from sympy.abc import x
 
-    pytest.raises(ValueError, lambda: Partition(*list(range(3))))
+    pytest.raises(ValueError, lambda: Partition(*range(3)))
     pytest.raises(ValueError, lambda: Partition([1, 1, 2]))
 
     a = Partition([1, 2, 3], [4])

sympy/concrete/delta.py

@@ -183,10 +183,10 @@ def deltaproduct(f, limit):
         newexpr = f.func(*terms)
         k = Dummy("kprime", integer=True)
         if isinstance(limit[1], int) and isinstance(limit[2], int):
-            result = deltaproduct(newexpr, limit) + sum([
+            result = deltaproduct(newexpr, limit) + sum(
                 deltaproduct(newexpr, (limit[0], limit[1], ik - 1)) *
                 delta.subs(limit[0], ik) *
-                deltaproduct(newexpr, (limit[0], ik + 1, limit[2])) for ik in range(int(limit[1]), int(limit[2] + 1))]
+                deltaproduct(newexpr, (limit[0], ik + 1, limit[2])) for ik in range(int(limit[1]), int(limit[2] + 1))
             )
         else:
             result = deltaproduct(newexpr, limit) + deltasummation(

sympy/core/assumptions.py

@@ -154,7 +154,7 @@
 
 from random import shuffle
 
-from sympy.core.facts import FactRules, FactKB
+from .facts import FactRules, FactKB
 
 
 _assume_rules = FactRules([

sympy/core/basic.py

@@ -496,8 +496,8 @@ def canonical_variables(self):
             u += "_"
         name = '%%i%s' % u
         V = self.variables
-        return dict(list(zip(V, [Symbol(name % i, **v.assumptions0)
-            for i, v in enumerate(V)])))
+        return dict(zip(V, (Symbol(name % i, **v.assumptions0)
+                            for i, v in enumerate(V))))
 
     def rcall(self, *args):
         """Apply on the argument recursively through the expression tree.
@@ -747,15 +747,10 @@ def subs(self, *args, **kwargs):
         >>> from sympy import sqrt, sin, cos
         >>> from sympy.abc import a, b, c, d, e
 
-        >>> A = (sqrt(sin(2*x)), a)
-        >>> B = (sin(2*x), b)
-        >>> C = (cos(2*x), c)
-        >>> D = (x, d)
-        >>> E = (exp(x), e)
-
         >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)
 
-        >>> expr.subs(dict([A, B, C, D, E]))
+        >>> expr.subs({sqrt(sin(2*x)): a, sin(2*x): b,
+        ...            cos(2*x): c, x: d, exp(x): e})
         a*c*sin(d*e) + b
 
         The resulting expression represents a literal replacement of the

sympy/core/cache.py

@@ -52,7 +52,7 @@ def __cacheit_nocache(func):
 
 
 # from sympy.assumptions.assume import global_assumptions  # circular import
-from sympy.core.evaluate import global_evaluate
+from .evaluate import global_evaluate
 _globals = (global_evaluate,)
 
 

sympy/core/containers.py

@@ -6,9 +6,9 @@
     They are supposed to work seamlessly within the SymPy framework.
 """
 
-from sympy.core.basic import Basic
-from sympy.core.compatibility import as_int
-from sympy.core.sympify import sympify, converter
+from .basic import Basic
+from .compatibility import as_int
+from .sympify import sympify, converter
 from sympy.utilities.iterables import iterable
 
 

sympy/core/evalf.py

@@ -21,10 +21,9 @@
 from mpmath.libmp.libmpf import dps_to_prec, prec_to_dps
 from mpmath.libmp.gammazeta import mpf_bernoulli
 
-from .compatibility import SYMPY_INTS
+from .compatibility import SYMPY_INTS, is_sequence
 from .sympify import sympify
 from .singleton import S
-from sympy.utilities.iterables import is_sequence
 
 LG10 = math.log(10, 2)
 rnd = round_nearest

sympy/core/expr.py

@@ -378,8 +378,8 @@ def _random(self, n=None, re_min=-1, im_min=-1, re_max=1, im_max=1):
         if free:
             from sympy.utilities.randtest import random_complex_number
             a, c, b, d = re_min, re_max, im_min, im_max
-            reps = dict(list(zip(free, [random_complex_number(a, b, c, d, rational=True)
-                           for zi in free])))
+            reps = dict(zip(free, [random_complex_number(a, b, c, d, rational=True)
+                                   for zi in free]))
             try:
                 nmag = abs(self.evalf(2, subs=reps))
             except (ValueError, TypeError):
@@ -1664,7 +1664,8 @@ def as_powers_dict(self):
         commutative factors since the order that they appeared will be lost in
         the dictionary."""
         d = defaultdict(int)
-        d.update(dict([self.as_base_exp()]))
+        b, e = self.as_base_exp()
+        d[b] = e
         return d
 
     def as_coefficients_dict(self):

sympy/core/exprtools.py

@@ -2,21 +2,21 @@
 
 from collections import defaultdict
 
-from sympy.core.add import Add
-from sympy.core.compatibility import iterable, is_sequence, SYMPY_INTS
-from sympy.core.mul import Mul, _keep_coeff
-from sympy.core.power import Pow
-from sympy.core.basic import Basic, preorder_traversal
-from sympy.core.expr import Expr
-from sympy.core.sympify import sympify
-from sympy.core.numbers import Rational, Integer, Number, I
-from sympy.core.singleton import S
-from sympy.core.symbol import Dummy
-from sympy.core.coreerrors import NonCommutativeExpression
-from sympy.core.containers import Tuple, Dict
-from sympy.utilities import default_sort_key
+from .add import Add
+from .compatibility import (iterable, is_sequence, SYMPY_INTS,
+                            default_sort_key, ordered)
+from .mul import Mul, _keep_coeff
+from .power import Pow
+from .basic import Basic, preorder_traversal
+from .expr import Expr
+from .sympify import sympify
+from .numbers import Rational, Integer, Number, I
+from .singleton import S
+from .symbol import Dummy
+from .coreerrors import NonCommutativeExpression
+from .containers import Tuple, Dict
 from sympy.utilities.iterables import (common_prefix, common_suffix,
-                                       variations, ordered)
+                                       variations)
 
 
 def _isnumber(i):