예제 #1
0
def nres(func):
    if isinstance(func, Lambda):
        return len(pack_if_not(func.expr))
    elif isinstance(func, Functor):
        return func.nres
    elif isinstance(func, FunctionClass):
        return 1
    else:
        raise TypeError
예제 #2
0
    def __new__(cls, variable, expr, **kwargs):
        evaluate = kwargs.pop('evaluate', global_evaluate[0])
        variable = repack_if_can(sympify(unpack_if_can(variable)))

        for v in pack_if_not(variable):
            if not is_Symbol(v):
                raise TypeError('variable is not a symbol or matrix symbol: %s' % v)
        if not is_Boolean(expr):
            raise TypeError('expression is not boolean or relational: %r' % expr)

        if evaluate:
            return Exist.eval(variable, expr)
        return Application.__new__(cls, variable, expr, **kwargs)
예제 #3
0
    def variables(self):
        """get variable with tuple of set builder

        >>> from sympy import *
        >>> from symplus.strplus import init_mprinting
        >>> init_mprinting()
        >>> x, y = symbols('x y')
        >>> AbstractSet(x, abs(x)>1).variables
        (x,)
        >>> AbstractSet((x,), abs(x)>1).variables
        (x,)
        >>> AbstractSet((x,y), abs(x-y)>1).variables
        (x, y)
        >>> AbstractSet(x, x>y).variables
        (x,)
        """
        return pack_if_not(self._args[0])
예제 #4
0
def solve_inv(func, *args):
    vars = symbols('a:%s'%narg(func))
    vars = rename_variables_in(vars, free_symbols(func) | free_symbols(Tuple(*args)))
    exprs = pack_if_not(func(*vars))

    if len(args) != len(exprs):
        raise ValueError

    try:
        solns = solve([expr - val for val, expr in zip(args, exprs)], vars)
        if isinstance(solns, list):
            solns = dict(zip(vars, solns[0]))

        if len(vars) == 1:
            return solns[vars[0]]
        else:
            return tuple(solns[var] for var in vars)

    except NotImplementedError:
        return None
예제 #5
0
    def __new__(cls, variable, expr, **kwargs):
        """create AbstractSet by variable and expression

        >>> from sympy import *
        >>> from symplus.strplus import init_mprinting
        >>> init_mprinting()
        >>> x, y = symbols('x y')
        >>> AbstractSet(x, abs(x)>1)
        {x | |x| > 1}
        >>> AbstractSet((x,), abs(x)>1)
        {x | |x| > 1}
        >>> AbstractSet((x, y), abs(x-y)>1)
        {(x, y) | |x - y| > 1}
        >>> AbstractSet([x, y], abs(x-y)>1)
        {(x, y) | |x - y| > 1}
        >>> m, n = MatrixSymbol('m', 2, 2), MatrixSymbol('n', 2, 2)
        >>> AbstractSet(m, Eq(m[0,0]+m[1,1],0))
        {m | 0 == m[0, 0] + m[1, 1]}
        >>> AbstractSet((m, x), Eq(det(m),x))
        {(m, x) | x == ||m||}
        >>> AbstractSet(x, (x>1)&(x<3))
        {x | (x < 3) /\ (x > 1)}
        >>> AbstractSet(x, x>y)
        {x | x > y}
        >>> AbstractSet(1, x>y)
        Traceback (most recent call last):
            ...
        TypeError: variable is not a symbol or matrix symbol: 1
        >>> AbstractSet(x, x+y)
        Traceback (most recent call last):
            ...
        TypeError: expression is not boolean or relational: x + y
        """
        variable = repack_if_can(sympify(unpack_if_can(variable)))
        for v in pack_if_not(variable):
            if not is_Symbol(v):
                raise TypeError("variable is not a symbol or matrix symbol: %s" % v)
        if not is_Boolean(expr):
            raise TypeError("expression is not boolean or relational: %r" % expr)

        return Set.__new__(cls, variable, expr, **kwargs)
예제 #6
0
 def _contains(self, other):
     """
     >>> from sympy import *
     >>> from symplus.strplus import init_mprinting
     >>> init_mprinting()
     >>> x, y, z = symbols('x y z')
     >>> AbstractSet(x, abs(x)>1)._contains(2)
     True
     >>> AbstractSet((x,y), abs(x-y)>1)._contains((3,1))
     True
     >>> AbstractSet((x,y), abs(x-y)>1)._contains((x+3,x+1))
     True
     >>> AbstractSet(x, x>y)._contains(z)
     z > y
     >>> AbstractSet(x, x>y)._contains(Matrix(2,2,[1,2,3,4]))
     False
     """
     var = self.variables
     val = pack_if_not(other)
     if not type_match(var, val):
         return false
     return self.expr.xreplace(dict(zip(var, val)))
예제 #7
0
 def reduce(funcs):
     i = 0
     while i < len(funcs):
         if funcs[i] == Id:
             funcs = funcs[:i] + funcs[i+1:]
         elif isinstance(funcs[i], FunctionCompose):
             funcs = funcs[:i] + funcs[i].functions + funcs[i+1:]
         elif i-1 >= 0:
             if is_inverse_of(funcs[i-1], funcs[i]):
                 funcs = funcs[:i-1] + funcs[i+1:]
                 i = i - 2
             elif hasattr(funcs[i-1], '_compose'):
                 comp_funcs = funcs[i-1]._compose(funcs[i])
                 if comp_funcs is not None:
                     funcs = funcs[:i-1] + (comp_funcs,) + funcs[i+1:]
                     i = i - 1
             elif isinstance(funcs[i-1], Lambda) and isinstance(funcs[i], Lambda):
                 variables = rename_variables_in(funcs[i].variables, free_symbols(funcs[i-1]))
                 expr = funcs[i].expr
                 comp_funcs = Lambda(variables, funcs[i-1](*pack_if_not(expr)))
                 funcs = funcs[:i-1] + (comp_funcs,) + funcs[i+1:]
                 i = i - 1
         i = i + 1
     return funcs
예제 #8
0
 def _contains(self, mem):
     if getattr(self.function, "is_invertible", False):
         mem_ = unpack_if_can(FunctionInverse(self.function)(*pack_if_not(mem)))
         return self.set._contains(mem_)
예제 #9
0
 def variables(self):
     return pack_if_not(self._args[0])
예제 #10
0
 def arguments(self):
     return pack_if_not(self._args[1])
예제 #11
0
 def call(self, *args):
     apply_multivar = lambda a, f: f(*pack_if_not(a))
     return reduce(apply_multivar, self.functions[::-1], args)