def __new__(cls, variable, condition, base_set=S.UniversalSet):
# nonlinsolve uses ConditionSet to return an unsolved system
# of equations (see _return_conditionset in solveset) so until
# that is changed we do minimal checking of the args
if isinstance(variable, (Tuple, tuple)): # unsolved eqns syntax
variable = Tuple(*variable)
condition = FiniteSet(*condition)
return Basic.__new__(cls, variable, condition, base_set)
condition = as_Boolean(condition)
if isinstance(base_set, set):
base_set = FiniteSet(*base_set)
elif not base_set.is_set:
raise TypeError('expecting set for base_set')
if condition is S.false:
return S.EmptySet
if condition is S.true:
return base_set
if isinstance(base_set, EmptySet):
return base_set
know = None
if isinstance(base_set, FiniteSet):
sifted = sift(
base_set, lambda _: fuzzy_bool(
condition.subs(variable, _)))
if sifted[None]:
know = FiniteSet(*sifted[True])
base_set = FiniteSet(*sifted[None])
else:
return FiniteSet(*sifted[True])
if isinstance(base_set, cls):
s, c, base_set = base_set.args
if variable == s:
condition = And(condition, c)
elif variable not in c.free_symbols:
condition = And(condition, c.xreplace({s: variable}))
elif s not in condition.free_symbols:
condition = And(condition.xreplace({variable: s}), c)
variable = s
else:
# user will have to use cls.variable to get symbol
dum = Symbol('lambda')
if dum in condition.free_symbols or \
dum in c.free_symbols:
dum = Dummy(str(dum))
condition = And(
condition.xreplace({variable: dum}),
c.xreplace({s: dum}))
variable = dum
from sympy.tensor.indexed import Slice, IndexedBase
assert isinstance(variable, (Symbol, Slice, IndexedBase))
# s = Dummy('lambda')
# if s not in condition.xreplace({variable: s}).free_symbols:
# raise ValueError('non-symbol dummy not recognized in condition')
if condition.is_BooleanFalse:
return S.EmptySet
rv = Basic.__new__(cls, variable, condition, base_set)
return rv if know is None else Union(know, rv)
def __new__(cls, sym, condition, base_set=S.UniversalSet):
# nonlinsolve uses ConditionSet to return an unsolved system
# of equations (see _return_conditionset in solveset) so until
# that is changed we do minimal checking of the args
if isinstance(sym, (Tuple, tuple)): # unsolved eqns syntax
sym = Tuple(*sym)
condition = FiniteSet(*condition)
return Basic.__new__(cls, sym, condition, base_set)
condition = as_Boolean(condition)
if isinstance(base_set, set):
base_set = FiniteSet(*base_set)
elif not isinstance(base_set, Set):
raise TypeError('expecting set for base_set')
if condition is S.false:
return S.EmptySet
if condition is S.true:
return base_set
if isinstance(base_set, EmptySet):
return base_set
know = None
if isinstance(base_set, FiniteSet):
sifted = sift(
base_set, lambda _: fuzzy_bool(
condition.subs(sym, _)))
if sifted[None]:
know = FiniteSet(*sifted[True])
base_set = FiniteSet(*sifted[None])
else:
return FiniteSet(*sifted[True])
if isinstance(base_set, cls):
s, c, base_set = base_set.args
if sym == s:
condition = And(condition, c)
elif sym not in c.free_symbols:
condition = And(condition, c.xreplace({s: sym}))
elif s not in condition.free_symbols:
condition = And(condition.xreplace({sym: s}), c)
sym = s
else:
# user will have to use cls.sym to get symbol
dum = Symbol('lambda')
if dum in condition.free_symbols or \
dum in c.free_symbols:
dum = Dummy(str(dum))
condition = And(
condition.xreplace({sym: dum}),
c.xreplace({s: dum}))
sym = dum
if not isinstance(sym, Symbol):
s = Dummy('lambda')
if s not in condition.xreplace({sym: s}).free_symbols:
raise ValueError(
'non-symbol dummy not recognized in condition')
rv = Basic.__new__(cls, sym, condition, base_set)
return rv if know is None else Union(know, rv)
def __new__(cls, sym, condition, base_set=S.UniversalSet):
# nonlinsolve uses ConditionSet to return an unsolved system
# of equations (see _return_conditionset in solveset) so until
# that is changed we do minimal checking of the args
if isinstance(sym, (Tuple, tuple)): # unsolved eqns syntax
sym = Tuple(*sym)
condition = FiniteSet(*condition)
return Basic.__new__(cls, sym, condition, base_set)
condition = as_Boolean(condition)
if isinstance(base_set, set):
base_set = FiniteSet(*base_set)
elif not isinstance(base_set, Set):
raise TypeError('expecting set for base_set')
if condition is S.false:
return S.EmptySet
if condition is S.true:
return base_set
if isinstance(base_set, EmptySet):
return base_set
know = None
if isinstance(base_set, FiniteSet):
sifted = sift(
base_set, lambda _: fuzzy_bool(
condition.subs(sym, _)))
if sifted[None]:
know = FiniteSet(*sifted[True])
base_set = FiniteSet(*sifted[None])
else:
return FiniteSet(*sifted[True])
if isinstance(base_set, cls):
s, c, base_set = base_set.args
if sym == s:
condition = And(condition, c)
elif sym not in c.free_symbols:
condition = And(condition, c.xreplace({s: sym}))
elif s not in condition.free_symbols:
condition = And(condition.xreplace({sym: s}), c)
sym = s
else:
# user will have to use cls.sym to get symbol
dum = Symbol('lambda')
if dum in condition.free_symbols or \
dum in c.free_symbols:
dum = Dummy(str(dum))
condition = And(
condition.xreplace({sym: dum}),
c.xreplace({s: dum}))
sym = dum
if not isinstance(sym, Symbol):
s = Dummy('lambda')
if s not in condition.xreplace({sym: s}).free_symbols:
raise ValueError(
'non-symbol dummy not recognized in condition')
rv = Basic.__new__(cls, sym, condition, base_set)
return rv if know is None else Union(know, rv)
