bezierv 0.1.0__py3-none-any.whl

bezierv/classes/distfit.py

@@ -0,0 +1,216 @@
+import numpy as np
+import copy
+from bezierv.classes.bezierv import Bezierv
+from typing import List
+from statsmodels.distributions.empirical_distribution import ECDF
+from bezierv.algorithms import proj_grad as pg
+from bezierv.algorithms import non_linear as nl
+from bezierv.algorithms import nelder_mead as nm
+from bezierv.algorithms import proj_subgrad as ps
+from bezierv.algorithms import utils as utils
+
+
+class DistFit:
+    """
+    A class to fit a Bezier random variable to empirical data.
+
+    Attributes
+    ----------
+    data : List
+        The empirical data to fit the Bezier random variable to.
+    n : int
+        The number of control points minus one for the Bezier curve.
+    init_x : np.array
+        Initial control points for the x-coordinates of the Bezier curve.
+    init_z : np.array
+        Initial control points for the z-coordinates of the Bezier curve.
+    init_t : np.array
+        Initial parameter values.
+    emp_cdf_data : np.array
+        The empirical cumulative distribution function (CDF) data derived from the empirical data.
+    bezierv : Bezierv
+        An instance of the Bezierv class representing the Bezier random variable.
+    m : int
+        The number of empirical data points.
+    mse : float
+        The mean squared error of the fit, initialized to infinity.
+    """
+    def __init__(self, 
+                 data: List, 
+                 n: int=5, 
+                 init_x: np.array=None, 
+                 init_z: np.array=None,
+                 init_t: np.array=None,
+                 emp_cdf_data: np.array=None, 
+                 method_init_x: str='quantile'
+                 ):
+        """
+        Initialize the DistFit class with empirical data and parameters for fitting a Bezier random variable.
+
+        Parameters
+        ----------
+        data : List
+            The empirical data to fit the Bezier random variable to.
+        n : int, optional
+            The number of control points minus one for the Bezier curve (default is 5).
+        init_x : np.array, optional
+            Initial control points for the x-coordinates of the Bezier curve (default is None).
+        init_z : np.array, optional
+            Initial control points for the z-coordinates of the Bezier curve (default is None).
+        emp_cdf_data : np.array, optional
+            The empirical cumulative distribution function (CDF) data derived from the empirical data (default is None).
+        method_init_x : str, optional
+            Method to initialize the x-coordinates of the control points (default is 'quantile').
+        """
+        self.data = np.sort(data)
+        self.n = n
+        self.bezierv = Bezierv(n)
+        self.m = len(data)
+        self.mse = np.inf
+
+        if init_x is None:
+            self.init_x = self.get_controls_x(method_init_x)
+        else:
+            init_x = np.asarray(init_x, dtype=float)
+            self.init_x = init_x
+
+        if init_t is None:
+            self.init_t = utils.get_t(self.n, self.m, self.data, self.bezierv, self.init_x)
+        else:
+            self.init_t = init_t
+
+        if init_z is None:
+            self.init_z = self.get_controls_z()
+        else:
+            init_z = np.asarray(init_z, dtype=float)
+            self.init_z = init_z
+
+        if emp_cdf_data is None:
+            emp_cdf = ECDF(self.data)
+            self.emp_cdf_data = emp_cdf(self.data)
+        else:
+            self.emp_cdf_data = emp_cdf_data
+
+    def fit(self,
+            method: str='projgrad',
+            step_size_PG: float=0.001,
+            max_iter_PG: float=1000,
+            threshold_PG: float=1e-3,
+            step_size_PS: float=0.001,
+            max_iter_PS: int=1000,
+            solver_NL: str='ipopt',
+            max_iter_NM: int=1000) -> Bezierv:
+        """
+        Fit the bezierv distribution to the data.
+
+        Parameters
+        ----------
+        method : str, optional
+            The fitting method to use. Options are 'projgrad', 'nonlinear', 'projsubgrad', or 'neldermead'.
+            Default is 'projgrad'.
+        step_size_PG : float, optional
+            The step size for the projected gradient descent method (default is 0.001).
+        max_iter_PG : int, optional
+            The maximum number of iterations for the projected gradient descent method (default is 1000).
+        threshold_PG : float, optional
+            The convergence threshold for the projected gradient descent method (default is 1e-3).
+        solver_NL : str, optional
+            The solver to use for the nonlinear fitting method (default is 'ipopt').
+        
+        Returns
+        -------
+        Bezierv
+            The fitted Bezierv instance with updated control points.
+        """
+        if method == 'projgrad':
+            self.bezierv, self.mse = pg.fit(self.n, 
+                                            self.m, 
+                                            self.data, 
+                                            self.bezierv, 
+                                            self.init_x, 
+                                            self.init_z, 
+                                            self.init_t,
+                                            self.emp_cdf_data, 
+                                            step_size_PG, 
+                                            max_iter_PG, 
+                                            threshold_PG)
+        elif method == 'nonlinear':
+            self.bezierv, self.mse = nl.fit(self.n,
+                                                self.m,
+                                                self.data,
+                                                self.bezierv,
+                                                self.init_x,
+                                                self.init_z,
+                                                self.init_t,
+                                                self.emp_cdf_data,
+                                                solver_NL)
+
+        elif method == 'neldermead':
+            self.bezierv, self.mse = nm.fit(self.n,
+                                            self.m,
+                                            self.data,
+                                            self.bezierv,
+                                            self.init_x,
+                                            self.init_z,
+                                            self.emp_cdf_data,
+                                            max_iter_NM)
+        elif method == 'projsubgrad':
+            self.bezierv, self.mse = ps.fit(self.n,
+                                            self.m,
+                                            self.data,
+                                            self.bezierv,
+                                            self.init_x,
+                                            self.init_z,
+                                            self.init_t,
+                                            self.emp_cdf_data,
+                                            step_size_PS,
+                                            max_iter_PS)
+        else:
+            raise ValueError("Method not recognized. Use 'projgrad', 'nonlinear', or 'neldermead'.")
+
+        return copy.copy(self.bezierv), copy.copy(self.mse)
+    
+    def get_controls_z(self) -> np.array:
+        """
+        Compute the control points for the z-coordinates of the Bezier curve.
+
+        'quantile' method is used to determine the control points based on the data quantiles.
+
+        Parameters
+        ----------
+        data : np.array
+            The sorted data points.
+
+        Returns
+        -------
+        np.array
+            The control points for the z-coordinates of the Bezier curve.
+        """
+        controls_z = np.linspace(0, 1, self.n + 1)
+        return controls_z
+
+    def get_controls_x(self, method: str) -> np.array:
+        """
+        Compute the control points for the x-coordinates of the Bezier curve.
+
+        'quantile' method is used to determine the control points based on the data quantiles.
+
+        Parameters
+        ----------
+        data : np.array
+            The sorted data points.
+
+        Returns
+        -------
+        np.array
+            The control points for the x-coordinates of the Bezier curve.
+        """
+        if method == 'quantile':
+            controls_x = np.zeros(self.n + 1)
+            for i in range(self.n + 1):
+                controls_x[i] = np.quantile(self.data, i/self.n)
+        elif method == 'uniform':
+            controls_x = np.linspace(np.min(self.data), np.max(self.data), self.n + 1)
+        else:
+            raise ValueError("Method not recognized. Use 'quantile' or 'uniform'.")
+        return controls_x

bezierv/tests/test_algorithms/test_nelder_mead.py

@@ -0,0 +1,54 @@
+import numpy as np
+from bezierv.algorithms import nelder_mead as nm
+from bezierv.classes.bezierv import Bezierv
+
+
+def test_objective_function_zero_for_perfect_fit():
+    n = 1
+    m = 3
+    data = np.array([0.0, 0.5, 1.0])
+    x = np.array([0.0, 1.0])
+    z = np.array([0.0, 1.0])
+    emp_cdf = data.copy()
+    bez = Bezierv(n)
+
+    concat = np.concatenate((x, z))
+    val = nm.objective_function(concat, n, m, data, bez, emp_cdf)
+    assert val < 1e-12, "Perfect fit should give ~0 MSE"
+
+def test_objective_function_lagrangian_adds_penalty():
+    n = 1
+    m = 3
+    data = np.array([0.0, 0.5, 1.0])
+    x_bad = np.array([1.0, -0.5])
+    z_bad = np.array([0.2, 0.2])
+    emp_cdf = data.copy()
+    bez = Bezierv(n)
+    good = np.concatenate((np.array([0.0, 1.0]), np.array([0.0, 1.0])))
+    bad  = np.concatenate((x_bad, z_bad))
+    mse_good = nm.objective_function_lagrangian(good, n, m, data, bez, emp_cdf)
+    mse_bad  = nm.objective_function_lagrangian(bad,  n, m, data, bez, emp_cdf)
+    assert mse_bad > mse_good + 1.0, "Violating constraints should increase objective markedly"
+
+def test_fit_returns_low_mse_and_updates_bezier():
+    n = 1
+    m = 3
+    data = np.array([0.0, 0.5, 1.0])
+    init_x = np.array([-0.05, 1.05])
+    init_z = np.array([0, 1])
+    emp_cdf = data.copy()
+    bez = Bezierv(n)
+
+    fitted_bez, mse = nm.fit(
+        n=n,
+        m=m,
+        data=data,
+        bezierv=bez,
+        init_x=init_x,
+        init_z=init_z,
+        emp_cdf_data=emp_cdf
+        )
+
+    assert mse < 1e-5, "Expected near-perfect fit with dummy minimise"
+    np.testing.assert_allclose(fitted_bez.controls_x, np.array([0.0, 1.0]), atol=1e-2)
+    np.testing.assert_allclose(fitted_bez.controls_z, np.array([0.0, 1.0]), atol=1e-2)

bezierv/tests/test_algorithms/test_proj_grad.py

@@ -0,0 +1,63 @@
+import numpy as np
+from bezierv.algorithms import proj_grad as pg
+from bezierv.algorithms import utils as utils
+from bezierv.classes.bezierv import Bezierv
+
+
+def test_grad_zero_error_returns_zero_gradient():
+    """When the Bézier curve matches the empirical CDF exactly, the gradient is 0."""
+    n = 1                      # linear curve: z(t) = t
+    t = np.array([0.0, 0.5, 1.0])
+    m = t.size
+    emp_cdf = t.copy()         # perfect fit
+    controls_z = np.array([0.0, 1.0])
+    bez = Bezierv(n)
+
+    g = pg.grad(n, m, t, bez, controls_z, emp_cdf)
+    np.testing.assert_allclose(g, np.zeros_like(g), atol=1e-12)
+
+def test_project_z_clips_sorts_and_enforces_bounds():
+    """
+    Test the project_z function to ensure it clips, sorts, and enforces bounds correctly.
+    """
+    raw = np.array([-0.2, 0.9, 0.7, 1.2])
+    projected = pg.project_z(raw.copy())
+    expected = np.array([0.0, 0.7, 0.9, 1.0])
+    np.testing.assert_allclose(projected, expected)
+    np.testing.assert_allclose(pg.project_z(projected.copy()), expected)
+
+def test_fit_converges_and_returns_low_mse():
+    """
+    On a toy linear CDF the projected-gradient solver should converge
+    to z = [0,1] and yield (almost) zero MSE.
+    """
+    n = 1
+    t = np.array([0.0, 0.5, 1.0])
+    m = t.size
+    data = t.copy()
+    emp_cdf = t.copy()
+    init_x = np.array([0.0, 1.0])
+    init_z = np.array([0.2, 0.8])
+    bez = Bezierv(n)
+
+    bezierv , mse = pg.fit(
+        n=n,
+        m=m,
+        data=data,
+        bezierv=bez,
+        init_x=init_x,
+        init_z=init_z,
+        t=t,
+        emp_cdf_data=emp_cdf,
+        step_size=0.2,
+        max_iter=1_000,
+        threshold=1e-6,
+    )
+
+    assert isinstance(bezierv, Bezierv), "Expected Bezierv instance as output"
+    np.testing.assert_allclose(bezierv.controls_z, np.array([0., 1.])), "Expected z control points to be [0, 1]"
+    np.testing.assert_allclose(bezierv.controls_x, np.array([0., 1.])), "Expected x control points to be [0, 1]"
+    assert mse < 1e-6, "Solver failed to reach a near-perfect fit"
+    
+
+

bezierv/tests/test_algorithms/test_proj_subgrad.py

@@ -0,0 +1,65 @@
+import numpy as np
+from bezierv.algorithms import proj_subgrad as ps
+from bezierv.algorithms import utils as utils
+from bezierv.classes.bezierv import Bezierv
+
+def test_subgrad_zero_when_perfect_fit():
+    n = 1
+    t = np.array([0.0, 0.5, 1.0])
+    m = t.size
+    emp_cdf = t.copy()
+    controls_z = np.array([0.0, 1.0])
+    bez = Bezierv(n)
+    g_x, g_z = ps.subgrad(n, m, bez, t, controls_z, emp_cdf)
+    np.testing.assert_allclose(g_x, 0.0)
+    np.testing.assert_allclose(g_z, 0.0)
+
+
+def test_project_x_respects_bounds_and_order():
+    data = np.array([2.0, 5.0, 10.0])
+    raw_x = np.array([12.0, 3.0, -7.0])
+    projected = ps.project_x(data, raw_x.copy())
+    expected = np.array([2.0, 3.0, 10.0])
+    np.testing.assert_allclose(projected, expected)
+    np.testing.assert_allclose(ps.project_x(data, projected.copy()), expected)
+
+
+def test_project_z_behaviour():
+    z_raw = np.array([1.3, -0.1, 0.6])
+    res = ps.project_z(z_raw.copy())
+    np.testing.assert_allclose(res, np.array([0.0, 0.6, 1.0]))
+    np.testing.assert_allclose(ps.project_z(res.copy()), res)
+
+
+def test_fit_converges_to_linear_solution():
+    """
+    The full projected-subgradient solver should find the perfect fit on a
+    toy linear CDF — i.e. MSE near 0 and final z ≈ [0,1].
+    """
+    n = 1
+    t_init = np.array([0.0, 0.5, 1.0])
+    m = t_init.size
+    data = t_init.copy()
+    emp_cdf = t_init.copy()
+    init_x = np.array([2.0, 8.0])
+    init_z = np.array([0.4, 0.7])
+    bez = Bezierv(n)
+
+    _, mse = ps.fit(
+        n=n,
+        m=m,
+        data=data,
+        bezierv=bez,
+        init_x=init_x,
+        init_z=init_z,
+        init_t=t_init,
+        emp_cdf_data=emp_cdf,
+        step_size_x=0.5,
+        step_size_z=0.5,
+        max_iter=200,
+    )
+
+    assert mse < 1e-6, "Expected near-perfect fit"
+    # check the Bézier object got updated to the best values
+    np.testing.assert_allclose(bez.controls_z, np.array([0.0, 1.0]), atol=1e-3)
+    np.testing.assert_allclose(bez.controls_x, data[[0, -1]], atol=1e-3)

bezierv/tests/test_algorithms/test_utils.py

@@ -0,0 +1,42 @@
+import numpy as np
+import pytest
+from bezierv.classes.bezierv import Bezierv
+from bezierv.algorithms import utils as utils
+
+def test_root_find_linear_case():
+    """
+    For the linear Bézier curve x(t) = t, root_find should return t = data_point.
+    """
+    n = 1
+    bez = Bezierv(n)
+    controls_x = np.array([0.0, 1.0])
+    for dp in [0.0, 0.25, 0.9, 1.0]:
+        t = utils.root_find(n, bez, controls_x, dp)
+        assert abs(t - dp) < 1e-12, f"Expected {dp}, got {t}"
+
+
+def test_get_t_returns_vector_of_roots():
+    """
+    get_t should call root_find for each data point and return the same values
+    when the mapping is linear.
+    """
+    n = 1
+    m = 5
+    data = np.linspace(0, 1, m)
+    controls_x = np.array([0.0, 1.0])
+    bez = Bezierv(n)
+
+    t_vals = utils.get_t(n, m, data, bez, controls_x)
+    np.testing.assert_allclose(t_vals, data, atol=1e-12)
+
+
+def test_root_find_errors_outside_interval():
+    """
+    Raises ValueError when the data point is outside [0,1].
+    root_find should propagate that error.
+    """
+    n = 1
+    bez = Bezierv(n)
+    controls_x = np.array([0.0, 1.0])
+    with pytest.raises(ValueError):
+        _ = utils.root_find(n, bez, controls_x, 1.5)

bezierv/tests/test_classes/conftest.py

@@ -0,0 +1,42 @@
+import pytest
+import numpy as np
+from bezierv.classes.bezierv import Bezierv
+
+@pytest.fixture
+def normal_data(scope='package') -> np.array:
+    """
+    Fixture to create a sample data instance for testing.
+    
+    Returns
+    -------
+    np.array
+        A numpy array of sample data points.
+    """
+    np.random.seed(111)
+    return np.random.normal(loc=0, scale=1, size=100)
+
+@pytest.fixture
+def linear_bezierv() -> Bezierv:
+    """
+    Fixture to create a linear Bezier instance for testing.
+    
+    Returns
+    -------
+    Bezierv
+        An instance of the Bezierv class with linear controls.
+    """
+    return Bezierv(n=1, controls_x=np.array([0.0, 1.0]), controls_z=np.array([0.0, 1.0]))
+
+@pytest.fixture
+def two_uniform_bezierv() -> tuple:
+    """
+    Fixture to create two uniform Bezier random variables for testing convolution.
+    
+    Returns
+    -------
+    tuple
+    """
+    return (
+        Bezierv(n=1, controls_x=np.array([0.0, 1.0]), controls_z=np.array([0.0, 1.0])),
+        Bezierv(n=1, controls_x=np.array([0.0, 1.0]), controls_z=np.array([0.0, 1.0]))
+    )

bezierv/tests/test_classes/test_convolver.py

@@ -0,0 +1,36 @@
+import numpy as np
+import pytest
+from bezierv.classes.convolver import Convolver
+from bezierv.classes.bezierv import Bezierv
+
+def triangular_cdf(z):
+    """
+    CDF of Z = X+Y with X,Y ~ U(0,1):
+      F_Z(z) = 0                 (z ≤ 0)
+               z² / 2            (0 < z < 1)
+               1 - (2 - z)² / 2  (1 ≤ z < 2)
+               1                 (z ≥ 2)
+    """
+    if z <= 0:
+        return 0.0
+    if z < 1:
+        return 0.5 * z * z
+    if z < 2:
+        return 1 - 0.5 * (2 - z) ** 2
+    return 1.0
+
+def test_cdf_z_matches_triangle(two_uniform_bezierv):
+    bx, by = two_uniform_bezierv
+    conv = Convolver(bx, by, grid=50)
+
+    for z in [0.0, 0.2, 0.8, 1.0, 1.4, 2.0]:
+        val = conv.cdf_z(z)
+        expected = triangular_cdf(z)
+        assert val == pytest.approx(expected, abs=5e-3)
+
+def test_conv_calls_distfit_and_returns(two_uniform_bezierv):
+    bx, by = two_uniform_bezierv
+    conv = Convolver(bx, by, grid=20)
+    bez_out, mse = conv.conv(method="projgrad")
+    assert isinstance(bez_out, Bezierv)
+    assert bez_out.check_ordering() is True

bezierv/tests/test_classes/test_distfit.py

@@ -0,0 +1,34 @@
+import numpy as np
+import pytest
+from bezierv.classes.distfit import DistFit
+
+def test_quantile_initial_x(normal_data):
+    d = DistFit(normal_data, n=4)
+    expected = np.quantile(normal_data, np.linspace(0, 1, 5))
+    np.testing.assert_allclose(d.init_x, expected)
+
+def test_uniform_initial_x(normal_data):
+    d = DistFit(normal_data, n=3, method_init_x="uniform")
+    expected = np.linspace(np.min(normal_data), np.max(normal_data), 4)
+    np.testing.assert_allclose(d.init_x, expected)
+
+@pytest.mark.parametrize(
+    "method, target_mse",
+    [
+        ("projgrad", 1e-2),
+        ("nonlinear", 1e-2),
+        ("neldermead", 1e-2),
+        ("projsubgrad", 1e-2),
+    ],
+)
+
+def test_fit_dispatch_and_mse(normal_data, method, target_mse):
+    df = DistFit(normal_data, n=3)
+    bez, mse = df.fit(method=method, max_iter_PS = 100, max_iter_PG=100)
+    assert mse <= target_mse
+    assert bez.check_ordering() is True
+    
+def test_bad_method_raises(normal_data):
+    df = DistFit(normal_data)
+    with pytest.raises(ValueError):
+        df.fit(method="does-not-exist")

bezierv-0.1.0.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: bezierv
+Version: 0.1.0
+Author-email: Esteban Leiva <e.leivam@uniandes.edu.co>, "Andrés L. Medaglia" <amedagli@uniandes.edu.co>
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.14,>=3.10
+License-File: LICENSE
+Requires-Dist: numpy<2,>=1.26; python_version == "3.10"
+Requires-Dist: scipy<1.16,>=1.13; python_version == "3.10"
+Requires-Dist: matplotlib<3.11,>=3.9; python_version == "3.10"
+Requires-Dist: statsmodels<0.15,>=0.14.2; python_version == "3.10"
+Requires-Dist: pyomo<7,>=6.8; python_version == "3.10"
+Requires-Dist: numpy<2.3,>=1.26; python_version == "3.11"
+Requires-Dist: scipy<1.17,>=1.13; python_version == "3.11"
+Requires-Dist: matplotlib<3.11,>=3.9; python_version == "3.11"
+Requires-Dist: statsmodels<0.15,>=0.14.2; python_version == "3.11"
+Requires-Dist: pyomo<7,>=6.8; python_version == "3.11"
+Requires-Dist: numpy<2.3,>=2.1; python_version == "3.12"
+Requires-Dist: scipy<1.17,>=1.14.1; python_version == "3.12"
+Requires-Dist: matplotlib<3.11,>=3.9; python_version == "3.12"
+Requires-Dist: statsmodels<0.15,>=0.14.2; python_version == "3.12"
+Requires-Dist: pyomo<7,>=6.8; python_version == "3.12"
+Requires-Dist: numpy<2.4,>=2.2; python_version == "3.13"
+Requires-Dist: scipy<1.17,>=1.14.1; python_version == "3.13"
+Requires-Dist: matplotlib<3.11,>=3.9; python_version == "3.13"
+Requires-Dist: statsmodels<0.15,>=0.14.2; python_version == "3.13"
+Requires-Dist: pyomo<7,>=6.8; python_version == "3.13"
+Dynamic: license-file

bezierv-0.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+bezierv/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bezierv/algorithms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bezierv/algorithms/conv_bezierv.py,sha256=t74CKomBli98WpVyFWp3oueu7mBuJ4jVYXNj55jmg_Q,4795
+bezierv/algorithms/nelder_mead.py,sha256=uqH3jJS-CG6wblOKP83Rt8-XFJrXZSVJLHaixRKCflw,5478
+bezierv/algorithms/non_linear.py,sha256=dgwGGe__JJGXQXidmAYjSkDBqSjdr-1HilnUUuPEs8c,7523
+bezierv/algorithms/non_linear_solver.py,sha256=03QaD0XJLfRdnhYay_WaspxbRZtDcURjqcl2p-DnOVI,8480
+bezierv/algorithms/proj_grad.py,sha256=BhBAKtvW0_FZrNwinN9VCq27taYshM8zZymu5zX46w0,4622
+bezierv/algorithms/proj_subgrad.py,sha256=gtk4FXpKziykHHfyfhaRhBhRbdDQErpTDPYqrjo15e0,6962
+bezierv/algorithms/utils.py,sha256=QQecNlGdxMWhDcHPfGEJ_V1nuOIdJdR-2UziKh6N6tw,2396
+bezierv/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bezierv/classes/bezierv.py,sha256=UT-iPn-gKfKi9qMG8lrPi3VRmnV2sjSKQCGazoaUSAc,19696
+bezierv/classes/convolver.py,sha256=h-NewJ__VlL881UQSAUFSamscMEgPBwUxvpb6bHpFD0,2850
+bezierv/classes/distfit.py,sha256=EBN_knZ7vinkNjZQf6KSyGfMl0nx0rVqTJR7xUumIDY,8863
+bezierv/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bezierv/tests/conf_test.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bezierv/tests/test_algorithms/test_conv_bezierv.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bezierv/tests/test_algorithms/test_nelder_mead.py,sha256=METAE2eWnfm4bBdGMKtrFEoP_8FpFU4O3uFuiqEsBG0,1788
+bezierv/tests/test_algorithms/test_proj_grad.py,sha256=eRdwQFn5rfGH1Tu5812hW_7BrPWGO88L6HipexGPW9s,2109
+bezierv/tests/test_algorithms/test_proj_subgrad.py,sha256=On4-E1A4fS7szXxfokv4BZKY5GIVgbl2YVAtVztwS1A,2077
+bezierv/tests/test_algorithms/test_utils.py,sha256=JBb9uukGfBsrFOgSngX6FUkPdW2KrY7hJ3DkY_TQz7I,1236
+bezierv/tests/test_classes/conftest.py,sha256=X94OWG8puTTjueuxjBBQR-fU4f8nN-4QT5NlDFZgTgs,1124
+bezierv/tests/test_classes/test_bezierv.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bezierv/tests/test_classes/test_convolver.py,sha256=3Z6G0em_owso1gNcGWadHkiHxx65ktFJV_u9Gvop_W8,1118
+bezierv/tests/test_classes/test_distfit.py,sha256=B-xgIocMzWAfuTxhMTvD2S1QvE-MHXSw8JkoVcziQHA,1103
+bezierv-0.1.0.dist-info/licenses/LICENSE,sha256=VfWiefIi6eo_kZleNp0Plg8A2eUX4D8fDbKtfj4VCp4,1115
+bezierv-0.1.0.dist-info/METADATA,sha256=VGF8QhZgQrWtyMz1P_pId6ZZm37P7SgaS17Po2NO8ow,1730
+bezierv-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bezierv-0.1.0.dist-info/top_level.txt,sha256=AC8zK0YmUeXyPIHtt0EKuHkLrvFBFeHwzp6bjzYnqJI,8
+bezierv-0.1.0.dist-info/RECORD,,

bezierv-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bezierv-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Esteban Leiva and Andrés L. Medaglia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bezierv-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bezierv