Beispiel #1
0
def test_cosm1_opt():
    x = Symbol('x')

    expr1 = cos(x) - 1
    opt1 = optimize(expr1, [cosm1_opt])
    assert cosm1(x) - opt1 == 0
    assert opt1.rewrite(cos) == expr1

    expr2 = 3*cos(x) - 3
    opt2 = optimize(expr2, [cosm1_opt])
    assert 3*cosm1(x) == opt2
    assert opt2.rewrite(cos) == expr2

    expr3 = 3*cos(x) - 5
    assert expr3 == optimize(expr3, [cosm1_opt])

    expr4 = 3*cos(x) + log(x) - 3
    opt4 = optimize(expr4, [cosm1_opt])
    assert 3*cosm1(x) + log(x) == opt4
    assert opt4.rewrite(cos) == expr4

    expr5 = 3*cos(2*x) - 3
    opt5 = optimize(expr5, [cosm1_opt])
    assert 3*cosm1(2*x) == opt5
    assert opt5.rewrite(cos) == expr5
def test_cosm1():
    cm1_xy = cosm1(x * y)
    ref_xy = cos(x * y) - 1
    for wrt, deriv_order in product([x, y, z], range(0, 3)):
        assert (cm1_xy.diff(wrt, deriv_order) -
                ref_xy.diff(wrt, deriv_order)).rewrite(cos).simplify() == 0

    expr_minus2 = cosm1(pi)
    assert expr_minus2.rewrite(cos) == -2
    assert cosm1(3.14).simplify() == cosm1(3.14)  # cannot simplify with 3.14
def test_cosm1_opt():
    x = Symbol('x')

    expr1 = cos(x) - 1
    opt1 = optimize(expr1, [cosm1_opt])
    assert cosm1(x) - opt1 == 0
    assert opt1.rewrite(cos) == expr1

    expr2 = 3 * cos(x) - 3
    opt2 = optimize(expr2, [cosm1_opt])
    assert 3 * cosm1(x) == opt2
    assert opt2.rewrite(cos) == expr2

    expr3 = 3 * cos(x) - 5
    opt3 = optimize(expr3, [cosm1_opt])
    assert 3 * cosm1(x) - 2 == opt3
    assert opt3.rewrite(cos) == expr3
    cosm1_opt_non_opportunistic = FuncMinusOneOptim(cos,
                                                    cosm1,
                                                    opportunistic=False)
    assert expr3 == optimize(expr3, [cosm1_opt_non_opportunistic])
    assert opt1 == optimize(expr1, [cosm1_opt_non_opportunistic])
    assert opt2 == optimize(expr2, [cosm1_opt_non_opportunistic])

    expr4 = 3 * cos(x) + log(x) - 3
    opt4 = optimize(expr4, [cosm1_opt])
    assert 3 * cosm1(x) + log(x) == opt4
    assert opt4.rewrite(cos) == expr4

    expr5 = 3 * cos(2 * x) - 3
    opt5 = optimize(expr5, [cosm1_opt])
    assert 3 * cosm1(2 * x) == opt5
    assert opt5.rewrite(cos) == expr5

    expr6 = 2 - 2 * cos(x)
    opt6 = optimize(expr6, [cosm1_opt])
    assert -2 * cosm1(x) == opt6
    assert opt6.rewrite(cos) == expr6
Beispiel #4
0
def test_numerical_accuracy_functions():
    prntr = SciPyPrinter()
    assert prntr.doprint(expm1(x)) == 'numpy.expm1(x)'
    assert prntr.doprint(log1p(x)) == 'numpy.log1p(x)'
    assert prntr.doprint(cosm1(x)) == 'scipy.special.cosm1(x)'
Beispiel #5
0
def test_scipy_special_math():
    if not scipy:
        skip("scipy not installed")

    cm1 = lambdify((x, ), cosm1(x), modules='scipy')
    assert abs(cm1(1e-20) + 5e-41) < 1e-200
Beispiel #6
0
def test_expm1_cosm1_mixed():
    x = Symbol('x')
    expr1 = exp(x) + cos(x) - 2
    opt1 = optimize(expr1, [expm1_opt, cosm1_opt])  # need a combined opt pass?
    assert opt1 == cosm1(x) + expm1(x)
Beispiel #7
0
def test_cosm1_two_cos_terms():
    x, y = map(Symbol, 'x y'.split())
    expr1 = cos(x) + cos(y) - 2
    opt1 = optimize(expr1, [cosm1_opt])
    assert opt1 == cosm1(x) + cosm1(y)
def test_expm1_cosm1_mixed():
    x = Symbol('x')
    expr1 = exp(x) + cos(x) - 2
    opt1 = optimize(expr1, [expm1_opt, cosm1_opt])
    assert opt1 == cosm1(x) + expm1(x)