bezierv 0.1.0__tar.gz

bezierv-0.1.0/.gitignore

@@ -0,0 +1,171 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# PyPI configuration file
+.pypirc

bezierv-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,38 @@
+<p align="center">
+  <!-- If you used a different path, update the src accordingly -->
+  <img src="docs/assets/logo.png" alt="bezierv logo" width="260"/>
+</p>
+
+<h1 align="center">bezierv</h1>
+<p align="center">
+  <em>Fit smooth Bézier random variables to empirical data &mdash; elegant, differentiable, and fast.</em>
+</p>
+
+<p align="center">
+  <!-- Add real badges once you publish to PyPI / set up CI -->
+  <img alt="PyPI" src="https://img.shields.io/pypi/v/bezierv?style=flat-square">
+  <img alt="CI" src="https://img.shields.io/github/actions/workflow/status/EstebanLeiva/bezierv/ci.yml?style=flat-square">
+  <img alt="License" src="https://img.shields.io/github/license/EstebanLeiva/bezierv?style=flat-square">
+</p>
+
+---
+
+## Why Bézier random variables?  
+Classical parametric distributions can be too rigid; non-parametric methods can be noisy.  
+Bézier curves offer a sweet spot: **smooth** and **shape-controlled**.  
+With **bezierv** you can:
+
+* Fit Bézier CDFs/PDFs to sample data of any shape.
+* Evaluate moments and quantiles.
+* Compose variables via convolution.
+
+---
+
+## Installation
+
+```bash
+pip install bezierv            # from PyPI (coming soon)
+# or, for development:
+git clone https://github.com/your-org/bezierv
+cd bezierv
+pip install -e .

bezierv-0.1.0/bezierv/algorithms/nelder_mead.py

@@ -0,0 +1,157 @@
+import numpy as np
+from bezierv.classes.bezierv import Bezierv
+from scipy.optimize import minimize
+import bezierv.algorithms.utils as utils
+
+def objective_function(concatenated: np.array, 
+                       n: int, 
+                       m: int,
+                       data:np.array,
+                       bezierv: Bezierv,
+                       emp_cdf_data: np.array) -> float:
+    """
+    Compute the objective function value for the given control points.
+
+    This method calculates the sum of squared errors between the Bezier random variable's CDF
+    and the empirical CDF data.
+
+    Parameters
+    ----------
+    concatenated : np.array
+        A concatenated array containing the control points for z and x coordinates.
+        The first n+1 elements are the z control points, and the remaining elements are the x control points.
+    n : int
+        The number of control points minus one for the Bezier curve.
+    m : int
+        The number of empirical CDF data points.
+    data : np.array
+        The sorted data points used to fit the Bezier distribution.
+    bezierv : Bezierv
+        An instance of the Bezierv class representing the Bezier random variable.
+    emp_cdf_data : np.array
+        The empirical CDF data points used for fitting.
+
+    Returns
+    -------
+    float
+        The value of the objective function (MSE).
+    """
+    x = concatenated[0 : n + 1]
+    z = concatenated[n + 1:]
+    t = utils.get_t(n, m, data, bezierv, x)
+    se = 0
+    for j in range(m):
+        se += (bezierv.poly_z(t[j], z) - emp_cdf_data[j])**2
+    return se / m
+
+def objective_function_lagrangian(concatenated: np.array,
+                                  n: int,
+                                  m: int,
+                                  data: np.array, 
+                                  bezierv: Bezierv,
+                                  emp_cdf_data: np.array,
+                                  penalty_weight: float=1e3) -> float:
+    """
+    Compute the objective function value for the given control points.
+
+    This method calculates the sum of squared errors between the Bezier random variable's CDF
+    and the empirical CDF data.
+
+    Parameters
+    ----------
+    concatenated : np.array
+        A concatenated array containing the control points for z and x coordinates.
+        The first n+1 elements are the z control points, and the remaining elements are the x control points.
+    n : int
+        The number of control points minus one for the Bezier curve.
+    m : int
+        The number of empirical CDF data points.
+    data : np.array
+        The sorted data points used to fit the Bezier distribution.
+    bezierv : Bezierv
+        An instance of the Bezierv class representing the Bezier random variable.
+    emp_cdf_data : np.array
+        The empirical CDF data points used for fitting.
+    penalty_weight : float, optional
+        The weight for the penalty term in the objective function (default is 1e3).
+
+    Returns
+    -------
+    float
+        The value of the objective function + penalty (MSE + penalty).
+    """
+    
+    x = concatenated[0 : n + 1]
+    z = concatenated[n + 1 : ]
+
+    try:
+        t = utils.get_t(n, m, data, bezierv, x)
+    except ValueError as e:
+        return np.inf
+    
+    se = 0
+    for j in range(m):
+        se += (bezierv.poly_z(t[j], z) - emp_cdf_data[j])**2
+    mse = se / m
+
+    penalty = 0.0
+    penalty += abs(z[0] - 0.0)
+    penalty += abs(z[-1] - 1.0)
+    delta_zs = np.diff(z)
+    delta_xs = np.diff(x)
+    penalty += np.sum(abs(np.minimum(0, delta_zs)))
+    penalty += np.sum(abs(np.minimum(0, delta_xs)))
+    penalty += abs(x[0] - data[0])
+    penalty += abs(data[-1] - x[-1])
+
+    return mse + penalty_weight * penalty
+
+def fit(n: int, 
+        m: int,
+        data: np.array,
+        bezierv: Bezierv,
+        init_x: np.array,
+        init_z: np.array,
+        emp_cdf_data: np.array,
+        max_iter: int
+        ) -> Bezierv:
+    """
+    Fit the Bezier random variable to the empirical CDF data using the Nelder-Mead optimization algorithm.
+
+    Parameters
+    ----------
+    n : int
+        The number of control points minus one for the Bezier curve.
+    m : int
+        The number of empirical CDF data points.
+    data : np.array
+        The sorted data points used to fit the Bezier distribution.
+    bezierv : Bezierv
+        An instance of the Bezierv class representing the Bezier 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.
+    emp_cdf_data : np.array
+        The empirical CDF data points used for fitting.
+    
+    Returns
+    -------
+    Bezierv
+        The fitted Bezierv object with updated control points.
+    float
+        The mean squared error (MSE) of the fit.
+    """
+    start = np.concatenate((init_x, init_z))
+    result = minimize(
+        fun=objective_function_lagrangian,
+        args=(n, m, data, bezierv, emp_cdf_data),
+        x0=start,
+        method='Nelder-Mead',
+        options={'maxiter': max_iter, 'disp': False})
+    sol = result.x
+    controls_x = sol[0 : n + 1]
+    controls_z = sol[n + 1: ]
+    bezierv.update_bezierv(controls_x, controls_z)
+    mse = objective_function(sol, n, m, data, bezierv, emp_cdf_data)
+    return bezierv, mse

bezierv-0.1.0/bezierv/algorithms/non_linear.py

@@ -0,0 +1,167 @@
+from pyexpat import model
+import pyomo.environ as pyo
+import numpy as np
+from bezierv.classes.bezierv import Bezierv
+from pyomo.opt import SolverFactory, SolverStatus, TerminationCondition
+
+def fit(n: int,
+        m: int,
+        data: np.array,
+        bezierv: Bezierv,
+        init_x: np.array,
+        init_z: np.array,
+        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.
+        
+        Parameters
+        ----------
+        n : int
+          The number of control points minus one for the Bezier curve.
+        m : int
+          The number of empirical CDF data points.
+        data : np.array
+          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.
+        solver : str, optional
+          The name of the solver to use for optimization.
+
+        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.
+        """        
+        # Defining the optimization model
+        model = pyo.ConcreteModel()
+
+        # Sets
+        model.N = pyo.Set(initialize=list(range(n + 1))) # N = 0,...,i,...,n
+        model.N_n = pyo.Set(initialize=list(range(n))) # N = 0,...,i,...,n-1
+        model.M = pyo.Set(initialize=list(range(1, m + 1))) # M = 1,...,j,...,m
+        model.M_m = pyo.Set(initialize=list(range(1, m))) # M = 1,...,j,...,m-1
+
+        # Decision variables
+        # Control points. Box constraints.
+        X_min = data[0];
+        X_max = data[-1];
+        # var x{i in 0..n} >=X[1], <=X[m];
+        # Initialization:
+        def init_x_rule(model, i):
+          return float(init_x[i])
+        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:
+        def init_z_rule(model, i):
+          return float(init_z[i])
+        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:  
+        def init_t_rule(model, j):
+          return float(init_t[j - 1])  # j starts from 1, so we access init_t with j-1
+        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 / m) * sum((emp_cdf_data[j - 1] - 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(bezierv.comb[i] * model.t[j]**i * (1 - model.t[j])**(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(bezierv.comb[i] * model.t[j]**i * (1 - model.t[j])**(n - i) * model.x[i] for i in model.N ) == data[j-1]
+        model.ctr_sample = pyo.Constraint(model.M , rule=data_sample_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] <= 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[n] >= data[-1]) 
+        # subject to last_control_z:
+        #    z[n] = 1;
+        model.last_control_z = pyo.Constraint(expr=model.z[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[m] == 1)
+
+        delta_z = 0.0001
+        delta_x = 0.5
+        # Left end: x1 ~= x0, z1 ~= z0
+        #model.end_close_z_left  = pyo.Constraint(expr = model.z[1] - model.z[0] <= delta_z)
+        #model.end_close_x_left  = pyo.Constraint(expr = model.x[1] - model.x[0] <= delta_x)
+
+        # Right end: xn ~= xn-1, zn ~= zn-1
+        #model.end_close_x_right = pyo.Constraint(expr = model.x[n] - model.x[n-1] <= delta_x)
+        #model.end_close_z_right = pyo.Constraint(expr = model.z[n] - model.z[n-1] <= delta_z)
+ 
+        # 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])
+                mse = model.mse()
+                bezierv.update_bezierv(controls_x, controls_z)
+        except Exception as e:
+            print("NonLinearSolver [fit]: An exception occurred during model evaluation:", e)
+
+        return bezierv, mse