131 lines
5.4 KiB
Python
131 lines
5.4 KiB
Python
import numpy as np
|
|
import pytest
|
|
import sys
|
|
import os
|
|
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
|
|
from slic.utils.npy import *
|
|
|
|
@pytest.mark.parametrize("start, stop, step, expected", [
|
|
(0, 5, 1, np.linspace(0, 5, 6)), # regular integer step
|
|
(5, 0, -1, np.linspace(5, 0, 6)), # reversed with negative step
|
|
(1, 2, 0.3, np.linspace(1, 2, 4)), # step doesn't divide evenly
|
|
(-2, 2, 1.5, np.linspace(-2, 2, 3)), # centered range
|
|
(2.5, 0.5, -0.4, np.linspace(2.5, 0.5, 6)), # reversed float
|
|
])
|
|
def test_nice_arange(start, stop, step, expected):
|
|
np.testing.assert_allclose(nice_arange(start, stop, step), expected, rtol=1e-6)
|
|
|
|
|
|
@pytest.mark.parametrize("start, stop, num, expected", [
|
|
(0, 10, 4, np.array([0., 2.5, 5., 7.5, 10.])), # basic
|
|
(5, 15, 2, np.array([5., 10., 15.])), # evenly spaced 3 points
|
|
(-5, 5, 4, np.array([-5., -2.5, 0., 2.5, 5.])), # negative to positive
|
|
(0, 1, 3, np.array([0., 1/3, 2/3, 1.])), # fractions (non-integers)
|
|
(2, 2, 3, np.array([2., 2., 2., 2.])), # constant start = stop
|
|
(3, 0, 3, np.array([3., 2., 1., 0.])), # decreasing
|
|
(0, 1, 0, np.array([0.])), # edge case: 0 intervals → 1 point
|
|
])
|
|
def test_nice_linspace(start, stop, num, expected):
|
|
np.testing.assert_allclose(nice_linspace(start, stop, num), expected)
|
|
|
|
|
|
|
|
@pytest.mark.parametrize("start, stop, step, endpoint, expected", [
|
|
(-2, 2, 2, True, np.array([-2., 0., 2.])), # symmetric around 0
|
|
(0, 5, 2, True, np.array([0., 2., 4.])), # basic
|
|
(0, 5, 2, False, np.array([0., 2.])), # no endpoint
|
|
(-1, 2, 1.5, True, np.array([-1.5, 0., 1.5])) # step doesn't fit exactly
|
|
])
|
|
def test_nice_steps_centered(start, stop, step, endpoint, expected):
|
|
np.testing.assert_allclose(nice_steps_centered(start, stop, step, endpoint), expected)
|
|
|
|
|
|
@pytest.mark.parametrize("start, stop, step, endpoint, expected", [
|
|
(0, 5, 2, True, np.array([0., 2., 4., 6.])), # Normal case with endpoint overshooting
|
|
(0, 5, 2, False, np.array([0., 2., 4.])), # No endpoint
|
|
(-1, 2, 1.5, True, np.array([-1., 0.5, 2.])), # Needs fractional alignment to include stop
|
|
(-1, 2, 1.5, False, np.array([-1., 0.5])), # Same range but no endpoint
|
|
(-2, 1, 1.2, True, np.array([-2., -0.8, 0.4, 1.6])), # Step overshoots
|
|
(5, 0, -2, True, np.array([5., 3., 1., -1.])), # Backward steps with overshoot
|
|
(5, 0, -2, False, np.array([5., 3., 1.])), # No endpoint, backward
|
|
])
|
|
def test_nice_steps_left_aligned(start, stop, step, endpoint, expected):
|
|
np.testing.assert_allclose(nice_steps_left_aligned(start, stop, step, endpoint), expected)
|
|
|
|
|
|
|
|
@pytest.mark.parametrize("start, stop, step, endpoint, expected", [
|
|
(0, 5, 2, True, np.array([6., 4., 2., 0.])), # Right-aligned, overshoots left
|
|
(0, 5, 2, False, np.array([4., 2., 0.])), # Right-aligned, no endpoint
|
|
(-1, 2, 1.5, True, np.array([2., 0.5, -1.])), # Step doesn t divide evenly, reverse it
|
|
(-1, 2, 1.5, False, np.array([0.5, -1.])), # Without endpoint
|
|
(5, 0, -2, True, np.array([5., 3., 1., -1.])), # Negative step, includes endpoint overshoot
|
|
(5, 0, -2, False, np.array([3., 1., -1.])), # No endpoint, skips last one
|
|
(-3, 3, 2, True, np.array([5., 3., 1., -1., -3.])), # Large symmetric range, reverse
|
|
])
|
|
def test_nice_steps_right_aligned(start, stop, step, endpoint, expected):
|
|
np.testing.assert_allclose(nice_steps_right_aligned(start, stop, step, endpoint), expected)
|
|
|
|
|
|
|
|
@pytest.mark.parametrize("val, vmin, vmax, expected", [
|
|
(5, 0, 10, True),
|
|
(5, 6, 10, False),
|
|
(5, None, 10, True),
|
|
(5, 0, None, True),
|
|
(5, None, None, True),
|
|
])
|
|
def test_within_scalar(val, vmin, vmax, expected):
|
|
assert within(val, vmin, vmax) == expected
|
|
|
|
|
|
@pytest.mark.parametrize("data, vmin, vmax, expected", [
|
|
([1, 2, 3, 4, 5], 2, 5, 0.6),
|
|
([10, 20, 30], 5, 25, 2/3),
|
|
([1, 2, 3], None, 2, 1/3),
|
|
([], 0, 1, 0),
|
|
])
|
|
def test_within_fraction(data, vmin, vmax, expected):
|
|
result = within_fraction(data, vmin, vmax)
|
|
assert np.isclose(result, expected)
|
|
|
|
|
|
@pytest.mark.parametrize("fraction, ndigits, expected", [
|
|
(0.456, 1, 45.6),
|
|
(0.12345, 2, 12.35),
|
|
(0.9999, 0, 100.0),
|
|
])
|
|
def test_fraction_to_percentage(fraction, ndigits, expected):
|
|
assert fraction_to_percentage(fraction, ndigits) == expected
|
|
|
|
|
|
@pytest.mark.parametrize("val, expected", [
|
|
(np.array([1, 2, 3]), np.ndarray),
|
|
([1, 2, 3], list),
|
|
(3.14, float),
|
|
])
|
|
def test_get_dtype(val, expected):
|
|
dtype = get_dtype(val)
|
|
if isinstance(dtype, type):
|
|
assert dtype == expected
|
|
else:
|
|
assert isinstance(dtype, np.dtype)
|
|
|
|
|
|
@pytest.mark.parametrize("val, expected", [
|
|
(np.array([[1, 2], [3, 4]]), (2, 2)),
|
|
([1, 2, 3], ()),
|
|
(42, ()),
|
|
])
|
|
def test_get_shape(val, expected):
|
|
assert get_shape(val) == expected
|
|
|
|
|
|
@pytest.mark.parametrize("val, expected", [
|
|
(np.array([1, 2, 3]), True),
|
|
([1, 2, 3], False),
|
|
(42, False),
|
|
])
|
|
def test_is_array(val, expected):
|
|
assert is_array(val) == expected
|