Ejemplo n.º 1
0
    def __new__(cls, *args, **assumptions):
        if len(args) == 0:
            return cls.identity

        args = map(_sympify, args)
        if len(args) == 1:
            return args[0]

        if not assumptions.pop('evaluate', True):
            obj = Expr.__new__(cls, *args, **assumptions)
            obj.is_commutative = all(a.is_commutative for a in args)
            return obj

        c_part, nc_part, order_symbols = cls.flatten(args)
        if len(c_part) + len(nc_part) <= 1:
            if c_part:
                obj = c_part[0]
            elif nc_part:
                obj = nc_part[0]
            else:
                obj = cls.identity
        else:
            obj = Expr.__new__(cls, *(c_part + nc_part), **assumptions)
            obj.is_commutative = not nc_part

        if order_symbols is not None:
            obj = C.Order(obj, *order_symbols)
        return obj
Ejemplo n.º 2
0
    def __new__(cls, *args, **options):
        if len(args) == 0:
            return cls.identity

        args = map(_sympify, args)
        if len(args) == 1:
            return args[0]

        if not options.pop('evaluate', True):
            obj = Expr.__new__(cls, *args)
            obj.is_commutative = all(a.is_commutative for a in args)
            return obj

        c_part, nc_part, order_symbols = cls.flatten(args)
        if len(c_part) + len(nc_part) <= 1:
            if c_part:
                obj = c_part[0]
            elif nc_part:
                obj = nc_part[0]
            else:
                obj = cls.identity
        else:
            obj = Expr.__new__(cls, *(c_part + nc_part))
            obj.is_commutative = not nc_part

        if order_symbols is not None:
            obj = C.Order(obj, *order_symbols)
        return obj
Ejemplo n.º 3
0
    def is_number(self):
        """Returns True if 'self' is a number.

           >>> from sympy import log, Integral
           >>> from sympy.abc import x, y

           >>> x.is_number
           False
           >>> (2*x).is_number
           False
           >>> (2 + log(2)).is_number
           True
           >>> (2 + Integral(2, x)).is_number
           False
           >>> (2 + Integral(2, (x, 1, 2))).is_number
           True

        """
        if not self.args:
            return False
        return all(obj.is_number for obj in self.iter_basic_args())
Ejemplo n.º 4
0
    def is_number(self):
        """Returns True if 'self' is a number.

           >>> from sympy import log, Integral
           >>> from sympy.abc import x, y

           >>> x.is_number
           False
           >>> (2*x).is_number
           False
           >>> (2 + log(2)).is_number
           True
           >>> (2 + Integral(2, x)).is_number
           False
           >>> (2 + Integral(2, (x, 1, 2))).is_number
           True

        """
        if not self.args:
            return False
        return all(obj.is_number for obj in self.iter_basic_args())
Ejemplo n.º 5
0
    def _new_rawargs(self, *args, **kwargs):
        """create new instance of own class with args exactly as provided by caller
           but returning the self class identity if args is empty.

           This is handy when we want to optimize things, e.g.

               >>> from sympy import Mul, symbols, S
               >>> from sympy.abc import x, y
               >>> e = Mul(3, x, y)
               >>> e.args
               (3, x, y)
               >>> Mul(*e.args[1:])
               x*y
               >>> e._new_rawargs(*e.args[1:])  # the same as above, but faster
               x*y

           Note: use this with caution. There is no checking of arguments at
           all. This is best used when you are rebuilding an Add or Mul after
           simply removing one or more terms. If modification which result,
           for example, in extra 1s being inserted (as when collecting an
           expression's numerators and denominators) they will not show up in
           the result but a Mul will be returned nonetheless:

               >>> m = (x*y)._new_rawargs(S.One, x); m
               x
               >>> m == x
               False
               >>> m.is_Mul
               True

           Another issue to be aware of is that the commutativity of the result
           is based on the commutativity of self. If you are rebuilding the
           terms that came from a commutative object then there will be no
           problem, but if self was non-commutative then what you are
           rebuilding may now be commutative.

           Although this routine tries to do as little as possible with the
           input, getting the commutativity right is important, so this level
           of safety is enforced: commutativity will always be recomputed if
           either a) self has no is_commutate attribute or b) self is
           non-commutative and kwarg `reeval=False` has not been passed.

           If you don't have an existing Add or Mul and need one quickly, try
           the following.

               >>> m = object.__new__(Mul)
               >>> m._new_rawargs(x, y)
               x*y

           Note that the commutativity is always computed in this case since
           m doesn't have an is_commutative attribute; reeval is ignored:

               >>> _.is_commutative
               True
               >>> hasattr(m, 'is_commutative')
               False
               >>> m._new_rawargs(x, y, reeval=False).is_commutative
               True

           It is possible to define the commutativity of m. If it's False then
           the new Mul's commutivity will be re-evaluated:

               >>> m.is_commutative = False
               >>> m._new_rawargs(x, y).is_commutative
               True

           But if reeval=False then a non-commutative self can pass along
           its non-commutativity to the result (but at least you have to *work*
           to get this wrong):

               >>> m._new_rawargs(x, y, reeval=False).is_commutative
               False

        """
        if len(args) > 1:
            obj = Expr.__new__(type(self),
                               *args)  # NB no assumptions for Add/Mul

            if (hasattr(self, 'is_commutative') and
                (self.is_commutative or not kwargs.pop('reeval', True))):
                obj.is_commutative = self.is_commutative
            else:
                obj.is_commutative = all(a.is_commutative for a in args)

        elif len(args) == 1:
            obj = args[0]
        else:
            obj = self.identity

        return obj
Ejemplo n.º 6
0
    def _new_rawargs(self, *args, **kwargs):
        """create new instance of own class with args exactly as provided by caller
           but returning the self class identity if args is empty.

           This is handy when we want to optimize things, e.g.

               >>> from sympy import Mul, symbols, S
               >>> from sympy.abc import x, y
               >>> e = Mul(3, x, y)
               >>> e.args
               (3, x, y)
               >>> Mul(*e.args[1:])
               x*y
               >>> e._new_rawargs(*e.args[1:])  # the same as above, but faster
               x*y

           Note: use this with caution. There is no checking of arguments at
           all. This is best used when you are rebuilding an Add or Mul after
           simply removing one or more terms. If modification which result,
           for example, in extra 1s being inserted (as when collecting an
           expression's numerators and denominators) they will not show up in
           the result but a Mul will be returned nonetheless:

               >>> m = (x*y)._new_rawargs(S.One, x); m
               x
               >>> m == x
               False
               >>> m.is_Mul
               True

           Another issue to be aware of is that the commutativity of the result
           is based on the commutativity of self. If you are rebuilding the
           terms that came from a commutative object then there will be no
           problem, but if self was non-commutative then what you are
           rebuilding may now be commutative.

           Although this routine tries to do as little as possible with the
           input, getting the commutativity right is important, so this level
           of safety is enforced: commutativity will always be recomputed if
           either a) self has no is_commutate attribute or b) self is
           non-commutative and kwarg `reeval=False` has not been passed.

           If you don't have an existing Add or Mul and need one quickly, try
           the following.

               >>> m = object.__new__(Mul)
               >>> m._new_rawargs(x, y)
               x*y

           Note that the commutativity is always computed in this case since
           m doesn't have an is_commutative attribute; reeval is ignored:

               >>> _.is_commutative
               True
               >>> hasattr(m, 'is_commutative')
               False
               >>> m._new_rawargs(x, y, reeval=False).is_commutative
               True

           It is possible to define the commutativity of m. If it's False then
           the new Mul's commutivity will be re-evaluated:

               >>> m.is_commutative = False
               >>> m._new_rawargs(x, y).is_commutative
               True

           But if reeval=False then a non-commutative self can pass along
           its non-commutativity to the result (but at least you have to *work*
           to get this wrong):

               >>> m._new_rawargs(x, y, reeval=False).is_commutative
               False

        """
        if len(args) > 1:
            obj = Expr.__new__(type(self), *args)  # NB no assumptions for Add/Mul

            if (hasattr(self, 'is_commutative') and
                (self.is_commutative or
                not kwargs.pop('reeval', True))):
                obj.is_commutative = self.is_commutative
            else:
                obj.is_commutative = all(a.is_commutative for a in args)

        elif len(args) == 1:
            obj = args[0]
        else:
            obj = self.identity

        return obj
Ejemplo n.º 7
0
 def _eval_is_rational_function(self, syms):
     return all(term._eval_is_rational_function(syms) for term in self.args)
Ejemplo n.º 8
0
 def _eval_is_polynomial(self, syms):
     return all(term._eval_is_polynomial(syms) for term in self.args)
Ejemplo n.º 9
0
    def has(self, *patterns, **flags):
        """Return True if self has any of the patterns. If the `all` flag
        is True then return True if all of the patterns are present.

           >>> from sympy import sin, S
           >>> from sympy.abc import x, y, z

           >>> (x**2 + sin(x*y)).has(z)
           False

           >>> (x**2 + sin(x*y)).has(x, y, z)
           True

           When `all` is True then True is returned only if all of the
           patterns are present:

           >>> (x**2 + sin(x*y)).has(x, y, z, all=True)
           False

           If there are no patterns, False is always returned:
           "something doesn't have nothing"

           >>> (x).has()
           False
           >>> (S.One).has()
           False


        """
        from sympy.core.symbol import Wild

        def search(expr, target, hit):
            if hasattr(expr, '__iter__') and hasattr(expr, '__len__'):
                # this 'if' clause is needed until all objects use
                # sympy containers
                for i in expr:
                    if search(i, target, hit):
                        return True
            elif not isinstance(expr, Basic):
                pass
            elif target(expr) and hit(expr):
                return True
            else:
                for term in expr.iter_basic_args():
                    if search(term, target, hit):
                        return True
            return False

        def _has(p):
            p = sympify(p)
            if isinstance(p, BasicType):
                return search(self, lambda w: isinstance(w, p), lambda w: True)
            if p.is_Atom and not isinstance(p, Wild):
                return search(self, lambda w: isinstance(w, p.func), lambda w: w in [p])
            return search(self, lambda w: p.matches(w) is not None, lambda w: True)

        if not patterns:
            return False # something doesn't have nothing

        patterns = set(patterns)

        if flags.get('all', False):
            return all(_has(p) for p in patterns)
        else:
            return any(_has(p) for p in patterns)
Ejemplo n.º 10
0
Archivo: mul.py Proyecto: fxkr/sympy
 def _eval_is_rational_function(self, syms):
     return all(term._eval_is_rational_function(syms) for term in self.args)
Ejemplo n.º 11
0
Archivo: mul.py Proyecto: fxkr/sympy
 def _eval_is_polynomial(self, syms):
     return all(term._eval_is_polynomial(syms) for term in self.args)
Ejemplo n.º 12
0
def is_arcade_part(part):
    """Try to work out if the given block is a table generated by ARCADE.
    This is true if the first, third and last line satisfies is_line."""
    lines = part.split("\n")
    return (len(lines) >= 5
            and all(map(is_line, [lines[0], lines[2], lines[-1]])))
Ejemplo n.º 13
0
def is_arcade_part(part):
    """Try to work out if the given block is a table generated by ARCADE.
    This is true if the first, third and last line satisfies is_line."""
    lines = part.split("\n")
    return (len(lines) >= 5 
            and all(map(is_line, [lines[0], lines[2], lines[-1]])))