Exemplo n.º 1
0
 def _print_Assignment(self, expr):
     lhs = expr.lhs
     rhs = expr.rhs
     # We special case assignments that take multiple lines
     if isinstance(expr.rhs, C.Piecewise):
         # Here we modify Piecewise so each expression is now
         # an Assignment, and then continue on the print.
         expressions = []
         conditions = []
         for (e, c) in rhs.args:
             expressions.append(Assignment(lhs, e))
             conditions.append(c)
         temp = C.Piecewise(*zip(expressions, conditions))
         return self._print(temp)
     elif isinstance(lhs, C.MatrixSymbol):
         # Here we form an Assignment for each element in the array,
         # printing each one.
         lines = []
         for (i, j) in self._traverse_matrix_indices(lhs):
             temp = Assignment(lhs[i, j], rhs[i, j])
             code0 = self._print(temp)
             lines.append(code0)
         return "\n".join(lines)
     elif self._settings["contract"] and (lhs.has(C.IndexedBase)
                                          or rhs.has(C.IndexedBase)):
         # Here we check if there is looping to be done, and if so
         # print the required loops.
         return self._doprint_loops(rhs, lhs)
     else:
         lhs_code = self._print(lhs)
         rhs_code = self._print(rhs)
         return self._get_statement("%s = %s" % (lhs_code, rhs_code))
Exemplo n.º 2
0
def real_root(arg, n=None):
    """Return the real nth-root of arg if possible. If n is omitted then
    all instances of (-n)**(1/odd) will be changed to -n**(1/odd); this
    will only create a real root of a principle root -- the presence of
    other factors may cause the result to not be real.

    Examples
    ========

    >>> from sympy import root, real_root, Rational
    >>> from sympy.abc import x, n

    >>> real_root(-8, 3)
    -2
    >>> root(-8, 3)
    2*(-1)**(1/3)
    >>> real_root(_)
    -2

    If one creates a non-principle root and applies real_root, the
    result will not be real (so use with caution):

    >>> root(-8, 3, 2)
    -2*(-1)**(2/3)
    >>> real_root(_)
    -2*(-1)**(2/3)


    See Also
    ========

    sympy.polys.rootoftools.RootOf
    sympy.core.power.integer_nthroot
    root, sqrt
    """
    if n is not None:
        try:
            n = as_int(n)
            arg = sympify(arg)
            if arg.is_positive or arg.is_negative:
                rv = root(arg, n)
            else:
                raise ValueError
        except ValueError:
            return root(arg, n)*C.Piecewise(
                (S.One, ~C.Equality(C.im(arg), 0)),
                (C.Pow(S.NegativeOne, S.One/n)**(2*C.floor(n/2)), C.And(
                    C.Equality(n % 2, 1),
                    arg < 0)),
                (S.One, True))
    else:
        rv = sympify(arg)
    n1pow = Transform(lambda x: -(-x.base)**x.exp,
                      lambda x:
                      x.is_Pow and
                      x.base.is_negative and
                      x.exp.is_Rational and
                      x.exp.p == 1 and x.exp.q % 2)
    return rv.xreplace(n1pow)
Exemplo n.º 3
0
 def _print_Assignment(self, expr):
     # Copied from codeprinter, but remove special MatrixSymbol treatment
     lhs = expr.lhs
     rhs = expr.rhs
     # We special case assignments that take multiple lines
     if not self._settings["inline"] and isinstance(expr.rhs, C.Piecewise):
         # Here we modify Piecewise so each expression is now
         # an Assignment, and then continue on the print.
         expressions = []
         conditions = []
         for (e, c) in rhs.args:
             expressions.append(Assignment(lhs, e))
             conditions.append(c)
         temp = C.Piecewise(*zip(expressions, conditions))
         return self._print(temp)
     if self._settings["contract"] and (lhs.has(C.IndexedBase)
                                        or rhs.has(C.IndexedBase)):
         # Here we check if there is looping to be done, and if so
         # print the required loops.
         return self._doprint_loops(rhs, lhs)
     else:
         lhs_code = self._print(lhs)
         rhs_code = self._print(rhs)
         return self._get_statement("%s = %s" % (lhs_code, rhs_code))