Пример #1
0
def test_sets():
    x = Integer(2)
    y = Integer(3)
    x1 = sympy.Integer(2)
    y1 = sympy.Integer(3)

    assert Interval(x, y) == Interval(x1, y1)
    assert Interval(x1, y) == Interval(x1, y1)
    assert Interval(x, y)._sympy_() == sympy.Interval(x1, y1)
    assert sympify(sympy.Interval(x1, y1)) == Interval(x, y)

    assert sympify(sympy.EmptySet()) == EmptySet()
    assert sympy.EmptySet() == EmptySet()._sympy_()

    assert FiniteSet(x, y) == FiniteSet(x1, y1)
    assert FiniteSet(x1, y) == FiniteSet(x1, y1)
    assert FiniteSet(x, y)._sympy_() == sympy.FiniteSet(x1, y1)
    assert sympify(sympy.FiniteSet(x1, y1)) == FiniteSet(x, y)

    x = Interval(1, 2)
    y = Interval(2, 3)
    x1 = sympy.Interval(1, 2)
    y1 = sympy.Interval(2, 3)

    assert Union(x, y) == Union(x1, y1)
    assert Union(x1, y) == Union(x1, y1)
    assert Union(x, y)._sympy_() == sympy.Union(x1, y1)
    assert sympify(sympy.Union(x1, y1)) == Union(x, y)

    assert Complement(x, y) == Complement(x1, y1)
    assert Complement(x1, y) == Complement(x1, y1)
    assert Complement(x, y)._sympy_() == sympy.Complement(x1, y1)
    assert sympify(sympy.Complement(x1, y1)) == Complement(x, y)
Пример #2
0
def test_n():
    x = Symbol("x")
    raises(RuntimeError, lambda: (x.n()))

    x = 2 + I
    raises(RuntimeError, lambda: (x.n(real=True)))

    x = sqrt(Integer(4))
    y = RealDouble(2.0)
    assert x.n(real=True) == y

    x = 1 + 2*I
    y = 1.0 + 2.0*I
    assert x.n() == y

    try:
        from symengine import RealMPFR
        x = sqrt(Integer(2))
        y = RealMPFR('1.41421356237309504880169', 75)
        assert x.n(75, real=True) == y
    except ImportError:
        x = sqrt(Integer(2))
        raises(ValueError, lambda: (x.n(75, real=True)))

    try:
        from symengine import ComplexMPC
        x = sqrt(Integer(2)) + 3*I
        y = ComplexMPC('1.41421356237309504880169', '3.0', 75)
        assert x.n(75) == y
    except ImportError:
        x = sqrt(Integer(2))
        raises(ValueError, lambda: (x.n(75)))
Пример #3
0
def test_conv10():
    A = DenseMatrix(1, 4, [Integer(1), Integer(2), Integer(3), Integer(4)])
    assert (A._sympy_() == sympy.Matrix(1, 4, [
        sympy.Integer(1),
        sympy.Integer(2),
        sympy.Integer(3),
        sympy.Integer(4)
    ]))

    B = DenseMatrix(4, 1, [Symbol("x"), Symbol("y"), Symbol("z"), Symbol("t")])
    assert (B._sympy_() == sympy.Matrix(4, 1, [
        sympy.Symbol("x"),
        sympy.Symbol("y"),
        sympy.Symbol("z"),
        sympy.Symbol("t")
    ]))

    C = DenseMatrix(
        2, 2,
        [Integer(5),
         Symbol("x"),
         function_symbol("f", Symbol("x")), 1 + I])

    assert (C._sympy_() == sympy.Matrix(
        [[5, sympy.Symbol("x")],
         [sympy.Function("f")(sympy.Symbol("x")), 1 + sympy.I]]))
Пример #4
0
def test_args():
    x = Symbol("x")
    y = Symbol("y")
    assert (x**2).args == (x, 2)
    assert (x**2 + 5).args == (5, x**2)
    assert set((x**2 + 2*x*y + 5).args) == set((x**2, 2*x*y, Integer(5)))
    assert (2*x**2).args == (2, x**2)
    assert set((2*x**2*y).args) == set((Integer(2), x**2, y))
Пример #5
0
def test_as_numer_denom():
    x, y = Rational(17, 26).as_numer_denom()
    assert x == Integer(17)
    assert y == Integer(26)

    x, y = Integer(-5).as_numer_denom()
    assert x == Integer(-5)
    assert y == Integer(1)
Пример #6
0
    def test_function_within_function(self):
        expression = f(f(42))

        self.assertEqual(collect_arguments(expression, f),
                         {(Integer(42), ), (f(Integer(42)), )})

        self.assertEqual(count_calls(expression, f), 2)
        self.assertTrue(has_function(expression, f))
        self.assertEqual(replace_function(expression, f, g), g(g(42)))
Пример #7
0
def test_n_mpfr():
    try:
        from symengine import RealMPFR
        x = sqrt(Integer(2))
        y = RealMPFR('1.41421356237309504880169', 75)
        assert x.n(75, real=True) == y
    except ImportError:
        x = sqrt(Integer(2))
        raises(ValueError, lambda: (x.n(75, real=True)))
        raise SkipTest("No MPFR support")
Пример #8
0
def test_n_mpc():
    try:
        from symengine import ComplexMPC
        x = sqrt(Integer(2)) + 3 * I
        y = ComplexMPC('1.41421356237309504880169', '3.0', 75)
        assert x.n(75) == y
    except ImportError:
        x = sqrt(Integer(2))
        raises(ValueError, lambda: (x.n(75)))
        raise SkipTest("No MPC support")
Пример #9
0
def test_ccode():
    x = Symbol("x")
    y = Symbol("y")
    assert ccode(x) == "x"
    assert ccode(x**3) == "pow(x, 3)"
    assert ccode(x**(y**3)) == "pow(x, pow(y, 3))"
    assert ccode(x**-1.0) == "pow(x, -1.0)"
    assert ccode(Max(x, x*x)) == "fmax(x, pow(x, 2))"
    assert ccode(sin(x)) == "sin(x)"
    assert ccode(Integer(67)) == "67"
    assert ccode(Integer(-1)) == "-1"
Пример #10
0
def test_complex():
    i = Integer(5) / 10 + I
    assert str(i) == "1/2 + I"
    assert complex(i) == 0.5 + 1j
    assert i.real == Integer(1) / 2
    assert i.imag == 1

    i = 0.5 + I
    assert str(i) == "0.5 + 1.0*I"
    assert complex(i) == 0.5 + 1j
    assert i.real == 0.5
    assert i.imag == 1.0
Пример #11
0
def test_arit2():
    x = Symbol("x")
    y = Symbol("y")
    assert x + x == Integer(2) * x
    assert x + x != Integer(3) * x
    assert x + y == y + x
    assert x + x == 2 * x
    assert x + x == x * 2
    assert x + x + x == 3 * x
    assert x + y + x + x == 3 * x + y

    assert not x + x == 3 * x
    assert not x + x != 2 * x
Пример #12
0
def test_FunctionWrapper():
    import sympy
    sympy.var("n, m, theta, phi")
    r = sympy.Ynm(n, m, theta, phi)
    s = Integer(2) * r
    assert isinstance(s, Mul)
    assert isinstance(s.args[1]._sympy_(), sympy.Ynm)
Пример #13
0
def test_conv10b():
    A = sympy.Matrix([[sympy.Symbol("x"), sympy.Symbol("y")],
                     [sympy.Symbol("z"), sympy.Symbol("t")]])
    assert sympify(A) == DenseMatrix(2, 2, [Symbol("x"), Symbol("y"),
                                            Symbol("z"), Symbol("t")])

    B = sympy.Matrix([[1, 2], [3, 4]])
    assert sympify(B) == DenseMatrix(2, 2, [Integer(1), Integer(2), Integer(3),
                                            Integer(4)])

    C = sympy.Matrix([[7, sympy.Symbol("y")],
                     [sympy.Function("g")(sympy.Symbol("z")), 3 + 2*sympy.I]])
    assert sympify(C) == DenseMatrix(2, 2, [Integer(7), Symbol("y"),
                                            function_symbol("g",
                                                            Symbol("z")),
                                            3 + 2*I])
Пример #14
0
def test_FunctionWrapper():
    import sympy
    n, m, theta, phi = sympy.symbols("n, m, theta, phi")
    r = sympy.Ynm(n, m, theta, phi)
    s = Integer(2) * r
    assert isinstance(s, Mul)
    assert isinstance(s.args[1]._sympy_(), sympy.Ynm)

    x = symbols("x")
    e = x + sympy.loggamma(x)
    assert str(e) == "x + loggamma(x)"
    assert isinstance(e, Add)
    assert e + sympy.loggamma(x) == x + 2 * sympy.loggamma(x)

    f = e.subs({x: 10})
    assert f == 10 + log(362880)

    f = e.subs({x: 2})
    assert f == 2

    f = e.subs({x: 100})
    v = f.n(53, real=True)
    assert abs(float(v) - 459.13420537) < 1e-7

    f = e.diff(x)
    assert f == 1 + sympy.polygamma(0, x)
Пример #15
0
def test_integer():
    i = Integer(5)
    assert str(i) == "5"
    assert int(i) == 5
    assert float(i) == 5.0
    assert complex(i) == 5.0 + 0j
    assert i.real == i
    assert i.imag == S.Zero
Пример #16
0
def test_conv9():
    x = Symbol("x")
    y = Symbol("y")
    assert (I)._sympy_() == sympy.I
    assert (2*I+3)._sympy_() == 2*sympy.I+3
    assert (2*I/5+Integer(3)/5)._sympy_() == 2*sympy.I/5+sympy.S(3)/5
    assert (x*I+3)._sympy_() == sympy.Symbol("x")*sympy.I + 3
    assert (x+I*y)._sympy_() == sympy.Symbol("x") + sympy.I*sympy.Symbol("y")
Пример #17
0
def test_conv9b():
    x = Symbol("x")
    y = Symbol("y")
    assert sympify(sympy.I) == I
    assert sympify(2*sympy.I+3) == 2*I+3
    assert sympify(2*sympy.I/5+sympy.S(3)/5) == 2*I/5+Integer(3)/5
    assert sympify(sympy.Symbol("x")*sympy.I + 3) == x*I+3
    assert sympify(sympy.Symbol("x") + sympy.I*sympy.Symbol("y")) == x+I*y
Пример #18
0
def test_rational():
    i = Integer(5) / 10
    assert str(i) == "1/2"
    assert int(i) == 0
    assert float(i) == 0.5
    assert complex(i) == 0.5 + 0j
    assert i.real == i
    assert i.imag == S.Zero
Пример #19
0
def test_sets():
    x = Integer(2)
    y = Integer(3)
    x1 = sympy.Integer(2)
    y1 = sympy.Integer(3)

    assert Interval(x, y) == Interval(x1, y1)
    assert Interval(x1, y) == Interval(x1, y1)
    assert Interval(x, y)._sympy_() == sympy.Interval(x1, y1)
    assert sympify(sympy.Interval(x1, y1)) == Interval(x, y)

    assert sympify(sympy.S.EmptySet) == EmptySet()
    assert sympy.S.EmptySet == EmptySet()._sympy_()

    assert sympify(sympy.S.UniversalSet) == UniversalSet()
    assert sympy.S.UniversalSet == UniversalSet()._sympy_()

    assert sympify(sympy.S.Reals) == Reals()
    assert sympy.S.Reals == Reals()._sympy_()

    assert sympify(sympy.S.Rationals) == Rationals()
    assert sympy.S.Rationals == Rationals()._sympy_()

    assert sympify(sympy.S.Integers) == Integers()
    assert sympy.S.Integers == Integers()._sympy_()

    assert FiniteSet(x, y) == FiniteSet(x1, y1)
    assert FiniteSet(x1, y) == FiniteSet(x1, y1)
    assert FiniteSet(x, y)._sympy_() == sympy.FiniteSet(x1, y1)
    assert sympify(sympy.FiniteSet(x1, y1)) == FiniteSet(x, y)

    x = Interval(1, 2)
    y = Interval(2, 3)
    x1 = sympy.Interval(1, 2)
    y1 = sympy.Interval(2, 3)

    assert Union(x, y) == Union(x1, y1)
    assert Union(x1, y) == Union(x1, y1)
    assert Union(x, y)._sympy_() == sympy.Union(x1, y1)
    assert sympify(sympy.Union(x1, y1)) == Union(x, y)

    assert Complement(x, y) == Complement(x1, y1)
    assert Complement(x1, y) == Complement(x1, y1)
    assert Complement(x, y)._sympy_() == sympy.Complement(x1, y1)
    assert sympify(sympy.Complement(x1, y1)) == Complement(x, y)
Пример #20
0
def test_arit1():
    x = Symbol("x")
    y = Symbol("y")
    e = x + y
    e = x * y
    e = Integer(2) * x
    e = 2 * x
    e = x + 1
    e = 1 + x
Пример #21
0
def test_as_coefficients_dict():
    x = Symbol('x')
    y = Symbol('y')
    check = [x, y, x*y, Integer(1)]
    assert [(3*x + 2*x + y + 3).as_coefficients_dict()[i] for i in check] == \
        [5, 1, 0, 3]
    assert [(3*x*y).as_coefficients_dict()[i] for i in check] == \
        [0, 0, 3, 0]
    assert (3.0*x*y).as_coefficients_dict()[3.0*x*y] == 0
    assert (3.0*x*y).as_coefficients_dict()[x*y] == 3.0
Пример #22
0
def test_abs():
    x = Symbol("x")
    e = abs(x)
    assert e == abs(x)
    assert e != cos(x)

    assert abs(5) == 5
    assert abs(-5) == 5
    assert abs(Integer(5) / 3) == Integer(5) / 3
    assert abs(-Integer(5) / 3) == Integer(5) / 3
    assert abs(Integer(5) / 3 + x) != Integer(5) / 3
    assert abs(Integer(5) / 3 + x) == abs(Integer(5) / 3 + x)
Пример #23
0
def test_arit6():
    x = Symbol("x")
    y = Symbol("y")
    e = x + y
    assert str(e) == "x + y" or "y + x"
    e = x * y
    assert str(e) == "x*y" or "y*x"
    e = Integer(2) * x
    assert str(e) == "2*x"
    e = 2 * x
    assert str(e) == "2*x"
Пример #24
0
def test_is_conditions():
    i = Integer(-123)
    assert not i.is_zero
    assert not i.is_positive
    assert i.is_negative
    assert i.is_nonzero
    assert i.is_nonpositive
    assert not i.is_nonnegative
    assert not i.is_complex

    i = Integer(123)
    assert not i.is_zero
    assert i.is_positive
    assert not i.is_negative
    assert i.is_nonzero
    assert not i.is_nonpositive
    assert i.is_nonnegative
    assert not i.is_complex

    i = Integer(0)
    assert i.is_zero
    assert not i.is_positive
    assert not i.is_negative
    assert not i.is_nonzero
    assert i.is_nonpositive
    assert i.is_nonnegative
    assert not i.is_complex

    i = Integer(1) + I
    assert not i.is_zero
    assert not i.is_positive
    assert not i.is_negative
    assert not i.is_nonzero
    assert not i.is_nonpositive
    assert not i.is_nonnegative
    assert i.is_complex

    assert pi.is_number
Пример #25
0
def test_n():
    x = Symbol("x")
    raises(RuntimeError, lambda: (x.n()))

    x = 2 + I
    raises(RuntimeError, lambda: (x.n(real=True)))

    x = sqrt(Integer(4))
    y = RealDouble(2.0)
    assert x.n(real=True) == y

    x = 1 + 2 * I
    y = 1.0 + 2.0 * I
    assert x.n() == y
Пример #26
0
 def test_find_dependent_helpers(self):
     helpers = [
         (q, p),
         (r, sin(q)),
         (s, 3 * p + r),
         (u, Integer(42)),
     ]
     control = [
         (q, 1),
         (r, cos(q)),
         (s, 3 + cos(q)),
     ]
     dependent_helpers = find_dependent_helpers(helpers, p)
     # This check is overly restrictive due to depending on the order and exact form of the result:
     self.assertListEqual(dependent_helpers, control)
Пример #27
0
def test_S():
    assert S(0) == Integer(0)
    assert S(1) == Integer(1)
    assert S(-1) == Integer(-1)
    assert S(1) / 2 == Rational(1, 2)
    assert S.One is S(1)
    assert S.Zero is S(0)
    assert S.NegativeOne is S(-1)
    assert S.Half is S(1) / 2
    assert S.Pi is pi
    assert S.NaN is S(0) / 0
    assert S.Infinity is -oo * -10
    assert S.NegativeInfinity is oo * (-3)
    assert S.ComplexInfinity is zoo
    assert S.Exp1 is (E + 1 - 1)
    assert S.ImaginaryUnit is sqrt(-1)
    assert S.GoldenRatio * 2 / 2 is GoldenRatio
    assert S.Catalan * 1 is Catalan
    assert S.EulerGamma is polygamma(0, 1) * -1
    assert S.true is Eq(2, 2)
    assert S.false is Eq(2, 3)
    assert S(1) / 0 is zoo
    assert S.Pi * 1 is pi
    assert type(S.One) == One
Пример #28
0
def test_sympify1():
    assert sympify(1) == Integer(1)
    assert sympify(2) != Integer(1)
    assert sympify(-5) == Integer(-5)
    assert sympify(Integer(3)) == Integer(3)
    assert sympify(('0', '0')) == (0, 0)
    assert sympify(['0', '0']) == [0, 0]
    assert sympify("3+5") == Integer(8)
    assert true == sympify(True)
    assert false == sympify(False)
Пример #29
0
def solid_harmonics(lmax, scaled=False):
    """Symbolic real solid harmonics up to order lmax.

    .. code-block:: python

        sh = solid_harmonics(6)  # Inclusive, so computes up to l = 6
        sh[3][-3]                # symbolic f-phi angular function

    Args:
        lmax (int): highest order angular momentum quantum number
        scaled (bool): if scaled, includes factor of 1 / (2 * np.pi ** 0.5)
    """
    def _top_sh(lp, kr, sp, sm):
        return ((2**kr * (2 * lp + 1) / (2 * lp + 2))**0.5 *
                (_x * sp - (1 - kr) * _y * sm))

    def _mid_sh(lp, m, sm, smm):
        return (((2 * lp + 1) * _z * sm - ((lp + m) * (lp - m))**0.5 *
                 (_x * _x + _y * _y + _z * _z) * smm) / (((lp + m + 1) *
                                                          (lp - m + 1))**0.5))

    def _bot_sh(lp, kr, sp, sm):
        return ((2**kr * (2 * lp + 1) / (2 * lp + 2))**0.5 *
                (_y * sp + (1 - kr) * _x * sm))

    sh = OrderedDict([(l, OrderedDict([])) for l in range(lmax + 1)])
    sh[0][0] = Integer(1)
    for L in range(1, lmax + 1):
        lp = L - 1
        kr = int(not lp)
        mls = list(range(-L, L + 1))
        sh[L][mls[0]] = _bot_sh(lp, kr, sh[lp][lp], sh[lp][-lp])
        for ml in mls[1:-1]:
            try:
                rec = sh[lp - 1][ml]
            except KeyError:
                rec = sh[lp][ml]
            sh[L][ml] = _mid_sh(lp, ml, sh[lp][ml], rec)
        sh[L][mls[-1]] = _top_sh(lp, kr, sh[lp][lp], sh[lp][-lp])
    if scaled:
        for L in range(lmax + 1):
            for ml in range(-L, L + 1):
                sh[L][ml] /= (2 * np.pi**0.5)
    return sh
Пример #30
0
    def test_complex_expression(self):
        expression = 3**f(42) + 23 - f(
            43, 44) + f(45 + a) * sin(g(f(46, 47, 48) + 17) - g(4)) + sin(
                f(42))

        self.assertEqual(
            collect_arguments(expression, f),
            {(Integer(42), ), (Integer(43), Integer(44)), (45 + a, ),
             (Integer(46), Integer(47), Integer(48))})

        self.assertEqual(count_calls(expression, f), 5)
        self.assertTrue(has_function(expression, f))
        self.assertEqual(
            replace_function(expression, f, g), 3**g(42) + 23 - g(43, 44) +
            g(45 + a) * sin(g(g(46, 47, 48) + 17) - g(4)) + sin(g(42)))
Пример #31
0
def legendre(n, x):
    e = Integer(1)/(Integer(2)**n * fact(Integer(n))) * diff((x**2-1)**n, x, n)
    return e.expand()
Пример #32
0
def test_conv5():
    x = Integer(5)
    y = Integer(6)
    assert x._sympy_() == sympy.Integer(5)
    assert (x/y)._sympy_() == sympy.Integer(5) / sympy.Integer(6)