bezierv 1.0.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

bezierv/classes/distfit.py

@@ -94,7 +94,7 @@ class DistFit:
     def fit(self,
             method: str='projgrad',
             step_size_PG: float=0.001,
-            max_iter_PG: float=1000,
+            max_iter_PG: int=1000,
             threshold_PG: float=1e-3,
             step_size_PS: float=0.001,
             max_iter_PS: int=1000,
@@ -114,8 +114,14 @@ class DistFit:
             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).
+        step_size_PS : float, optional
+            The step size for the projected subgradient method (default is 0.001).
+        max_iter_PS : int, optional
+            The maximum number of iterations for the projected subgradient method (default is 1000).
         solver_NL : str, optional
             The solver to use for the nonlinear fitting method (default is 'ipopt').
+        max_iter_NM : int, optional
+            The maximum number of iterations for the Nelder-Mead optimization method (default is 1000).
         
         Returns
         -------
@@ -173,18 +179,6 @@ class DistFit:
     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
@@ -197,8 +191,8 @@ class DistFit:
 
         Parameters
         ----------
-        data : np.array
-            The sorted data points.
+        method : str
+            The method to use for initializing the x-coordinates of the control points.
 
         Returns
         -------

{bezierv-1.0.0.dist-info → bezierv-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bezierv
-Version: 1.0.0
+Version: 1.1.1
 Summary: This package serves as a computational framework for Bézier distributions.
 Author-email: Esteban Leiva <e.leivam@uniandes.edu.co>, "Andrés L. Medaglia" <amedagli@uniandes.edu.co>
 Maintainer-email: Esteban Leiva <e.leivam@uniandes.edu.co>
@@ -26,9 +26,8 @@ License: MIT License
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
         
-Project-URL: Homepage, https://github.com/you/your-package
-Project-URL: Documentation, https://your-package.readthedocs.io/
-Project-URL: Source, https://github.com/you/your-package
+Project-URL: Documentation, https://estebanleiva.github.io/bezierv/
+Project-URL: Source, https://github.com/EstebanLeiva/bezierv
 Keywords: bezier,distribution,optimization
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.10
@@ -43,21 +42,25 @@ 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: bokeh<4,>=3.4; 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: bokeh<4,>=3.4; 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: bokeh<4,>=3.4; 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"
+Requires-Dist: bokeh<4,>=3.4; python_version == "3.13"
 Dynamic: license-file
 
 <p align="center">

bezierv-1.1.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+bezierv/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bezierv/algorithms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bezierv/algorithms/nelder_mead.py,sha256=tMKnCPF36qAAOTRV7MBuHxSuvNBgYOzwgsI2sLtmAQQ,5673
+bezierv/algorithms/non_linear.py,sha256=nNAHbLK1FEdN53nmOg8Np8Fb0PKX7tiHs2JqVPn_VF0,7684
+bezierv/algorithms/proj_grad.py,sha256=6Ve8vVaJSyN3495r3cPsXheL3Uyho9C5qGDr5MXPfbQ,4716
+bezierv/algorithms/proj_subgrad.py,sha256=l9CNZuxJMde44Im3dbbobdKK5LVqD1Ev73Pbgy8LeLM,7158
+bezierv/algorithms/utils.py,sha256=QQecNlGdxMWhDcHPfGEJ_V1nuOIdJdR-2UziKh6N6tw,2396
+bezierv/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bezierv/classes/bezierv.py,sha256=zv-Y-gpo2baA33JqP09Qlbqt0P-HxE_PrfVvc2PKqKA,26323
+bezierv/classes/convolver.py,sha256=h-NewJ__VlL881UQSAUFSamscMEgPBwUxvpb6bHpFD0,2850
+bezierv/classes/distfit.py,sha256=gw7nye1GDkGrvF1aHAoItCCV-45xUKLdm5Dyev0RFRY,8984
+bezierv-1.1.1.dist-info/licenses/LICENSE,sha256=VfWiefIi6eo_kZleNp0Plg8A2eUX4D8fDbKtfj4VCp4,1115
+bezierv-1.1.1.dist-info/METADATA,sha256=FcrW6EzdJvpaJr4k9B-cfCwfdk5f4FTrgSs_939XAOc,4850
+bezierv-1.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bezierv-1.1.1.dist-info/top_level.txt,sha256=AC8zK0YmUeXyPIHtt0EKuHkLrvFBFeHwzp6bjzYnqJI,8
+bezierv-1.1.1.dist-info/RECORD,,

bezierv/algorithms/conv_bezierv.py

@@ -1,113 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-from scipy.integrate import quad
-
-from bezierv.classes.bezierv import Bezierv
-from bezierv.algorithms.proj_grad import ProjGrad
-
-class ConvBezier:
-    def __init__(self, bezierv_x: Bezierv, bezierv_y: Bezierv, m: int):
-        """
-        Initialize a ConvBezier instance for convolving two Bezier curves.
-
-        This constructor sets up the convolution object by storing the provided Bezierv
-        random variables, and creates a new Bezierv instance to hold the convolution 
-        result. It also initializes the number of data points to be used in the numerical
-        convolution process.
-
-        Parameters
-        ----------
-        bezierv_x : Bezierv
-            A Bezierv instance representing the first Bezier random variable.
-        bezierv_y : Bezierv
-            A Bezierv instance representing the second Bezier random variable.
-        m : int
-            The number of data points to generate for the convolution (more data points
-            induce a better approximation).
-
-        Attributes
-        ----------
-        bezierv_x : Bezierv
-            The Bezierv instance representing the first random variable.
-        bezierv_y : Bezierv
-            The Bezierv instance representing the second random variable.
-        bezierv_conv : Bezierv
-            A Bezierv instance that will store the convolution result. Its number of control
-            points is set to the maximum of control points between bezierv_x and bezierv_y.
-        m : int
-            The number of data points used in the convolution.
-        """
-        self.bezierv_x = bezierv_x
-        self.bezierv_y = bezierv_y
-        self.bezierv_conv = Bezierv(max(bezierv_x.n, bezierv_y.n))
-        self.m = m
-
-    def cdf_z (self, z: float):
-        """
-        Numerically compute the cumulative distribution function (CDF) at a given z-value for the
-        sum of Bezier random variables.
-
-        This method evaluates the CDF at the specified value z by integrating over the
-        parameter t of the sum of Bezier random variables.
-
-        Parameters
-        ----------
-        z : float
-            The value at which to evaluate the cumulative distribution function.
-
-        Returns
-        -------
-        float
-            The computed CDF value at z.
-        """
-        def integrand(t: float):
-            y_val = z - self.bezierv_x.poly_x(t)
-            if y_val < self.bezierv_y.controls_x[0]:
-                cumul_z = 0
-            elif y_val > self.bezierv_y.controls_x[-1]:
-                cumul_z = self.bezierv_x.pdf_numerator(t)
-            else:
-                y_inv = self.bezierv_y.root_find(y_val)
-                cumul_z = self.bezierv_x.pdf_numerator(t) * self.bezierv_y.eval_t(y_inv)[1]
-            return cumul_z
-
-        result, _ = quad(integrand, 0, 1)
-        return self.bezierv_x.n * result
-
-    def conv(self, step=0.001):
-        """
-        Numerically compute the convolution of two Bezier random variables.
-
-        This method performs the convolution by:
-          - Defining the lower and upper bounds for the convolution as the sum of the
-            smallest and largest control points of bezierv_x and bezierv_y, respectively.
-          - Generating a set of data points over these bounds.
-          - Evaluating the cumulative distribution function (CDF) at each data point using the
-            cdf_z method.
-          - Initializing a ProjGrad instance with the computed data and empirical CDF values.
-          - Fitting the convolution Bezier random variable via projected gradient descent and updating
-            bezierv_conv.
-
-        Returns
-        -------
-        Bezierv
-            The updated Bezierv instance representing the convolution of the two input Bezier 
-            random variables.
-        """
-        low_bound = self.bezierv_x.controls_x[0] + self.bezierv_y.controls_x[0]
-        up_bound = self.bezierv_x.controls_x[-1] + self.bezierv_y.controls_x[-1]
-        data = np.linspace(low_bound, up_bound, self.m)
-
-        emp_cdf_data = np.zeros(self.m)
-        for i in range(self.m):
-            emp_cdf_data[i] = self.cdf_z(data[i])
-
-        if self.bezierv_x.n == self.bezierv_y.n:
-            controls_x = self.bezierv_x.controls_x + self.bezierv_y.controls_x
-        else:
-            #TODO: Implement the case where the number of control points is different with quantiles
-            raise NotImplementedError
-        proj_grad = ProjGrad(self.bezierv_conv, data, controls_x, emp_cdf_data)
-        controls_z = np.linspace(0, 1, self.bezierv_conv.n + 1)
-        self.bezierv_conv = proj_grad.fit(controls_z, step=step)
-        return self.bezierv_conv

bezierv/algorithms/non_linear_solver.py

@@ -1,186 +0,0 @@
-import pyomo.environ as pyo
-import numpy as np
-
-from statsmodels.distributions.empirical_distribution import ECDF
-from pyomo.opt import SolverFactory, SolverStatus, TerminationCondition
-
-from bezierv.classes.bezierv import Bezierv
-
-class NonLinearSolver:
-    def __init__(self, bezierv: Bezierv, data: np.array, emp_cdf_data: np.array=None):
-        """
-        Initialize the NonLinearSolver instance with a Bezierv object and data to fit.
-
-        Parameters
-        ----------
-        bezierv : Bezierv
-            An instance of the Bezierv class representing the Bezier random variable.
-        data : np.array
-            The data points to be fitted; they will be sorted.
-        emp_cdf_data : np.array, optional
-            The empirical CDF values corresponding to the data. If not provided, they
-            are computed using ECDF from the sorted data.
-
-        Attributes
-        ----------
-        bezierv : Bezierv
-            The Bezierv object.
-        n : int
-            The degree of the Bezier random variable (inferred from bezierv.n).
-        data : np.array
-            The sorted data points.
-        m : int
-            The number of data points.
-        t_data : np.array
-            The values of t corresponding to the data points on the Bezier random variable.
-        fit_error : float
-            The fitting error, initialized to infinity.
-        emp_cdf_data : np.array
-            The empirical CDF values for the data points.
-        """
-        self.bezierv = bezierv
-        self.n = bezierv.n
-        self.data = np.sort(data)
-        self.m = len(data)
-        self.mse = np.inf
-
-        if emp_cdf_data is None:
-            emp_cdf = ECDF(data)
-            self.emp_cdf_data = emp_cdf(data)
-        else:
-            self.emp_cdf_data = emp_cdf_data
-
-    def fit(self, solver='ipopt'):
-        """
-        Fits a Bézier distribution to the given data using n control points.
-        This method sorts the input data, computes the empirical cumulative 
-        distribution function (CDF), and sets up an optimization model to 
-        fit a Bézier distribution. The control points and the empirical CDF 
-        are automatically saved. The method returns the mean square error (MSE) 
-        of the fit.
-        
-        Parameters:
-        data (list): A list of data points to fit the Bézier distribution.
-        n (int): The number of control points for the Bézier distribution.
-        solver (str): The SolverFactory str in pyomo. Values: "ipopt","knitroampl"
-
-        Returns:
-        float: The mean squared error (MSE) of the fit.
-
-        Raises:
-        Exception: If the solver fails to find an optimal solution.
-
-        Notes:
-        - The method uses the IPOPT solver for optimization.
-        - The control points are constrained to lie within the range of the data.
-        - The method ensures that the control points and the Bézier 'time' parameters are sorted.
-        - Convexity constraints are applied to the control points and the Bézier 'time' parameters.
-        - The first and last control points are fixed to the minimum and maximum of the data, respectively.
-        - The first and last Bézier 'time' parameters are fixed to 0 and 1, respectively.
-        """        
-        # Defining the optimization model
-        model = pyo.ConcreteModel()
-
-        # Sets
-        model.N = pyo.Set(initialize=list(range(self.n + 1))) # N = 0,...,i,...,n
-        model.N_n = pyo.Set(initialize=list(range(self.n))) # N = 0,...,i,...,n-1
-        model.M = pyo.Set(initialize=list(range(1, self.m + 1))) # M = 1,...,j,...,m
-        model.M_m = pyo.Set(initialize=list(range(1, self.m))) # M = 1,...,j,...,m-1
-
-        # Decision variables
-        # Control points. Box constraints.
-        X_min = self.data[0];
-        X_max = self.data[self.m - 1];
-        # var x{i in 0..n} >=X[1], <=X[m];
-        # Initialization: let {i in 1..n-1} x[i] := X[1]+i*(X[m]-X[1])/n;
-        def init_x_rule(model, i):
-          return X_min + i*(X_max - X_min) / self.n
-        model.x = pyo.Var(model.N, within=pyo.Reals, bounds=(X_min, X_max), initialize=init_x_rule) 
-        # var z{i in 0..n} >=0, <=1;
-        # Initialization: let {i in 1..n-1} z[i] := i*(1/n);
-        def init_z_rule(model, i):
-          return i*(1 / self.n)
-        model.z = pyo.Var(model.N, within=pyo.NonNegativeReals, bounds=(0, 1), initialize=init_z_rule) 
-        # Bezier 'time' parameter t for the j-th sample point.
-        # var t{j in 1..m} >=0, <= 1;
-        # Initialization: let {j in 2..m-1} t[j] := j*(1/m);        
-        def init_t_rule(model, j):
-          return j*(1 / self.m)
-        model.t = pyo.Var(model.M, within=pyo.NonNegativeReals, bounds=(0,1), initialize=init_t_rule )         
-        # Estimated cdf for the j-th sample point.
-        # var F_hat{j in 1..m} >=0, <= 1;
-        model.F_hat = pyo.Var(model.M, within=pyo.NonNegativeReals, bounds=(0,1) ) 
-
-        # Objective function
-        # minimize mean_square_error:
-        #    1/m * sum {j in 1..m} ( ( j/m - F_hat[j] )^2);
-        def mse_rule(model):
-          return (1 / self.m) * sum(((j / self.m) - model.F_hat[j])**2 for j in model.M)
-        model.mse = pyo.Objective(rule=mse_rule, sense=pyo.minimize )
-
-        # Constraints
-        # subject to F_hat_estimates {j in 1..m}:
-        #    sum{i in 0..n}( comb[i]*t[j]^i*(1-t[j])^(n-i)*z[i] ) = F_hat[j];
-        def F_hat_rule(model, j):
-          return sum(self.bezierv.comb[i] * model.t[j]**i * (1 - model.t[j])**(self.n - i) * model.z[i] for i in model.N ) == model.F_hat[j]
-        model.ctr_F_hat = pyo.Constraint(model.M , rule=F_hat_rule)
-
-        # subject to data_sample {j in 1..m}:
-        #    sum{i in 0..n}( comb[i]*t[j]^i*(1-t[j])^(n-i)*x[i] ) = X[j];
-        def data_sample_rule(model, j):
-          return sum(self.bezierv.comb[i] * model.t[j]**i * (1 - model.t[j])**(self.n - i) * model.x[i] for i in model.N ) == self.data[j-1]
-        model.ctr_sample = pyo.Constraint(model.M , rule=data_sample_rule)
-
-        # subject to sorted_t{j in 1..m-1}:
-        #    t[j] <= t[j+1];
-        #def sorted_t_rule(model, j):
-        #  return model.t[j] <= model.t[j + 1]
-        #model.ctr_sorted_t = pyo.Constraint(model.M_m , rule=sorted_t_rule)
-        
-        # subject to convexity_x {i in 0..n-1}:
-        #    x[i] <= x[i+1];
-        def convexity_x_rule(model, i):
-          return model.x[i] <= model.x[i + 1]
-        model.ctr_convexity_x = pyo.Constraint(model.N_n , rule=convexity_x_rule)
-
-        # subject to convexity_z {i in 0..n-1}:
-        #    z[i] <= z[i+1];
-        def convexity_z_rule(model, i):
-          return model.z[i] <= model.z[i + 1]
-        model.ctr_convexity_z = pyo.Constraint(model.N_n , rule=convexity_z_rule)
-
-        # subject to first_control_x:
-        #    x[0] = X[1];
-        model.first_control_x = pyo.Constraint(expr=model.x[0] <= self.data[0]) #==
-        # subject to first_control_z:
-        #    z[0] = 0;
-        model.first_control_z = pyo.Constraint(expr=model.z[0] == 0)
-
-        # subject to last_control_x:
-        #    x[n] = X[m];
-        model.last_control_x = pyo.Constraint(expr=model.x[self.n] >= self.data[self.m - 1]) # ==
-        # subject to last_control_z:
-        #    z[n] = 1;
-        model.last_control_z = pyo.Constraint(expr=model.z[self.n] == 1)
-        
-        # subject to first_data_t:
-        #    t[1] = 0;
-        model.first_t = pyo.Constraint(expr=model.t[1] == 0)
-        # subject to last_data_t:
-        #    t[m] = 1;
-        model.last_t = pyo.Constraint(expr=model.t[self.m] == 1)
- 
-        # Set solver
-        pyo_solver = SolverFactory(solver)
-        
-        try:
-            results = pyo_solver.solve(model, tee=False, timelimit=60)
-            if (results.solver.status == SolverStatus.ok) and (results.solver.termination_condition == TerminationCondition.optimal):
-                controls_x = np.array([model.x[i]() for i in model.N])
-                controls_z = np.array([model.z[i]() for i in model.N])
-                self.mse = model.mse()
-                self.bezierv.update_bezierv(controls_x, controls_z, (self.data[0], self.data[-1]))
-        except Exception as e:
-            print("NonLinearSolver [fit]: An exception occurred during model evaluation:", e)
-
-        return self.bezierv

bezierv/tests/test_algorithms/test_nelder_mead.py

@@ -1,54 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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)