Cleaner implementation of Domain.__sub__()
[linpy.git] / linpy / linexprs.py
1 # Copyright 2014 MINES ParisTech
2 #
3 # This file is part of LinPy.
4 #
5 # LinPy is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation, either version 3 of the License, or
8 # (at your option) any later version.
9 #
10 # LinPy is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
14 #
15 # You should have received a copy of the GNU General Public License
16 # along with LinPy. If not, see <http://www.gnu.org/licenses/>.
17
18 import ast
19 import functools
20 import numbers
21 import re
22
23 from collections import OrderedDict, defaultdict, Mapping
24 from fractions import Fraction, gcd
25
26
27 __all__ = [
28 'LinExpr',
29 'Symbol', 'Dummy', 'symbols',
30 'Rational',
31 ]
32
33
34 def _polymorphic(func):
35 @functools.wraps(func)
36 def wrapper(left, right):
37 if isinstance(right, LinExpr):
38 return func(left, right)
39 elif isinstance(right, numbers.Rational):
40 right = Rational(right)
41 return func(left, right)
42 return NotImplemented
43 return wrapper
44
45
46 class LinExpr:
47 """
48 A linear expression consists of a list of coefficient-variable pairs
49 that capture the linear terms, plus a constant term. Linear expressions
50 are used to build constraints. They are temporary objects that typically
51 have short lifespans.
52
53 Linear expressions are generally built using overloaded operators. For
54 example, if x is a Symbol, then x + 1 is an instance of LinExpr.
55
56 LinExpr instances are hashable, and should be treated as immutable.
57 """
58
59 def __new__(cls, coefficients=None, constant=0):
60 """
61 Return a linear expression from a dictionary or a sequence, that maps
62 symbols to their coefficients, and a constant term. The coefficients and
63 the constant term must be rational numbers.
64
65 For example, the linear expression x + 2y + 1 can be constructed using
66 one of the following instructions:
67
68 >>> x, y = symbols('x y')
69 >>> LinExpr({x: 1, y: 2}, 1)
70 >>> LinExpr([(x, 1), (y, 2)], 1)
71
72 However, it may be easier to use overloaded operators:
73
74 >>> x, y = symbols('x y')
75 >>> x + 2*y + 1
76
77 Alternatively, linear expressions can be constructed from a string:
78
79 >>> LinExpr('x + 2*y + 1')
80
81 A linear expression with a single symbol of coefficient 1 and no
82 constant term is automatically subclassed as a Symbol instance. A linear
83 expression with no symbol, only a constant term, is automatically
84 subclassed as a Rational instance.
85 """
86 if isinstance(coefficients, str):
87 if constant != 0:
88 raise TypeError('too many arguments')
89 return LinExpr.fromstring(coefficients)
90 if coefficients is None:
91 return Rational(constant)
92 if isinstance(coefficients, Mapping):
93 coefficients = coefficients.items()
94 coefficients = list(coefficients)
95 for symbol, coefficient in coefficients:
96 if not isinstance(symbol, Symbol):
97 raise TypeError('symbols must be Symbol instances')
98 if not isinstance(coefficient, numbers.Rational):
99 raise TypeError('coefficients must be rational numbers')
100 if not isinstance(constant, numbers.Rational):
101 raise TypeError('constant must be a rational number')
102 if len(coefficients) == 0:
103 return Rational(constant)
104 if len(coefficients) == 1 and constant == 0:
105 symbol, coefficient = coefficients[0]
106 if coefficient == 1:
107 return symbol
108 coefficients = [(symbol, Fraction(coefficient))
109 for symbol, coefficient in coefficients if coefficient != 0]
110 coefficients.sort(key=lambda item: item[0].sortkey())
111 self = object().__new__(cls)
112 self._coefficients = OrderedDict(coefficients)
113 self._constant = Fraction(constant)
114 self._symbols = tuple(self._coefficients)
115 self._dimension = len(self._symbols)
116 return self
117
118 def coefficient(self, symbol):
119 """
120 Return the coefficient value of the given symbol, or 0 if the symbol
121 does not appear in the expression.
122 """
123 if not isinstance(symbol, Symbol):
124 raise TypeError('symbol must be a Symbol instance')
125 return self._coefficients.get(symbol, Fraction(0))
126
127 __getitem__ = coefficient
128
129 def coefficients(self):
130 """
131 Iterate over the pairs (symbol, value) of linear terms in the
132 expression. The constant term is ignored.
133 """
134 yield from self._coefficients.items()
135
136 @property
137 def constant(self):
138 """
139 The constant term of the expression.
140 """
141 return self._constant
142
143 @property
144 def symbols(self):
145 """
146 The tuple of symbols present in the expression, sorted according to
147 Symbol.sortkey().
148 """
149 return self._symbols
150
151 @property
152 def dimension(self):
153 """
154 The dimension of the expression, i.e. the number of symbols present in
155 it.
156 """
157 return self._dimension
158
159 def __hash__(self):
160 return hash((tuple(self._coefficients.items()), self._constant))
161
162 def isconstant(self):
163 """
164 Return True if the expression only consists of a constant term. In this
165 case, it is a Rational instance.
166 """
167 return False
168
169 def issymbol(self):
170 """
171 Return True if an expression only consists of a symbol with coefficient
172 1. In this case, it is a Symbol instance.
173 """
174 return False
175
176 def values(self):
177 """
178 Iterate over the coefficient values in the expression, and the constant
179 term.
180 """
181 yield from self._coefficients.values()
182 yield self._constant
183
184 def __bool__(self):
185 return True
186
187 def __pos__(self):
188 return self
189
190 def __neg__(self):
191 return self * -1
192
193 @_polymorphic
194 def __add__(self, other):
195 """
196 Return the sum of two linear expressions.
197 """
198 coefficients = defaultdict(Fraction, self._coefficients)
199 for symbol, coefficient in other._coefficients.items():
200 coefficients[symbol] += coefficient
201 constant = self._constant + other._constant
202 return LinExpr(coefficients, constant)
203
204 __radd__ = __add__
205
206 @_polymorphic
207 def __sub__(self, other):
208 """
209 Return the difference between two linear expressions.
210 """
211 coefficients = defaultdict(Fraction, self._coefficients)
212 for symbol, coefficient in other._coefficients.items():
213 coefficients[symbol] -= coefficient
214 constant = self._constant - other._constant
215 return LinExpr(coefficients, constant)
216
217 @_polymorphic
218 def __rsub__(self, other):
219 return other - self
220
221 def __mul__(self, other):
222 """
223 Return the product of the linear expression by a rational.
224 """
225 if isinstance(other, numbers.Rational):
226 coefficients = ((symbol, coefficient * other)
227 for symbol, coefficient in self._coefficients.items())
228 constant = self._constant * other
229 return LinExpr(coefficients, constant)
230 return NotImplemented
231
232 __rmul__ = __mul__
233
234 def __truediv__(self, other):
235 """
236 Return the quotient of the linear expression by a rational.
237 """
238 if isinstance(other, numbers.Rational):
239 coefficients = ((symbol, coefficient / other)
240 for symbol, coefficient in self._coefficients.items())
241 constant = self._constant / other
242 return LinExpr(coefficients, constant)
243 return NotImplemented
244
245 @_polymorphic
246 def __eq__(self, other):
247 """
248 Test whether two linear expressions are equal.
249 """
250 if isinstance(other, LinExpr):
251 return self._coefficients == other._coefficients and \
252 self._constant == other._constant
253 return NotImplemented
254
255 def __le__(self, other):
256 from .polyhedra import Le
257 return Le(self, other)
258
259 def __lt__(self, other):
260 from .polyhedra import Lt
261 return Lt(self, other)
262
263 def __ge__(self, other):
264 from .polyhedra import Ge
265 return Ge(self, other)
266
267 def __gt__(self, other):
268 from .polyhedra import Gt
269 return Gt(self, other)
270
271 def scaleint(self):
272 """
273 Return the expression multiplied by its lowest common denominator to
274 make all values integer.
275 """
276 lcd = functools.reduce(lambda a, b: a*b // gcd(a, b),
277 [value.denominator for value in self.values()])
278 return self * lcd
279
280 def subs(self, symbol, expression=None):
281 """
282 Substitute the given symbol by an expression and return the resulting
283 expression. Raise TypeError if the resulting expression is not linear.
284
285 >>> x, y = symbols('x y')
286 >>> e = x + 2*y + 1
287 >>> e.subs(y, x - 1)
288 3*x - 1
289
290 To perform multiple substitutions at once, pass a sequence or a
291 dictionary of (old, new) pairs to subs.
292
293 >>> e.subs({x: y, y: x})
294 2*x + y + 1
295 """
296 if expression is None:
297 substitutions = dict(symbol)
298 else:
299 substitutions = {symbol: expression}
300 for symbol in substitutions:
301 if not isinstance(symbol, Symbol):
302 raise TypeError('symbols must be Symbol instances')
303 result = self._constant
304 for symbol, coefficient in self._coefficients.items():
305 expression = substitutions.get(symbol, symbol)
306 result += coefficient * expression
307 return result
308
309 @classmethod
310 def _fromast(cls, node):
311 if isinstance(node, ast.Module) and len(node.body) == 1:
312 return cls._fromast(node.body[0])
313 elif isinstance(node, ast.Expr):
314 return cls._fromast(node.value)
315 elif isinstance(node, ast.Name):
316 return Symbol(node.id)
317 elif isinstance(node, ast.Num):
318 return Rational(node.n)
319 elif isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub):
320 return -cls._fromast(node.operand)
321 elif isinstance(node, ast.BinOp):
322 left = cls._fromast(node.left)
323 right = cls._fromast(node.right)
324 if isinstance(node.op, ast.Add):
325 return left + right
326 elif isinstance(node.op, ast.Sub):
327 return left - right
328 elif isinstance(node.op, ast.Mult):
329 return left * right
330 elif isinstance(node.op, ast.Div):
331 return left / right
332 raise SyntaxError('invalid syntax')
333
334 _RE_NUM_VAR = re.compile(r'(\d+|\))\s*([^\W\d]\w*|\()')
335
336 @classmethod
337 def fromstring(cls, string):
338 """
339 Create an expression from a string. Raise SyntaxError if the string is
340 not properly formatted.
341 """
342 # Add implicit multiplication operators, e.g. '5x' -> '5*x'.
343 string = LinExpr._RE_NUM_VAR.sub(r'\1*\2', string)
344 tree = ast.parse(string, 'eval')
345 expr = cls._fromast(tree)
346 if not isinstance(expr, cls):
347 raise SyntaxError('invalid syntax')
348 return expr
349
350 def __repr__(self):
351 string = ''
352 for i, (symbol, coefficient) in enumerate(self.coefficients()):
353 if coefficient == 1:
354 if i != 0:
355 string += ' + '
356 elif coefficient == -1:
357 string += '-' if i == 0 else ' - '
358 elif i == 0:
359 string += '{}*'.format(coefficient)
360 elif coefficient > 0:
361 string += ' + {}*'.format(coefficient)
362 else:
363 string += ' - {}*'.format(-coefficient)
364 string += '{}'.format(symbol)
365 constant = self.constant
366 if len(string) == 0:
367 string += '{}'.format(constant)
368 elif constant > 0:
369 string += ' + {}'.format(constant)
370 elif constant < 0:
371 string += ' - {}'.format(-constant)
372 return string
373
374 def _repr_latex_(self):
375 string = ''
376 for i, (symbol, coefficient) in enumerate(self.coefficients()):
377 if coefficient == 1:
378 if i != 0:
379 string += ' + '
380 elif coefficient == -1:
381 string += '-' if i == 0 else ' - '
382 elif i == 0:
383 string += '{}'.format(coefficient._repr_latex_().strip('$'))
384 elif coefficient > 0:
385 string += ' + {}'.format(coefficient._repr_latex_().strip('$'))
386 elif coefficient < 0:
387 string += ' - {}'.format((-coefficient)._repr_latex_().strip('$'))
388 string += '{}'.format(symbol._repr_latex_().strip('$'))
389 constant = self.constant
390 if len(string) == 0:
391 string += '{}'.format(constant._repr_latex_().strip('$'))
392 elif constant > 0:
393 string += ' + {}'.format(constant._repr_latex_().strip('$'))
394 elif constant < 0:
395 string += ' - {}'.format((-constant)._repr_latex_().strip('$'))
396 return '$${}$$'.format(string)
397
398 def _parenstr(self, always=False):
399 string = str(self)
400 if not always and (self.isconstant() or self.issymbol()):
401 return string
402 else:
403 return '({})'.format(string)
404
405 @classmethod
406 def fromsympy(cls, expr):
407 """
408 Create a linear expression from a sympy expression. Raise TypeError is
409 the sympy expression is not linear.
410 """
411 import sympy
412 coefficients = []
413 constant = 0
414 for symbol, coefficient in expr.as_coefficients_dict().items():
415 coefficient = Fraction(coefficient.p, coefficient.q)
416 if symbol == sympy.S.One:
417 constant = coefficient
418 elif isinstance(symbol, sympy.Dummy):
419 # We cannot properly convert dummy symbols with respect to
420 # symbol equalities.
421 raise TypeError('cannot convert dummy symbols')
422 elif isinstance(symbol, sympy.Symbol):
423 symbol = Symbol(symbol.name)
424 coefficients.append((symbol, coefficient))
425 else:
426 raise TypeError('non-linear expression: {!r}'.format(expr))
427 expr = LinExpr(coefficients, constant)
428 if not isinstance(expr, cls):
429 raise TypeError('cannot convert to a {} instance'.format(cls.__name__))
430 return expr
431
432 def tosympy(self):
433 """
434 Convert the linear expression to a sympy expression.
435 """
436 import sympy
437 expr = 0
438 for symbol, coefficient in self.coefficients():
439 term = coefficient * sympy.Symbol(symbol.name)
440 expr += term
441 expr += self.constant
442 return expr
443
444
445 class Symbol(LinExpr):
446 """
447 Symbols are the basic components to build expressions and constraints.
448 They correspond to mathematical variables. Symbols are instances of
449 class LinExpr and inherit its functionalities.
450
451 Two instances of Symbol are equal if they have the same name.
452 """
453
454 __slots__ = (
455 '_name',
456 '_constant',
457 '_symbols',
458 '_dimension',
459 )
460
461 def __new__(cls, name):
462 """
463 Return a symbol with the name string given in argument.
464 """
465 if not isinstance(name, str):
466 raise TypeError('name must be a string')
467 node = ast.parse(name)
468 try:
469 name = node.body[0].value.id
470 except (AttributeError, SyntaxError):
471 raise SyntaxError('invalid syntax')
472 self = object().__new__(cls)
473 self._name = name
474 self._constant = Fraction(0)
475 self._symbols = (self,)
476 self._dimension = 1
477 return self
478
479 @property
480 def _coefficients(self):
481 # This is not implemented as an attribute, because __hash__ is not
482 # callable in __new__ in class Dummy.
483 return {self: Fraction(1)}
484
485 @property
486 def name(self):
487 """
488 The name of the symbol.
489 """
490 return self._name
491
492 def __hash__(self):
493 return hash(self.sortkey())
494
495 def sortkey(self):
496 """
497 Return a sorting key for the symbol. It is useful to sort a list of
498 symbols in a consistent order, as comparison functions are overridden
499 (see the documentation of class LinExpr).
500
501 >>> sort(symbols, key=Symbol.sortkey)
502 """
503 return self.name,
504
505 def issymbol(self):
506 return True
507
508 def __eq__(self, other):
509 if isinstance(other, Symbol):
510 return self.sortkey() == other.sortkey()
511 return NotImplemented
512
513 def asdummy(self):
514 """
515 Return a new Dummy symbol instance with the same name.
516 """
517 return Dummy(self.name)
518
519 def __repr__(self):
520 return self.name
521
522 def _repr_latex_(self):
523 return '$${}$$'.format(self.name)
524
525
526 def symbols(names):
527 """
528 This function returns a tuple of symbols whose names are taken from a comma
529 or whitespace delimited string, or a sequence of strings. It is useful to
530 define several symbols at once.
531
532 >>> x, y = symbols('x y')
533 >>> x, y = symbols('x, y')
534 >>> x, y = symbols(['x', 'y'])
535 """
536 if isinstance(names, str):
537 names = names.replace(',', ' ').split()
538 return tuple(Symbol(name) for name in names)
539
540
541 class Dummy(Symbol):
542 """
543 A variation of Symbol in which all symbols are unique and identified by
544 an internal count index. If a name is not supplied then a string value
545 of the count index will be used. This is useful when a unique, temporary
546 variable is needed and the name of the variable used in the expression
547 is not important.
548
549 Unlike Symbol, Dummy instances with the same name are not equal:
550
551 >>> x = Symbol('x')
552 >>> x1, x2 = Dummy('x'), Dummy('x')
553 >>> x == x1
554 False
555 >>> x1 == x2
556 False
557 >>> x1 == x1
558 True
559 """
560
561 _count = 0
562
563 def __new__(cls, name=None):
564 """
565 Return a fresh dummy symbol with the name string given in argument.
566 """
567 if name is None:
568 name = 'Dummy_{}'.format(Dummy._count)
569 self = super().__new__(cls, name)
570 self._index = Dummy._count
571 Dummy._count += 1
572 return self
573
574 def __hash__(self):
575 return hash(self.sortkey())
576
577 def sortkey(self):
578 return self._name, self._index
579
580 def __repr__(self):
581 return '_{}'.format(self.name)
582
583 def _repr_latex_(self):
584 return '$${}_{{{}}}$$'.format(self.name, self._index)
585
586
587 class Rational(LinExpr, Fraction):
588 """
589 A particular case of linear expressions are rational values, i.e. linear
590 expressions consisting only of a constant term, with no symbol. They are
591 implemented by the Rational class, that inherits from both LinExpr and
592 fractions.Fraction classes.
593 """
594
595 __slots__ = (
596 '_coefficients',
597 '_constant',
598 '_symbols',
599 '_dimension',
600 ) + Fraction.__slots__
601
602 def __new__(cls, numerator=0, denominator=None):
603 self = object().__new__(cls)
604 self._coefficients = {}
605 self._constant = Fraction(numerator, denominator)
606 self._symbols = ()
607 self._dimension = 0
608 self._numerator = self._constant.numerator
609 self._denominator = self._constant.denominator
610 return self
611
612 def __hash__(self):
613 return Fraction.__hash__(self)
614
615 @property
616 def constant(self):
617 return self
618
619 def isconstant(self):
620 return True
621
622 def __bool__(self):
623 return Fraction.__bool__(self)
624
625 def __repr__(self):
626 if self.denominator == 1:
627 return '{!r}'.format(self.numerator)
628 else:
629 return '{!r}/{!r}'.format(self.numerator, self.denominator)
630
631 def _repr_latex_(self):
632 if self.denominator == 1:
633 return '$${}$$'.format(self.numerator)
634 elif self.numerator < 0:
635 return '$$-\\frac{{{}}}{{{}}}$$'.format(-self.numerator,
636 self.denominator)
637 else:
638 return '$$\\frac{{{}}}{{{}}}$$'.format(self.numerator,
639 self.denominator)