def test_K():
    assert K(0) == pi / 2
    assert K(S(1) / 2) == 8 * pi ** (S(3) / 2) / gamma(-S(1) / 4) ** 2
    assert K(1) == zoo
    assert K(-1) == gamma(S(1) / 4) ** 2 / (4 * sqrt(2 * pi))
    assert K(oo) == 0
    assert K(-oo) == 0
    assert K(I * oo) == 0
    assert K(-I * oo) == 0
    assert K(zoo) == 0

    assert K(z).diff(z) == (E(z) - (1 - z) * K(z)) / (2 * z * (1 - z))
    assert td(K(z), z)

    zi = Symbol("z", real=False)
    assert K(zi).conjugate() == K(zi.conjugate())
    zr = Symbol("z", real=True, negative=True)
    assert K(zr).conjugate() == K(zr)

    assert K(z).rewrite(hyper) == (pi / 2) * hyper((S.Half, S.Half), (S.One,), z)
    assert tn(K(z), (pi / 2) * hyper((S.Half, S.Half), (S.One,), z))
    assert K(z).rewrite(meijerg) == meijerg(((S.Half, S.Half), []), ((S.Zero,), (S.Zero,)), -z) / 2
    assert tn(K(z), meijerg(((S.Half, S.Half), []), ((S.Zero,), (S.Zero,)), -z) / 2)

    assert K(z).series(
        z
    ) == pi / 2 + pi * z / 8 + 9 * pi * z ** 2 / 128 + 25 * pi * z ** 3 / 512 + 1225 * pi * z ** 4 / 32768 + 3969 * pi * z ** 5 / 131072 + O(
        z ** 6
    )
Beispiel #2
0
def test_diff():
    x = Symbol('x')
    assert Rational(1, 3).diff(x) is S.Zero
    assert I.diff(x) is S.Zero
    assert pi.diff(x) is S.Zero
    assert x.diff(x, 0) == x
    assert (x**2).diff(x, 2, x) == 0
    raises(ValueError, 'x.diff(1, x)')

    a = Symbol("a")
    b = Symbol("b")
    c = Symbol("c")
    p = Rational(5)
    e = a*b + b**p
    assert e.diff(a) == b
    assert e.diff(b) == a + 5*b**4
    assert e.diff(b).diff(a) == Rational(1)
    e = a*(b + c)
    assert e.diff(a) == b + c
    assert e.diff(b) == a
    assert e.diff(b).diff(a) == Rational(1)
    e = c**p
    assert e.diff(c, 6) == Rational(0)
    assert e.diff(c, 5) == Rational(120)
    e = c**Rational(2)
    assert e.diff(c) == 2*c
    e = a*b*c
    assert e.diff(c) == a*b
Beispiel #3
0
    def get_dim(self, dim):
        """
        Find a specific dimension which is part of the system.

        dim can be a string or a dimension object. If no dimension is found,
        then return None.
        """

        #TODO: if the argument is a list, return a list of all matching dims

        found_dim = None

        #TODO: use copy instead of direct assignment for found_dim?
        if isinstance(dim, string_types):
            dim = Symbol(dim)

        if dim.is_Symbol:
            for d in self._dims:
                if dim in (d.name, d.symbol):
                    found_dim = d
                    break
        elif isinstance(dim, Dimension):
            for i, idim in enumerate(self._dims):
                if dim.get_dimensional_dependencies() == idim.get_dimensional_dependencies():
                    return idim

        return found_dim
Beispiel #4
0
def test_as_coeff_factors():
    x = Symbol("x")

    assert x.as_coeff_factors() == (0, (x,))
    assert (-1 + x).as_coeff_factors() == (-1, (x,))
    assert (2 + x).as_coeff_factors() == (2, (x,))
    assert (1 + x).as_coeff_factors() == (1, (x,))
Beispiel #5
0
def test_E():
    assert E(z, 0) == z
    assert E(0, m) == 0
    assert E(i*pi/2, m) == i*E(m)
    assert E(z, oo) == zoo
    assert E(z, -oo) == zoo
    assert E(0) == pi/2
    assert E(1) == 1
    assert E(oo) == I*oo
    assert E(-oo) == oo
    assert E(zoo) == zoo

    assert E(-z, m) == -E(z, m)

    assert E(z, m).diff(z) == sqrt(1 - m*sin(z)**2)
    assert E(z, m).diff(m) == (E(z, m) - F(z, m))/(2*m)
    assert E(z).diff(z) == (E(z) - K(z))/(2*z)
    r = randcplx()
    assert td(E(r, m), m)
    assert td(E(z, r), z)
    assert td(E(z), z)

    mi = Symbol('m', real=False)
    assert E(z, mi).conjugate() == E(z.conjugate(), mi.conjugate())
    mr = Symbol('m', real=True, negative=True)
    assert E(z, mr).conjugate() == E(z.conjugate(), mr)

    assert E(z).rewrite(hyper) == (pi/2)*hyper((-S.Half, S.Half), (S.One,), z)
    assert tn(E(z), (pi/2)*hyper((-S.Half, S.Half), (S.One,), z))
    assert E(z).rewrite(meijerg) == \
        -meijerg(((S.Half, S(3)/2), []), ((S.Zero,), (S.Zero,)), -z)/4
    assert tn(E(z), -meijerg(((S.Half, S(3)/2), []), ((S.Zero,), (S.Zero,)), -z)/4)
Beispiel #6
0
def test_Dummy_from_Symbol():
    # should not get the full dictionary of assumptions
    n = Symbol('n', integer=True)
    d = n.as_dummy()
    s1 = "Dummy('n', dummy_index=%s, integer=True)" % str(d.dummy_index)
    s2 = "Dummy('n', integer=True, dummy_index=%s)" % str(d.dummy_index)
    assert srepr(d) in (s1, s2)
Beispiel #7
0
def test_K():
    assert K(0) == pi/2
    assert K(S(1)/2) == 8*pi**(S(3)/2)/gamma(-S(1)/4)**2
    assert K(1) == zoo
    assert K(-1) == gamma(S(1)/4)**2/(4*sqrt(2*pi))
    assert K(oo) == 0
    assert K(-oo) == 0
    assert K(I*oo) == 0
    assert K(-I*oo) == 0
    assert K(zoo) == 0

    assert K(z).diff(z) == (E(z) - (1 - z)*K(z))/(2*z*(1 - z))
    assert td(K(z), z)

    zi = Symbol('z', real=False)
    assert K(zi).conjugate() == K(zi.conjugate())
    zr = Symbol('z', real=True, negative=True)
    assert K(zr).conjugate() == K(zr)

    assert K(z).rewrite(hyper) == \
        (pi/2)*hyper((S.Half, S.Half), (S.One,), z)
    assert tn(K(z), (pi/2)*hyper((S.Half, S.Half), (S.One,), z))
    assert K(z).rewrite(meijerg) == \
        meijerg(((S.Half, S.Half), []), ((S.Zero,), (S.Zero,)), -z)/2
    assert tn(K(z), meijerg(((S.Half, S.Half), []), ((S.Zero,), (S.Zero,)), -z)/2)
Beispiel #8
0
    def __init__(self, data, step_size=1.0):
        """A continuous scalar data source from a discrete time series.

        Time series data points are linearly interpolated in order to generate
        values for points not present in the time series. The time series is
        wrapped in order to generate an infinite sequence.

        :param data: iterable of scalar values
        :param step_size: number of LB iterations corresponding to one unit in
            the time series (i.e. time distance between two neighboring points).
        """

        Symbol.__init__("unused")
        if type(data) is list or type(data) is tuple:
            data = np.float64(data)

        # Copy here is necessary so that the caller doesn't accidentally change
        # the underlying array later. Also, we need the array to be C-contiguous
        # (for __hash__ below), which might not be the case if it's a view.
        self._data = data.copy()
        self._step_size = step_size

        # To be set later by the geometry encoder class. This is necessary due
        # to how the printing system in Sympy works (see _ccode below).
        self._offset = None
Beispiel #9
0
def GeneralizedCoordinate(s, constant=False):
    gc = Symbol(s)(Symbol("t"))
    gc.is_gc = True
    if constant == True:
        gc.fdiff = lambda argindex: 0
    gc.__repr__ = lambda self: PyDyStrPrinter().doprint(self)
    gc.__str__ = lambda self: PyDyStrPrinter().doprint(self)
    return gc
Beispiel #10
0
def test_atoms():
   x = Symbol('x')
   y = Symbol('y')
   assert list((1+x).atoms()) == [1,x]
   assert list(x.atoms()) == [x]
   assert list((1+2*cos(x)).atoms(type=Symbol)) == [x]
   assert list((2*(x**(y**x))).atoms()) == [2,x,y]
   assert list(Rational(1,2).atoms()) == [Rational(1,2)]
   assert list(Rational(1,2).atoms(type=type(oo))) == []
Beispiel #11
0
def test_as_dummy():
    x = Symbol('x')
    x1 = x.as_dummy()
    assert x1 != x
    assert x1 != x.as_dummy()

    x = Symbol('x', commutative=False)
    x1 = x.as_dummy()
    assert x1 != x
    assert x1.is_commutative is False
Beispiel #12
0
def test_as_dummy_nondummy():
    x = Symbol('x')
    x1 = x.as_dummy()
    assert x1 != x
    assert x1 != x.as_dummy()
    # assert x == x1.as_nondummy()

    x = Symbol('x', commutative = False)
    x1 = x.as_dummy()
    assert x1 != x
    assert x1.is_commutative == False
Beispiel #13
0
  def __init__(self, val):
    if not Expr.initialized:
      Expr.initialized = True
      Expr.init()

    if isinstance(val, int) or isinstance(val, long):
      self.expr = Integer(val)
    elif isinstance(val, basestring):
      self.expr = Symbol(val)
    elif isinstance(val, bool) or isinstance(val, BooleanAtom):
      self.expr = S.One if val else S.Zero
    else:
      assert isinstance(val, SymPyExpr) or isinstance(val, BooleanFunction) \
             or (val == S.Infinity) or (val == -S.Infinity)
      self.expr = val
Beispiel #14
0
def test_as_coeff_add():
    x = Symbol("x")
    y = Symbol("y")

    assert S(2).as_coeff_add() == (2, ())
    assert S(3.0).as_coeff_add() == (0, (S(3.0),))
    assert S(-3.0).as_coeff_add() == (0, (S(-3.0),))
    assert x.as_coeff_add() == (0, (x,))
    assert (-1 + x).as_coeff_add() == (-1, (x,))
    assert (2 + x).as_coeff_add() == (2, (x,))
    assert (1 + x).as_coeff_add() == (1, (x,))
    assert (x + y).as_coeff_add(y) == (x, (y,))
    assert (3 * x).as_coeff_add(y) == (3 * x, ())
    # don't do expansion
    e = (x + y) ** 2
    assert e.as_coeff_add(y) == (0, (e,))
Beispiel #15
0
 def __new__(cls, i, label="sigma"):
     if not i in [1, 2, 3]:
         raise IndexError("Invalid Pauli index")
     obj = Symbol.__new__(cls, "%s%d" %(label,i), commutative=False, hermitian=True)
     obj.i = i
     obj.label = label
     return obj
Beispiel #16
0
 def __new__(cls, name, dim=None):
     obj = Symbol.__new__(cls, name)
     obj.dim = dim
     obj._fields = None
     obj._field_names = None
     obj._constant_fields = None
     return obj
Beispiel #17
0
def test_dict_set():
    x = Symbol('x')
    a, b, c = map(Wild, 'abc')

    f = 3*cos(4*x)
    r = f.match(a*cos(b*x))
    assert r == {a: 3, b: 4}
    e = a/b*sin(b*x)
    assert e.subs(r) == r[a]/r[b]*sin(r[b]*x)
    assert e.subs(r) == 3*sin(4*x) / 4
    s = set(r.items())
    assert e.subs(s) == r[a]/r[b]*sin(r[b]*x)
    assert e.subs(s) == 3*sin(4*x) / 4

    assert e.subs(r) == r[a]/r[b]*sin(r[b]*x)
    assert e.subs(r) == 3*sin(4*x) / 4
    assert x.subs(Dict((x, 1))) == 1
Beispiel #18
0
def test_as_coeff_mul():
    x = Symbol("x")
    y = Symbol("y")

    assert S(2).as_coeff_mul() == (2, ())
    assert S(3.0).as_coeff_mul() == (1, (S(3.0),))
    assert S(-3.0).as_coeff_mul() == (-1, (S(3.0),))
    assert x.as_coeff_mul() == (1, (x,))
    assert (-x).as_coeff_mul() == (-1, (x,))
    assert (2 * x).as_coeff_mul() == (2, (x,))
    assert (x * y).as_coeff_mul(y) == (x, (y,))
    assert (3 + x).as_coeff_mul(y) == (3 + x, ())
    # don't do expansion
    e = exp(x + y)
    assert e.as_coeff_mul(y) == (1, (e,))
    e = 2 ** (x + y)
    assert e.as_coeff_mul(y) == (1, (e,))
def test_P():
    assert P(0, z, m) == F(z, m)
    assert P(1, z, m) == F(z, m) + (sqrt(1 - m * sin(z) ** 2) * tan(z) - E(z, m)) / (1 - m)
    assert P(n, i * pi / 2, m) == i * P(n, m)
    assert P(n, z, 0) == atanh(sqrt(n - 1) * tan(z)) / sqrt(n - 1)
    assert P(n, z, n) == F(z, n) - P(1, z, n) + tan(z) / sqrt(1 - n * sin(z) ** 2)
    assert P(oo, z, m) == 0
    assert P(-oo, z, m) == 0
    assert P(n, z, oo) == 0
    assert P(n, z, -oo) == 0
    assert P(0, m) == K(m)
    assert P(1, m) == zoo
    assert P(n, 0) == pi / (2 * sqrt(1 - n))
    assert P(2, 1) == -oo
    assert P(-1, 1) == oo
    assert P(n, n) == E(n) / (1 - n)

    assert P(n, -z, m) == -P(n, z, m)

    ni, mi = Symbol("n", real=False), Symbol("m", real=False)
    assert P(ni, z, mi).conjugate() == P(ni.conjugate(), z.conjugate(), mi.conjugate())
    nr, mr = Symbol("n", real=True, negative=True), Symbol("m", real=True, negative=True)
    assert P(nr, z, mr).conjugate() == P(nr, z.conjugate(), mr)
    assert P(n, m).conjugate() == P(n.conjugate(), m.conjugate())

    assert P(n, z, m).diff(n) == (
        E(z, m)
        + (m - n) * F(z, m) / n
        + (n ** 2 - m) * P(n, z, m) / n
        - n * sqrt(1 - m * sin(z) ** 2) * sin(2 * z) / (2 * (1 - n * sin(z) ** 2))
    ) / (2 * (m - n) * (n - 1))
    assert P(n, z, m).diff(z) == 1 / (sqrt(1 - m * sin(z) ** 2) * (1 - n * sin(z) ** 2))
    assert P(n, z, m).diff(m) == (
        E(z, m) / (m - 1) + P(n, z, m) - m * sin(2 * z) / (2 * (m - 1) * sqrt(1 - m * sin(z) ** 2))
    ) / (2 * (n - m))
    assert P(n, m).diff(n) == (E(m) + (m - n) * K(m) / n + (n ** 2 - m) * P(n, m) / n) / (2 * (m - n) * (n - 1))
    assert P(n, m).diff(m) == (E(m) / (m - 1) + P(n, m)) / (2 * (n - m))
    rx, ry = randcplx(), randcplx()
    assert td(P(n, rx, ry), n)
    assert td(P(rx, z, ry), z)
    assert td(P(rx, ry, m), m)

    assert P(n, z, m).series(z) == z + z ** 3 * (m / 6 + n / 3) + z ** 5 * (
        3 * m ** 2 / 40 + m * n / 10 - m / 30 + n ** 2 / 5 - n / 15
    ) + O(z ** 6)
Beispiel #20
0
def test_F():
    assert F(z, 0) == z
    assert F(0, m) == 0
    assert F(pi*i/2, m) == i*K(m)
    assert F(z, oo) == 0
    assert F(z, -oo) == 0

    assert F(-z, m) == -F(z, m)

    assert F(z, m).diff(z) == 1/sqrt(1 - m*sin(z)**2)
    assert F(z, m).diff(m) == E(z, m)/(2*m*(1 - m)) - F(z, m)/(2*m) - \
        sin(2*z)/(4*(1 - m)*sqrt(1 - m*sin(z)**2))
    r = randcplx()
    assert td(F(z, r), z)
    assert td(F(r, m), m)

    mi = Symbol('m', real=False)
    assert F(z, mi).conjugate() == F(z.conjugate(), mi.conjugate())
    mr = Symbol('m', real=True, negative=True)
    assert F(z, mr).conjugate() == F(z.conjugate(), mr)
def test_E():
    assert E(z, 0) == z
    assert E(0, m) == 0
    assert E(i * pi / 2, m) == i * E(m)
    assert E(z, oo) == zoo
    assert E(z, -oo) == zoo
    assert E(0) == pi / 2
    assert E(1) == 1
    assert E(oo) == I * oo
    assert E(-oo) == oo
    assert E(zoo) == zoo

    assert E(-z, m) == -E(z, m)

    assert E(z, m).diff(z) == sqrt(1 - m * sin(z) ** 2)
    assert E(z, m).diff(m) == (E(z, m) - F(z, m)) / (2 * m)
    assert E(z).diff(z) == (E(z) - K(z)) / (2 * z)
    r = randcplx()
    assert td(E(r, m), m)
    assert td(E(z, r), z)
    assert td(E(z), z)

    mi = Symbol("m", real=False)
    assert E(z, mi).conjugate() == E(z.conjugate(), mi.conjugate())
    assert E(mi).conjugate() == E(mi.conjugate())
    mr = Symbol("m", real=True, negative=True)
    assert E(z, mr).conjugate() == E(z.conjugate(), mr)
    assert E(mr).conjugate() == E(mr)

    assert E(z).rewrite(hyper) == (pi / 2) * hyper((-S.Half, S.Half), (S.One,), z)
    assert tn(E(z), (pi / 2) * hyper((-S.Half, S.Half), (S.One,), z))
    assert E(z).rewrite(meijerg) == -meijerg(((S.Half, S(3) / 2), []), ((S.Zero,), (S.Zero,)), -z) / 4
    assert tn(E(z), -meijerg(((S.Half, S(3) / 2), []), ((S.Zero,), (S.Zero,)), -z) / 4)

    assert E(z, m).series(z) == z + z ** 5 * (-m ** 2 / 40 + m / 30) - m * z ** 3 / 6 + O(z ** 6)
    assert E(z).series(
        z
    ) == pi / 2 - pi * z / 8 - 3 * pi * z ** 2 / 128 - 5 * pi * z ** 3 / 512 - 175 * pi * z ** 4 / 32768 - 441 * pi * z ** 5 / 131072 + O(
        z ** 6
    )
Beispiel #22
0
def test_issue_1460():
    x = Symbol('x')
    e = Symbol('e')
    w = Wild('w', exclude=[x])
    y = Wild('y')

    # this is as it should be

    assert (3/x).match(w/y) == {w: 3, y: x}
    assert (3*x).match(w*y) == {w: 3, y: x}
    assert (x/3).match(y/w) == {w: 3, y: x}
    assert (3*x).match(y/w) == {w: S(1)/3, y: x}

    # these could be allowed to fail

    assert (x/3).match(w/y) == {w: S(1)/3, y: 1/x}
    assert (3*x).match(w/y) == {w: 3, y: 1/x}
    assert (3/x).match(w*y) == {w: 3, y: 1/x}

    # Note that solve will give
    # multiple roots but match only gives one:
    #
    # >>> solve(x**r-y**2,y)
    # [-x**(r/2), x**(r/2)]

    r = Symbol('r', rational=True)
    assert (x**r).match(y**2) == {y: x**(r/2)}
    assert (x**e).match(y**2) == {y: sqrt(x**e)}

    # since (x**i = y) -> x = y**(1/i) where i is an integer
    # the following should also be valid as long as y is not
    # zero when i is negative.

    a = Wild('a')

    e = S(0)
    assert e.match(a) == {a: e}
    assert e.match(1/a) is None
    assert e.match(a**.3) is None

    e = S(3)
    assert e.match(1/a) == {a: 1/e}
    assert e.match(1/a**2) == {a: 1/sqrt(e)}
    e = pi
    assert e.match(1/a) == {a: 1/e}
    assert e.match(1/a**2) == {a: 1/sqrt(e)}
    assert (-e).match(sqrt(a)) is None
    assert (-e).match(a**2) == {a: I*sqrt(pi)}
def test_F():
    assert F(z, 0) == z
    assert F(0, m) == 0
    assert F(pi * i / 2, m) == i * K(m)
    assert F(z, oo) == 0
    assert F(z, -oo) == 0

    assert F(-z, m) == -F(z, m)

    assert F(z, m).diff(z) == 1 / sqrt(1 - m * sin(z) ** 2)
    assert F(z, m).diff(m) == E(z, m) / (2 * m * (1 - m)) - F(z, m) / (2 * m) - sin(2 * z) / (
        4 * (1 - m) * sqrt(1 - m * sin(z) ** 2)
    )
    r = randcplx()
    assert td(F(z, r), z)
    assert td(F(r, m), m)

    mi = Symbol("m", real=False)
    assert F(z, mi).conjugate() == F(z.conjugate(), mi.conjugate())
    mr = Symbol("m", real=True, negative=True)
    assert F(z, mr).conjugate() == F(z.conjugate(), mr)

    assert F(z, m).series(z) == z + z ** 5 * (3 * m ** 2 / 40 - m / 30) + m * z ** 3 / 6 + O(z ** 6)
Beispiel #24
0
    def __new__ (cls, ten, rank=None, shape=None, has_inv=None, transposed=None,
                 **kws):

        # Handle either str or change the behavior
        if isinstance(ten, str):
            name = ten
            if rank is None:
                raise ValueError("Must give rank with string arg.")
            if name in ['0', '1']:
                name = "%s_%d" % (name, rank)

            if name.startswith('0'):
                has_inv = False
            elif name.startswith('1') and rank in [0, 2]:
                has_inv = True
            elif rank == 0:
                has_inv = True
            elif has_inv is None:
                has_inv = False

        elif isinstance(ten, Tensor):
            name = ten.name
            if has_inv is None:
                has_inv = ten.has_inverse
            if not rank is None and rank != ten.rank:
                raise ValueError("Given rank and rank of ten don't match")
            if shape is None and transposed is None:
                shape = ten.shape
            if transposed is None:
                transposed = ten.transposed
            rank = ten.rank
        else:
            raise ValueError("Unable to create Tensor from a %s" \
                             % type(ten))

        if rank > 0 and not kws.has_key("commutative"):
            kws['commutative'] = False

        if transposed is None:
            transposed = False
        if transposed:
            name += "'"

        obj = Symbol.__new__(cls, name, **kws)
        obj.rank = rank
        obj.has_inverse = has_inv
        obj.transposed = transposed
        obj._set_default_shape(shape)
        return obj
Beispiel #25
0
def test_as_dummy():
    x = Symbol('x')
    x1 = x.as_dummy()
    assert x1 != x
    assert x1 != x.as_dummy()

    x = Symbol('x', commutative = False)
    x1 = x.as_dummy()
    assert x1 != x
    assert x1.is_commutative == False

    # issue 2446
    x = Symbol('x', real=True, commutative=False)
    assert x.as_dummy().assumptions0 == x.assumptions0
Beispiel #26
0
    def __new__(cls, name=None, longname=None):

        if name is None or name == "":
            name = "NoName_"+str(Quantity.dummy_count)
            Quantity.dummy_count += 1
            self = Dummy.__new__(cls, name)
        else:
            self = Symbol.__new__(cls, name)

        self.count = Quantity.quantity_count
        Quantity.quantity_count += 1

        self.abbrev = name
        self.name = name
        self.longname = longname
        self.value = None
        self.value_formula = None
        self.error = None
        self.error_formula = None
        self.prefer_unit = None
        self.dim = None
        return self
Beispiel #27
0
Base dimensions


"""

#-----------------------------------------------------------------------------
# Copyright (c) 2013, yt Development Team.
#
# Distributed under the terms of the Modified BSD License.
#
# The full license is in the file COPYING.txt, distributed with this software.
#-----------------------------------------------------------------------------

from sympy import Symbol, sympify, Rational

mass = Symbol("(mass)", positive=True)
length = Symbol("(length)", positive=True)
time = Symbol("(time)", positive=True)
temperature = Symbol("(temperature)", positive=True)
angle = Symbol("(angle)", positive=True)
current_mks = Symbol("(current_mks)", positive=True)
dimensionless = sympify(1)

base_dimensions = [
    mass, length, time, temperature, angle, current_mks, dimensionless
]

#
# Derived dimensions
#
Beispiel #28
0
def test_issue536():
    y = Symbol('y')
    assert integrate(x**2, y) == x**2 * y
    assert integrate(x**2, (y, -1, 1)) == 2 * x**2
from sympy.sets import (ConditionSet, Intersection, FiniteSet,
    EmptySet, Union)
from sympy import (Symbol, Eq, Lt, S, Abs, sin, pi, Lambda, Interval,
    And, Mod, oo, Function)
from sympy.utilities.pytest import raises


w = Symbol('w')
x = Symbol('x')
y = Symbol('y')
z = Symbol('z')
L = Symbol('lambda')
f = Function('f')


def test_CondSet():
    sin_sols_principal = ConditionSet(x, Eq(sin(x), 0),
                                      Interval(0, 2*pi, False, True))
    assert pi in sin_sols_principal
    assert pi/2 not in sin_sols_principal
    assert 3*pi not in sin_sols_principal
    assert 5 in ConditionSet(x, x**2 > 4, S.Reals)
    assert 1 not in ConditionSet(x, x**2 > 4, S.Reals)
    # in this case, 0 is not part of the base set so
    # it can't be in any subset selected by the condition
    assert 0 not in ConditionSet(x, y > 5, Interval(1, 7))
    # since 'in' requires a true/false, the following raises
    # an error because the given value provides no information
    # for the condition to evaluate (since the condition does
    # not depend on the dummy symbol): the result is `y > 5`.
    # In this case, ConditionSet is just acting like
Beispiel #30
0
 def _sympy_(self):
     return Symbol("x")
Beispiel #31
0
    def step(self, action):

        execute_action = False
        execute_sell = False
        execute_buy = False

        ask_price = self.ask_price_history[-1]
        bid_price = self.bid_price_history[-1]

        reward = 0  #reward is the profit

        value_in_stock = 0
        for position in self.positions:
            value_in_stock += position['quantity'] * bid_price

        #the action is an integer anywhere between 0 and max_position
        if action != self.last_action:

            self.last_action = action
            x = Symbol('x')
            r = solve(
                (value_in_stock + x) / (value_in_stock + x + self.cash - x) -
                (action / self.max_position), x)

            r = float(r[0])

            if r > 0:
                #buy
                if r > self.cash:
                    r = self.cash

                num_new_position = action - len(self.positions)

                if num_new_position > 0:

                    per_position_value = r / num_new_position

                    for _ in range(0, int(num_new_position)):
                        new_position = {}
                        new_position['quantity'] = np.floor(
                            per_position_value / ask_price)
                        new_position['price'] = ask_price
                        self.cash -= new_position['quantity'] * new_position[
                            'price']
                        self.positions.append(new_position)
                        execute_action = True
                        execute_buy = True

                    self.positions = sorted(self.positions,
                                            key=lambda k: k['price'])

            elif r < 0:
                #sell

                num_sell_position = len(self.positions) - action

                for _ in range(0, int(num_sell_position)):
                    sold_position = self.positions.pop(
                        0)  #sell the cheapest first
                    self.cash += sold_position['quantity'] * bid_price
                    execute_action = True
                    execute_sell = True
                    reward += sold_position['quantity'] * (
                        sold_position['price'] - bid_price)

        self.current_time_index += 1

        self.ask_price_history.pop(0)
        self.ask_price_history.append(
            self.ask_price_list[self.current_time_index])
        self.bid_price_history.pop(0)
        self.bid_price_history.append(
            self.bid_price_list[self.current_time_index])
        self.middle_price_history.pop(0)
        self.middle_price_history.append(
            self.middle_price_list[self.current_time_index])

        ask_price = self.ask_price_history[-1]
        bid_price = self.bid_price_history[-1]

        value_in_stock = 0
        for position in self.positions:
            value_in_stock += position['quantity'] * bid_price

        self.current_portfolio_value = self.cash + value_in_stock
        current_stock_portfolio_ratio = value_in_stock / self.current_portfolio_value

        observation_dict = {}
        price_for_percentage_computation = self.middle_price_history[
            -1 * self.min_history_length:]
        observed_price_history = [
            100.0 * a1 / a2 - 100
            for a1, a2 in zip(price_for_percentage_computation[1:],
                              price_for_percentage_computation)
        ]
        observation_dict['price_history'] = observed_price_history
        observation_dict['current_stock_ratio'] = current_stock_portfolio_ratio
        observation_dict[
            'current_portfolio_value'] = self.current_portfolio_value
        observation_dict['action'] = action
        observation_dict['raw_price'] = price_for_percentage_computation

        return observation_dict, reward, execute_action
Beispiel #32
0
def wrap_symbol(obj):
    if isinstance(obj, Symbol):
        return obj
    else:
        return Symbol(obj)
Beispiel #33
0
from sympy import sympify, Symbol

x = Symbol('x')  #Se comvierte la variable a simbolico


#Funcion principal del metodo
def metodo_nuevo(x_0, f, tol, iter_max):

    if tol <= 0:
        raise ValueError(
            'Tolerancia no debe ser cero.'
        )  #Error al ingresar una tolerancia con las condiones no aptas
    f = sympify(f)
    k = 0
    x_k = x_0
    error = tol + 1

    D = []
    A = []

    # Cliclo de iteraciones segun tolerancia o maximo de iteraciones
    while error > tol and k < iter_max:
        x_k = calc_sgte(x_k, f)
        error = calc_error(x_k, f)

        D.append(k)
        A.append(error)

        k += 1

    return [x_k, error, k, D, A]
Beispiel #34
0
from sympy import (binomial, Catalan, cos, Derivative, E, exp, EulerGamma,
                   factorial, Function, harmonic, Integral, log, nan, oo, pi,
                   Product, product, Rational, S, sqrt, Sum, summation, Symbol,
                   sympify, zeta)
from sympy.abc import a, b, c, d, k, m, x, y, z
from sympy.concrete.summations import telescopic
from sympy.utilities.pytest import XFAIL, raises

n = Symbol('n', integer=True)


def test_arithmetic_sums():
    assert summation(1, (n, a, b)) == b - a + 1
    assert Sum(S.NaN, (n, a, b)) is S.NaN
    assert Sum(x, (n, a, a)).doit() == x
    assert Sum(x, (x, a, a)).doit() == a
    assert Sum(x, (n, 1, a)).doit() == a * x
    lo, hi = 1, 2
    s1 = Sum(n, (n, lo, hi))
    s2 = Sum(n, (n, hi, lo))
    assert s1 != s2
    assert s1.doit() == s2.doit() == 3
    lo, hi = x, x + 1
    s1 = Sum(n, (n, lo, hi))
    s2 = Sum(n, (n, hi, lo))
    assert s1 != s2
    assert s1.doit() == s2.doit() == 2 * x + 1
    assert Sum(Integral(x, (x, 1, y)) + x, (x, 1, 2)).doit() == \
        y**2 + 2
    assert summation(1, (n, 1, 10)) == 10
    assert summation(2 * n, (n, 0, 10**10)) == 100000000010000000000
Beispiel #35
0
from functools import singledispatch
from typing import Tuple as tTuple

from sympy import (Basic, S, Expr, Symbol, Tuple, And, Add, Eq, lambdify, Or,
                   Equality, Lambda, sympify, Dummy, Ne, KroneckerDelta,
                   DiracDelta, Mul, Indexed, MatrixSymbol, Function)
from sympy.core.relational import Relational
from sympy.core.sympify import _sympify
from sympy.sets.sets import FiniteSet, ProductSet, Intersection
from sympy.solvers.solveset import solveset
from sympy.external import import_module
from sympy.utilities.misc import filldedent
import warnings

x = Symbol('x')


@singledispatch
def is_random(x):
    return False


@is_random.register(Basic)
def _(x):
    atoms = x.free_symbols
    return any([is_random(i) for i in atoms])


class RandomDomain(Basic):
    """
Beispiel #36
0
def test_ndim_array_initiation():
    arr_with_no_elements = ImmutableDenseNDimArray([], shape=(0, ))
    assert len(arr_with_no_elements) == 0
    assert arr_with_no_elements.rank() == 1

    raises(ValueError, lambda: ImmutableDenseNDimArray([0], shape=(0, )))
    raises(ValueError, lambda: ImmutableDenseNDimArray([1, 2, 3], shape=(0, )))
    raises(ValueError, lambda: ImmutableDenseNDimArray([], shape=()))

    raises(ValueError, lambda: ImmutableSparseNDimArray([0], shape=(0, )))
    raises(ValueError,
           lambda: ImmutableSparseNDimArray([1, 2, 3], shape=(0, )))
    raises(ValueError, lambda: ImmutableSparseNDimArray([], shape=()))

    arr_with_one_element = ImmutableDenseNDimArray([23])
    assert len(arr_with_one_element) == 1
    assert arr_with_one_element[0] == 23
    assert arr_with_one_element[:] == ImmutableDenseNDimArray([23])
    assert arr_with_one_element.rank() == 1

    arr_with_symbol_element = ImmutableDenseNDimArray([Symbol('x')])
    assert len(arr_with_symbol_element) == 1
    assert arr_with_symbol_element[0] == Symbol('x')
    assert arr_with_symbol_element[:] == ImmutableDenseNDimArray([Symbol('x')])
    assert arr_with_symbol_element.rank() == 1

    number5 = 5
    vector = ImmutableDenseNDimArray.zeros(number5)
    assert len(vector) == number5
    assert vector.shape == (number5, )
    assert vector.rank() == 1

    vector = ImmutableSparseNDimArray.zeros(number5)
    assert len(vector) == number5
    assert vector.shape == (number5, )
    assert vector._sparse_array == Dict()
    assert vector.rank() == 1

    n_dim_array = ImmutableDenseNDimArray(range(3**4), (
        3,
        3,
        3,
        3,
    ))
    assert len(n_dim_array) == 3 * 3 * 3 * 3
    assert n_dim_array.shape == (3, 3, 3, 3)
    assert n_dim_array.rank() == 4

    array_shape = (3, 3, 3, 3)
    sparse_array = ImmutableSparseNDimArray.zeros(*array_shape)
    assert len(sparse_array._sparse_array) == 0
    assert len(sparse_array) == 3 * 3 * 3 * 3
    assert n_dim_array.shape == array_shape
    assert n_dim_array.rank() == 4

    one_dim_array = ImmutableDenseNDimArray([2, 3, 1])
    assert len(one_dim_array) == 3
    assert one_dim_array.shape == (3, )
    assert one_dim_array.rank() == 1
    assert one_dim_array.tolist() == [2, 3, 1]

    shape = (3, 3)
    array_with_many_args = ImmutableSparseNDimArray.zeros(*shape)
    assert len(array_with_many_args) == 3 * 3
    assert array_with_many_args.shape == shape
    assert array_with_many_args[0, 0] == 0
    assert array_with_many_args.rank() == 2

    shape = (int(3), int(3))
    array_with_long_shape = ImmutableSparseNDimArray.zeros(*shape)
    assert len(array_with_long_shape) == 3 * 3
    assert array_with_long_shape.shape == shape
    assert array_with_long_shape[int(0), int(0)] == 0
    assert array_with_long_shape.rank() == 2

    vector_with_long_shape = ImmutableDenseNDimArray(range(5), int(5))
    assert len(vector_with_long_shape) == 5
    assert vector_with_long_shape.shape == (int(5), )
    assert vector_with_long_shape.rank() == 1
    raises(ValueError, lambda: vector_with_long_shape[int(5)])

    from sympy.abc import x
    for ArrayType in [ImmutableDenseNDimArray, ImmutableSparseNDimArray]:
        rank_zero_array = ArrayType(x)
        assert len(rank_zero_array) == 1
        assert rank_zero_array.shape == ()
        assert rank_zero_array.rank() == 0
        assert rank_zero_array[()] == x
        raises(ValueError, lambda: rank_zero_array[0])
Beispiel #37
0
# print(solve(expr, dict=True))

# from sympy import Symbol, solve
# x=Symbol('x')
# expr = x**2 + x + 1
# print(solve(expr, dict=True))

# from sympy import Symbol, solve
# x = Symbol('x')
# a = Symbol('a')
# b = Symbol('b')
# c = Symbol('c')
# expr = a*x*x + b*x + c
# print(solve(expr, x, dict=True))

# from sympy import Symbol, solve, pprint
# s = Symbol('s')
# u = Symbol('u')
# t = Symbol('t')
# a = Symbol('a')
# expr = u*t + (1/2)*a*t*t - s
# t_expr = solve(expr,t, dict=True)
# pprint(t_expr)

from sympy import Symbol, solve
x = Symbol('x')
y = Symbol('y')
expr1 = 2 * x + 3 * y - 6
expr2 = 3 * x + 2 * y - 12
print(solve((expr1, expr2), dict=True))
Beispiel #38
0
 def gen_kargs(self):
     kargs = []
     if len(self._indexes) == 3:
         argspaces = {
             tuple(): "KerArgSpace(1, KER_ITER_TILE0)",
             (0, ): "KerArgSpace(1, KER_ITER_D0)",
             (1, ): "KerArgSpace(1, KER_ITER_TILE0)",
             (2, ): "KerArgSpace(1, KER_ITER_TILE0)",
             (0, 1): "KerArgSpace(2, KER_ITER_D0, KER_ITER_TILE0)",
             (0, 2): "KerArgSpace(2, KER_ITER_D0, KER_ITER_TILE0)",
             (1, 2): "KerArgSpace(1, KER_ITER_TILE0)",
             (0, 1, 2): "KerArgSpace(2, KER_ITER_D0, KER_ITER_TILE0)",
         }
         out_argspace = "KerArgSpace(2, KER_ITER_D0, KER_ITER_TILE0)"
         dim_w = 2
         dim_h = 1
     elif len(self._indexes) == 2:
         argspaces = {
             tuple(): "KerArgSpace(1, KER_ITER_TILE0)",
             (0, ): "KerArgSpace(1, KER_ITER_TILE0)",
             (1, ): "KerArgSpace(1, KER_ITER_TILE0)",
             (0, 1): "KerArgSpace(1, KER_ITER_TILE0)",
         }
         out_argspace = "KerArgSpace(1, KER_ITER_TILE0)"
         dim_w = 1
         dim_h = 0
     elif len(self._indexes) == 1:
         argspaces = {
             tuple(): "KerArgSpace(1, KER_ITER_TILE0)",
             (0, ): "KerArgSpace(1, KER_ITER_TILE0)",
         }
         out_argspace = "KerArgSpace(1, KER_ITER_TILE0)"
         dim_w = -1
         dim_h = 0
     else:
         raise NotImplementedError()
     for input_node in self._inputs:
         sym = Symbol(input_node.name)
         arg_indexes = self._symbol_indexes[sym]
         argspace = argspaces[arg_indexes]
         constraints = "O_IN|O_DB|O_CONST" if self._constant_inputs[
             input_node.idx] else "O_IN|O_DB"
         dims = [
             index[1] if idx in arg_indexes else 1
             for idx, index in enumerate(self._indexes)
         ]
         width = dims[dim_w] if dim_w > -1 else 1
         height = dims[dim_h] if dim_h > -1 else 1
         kargs.append(
             "KerArg(\"{0}\", {1}, {2}, {3}, {4}, 1, 0, 0, 0, \"{0}\")".
             format(sym.name, argspace, constraints, height, width))
     dims = [index[1] for index in self._indexes]
     for output_node in self._outputs:
         name = output_node.name
         constraints = "O_OUT|O_DB"
         width = dims[dim_w] if dim_w > -1 else 1
         height = dims[dim_h] if dim_h > -1 else 1
         kargs.append(
             "KerArg(\"{0}\", {1}, {2}, {3}, {4}, 1, 0, 0, 0, \"{0}\")".
             format(name, out_argspace, constraints, height, width))
     return kargs
Beispiel #39
0
def test_issue_4099():
    a = Symbol('a')
    assert limit(a/x, x, 0) == oo*sign(a)
    assert limit(-a/x, x, 0) == -oo*sign(a)
    assert limit(-a*x, x, oo) == -oo*sign(a)
    assert limit(a*x, x, oo) == oo*sign(a)
Beispiel #40
0
 def __new__(cls, name, *args, **assumptions):
     return Symbol.__new__(cls, name.upper(), real=True, **assumptions)
Beispiel #41
0
def test_issue_6366():
    n = Symbol('n', integer=True, positive=True)
    r = (n + 1)*x**(n + 1)/(x**(n + 1) - 1) - x/(x - 1)
    assert limit(r, x, 1).simplify() == n/2
Beispiel #42
0
 def __new__(cls, s, distribution):
     if isinstance(s, str):
         s = Symbol(s)
     if not isinstance(s, Symbol):
         raise TypeError("s should have been string or Symbol")
     return Basic.__new__(cls, s, distribution)
Beispiel #43
0
""" 
Show that Guayan-Reduction of a single element result in rigid body modes

"""

import numpy as np
import sympy
from sympy import Symbol
from sympy import Matrix
from sympy.abc import *
from fem.frame3d import frame3d_KeMe

display = lambda x: sympy.pprint(x, use_unicode=False, wrap_line=False)

Kv = Symbol('Kv')
Ix = Symbol('Ix')
Iy = Symbol('Iy')
Iz = Symbol('Iz')
Mass = Symbol('M')

Ke, Me = frame3d_KeMe(E, G, Kv, E * A, E * Ix, E * Iy, E * Iz, L, A, Mass)
Ke = Matrix(Ke)
Me = Matrix(Me)
Kmm = Ke[:6, :6]
Ksm = Ke[6:, :6]
Kss = Ke[6:, 6:]
Kssm1 = Kss.inv()

print(
    '-----------------------------------------------------------------------------------------'
)
Beispiel #44
0
def test_issue_6364():
    a = Symbol('a')
    e = z/(1 - sqrt(1 + z)*sin(a)**2 - sqrt(1 - z)*cos(a)**2)
    assert limit(e, z, 0).simplify() == 2/cos(2*a)
Beispiel #45
0
def test_integrate_omit_var():
    y = Symbol('y')
    raises(ValueError, "integrate(2)")
    assert integrate(x) == x**2 / 2
    assert integrate(x * y) == x**2 * y**2 / 4
Beispiel #46
0
def test_issue_7088():
    a = Symbol('a')
    assert limit(sqrt(x/(x + a)), x, oo) == 1
Beispiel #47
0
def test_order_oo():
    x = Symbol('x', positive=True, finite=True)
    assert Order(x)*oo != Order(1, x)
    assert limit(oo/(x**2 - 4), x, oo) == oo
Beispiel #48
0
 def func(block, idx):
     return [
         VarFor(Declaration(Variable(Symbol(idx[0]), type=uint32)),
                VarRange(idx[2][0], idx[2][1], Integer(1)), block)
     ]
Beispiel #49
0
combinations of noncommutative SymPy symbols.

also contains "half_angle_reduce" which is probably not needed any more
due to the improvements in trigsimp.
"""

from sympy import expand, Mul, Add, Symbol, S, Pow, diff, trigsimp, \
    simplify, sin, cos, symbols

try:
    from numpy import matrix
    numpy_loaded = True
except ImportError:
    numpy_loaded = False

ONE_NC = Symbol('ONE', commutative=False)


def get_commutative_coef(expr):
    if isinstance(expr, Mul):
        (coefs, bases) = expr.args_cnc()
        return Mul(*coefs)
    return S.One


def half_angle_reduce(expr, theta):
    s, c = symbols('s c')
    sub_dict = {sin(theta / 2): s, cos(theta / 2): c}
    new_expr = expr.subs(sub_dict)
    sub_dict = {
        s * c: sin(theta) / 2,
# -*- coding: utf-8 -*-
"""
Created on Fri Jul 31 09:39:18 2020

@author: andfg
"""
# =============================================================================
# RESUMEN SOBRE SYMPY 
# =============================================================================


# =============================================================================
# 1. Definir simbolos

from sympy import Symbol
x=Symbol("x") #Atribuye a x el valor del simbolo "x"

from sympy import symbols #permite  declarar multiples simbolos en una linea
x,y,z = symbols("x, y, z")

# =============================================================================
# =============================================================================
# 2. Factorizar y expandir expreciones 
from sympy import factor, expand
expr1= x**2 - y**2
factor(expr1) ##factor factoriza un expresion en la medida de lo posible

expr2=(x+2)**3 
expand(expr2) ## expand expande expresiones

# =============================================================================
Beispiel #51
0
def test_issue_5939():
    a = Symbol('a')
    b = Symbol('b')
    assert sympify('''a+\nb''') == a + b
Beispiel #52
0
def test_values():
    assert set(PropertiesOnlyMatrix(2, 2,
                                    [0, 1, 2, 3]).values()) == set([1, 2, 3])
    x = Symbol('x', real=True)
    assert set(PropertiesOnlyMatrix(2, 2,
                                    [x, 0, 0, 1]).values()) == set([x, 1])
Beispiel #53
0
 def __new__(cls, name, constant=None, fundamental=None, substitution=None, substitution_atoms=None, datatype=None, **assumptions) :
     from sympy import Symbol
     return Symbol.__new__(cls, name, **assumptions)
Beispiel #54
0
def test_multiplication():
    a = ArithmeticOnlyMatrix((
        (1, 2),
        (3, 1),
        (0, 6),
    ))

    b = ArithmeticOnlyMatrix((
        (1, 2),
        (3, 0),
    ))

    raises(ShapeError, lambda: b * a)
    raises(TypeError, lambda: a * {})

    c = a * b
    assert c[0, 0] == 7
    assert c[0, 1] == 2
    assert c[1, 0] == 6
    assert c[1, 1] == 6
    assert c[2, 0] == 18
    assert c[2, 1] == 0

    try:
        eval('c = a @ b')
    except SyntaxError:
        pass
    else:
        assert c[0, 0] == 7
        assert c[0, 1] == 2
        assert c[1, 0] == 6
        assert c[1, 1] == 6
        assert c[2, 0] == 18
        assert c[2, 1] == 0

    h = a.multiply_elementwise(c)
    assert h == matrix_multiply_elementwise(a, c)
    assert h[0, 0] == 7
    assert h[0, 1] == 4
    assert h[1, 0] == 18
    assert h[1, 1] == 6
    assert h[2, 0] == 0
    assert h[2, 1] == 0
    raises(ShapeError, lambda: a.multiply_elementwise(b))

    c = b * Symbol("x")
    assert isinstance(c, ArithmeticOnlyMatrix)
    assert c[0, 0] == x
    assert c[0, 1] == 2 * x
    assert c[1, 0] == 3 * x
    assert c[1, 1] == 0

    c2 = x * b
    assert c == c2

    c = 5 * b
    assert isinstance(c, ArithmeticOnlyMatrix)
    assert c[0, 0] == 5
    assert c[0, 1] == 2 * 5
    assert c[1, 0] == 3 * 5
    assert c[1, 1] == 0

    try:
        eval('c = 5 @ b')
    except SyntaxError:
        pass
    else:
        assert isinstance(c, ArithmeticOnlyMatrix)
        assert c[0, 0] == 5
        assert c[0, 1] == 2 * 5
        assert c[1, 0] == 3 * 5
        assert c[1, 1] == 0
Beispiel #55
0
def test_issue_3595():
    assert sympify("a_") == Symbol("a_")
    assert sympify("_a") == Symbol("_a")
Beispiel #56
0
def test_issue_4503():
    dx = Symbol('dx')
    assert limit((sqrt(1 + exp(x + dx)) - sqrt(1 + exp(x)))/dx, dx, 0) == \
        exp(x)/(2*sqrt(exp(x) + 1))
Beispiel #57
0
 def __new__(cls, data, step_size=1.0):
     return Symbol.__new__(cls, "lits%s_%s" % (hashlib.sha1(np.array(data)).hexdigest(), step_size))
Beispiel #58
0
def test_lambda():
    x = Symbol('x')
    assert sympify('lambda: 1') == Lambda((), 1)
    assert sympify('lambda x: x') == Lambda(x, x)
    assert sympify('lambda x: 2*x') == Lambda(x, 2 * x)
    assert sympify('lambda x, y: 2*x+y') == Lambda([x, y], 2 * x + y)
Beispiel #59
0
 def __new__(cls, i):
     if not i in [1, 2, 3]:
         raise IndexError("Invalid Pauli index")
     obj = Symbol.__new__(cls, "sigma%d" % i, commutative=False)
     obj.i = i
     return obj
Beispiel #60
0
def test_sympify_set():
    n = Symbol('n')
    assert sympify({n}) == FiniteSet(n)
    assert sympify(set()) == EmptySet()