put_values_attr_for_imageSet_idea_dropped_11jul2016.py

# in fancyset/ImageSet class
lamda_vars = property(lambda self: self.lamda.variables)
    
def put_values(self, symbol, val=None):
        """
        Returns ImageSet expr value in FiniteSet after substituting the given
        `values` for `symbol`.

        Input can be either a single symbol and corresponding value
        or a dictionary of symbols and values. If symbol(s) are present in
        lambda variables and values are in the base_set, it returns
        corresponding ImageSet value.

        Raises
        ======

        ValueError
            The input is not valid.
            All symbols are not present in lambda.
            The value(s) are not in ImageSet base_set

        Examples
        ========

        >>> from sympy import symbols, Lambda, S
        >>> from sympy.sets.fancysets import ImageSet
        >>> n, m = symbols('n, m')
        >>> imgset = ImageSet(Lambda((n, m), n**2), S.Reals)
        >>> imgset.put_values({n: 1, m: 2})
        {1}
        >>> imgset = ImageSet(Lambda((n, m), n**2 + m), S.Reals)
        >>> imgset.put_values({n: 1, m: 2})
        {3}

        """
        from sympy.core.sympify import SympifyError
        if val is not None:
            val = {symbol: val}
        elif isinstance(symbol, dict):
            val = symbol
        else:
            msg = 'Expecting (sym, val) or ({sym: val}, None) but got (%s, %s)'
            raise ValueError(filldedent(msg % (symbol, val)))

        variabls = self.lamda_vars

        if set(val.keys()) & set(variabls):
            # if variables present in the imageset lambda
            # and variable value is in base_set, then only put values
            baseset = self.base_set
            try:
                check_values = all(v in baseset for v in val.values())
            except (TypeError, SympifyError):
                msg = 'Base set: %s, doesn\'t contain the subset: %s '
                raise TypeError(filldedent(msg % (baseset, val.values())))
            if check_values:
                # substitute the values
                return FiniteSet(self.lamda.expr.subs(val))
            else:
                msg = 'All or some of the values %s, you want to put is not in \
                base_set: %s '
                raise ValueError(filldedent(msg % (val, baseset)))
        else:
            msg = 'All of the symbol(s): %s, you want to replace is not \
            present in ImageSet lambda variables: %s '
            raise ValueError(filldedent(msg % (val.keys(), variabls)))

    def finite_values(self, *args):
        """Each `args` contains dict of symbols and values to replace.
        Returns a tuple with corresponding ImageSet values. Order
        of the solution is same as order of `args`.

        Examples
        ========

        >>> from sympy import symbols, Lambda, S
        >>> from sympy.sets.fancysets import ImageSet
        >>> n, m = symbols('n, m')
        >>> img = ImageSet(Lambda((n, m), n**2) , S.Reals)
        >>> img.finite_values({n: 1}, {n: 2, m:3}, {n: 10})
        (1, 4, 100)
        >>> img.finite_values({n: 10}, {n: 1, m:3}, {n: 2})
        (100, 1, 4)

        """
        length = len(args)
        finite_values = ()
        for i in range(0, length):
            finite_values += (list(self.put_values(args[i]))[0], )
        return finite_values

# testcases
def test_ImageSet_put_values():
    from sympy import Dummy
    n, m = symbols('n, m')
    imgset = ImageSet(Lambda((n, m), n**2), S.Reals)
    assert imgset.lamda_vars == (n, m)
    assert imgset.put_values({n: 1, m: 2}) == FiniteSet(1)
    assert imgset.put_values({n: 2}) == FiniteSet(4)
    # x is not present in imageset lambda variables
    raises(ValueError, lambda: imgset.put_values({x: 1}))
    # base set is S.Reals. Can't replace with complex number
    raises(ValueError, lambda: imgset.put_values({n: I}))

    imgset = ImageSet(Lambda((n, m), n**2 + m), S.Reals)
    assert imgset.put_values(n, 2) == FiniteSet(4 + m)

    # test for dummy
    n = Dummy('n')
    m = Dummy('m')
    imgeset = ImageSet(Lambda((n, m), n**2 + m), S.Reals)
    assert imgeset.put_values(n, 1) == FiniteSet(1 + m)
    assert imgeset.put_values(m, 1) == FiniteSet(n**2 + 1)
    assert imgeset.put_values({m: 1, n: 2}) == FiniteSet(5)
    n_old = n
    n = Dummy('n')
    assert imgeset.put_values({m: 1, n: 2}) == FiniteSet(n_old**2 + 1)
    # invailid input
    raises(ValueError, lambda: imgeset.put_values((m, 1), (n, 2)))


def test_ImageSet_finite_values():
    n, m = symbols('n, m')
    x = Symbol('x')
    imgset = ImageSet(Lambda((n, m), n**2), S.Reals)
    assert imgset.finite_values({n: 1, m: 2}, {n: 2}) == (1, 4)
    assert imgset.finite_values({n: 2, m: 2}, {n: 1}) == (4, 1)
    raises(TypeError, lambda: imgset.finite_values({n: x}))
    x = Symbol('x', real=True)
    assert imgset.finite_values({n: x}) == (x**2,)