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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bezierv
-Version: 1.0.0
+Version: 1.0.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

bezierv-1.0.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=uqH3jJS-CG6wblOKP83Rt8-XFJrXZSVJLHaixRKCflw,5478
+bezierv/algorithms/non_linear.py,sha256=dgwGGe__JJGXQXidmAYjSkDBqSjdr-1HilnUUuPEs8c,7523
+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-1.0.1.dist-info/licenses/LICENSE,sha256=VfWiefIi6eo_kZleNp0Plg8A2eUX4D8fDbKtfj4VCp4,1115
+bezierv-1.0.1.dist-info/METADATA,sha256=x3-0fmrohRnqUBTQMN0xfq02YDLM21KGAgudhLgx_Zk,4626
+bezierv-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bezierv-1.0.1.dist-info/top_level.txt,sha256=AC8zK0YmUeXyPIHtt0EKuHkLrvFBFeHwzp6bjzYnqJI,8
+bezierv-1.0.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)

bezierv/tests/test_classes/conftest.py

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

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

@@ -1,34 +0,0 @@
-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-1.0.0.dist-info/RECORD

@@ -1,29 +0,0 @@
-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-1.0.0.dist-info/licenses/LICENSE,sha256=VfWiefIi6eo_kZleNp0Plg8A2eUX4D8fDbKtfj4VCp4,1115
-bezierv-1.0.0.dist-info/METADATA,sha256=hzqB1McgWf-yUlKqHtBTsY3gpUjv6PN-JQ7_KNQCQG0,4679
-bezierv-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bezierv-1.0.0.dist-info/top_level.txt,sha256=AC8zK0YmUeXyPIHtt0EKuHkLrvFBFeHwzp6bjzYnqJI,8
-bezierv-1.0.0.dist-info/RECORD,,