mjo/symbolic.py

   1 from sage.all import *
   2 from sage.interfaces.maxima_lib import maxima_lib
   3 from sage.symbolic.expression import Expression
   4
   5
   6 def set_simplification_domain(d):
   7     """
   8     Set Maxima's simplification domain.
   9
  10     INPUT:
  11
  12       - ``d`` -- The domain, either 'real' or 'complex'.
  13
  14     TESTS:
  15
  16     With the default 'complex' domain, we don't simplify this::
  17
  18         sage: (abs(x)^2).simplify()
  19         abs(x)^2
  20
  21     But in the 'real' domain, we do::
  22
  23         sage: set_simplification_domain('real')
  24         'real'
  25         sage: (abs(x)^2).simplify()
  26         x^2
  27         sage: set_simplification_domain('complex')
  28         'complex'
  29
  30     """
  31     cmd = 'domain: %s;' % d
  32     result = maxima_lib._eval_line(cmd)
  33     return result
  34
  35
  36 def safe_simplify(expr):
  37     """
  38     What should be a totally safe simplification operation that works
  39     a little better than the plain simplify().
  40
  41     Uses a top-level function because we can't monkey-patch Cython
  42     classes.
  43     """
  44     expr = expr.simplify_factorial()
  45     expr = expr.simplify_log()
  46     return expr
  47
  48
  49 def matrix_subs_expr(m, *equations):
  50     """
  51     Symbolic matrices have a `subs()` method, but no `subs_expr()`.
  52     This makes it diffucult to substitute in a list of solutions obtained
  53     with `solve()`.
  54
  55     INPUT:
  56
  57       - ``m`` -- A symbolic matrix.
  58
  59       - ``equations`` - One or more symbolic equations, presumably for
  60         the entries of `m`.
  61
  62     OUTPUT:
  63
  64     The result of substituting each equation into `m`, one after another.
  65
  66     EXAMPLES::
  67
  68     sage: w,x,y,z = SR.var('w,x,y,z')
  69     sage: A = matrix(SR, [[w,x],[y,z]])
  70     sage: matrix_subs_expr(A, w == 1, x == 2, y == 3, z == 4)
  71     [1 2]
  72     [3 4]
  73
  74     """
  75     from sage.symbolic.expression import is_SymbolicEquation
  76
  77     if not m.base_ring() == SR:
  78         raise TypeError, 'the matrix "m" must be symbolic'
  79
  80     if isinstance(equations[0], dict):
  81         eq_dict = equations[0]
  82         equations = [ x == eq_dict[x] for x in eq_dict.keys() ]
  83
  84     if not all([is_SymbolicEquation(eq) for eq in equations]):
  85             raise TypeError, "each expression must be an equation"
  86
  87     d = dict([(eq.lhs(), eq.rhs()) for eq in equations])
  88     return m.subs(d)