예제 #1
0
def test_IndexedBase_assumptions():
    i = Symbol('i', integer=True)
    a = Symbol('a')
    A = IndexedBase(a, positive=True)
    for c in (A, A[i]):
        assert c.is_real
        assert c.is_complex
        assert not c.is_imaginary
        assert c.is_nonnegative
        assert c.is_nonzero
        assert c.is_commutative
        assert log(exp(c)) == c

    assert A != IndexedBase(a)
    assert A == IndexedBase(a, positive=True, real=True)
    assert A[i] != Indexed(a, i)
예제 #2
0
    def __getitem__(self, time):
        """
        For indexing discrete time stochastic processes.

        Returns
        =======

        RandomIndexedSymbol
        """
        if time not in self.index_set:
            raise IndexError("%s is not in the index set of %s" %
                             (time, self.symbol))
        idx_obj = Indexed(self.symbol, time)
        distribution = getattr(self, "distribution", None)
        pspace_obj = StochasticPSpace(self.symbol, self, distribution)
        return RandomIndexedSymbol(idx_obj, pspace_obj)
예제 #3
0
 def pdf(self, *x):
     expr, rvs = self.args[0], self.args[1]
     marginalise_out = [i for i in random_symbols(expr) if i not in rvs]
     if isinstance(expr, CompoundDistribution):
         syms = Dummy('x', real=True)
         expr = expr.args[0].pdf(syms)
     elif isinstance(expr, JointDistribution):
         count = len(expr.domain.args)
         x = Dummy('x', real=True, finite=True)
         syms = tuple(Indexed(x, i) for i in count)
         expr = expr.pdf(syms)
     else:
         syms = tuple(rv.pspace.symbol if isinstance(rv, RandomSymbol
                                                     ) else rv.args[0]
                      for rv in rvs)
     return Lambda(syms, self.compute_pdf(expr, marginalise_out))(*x)
예제 #4
0
def test_issue_12283():
    x = symbols('x')
    X = RandomSymbol(x)
    Y = RandomSymbol('Y')
    Z = RandomMatrixSymbol('Z', 2, 1)
    W = RandomMatrixSymbol('W', 2, 1)
    RI = RandomIndexedSymbol(Indexed('RI', 3))
    assert pspace(Z) == PSpace()
    assert pspace(RI) == PSpace()
    assert pspace(X) == PSpace()
    assert E(X) == Expectation(X)
    assert P(Y > 3) == Probability(Y > 3)
    assert variance(X) == Variance(X)
    assert variance(RI) == Variance(RI)
    assert covariance(X, Y) == Covariance(X, Y)
    assert covariance(W, Z) == Covariance(W, Z)
예제 #5
0
def shift_grid(expr):
    if expr.is_Symbol:
        return expr
    if expr.is_Number:
        return expr
    if isinstance(expr, Indexed):
        b = expr.base
        idx = list(expr.indices)
        if b.label.name in shift_x:
            idx[1] -= hf
        if b.label.name in shift_y:
            idx[2] -= hf
        t = Indexed(b, *idx)
        return t
    args = tuple([shift_grid(arg) for arg in expr.args])
    expr2 = expr.func(*args)
    return expr2
예제 #6
0
파일: joint_rv.py 프로젝트: yatna/sympy
 def pdf(self, *x):
     expr, rvs = self.args[0], self.args[1]
     marginalise_out = [i for i in random_symbols(expr) if i not in self.args[1]]
     syms = [i.pspace.symbol for i in self.args[1]]
     for i in expr.atoms(Indexed):
         if isinstance(i, Indexed) and isinstance(i.base, RandomSymbol)\
          and i not in rvs:
             marginalise_out.append(i)
     if isinstance(expr, CompoundDistribution):
         syms = Dummy('x', real=True)
         expr = expr.args[0].pdf(syms)
     elif isinstance(expr, JointDistribution):
         count = len(expr.domain.args)
         x = Dummy('x', real=True, finite=True)
         syms = [Indexed(x, i) for i in count]
         expr = expression.pdf(syms)
     return Lambda(syms, self.compute_pdf(expr, marginalise_out))(*x)
예제 #7
0
파일: util.py 프로젝트: navjotk/opesci-fd
def shift_grid(expr):
    """
    shift all field indices in the input expression to whole number
    if it is staggered (i.e. has index that is in the middle of grids)
    the result expression can then be converted to C code
    """
    if expr.is_Symbol:
        return expr
    if expr.is_Number:
        return expr
    if isinstance(expr, Indexed):
        b = expr.base
        idx = [x-hf if is_half(x) else x for x in list(expr.indices)]
        t = Indexed(b, *idx)
        return t
    args = tuple([shift_grid(arg) for arg in expr.args])  # recursive call
    expr2 = expr.func(*args)
    return expr2
예제 #8
0
def test_sample_seed():
    x1, x2 = (Indexed('x', i) for i in (1, 2))
    pdf = exp(-x1**2 / 2 + x1 - x2**2 / 2 - S.Half) / (2 * pi)
    X = JointRV('x', pdf)

    libraries = ['scipy', 'numpy', 'pymc3']
    for lib in libraries:
        try:
            imported_lib = import_module(lib)
            if imported_lib:
                s0, s1, s2 = [], [], []
                s0 = list(sample(X, numsamples=10, library=lib, seed=0))
                s1 = list(sample(X, numsamples=10, library=lib, seed=0))
                s2 = list(sample(X, numsamples=10, library=lib, seed=1))
                assert s0 == s1
                assert s1 != s2
        except NotImplementedError:
            continue
예제 #9
0
 def kappac(self, n):
     fn = self.fn
     r = self.r
     z = self.z
     y = self.y
     W = self.W
     Q = self.Q
     S = self.S
     NBc = self.NBc
     NBbc = self.NBbc
     j = self.j
     L1 = [fn[0] * bell(n, 1, (r))]
     for k in range(2, n + 1):
         L1.extend([fn[k - 1] * bell(n, k, r)])
     L2 = Sum(Indexed('y', j), (j, 0, n - 1))
     L22 = lambdify(y, L2)
     L3 = L22(L1)
     L4 = L3.subs({W(z): Q(z) * S(z) - NBc * NBbc})
     L5 = L4.subs({S(z): NBc + NBbc, Q(z): z * z - NBc * NBbc})
     return L5
예제 #10
0
def test_Lambda():
    e = Lambda(x, x**2)
    assert e(4) == 16
    assert e(x) == x**2
    assert e(y) == y**2

    assert Lambda((), 42)() == 42
    assert unchanged(Lambda, (), 42)
    assert Lambda((), 42) != Lambda((), 43)
    assert Lambda((), f(x))() == f(x)
    assert Lambda((), 42).nargs == FiniteSet(0)

    assert unchanged(Lambda, (x,), x**2)
    assert Lambda(x, x**2) == Lambda((x,), x**2)
    assert Lambda(x, x**2) == Lambda(y, y**2)
    assert Lambda(x, x**2) != Lambda(y, y**2 + 1)
    assert Lambda((x, y), x**y) == Lambda((y, x), y**x)
    assert Lambda((x, y), x**y) != Lambda((x, y), y**x)

    assert Lambda((x, y), x**y)(x, y) == x**y
    assert Lambda((x, y), x**y)(3, 3) == 3**3
    assert Lambda((x, y), x**y)(x, 3) == x**3
    assert Lambda((x, y), x**y)(3, y) == 3**y
    assert Lambda(x, f(x))(x) == f(x)
    assert Lambda(x, x**2)(e(x)) == x**4
    assert e(e(x)) == x**4

    x1, x2 = (Indexed('x', i) for i in (1, 2))
    assert Lambda((x1, x2), x1 + x2)(x, y) == x + y

    assert Lambda((x, y), x + y).nargs == FiniteSet(2)

    p = x, y, z, t
    assert Lambda(p, t*(x + y + z))(*p) == t * (x + y + z)

    assert Lambda(x, 2*x) + Lambda(y, 2*y) == 2*Lambda(x, 2*x)
    assert Lambda(x, 2*x) not in [ Lambda(x, x) ]
    raises(TypeError, lambda: Lambda(1, x))
    assert Lambda(x, 1)(1) is S.One

    raises(SyntaxError, lambda: Lambda((x, x), x + 2))
예제 #11
0
파일: util.py 프로젝트: navjotk/opesci-fd
def shift_index(expr, k, s):
    """
    shift the k-th index of all fields in input expression by s
    return the shifted expression
    :param expr: input expression
    k: the index number to be shifted
    s: the shifted amount
    e.g. k=1, s=1, U[x,y,z] -> U[x,y+1,z]
    """
    if expr.is_Symbol:
        return expr
    if expr.is_Number:
        return expr
    if isinstance(expr, Indexed):
        b = expr.base
        idx = list(expr.indices)
        idx[k] += s
        t = Indexed(b, *idx)
        return t
    # recursive call
    args = tuple([shift_index(arg, k, s) for arg in expr.args])
    expr2 = expr.func(*args)
    return expr2
예제 #12
0
def test_indexed_idx_sum():
    i = symbols('i', cls=Idx)
    r = Indexed('r', i)
    assert Sum(r, (i, 0, 3)).doit() == sum([r.xreplace({i: j}) for j in range(4)])
    assert Product(r, (i, 0, 3)).doit() == prod([r.xreplace({i: j}) for j in range(4)])

    j = symbols('j', integer=True)
    assert Sum(r, (i, j, j+2)).doit() == sum([r.xreplace({i: j+k}) for k in range(3)])
    assert Product(r, (i, j, j+2)).doit() == prod([r.xreplace({i: j+k}) for k in range(3)])

    k = Idx('k', range=(1, 3))
    A = IndexedBase('A')
    assert Sum(A[k], k).doit() == sum([A[Idx(j, (1, 3))] for j in range(1, 4)])
    assert Product(A[k], k).doit() == prod([A[Idx(j, (1, 3))] for j in range(1, 4)])

    raises(ValueError, lambda: Sum(A[k], (k, 1, 4)))
    raises(ValueError, lambda: Sum(A[k], (k, 0, 3)))
    raises(ValueError, lambda: Sum(A[k], (k, 2, oo)))

    raises(ValueError, lambda: Product(A[k], (k, 1, 4)))
    raises(ValueError, lambda: Product(A[k], (k, 0, 3)))
    raises(ValueError, lambda: Product(A[k], (k, 2, oo)))
예제 #13
0
 def pdf(self):
     sym = [Indexed(self.symbol, i) for i in range(self.component_count)]
     return self.distribution(*sym)
예제 #14
0
 def __getitem__(self, key):
     if isinstance(self.pspace, JointPSpace):
         if (self.pspace.component_count <= key) == True:
             raise ValueError("Index keys for %s can only up to %s." %
                 (self.name, self.pspace.component_count - 1))
         return Indexed(self, key)
예제 #15
0
    def handleSymmetricYukawa(self, fermions, contractArgs, coeff, freeDummies,
                              coupling):
        duplicateFermions = [el for el in fermions if fermions.count(el) == 2]

        if len(duplicateFermions) != 2:
            return expand(
                tensorContract(*contractArgs,
                               value=coeff,
                               freeDummies=freeDummies,
                               doit=True))

        expanded = []

        duplicateFermion = duplicateFermions[0]

        symbs = [el[0].symbol for el in contractArgs]
        duplicatePos = [
            i for i, el in enumerate(symbs) if el == duplicateFermion
        ]

        for pos in duplicatePos:
            duplicateTensor = copy.deepcopy(contractArgs[pos][0])

            newDic = {}
            for k, v in duplicateTensor.dic.items():
                if isinstance(v, Symbol):
                    newDic[k] = Symbol('df$' + str(v))
                elif isinstance(v, Indexed):
                    newDic[k] = Indexed('df$' + str(v.base), *v.indices)

            duplicateTensor.dic = newDic
            newcArgs = []
            for i, el in enumerate(contractArgs):
                if i != pos:
                    newcArgs.append(el)
                else:
                    if len(contractArgs[pos]) > 1:
                        newcArgs.append(
                            (duplicateTensor, *contractArgs[pos][1:]))
                    else:
                        newcArgs.append((duplicateTensor, ))

            expanded.append(
                expand(
                    tensorContract(*newcArgs,
                                   value=coeff,
                                   freeDummies=freeDummies,
                                   doit=True)))

        if expand(expanded[0] + expanded[1]) == 0:
            # Antisymmetric Yukawa matrix

            # For one generation, the Yukawa operator simply vanishes.
            # In this case an error should be raised eventually
            if self.model.Fermions[str(duplicateFermion)].gen == 1:
                return expand(
                    tensorContract(*contractArgs,
                                   value=coeff,
                                   freeDummies=freeDummies,
                                   doit=True))

            self.model.assumptions[coupling]['antisymmetric'] = True
        else:
            # Symmetric Yukawa matrix
            self.model.assumptions[coupling]['symmetric'] = True

        return expanded[0]
예제 #16
0
파일: drs.py 프로젝트: rdguerrerom/drudge
 def class_key(cls):
     return Indexed.class_key()
예제 #17
0
def test_issue_9594():
    i = symbols('i', cls=Idx)
    r = Indexed('r', i)
    Sum(r, (i, 0, 3)).doit() == [r.subs(i, j) for j in range(4)]
예제 #18
0
def dse_cse(expr):
    """
    Perform common subexpression elimination on sympy expressions.

    :param expr: sympy equation or list of equations on which CSE is performed.

    :return: A list of the resulting equations after performing CSE
    """
    expr = expr if isinstance(expr, list) else [expr]

    temps, stencils = cse(expr, numbered_symbols("temp"))

    # Restores the LHS
    for i in range(len(expr)):
        stencils[i] = Eq(expr[i].lhs, stencils[i].rhs)

    to_revert = {}
    to_keep = []

    # Restores IndexedBases if they are collected by CSE and
    # reverts changes to simple index operations (eg: t - 1)
    for temp, value in temps:
        if isinstance(value, IndexedBase):
            to_revert[temp] = value
        elif isinstance(value, Indexed):
            to_revert[temp] = value
        elif isinstance(value, Add) and not \
                set([t, x, y, z]).isdisjoint(set(value.args)):
            to_revert[temp] = value
        else:
            to_keep.append((temp, value))

    # Restores the IndexedBases and the Indexes in the assignments to revert
    for temp, value in to_revert.items():
        s_dict = {}
        for arg in preorder_traversal(value):
            if isinstance(arg, Indexed):
                new_indices = []
                for index in arg.indices:
                    if index in to_revert:
                        new_indices.append(to_revert[index])
                    else:
                        new_indices.append(index)
                if arg.base.label in to_revert:
                    s_dict[arg] = Indexed(to_revert[value.base.label],
                                          *new_indices)
        to_revert[temp] = value.xreplace(s_dict)

    subs_dict = {}

    # Builds a dictionary of the replacements
    for expr in stencils + [assign for temp, assign in to_keep]:
        for arg in preorder_traversal(expr):
            if isinstance(arg, Indexed):
                new_indices = []
                for index in arg.indices:
                    if index in to_revert:
                        new_indices.append(to_revert[index])
                    else:
                        new_indices.append(index)
                if arg.base.label in to_revert:
                    subs_dict[arg] = Indexed(to_revert[arg.base.label],
                                             *new_indices)
                elif tuple(new_indices) != arg.indices:
                    subs_dict[arg] = Indexed(arg.base, *new_indices)
            if arg in to_revert:
                subs_dict[arg] = to_revert[arg]

    stencils = [stencil.xreplace(subs_dict) for stencil in stencils]

    to_keep = [Eq(temp[0], temp[1].xreplace(subs_dict)) for temp in to_keep]

    # If the RHS of a temporary variable is the LHS of a stencil,
    # update the value of the temporary variable after the stencil

    new_stencils = []

    for stencil in stencils:
        new_stencils.append(stencil)

        for temp in to_keep:
            if stencil.lhs in preorder_traversal(temp.rhs):
                new_stencils.append(temp)
                break

    return to_keep + new_stencils
예제 #19
0
def test_Indexed_func_args():
    i, j = symbols('i j', integer=True)
    a = symbols('a')
    A = Indexed(a, i, j)
    assert A == A.func(*A.args)
예제 #20
0
def test_not_interable():
    i, j = symbols('i j', integer=True)
    A = Indexed('A', i, i + j)
    assert not iterable(A)
예제 #21
0
def test_MarginalDistribution():
    a1, p1, p2 = symbols('a1 p1 p2', positive=True)
    C = Multinomial('C', 2, p1, p2)
    B = MultivariateBeta('B', a1, C[0])
    MGR = MarginalDistribution(B, (C[0],))
    mgrc = Mul(Symbol('B'), Piecewise(ExprCondPair(Mul(Integer(2),
    Pow(Symbol('p1', positive=True), Indexed(IndexedBase(Symbol('C')),
    Integer(0))), Pow(Symbol('p2', positive=True),
    Indexed(IndexedBase(Symbol('C')), Integer(1))),
    Pow(factorial(Indexed(IndexedBase(Symbol('C')), Integer(0))), Integer(-1)),
    Pow(factorial(Indexed(IndexedBase(Symbol('C')), Integer(1))), Integer(-1))),
    Eq(Add(Indexed(IndexedBase(Symbol('C')), Integer(0)),
    Indexed(IndexedBase(Symbol('C')), Integer(1))), Integer(2))),
    ExprCondPair(Integer(0), True)), Pow(gamma(Symbol('a1', positive=True)),
    Integer(-1)), gamma(Add(Symbol('a1', positive=True),
    Indexed(IndexedBase(Symbol('C')), Integer(0)))),
    Pow(gamma(Indexed(IndexedBase(Symbol('C')), Integer(0))), Integer(-1)),
    Pow(Indexed(IndexedBase(Symbol('B')), Integer(0)),
    Add(Symbol('a1', positive=True), Integer(-1))),
    Pow(Indexed(IndexedBase(Symbol('B')), Integer(1)),
    Add(Indexed(IndexedBase(Symbol('C')), Integer(0)), Integer(-1))))
    assert MGR(C) == mgrc
예제 #22
0
    def probability(self,
                    condition,
                    given_condition=None,
                    evaluate=True,
                    **kwargs):
        """
        Handles probability queries for discrete Markov chains.

        Parameters
        ==========

        condition: Relational
        given_condition: Relational/And

        Returns
        =======

        Probability
            If the transition probabilities are not available
        Expr
            If the transition probabilities is MatrixSymbol or Matrix

        Note
        ====

        Any information passed at the time of query overrides
        any information passed at the time of object creation like
        transition probabilities, state space.

        Pass the transition matrix using TransitionMatrixOf and state space
        using StochasticStateSpaceOf in given_condition using & or And.
        """

        check, trans_probs, state_space, given_condition = \
            self._preprocess(given_condition, evaluate)

        if check:
            return Probability(condition, given_condition)

        if isinstance(condition, Eq) and \
            isinstance(given_condition, Eq) and \
            len(given_condition.atoms(RandomSymbol)) == 1:
            # handles simple queries like P(Eq(X[i], dest_state), Eq(X[i], init_state))
            lhsc, rhsc = condition.lhs, condition.rhs
            lhsg, rhsg = given_condition.lhs, given_condition.rhs
            if not isinstance(lhsc, RandomIndexedSymbol):
                lhsc, rhsc = (rhsc, lhsc)
            if not isinstance(lhsg, RandomIndexedSymbol):
                lhsg, rhsg = (rhsg, lhsg)
            keyc, statec, keyg, stateg = (lhsc.key, rhsc, lhsg.key, rhsg)
            if Lt(stateg, trans_probs.shape[0]) == False or Lt(
                    statec, trans_probs.shape[1]) == False:
                raise IndexError(
                    "No information is avaliable for (%s, %s) in "
                    "transition probabilities of shape, (%s, %s). "
                    "State space is zero indexed." %
                    (stateg, statec, trans_probs.shape[0],
                     trans_probs.shape[1]))
            if keyc < keyg:
                raise ValueError(
                    "Incorrect given condition is given, probability "
                    "of past state cannot be computed from future state.")
            nsteptp = trans_probs**(keyc - keyg)
            if hasattr(nsteptp, "__getitem__"):
                return nsteptp.__getitem__((stateg, statec))
            return Indexed(nsteptp, stateg, statec)

        if isinstance(condition, And):
            # handle queries like,
            # P(Eq(X[i+k], s1) & Eq(X[i+m], s2) . . . & Eq(X[i], sn), Eq(P(X[i]), prob))
            conds = condition.args
            i, result = -1, 1
            while i > -len(conds):
                result *= self.probability(conds[i], conds[i-1] & \
                            TransitionMatrixOf(self, trans_probs) & \
                            StochasticStateSpaceOf(self, state_space))
                i -= 1
            if isinstance(given_condition,
                          (TransitionMatrixOf, StochasticStateSpaceOf)):
                return result * Probability(conds[i])
            if isinstance(given_condition, Eq):
                if not isinstance(given_condition.lhs, Probability) or \
                    given_condition.lhs.args[0] != conds[i]:
                    raise ValueError("Probability for %s needed", conds[i])
                return result * given_condition.rhs

        raise NotImplementedError(
            "Mechanism for handling (%s, %s) queries hasn't been "
            "implemented yet." % (condition, given_condition))
예제 #23
0
파일: joint_rv.py 프로젝트: yatna/sympy
 def __getitem__(self, key):
     from sympy.stats.joint_rv import JointPSpace
     if isinstance(self.pspace, JointPSpace):
         return Indexed(self, key)
def get_sum(min_limit, max_limit, reg):
    x, i = symbols('x i')
    return Sum(Indexed('x', i), (i, min_limit, max_limit)).doit()
예제 #25
0
def test_Idx_limits():
    i = symbols('i', cls=Idx)
    r = Indexed('r', i)

    assert SeqFormula(r, (i, 0, 5))[:] == [r.subs(i, j) for j in range(6)]
    assert SeqPer((1, 2), (i, 0, 5))[:] == [1, 2, 1, 2, 1, 2]
예제 #26
0
 def __getitem__(self, indices, **kw_args):
     if is_sequence(indices):
         # Special case needed because M[*my_tuple] is a syntax error.
         return Indexed(self, *indices, **kw_args)
     else:
         return Indexed(self, indices, **kw_args)
예제 #27
0
def test_Indexed_func_args():
    i, j = symbols('i j', integer=True)
    a = symbols('a')
    A = Indexed(a, i, j)
    assert A == A.func(*A.args)
예제 #28
0
def test_Idx_limits():
    i = symbols('i', cls=Idx)
    r = Indexed('r', i)

    assert SeqFormula(r, (i, 0, 5))[:] == [r.subs(i, j) for j in range(6)]
    assert SeqPer((1, 2), (i, 0, 5))[:] == [1, 2, 1, 2, 1, 2]
예제 #29
0
def test_not_interable():
    i, j = symbols("i j", integer=True)
    A = Indexed("A", i, i + j)
    assert not iterable(A)
예제 #30
0
def test_complex_indices():
    i, j = symbols('i j', integer=True)
    A = Indexed('A', i, i + j)
    assert A.rank == 2
    assert A.indices == (i, i + j)
예제 #31
0
def generate_coupling_expansions(obj, verbose=True):
    """
    generate expansions for coupling.
    """
    if verbose:
        print('* Generating coupling expansions...')
    i = sym.symbols('i_sym')  # summation index
    psi = obj.psi
    eps = obj.eps

    ruleA = {'psi': obj.pA['expand']}
    ruleB = {'psi': obj.pB['expand']}

    rule_trunc = {}
    for k in range(obj.miter, obj.miter + 200):
        rule_trunc.update({obj.eps**k: 0})

    for key in obj.var_names:
        if verbose:
            print('key in coupling expand', key)
        gA = Sum(psi**i * Indexed('g' + key + 'A', i),
                 (i, 1, obj.miter)).doit()
        gB = Sum(psi**i * Indexed('g' + key + 'B', i),
                 (i, 1, obj.miter)).doit()

        iA = Sum(psi**i * Indexed('i' + key + 'A', i),
                 (i, 0, obj.miter)).doit()
        iB = Sum(psi**i * Indexed('i' + key + 'B', i),
                 (i, 0, obj.miter)).doit()

        tmp = gA.subs(ruleA)
        tmp = sym.expand(tmp,
                         basic=False,
                         deep=True,
                         power_base=False,
                         power_exp=False,
                         mul=False,
                         log=False,
                         multinomial=True)
        tmp = tmp.subs(rule_trunc)
        gA_collected = collect(expand(tmp).subs(rule_trunc), eps)
        if verbose:
            print('completed gA collected')

        tmp = gB.subs(ruleB)
        tmp = sym.expand(tmp,
                         basic=False,
                         deep=True,
                         power_base=False,
                         power_exp=False,
                         mul=False,
                         log=False,
                         multinomial=True)
        tmp = tmp.subs(rule_trunc)
        gB_collected = collect(expand(tmp).subs(rule_trunc), eps)
        if verbose:
            print('completed gB collected')

        tmp = iA.subs(ruleA)
        tmp = sym.expand(tmp,
                         basic=False,
                         deep=True,
                         power_base=False,
                         power_exp=False,
                         mul=False,
                         log=False,
                         multinomial=True)
        tmp = tmp.subs(rule_trunc)
        iA_collected = collect(expand(tmp).subs(rule_trunc), eps)
        if verbose:
            print('completed iA collected')

        tmp = iB.subs(ruleB)
        tmp = sym.expand(tmp,
                         basic=False,
                         deep=True,
                         power_base=False,
                         power_exp=False,
                         mul=False,
                         log=False,
                         multinomial=True)
        tmp = tmp.subs(rule_trunc)
        iB_collected = collect(expand(tmp).subs(rule_trunc), eps)
        if verbose:
            print('completed iB collected')

        obj.g[key + '_epsA'] = 0
        obj.g[key + '_epsB'] = 0

        obj.i[key + '_epsA'] = 0
        obj.i[key + '_epsB'] = 0

        for j in range(obj.miter):
            obj.g[key + '_epsA'] += eps**j * gA_collected.coeff(eps, j)
            obj.g[key + '_epsB'] += eps**j * gB_collected.coeff(eps, j)

            obj.i[key + '_epsA'] += eps**j * iA_collected.coeff(eps, j)
            obj.i[key + '_epsB'] += eps**j * iB_collected.coeff(eps, j)

    return obj.g, obj.i
예제 #32
0
def test_Lambda():
    e = Lambda(x, x**2)
    assert e(4) == 16
    assert e(x) == x**2
    assert e(y) == y**2

    assert Lambda((), 42)() == 42
    assert unchanged(Lambda, (), 42)
    assert Lambda((), 42) != Lambda((), 43)
    assert Lambda((), f(x))() == f(x)
    assert Lambda((), 42).nargs == FiniteSet(0)

    assert unchanged(Lambda, (x, ), x**2)
    assert Lambda(x, x**2) == Lambda((x, ), x**2)
    assert Lambda(x, x**2) == Lambda(y, y**2)
    assert Lambda(x, x**2) != Lambda(y, y**2 + 1)
    assert Lambda((x, y), x**y) == Lambda((y, x), y**x)
    assert Lambda((x, y), x**y) != Lambda((x, y), y**x)

    assert Lambda((x, y), x**y)(x, y) == x**y
    assert Lambda((x, y), x**y)(3, 3) == 3**3
    assert Lambda((x, y), x**y)(x, 3) == x**3
    assert Lambda((x, y), x**y)(3, y) == 3**y
    assert Lambda(x, f(x))(x) == f(x)
    assert Lambda(x, x**2)(e(x)) == x**4
    assert e(e(x)) == x**4

    x1, x2 = (Indexed('x', i) for i in (1, 2))
    assert Lambda((x1, x2), x1 + x2)(x, y) == x + y

    assert Lambda((x, y), x + y).nargs == FiniteSet(2)

    p = x, y, z, t
    assert Lambda(p, t * (x + y + z))(*p) == t * (x + y + z)

    assert Lambda(x, 2 * x) + Lambda(y, 2 * y) == 2 * Lambda(x, 2 * x)
    assert Lambda(x, 2 * x) not in [Lambda(x, x)]
    raises(BadSignatureError, lambda: Lambda(1, x))
    assert Lambda(x, 1)(1) is S.One

    raises(BadSignatureError, lambda: Lambda((x, x), x + 2))
    raises(BadSignatureError, lambda: Lambda(((x, x), y), x))
    raises(BadSignatureError, lambda: Lambda(((y, x), x), x))
    raises(BadSignatureError, lambda: Lambda(((y, 1), 2), x))

    with warns_deprecated_sympy():
        assert Lambda([x, y], x + y) == Lambda((x, y), x + y)

    flam = Lambda(((x, y), ), x + y)
    assert flam((2, 3)) == 5
    flam = Lambda(((x, y), z), x + y + z)
    assert flam((2, 3), 1) == 6
    flam = Lambda((((x, y), z), ), x + y + z)
    assert flam(((2, 3), 1)) == 6
    raises(BadArgumentsError, lambda: flam(1, 2, 3))
    flam = Lambda((x, ), (x, x))
    assert flam(1, ) == (1, 1)
    assert flam((1, )) == ((1, ), (1, ))
    flam = Lambda(((x, ), ), (x, x))
    raises(BadArgumentsError, lambda: flam(1))
    assert flam((1, )) == (1, 1)

    # Previously TypeError was raised so this is potentially needed for
    # backwards compatibility.
    assert issubclass(BadSignatureError, TypeError)
    assert issubclass(BadArgumentsError, TypeError)

    # These are tested to see they don't raise:
    hash(Lambda(x, 2 * x))
    hash(Lambda(x, x))  # IdentityFunction subclass
예제 #33
0
def load_coupling_expansions(obj, fn='gA', recompute=False):

    i = sym.symbols('i_sym')  # summation index
    #psi = obj.psi
    eps = obj.eps

    # for solution of isostables in terms of theta.
    obj.pA['expand'] = Sum(eps**i * Indexed('pA', i), (i, 1, obj.miter)).doit()
    obj.pB['expand'] = Sum(eps**i * Indexed('pB', i), (i, 1, obj.miter)).doit()

    #fname = obj.hodd['dat_fnames'][i]
    #file_does_not_exist = not(os.path.exists(fname))
    for key in obj.var_names:
        obj.g[key + '_epsA'] = []
        obj.g[key + '_epsB'] = []

        obj.i[key + '_epsA'] = []
        obj.i[key + '_epsB'] = []

        # check that files exist
        val = 0
        for key in obj.var_names:
            val += not (os.path.isfile(obj.g[key + '_epsA_fname']))
            val += not (os.path.isfile(obj.g[key + '_epsB_fname']))
            val += not (os.path.isfile(obj.i[key + '_epsA_fname']))
            val += not (os.path.isfile(obj.i[key + '_epsB_fname']))

            #print(key,obj.g[key+'_epsA_fname'])

        if val != 0:
            files_do_not_exist = True
        else:
            files_do_not_exist = False

    if recompute or files_do_not_exist:
        generate_coupling_expansions(obj)

        for key in obj.var_names:
            # dump
            dill.dump(obj.g[key + '_epsA'],
                      open(obj.g[key + '_epsA_fname'], 'wb'),
                      recurse=True)
            dill.dump(obj.g[key + '_epsB'],
                      open(obj.g[key + '_epsB_fname'], 'wb'),
                      recurse=True)

            dill.dump(obj.i[key + '_epsA'],
                      open(obj.i[key + '_epsA_fname'], 'wb'),
                      recurse=True)
            dill.dump(obj.i[key + '_epsB'],
                      open(obj.i[key + '_epsB_fname'], 'wb'),
                      recurse=True)

    else:

        for key in obj.var_names:
            obj.g[key + '_epsA'] = dill.load(
                open(obj.g[key + '_epsA_fname'], 'rb'))
            obj.g[key + '_epsB'] = dill.load(
                open(obj.g[key + '_epsB_fname'], 'rb'))

            obj.i[key + '_epsA'] = dill.load(
                open(obj.i[key + '_epsA_fname'], 'rb'))
            obj.i[key + '_epsB'] = dill.load(
                open(obj.i[key + '_epsB_fname'], 'rb'))

    # vector of i expansion
    obj.i['vecA'] = sym.zeros(obj.dim, 1)
    obj.i['vecB'] = sym.zeros(obj.dim, 1)

    for i, key in enumerate(obj.var_names):
        #print('ia',i,key,obj.i[key+'_epsA'])
        #print('ib',i,key,obj.i[key+'_epsB'])
        obj.i['vecA'][i] = obj.i[key + '_epsA']
        obj.i['vecB'][i] = obj.i[key + '_epsB']

    pass