Esempio n. 1
0
def test_log():
    sol = vt.Solver(2)
    x1 = sol.create_variable(10)
    x2 = sol.create_variable(5)
    f = np.log(x1) + np.log(x2)
    assert f.x == 3.9120230054281464, "error with log"
    assert (abs(f.dx - np.array([0.1, 0.2])) < 1e-6).all(), "error with log"
Esempio n. 2
0
def test_exp():
    sol = vt.Solver(2)
    x1 = sol.create_variable(0)
    x2 = sol.create_variable(5)
    f = np.exp(x1) + x2
    assert f.x == 6.0, "error with exp"
    assert (abs(f.dx - np.array([1., 1.])) < 1e-6).all(), "error with exp"
Esempio n. 3
0
def test_cosh():
    sol = vt.Solver(2)
    x1 = sol.create_variable(2)
    f = x1.cosh()
    assert (f.x - 3.7621957) < 1e-6, "error with cosh"
    assert (abs(f.dx - np.array([3.6268604, 0])) <
            1e-6).sum() == 2, "error with cosh"
Esempio n. 4
0
def test_logarithm():
    sol = vt.Solver(2)
    x1 = sol.create_variable(3)
    f = x1.logarithm(2)
    assert (f.x - 1.5849625) < 1e-6, "error with logarithm"
    assert (abs(f.dx - np.array([0.4808983, 0])) <
            1e-6).sum() == 2, "error with logarithm"
Esempio n. 5
0
def test_tanh():
    sol = vt.Solver(2)
    x1 = sol.create_variable(2)
    f = x1.tanh()
    assert (f.x - 0.9640276) < 1e-6, "error with tanh"
    assert (abs(f.dx - np.array([0.0706508, 0])) <
            1e-6).sum() == 2, "error with tanh"
Esempio n. 6
0
def test_sqrt():
    sol = vt.Solver(2)
    x1 = sol.create_variable(5)
    f = x1.sqrt()
    assert (f.x - 2.2360680) < 1e-6, "error with sqrt"
    assert (abs(f.dx - np.array([0.223606798, 0])) <
            1e-6).sum() == 2, "error with sqrt"
Esempio n. 7
0
def test_logistic():
    sol = vt.Solver(2)
    x1 = sol.create_variable(2)
    f = x1.logistic()
    assert (f.x - 0.8807971) < 1e-6, "error with logistic"
    assert (abs(f.dx - np.array([0.1049936, 0])) <
            1e-6).sum() == 2, "error with logistic"
Esempio n. 8
0
def test_exponential():
    sol = vt.Solver(2)
    x1 = sol.create_variable(5)
    f = x1.exponential(2)
    assert f.x == 32, "error with exponential"
    assert (abs(f.dx - np.array([22.1807098, 0])) <
            1e-6).sum() == 2, "error with exponential"
Esempio n. 9
0
def test_rsub():
    sol = vt.Solver(3)
    x1 = sol.create_variable(4)
    x2 = sol.create_variable(5)
    x3 = sol.create_variable(6)
    f = 11 - x1 - x3
    assert f.x == 1, "error with rsub"
    assert (f.dx == np.array([-1, 0, -1])).all(), "error with rsub"
Esempio n. 10
0
def test_sub():
    sol = vt.Solver(3)
    x1 = sol.create_variable(4)
    x2 = sol.create_variable(5)
    x3 = sol.create_variable(6)
    f = x1 - x2 - 3
    assert f.x == -4, "error with sub"
    assert (f.dx == np.array([1, -1, 0])).all(), "error with sub"
Esempio n. 11
0
def test_pow():
    sol = vt.Solver(2)
    x1 = sol.create_variable(4)
    x2 = sol.create_variable(5)
    f = (x1 + x2)**2
    assert f.x == 81, "error with pow"
    assert (abs(f.dx - np.array([18., 18.])) < 1e-6).all(), "error with pow"

    sol = vt.Solver(3)
    x12 = sol.create_variable(4)
    x22 = sol.create_variable(5)
    x32 = sol.create_variable(2)
    f = (x12 + x22)**x32
    assert f.x == 81, "error with pow"
    print(f.dx)
    assert (abs(f.dx - np.array([18., 18., 177.975190764])) <
            1e-6).all(), "error with pow"
Esempio n. 12
0
def test_cos():
    sol = vt.Solver(2)
    x1 = sol.create_variable(math.pi / 2)
    x2 = sol.create_variable(math.pi / 6)
    f = np.cos(x1) + np.cos(x2)
    assert f.x == 0.8660254037844388, "error with cos"
    assert ((f.dx - np.array([-1., -0.5])) < 10
            **(-8)).sum() == 2, "error with cos"
Esempio n. 13
0
def test_f_return_nothing():
    sol = vt.Solver(5)

    def f(a, b, c, d, e):
        return []

    with pytest.raises(TypeError):
        dx = sol.get_diff(f, [1, 2, 3, 4, 5])
Esempio n. 14
0
def test_radd():
    sol = vt.Solver(3)
    x1 = sol.create_variable(4)
    x2 = sol.create_variable(5)
    x3 = sol.create_variable(6)
    f = 4 + x2 + x3
    assert f.x == 15, "error with radd"
    assert (f.dx == np.array([0, 1, 1])).all(), "error with radd"
Esempio n. 15
0
def test_arctan():
    sol = vt.Solver(2)
    x1 = sol.create_variable(0.5)
    x2 = sol.create_variable(0.1)
    f = np.arctan(x1) + np.arctan(x2)
    assert abs(f.x - 0.5633162614919682) < 1e-8, "error with arctan"
    assert ((f.dx - np.array([0.8, 0.99009901])) < 10
            **(-8)).sum() == 2, "error with arctan"
Esempio n. 16
0
def test_arccos():
    sol = vt.Solver(2)
    x1 = sol.create_variable(0.5)
    x2 = sol.create_variable(0.1)
    f = np.arccos(x1) + np.arccos(x2)
    assert abs(f.x - 2.5178264568299342) < 1e-8, "error with arccos"
    assert ((f.dx - np.array([-1.15470054, -1.00503782])) < 10
            **(-8)).sum() == 2, "error with arccos"
Esempio n. 17
0
def test_arcsin():
    sol = vt.Solver(2)
    x1 = sol.create_variable(0.5)
    x2 = sol.create_variable(0.1)
    f = np.arcsin(x1) + np.arcsin(x2)
    assert abs(f.x - 0.6237661967598587) < 1e-8, "error with arcsin"
    assert ((f.dx - np.array([1.15470054, 1.00503782])) < 10
            **(-8)).sum() == 2, "error with arcsin"
Esempio n. 18
0
def test_tan():
    sol = vt.Solver(2)
    x1 = sol.create_variable(math.pi / 2)
    x2 = sol.create_variable(math.pi / 6)
    f = np.tan(x1) + np.tan(x2)
    assert f.x == 1.633123935319537e+16, "error with tan"
    assert ((f.dx - np.array([2.66709379e+32, 1.33333333e+00])) < 10
            **(-8)).sum() == 2, "error with tan"
Esempio n. 19
0
def test_rmul():
    sol = vt.Solver(3)
    x1 = sol.create_variable(4)
    x2 = sol.create_variable(5)
    x3 = sol.create_variable(6)
    f = 2 * x1 * x2 * x3
    assert f.x == 240, "error with rmul"
    assert (f.dx == np.array([60., 48., 40.])).all(), "error with rmul"
Esempio n. 20
0
def test_supplied_argument_length_not_match():
    sol = vt.Solver(5)

    def f(a, b, c, d, e):
        return [a * b * c * d * e]

    with pytest.raises(IndexError):
        dx = sol.get_diff(f, [1, 2, 3])
Esempio n. 21
0
def test_sin():
    sol = vt.Solver(2)
    x1 = sol.create_variable(math.pi / 2)
    x2 = sol.create_variable(math.pi / 6)
    f = np.sin(x1) + np.sin(x2)
    assert f.x == 1.5, "error with sin"
    assert ((f.dx - np.array([6.12323400e-17, 8.66025404e-01])) < 10
            **(-8)).sum() == 2, "error with sin"
Esempio n. 22
0
def test_f_argument_length_not_match():
    sol = vt.Solver(5)

    def f(x):
        return [x * x]

    with pytest.raises(TypeError):
        dx = sol.get_diff(f, [1, 2, 3, 4, 5])
Esempio n. 23
0
def test_evaluate_and_get_diff_vector_to_vector():
    sol = vt.Solver(2)

    def f(x, y):
        return [y * x.exponential(2), x * y.logistic()]

    x, dx = sol.evaluate_and_get_diff(f, [5, 2])
    assert (abs(x[0] - 64) < 1e-5)
    assert (abs(x[1] - 5 * 0.8807971) < 1e-5)
    assert ((dx - np.array([[2 * 22.18070977791825, 32],
                            [0.8807971, 5 * 0.10499358540350652]])) <
            1e-5).all()
Esempio n. 24
0
def test_get_diff_continuous_usage():
    sol = vt.Solver(2)

    def f(x, y):
        return [x * y]

    def g(x, y):
        return [x**3, 4 * x]

    dx = sol.get_diff(f, [1, 2])
    assert (dx == np.array([2, 1])).all()
    dx = sol.get_diff(g, [2, 1])
    assert (dx == np.array([[12, 0], [4, 0]])).all()
Esempio n. 25
0
def test_rtruediv():
    sol = vt.Solver(3)
    x1 = sol.create_variable(4)
    x2 = sol.create_variable(5)
    x3 = sol.create_variable(6)
    f = 1 / x1
    f2 = 1 / (2 * x1)
    f3 = 7 / (x1 * x1)
    assert f.x == 0.25, "error with rtruediv"
    assert (abs(f.dx - np.array([-0.0625, -0., -0.])) <
            1e-6).all(), "error with rtruediv"
    assert f2.x == 0.125, "error with rtruediv"
    assert (abs(f2.dx - np.array([-0.03125, -0., -0.])) <
            1e-6).all(), "error with rtruediv"
    assert f3.x == 0.4375, "error with rtruediv"
    assert (abs(f3.dx - np.array([-0.21875, -0., -0.])) <
            1e-6).all(), "error with rtruediv"
Esempio n. 26
0
def test_get_diff_scalar_to_vector():
    sol = vt.Solver(1)

    def f(x):
        return [x * x * x, 4 * x]

    dx = sol.get_diff(f, [2])
    assert (dx == np.array([[12], [4]])).all()

    sol = vt.Solver(1)

    def f(x):
        return [x * x * x, 4 * x]

    dx = sol.get_diff(f, [2])
    assert (dx == np.array([[12], [4]])).all()

    sol = vt.Solver(1)

    def f(x):
        return [x * x, x * x + 3 * x]

    dx = sol.get_diff(f, [1])
    assert (dx == np.array([[2], [5]])).all()

    sol = vt.Solver(1)

    def f(x):
        return [np.log(x) + x * x, np.exp(x) / np.sqrt(x)]

    dx = sol.get_diff(f, [1])
    assert (dx == np.array([[3], [np.exp(1) / 2]])).all()

    sol = vt.Solver(1)

    def f(x):
        return [np.sin(x) * np.cos(x) * np.tan(x), np.exp(np.sin(np.exp(x)))]

    dx = sol.get_diff(f, [1])
    assert (dx - np.array(
        [[np.sin(2)], [np.cos(np.exp(1)) * np.exp(np.sin(np.exp(1)) + 1)]]) <
            1e-8).all()

    sol = vt.Solver(1)

    def f(x):
        return [2 * x**(3 / 2), (x**2 * np.sin(x)) / (x**2 + 1)]

    dx = sol.get_diff(f, [1])
    assert (dx == np.array([[3], [(2 * np.sin(1) + 2 * np.cos(1)) / (2**2)]
                            ])).all()
Esempio n. 27
0
def test_truediv():
    sol = vt.Solver(3)
    x1 = sol.create_variable(4)
    x2 = sol.create_variable(5)
    x3 = sol.create_variable(6)
    f = x2 / x1
    f2 = x2 / 2
    f3 = x2 / (2 * x1)
    f4 = x2 / (x1 * x1)
    assert f.x == 1.25, "error with truediv"
    assert (f.dx == np.array([-0.3125, 0.25, 0.])).all(), "error with truediv"
    assert f2.x == 2.5, "error with truediv"
    assert (f2.dx == np.array([0., 0.5, 0.])).all(), "error with truediv"
    assert f3.x == 0.625, "error with truediv"
    assert (f3.dx == np.array([-0.15625, 0.125,
                               0.])).all(), "error with truediv"
    assert f4.x == 0.3125, "error with truediv"
    assert (f4.dx == np.array([-0.15625, 0.0625,
                               0.])).all(), "error with truediv"
Esempio n. 28
0
def testb_arccos_out_of_range():
    sol = vt.Solver(2)
    x1 = sol.create_variable_b(10)
    with pytest.raises(ValueError):
        f = np.arccos(x1)
Esempio n. 29
0
def testb_str():
    sol = vt.Solver(2)
    x1 = sol.create_variable_b(1)
    print(x1)
    x1.grad_value = 1.0
    print(x1)
Esempio n. 30
0
def test_get_diff_vector_to_vector():
    sol = vt.Solver(2)

    def f(x, y):
        return [x * y, x + y]

    dx = sol.get_diff(f, [1, 2])
    assert (dx == np.array([[2, 1], [1, 1]])).all()

    sol = vt.Solver(2)

    def f(x, y):
        return [np.exp(x**2 * y), x * np.log(2 * x + y)]

    dx = sol.get_diff(f, [1, 2])
    assert (
        dx - np.array([[4 * np.exp(2), np.exp(2)], [np.log(4) + 0.5, 1 / 4]]) <
        1e-8).all()

    sol = vt.Solver(2)

    def f(x, y):
        return [x / y, np.sin(3 * x + 2 * y)]

    dx = sol.get_diff(f, [1, 2])
    assert (dx == np.array([[1 / 2, -1 / 4], [3 * np.cos(7),
                                              2 * np.cos(7)]])).all()

    sol = vt.Solver(2)

    def f(x, y):
        return [x * y, x * y + 2 * x + 2 * y]

    dx = sol.get_diff(f, [1, 2])
    assert (dx == np.array([[2, 1], [4, 3]])).all()

    sol = vt.Solver(2)

    def f(x, y):
        return [x * y + np.exp(x * y), x**3 * y - 3 * x * y**2 + 2 * y**2]

    dx = sol.get_diff(f, [1, 2])
    assert (dx - np.array([[2 + 2 * np.exp(2), 1 + np.exp(2)], [-6, -3]]) <
            1e-8).all()

    sol = vt.Solver(2)

    def f(x, y):
        return [y * x.exponential(2), x * y.logistic()]

    dx = sol.get_diff(f, [5, 2])
    assert ((dx - np.array([[2 * 22.18070977791825, 32],
                            [0.8807971, 5 * 0.10499358540350652]])) <
            1e-5).all()

    sol = vt.Solver(2)

    def f(x, y):
        return [x**y, y**x]

    dx = sol.get_diff(f, [2, 3])
    assert ((dx - np.array([[12, 5.54517744], [9.8875106, 6]])) < 1e-5).all()