Coverage for /usr/lib/python3/dist-packages/sympy/core/relational.py: 35%

1from __future__ import annotations 

2 

3from .basic import Atom, Basic 

4from .sorting import ordered 

5from .evalf import EvalfMixin 

6from .function import AppliedUndef 

7from .singleton import S 

8from .sympify import _sympify, SympifyError 

9from .parameters import global_parameters 

10from .logic import fuzzy_bool, fuzzy_xor, fuzzy_and, fuzzy_not 

11from sympy.logic.boolalg import Boolean, BooleanAtom 

12from sympy.utilities.iterables import sift 

13from sympy.utilities.misc import filldedent 

14 

15__all__ = ( 

16 'Rel', 'Eq', 'Ne', 'Lt', 'Le', 'Gt', 'Ge', 

17 'Relational', 'Equality', 'Unequality', 'StrictLessThan', 'LessThan', 

18 'StrictGreaterThan', 'GreaterThan', 

19) 

20 

21from .expr import Expr 

22from sympy.multipledispatch import dispatch 

23from .containers import Tuple 

24from .symbol import Symbol 

25 

26 

27def _nontrivBool(side): 

28 return isinstance(side, Boolean) and \ 

29 not isinstance(side, Atom) 

30 

31 

32# Note, see issue 4986. Ideally, we wouldn't want to subclass both Boolean 

33# and Expr. 

34# from .. import Expr 

35 

36 

37def _canonical(cond): 

38 # return a condition in which all relationals are canonical 

39 reps = {r: r.canonical for r in cond.atoms(Relational)} 

40 return cond.xreplace(reps) 

41 # XXX: AttributeError was being caught here but it wasn't triggered by any of 

42 # the tests so I've removed it... 

43 

44 

45def _canonical_coeff(rel): 

46 # return -2*x + 1 < 0 as x > 1/2 

47 # XXX make this part of Relational.canonical? 

48 rel = rel.canonical 

49 if not rel.is_Relational or rel.rhs.is_Boolean: 

50 return rel # Eq(x, True) 

51 b, l = rel.lhs.as_coeff_Add(rational=True) 

52 m, lhs = l.as_coeff_Mul(rational=True) 

53 rhs = (rel.rhs - b)/m 

54 if m < 0: 

55 return rel.reversed.func(lhs, rhs) 

56 return rel.func(lhs, rhs) 

57 

58 

59class Relational(Boolean, EvalfMixin): 

60 """Base class for all relation types. 

61 

62 Explanation 

63 =========== 

64 

65 Subclasses of Relational should generally be instantiated directly, but 

66 Relational can be instantiated with a valid ``rop`` value to dispatch to 

67 the appropriate subclass. 

68 

69 Parameters 

70 ========== 

71 

72 rop : str or None 

73 Indicates what subclass to instantiate. Valid values can be found 

74 in the keys of Relational.ValidRelationOperator. 

75 

76 Examples 

77 ======== 

78 

79 >>> from sympy import Rel 

80 >>> from sympy.abc import x, y 

81 >>> Rel(y, x + x**2, '==') 

82 Eq(y, x**2 + x) 

83 

84 A relation's type can be defined upon creation using ``rop``. 

85 The relation type of an existing expression can be obtained 

86 using its ``rel_op`` property. 

87 Here is a table of all the relation types, along with their 

88 ``rop`` and ``rel_op`` values: 

89 

90 +---------------------+----------------------------+------------+ 

91 |Relation |``rop`` |``rel_op`` | 

92 +=====================+============================+============+ 

93 |``Equality`` |``==`` or ``eq`` or ``None``|``==`` | 

94 +---------------------+----------------------------+------------+ 

95 |``Unequality`` |``!=`` or ``ne`` |``!=`` | 

96 +---------------------+----------------------------+------------+ 

97 |``GreaterThan`` |``>=`` or ``ge`` |``>=`` | 

98 +---------------------+----------------------------+------------+ 

99 |``LessThan`` |``<=`` or ``le`` |``<=`` | 

100 +---------------------+----------------------------+------------+ 

101 |``StrictGreaterThan``|``>`` or ``gt`` |``>`` | 

102 +---------------------+----------------------------+------------+ 

103 |``StrictLessThan`` |``<`` or ``lt`` |``<`` | 

104 +---------------------+----------------------------+------------+ 

105 

106 For example, setting ``rop`` to ``==`` produces an 

107 ``Equality`` relation, ``Eq()``. 

108 So does setting ``rop`` to ``eq``, or leaving ``rop`` unspecified. 

109 That is, the first three ``Rel()`` below all produce the same result. 

110 Using a ``rop`` from a different row in the table produces a 

111 different relation type. 

112 For example, the fourth ``Rel()`` below using ``lt`` for ``rop`` 

113 produces a ``StrictLessThan`` inequality: 

114 

115 >>> from sympy import Rel 

116 >>> from sympy.abc import x, y 

117 >>> Rel(y, x + x**2, '==') 

118 Eq(y, x**2 + x) 

119 >>> Rel(y, x + x**2, 'eq') 

120 Eq(y, x**2 + x) 

121 >>> Rel(y, x + x**2) 

122 Eq(y, x**2 + x) 

123 >>> Rel(y, x + x**2, 'lt') 

124 y < x**2 + x 

125 

126 To obtain the relation type of an existing expression, 

127 get its ``rel_op`` property. 

128 For example, ``rel_op`` is ``==`` for the ``Equality`` relation above, 

129 and ``<`` for the strict less than inequality above: 

130 

131 >>> from sympy import Rel 

132 >>> from sympy.abc import x, y 

133 >>> my_equality = Rel(y, x + x**2, '==') 

134 >>> my_equality.rel_op 

135 '==' 

136 >>> my_inequality = Rel(y, x + x**2, 'lt') 

137 >>> my_inequality.rel_op 

138 '<' 

139 

140 """ 

141 __slots__ = () 

142 

143 ValidRelationOperator: dict[str | None, type[Relational]] = {} 

144 

145 is_Relational = True 

146 

147 # ValidRelationOperator - Defined below, because the necessary classes 

148 # have not yet been defined 

149 

150 def __new__(cls, lhs, rhs, rop=None, **assumptions): 

151 # If called by a subclass, do nothing special and pass on to Basic. 

152 if cls is not Relational: 

153 return Basic.__new__(cls, lhs, rhs, **assumptions) 

154 

155 # XXX: Why do this? There should be a separate function to make a 

156 # particular subclass of Relational from a string. 

157 # 

158 # If called directly with an operator, look up the subclass 

159 # corresponding to that operator and delegate to it 

160 cls = cls.ValidRelationOperator.get(rop, None) 

161 if cls is None: 

162 raise ValueError("Invalid relational operator symbol: %r" % rop) 

163 

164 if not issubclass(cls, (Eq, Ne)): 

165 # validate that Booleans are not being used in a relational 

166 # other than Eq/Ne; 

167 # Note: Symbol is a subclass of Boolean but is considered 

168 # acceptable here. 

169 if any(map(_nontrivBool, (lhs, rhs))): 

170 raise TypeError(filldedent(''' 

171 A Boolean argument can only be used in 

172 Eq and Ne; all other relationals expect 

173 real expressions. 

174 ''')) 

175 

176 return cls(lhs, rhs, **assumptions) 

177 

178 @property 

179 def lhs(self): 

180 """The left-hand side of the relation.""" 

181 return self._args[0] 

182 

183 @property 

184 def rhs(self): 

185 """The right-hand side of the relation.""" 

186 return self._args[1] 

187 

188 @property 

189 def reversed(self): 

190 """Return the relationship with sides reversed. 

191 

192 Examples 

193 ======== 

194 

195 >>> from sympy import Eq 

196 >>> from sympy.abc import x 

197 >>> Eq(x, 1) 

198 Eq(x, 1) 

199 >>> _.reversed 

200 Eq(1, x) 

201 >>> x < 1 

202 x < 1 

203 >>> _.reversed 

204 1 > x 

205 """ 

206 ops = {Eq: Eq, Gt: Lt, Ge: Le, Lt: Gt, Le: Ge, Ne: Ne} 

207 a, b = self.args 

208 return Relational.__new__(ops.get(self.func, self.func), b, a) 

209 

210 @property 

211 def reversedsign(self): 

212 """Return the relationship with signs reversed. 

213 

214 Examples 

215 ======== 

216 

217 >>> from sympy import Eq 

218 >>> from sympy.abc import x 

219 >>> Eq(x, 1) 

220 Eq(x, 1) 

221 >>> _.reversedsign 

222 Eq(-x, -1) 

223 >>> x < 1 

224 x < 1 

225 >>> _.reversedsign 

226 -x > -1 

227 """ 

228 a, b = self.args 

229 if not (isinstance(a, BooleanAtom) or isinstance(b, BooleanAtom)): 

230 ops = {Eq: Eq, Gt: Lt, Ge: Le, Lt: Gt, Le: Ge, Ne: Ne} 

231 return Relational.__new__(ops.get(self.func, self.func), -a, -b) 

232 else: 

233 return self 

234 

235 @property 

236 def negated(self): 

237 """Return the negated relationship. 

238 

239 Examples 

240 ======== 

241 

242 >>> from sympy import Eq 

243 >>> from sympy.abc import x 

244 >>> Eq(x, 1) 

245 Eq(x, 1) 

246 >>> _.negated 

247 Ne(x, 1) 

248 >>> x < 1 

249 x < 1 

250 >>> _.negated 

251 x >= 1 

252 

253 Notes 

254 ===== 

255 

256 This works more or less identical to ``~``/``Not``. The difference is 

257 that ``negated`` returns the relationship even if ``evaluate=False``. 

258 Hence, this is useful in code when checking for e.g. negated relations 

259 to existing ones as it will not be affected by the `evaluate` flag. 

260 

261 """ 

262 ops = {Eq: Ne, Ge: Lt, Gt: Le, Le: Gt, Lt: Ge, Ne: Eq} 

263 # If there ever will be new Relational subclasses, the following line 

264 # will work until it is properly sorted out 

265 # return ops.get(self.func, lambda a, b, evaluate=False: ~(self.func(a, 

266 # b, evaluate=evaluate)))(*self.args, evaluate=False) 

267 return Relational.__new__(ops.get(self.func), *self.args) 

268 

269 @property 

270 def weak(self): 

271 """return the non-strict version of the inequality or self 

272 

273 EXAMPLES 

274 ======== 

275 

276 >>> from sympy.abc import x 

277 >>> (x < 1).weak 

278 x <= 1 

279 >>> _.weak 

280 x <= 1 

281 """ 

282 return self 

283 

284 @property 

285 def strict(self): 

286 """return the strict version of the inequality or self 

287 

288 EXAMPLES 

289 ======== 

290 

291 >>> from sympy.abc import x 

292 >>> (x <= 1).strict 

293 x < 1 

294 >>> _.strict 

295 x < 1 

296 """ 

297 return self 

298 

299 def _eval_evalf(self, prec): 

300 return self.func(*[s._evalf(prec) for s in self.args]) 

301 

302 @property 

303 def canonical(self): 

304 """Return a canonical form of the relational by putting a 

305 number on the rhs, canonically removing a sign or else 

306 ordering the args canonically. No other simplification is 

307 attempted. 

308 

309 Examples 

310 ======== 

311 

312 >>> from sympy.abc import x, y 

313 >>> x < 2 

314 x < 2 

315 >>> _.reversed.canonical 

316 x < 2 

317 >>> (-y < x).canonical 

318 x > -y 

319 >>> (-y > x).canonical 

320 x < -y 

321 >>> (-y < -x).canonical 

322 x < y 

323 

324 The canonicalization is recursively applied: 

325 

326 >>> from sympy import Eq 

327 >>> Eq(x < y, y > x).canonical 

328 True 

329 """ 

330 args = tuple([i.canonical if isinstance(i, Relational) else i for i in self.args]) 

331 if args != self.args: 

332 r = self.func(*args) 

333 if not isinstance(r, Relational): 

334 return r 

335 else: 

336 r = self 

337 if r.rhs.is_number: 

338 if r.rhs.is_Number and r.lhs.is_Number and r.lhs > r.rhs: 

339 r = r.reversed 

340 elif r.lhs.is_number: 

341 r = r.reversed 

342 elif tuple(ordered(args)) != args: 

343 r = r.reversed 

344 

345 LHS_CEMS = getattr(r.lhs, 'could_extract_minus_sign', None) 

346 RHS_CEMS = getattr(r.rhs, 'could_extract_minus_sign', None) 

347 

348 if isinstance(r.lhs, BooleanAtom) or isinstance(r.rhs, BooleanAtom): 

349 return r 

350 

351 # Check if first value has negative sign 

352 if LHS_CEMS and LHS_CEMS(): 

353 return r.reversedsign 

354 elif not r.rhs.is_number and RHS_CEMS and RHS_CEMS(): 

355 # Right hand side has a minus, but not lhs. 

356 # How does the expression with reversed signs behave? 

357 # This is so that expressions of the type 

358 # Eq(x, -y) and Eq(-x, y) 

359 # have the same canonical representation 

360 expr1, _ = ordered([r.lhs, -r.rhs]) 

361 if expr1 != r.lhs: 

362 return r.reversed.reversedsign 

363 

364 return r 

365 

366 def equals(self, other, failing_expression=False): 

367 """Return True if the sides of the relationship are mathematically 

368 identical and the type of relationship is the same. 

369 If failing_expression is True, return the expression whose truth value 

370 was unknown.""" 

371 if isinstance(other, Relational): 

372 if other in (self, self.reversed): 

373 return True 

374 a, b = self, other 

375 if a.func in (Eq, Ne) or b.func in (Eq, Ne): 

376 if a.func != b.func: 

377 return False 

378 left, right = [i.equals(j, 

379 failing_expression=failing_expression) 

380 for i, j in zip(a.args, b.args)] 

381 if left is True: 

382 return right 

383 if right is True: 

384 return left 

385 lr, rl = [i.equals(j, failing_expression=failing_expression) 

386 for i, j in zip(a.args, b.reversed.args)] 

387 if lr is True: 

388 return rl 

389 if rl is True: 

390 return lr 

391 e = (left, right, lr, rl) 

392 if all(i is False for i in e): 

393 return False 

394 for i in e: 

395 if i not in (True, False): 

396 return i 

397 else: 

398 if b.func != a.func: 

399 b = b.reversed 

400 if a.func != b.func: 

401 return False 

402 left = a.lhs.equals(b.lhs, 

403 failing_expression=failing_expression) 

404 if left is False: 

405 return False 

406 right = a.rhs.equals(b.rhs, 

407 failing_expression=failing_expression) 

408 if right is False: 

409 return False 

410 if left is True: 

411 return right 

412 return left 

413 

414 def _eval_simplify(self, **kwargs): 

415 from .add import Add 

416 from .expr import Expr 

417 r = self 

418 r = r.func(*[i.simplify(**kwargs) for i in r.args]) 

419 if r.is_Relational: 

420 if not isinstance(r.lhs, Expr) or not isinstance(r.rhs, Expr): 

421 return r 

422 dif = r.lhs - r.rhs 

423 # replace dif with a valid Number that will 

424 # allow a definitive comparison with 0 

425 v = None 

426 if dif.is_comparable: 

427 v = dif.n(2) 

428 elif dif.equals(0): # XXX this is expensive 

429 v = S.Zero 

430 if v is not None: 

431 r = r.func._eval_relation(v, S.Zero) 

432 r = r.canonical 

433 # If there is only one symbol in the expression, 

434 # try to write it on a simplified form 

435 free = list(filter(lambda x: x.is_real is not False, r.free_symbols)) 

436 if len(free) == 1: 

437 try: 

438 from sympy.solvers.solveset import linear_coeffs 

439 x = free.pop() 

440 dif = r.lhs - r.rhs 

441 m, b = linear_coeffs(dif, x) 

442 if m.is_zero is False: 

443 if m.is_negative: 

444 # Dividing with a negative number, so change order of arguments 

445 # canonical will put the symbol back on the lhs later 

446 r = r.func(-b / m, x) 

447 else: 

448 r = r.func(x, -b / m) 

449 else: 

450 r = r.func(b, S.Zero) 

451 except ValueError: 

452 # maybe not a linear function, try polynomial 

453 from sympy.polys.polyerrors import PolynomialError 

454 from sympy.polys.polytools import gcd, Poly, poly 

455 try: 

456 p = poly(dif, x) 

457 c = p.all_coeffs() 

458 constant = c[-1] 

459 c[-1] = 0 

460 scale = gcd(c) 

461 c = [ctmp / scale for ctmp in c] 

462 r = r.func(Poly.from_list(c, x).as_expr(), -constant / scale) 

463 except PolynomialError: 

464 pass 

465 elif len(free) >= 2: 

466 try: 

467 from sympy.solvers.solveset import linear_coeffs 

468 from sympy.polys.polytools import gcd 

469 free = list(ordered(free)) 

470 dif = r.lhs - r.rhs 

471 m = linear_coeffs(dif, *free) 

472 constant = m[-1] 

473 del m[-1] 

474 scale = gcd(m) 

475 m = [mtmp / scale for mtmp in m] 

476 nzm = list(filter(lambda f: f[0] != 0, list(zip(m, free)))) 

477 if scale.is_zero is False: 

478 if constant != 0: 

479 # lhs: expression, rhs: constant 

480 newexpr = Add(*[i * j for i, j in nzm]) 

481 r = r.func(newexpr, -constant / scale) 

482 else: 

483 # keep first term on lhs 

484 lhsterm = nzm[0][0] * nzm[0][1] 

485 del nzm[0] 

486 newexpr = Add(*[i * j for i, j in nzm]) 

487 r = r.func(lhsterm, -newexpr) 

488 

489 else: 

490 r = r.func(constant, S.Zero) 

491 except ValueError: 

492 pass 

493 # Did we get a simplified result? 

494 r = r.canonical 

495 measure = kwargs['measure'] 

496 if measure(r) < kwargs['ratio'] * measure(self): 

497 return r 

498 else: 

499 return self 

500 

501 def _eval_trigsimp(self, **opts): 

502 from sympy.simplify.trigsimp import trigsimp 

503 return self.func(trigsimp(self.lhs, **opts), trigsimp(self.rhs, **opts)) 

504 

505 def expand(self, **kwargs): 

506 args = (arg.expand(**kwargs) for arg in self.args) 

507 return self.func(*args) 

508 

509 def __bool__(self): 

510 raise TypeError("cannot determine truth value of Relational") 

511 

512 def _eval_as_set(self): 

513 # self is univariate and periodicity(self, x) in (0, None) 

514 from sympy.solvers.inequalities import solve_univariate_inequality 

515 from sympy.sets.conditionset import ConditionSet 

516 syms = self.free_symbols 

517 assert len(syms) == 1 

518 x = syms.pop() 

519 try: 

520 xset = solve_univariate_inequality(self, x, relational=False) 

521 except NotImplementedError: 

522 # solve_univariate_inequality raises NotImplementedError for 

523 # unsolvable equations/inequalities. 

524 xset = ConditionSet(x, self, S.Reals) 

525 return xset 

526 

527 @property 

528 def binary_symbols(self): 

529 # override where necessary 

530 return set() 

531 

532 

533Rel = Relational 

534 

535 

536class Equality(Relational): 

537 """ 

538 An equal relation between two objects. 

539 

540 Explanation 

541 =========== 

542 

543 Represents that two objects are equal. If they can be easily shown 

544 to be definitively equal (or unequal), this will reduce to True (or 

545 False). Otherwise, the relation is maintained as an unevaluated 

546 Equality object. Use the ``simplify`` function on this object for 

547 more nontrivial evaluation of the equality relation. 

548 

549 As usual, the keyword argument ``evaluate=False`` can be used to 

550 prevent any evaluation. 

551 

552 Examples 

553 ======== 

554 

555 >>> from sympy import Eq, simplify, exp, cos 

556 >>> from sympy.abc import x, y 

557 >>> Eq(y, x + x**2) 

558 Eq(y, x**2 + x) 

559 >>> Eq(2, 5) 

560 False 

561 >>> Eq(2, 5, evaluate=False) 

562 Eq(2, 5) 

563 >>> _.doit() 

564 False 

565 >>> Eq(exp(x), exp(x).rewrite(cos)) 

566 Eq(exp(x), sinh(x) + cosh(x)) 

567 >>> simplify(_) 

568 True 

569 

570 See Also 

571 ======== 

572 

573 sympy.logic.boolalg.Equivalent : for representing equality between two 

574 boolean expressions 

575 

576 Notes 

577 ===== 

578 

579 Python treats 1 and True (and 0 and False) as being equal; SymPy 

580 does not. And integer will always compare as unequal to a Boolean: 

581 

582 >>> Eq(True, 1), True == 1 

583 (False, True) 

584 

585 This class is not the same as the == operator. The == operator tests 

586 for exact structural equality between two expressions; this class 

587 compares expressions mathematically. 

588 

589 If either object defines an ``_eval_Eq`` method, it can be used in place of 

590 the default algorithm. If ``lhs._eval_Eq(rhs)`` or ``rhs._eval_Eq(lhs)`` 

591 returns anything other than None, that return value will be substituted for 

592 the Equality. If None is returned by ``_eval_Eq``, an Equality object will 

593 be created as usual. 

594 

595 Since this object is already an expression, it does not respond to 

596 the method ``as_expr`` if one tries to create `x - y` from ``Eq(x, y)``. 

597 This can be done with the ``rewrite(Add)`` method. 

598 

599 .. deprecated:: 1.5 

600 

601 ``Eq(expr)`` with a single argument is a shorthand for ``Eq(expr, 0)``, 

602 but this behavior is deprecated and will be removed in a future version 

603 of SymPy. 

604 

605 """ 

606 rel_op = '==' 

607 

608 __slots__ = () 

609 

610 is_Equality = True 

611 

612 def __new__(cls, lhs, rhs, **options): 

613 evaluate = options.pop('evaluate', global_parameters.evaluate) 

614 lhs = _sympify(lhs) 

615 rhs = _sympify(rhs) 

616 if evaluate: 

617 val = is_eq(lhs, rhs) 

618 if val is None: 

619 return cls(lhs, rhs, evaluate=False) 

620 else: 

621 return _sympify(val) 

622 

623 return Relational.__new__(cls, lhs, rhs) 

624 

625 @classmethod 

626 def _eval_relation(cls, lhs, rhs): 

627 return _sympify(lhs == rhs) 

628 

629 def _eval_rewrite_as_Add(self, *args, **kwargs): 

630 """ 

631 return Eq(L, R) as L - R. To control the evaluation of 

632 the result set pass `evaluate=True` to give L - R; 

633 if `evaluate=None` then terms in L and R will not cancel 

634 but they will be listed in canonical order; otherwise 

635 non-canonical args will be returned. If one side is 0, the 

636 non-zero side will be returned. 

637 

638 Examples 

639 ======== 

640 

641 >>> from sympy import Eq, Add 

642 >>> from sympy.abc import b, x 

643 >>> eq = Eq(x + b, x - b) 

644 >>> eq.rewrite(Add) 

645 2*b 

646 >>> eq.rewrite(Add, evaluate=None).args 

647 (b, b, x, -x) 

648 >>> eq.rewrite(Add, evaluate=False).args 

649 (b, x, b, -x) 

650 """ 

651 from .add import _unevaluated_Add, Add 

652 L, R = args 

653 if L == 0: 

654 return R 

655 if R == 0: 

656 return L 

657 evaluate = kwargs.get('evaluate', True) 

658 if evaluate: 

659 # allow cancellation of args 

660 return L - R 

661 args = Add.make_args(L) + Add.make_args(-R) 

662 if evaluate is None: 

663 # no cancellation, but canonical 

664 return _unevaluated_Add(*args) 

665 # no cancellation, not canonical 

666 return Add._from_args(args) 

667 

668 @property 

669 def binary_symbols(self): 

670 if S.true in self.args or S.false in self.args: 

671 if self.lhs.is_Symbol: 

672 return {self.lhs} 

673 elif self.rhs.is_Symbol: 

674 return {self.rhs} 

675 return set() 

676 

677 def _eval_simplify(self, **kwargs): 

678 # standard simplify 

679 e = super()._eval_simplify(**kwargs) 

680 if not isinstance(e, Equality): 

681 return e 

682 from .expr import Expr 

683 if not isinstance(e.lhs, Expr) or not isinstance(e.rhs, Expr): 

684 return e 

685 free = self.free_symbols 

686 if len(free) == 1: 

687 try: 

688 from .add import Add 

689 from sympy.solvers.solveset import linear_coeffs 

690 x = free.pop() 

691 m, b = linear_coeffs( 

692 e.rewrite(Add, evaluate=False), x) 

693 if m.is_zero is False: 

694 enew = e.func(x, -b / m) 

695 else: 

696 enew = e.func(m * x, -b) 

697 measure = kwargs['measure'] 

698 if measure(enew) <= kwargs['ratio'] * measure(e): 

699 e = enew 

700 except ValueError: 

701 pass 

702 return e.canonical 

703 

704 def integrate(self, *args, **kwargs): 

705 """See the integrate function in sympy.integrals""" 

706 from sympy.integrals.integrals import integrate 

707 return integrate(self, *args, **kwargs) 

708 

709 def as_poly(self, *gens, **kwargs): 

710 '''Returns lhs-rhs as a Poly 

711 

712 Examples 

713 ======== 

714 

715 >>> from sympy import Eq 

716 >>> from sympy.abc import x 

717 >>> Eq(x**2, 1).as_poly(x) 

718 Poly(x**2 - 1, x, domain='ZZ') 

719 ''' 

720 return (self.lhs - self.rhs).as_poly(*gens, **kwargs) 

721 

722 

723Eq = Equality 

724 

725 

726class Unequality(Relational): 

727 """An unequal relation between two objects. 

728 

729 Explanation 

730 =========== 

731 

732 Represents that two objects are not equal. If they can be shown to be 

733 definitively equal, this will reduce to False; if definitively unequal, 

734 this will reduce to True. Otherwise, the relation is maintained as an 

735 Unequality object. 

736 

737 Examples 

738 ======== 

739 

740 >>> from sympy import Ne 

741 >>> from sympy.abc import x, y 

742 >>> Ne(y, x+x**2) 

743 Ne(y, x**2 + x) 

744 

745 See Also 

746 ======== 

747 Equality 

748 

749 Notes 

750 ===== 

751 This class is not the same as the != operator. The != operator tests 

752 for exact structural equality between two expressions; this class 

753 compares expressions mathematically. 

754 

755 This class is effectively the inverse of Equality. As such, it uses the 

756 same algorithms, including any available `_eval_Eq` methods. 

757 

758 """ 

759 rel_op = '!=' 

760 

761 __slots__ = () 

762 

763 def __new__(cls, lhs, rhs, **options): 

764 lhs = _sympify(lhs) 

765 rhs = _sympify(rhs) 

766 evaluate = options.pop('evaluate', global_parameters.evaluate) 

767 if evaluate: 

768 val = is_neq(lhs, rhs) 

769 if val is None: 

770 return cls(lhs, rhs, evaluate=False) 

771 else: 

772 return _sympify(val) 

773 

774 return Relational.__new__(cls, lhs, rhs, **options) 

775 

776 @classmethod 

777 def _eval_relation(cls, lhs, rhs): 

778 return _sympify(lhs != rhs) 

779 

780 @property 

781 def binary_symbols(self): 

782 if S.true in self.args or S.false in self.args: 

783 if self.lhs.is_Symbol: 

784 return {self.lhs} 

785 elif self.rhs.is_Symbol: 

786 return {self.rhs} 

787 return set() 

788 

789 def _eval_simplify(self, **kwargs): 

790 # simplify as an equality 

791 eq = Equality(*self.args)._eval_simplify(**kwargs) 

792 if isinstance(eq, Equality): 

793 # send back Ne with the new args 

794 return self.func(*eq.args) 

795 return eq.negated # result of Ne is the negated Eq 

796 

797 

798Ne = Unequality 

799 

800 

801class _Inequality(Relational): 

802 """Internal base class for all *Than types. 

803 

804 Each subclass must implement _eval_relation to provide the method for 

805 comparing two real numbers. 

806 

807 """ 

808 __slots__ = () 

809 

810 def __new__(cls, lhs, rhs, **options): 

811 

812 try: 

813 lhs = _sympify(lhs) 

814 rhs = _sympify(rhs) 

815 except SympifyError: 

816 return NotImplemented 

817 

818 evaluate = options.pop('evaluate', global_parameters.evaluate) 

819 if evaluate: 

820 for me in (lhs, rhs): 

821 if me.is_extended_real is False: 

822 raise TypeError("Invalid comparison of non-real %s" % me) 

823 if me is S.NaN: 

824 raise TypeError("Invalid NaN comparison") 

825 # First we invoke the appropriate inequality method of `lhs` 

826 # (e.g., `lhs.__lt__`). That method will try to reduce to 

827 # boolean or raise an exception. It may keep calling 

828 # superclasses until it reaches `Expr` (e.g., `Expr.__lt__`). 

829 # In some cases, `Expr` will just invoke us again (if neither it 

830 # nor a subclass was able to reduce to boolean or raise an 

831 # exception). In that case, it must call us with 

832 # `evaluate=False` to prevent infinite recursion. 

833 return cls._eval_relation(lhs, rhs, **options) 

834 

835 # make a "non-evaluated" Expr for the inequality 

836 return Relational.__new__(cls, lhs, rhs, **options) 

837 

838 @classmethod 

839 def _eval_relation(cls, lhs, rhs, **options): 

840 val = cls._eval_fuzzy_relation(lhs, rhs) 

841 if val is None: 

842 return cls(lhs, rhs, evaluate=False) 

843 else: 

844 return _sympify(val) 

845 

846 

847class _Greater(_Inequality): 

848 """Not intended for general use 

849 

850 _Greater is only used so that GreaterThan and StrictGreaterThan may 

851 subclass it for the .gts and .lts properties. 

852 

853 """ 

854 __slots__ = () 

855 

856 @property 

857 def gts(self): 

858 return self._args[0] 

859 

860 @property 

861 def lts(self): 

862 return self._args[1] 

863 

864 

865class _Less(_Inequality): 

866 """Not intended for general use. 

867 

868 _Less is only used so that LessThan and StrictLessThan may subclass it for 

869 the .gts and .lts properties. 

870 

871 """ 

872 __slots__ = () 

873 

874 @property 

875 def gts(self): 

876 return self._args[1] 

877 

878 @property 

879 def lts(self): 

880 return self._args[0] 

881 

882 

883class GreaterThan(_Greater): 

884 r"""Class representations of inequalities. 

885 

886 Explanation 

887 =========== 

888 

889 The ``*Than`` classes represent inequal relationships, where the left-hand 

890 side is generally bigger or smaller than the right-hand side. For example, 

891 the GreaterThan class represents an inequal relationship where the 

892 left-hand side is at least as big as the right side, if not bigger. In 

893 mathematical notation: 

894 

895 lhs $\ge$ rhs 

896 

897 In total, there are four ``*Than`` classes, to represent the four 

898 inequalities: 

899 

900 +-----------------+--------+ 

901 |Class Name | Symbol | 

902 +=================+========+ 

903 |GreaterThan | ``>=`` | 

904 +-----------------+--------+ 

905 |LessThan | ``<=`` | 

906 +-----------------+--------+ 

907 |StrictGreaterThan| ``>`` | 

908 +-----------------+--------+ 

909 |StrictLessThan | ``<`` | 

910 +-----------------+--------+ 

911 

912 All classes take two arguments, lhs and rhs. 

913 

914 +----------------------------+-----------------+ 

915 |Signature Example | Math Equivalent | 

916 +============================+=================+ 

917 |GreaterThan(lhs, rhs) | lhs $\ge$ rhs | 

918 +----------------------------+-----------------+ 

919 |LessThan(lhs, rhs) | lhs $\le$ rhs | 

920 +----------------------------+-----------------+ 

921 |StrictGreaterThan(lhs, rhs) | lhs $>$ rhs | 

922 +----------------------------+-----------------+ 

923 |StrictLessThan(lhs, rhs) | lhs $<$ rhs | 

924 +----------------------------+-----------------+ 

925 

926 In addition to the normal .lhs and .rhs of Relations, ``*Than`` inequality 

927 objects also have the .lts and .gts properties, which represent the "less 

928 than side" and "greater than side" of the operator. Use of .lts and .gts 

929 in an algorithm rather than .lhs and .rhs as an assumption of inequality