Exemple #1
0
def test_check_opt(capsys):
    fhtarg = [filters.kong_61_2007(), 43]
    qwehtarg = [
        np.array(1e-12),
        np.array(1e-30),
        np.array(51),
        np.array(100),
        np.array(33)
    ]

    res = utils.check_opt(None, None, 'fht', fhtarg, 4)
    assert_allclose(res, (False, True, False))
    out, _ = capsys.readouterr()
    outstr = "   Kernel Opt.     :  None\n   Loop over       :  Freq"
    assert out[:53] == outstr

    res = utils.check_opt(None, 'off', 'hqwe', qwehtarg, 4)
    assert_allclose(res, (False, True, False))
    out, _ = capsys.readouterr()
    outstr = "   Kernel Opt.     :  None\n   Loop over       :  Freq"
    assert out[:53] == outstr

    res = utils.check_opt('parallel', 'off', 'fht', [fhtarg[0], 0], 4)
    if use_vml:
        assert_allclose(callable(res[0]), True)
        outstr = "   Kernel Opt.     :  Use parallel\n   Loop over       :  Of"
    elif not use_ne_eval:
        assert_allclose(callable(res[0]), False)
        outstr = "* WARNING :: `numexpr` is not installed, `opt=='parallel'` "
    else:
        assert_allclose(callable(res[0]), False)
        outstr = "* WARNING :: `numexpr` is not installed with VML, `opt=='pa"
    assert_allclose(res[1:], (False, True))
    out, _ = capsys.readouterr()
    assert out[:59] == outstr

    res = utils.check_opt('parallel', 'freq', 'hqwe', qwehtarg, 4)
    if use_vml:
        assert_allclose(callable(res[0]), True)
        outstr = "   Kernel Opt.     :  Use parallel\n   Loop over       :  Fr"
    elif not use_ne_eval:
        assert_allclose(callable(res[0]), False)
        outstr = "* WARNING :: `numexpr` is not installed, `opt=='parallel'` "
    else:
        assert_allclose(callable(res[0]), False)
        outstr = "* WARNING :: `numexpr` is not installed with VML, `opt=='pa"
    assert_allclose(res[1:], (True, False))
    out, _ = capsys.readouterr()
    assert out[:59] == outstr
Exemple #2
0
def test_check_hankel(capsys):
    # # DLF # #
    # verbose
    ht, htarg = utils.check_hankel('dlf', {}, 4)
    out, _ = capsys.readouterr()
    assert "   Hankel          :  DLF (Fast Hankel Transform)\n     > F" in out
    assert "     > DLF type    :  Standard" in out
    assert ht == 'dlf'
    assert htarg['dlf'].name == filters.key_201_2009().name
    assert htarg['pts_per_dec'] == 0

    # provide filter-string and unknown parameter
    _, htarg = utils.check_hankel('dlf', {'dlf': 'key_201_2009', 'abc': 0}, 1)
    out, _ = capsys.readouterr()
    assert htarg['dlf'].name == filters.key_201_2009().name
    assert htarg['pts_per_dec'] == 0
    assert "WARNING :: Unknown htarg {'abc': 0} for method 'dlf'" in out

    # provide filter-instance
    _, htarg = utils.check_hankel('dlf', {'dlf': filters.kong_61_2007()}, 0)
    assert htarg['dlf'].name == filters.kong_61_2007().name
    assert htarg['pts_per_dec'] == 0

    # provide pts_per_dec
    _, htarg = utils.check_hankel('dlf', {'pts_per_dec': -1}, 3)
    out, _ = capsys.readouterr()
    assert "     > DLF type    :  Lagged Convolution" in out
    assert htarg['dlf'].name == filters.key_201_2009().name
    assert htarg['pts_per_dec'] == -1

    # provide filter-string and pts_per_dec
    _, htarg = utils.check_hankel('dlf', {
        'dlf': 'key_201_2009',
        'pts_per_dec': 20
    }, 4)
    out, _ = capsys.readouterr()
    assert "     > DLF type    :  Splined, 20.0 pts/dec" in out
    assert htarg['dlf'].name == filters.key_201_2009().name
    assert htarg['pts_per_dec'] == 20

    # Assert it can be called repetitively
    _, _ = capsys.readouterr()
    ht, htarg = utils.check_hankel('dlf', {}, 1)
    _, _ = utils.check_hankel(ht, htarg, 1)
    out, _ = capsys.readouterr()
    assert out == ""

    # # QWE # #
    # verbose
    ht, htarg = utils.check_hankel('qwe', {}, 4)
    out, _ = capsys.readouterr()
    outstr = "   Hankel          :  Quadrature-with-Extrapolation\n     > rtol"
    assert outstr in out
    assert ht == 'qwe'
    assert htarg['rtol'] == 1e-12
    assert htarg['atol'] == 1e-30
    assert htarg['nquad'] == 51
    assert htarg['maxint'] == 100
    assert htarg['pts_per_dec'] == 0
    assert htarg['diff_quad'] == 100
    assert htarg['a'] is None
    assert htarg['b'] is None
    assert htarg['limit'] is None

    # limit
    _, htarg = utils.check_hankel('qwe', {'limit': 30}, 0)
    assert htarg['rtol'] == 1e-12
    assert htarg['atol'] == 1e-30
    assert htarg['nquad'] == 51
    assert htarg['maxint'] == 100
    assert htarg['pts_per_dec'] == 0
    assert htarg['diff_quad'] == 100
    assert htarg['a'] is None
    assert htarg['b'] is None
    assert htarg['limit'] == 30

    # all arguments
    _, htarg = utils.check_hankel(
        'qwe', {
            'rtol': 1e-3,
            'atol': 1e-4,
            'nquad': 31,
            'maxint': 20,
            'pts_per_dec': 30,
            'diff_quad': 200,
            'a': 1e-6,
            'b': 160,
            'limit': 30
        }, 3)
    out, _ = capsys.readouterr()
    assert "     > a     (quad):  1e-06" in out
    assert "     > b     (quad):  160" in out
    assert "     > limit (quad):  30" in out
    assert htarg['rtol'] == 1e-3
    assert htarg['atol'] == 1e-4
    assert htarg['nquad'] == 31
    assert htarg['maxint'] == 20
    assert htarg['pts_per_dec'] == 30
    assert htarg['diff_quad'] == 200
    assert htarg['a'] == 1e-6
    assert htarg['b'] == 160
    assert htarg['limit'] == 30

    # Assert it can be called repetitively
    _, _ = capsys.readouterr()
    ht, htarg = utils.check_hankel('qwe', {}, 1)
    _, _ = utils.check_hankel(ht, htarg, 1)
    out, _ = capsys.readouterr()
    assert out == ""

    # # QUAD # #
    # verbose
    ht, htarg = utils.check_hankel('quad', {}, 4)
    out, _ = capsys.readouterr()
    outstr = "   Hankel          :  Quadrature\n     > rtol"
    assert outstr in out
    assert ht == 'quad'
    assert htarg['rtol'] == 1e-12
    assert htarg['atol'] == 1e-20
    assert htarg['limit'] == 500
    assert htarg['a'] == 1e-6
    assert htarg['b'] == 0.1
    assert htarg['pts_per_dec'] == 40

    # pts_per_dec
    _, htarg = utils.check_hankel('quad', {'pts_per_dec': 100}, 0)
    assert htarg['rtol'] == 1e-12
    assert htarg['atol'] == 1e-20
    assert htarg['limit'] == 500
    assert htarg['a'] == 1e-6
    assert htarg['b'] == 0.1
    assert htarg['pts_per_dec'] == 100
    # all arguments
    _, htarg = utils.check_hankel(
        'quad', {
            'rtol': 1e-3,
            'atol': 1e-4,
            'limit': 100,
            'a': 1e-10,
            'b': 200,
            'pts_per_dec': 50
        }, 0)
    assert htarg['rtol'] == 1e-3
    assert htarg['atol'] == 1e-4
    assert htarg['limit'] == 100
    assert htarg['a'] == 1e-10
    assert htarg['b'] == 200
    assert htarg['pts_per_dec'] == 50

    # Assert it can be called repetitively
    _, _ = capsys.readouterr()
    ht, htarg = utils.check_hankel('quad', {}, 1)
    _, _ = utils.check_hankel(ht, htarg, 1)
    out, _ = capsys.readouterr()
    assert out == ""

    # wrong ht
    with pytest.raises(ValueError):
        utils.check_hankel('doesnotexist', {}, 1)

    # filter missing attributes
    with pytest.raises(AttributeError):
        utils.check_hankel('dlf', {'dlf': 'key_101_CosSin_2012'}, 1)
Exemple #3
0
def test_check_hankel(capsys):
    # # FHT # #
    # verbose
    ht, htarg = utils.check_hankel('fht', None, 4)
    out, _ = capsys.readouterr()
    assert "   Hankel          :  DLF (Fast Hankel Transform)\n     > F" in out
    assert "     > DLF type    :  Standard" in out
    assert ht == 'fht'
    assert htarg[0].name == filters.key_201_2009().name
    assert htarg[1] is 0

    # [filter str]
    _, htarg = utils.check_hankel('fht', 'key_201_2009', 0)
    assert htarg[0].name == filters.key_201_2009().name
    assert htarg[1] is 0
    # [filter inst]
    _, htarg = utils.check_hankel('fht', filters.kong_61_2007(), 0)
    assert htarg[0].name == filters.kong_61_2007().name
    assert htarg[1] is 0
    # ['', pts_per_dec]  :: list
    _, htarg = utils.check_hankel('fht', ['', 20], 0)
    assert htarg[0].name == filters.key_201_2009().name
    assert htarg[1] == 20
    # ['', pts_per_dec]  :: dict
    _, htarg = utils.check_hankel('fht', {'pts_per_dec': -1}, 4)
    out, _ = capsys.readouterr()
    assert "     > DLF type    :  Lagged Convolution" in out
    assert htarg[0].name == filters.key_201_2009().name
    assert htarg[1] == -1
    # [filter str, pts_per_dec]
    _, htarg = utils.check_hankel('fht', ['key_201_2009', 20], 4)
    out, _ = capsys.readouterr()
    assert "     > DLF type    :  Splined, 20 pts/dec" in out
    assert htarg[0].name == filters.key_201_2009().name
    assert htarg[1] == 20

    # # QWE # #
    # verbose
    ht, htarg = utils.check_hankel('qwe', None, 4)
    out, _ = capsys.readouterr()
    outstr = "   Hankel          :  Quadrature-with-Extrapolation\n     > rtol"
    assert outstr in out
    assert ht == 'hqwe'
    assert_allclose(htarg[:-3], [1e-12, 1e-30, 51, 100, 0, 100])
    assert htarg[-3] is None
    assert htarg[-2] is None
    assert htarg[-1] is None

    # only last argument
    _, htarg = utils.check_hankel('qwe', ['', '', '', '', '', '', '', '', 30],
                                  0)
    assert_allclose(htarg[:-3], [1e-12, 1e-30, 51, 100, 0, 100])
    assert htarg[-3] is None
    assert htarg[-2] is None
    assert htarg[-1] == 30

    # all arguments
    _, htarg = utils.check_hankel('qwe',
                                  [1e-3, 1e-4, 31, 20, 30, 200, 1e-6, 160, 30],
                                  3)
    out, _ = capsys.readouterr()
    assert "     > a     (quad):  1e-06" in out
    assert "     > b     (quad):  160" in out
    assert "     > limit (quad):  30" in out
    assert_allclose(htarg, [1e-3, 1e-4, 31, 20, 30, 200, 1e-6, 160, 30])

    # # QUAD # #
    # verbose
    ht, htarg = utils.check_hankel('quad', None, 4)
    out, _ = capsys.readouterr()
    outstr = "   Hankel          :  Quadrature\n     > rtol"
    assert outstr in out
    assert ht == 'hquad'
    assert_allclose(htarg, [1e-12, 1e-20, 500, 1e-6, 0.1, 40])

    # only last argument
    _, htarg = utils.check_hankel('quad', ['', '', '', '', '', 100], 0)
    assert_allclose(htarg, [1e-12, 1e-20, 500, 1e-6, 0.1, 100])
    # all arguments
    _, htarg = utils.check_hankel('quad', [1e-3, 1e-4, 100, 1e-10, 200, 50], 0)
    assert_allclose(htarg, [1e-3, 1e-4, 100, 1e-10, 200, 50])

    # wrong ht
    with pytest.raises(ValueError):
        utils.check_hankel('doesnotexist', None, 1)