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

bezierv/algorithms/nelder_mead.py

@@ -114,7 +114,7 @@ def fit(n: int,
         init_z: np.array,
         emp_cdf_data: np.array,
         max_iter: int
-        ) -> Bezierv:
+        ) -> tuple[Bezierv, float]:
     """
     Fit the Bezier random variable to the empirical CDF data using the Nelder-Mead optimization algorithm.
 
@@ -134,13 +134,16 @@ def fit(n: int,
         Initial guess for the z-coordinates of the control points.
     emp_cdf_data : np.array
         The empirical CDF data points used for fitting.
+    max_iter : int
+        The maximum number of iterations for the optimization algorithm.
     
     Returns
     -------
-    Bezierv
-        The fitted Bezierv object with updated control points.
-    float
-        The mean squared error (MSE) of the fit.
+    tuple[Bezierv, float]
+        A tuple containing:
+        - bezierv (Bezierv): The fitted `Bezierv` object with updated control
+          points.
+        - mse (float): The final mean squared error (MSE) of the fit.
     """
     start = np.concatenate((init_x, init_z))
     result = minimize(

bezierv/algorithms/non_linear.py

@@ -13,47 +13,54 @@ def fit(n: int,
         init_t: np.array,
         emp_cdf_data: np.array,
         solver: str) -> Bezierv:
-        """
-        Fit a Bézier random variable to the empirical CDF data using a nonlinear optimization solver.
-        
+        """Fits a Bézier random variable to empirical CDF data.
+
+        This method uses a nonlinear optimization solver to find the optimal
+        Bézier curve control points that best represent the empirical cumulative
+        distribution function (CDF) of the provided data.
+
         Parameters
         ----------
         n : int
-          The number of control points minus one for the Bezier curve.
+            The degree of the Bézier curve (number of control points - 1).
         m : int
-          The number of empirical CDF data points.
-        data : np.array
-          The sorted data points used to fit the Bézier distribution.
+            The number of empirical CDF data points.
+        data : np.ndarray
+            The sorted data points used to fit the Bézier distribution.
         bezierv : Bezierv
-          An instance of the Bezierv class representing the Bézier random variable.
-        init_x : np.array
-          Initial guess for the x-coordinates of the control points.
-        init_z : np.array
-          Initial guess for the z-coordinates of the control points.
-        init_t : np.array
-          Initial guess for the Bézier 'time' parameters corresponding to the data points.
-        emp_cdf_data : np.array
-          The empirical CDF data points used for fitting.
+            An instance of the `Bezierv` class to be fitted.
+        init_x : np.ndarray
+            Initial guess for the x-coordinates of the control points.
+        init_z : np.ndarray
+            Initial guess for the z-coordinates of the control points.
+        init_t : np.ndarray
+            Initial guess for the Bézier 'time' parameters `t` in [0, 1].
+        emp_cdf_data : np.ndarray
+            The empirical CDF values corresponding to the `data` points.
         solver : str, optional
-          The name of the solver to use for optimization.
+            The name of the solver to use for optimization. Defaults to 'ipopt'.
 
         Returns
         -------
-        Bezierv
-            The fitted Bezierv object with updated control points.
-        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.
+        tuple[Bezierv, float]
+            A tuple containing:
+            - bezierv (Bezierv): The fitted `Bezierv` object with updated
+              control points.
+            - mse (float): The final mean squared error (MSE) of the fit.
+
+        Raises
+        ------
+        Exception
+            If the optimization solver fails to find a solution.
+
+        Notes
+        -----
+        The optimization is subject to several constraints to ensure a valid
+        CDF representation:
+        - The control points and 'time' parameters are kept sorted.
+        - Convexity constraints are applied to the control points.
+        - The first and last control points are fixed to the data's range.
+        - The first and last 'time' parameters are fixed to 0 and 1.
         """        
         # Defining the optimization model
         model = pyo.ConcreteModel()

bezierv/algorithms/proj_grad.py

@@ -3,7 +3,7 @@ from bezierv.classes.bezierv import Bezierv
 
 def grad(n: int, 
          m:int, 
-         t: float, 
+         t: np.array, 
          bezierv: Bezierv, 
          controls_z: np.array, 
          emp_cdf_data: np.array) -> np.array:
@@ -38,7 +38,7 @@ def grad(n: int,
         grad_z += 2 * (bezierv.poly_z(t[j], controls_z) - emp_cdf_data[j]) * inner_sum
     return grad_z
     
-def project_z(controls_z: np.array):
+def project_z(controls_z: np.array) -> np.array:
     """
     Project the z control points onto the feasible set.
 
@@ -68,7 +68,7 @@ def fit(n: int,
         bezierv: Bezierv,
         init_x: np.array,
         init_z: np.array,
-        t: float,
+        t: np.array,
         emp_cdf_data: np.array, 
         step_size: float, 
         max_iter: int,
@@ -97,7 +97,7 @@ def fit(n: int,
         Initial guess for the x-coordinates of the control points.
     init_z : np.array
         Initial guess for the z-coordinates of the control points.
-    t : float or np.array
+    t : np.array
         The parameter values corresponding to the data points. Expected to be an array of shape (m,).
     emp_cdf_data : np.array
         The empirical CDF data points used for fitting.
@@ -110,10 +110,11 @@ def fit(n: int,
 
     Returns
     -------
-    Bezierv
-        The updated Bezierv instance with fitted control points.
-    float
-        The mean squared error (MSE) of the fit.
+    tuple[Bezierv, float]
+        A tuple containing:
+        - bezierv (Bezierv): The fitted `Bezierv` object with updated control
+          points.
+        - mse (float): The final mean squared error (MSE) of the fit.
     """
     z = init_z
     for i in range(max_iter):

bezierv/algorithms/proj_subgrad.py

@@ -5,7 +5,7 @@ from bezierv.algorithms import utils as utils
 def subgrad(n: int,
             m: int,
             bezierv: Bezierv,
-            t: float, 
+            t: np.array, 
             controls_z: np.array,
             emp_cdf_data: np.array) -> tuple:
     """
@@ -28,8 +28,10 @@ def subgrad(n: int,
 
     Returns
     -------
-    np.array, np.array
-        A tuple containing the subgradient with respect to the x control points and the gradient with respect to the z control points.
+    tuple[np.ndarray, np.ndarray]
+        A tuple containing:
+        - subgrad_x (np.ndarray): Subgradient w.r.t. the x-coordinates.
+        - grad_z (np.ndarray): Gradient w.r.t. the z-coordinates.
     """
     grad_z = np.zeros(n + 1)
     subgrad_x = np.zeros(n + 1)
@@ -52,7 +54,7 @@ def subgrad(n: int,
     return subgrad_x, grad_z
 
 def project_x(data:np.array,
-              controls_x: np.array):
+              controls_x: np.array) -> np.array:
     """
     Project the x control points onto the feasible set.
 
@@ -76,7 +78,7 @@ def project_x(data:np.array,
     x_prime[-1] = data[-1]
     return x_prime
 
-def project_z(controls_z: np.array):
+def project_z(controls_z: np.array) -> np.array:
     """
     Project the z control points onto the feasible set.
 
@@ -104,7 +106,7 @@ def objective_function(m: int,
                        bezierv: Bezierv,
                        emp_cdf_data: np.array,
                        z: np.array, 
-                       t: np.array):
+                       t: np.array) -> float:
     """
     Compute the objective function value for the given z control points.
 
@@ -134,10 +136,10 @@ def fit(n: int,
         bezierv: Bezierv,
         init_x: np.array,
         init_z: np.array,
-        init_t: float,
+        init_t: np.array,
         emp_cdf_data: np.array, 
         step_size: float,
-        max_iter: int):
+        max_iter: int) -> tuple[Bezierv, float]:
     """
     Fit the Bezier random variable to the empirical CDF data using projected gradient descent.
 
@@ -162,7 +164,7 @@ def fit(n: int,
         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 : float
+    init_t : np.array
         Initial parameter values corresponding to the data points.
     emp_cdf_data : np.array
         The empirical cumulative distribution function (CDF) data derived from the empirical data.
@@ -173,10 +175,11 @@ def fit(n: int,
 
     Returns
     -------
-    Bezierv
-        The updated Bezierv instance with fitted control points.
-    float
-        The mean squared error (MSE) of the fit.
+    tuple[Bezierv, float]
+        A tuple containing:
+        - bezierv (Bezierv): The fitted `Bezierv` object with updated control
+          points.
+        - mse (float): The final mean squared error (MSE) of the fit.
     """
     f_best = np.inf
     x_best = None

bezierv/classes/bezierv.py

@@ -6,13 +6,14 @@ from scipy.optimize import brentq, bisect
 from scipy.integrate import quad
 from statsmodels.distributions.empirical_distribution import ECDF
 
-from numpy import tanh, arctanh
+# import arrays for type hinting
+from numpy.typing import ArrayLike
 
 class Bezierv:
     def __init__(self, 
                  n: int, 
-                 controls_x=None, 
-                 controls_z=None):
+                 controls_x: ArrayLike=None, 
+                 controls_z: ArrayLike=None):
         """
         Initialize a Bezierv instance representing a Bezier random variable.
 
@@ -117,14 +118,6 @@ class Bezierv:
     def combinations(self):
         """
         Compute and store binomial coefficients.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
         """
         n = self.n
         for i in range(0, n + 1):
@@ -135,21 +128,13 @@ class Bezierv:
     def deltas(self):
         """
         Compute the differences between consecutive control points.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
         """
         n = self.n
         for i in range(n):
             self.deltas_x[i] = self.controls_x[i + 1] - self.controls_x[i]
             self.deltas_z[i] = self.controls_z[i + 1] - self.controls_z[i]
 
-    def bernstein(self, t, i, combinations, n):
+    def bernstein(self, t: float, i: int, combinations: np.array, n: int) -> float:
         """
         Compute the Bernstein basis polynomial value.
 
@@ -159,7 +144,7 @@ class Bezierv:
             The parameter value (in the interval [0, 1]).
         i : int
             The index of the Bernstein basis polynomial.
-        combinations : array-like
+        combinations : np.array
             An array of binomial coefficients to use in the computation.
         n : int
             The degree for the Bernstein polynomial.
@@ -171,7 +156,7 @@ class Bezierv:
         """
         return combinations[i] * t**i * (1 - t)**(n - i)
 
-    def poly_x(self, t, controls_x = None):
+    def poly_x(self, t: float, controls_x: np.array = None) -> float:
         """
         Evaluate the x-coordinate at a given t value.
 
@@ -195,8 +180,8 @@ class Bezierv:
         for i in range(n + 1):
            p_x  += self.bernstein(t, i, self.comb, self.n) * controls_x[i]
         return p_x
-    
-    def poly_z(self, t, controls_z = None):
+
+    def poly_z(self, t: float, controls_z: np.array = None) -> float:
         """
         Evaluate the z-coordinate at a given t value.
 
@@ -204,7 +189,7 @@ class Bezierv:
         ----------
         t : float
             The parameter value at which to evaluate the curve (typically in [0, 1]).
-        controls_z : array-like, optional
+        controls_z : np.array, optional
             An array of control points for the z-coordinate. Defaults to self.controls_z.
 
         Returns
@@ -220,8 +205,8 @@ class Bezierv:
         for i in range(n + 1):
            p_z  += self.bernstein(t, i, self.comb, self.n) * controls_z[i]
         return p_z
-    
-    def root_find(self, x, method='brentq'):
+
+    def root_find(self, x: float, method: str = 'brentq') -> float:
         """
         Find t such that the Bezier curve's x-coordinate equals a given value.
 
@@ -249,7 +234,7 @@ class Bezierv:
             t = bisect(poly_x_zero, 0, 1, args=(x,))
         return t
 
-    def eval_t(self, t):
+    def eval_t(self, t: float) -> tuple[float, float]:
         """
         Evaluate the CDF of the Bezier random variable at a given parameter value t.
 
@@ -260,8 +245,8 @@ class Bezierv:
 
         Returns
         -------
-        tuple of floats
-            A tuple (p_x, p_z) where p_x is the evaluated x-coordinate and p_z is the evaluated z-coordinate.
+        tuple[float, float]
+            A tuple containing the (x, z) coordinates of the point on the curve w.r.t. t.
         """
         self._ensure_initialized()
         n = self.n
@@ -271,8 +256,8 @@ class Bezierv:
             p_x += self.comb[i] * t**i * (1 - t)**(n - i) * self.controls_x[i]
             p_z += self.comb[i] * t**i * (1 - t)**(n - i) * self.controls_z[i]
         return p_x, p_z
-    
-    def eval_x(self, x):
+
+    def eval_x(self, x: float) -> tuple[float, float]:
         """
         Evaluate the CDF of the Bezier random variable at a given x-coordinate.
 
@@ -283,14 +268,14 @@ class Bezierv:
 
         Returns
         -------
-        tuple of floats
-            A tuple (p_x, p_z) where p_x is the x-coordinate and p_z is the z-coordinate of the curve at x.
+        tuple[float, float]
+            A tuple containing the (x, z) coordinates of the point on the curve w.r.t. x.
         """
         self._ensure_initialized()
         t = self.root_find(x)
         return self.eval_t(t)
-    
-    def cdf_x(self, x):
+
+    def cdf_x(self, x: float) -> float:
         """
         Compute the cumulative distribution function (CDF) at a given x-coordinate.
 
@@ -312,7 +297,7 @@ class Bezierv:
         _, p_z = self.eval_x(x)
         return p_z
 
-    def quantile(self, alpha, method='brentq'):
+    def quantile(self, alpha: float, method: str = 'brentq') -> float:
         """
         Compute the quantile function (inverse CDF) for a given probability level alpha.
 
@@ -335,8 +320,8 @@ class Bezierv:
         elif method == 'bisect':
             t = bisect(cdf_t, 0, 1, args=(alpha,))
         return self.poly_x(t)
-    
-    def pdf_t(self, t):
+
+    def pdf_t(self, t: float) -> float:
         """
         Compute the probability density function (PDF) of the Bezier random variable with respect to t.
 
@@ -359,7 +344,7 @@ class Bezierv:
             pdf_denom_x += self.bernstein(t, i, self.comb_minus, n - 1) * self.deltas_x[i]
         return pdf_num_z/pdf_denom_x
     
-    def pdf_x(self, x):
+    def pdf_x(self, x: float) -> float:
         """
         Compute the probability density function (PDF) of the Bezier random variable at a given x.
 
@@ -376,8 +361,8 @@ class Bezierv:
         self._ensure_initialized()
         t = self.root_find(x)
         return self.pdf_t(t)
-    
-    def pdf_numerator_t(self, t):
+
+    def pdf_numerator_t(self, t: float) -> float:
         """
         Compute the numerator part of the PDF for the Bezier random variable with respect to t.
 
@@ -397,7 +382,7 @@ class Bezierv:
             pdf_num_z += self.bernstein(t, i, self.comb_minus, self.n - 1) * self.deltas_z[i]
         return pdf_num_z
 
-    def get_mean(self, closed_form: bool=True):
+    def get_mean(self, closed_form: bool=True) -> float:
         """
         Compute and return the mean of the distribution.
 
@@ -427,7 +412,12 @@ class Bezierv:
                 self.mean, _ = quad(lambda x: x * self.pdf_x(x), a, b) 
         return self.mean
 
-    def get_variance(self):
+    def get_variance(self) -> float:
+        """Compute and return the variance of the distribution.
+
+        Returns:
+            float: The variance value of the distribution.
+        """
         self._ensure_initialized()
         a, b = self.bounds
         E_x2, _ = quad(lambda x: (x)**2 * self.pdf_x(x), a, b)
@@ -437,6 +427,8 @@ class Bezierv:
             self.variance = E_x2 - self.mean**2
         return self.variance
     
+    #TODO: implement skewness and kurtosis
+    
     def random(self, 
                n_sims: int,
                *,
@@ -471,8 +463,8 @@ class Bezierv:
             samples[i] = self.quantile(u[i])
         return samples
 
-    
-    def plot_cdf(self, data=None, num_points=100, ax=None):
+
+    def plot_cdf(self, data: np.array=None, num_points: int=100, ax: plt.Axes=None):
         """
         Plot the cumulative distribution function (CDF) of the Bezier random variable alongside 
         the empirical CDF (if data is provided).
@@ -485,10 +477,6 @@ class Bezierv:
             The number of points to use in the linspace when data is not provided (default is 100).
         ax : matplotlib.axes.Axes, optional
             The axes on which to plot the CDF. If None, the current axes are used.
-
-        Returns
-        -------
-        None
         """
         self._ensure_initialized()
         data_bool = True
@@ -520,7 +508,7 @@ class Bezierv:
         if show:
             plt.show()
 
-    def plot_pdf(self, data=None, num_points=100, ax=None):
+    def plot_pdf(self, data: np.array=None, num_points: int=100, ax: plt.Axes=None):
         """
         Plot the probability density function (PDF) of the Bezier random variable.
 
@@ -532,10 +520,6 @@ class Bezierv:
             The number of points to use in the linspace when data is not provided (default is 100).
         ax : matplotlib.axes.Axes, optional
             The axes on which to plot the PDF. If None, the current axes are used.
-
-        Returns
-        -------
-        None
         """
         self._ensure_initialized()
         if data is None:
@@ -576,4 +560,170 @@ class Bezierv:
             raise RuntimeError(
                 "Bezier controls are all zeros (placeholder). "
                 "Provide valid controls in the constructor or call update_bezierv()."
-            )
+            )
+        
+from bokeh.plotting import figure, curdoc
+from bokeh.models import (ColumnDataSource, PointDrawTool, Button, CustomJS, 
+                          DataTable, TableColumn, NumberFormatter)
+from bokeh.layouts import column, row
+
+class InteractiveBezierv:
+    """Manages an interactive Bezier distribution in a Bokeh plot."""
+    
+    def __init__(self, controls_x, controls_z):
+        self._is_updating = False
+
+        n = len(controls_x) - 1
+        self.bezier = Bezierv(n=n, controls_x=controls_x, controls_z=controls_z)
+
+        self.controls_source = ColumnDataSource(data=self._get_controls_data())
+        self.curve_source = ColumnDataSource(data=self._get_curve_data())
+        
+        self.plot = figure(
+            height=600, width=900,
+            title="Interactive Bézier CDF Editor",
+            x_axis_label="x", y_axis_label="CDF",
+            y_range=(-0.05, 1.05)
+        )
+        
+        self.plot.line(x='x', y='y', source=self.curve_source, line_width=3, legend_label="Bézier CDF", color="navy")
+        self.plot.line(x='x', y='y', source=self.controls_source, line_dash="dashed", color="gray")
+        
+        controls_renderer = self.plot.scatter(
+            x='x', y='y', source=self.controls_source, size=12,
+            legend_label="Control Points", color="firebrick"
+        )
+        self.plot.legend.location = "top_left"
+
+        draw_tool = PointDrawTool(renderers=[controls_renderer])
+        self.plot.add_tools(draw_tool)
+        self.plot.toolbar.active_tap = draw_tool
+
+        formatter = NumberFormatter(format="0.000")
+        columns = [
+            TableColumn(field="x", title="X", formatter=formatter),
+            TableColumn(field="y", title="Z", formatter=formatter)
+        ]
+        
+        self.data_table = DataTable(
+            source=self.controls_source,
+            columns=columns, 
+            width=250, 
+            height=600, 
+            editable=True
+        )
+
+        self.download_button = Button(
+            label="Download Control Points as CSV", 
+            button_type="success", 
+            width=250
+        )
+
+        callback = CustomJS(args=dict(source=self.controls_source), code="""
+            const data = source.data;
+            const file_name = 'control_points.csv';
+            let csv_content = 'X,Z_CDF\\n'; // CSV Header
+
+            // Iterate over the data and build the CSV string
+            for (let i = 0; i < data.x.length; i++) {
+                const row = [data.x[i], data.y[i]];
+                csv_content += row.join(',') + '\\n';
+            }
+
+            // Create a Blob and trigger the download
+            const blob = new Blob([csv_content], { type: 'text/csv;charset=utf-8;' });
+            const link = document.createElement('a');
+            link.href = URL.createObjectURL(blob);
+            link.download = file_name;
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+        """)
+        
+        self.download_button.js_on_click(callback)
+
+        self.controls_source.on_change('data', self._update_callback)
+
+        widgets_layout = column(self.plot, self.download_button)
+        self.layout = row(widgets_layout, self.data_table)
+
+    def _get_controls_data(self):
+        """Returns the current control points from the Bezierv instance."""
+        return {'x': self.bezier.controls_x, 'y': self.bezier.controls_z}
+
+    def _get_curve_data(self, num_points=200):
+        """Calculates and returns the CDF curve points."""
+        t = np.linspace(0, 1, num_points)
+        curve_x = [self.bezier.poly_x(ti) for ti in t]
+        curve_z = [self.bezier.poly_z(ti) for ti in t]
+        return {'x': curve_x, 'y': curve_z}
+
+    def _update_callback(self, attr, old, new):
+        """Handles moving, adding, and deleting control points."""
+        
+        if self._is_updating:
+            return
+
+        try:
+            self._is_updating = True
+
+            new_x = new['x']
+            new_z = new['y']
+
+            is_point_added = len(new_x) > len(old['x'])
+            
+            if is_point_added:
+                old_points_sorted = sorted(zip(old['x'], old['y']))
+                
+                if len(old_points_sorted) < 2:
+                    raise ValueError("Cannot add a point, need at least 2 existing points.")
+
+                mid_index = len(old_points_sorted) // 2
+
+                p_before = old_points_sorted[mid_index - 1]
+                p_after = old_points_sorted[mid_index]
+
+                x_new = (p_before[0] + p_after[0]) / 2.0
+                y_new = (p_before[1] + p_after[1]) / 2.0
+                
+                final_points = old_points_sorted
+                final_points.insert(mid_index, (x_new, y_new))
+                
+                final_x, final_z = zip(*final_points)
+                final_x, final_z = list(final_x), list(final_z)
+            
+            else:
+                sorted_points = sorted(zip(new_x, new_z))
+                if not sorted_points:
+                    final_x, final_z = [], []
+                else:
+                    final_x, final_z = zip(*sorted_points)
+                    final_x, final_z = list(final_x), list(final_z)
+
+                if final_z != sorted(final_z):
+                    raise ValueError("Control points' y-values must be in non-decreasing order.")
+
+            if len(final_x) < 2:
+                raise ValueError("At least two control points are required.")
+
+            final_z[0] = 0.0
+            final_z[-1] = 1.0
+            
+            new_n = len(final_x) - 1
+            if new_n != self.bezier.n:
+                self.bezier = Bezierv(n=new_n, controls_x=final_x, controls_z=final_z)
+            else:
+                self.bezier.update_bezierv(np.array(final_x), np.array(final_z))
+            
+            self.controls_source.data = {
+                'x': list(self.bezier.controls_x), 
+                'y': list(self.bezier.controls_z)
+            }
+            self.curve_source.data = self._get_curve_data()
+
+        except Exception as e:
+            print(f"An unexpected error occurred: {e}. Reverting.")
+            self.controls_source.data = dict(old)
+
+        finally:
+            self._is_updating = False

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.1.dist-info → bezierv-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bezierv
-Version: 1.0.1
+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>
@@ -42,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-1.0.1.dist-info/RECORD

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