bezierv 0.1.0__py3-none-any.whl

bezierv/algorithms/conv_bezierv.py

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

bezierv/algorithms/non_linear_solver.py

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