pvlib 0.11.2__py3-none-any.whl → 0.12.1a1__py3-none-any.whl

pvlib/tests/test_conftest.py

@@ -1,37 +0,0 @@
-import pytest
-
-from pvlib.tests import conftest
-
-
-@pytest.mark.parametrize('function_name', ['assert_index_equal',
-                                           'assert_series_equal',
-                                           'assert_frame_equal'])
-@pytest.mark.parametrize('pd_version', ['1.0.0', '1.1.0'])
-@pytest.mark.parametrize('check_less_precise', [True, False])
-def test__check_pandas_assert_kwargs(mocker, function_name, pd_version,
-                                     check_less_precise):
-    # test that conftest._check_pandas_assert_kwargs returns appropriate
-    # kwargs for the assert_x_equal functions
-
-    # NOTE: be careful about mixing mocker.patch and pytest.MonkeyPatch!
-    # they do not coordinate their cleanups, so it is safest to only
-    # use one or the other.  GH #1447
-
-    # patch the pandas assert; not interested in actually calling them,
-    # plus we want to spy on how they get called.
-    spy = mocker.patch('pandas.testing.' + function_name)
-    # patch pd.__version__ to exercise the two branches in
-    # conftest._check_pandas_assert_kwargs
-    mocker.patch('pandas.__version__', new=pd_version)
-
-    # finally, run the function and check what args got passed to pandas:
-    assert_function = getattr(conftest, function_name)
-    args = [None, None]
-    assert_function(*args, check_less_precise=check_less_precise)
-    if pd_version == '1.1.0':
-        tol = 1e-3 if check_less_precise else 1e-5
-        expected_kwargs = {'atol': tol, 'rtol': tol}
-    else:
-        expected_kwargs = {'check_less_precise': check_less_precise}
-
-    spy.assert_called_once_with(*args, **expected_kwargs)

pvlib/tests/test_iam.py

@@ -1,555 +0,0 @@
-"""
-Created on Wed Oct  2 10:14:16 2019
-
-@author: cwhanse
-"""
-
-import numpy as np
-import pandas as pd
-
-import pytest
-from .conftest import assert_series_equal
-from numpy.testing import assert_allclose
-
-from pvlib import iam as _iam
-
-
-def test_ashrae():
-    thetas = np.array([-90., -67.5, -45., -22.5, 0., 22.5, 45., 67.5, 89., 90.,
-                       np.nan])
-    expected = np.array([0, 0.9193437, 0.97928932, 0.99588039, 1., 0.99588039,
-                         0.97928932, 0.9193437, 0, 0, np.nan])
-    iam = _iam.ashrae(thetas, .05)
-    assert_allclose(iam, expected, equal_nan=True)
-    iam_series = _iam.ashrae(pd.Series(thetas))
-    assert_series_equal(iam_series, pd.Series(expected))
-
-
-def test_ashrae_scalar():
-    thetas = -45.
-    iam = _iam.ashrae(thetas, .05)
-    expected = 0.97928932
-    assert_allclose(iam, expected, equal_nan=True)
-    thetas = np.nan
-    iam = _iam.ashrae(thetas, .05)
-    expected = np.nan
-    assert_allclose(iam, expected, equal_nan=True)
-
-
-def test_physical():
-    aoi = np.array([-90., -67.5, -45., -22.5, 0., 22.5, 45., 67.5, 90.,
-                    np.nan])
-    expected = np.array([0, 0.8893998, 0.98797788, 0.99926198, 1, 0.99926198,
-                         0.98797788, 0.8893998, 0, np.nan])
-    iam = _iam.physical(aoi, 1.526, 0.002, 4)
-    assert_allclose(iam, expected, atol=1e-7, equal_nan=True)
-
-    # GitHub issue 397
-    aoi = pd.Series(aoi)
-    iam = _iam.physical(aoi, 1.526, 0.002, 4)
-    expected = pd.Series(expected)
-    assert_series_equal(iam, expected)
-
-
-def test_physical_n1_L0():
-    aoi = np.array([0, 22.5, 45, 67.5, 90, 100, np.nan])
-    expected = np.array([1, 1, 1, 1, 0, 0, np.nan])
-    iam = _iam.physical(aoi, n=1, L=0)
-    assert_allclose(iam, expected, equal_nan=True)
-
-    aoi = pd.Series(aoi)
-    expected = pd.Series(expected)
-    iam = _iam.physical(aoi, n=1, L=0)
-    assert_series_equal(iam, expected)
-
-
-def test_physical_ar():
-    aoi = np.array([0, 22.5, 45, 67.5, 90, 100, np.nan])
-    expected = np.array([1, 0.99944171, 0.9917463, 0.91506158, 0, 0, np.nan])
-    iam = _iam.physical(aoi, n_ar=1.29)
-    assert_allclose(iam, expected, atol=1e-7, equal_nan=True)
-
-
-def test_physical_noar():
-    aoi = np.array([0, 22.5, 45, 67.5, 90, 100, np.nan])
-    expected = _iam.physical(aoi)
-    iam0 = _iam.physical(aoi, n_ar=1)
-    iam1 = _iam.physical(aoi, n_ar=1.526)
-    assert_allclose(iam0, expected, equal_nan=True)
-    assert_allclose(iam1, expected, equal_nan=True)
-
-
-def test_physical_scalar():
-    aoi = -45.
-    iam = _iam.physical(aoi, 1.526, 0.002, 4)
-    expected = 0.98797788
-    assert_allclose(iam, expected, equal_nan=True)
-    aoi = np.nan
-    iam = _iam.physical(aoi, 1.526, 0.002, 4)
-    expected = np.nan
-    assert_allclose(iam, expected, equal_nan=True)
-
-
-def test_martin_ruiz():
-
-    aoi = 45.
-    a_r = 0.16
-    expected = 0.98986965
-
-    # will fail if default values change
-    iam = _iam.martin_ruiz(aoi)
-    assert_allclose(iam, expected)
-
-    # will fail if parameter names change
-    iam = _iam.martin_ruiz(aoi=aoi, a_r=a_r)
-    assert_allclose(iam, expected)
-
-    a_r = 0.18
-    aoi = [-100, -60, 0, 60, 100, np.nan, np.inf]
-    expected = [0.0, 0.9414631, 1.0, 0.9414631, 0.0, np.nan, 0.0]
-
-    # check out of range of inputs as list
-    iam = _iam.martin_ruiz(aoi, a_r)
-    assert_allclose(iam, expected, equal_nan=True)
-
-    # check out of range of inputs as array
-    iam = _iam.martin_ruiz(np.array(aoi), a_r)
-    assert_allclose(iam, expected, equal_nan=True)
-
-    # check out of range of inputs as Series
-    aoi = pd.Series(aoi)
-    expected = pd.Series(expected)
-    iam = _iam.martin_ruiz(aoi, a_r)
-    assert_series_equal(iam, expected)
-
-
-def test_martin_ruiz_exception():
-
-    with pytest.raises(ValueError):
-        _iam.martin_ruiz(0.0, a_r=0.0)
-
-
-def test_martin_ruiz_diffuse():
-
-    surface_tilt = 30.
-    a_r = 0.16
-    expected = (0.9549735, 0.7944426)
-
-    # will fail if default values change
-    iam = _iam.martin_ruiz_diffuse(surface_tilt)
-    assert_allclose(iam, expected)
-
-    # will fail if parameter names change
-    iam = _iam.martin_ruiz_diffuse(surface_tilt=surface_tilt, a_r=a_r)
-    assert_allclose(iam, expected)
-
-    a_r = 0.18
-    surface_tilt = [0, 30, 90, 120, 180, np.nan, np.inf]
-    expected_sky = [0.9407678, 0.9452250, 0.9407678, 0.9055541, 0.0000000,
-                    np.nan, np.nan]
-    expected_gnd = [0.0000000, 0.7610849, 0.9407678, 0.9483508, 0.9407678,
-                    np.nan, np.nan]
-
-    # check various inputs as list
-    iam = _iam.martin_ruiz_diffuse(surface_tilt, a_r)
-    assert_allclose(iam[0], expected_sky, atol=1e-7, equal_nan=True)
-    assert_allclose(iam[1], expected_gnd, atol=1e-7, equal_nan=True)
-
-    # check various inputs as array
-    iam = _iam.martin_ruiz_diffuse(np.array(surface_tilt), a_r)
-    assert_allclose(iam[0], expected_sky, atol=1e-7, equal_nan=True)
-    assert_allclose(iam[1], expected_gnd, atol=1e-7, equal_nan=True)
-
-    # check various inputs as Series
-    surface_tilt = pd.Series(surface_tilt)
-    expected_sky = pd.Series(expected_sky, name='iam_sky')
-    expected_gnd = pd.Series(expected_gnd, name='iam_ground')
-    iam = _iam.martin_ruiz_diffuse(surface_tilt, a_r)
-    assert_series_equal(iam[0], expected_sky)
-    assert_series_equal(iam[1], expected_gnd)
-
-
-def test_iam_interp():
-
-    aoi_meas = [0.0, 45.0, 65.0, 75.0]
-    iam_meas = [1.0,  0.9,  0.8,  0.6]
-
-    # simple default linear method
-    aoi = 55.0
-    expected = 0.85
-    iam = _iam.interp(aoi, aoi_meas, iam_meas)
-    assert_allclose(iam, expected)
-
-    # simple non-default method
-    aoi = 55.0
-    expected = 0.8878062
-    iam = _iam.interp(aoi, aoi_meas, iam_meas, method='cubic')
-    assert_allclose(iam, expected)
-
-    # check with all reference values
-    aoi = aoi_meas
-    expected = iam_meas
-    iam = _iam.interp(aoi, aoi_meas, iam_meas)
-    assert_allclose(iam, expected)
-
-    # check normalization and Series
-    aoi = pd.Series(aoi)
-    expected = pd.Series(expected)
-    iam_mult = np.multiply(0.9, iam_meas)
-    iam = _iam.interp(aoi, aoi_meas, iam_mult, normalize=True)
-    assert_series_equal(iam, expected)
-
-    # check beyond reference values
-    aoi = [-45, 0, 45, 85, 90, 95, 100, 105, 110]
-    expected = [0.9, 1.0, 0.9, 0.4, 0.3, 0.2, 0.1, 0.0, 0.0]
-    iam = _iam.interp(aoi, aoi_meas, iam_meas)
-    assert_allclose(iam, expected)
-
-    # check exception clause
-    with pytest.raises(ValueError):
-        _iam.interp(0.0, [0], [1])
-
-    # check exception clause
-    with pytest.raises(ValueError):
-        _iam.interp(0.0, [0, 90], [1, -1])
-
-
-@pytest.mark.parametrize('aoi,expected', [
-    (45, 0.9975036250000002),
-    (np.array([[-30, 30, 100, np.nan]]),
-     np.array([[0, 1.007572, 0, np.nan]])),
-    (pd.Series([80]), pd.Series([0.597472]))
-])
-def test_sapm(sapm_module_params, aoi, expected):
-
-    out = _iam.sapm(aoi, sapm_module_params)
-
-    if isinstance(aoi, pd.Series):
-        assert_series_equal(out, expected, check_less_precise=4)
-    else:
-        assert_allclose(out, expected, atol=1e-4)
-
-
-def test_sapm_limits():
-    module_parameters = {'B0': 5, 'B1': 0, 'B2': 0, 'B3': 0, 'B4': 0, 'B5': 0}
-    assert _iam.sapm(1, module_parameters) == 5
-
-    module_parameters = {'B0': 5, 'B1': 0, 'B2': 0, 'B3': 0, 'B4': 0, 'B5': 0}
-    assert _iam.sapm(1, module_parameters, upper=1) == 1
-
-    module_parameters = {'B0': -5, 'B1': 0, 'B2': 0, 'B3': 0, 'B4': 0, 'B5': 0}
-    assert _iam.sapm(1, module_parameters) == 0
-
-
-def test_marion_diffuse_model(mocker):
-    # 1: return values are correct
-    # 2: the underlying models are called appropriately
-    ashrae_expected = {
-        'sky': 0.9596085829811408,
-        'horizon': 0.8329070417832541,
-        'ground': 0.719823559106309
-    }
-    physical_expected = {
-        'sky': 0.9539178294437575,
-        'horizon': 0.7652650139134007,
-        'ground': 0.6387140117795903
-    }
-    ashrae_spy = mocker.spy(_iam, 'ashrae')
-    physical_spy = mocker.spy(_iam, 'physical')
-
-    ashrae_actual = _iam.marion_diffuse('ashrae', 20)
-    assert ashrae_spy.call_count == 3  # one call for each of the 3 regions
-    assert physical_spy.call_count == 0
-    physical_actual = _iam.marion_diffuse('physical', 20)
-    assert ashrae_spy.call_count == 3
-    assert physical_spy.call_count == 3
-
-    for k, v in ashrae_expected.items():
-        assert_allclose(ashrae_actual[k], v)
-
-    for k, v in physical_expected.items():
-        assert_allclose(physical_actual[k], v)
-
-
-def test_marion_diffuse_kwargs():
-    # kwargs get passed to underlying model
-    expected = {
-        'sky': 0.967489994422575,
-        'horizon': 0.8647842827418412,
-        'ground': 0.7700443455928433
-    }
-    actual = _iam.marion_diffuse('ashrae', 20, b=0.04)
-
-    for k, v in expected.items():
-        assert_allclose(actual[k], v)
-
-
-def test_marion_diffuse_invalid():
-    with pytest.raises(ValueError):
-        _iam.marion_diffuse('not_a_model', 20)
-
-
-@pytest.mark.parametrize('region,N,expected', [
-    ('sky', 180, 0.9596085829811408),
-    ('horizon', 1800, 0.8329070417832541),
-    ('ground', 180, 0.719823559106309)
-])
-def test_marion_integrate_scalar(region, N, expected):
-    actual = _iam.marion_integrate(_iam.ashrae, 20, region, N)
-    assert_allclose(actual, expected)
-
-    with np.errstate(invalid='ignore'):
-        actual = _iam.marion_integrate(_iam.ashrae, np.nan, region, N)
-    expected = np.nan
-    assert_allclose(actual, expected)
-
-
-@pytest.mark.parametrize('region,N,expected', [
-    ('sky', 180, [0.9523611991069362, 0.9596085829811408, 0.9619811198105501]),
-    ('horizon', 1800, [0.0, 0.8329070417832541, 0.8987287652347437]),
-    ('ground', 180, [0.0, 0.719823559106309, 0.8186360238536674])
-])
-def test_marion_integrate_list(region, N, expected):
-    actual = _iam.marion_integrate(_iam.ashrae, [0, 20, 30], region, N)
-    assert_allclose(actual, expected)
-
-    with np.errstate(invalid='ignore'):
-        actual = _iam.marion_integrate(_iam.ashrae, [0, 20, np.nan], region, N)
-    assert_allclose(actual, [expected[0], expected[1], np.nan])
-
-
-@pytest.mark.parametrize('region,N,expected', [
-    ('sky', 180, [0.9523611991069362, 0.9596085829811408, 0.9619811198105501]),
-    ('horizon', 1800, [0.0, 0.8329070417832541, 0.8987287652347437]),
-    ('ground', 180, [0.0, 0.719823559106309, 0.8186360238536674])
-])
-def test_marion_integrate_series(region, N, expected):
-    idx = pd.date_range('2019-01-01', periods=3, freq='h')
-    tilt = pd.Series([0, 20, 30], index=idx)
-    expected = pd.Series(expected, index=idx)
-    actual = _iam.marion_integrate(_iam.ashrae, tilt, region, N)
-    assert_series_equal(actual, expected)
-
-    tilt.iloc[1] = np.nan
-    expected.iloc[1] = np.nan
-    with np.errstate(invalid='ignore'):
-        actual = _iam.marion_integrate(_iam.ashrae, tilt, region, N)
-    assert_allclose(actual, expected)
-
-
-def test_marion_integrate_ground_flat():
-    iam = _iam.marion_integrate(_iam.ashrae, 0, 'horizon', 1800)
-    assert_allclose(iam, 0)
-
-
-def test_marion_integrate_invalid():
-    # check for invalid region string.  this actually gets checked twice,
-    # with the difference being whether `num` is specified or not.
-    with pytest.raises(ValueError):
-        _iam.marion_integrate(_iam.ashrae, 0, 'bad')
-
-    with pytest.raises(ValueError):
-        _iam.marion_integrate(_iam.ashrae, 0, 'bad', 180)
-
-
-def test_schlick():
-    idx = pd.date_range('2019-01-01', freq='h', periods=9)
-    aoi = pd.Series([-180, -135, -90, -45, 0, 45, 90, 135, 180], idx)
-    expected = pd.Series([0, 0, 0, 0.99784451, 1.0, 0.99784451, 0, 0, 0], idx)
-
-    # scalars
-    for aoi_scalar, expected_scalar in zip(aoi, expected):
-        actual = _iam.schlick(aoi_scalar)
-        assert_allclose(expected_scalar, actual)
-
-    # numpy arrays
-    actual = _iam.schlick(aoi.values)
-    assert_allclose(expected.values, actual)
-
-    # pandas Series
-    actual = _iam.schlick(aoi)
-    assert_series_equal(expected, actual)
-
-
-def test_schlick_diffuse():
-    surface_tilt = np.array([0, 20, 70, 90])
-    # expected values calculated with marion_integrate and schlick
-    expected_sky = np.array([0.95238092, 0.96249934, 0.96228167, 0.95238094])
-    expected_ground = np.array([0, 0.62693858, 0.93218737, 0.95238094])
-
-    # numpy arrays
-    actual_sky, actual_ground = _iam.schlick_diffuse(surface_tilt)
-    assert_allclose(expected_sky, actual_sky)
-    assert_allclose(expected_ground, actual_ground, rtol=1e-6)
-
-    # scalars
-    for i in range(len(surface_tilt)):
-        actual_sky, actual_ground = _iam.schlick_diffuse(surface_tilt[i])
-        assert_allclose(expected_sky[i], actual_sky)
-        assert_allclose(expected_ground[i], actual_ground, rtol=1e-6)
-
-    # pandas Series
-    idx = pd.date_range('2019-01-01', freq='h', periods=len(surface_tilt))
-    actual_sky, actual_ground = _iam.schlick_diffuse(pd.Series(surface_tilt,
-                                                               idx))
-    assert_series_equal(pd.Series(expected_sky, idx), actual_sky)
-    assert_series_equal(pd.Series(expected_ground, idx), actual_ground,
-                        rtol=1e-6)
-
-
-@pytest.mark.parametrize('source,source_params,target,expected', [
-    ('physical', {'n': 1.5, 'K': 4.5, 'L': 0.004}, 'martin_ruiz',
-     {'a_r': 0.174037}),
-    ('physical', {'n': 1.5, 'K': 4.5, 'L': 0.004}, 'ashrae',
-     {'b': 0.042896}),
-    ('ashrae', {'b': 0.15}, 'physical',
-     {'n': 0.991457, 'K': 4, 'L': 0.037813}),
-    ('ashrae', {'b': 0.15}, 'martin_ruiz', {'a_r': 0.302390}),
-    ('martin_ruiz', {'a_r': 0.15}, 'physical',
-     {'n': 1.240190, 'K': 4, 'L': 0.002791055}),
-    ('martin_ruiz', {'a_r': 0.15}, 'ashrae', {'b': 0.025458})])
-def test_convert(source, source_params, target, expected):
-    target_params = _iam.convert(source, source_params, target)
-    exp = [expected[k] for k in expected]
-    tar = [target_params[k] for k in expected]
-    assert_allclose(exp, tar, rtol=1e-05)
-
-
-@pytest.mark.parametrize('source,source_params', [
-    ('ashrae', {'b': 0.15}),
-    ('ashrae', {'b': 0.05}),
-    ('martin_ruiz', {'a_r': 0.15})])
-def test_convert_recover(source, source_params):
-    # convert isn't set up to handle both source and target = 'physical'
-    target_params = _iam.convert(source, source_params, source, xtol=1e-7)
-    exp = [source_params[k] for k in source_params]
-    tar = [target_params[k] for k in source_params]
-    assert_allclose(exp, tar, rtol=1e-05)
-
-
-def test_convert_ashrae_physical_no_fix_n():
-    # convert ashrae to physical, without fixing n
-    source_params = {'b': 0.15}
-    target_params = _iam.convert('ashrae', source_params, 'physical',
-                                 fix_n=False)
-    expected = {'n': 0.989019, 'K': 4, 'L': 0.037382}
-    exp = [expected[k] for k in expected]
-    tar = [target_params[k] for k in expected]
-    assert_allclose(exp, tar, rtol=1e-05)
-
-
-def test_convert_reverse_order_in_physical():
-    source_params = {'a_r': 0.25}
-    target_params = _iam.convert('martin_ruiz', source_params, 'physical')
-    expected = {'n': 1.691398, 'K': 4, 'L': 0.071633}
-    exp = [expected[k] for k in expected]
-    tar = [target_params[k] for k in expected]
-    assert_allclose(exp, tar, rtol=1e-05)
-
-
-def test_convert_xtol():
-    source_params = {'b': 0.15}
-    target_params = _iam.convert('ashrae', source_params, 'physical',
-                                 xtol=1e-8)
-    expected = {'n': 0.9914568914, 'K': 4, 'L': 0.0378126985}
-    exp = [expected[k] for k in expected]
-    tar = [target_params[k] for k in expected]
-    assert_allclose(exp, tar, rtol=1e-6)
-
-
-def test_convert_custom_weight_func():
-    aoi = np.linspace(0, 90, 91)
-
-    # convert physical to martin_ruiz, using custom weight function
-    source_params = {'n': 1.5, 'K': 4.5, 'L': 0.004}
-    source_iam = _iam.physical(aoi, **source_params)
-
-    # define custom weight function that takes in other arguments
-    def scaled_weight(aoi):
-        return 2. * aoi
-
-    # expected value calculated from computing residual function over
-    # a range of inputs, and taking minimum of these values
-    expected_min_res = 16.39724
-
-    actual_dict = _iam.convert('physical', source_params, 'martin_ruiz',
-                               weight=scaled_weight)
-    actual_min_res = _iam._residual(aoi, source_iam, _iam.martin_ruiz,
-                                    [actual_dict['a_r']], scaled_weight)
-
-    assert np.isclose(expected_min_res, actual_min_res, atol=1e-06)
-
-
-def test_convert_model_not_implemented():
-    with pytest.raises(NotImplementedError, match='model has not been'):
-        _iam.convert('ashrae', {'b': 0.1}, 'foo')
-
-
-def test_convert_wrong_model_parameters():
-    with pytest.raises(ValueError, match='model was expecting'):
-        _iam.convert('ashrae', {'B': 0.1}, 'physical')
-
-
-def test_convert__minimize_fails():
-    # to make scipy.optimize.minimize fail, we'll pass in a nonsense
-    # weight function that only outputs nans
-    def nan_weight(aoi):
-        return np.nan
-
-    with pytest.raises(RuntimeError, match='Optimizer exited unsuccessfully'):
-        _iam.convert('ashrae', {'b': 0.1}, 'physical', weight=nan_weight)
-
-
-def test_fit():
-    aoi = np.linspace(0, 90, 5)
-    perturb = np.array([1.2, 1.01, 0.95, 1, 0.98])
-    perturbed_iam = _iam.martin_ruiz(aoi, a_r=0.14) * perturb
-
-    expected_a_r = 0.14
-
-    actual_dict = _iam.fit(aoi, perturbed_iam, 'martin_ruiz')
-    actual_a_r = actual_dict['a_r']
-
-    assert np.isclose(expected_a_r, actual_a_r, atol=1e-04)
-
-
-def test_fit_custom_weight_func():
-    # define custom weight function that takes in other arguments
-    def scaled_weight(aoi):
-        return 2. * aoi
-
-    aoi = np.linspace(0, 90, 5)
-    perturb = np.array([1.2, 1.01, 0.95, 1, 0.98])
-    perturbed_iam = _iam.martin_ruiz(aoi, a_r=0.14) * perturb
-
-    expected_a_r = 0.14
-
-    actual_dict = _iam.fit(aoi, perturbed_iam, 'martin_ruiz',
-                           weight=scaled_weight)
-    actual_a_r = actual_dict['a_r']
-
-    assert np.isclose(expected_a_r, actual_a_r, atol=1e-04)
-
-
-def test_fit_model_not_implemented():
-    with pytest.raises(NotImplementedError, match='model has not been'):
-        _iam.fit(np.array([0, 10]), np.array([1, 0.99]), 'foo')
-
-
-def test_fit__minimize_fails():
-    # to make scipy.optimize.minimize fail, we'll pass in a nonsense
-    # weight function that only outputs nans
-    def nan_weight(aoi):
-        return np.nan
-
-    with pytest.raises(RuntimeError, match='Optimizer exited unsuccessfully'):
-        _iam.fit(np.array([0, 10]), np.array([1, 0.99]), 'physical',
-                 weight=nan_weight)
-
-
-def test__residual_zero_outside_range():
-    # check that _residual annihilates any weights that come from aoi
-    # outside of interval [0, 90] (this is important for `iam.fit`, when
-    # the `measured_aoi` contains angles outside this range
-    residual = _iam._residual(101, _iam.ashrae(101), _iam.martin_ruiz, [0.16])
-    assert residual == 0.0