def test_ExpressionParameterFunctional_for_2d_array():
    dict_of_d_mus_2d = {'mu': [['10', '20'], ['1', '2']], 'nu': 'cos(nu)'}

    epf2d = ExpressionParameterFunctional(
        '10 * mu[(0,0)] + 20 * mu[(0,1)] \
                                          + 1 * mu[(1,0)] + 2 *  mu[(1,1)] \
                                          + sin(nu)', {
            'mu': (2, 2),
            'nu': ()
        }, 'functional_with_derivative', dict_of_d_mus_2d)

    derivative_to_11_mu_index = epf2d.d_mu('mu', (0, 0))
    derivative_to_12_mu_index = epf2d.d_mu('mu', (0, 1))
    derivative_to_21_mu_index = epf2d.d_mu('mu', (1, 0))
    derivative_to_22_mu_index = epf2d.d_mu('mu', (1, 1))
    derivative_to_nu_index = epf2d.d_mu('nu')

    mu = {'mu': (1, 2, 3, 4), 'nu': 0}

    der_mu_11 = derivative_to_11_mu_index.evaluate(mu)
    der_mu_12 = derivative_to_12_mu_index.evaluate(mu)
    der_mu_21 = derivative_to_21_mu_index.evaluate(mu)
    der_mu_22 = derivative_to_22_mu_index.evaluate(mu)
    der_nu = derivative_to_nu_index.evaluate(mu)

    assert epf2d.evaluate(mu) == 1 * 10 + 2 * 20 + 3 * 1 + 4 * 2 + 0
    assert der_mu_11 == 10
    assert der_mu_12 == 20
    assert der_mu_21 == 1
    assert der_mu_22 == 2
    assert der_nu == 1
Beispiel #2
0
def test_ExpressionParameterFunctional():
    dict_of_d_mus = {'mu': ['200 * mu[0]', '2 * mu[0]'], 'nu': ['cos(nu[0])']}

    dict_of_second_derivative = {
        'mu': [{'mu': ['200', '2'], 'nu': ['0']}, {'mu': ['2', '0'], 'nu': ['0']}],
        'nu': [{'mu': ['0', '0'], 'nu': ['-sin(nu[0])']}]
    }

    epf = ExpressionParameterFunctional('100 * mu[0]**2 + 2 * mu[1] * mu[0] + sin(nu[0])',
                                        {'mu': 2, 'nu': 1},
                                        'functional_with_derivative_and_second_derivative',
                                        dict_of_d_mus, dict_of_second_derivative)

    mu = Mu({'mu': [10, 2], 'nu': [0]})

    derivative_to_first_mu_index = epf.d_mu('mu', 0)
    derivative_to_second_mu_index = epf.d_mu('mu', 1)
    derivative_to_nu_index = epf.d_mu('nu', 0)

    der_mu_1 = derivative_to_first_mu_index.evaluate(mu)
    der_mu_2 = derivative_to_second_mu_index.evaluate(mu)
    der_nu = derivative_to_nu_index.evaluate(mu)

    second_derivative_first_mu_first_mu = epf.d_mu('mu', 0).d_mu('mu', 0)
    second_derivative_first_mu_second_mu = epf.d_mu('mu', 0).d_mu('mu', 1)
    second_derivative_first_mu_nu = epf.d_mu('mu', 0).d_mu('nu')
    second_derivative_second_mu_first_mu = epf.d_mu('mu', 1).d_mu('mu', 0)
    second_derivative_second_mu_second_mu = epf.d_mu('mu', 1).d_mu('mu', 1)
    second_derivative_second_mu_nu = epf.d_mu('mu', 1).d_mu('nu')
    second_derivative_nu_first_mu = epf.d_mu('nu').d_mu('mu', 0)
    second_derivative_nu_second_mu = epf.d_mu('nu').d_mu('mu', 1)
    second_derivative_nu_nu = epf.d_mu('nu').d_mu('nu')

    hes_mu_1_mu_1 = second_derivative_first_mu_first_mu.evaluate(mu)
    hes_mu_1_mu_2 = second_derivative_first_mu_second_mu.evaluate(mu)
    hes_mu_1_nu = second_derivative_first_mu_nu.evaluate(mu)
    hes_mu_2_mu_1 = second_derivative_second_mu_first_mu.evaluate(mu)
    hes_mu_2_mu_2 = second_derivative_second_mu_second_mu.evaluate(mu)
    hes_mu_2_nu = second_derivative_second_mu_nu.evaluate(mu)
    hes_nu_mu_1 = second_derivative_nu_first_mu.evaluate(mu)
    hes_nu_mu_2 = second_derivative_nu_second_mu.evaluate(mu)
    hes_nu_nu = second_derivative_nu_nu.evaluate(mu)

    assert epf.evaluate(mu) == 100*10**2 + 2*2*10 + 0
    assert der_mu_1 == 200 * 10
    assert der_mu_2 == 2 * 10
    assert der_nu == 1
    assert hes_mu_1_mu_1 == 200
    assert hes_mu_1_mu_2 == 2
    assert hes_mu_1_nu == 0
    assert hes_mu_2_mu_1 == 2
    assert hes_mu_2_mu_2 == 0
    assert hes_mu_2_nu == 0
    assert hes_nu_mu_1 == 0
    assert hes_nu_mu_2 == 0
    assert hes_nu_nu == -0
def test_ExpressionParameterFunctional():
    dict_of_d_mus = {'mu': ['100', '2'], 'nu': 'cos(nu)'}

    epf = ExpressionParameterFunctional('100 * mu[0] + 2 * mu[1] + sin(nu)', {
        'mu': (2, ),
        'nu': ()
    }, 'functional_with_derivative', dict_of_d_mus)

    mu = {'mu': (10, 2), 'nu': 0}

    derivative_to_first_mu_index = epf.d_mu('mu', 0)
    derivative_to_second_mu_index = epf.d_mu('mu', 1)
    derivative_to_nu_index = epf.d_mu('nu', ())

    der_mu_1 = derivative_to_first_mu_index.evaluate(mu)
    der_mu_2 = derivative_to_second_mu_index.evaluate(mu)
    der_nu = derivative_to_nu_index.evaluate(mu)

    assert epf.evaluate(mu) == 100 * 10 + 2 * 2 + 0
    assert der_mu_1 == 100
    assert der_mu_2 == 2
    assert der_nu == 1