Coverage for sympy/sets/sets.py : 47%
Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
|
from __future__ import print_function, division
from itertools import product
from sympy.core.sympify import (_sympify, sympify, converter, SympifyError) from sympy.core.basic import Basic from sympy.core.expr import Expr from sympy.core.singleton import Singleton, S from sympy.core.evalf import EvalfMixin from sympy.core.numbers import Float from sympy.core.compatibility import (iterable, with_metaclass, ordered, range, PY3) from sympy.core.evaluate import global_evaluate from sympy.core.function import FunctionClass from sympy.core.mul import Mul from sympy.core.relational import Eq from sympy.core.symbol import Symbol, Dummy from sympy.sets.contains import Contains from sympy.utilities.misc import func_name, filldedent
from mpmath import mpi, mpf from sympy.logic.boolalg import And, Or, Not, true, false from sympy.utilities import subsets
class Set(Basic): """ The base class for any kind of set.
This is not meant to be used directly as a container of items. It does not behave like the builtin ``set``; see :class:`FiniteSet` for that.
Real intervals are represented by the :class:`Interval` class and unions of sets by the :class:`Union` class. The empty set is represented by the :class:`EmptySet` class and available as a singleton as ``S.EmptySet``. """ is_number = False is_iterable = False is_interval = False
is_FiniteSet = False is_Interval = False is_ProductSet = False is_Union = False is_Intersection = None is_EmptySet = None is_UniversalSet = None is_Complement = None is_ComplexRegion = False
@staticmethod def _infimum_key(expr): """ Return infimum (if possible) else S.Infinity. """ AttributeError, AssertionError, ValueError):
def union(self, other): """ Returns the union of 'self' and 'other'.
Examples ========
As a shortcut it is possible to use the '+' operator:
>>> from sympy import Interval, FiniteSet >>> Interval(0, 1).union(Interval(2, 3)) [0, 1] U [2, 3] >>> Interval(0, 1) + Interval(2, 3) [0, 1] U [2, 3] >>> Interval(1, 2, True, True) + FiniteSet(2, 3) (1, 2] U {3}
Similarly it is possible to use the '-' operator for set differences:
>>> Interval(0, 2) - Interval(0, 1) (1, 2] >>> Interval(1, 3) - FiniteSet(2) [1, 2) U (2, 3]
"""
def intersect(self, other): """ Returns the intersection of 'self' and 'other'.
>>> from sympy import Interval
>>> Interval(1, 3).intersect(Interval(1, 2)) [1, 2]
>>> from sympy import imageset, Lambda, symbols, S >>> n, m = symbols('n m') >>> a = imageset(Lambda(n, 2*n), S.Integers) >>> a.intersect(imageset(Lambda(m, 2*m + 1), S.Integers)) EmptySet()
"""
def intersection(self, other): """ Alias for :meth:`intersect()` """
def _intersect(self, other): """ This function should only be used internally
self._intersect(other) returns a new, intersected set if self knows how to intersect itself with other, otherwise it returns ``None``
When making a new set class you can be assured that other will not be a :class:`Union`, :class:`FiniteSet`, or :class:`EmptySet`
Used within the :class:`Intersection` class """ return None
def is_disjoint(self, other): """ Returns True if 'self' and 'other' are disjoint
Examples ========
>>> from sympy import Interval >>> Interval(0, 2).is_disjoint(Interval(1, 2)) False >>> Interval(0, 2).is_disjoint(Interval(3, 4)) True
References ==========
.. [1] http://en.wikipedia.org/wiki/Disjoint_sets """ return self.intersect(other) == S.EmptySet
def isdisjoint(self, other): """ Alias for :meth:`is_disjoint()` """ return self.is_disjoint(other)
def _union(self, other): """ This function should only be used internally
self._union(other) returns a new, joined set if self knows how to join itself with other, otherwise it returns ``None``. It may also return a python set of SymPy Sets if they are somehow simpler. If it does this it must be idempotent i.e. the sets returned must return ``None`` with _union'ed with each other
Used within the :class:`Union` class """
def complement(self, universe): """ The complement of 'self' w.r.t the given the universe.
Examples ========
>>> from sympy import Interval, S >>> Interval(0, 1).complement(S.Reals) (-oo, 0) U (1, oo)
>>> Interval(0, 1).complement(S.UniversalSet) UniversalSet() \ [0, 1]
"""
def _complement(self, other): # this behaves as other - self # For each set consider it or it's complement # We need at least one of the sets to be complemented # Consider all 2^n combinations. # We can conveniently represent these options easily using a # ProductSet
# XXX: this doesn't work if the dimentions of the sets isn't same. # A - B is essentially same as A if B has a different # dimentionality than A switch_sets = ProductSet(FiniteSet(o, o - s) for s, o in zip(self.sets, other.sets)) product_sets = (ProductSet(*set) for set in switch_sets) # Union of all combinations but this one return Union(p for p in product_sets if p != other)
return S.EmptySet
return FiniteSet(*[el for el in other if self.contains(el) != True])
def symmetric_difference(self, other): return SymmetricDifference(self, other)
def _symmetric_difference(self, other): return Union(Complement(self, other), Complement(other, self))
@property def inf(self): """ The infimum of 'self'
Examples ========
>>> from sympy import Interval, Union >>> Interval(0, 1).inf 0 >>> Union(Interval(0, 1), Interval(2, 3)).inf 0
"""
@property def _inf(self): raise NotImplementedError("(%s)._inf" % self)
@property def sup(self): """ The supremum of 'self'
Examples ========
>>> from sympy import Interval, Union >>> Interval(0, 1).sup 1 >>> Union(Interval(0, 1), Interval(2, 3)).sup 3
"""
@property def _sup(self): raise NotImplementedError("(%s)._sup" % self)
def contains(self, other): """ Returns True if 'other' is contained in 'self' as an element.
As a shortcut it is possible to use the 'in' operator:
Examples ========
>>> from sympy import Interval >>> Interval(0, 1).contains(0.5) True >>> 0.5 in Interval(0, 1) True
"""
def _contains(self, other): raise NotImplementedError("(%s)._contains(%s)" % (self, other))
def is_subset(self, other): """ Returns True if 'self' is a subset of 'other'.
Examples ========
>>> from sympy import Interval >>> Interval(0, 0.5).is_subset(Interval(0, 1)) True >>> Interval(0, 1).is_subset(Interval(0, 1, left_open=True)) False
""" else: raise ValueError("Unknown argument '%s'" % other)
def issubset(self, other): """ Alias for :meth:`is_subset()` """ return self.is_subset(other)
def is_proper_subset(self, other): """ Returns True if 'self' is a proper subset of 'other'.
Examples ========
>>> from sympy import Interval >>> Interval(0, 0.5).is_proper_subset(Interval(0, 1)) True >>> Interval(0, 1).is_proper_subset(Interval(0, 1)) False
""" if isinstance(other, Set): return self != other and self.is_subset(other) else: raise ValueError("Unknown argument '%s'" % other)
def is_superset(self, other): """ Returns True if 'self' is a superset of 'other'.
Examples ========
>>> from sympy import Interval >>> Interval(0, 0.5).is_superset(Interval(0, 1)) False >>> Interval(0, 1).is_superset(Interval(0, 1, left_open=True)) True
""" if isinstance(other, Set): return other.is_subset(self) else: raise ValueError("Unknown argument '%s'" % other)
def issuperset(self, other): """ Alias for :meth:`is_superset()` """ return self.is_superset(other)
def is_proper_superset(self, other): """ Returns True if 'self' is a proper superset of 'other'.
Examples ========
>>> from sympy import Interval >>> Interval(0, 1).is_proper_superset(Interval(0, 0.5)) True >>> Interval(0, 1).is_proper_superset(Interval(0, 1)) False
""" if isinstance(other, Set): return self != other and self.is_superset(other) else: raise ValueError("Unknown argument '%s'" % other)
def _eval_powerset(self): raise NotImplementedError('Power set not defined for: %s' % self.func)
def powerset(self): """ Find the Power set of 'self'.
Examples ========
>>> from sympy import FiniteSet, EmptySet >>> A = EmptySet() >>> A.powerset() {EmptySet()} >>> A = FiniteSet(1, 2) >>> a, b, c = FiniteSet(1), FiniteSet(2), FiniteSet(1, 2) >>> A.powerset() == FiniteSet(a, b, c, EmptySet()) True
References ==========
.. [1] http://en.wikipedia.org/wiki/Power_set
""" return self._eval_powerset()
@property def measure(self): """ The (Lebesgue) measure of 'self'
Examples ========
>>> from sympy import Interval, Union >>> Interval(0, 1).measure 1 >>> Union(Interval(0, 1), Interval(2, 3)).measure 2
""" return self._measure
@property def boundary(self): """ The boundary or frontier of a set
A point x is on the boundary of a set S if
1. x is in the closure of S. I.e. Every neighborhood of x contains a point in S. 2. x is not in the interior of S. I.e. There does not exist an open set centered on x contained entirely within S.
There are the points on the outer rim of S. If S is open then these points need not actually be contained within S.
For example, the boundary of an interval is its start and end points. This is true regardless of whether or not the interval is open.
Examples ========
>>> from sympy import Interval >>> Interval(0, 1).boundary {0, 1} >>> Interval(0, 1, True, False).boundary {0, 1} """ return self._boundary
@property def is_open(self): if not Intersection(self, self.boundary): return True # We can't confidently claim that an intersection exists return None
@property def is_closed(self): return self.boundary.is_subset(self)
@property def closure(self): return self + self.boundary
@property def interior(self): return self - self.boundary
@property def _boundary(self): raise NotImplementedError()
def _eval_imageset(self, f):
@property def _measure(self): raise NotImplementedError("(%s)._measure" % self)
def __add__(self, other):
def __or__(self, other): return self.union(other)
def __and__(self, other): return self.intersect(other)
def __mul__(self, other):
def __xor__(self, other): return SymmetricDifference(self, other)
def __pow__(self, exp): if not sympify(exp).is_Integer and exp >= 0: raise ValueError("%s: Exponent must be a positive Integer" % exp) return ProductSet([self]*exp)
def __sub__(self, other):
def __contains__(self, other):
class ProductSet(Set): """ Represents a Cartesian Product of Sets.
Returns a Cartesian product given several sets as either an iterable or individual arguments.
Can use '*' operator on any sets for convenient shorthand.
Examples ========
>>> from sympy import Interval, FiniteSet, ProductSet >>> I = Interval(0, 5); S = FiniteSet(1, 2, 3) >>> ProductSet(I, S) [0, 5] x {1, 2, 3}
>>> (2, 2) in ProductSet(I, S) True
>>> Interval(0, 1) * Interval(0, 1) # The unit square [0, 1] x [0, 1]
>>> coin = FiniteSet('H', 'T') >>> set(coin**2) set([(H, H), (H, T), (T, H), (T, T)])
Notes =====
- Passes most operations down to the argument sets - Flattens Products of ProductSets
References ==========
.. [1] http://en.wikipedia.org/wiki/Cartesian_product """ is_ProductSet = True
def __new__(cls, *sets, **assumptions): return sum(map(flatten, arg.args), []) else: raise TypeError("Input must be Sets or iterables of Sets")
return EmptySet()
return sets[0]
def _eval_Eq(self, other): if not other.is_ProductSet: return
if len(self.args) != len(other.args): return false
return And(*(Eq(x, y) for x, y in zip(self.args, other.args)))
def _contains(self, element): """ 'in' operator for ProductSets
Examples ========
>>> from sympy import Interval >>> (2, 3) in Interval(0, 5) * Interval(0, 5) True
>>> (10, 10) in Interval(0, 5) * Interval(0, 5) False
Passes operation on to constituent sets """ try: if len(element) != len(self.args): return false except TypeError: # maybe element isn't an iterable return false return And(* [set.contains(item) for set, item in zip(self.sets, element)])
def _intersect(self, other): """ This function should only be used internally
See Set._intersect for docstring """ if not other.is_ProductSet: return None if len(other.args) != len(self.args): return S.EmptySet return ProductSet(a.intersect(b) for a, b in zip(self.sets, other.sets))
def _union(self, other): if not other.is_ProductSet: return None if len(other.args) != len(self.args): return None if self.args[0] == other.args[0]: return self.args[0] * Union(ProductSet(self.args[1:]), ProductSet(other.args[1:])) if self.args[-1] == other.args[-1]: return Union(ProductSet(self.args[:-1]), ProductSet(other.args[:-1])) * self.args[-1] return None
@property def sets(self):
@property def _boundary(self): return Union(ProductSet(b + b.boundary if i != j else b.boundary for j, b in enumerate(self.sets)) for i, a in enumerate(self.sets))
@property def is_iterable(self): return all(set.is_iterable for set in self.sets)
def __iter__(self): if self.is_iterable: return product(*self.sets) else: raise TypeError("Not all constituent sets are iterable")
@property def _measure(self): measure = 1 for set in self.sets: measure *= set.measure return measure
def __len__(self): return Mul(*[len(s) for s in self.args])
class Interval(Set, EvalfMixin): """ Represents a real interval as a Set.
Usage: Returns an interval with end points "start" and "end".
For left_open=True (default left_open is False) the interval will be open on the left. Similarly, for right_open=True the interval will be open on the right.
Examples ========
>>> from sympy import Symbol, Interval >>> Interval(0, 1) [0, 1] >>> Interval(0, 1, False, True) [0, 1) >>> Interval.Ropen(0, 1) [0, 1) >>> Interval.Lopen(0, 1) (0, 1] >>> Interval.open(0, 1) (0, 1)
>>> a = Symbol('a', real=True) >>> Interval(0, a) [0, a]
Notes ===== - Only real end points are supported - Interval(a, b) with a > b will return the empty set - Use the evalf() method to turn an Interval into an mpmath 'mpi' interval instance
References ==========
.. [1] http://en.wikipedia.org/wiki/Interval_%28mathematics%29 """ is_Interval = True
def __new__(cls, start, end, left_open=False, right_open=False):
for a in [left_open, right_open]): raise NotImplementedError( "left_open and right_open can have only true/false values, " "got %s and %s" % (left_open, right_open))
# Only allow real intervals (use symbols with 'is_real=True'). raise ValueError("Non-real intervals are not supported")
# evaluate if possible return S.EmptySet
return FiniteSet(end)
# Make sure infinite interval end points are open.
@property def start(self): """ The left end point of 'self'.
This property takes the same value as the 'inf' property.
Examples ========
>>> from sympy import Interval >>> Interval(0, 1).start 0
"""
_inf = left = start
@classmethod def open(cls, a, b): """Return an interval including neither boundary."""
@classmethod def Lopen(cls, a, b): """Return an interval not including the left boundary.""" return cls(a, b, True, False)
@classmethod def Ropen(cls, a, b): """Return an interval not including the right boundary.""" return cls(a, b, False, True)
@property def end(self): """ The right end point of 'self'.
This property takes the same value as the 'sup' property.
Examples ========
>>> from sympy import Interval >>> Interval(0, 1).end 1
"""
_sup = right = end
@property def left_open(self): """ True if 'self' is left-open.
Examples ========
>>> from sympy import Interval >>> Interval(0, 1, left_open=True).left_open True >>> Interval(0, 1, left_open=False).left_open False
"""
@property def right_open(self): """ True if 'self' is right-open.
Examples ========
>>> from sympy import Interval >>> Interval(0, 1, right_open=True).right_open True >>> Interval(0, 1, right_open=False).right_open False
"""
def _intersect(self, other): """ This function should only be used internally
See Set._intersect for docstring """ # We only know how to intersect with other intervals
# handle (-oo, oo)
# We can't intersect [0,3] with [x,6] -- we don't know if x>0 or x<0
# Get topology right. else:
else:
else:
def _complement(self, other): True, not self.left_open)
nums = [m for m in other.args if m.is_number] if nums == []: return None
def _union(self, other): """ This function should only be used internally
See Set._union for docstring """ return S.UniversalSet # Non-overlapping intervals (end == start and (end not in self and end not in other))): else:
(other.start != start or other.left_open)) (other.end != end or other.right_open))
# If I have open end points and these endpoints are contained in other. # But only in case, when endpoints are finite. Because # interval does not contain oo or -oo. sympify(other.contains(self.start)) is S.true and self.start.is_finite) sympify(other.contains(self.end)) is S.true and self.end.is_finite) # Fill in my end points and return
@property def _boundary(self): finite_points = [p for p in (self.start, self.end) if abs(p) != S.Infinity] return FiniteSet(*finite_points)
def _contains(self, other): other is S.Infinity or other is S.NegativeInfinity or other is S.NaN or other is S.ComplexInfinity) or other.is_real is False:
else:
else:
def _eval_imageset(self, f): # TODO: handle functions with infinitely many solutions (eg, sin, tan) # TODO: handle multivariate functions
result = S.EmptySet domain_set = self for (p_expr, p_cond) in expr.args: if p_cond is true: intrvl = domain_set else: intrvl = p_cond.as_set() intrvl = Intersection(domain_set, intrvl)
if p_expr.is_Number: image = FiniteSet(p_expr) else: image = imageset(Lambda(var, p_expr), intrvl) result = Union(result, image)
# remove the part which has been `imaged` domain_set = Complement(domain_set, intrvl) if domain_set.is_EmptySet: break return result
return
if x.is_real and x in self] except NotImplementedError: return
if x.is_real and x in self]
# the minimum or maximum value can occur simultaneously # on both the edge of the interval and in some interior # point else: if start == _end and start not in solns: left_open = self.right_open if end == _start and end not in solns: right_open = self.left_open
else: return imageset(f, Interval(self.start, sing[0], self.left_open, True)) + \ Union(*[imageset(f, Interval(sing[i], sing[i + 1], True, True)) for i in range(0, len(sing) - 1)]) + \ imageset(f, Interval(sing[-1], self.end, True, self.right_open))
@property def _measure(self): return self.end - self.start
def to_mpi(self, prec=53): return mpi(mpf(self.start._eval_evalf(prec)), mpf(self.end._eval_evalf(prec)))
def _eval_evalf(self, prec): return Interval(self.left._eval_evalf(prec), self.right._eval_evalf(prec), left_open=self.left_open, right_open=self.right_open)
def _is_comparable(self, other):
@property def is_left_unbounded(self): """Return ``True`` if the left endpoint is negative infinity. """ return self.left is S.NegativeInfinity or self.left == Float("-inf")
@property def is_right_unbounded(self): """Return ``True`` if the right endpoint is positive infinity. """ return self.right is S.Infinity or self.right == Float("+inf")
def as_relational(self, x): """Rewrite an interval in terms of inequalities and logic operators.""" x = sympify(x) if self.right_open: right = x < self.end else: right = x <= self.end if self.left_open: left = self.start < x else: left = self.start <= x return And(left, right)
def _eval_Eq(self, other): if not other.is_Interval: if (other.is_Union or other.is_Complement or other.is_Intersection or other.is_ProductSet): return
return false
return And(Eq(self.left, other.left), Eq(self.right, other.right), self.left_open == other.left_open, self.right_open == other.right_open)
class Union(Set, EvalfMixin): """ Represents a union of sets as a :class:`Set`.
Examples ========
>>> from sympy import Union, Interval >>> Union(Interval(1, 2), Interval(3, 4)) [1, 2] U [3, 4]
The Union constructor will always try to merge overlapping intervals, if possible. For example:
>>> Union(Interval(1, 2), Interval(2, 3)) [1, 3]
See Also ========
Intersection
References ==========
.. [1] http://en.wikipedia.org/wiki/Union_%28set_theory%29 """ is_Union = True
def __new__(cls, *args, **kwargs):
# flatten inputs to merge intersections and iterables
else: raise TypeError("Input must be Sets or iterables of Sets")
# Union of no sets is EmptySet
# Reduce sets using known rules
@staticmethod def reduce(args): """ Simplify a :class:`Union` using known rules
We first start with global rules like 'Merge all FiniteSets'
Then we iterate through all pairs and ask the constituent sets if they can simplify themselves with any other constituent """
# ===== Global Rules ===== # Merge all finite sets
# ===== Pair-wise Rules ===== # Here we depend on rules built into the constituent sets # This returns None if s does not know how to intersect # with t. Returns the newly intersected set otherwise
else:
def _complement(self, universe): # DeMorgan's Law return Intersection(s.complement(universe) for s in self.args)
@property def _inf(self): # We use Min so that sup is meaningful in combination with symbolic # interval end points.
@property def _sup(self): # We use Max so that sup is meaningful in combination with symbolic # end points. from sympy.functions.elementary.miscellaneous import Max return Max(*[set.sup for set in self.args])
def _contains(self, other):
@property def _measure(self): # Measure of a union is the sum of the measures of the sets minus # the sum of their pairwise intersections plus the sum of their # triple-wise intersections minus ... etc...
# Sets is a collection of intersections and a set of elementary # sets which made up those intersections (called "sos" for set of sets) # An example element might of this list might be: # ( {A,B,C}, A.intersect(B).intersect(C) )
# Start with just elementary sets ( ({A}, A), ({B}, B), ... ) # Then get and subtract ( ({A,B}, (A int B), ... ) while non-zero sets = [(FiniteSet(s), s) for s in self.args] measure = 0 parity = 1 while sets: # Add up the measure of these sets and add or subtract it to total measure += parity * sum(inter.measure for sos, inter in sets)
# For each intersection in sets, compute the intersection with every # other set not already part of the intersection. sets = ((sos + FiniteSet(newset), newset.intersect(intersection)) for sos, intersection in sets for newset in self.args if newset not in sos)
# Clear out sets with no measure sets = [(sos, inter) for sos, inter in sets if inter.measure != 0]
# Clear out duplicates sos_list = [] sets_list = [] for set in sets: if set[0] in sos_list: continue else: sos_list.append(set[0]) sets_list.append(set) sets = sets_list
# Flip Parity - next time subtract/add if we added/subtracted here parity *= -1 return measure
@property def _boundary(self): def boundary_of_set(i): """ The boundary of set i minus interior of all other sets """ b = self.args[i].boundary for j, a in enumerate(self.args): if j != i: b = b - a.interior return b return Union(map(boundary_of_set, range(len(self.args))))
def _eval_imageset(self, f):
def as_relational(self, symbol): """Rewrite a Union in terms of equalities and logic operators. """ return Or(*[set.as_relational(symbol) for set in self.args])
@property def is_iterable(self): return all(arg.is_iterable for arg in self.args)
def _eval_evalf(self, prec): try: return Union(set._eval_evalf(prec) for set in self.args) except Exception: raise TypeError("Not all sets are evalf-able")
def __iter__(self): import itertools
# roundrobin recipe taken from itertools documentation: # https://docs.python.org/2/library/itertools.html#recipes def roundrobin(*iterables): "roundrobin('ABC', 'D', 'EF') --> A D E B F C" # Recipe credited to George Sakkis pending = len(iterables) if PY3: nexts = itertools.cycle(iter(it).__next__ for it in iterables) else: nexts = itertools.cycle(iter(it).next for it in iterables) while pending: try: for next in nexts: yield next() except StopIteration: pending -= 1 nexts = itertools.cycle(itertools.islice(nexts, pending))
if all(set.is_iterable for set in self.args): return roundrobin(*(iter(arg) for arg in self.args)) else: raise TypeError("Not all constituent sets are iterable")
class Intersection(Set): """ Represents an intersection of sets as a :class:`Set`.
Examples ========
>>> from sympy import Intersection, Interval >>> Intersection(Interval(1, 3), Interval(2, 4)) [2, 3]
We often use the .intersect method
>>> Interval(1,3).intersect(Interval(2,4)) [2, 3]
See Also ========
Union
References ==========
.. [1] http://en.wikipedia.org/wiki/Intersection_%28set_theory%29 """ is_Intersection = True
def __new__(cls, *args, **kwargs):
# flatten inputs to merge intersections and iterables
else: raise TypeError("Input must be Sets or iterables of Sets")
# args can't be ordered for Partition see issue #9608
# Reduce sets using known rules
@property def is_iterable(self): return any(arg.is_iterable for arg in self.args)
@property def _inf(self): raise NotImplementedError()
@property def _sup(self): raise NotImplementedError()
def _eval_imageset(self, f):
def _contains(self, other): return And(*[set.contains(other) for set in self.args])
def __iter__(self): no_iter = True for s in self.args: if s.is_iterable: no_iter = False other_sets = set(self.args) - set((s,)) other = Intersection(other_sets, evaluate=False) for x in s: c = sympify(other.contains(x)) if c is S.true: yield x elif c is S.false: pass else: yield c
if no_iter: raise ValueError("None of the constituent sets are iterable")
@staticmethod def _handle_finite_sets(args):
for o in fs_args + other) else: pass # drop arg *res, evaluate=False) if res else S.EmptySet *symbolic_s_list, evaluate=False) symbolic_s_list, (x for x in v if x.has(Symbol)))): # all the symbolic elements of `v` are the same # as in `s` so remove the non-symbol containing # expressions from `unk`, since they cannot be # contained for x in non_symbolic_s: if x in unk: unk.remove(x) else: # if only a subset of elements in `s` are # contained in `v` then remove them from `v` # and add this as a new arg if sympify(v.contains(x)) is S.true] v - FiniteSet( *contained, evaluate=False)) else: pass # for coverage
FiniteSet(*unk), other_sets, evaluate=False)
@staticmethod def reduce(args): """ Return a simplified intersection by applying rules.
We first start with global rules like 'if any empty sets, return empty set' and 'distribute unions'.
Then we iterate through all pairs and ask the constituent sets if they can simplify themselves with any other constituent """
# ===== Global Rules ===== # If any EmptySets return EmptySet
# Handle Finite sets
# If any of the sets are unions, return a Union of Intersections else: return Union(arg for arg in s.args)
# At this stage we are guaranteed not to have any # EmptySets, FiniteSets, or Unions in the intersection
# ===== Pair-wise Rules ===== # Here we depend on rules built into the constituent sets # This returns None if s does not know how to intersect # with t. Returns the newly intersected set otherwise
else:
def as_relational(self, symbol): """Rewrite an Intersection in terms of equalities and logic operators""" return And(*[set.as_relational(symbol) for set in self.args])
class Complement(Set, EvalfMixin): """Represents the set difference or relative complement of a set with another set.
`A - B = \{x \in A| x \\notin B\}`
Examples ========
>>> from sympy import Complement, FiniteSet >>> Complement(FiniteSet(0, 1, 2), FiniteSet(1)) {0, 2}
See Also =========
Intersection, Union
References ==========
.. [1] http://mathworld.wolfram.com/ComplementSet.html """
is_Complement = True
def __new__(cls, a, b, evaluate=True):
@staticmethod def reduce(A, B): """ Simplify a :class:`Complement`.
"""
return Intersection(s.complement(A) for s in B.args)
else:
def _contains(self, other):
class EmptySet(with_metaclass(Singleton, Set)): """ Represents the empty set. The empty set is available as a singleton as S.EmptySet.
Examples ========
>>> from sympy import S, Interval >>> S.EmptySet EmptySet()
>>> Interval(1, 2).intersect(S.EmptySet) EmptySet()
See Also ========
UniversalSet
References ==========
.. [1] http://en.wikipedia.org/wiki/Empty_set """ is_EmptySet = True is_FiniteSet = True
def _intersect(self, other): return S.EmptySet
@property def _measure(self): return 0
def _contains(self, other):
def as_relational(self, symbol): return false
def __len__(self):
def _union(self, other):
def __iter__(self):
def _eval_imageset(self, f):
def _eval_powerset(self): return FiniteSet(self)
@property def _boundary(self): return self
def _complement(self, other):
def _symmetric_difference(self, other): return other
class UniversalSet(with_metaclass(Singleton, Set)): """ Represents the set of all things. The universal set is available as a singleton as S.UniversalSet
Examples ========
>>> from sympy import S, Interval >>> S.UniversalSet UniversalSet()
>>> Interval(1, 2).intersect(S.UniversalSet) [1, 2]
See Also ========
EmptySet
References ==========
.. [1] http://en.wikipedia.org/wiki/Universal_set """
is_UniversalSet = True
def _intersect(self, other):
def _complement(self, other): return S.EmptySet
def _symmetric_difference(self, other): return other
@property def _measure(self): return S.Infinity
def _contains(self, other): return true
def as_relational(self, symbol): return true
def _union(self, other): return self
@property def _boundary(self): return EmptySet()
class FiniteSet(Set, EvalfMixin): """ Represents a finite set of discrete numbers
Examples ========
>>> from sympy import FiniteSet >>> FiniteSet(1, 2, 3, 4) {1, 2, 3, 4} >>> 3 in FiniteSet(1, 2, 3, 4) True
>>> members = [1, 2, 3, 4] >>> FiniteSet(*members) {1, 2, 3, 4}
References ==========
.. [1] http://en.wikipedia.org/wiki/Finite_set """ is_FiniteSet = True is_iterable = True
def __new__(cls, *args, **kwargs):
else:
def _eval_Eq(self, other): if not other.is_FiniteSet: if (other.is_Union or other.is_Complement or other.is_Intersection or other.is_ProductSet): return
return false
if len(self) != len(other): return false
return And(*(Eq(x, y) for x, y in zip(self.args, other.args)))
def __iter__(self):
def _intersect(self, other): """ This function should only be used internally
See Set._intersect for docstring """ if isinstance(other, self.__class__): return self.__class__(*(self._elements & other._elements)) return self.__class__(*[el for el in self if el in other])
def _complement(self, other): # Reals cannot contain elements other than numbers and symbols.
intervals.append(Interval(a, b, True, True)) # both open
return Complement(Union(intervals, evaluate=False), FiniteSet(*syms), evaluate=False) else: return None
def _union(self, other): """ This function should only be used internally
See Set._union for docstring """ return FiniteSet(*(self._elements | other._elements))
# If other set contains one of my elements, remove it from myself FiniteSet(*[x for x in self if other.contains(x) != True]), other))
def _contains(self, other): """ Tests whether an element, other, is in the set.
Relies on Python's set class. This tests for object equality All inputs are sympified
Examples ========
>>> from sympy import FiniteSet >>> 1 in FiniteSet(1, 2) True >>> 5 in FiniteSet(1, 2) False
"""
def _eval_imageset(self, f):
@property def _boundary(self): return self
@property def _inf(self):
@property def _sup(self):
@property def measure(self): return 0
def __len__(self):
def as_relational(self, symbol): """Rewrite a FiniteSet in terms of equalities and logic operators. """ from sympy.core.relational import Eq return Or(*[Eq(symbol, elem) for elem in self])
def compare(self, other): return (hash(self) - hash(other))
def _eval_evalf(self, prec): return FiniteSet(*[elem._eval_evalf(prec) for elem in self])
def _hashable_content(self):
@property def _sorted_args(self):
def _eval_powerset(self): return self.func(*[self.func(*s) for s in subsets(self.args)])
def __ge__(self, other): if not isinstance(other, Set): raise TypeError("Invalid comparison of set with %s" % func_name(other)) return other.is_subset(self)
def __gt__(self, other): if not isinstance(other, Set): raise TypeError("Invalid comparison of set with %s" % func_name(other)) return self.is_proper_superset(other)
def __le__(self, other): if not isinstance(other, Set): raise TypeError("Invalid comparison of set with %s" % func_name(other)) return self.is_subset(other)
def __lt__(self, other): if not isinstance(other, Set): raise TypeError("Invalid comparison of set with %s" % func_name(other)) return self.is_proper_subset(other)
class SymmetricDifference(Set): """Represents the set of elements which are in either of the sets and not in their intersection.
Examples ========
>>> from sympy import SymmetricDifference, FiniteSet >>> SymmetricDifference(FiniteSet(1, 2, 3), FiniteSet(3, 4, 5)) {1, 2, 4, 5}
See Also ========
Complement, Union
References ==========
.. [1] http://en.wikipedia.org/wiki/Symmetric_difference """
is_SymmetricDifference = True
def __new__(cls, a, b, evaluate=True): if evaluate: return SymmetricDifference.reduce(a, b)
return Basic.__new__(cls, a, b)
@staticmethod def reduce(A, B): result = B._symmetric_difference(A) if result is not None: return result else: return SymmetricDifference(A, B, evaluate=False)
def imageset(*args): r""" Return an image of the set under transformation ``f``.
If this function can't compute the image, it returns an unevaluated ImageSet object.
.. math:: { f(x) | x \in self }
Examples ========
>>> from sympy import S, Interval, Symbol, imageset, sin, Lambda >>> from sympy.abc import x, y
>>> imageset(x, 2*x, Interval(0, 2)) [0, 4]
>>> imageset(lambda x: 2*x, Interval(0, 2)) [0, 4]
>>> imageset(Lambda(x, sin(x)), Interval(-2, 1)) ImageSet(Lambda(x, sin(x)), [-2, 1])
>>> imageset(sin, Interval(-2, 1)) ImageSet(Lambda(x, sin(x)), [-2, 1]) >>> imageset(lambda y: x + y, Interval(-2, 1)) ImageSet(Lambda(_x, _x + x), [-2, 1])
Expressions applied to the set of Integers are simplified to show as few negatives as possible and linear expressions are converted to a canonical form. If this is not desirable then the unevaluated ImageSet should be used.
>>> imageset(x, -2*x + 5, S.Integers) ImageSet(Lambda(x, 2*x + 1), Integers())
See Also ========
sympy.sets.fancysets.ImageSet
"""
raise ValueError('imageset expects 2 or 3 args, got: %s' % len(args))
name = func_name(set) raise ValueError( 'last argument should be a set, not %s' % name)
f = Lambda(*args[:2]) elif ( isinstance(f, FunctionClass) # like cos or func_name(f) == '<lambda>' ): var = _uniquely_named_symbol(Symbol('x'), f(Dummy())) expr = f(var) f = Lambda(var, expr) else: raise TypeError(filldedent(''' expecting lambda, Lambda, or FunctionClass, not \'%s\'''' % func_name(f)))
f.expr.subs(f.variables[0], set.lamda.expr)), set.base_set)
|