skfolio 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

skfolio/exceptions.py

@@ -12,6 +12,7 @@ __all__ = [
     "EquationToMatrixError",
     "GroupNotFoundError",
     "NonPositiveVarianceError",
+    "DuplicateGroupsError",
 ]
 
 
@@ -27,5 +28,9 @@ class GroupNotFoundError(Exception):
     """Group name not found in the groups"""
 
 
+class DuplicateGroupsError(Exception):
+    """Group name appear in multiple group levels"""
+
+
 class NonPositiveVarianceError(Exception):
     """Variance negative or null"""

skfolio/optimization/cluster/hierarchical/_base.py

@@ -52,8 +52,6 @@ class BaseHierarchicalOptimization(BaseOptimization, ABC):
             * ENTROPIC_RISK_MEASURE
             * FOURTH_CENTRAL_MOMENT
             * FOURTH_LOWER_PARTIAL_MOMENT
-            * SKEW
-            * KURTOSIS
 
         The default is `RiskMeasure.VARIANCE`.
 
@@ -80,12 +78,12 @@ class BaseHierarchicalOptimization(BaseOptimization, ABC):
 
     min_weights : float | dict[str, float] | array-like of shape (n_assets, ), default=0.0
         Minimum assets weights (weights lower bounds). Negative weights are not allowed.
-        If a float is provided, it is applied to each asset. `None` is equivalent to
-        `-np.Inf` (no lower bound). If a dictionary is provided, its (key/value) pair
-        must be the (asset name/asset minium weight) and the input `X` of the `fit`
-        methods must be a DataFrame with the assets names in columns. When using a
-        dictionary, assets values that are not provided are assigned a minimum weight
-        of `0.0`. The default is 0.0 (no short selling).
+        If a float is provided, it is applied to each asset.
+        If a dictionary is provided, its (key/value) pair must be the
+        (asset name/asset minium weight) and the input `X` of the `fit` methods must be
+        a DataFrame with the assets names in columns.
+        When using a dictionary, assets values that are not provided are assigned a
+        minimum weight of `0.0`. The default is 0.0 (no short selling).
 
         Example:
 
@@ -96,12 +94,12 @@ class BaseHierarchicalOptimization(BaseOptimization, ABC):
 
     max_weights : float | dict[str, float] | array-like of shape (n_assets, ), default=1.0
         Maximum assets weights (weights upper bounds). Weights above 1.0 are not
-        allowed. If a float is provided, it is applied to each asset. `None` is
-        equivalent to `+np.Inf` (no upper bound). If a dictionary is provided, its
-        (key/value) pair must be the (asset name/asset maximum weight) and the input `X`
-        of the `fit` method must be a DataFrame with the assets names in columns. When
-        using a dictionary, assets values that are not provided are assigned a minimum
-        weight of `1.0`. The default is 1.0 (each asset is below 100%).
+        allowed. If a float is provided, it is applied to each asset.
+        If a dictionary is provided, its (key/value) pair must be the
+        (asset name/asset maximum weight) and the input `X` of the `fit` method must be
+        a DataFrame with the assets names in columns.
+        When using a dictionary, assets values that are not provided are assigned a
+        minimum weight of `1.0`. The default is 1.0 (each asset is below 100%).
 
         Example:
 
@@ -388,57 +386,6 @@ class BaseHierarchicalOptimization(BaseOptimization, ABC):
 
         return min_weights, max_weights
 
-    @staticmethod
-    def _apply_weight_constraints_to_alpha(
-        alpha: float,
-        max_weights: np.ndarray,
-        min_weights: np.ndarray,
-        weights: np.ndarray,
-        left_cluster: np.ndarray,
-        right_cluster: np.ndarray,
-    ) -> float:
-        """Apply weight constraints to the alpha multiplication factor of the
-        Hierarchical Tree Clustering algorithm.
-
-        Parameters
-        ----------
-        alpha : float
-            The alpha multiplication factor of the Hierarchical Tree Clustering
-            algorithm.
-
-         min_weights : ndarray of shape (n_assets,)
-            The weight lower bound 1D array.
-
-        max_weights : ndarray of shape (n_assets,)
-            The weight upper bound 1D array.
-
-        weights : np.ndarray of shape (n_assets,)
-            The assets weights.
-
-        left_cluster : ndarray of shape (n_left_cluster,)
-            Indices of the left cluster weights.
-
-        right_cluster : ndarray of shape (n_right_cluster,)
-            Indices of the right cluster weights.
-
-        Returns
-        -------
-        value : float
-            The transformed alpha incorporating the weight constraints.
-        """
-        alpha = min(
-            np.sum(max_weights[left_cluster]) / weights[left_cluster[0]],
-            max(np.sum(min_weights[left_cluster]) / weights[left_cluster[0]], alpha),
-        )
-        alpha = 1 - min(
-            np.sum(max_weights[right_cluster]) / weights[right_cluster[0]],
-            max(
-                np.sum(min_weights[right_cluster]) / weights[right_cluster[0]],
-                1 - alpha,
-            ),
-        )
-        return alpha
-
     def get_metadata_routing(self):
         # noinspection PyTypeChecker
         router = (

skfolio/optimization/cluster/hierarchical/_herc.py

@@ -3,8 +3,7 @@
 # Copyright (c) 2023
 # Author: Hugo Delatte <delatte.hugo@gmail.com>
 # License: BSD 3 clause
-# The risk measure generalization and constraint features are derived
-# from Riskfolio-Lib, Copyright (c) 2020-2023, Dany Cajas, Licensed under BSD 3 clause.
+# Weight constraints is a novel implementation, see docstring for more details.
 
 import numpy as np
 import numpy.typing as npt
@@ -20,6 +19,7 @@ from skfolio.optimization.cluster.hierarchical._base import (
     BaseHierarchicalOptimization,
 )
 from skfolio.prior import BasePrior, EmpiricalPrior
+from skfolio.utils.stats import minimize_relative_weight_deviation
 from skfolio.utils.tools import check_estimator
 
 
@@ -45,6 +45,32 @@ class HierarchicalEqualRiskContribution(BaseHierarchicalOptimization):
         which is more stable and has better properties than the single-linkage
         method [4]_.
 
+        Also, the initial paper does not provide an algorithm for handling weight
+        constraints, and no standard solution currently exists.
+        In contrast to HRP (Hierarchical Risk Parity), where weight constraints
+        can be applied to the split factor at each bisection step, HERC
+        (Hierarchical Equal Risk Contribution) cannot incorporate weight constraints
+        during the intermediate steps of the allocation. Therefore, in HERC, the
+        weight constraints must be enforced after the top-down allocation has been
+        completed.
+        In skfolio, we minimize the relative deviation of the final weights from
+        the initial weights. This is formulated as a convex optimization problem:
+
+        .. math::
+            \begin{cases}
+            \begin{aligned}
+            &\min_{w} & & \Vert \frac{w - w_{init}}{w_{init}} \Vert_{2}^{2} \\
+            &\text{s.t.} & & \sum_{i=1}^{N} w_{i} = 1 \\
+            & & & w_{min} \leq w_i \leq w_{max}, \quad \forall i
+            \end{aligned}
+            \end{cases}
+
+        The reason for minimizing the relative deviation (as opposed to the absolute
+        deviation) is that we want to limit the impact on the risk contribution of
+        each asset. Since HERC allocates inversely to risk, adjusting the weights
+        based on relative deviation ensures that the assets' risk contributions
+        remain proportionally consistent with the initial allocation.
+
     Parameters
     ----------
     risk_measure : RiskMeasure or ExtraRiskMeasure, default=RiskMeasure.VARIANCE
@@ -70,8 +96,6 @@ class HierarchicalEqualRiskContribution(BaseHierarchicalOptimization):
             * ENTROPIC_RISK_MEASURE
             * FOURTH_CENTRAL_MOMENT
             * FOURTH_LOWER_PARTIAL_MOMENT
-            * SKEW
-            * KURTOSIS
 
         The default is `RiskMeasure.VARIANCE`.
 
@@ -98,12 +122,12 @@ class HierarchicalEqualRiskContribution(BaseHierarchicalOptimization):
 
     min_weights : float | dict[str, float] | array-like of shape (n_assets, ), default=0.0
         Minimum assets weights (weights lower bounds). Negative weights are not allowed.
-        If a float is provided, it is applied to each asset. `None` is equivalent to
-        `-np.Inf` (no lower bound). If a dictionary is provided, its (key/value) pair
-        must be the (asset name/asset minium weight) and the input `X` of the `fit`
-        methods must be a DataFrame with the assets names in columns. When using a
-        dictionary, assets values that are not provided are assigned a minimum weight
-        of `0.0`. The default is 0.0 (no short selling).
+        If a float is provided, it is applied to each asset.
+        If a dictionary is provided, its (key/value) pair must be the
+        (asset name/asset minium weight) and the input `X` of the `fit` methods must be
+        a DataFrame with the assets names in columns.
+        When using a dictionary, assets values that are not provided are assigned a
+        minimum weight of `0.0`. The default is 0.0 (no short selling).
 
         Example:
 
@@ -114,12 +138,12 @@ class HierarchicalEqualRiskContribution(BaseHierarchicalOptimization):
 
     max_weights : float | dict[str, float] | array-like of shape (n_assets, ), default=1.0
         Maximum assets weights (weights upper bounds). Weights above 1.0 are not
-        allowed. If a float is provided, it is applied to each asset. `None` is
-        equivalent to `+np.Inf` (no upper bound). If a dictionary is provided, its
-        (key/value) pair must be the (asset name/asset maximum weight) and the input `X`
-        of the `fit` method must be a DataFrame with the assets names in columns. When
-        using a dictionary, assets values that are not provided are assigned a minimum
-        weight of `1.0`. The default is 1.0 (each asset is below 100%).
+        allowed. If a float is provided, it is applied to each asset.
+        If a dictionary is provided, its (key/value) pair must be the
+        (asset name/asset maximum weight) and the input `X` of the `fit` method must be
+        a DataFrame with the assets names in columns.
+        When using a dictionary, assets values that are not provided are assigned a
+        minimum weight of `1.0`. The default is 1.0 (each asset is below 100%).
 
         Example:
 
@@ -208,6 +232,19 @@ class HierarchicalEqualRiskContribution(BaseHierarchicalOptimization):
         `management_fees`, `previous_weights` and `risk_free_rate` are copied from the
         optimization model and passed to the portfolio.
 
+    solver : str, default="CLARABEL"
+        The solver used for the weights constraints optimization. The default is
+        "CLARABEL" which is written in Rust and has better numerical stability and
+        performance than ECOS and SCS.
+        For more details about available solvers, check the CVXPY documentation:
+        https://www.cvxpy.org/tutorial/advanced/index.html#choosing-a-solver
+
+    solver_params : dict, optional
+        Solver parameters. For example, `solver_params=dict(verbose=True)`.
+        The default (`None`) is to use the CVXPY default.
+        For more details about solver arguments, check the CVXPY documentation:
+        https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options
+
     Attributes
     ----------
     weights_ : ndarray of shape (n_assets,)
@@ -251,6 +288,8 @@ class HierarchicalEqualRiskContribution(BaseHierarchicalOptimization):
         hierarchical_clustering_estimator: HierarchicalClustering | None = None,
         min_weights: skt.MultiInput | None = 0.0,
         max_weights: skt.MultiInput | None = 1.0,
+        solver: str = "CLARABEL",
+        solver_params: dict | None = None,
         transaction_costs: skt.MultiInput = 0.0,
         management_fees: skt.MultiInput = 0.0,
         previous_weights: skt.MultiInput | None = None,
@@ -268,6 +307,8 @@ class HierarchicalEqualRiskContribution(BaseHierarchicalOptimization):
             previous_weights=previous_weights,
             portfolio_params=portfolio_params,
         )
+        self.solver = solver
+        self.solver_params = solver_params
 
     def fit(
         self, X: npt.ArrayLike, y: None = None, **fit_params
@@ -301,6 +342,13 @@ class HierarchicalEqualRiskContribution(BaseHierarchicalOptimization):
             raise TypeError(
                 "`risk_measure` must be of type `RiskMeasure` or `ExtraRiskMeasure`"
             )
+
+        if self.risk_measure in [ExtraRiskMeasure.SKEW, ExtraRiskMeasure.KURTOSIS]:
+            # Because Skew and Kurtosis can take negative values
+            raise ValueError(
+                f"risk_measure {self.risk_measure} currently not supported" f"in HERC"
+            )
+
         self.prior_estimator_ = check_estimator(
             self.prior_estimator,
             default=EmpiricalPrior(),
@@ -393,21 +441,12 @@ class HierarchicalEqualRiskContribution(BaseHierarchicalOptimization):
 
             left_cluster = np.array(left_cluster)
             right_cluster = np.array(right_cluster)
+
             left_risk = np.sum(cluster_risks[left_cluster])
             right_risk = np.sum(cluster_risks[right_cluster])
 
             alpha = 1 - left_risk / (left_risk + right_risk)
 
-            # Weights constraints
-            alpha = self._apply_weight_constraints_to_alpha(
-                alpha=alpha,
-                weights=weights,
-                max_weights=max_weights,
-                min_weights=min_weights,
-                left_cluster=left_cluster,
-                right_cluster=right_cluster,
-            )
-
             clusters_weights[left_cluster] *= alpha
             clusters_weights[right_cluster] *= 1 - alpha
 
@@ -421,5 +460,15 @@ class HierarchicalEqualRiskContribution(BaseHierarchicalOptimization):
         for i, cluster_ids in enumerate(clusters):
             weights[cluster_ids] *= clusters_weights[i]
 
+        # Apply weights constraints
+        weights = minimize_relative_weight_deviation(
+            weights=weights,
+            min_weights=min_weights,
+            max_weights=max_weights,
+            solver=self.solver,
+            solver_params=self.solver_params,
+        )
+
         self.weights_ = weights
+
         return self

skfolio/optimization/cluster/hierarchical/_hrp.py

@@ -72,8 +72,6 @@ class HierarchicalRiskParity(BaseHierarchicalOptimization):
             * ENTROPIC_RISK_MEASURE
             * FOURTH_CENTRAL_MOMENT
             * FOURTH_LOWER_PARTIAL_MOMENT
-            * SKEW
-            * KURTOSIS
 
         The default is `RiskMeasure.VARIANCE`.
 
@@ -100,9 +98,9 @@ class HierarchicalRiskParity(BaseHierarchicalOptimization):
 
     min_weights : float | dict[str, float] | array-like of shape (n_assets, ), default=0.0
         Minimum assets weights (weights lower bounds). Negative weights are not allowed.
-        If a float is provided, it is applied to each asset. `None` is equivalent to
-        `-np.Inf` (no lower bound). If a dictionary is provided, its (key/value) pair
-        must be the (asset name/asset minium weight) and the input `X` of the `fit`
+        If a float is provided, it is applied to each asset.
+        If a dictionary is provided, its (key/value) pair must be the
+        (asset name/asset minium weight) and the input `X` of the `fit`
         methods must be a DataFrame with the assets names in columns. When using a
         dictionary, assets values that are not provided are assigned a minimum weight
         of `0.0`. The default is 0.0 (no short selling).
@@ -116,12 +114,12 @@ class HierarchicalRiskParity(BaseHierarchicalOptimization):
 
     max_weights : float | dict[str, float] | array-like of shape (n_assets, ), default=1.0
         Maximum assets weights (weights upper bounds). Weights above 1.0 are not
-        allowed. If a float is provided, it is applied to each asset. `None` is
-        equivalent to `+np.Inf` (no upper bound). If a dictionary is provided, its
-        (key/value) pair must be the (asset name/asset maximum weight) and the input `X`
-        of the `fit` method must be a DataFrame with the assets names in columns. When
-        using a dictionary, assets values that are not provided are assigned a minimum
-        weight of `1.0`. The default is 1.0 (each asset is below 100%).
+        allowed. If a float is provided, it is applied to each asset.
+        If a dictionary is provided, its (key/value) pair must be the
+        (asset name/asset maximum weight) and the input `X` of the `fit` method must
+        be a DataFrame with the assets names in columns.
+        When using a dictionary, assets values that are not provided are assigned a
+        minimum weight of `1.0`. The default is 1.0 (each asset is below 100%).
 
         Example:
 
@@ -296,6 +294,13 @@ class HierarchicalRiskParity(BaseHierarchicalOptimization):
             raise TypeError(
                 "`risk_measure` must be of type `RiskMeasure` or `ExtraRiskMeasure`"
             )
+
+        if self.risk_measure in [ExtraRiskMeasure.SKEW, ExtraRiskMeasure.KURTOSIS]:
+            # Because Skew and Kurtosis can take negative values
+            raise ValueError(
+                f"risk_measure {self.risk_measure} currently not supported" f"in HRP"
+            )
+
         self.prior_estimator_ = check_estimator(
             self.prior_estimator,
             default=EmpiricalPrior(),
@@ -365,7 +370,7 @@ class HierarchicalRiskParity(BaseHierarchicalOptimization):
                 left_cluster, right_cluster = clusters_ids
                 alpha = 1 - left_risk / (left_risk + right_risk)
                 # Weights constraints
-                alpha = self._apply_weight_constraints_to_alpha(
+                alpha = _apply_weight_constraints_to_split_factor(
                     alpha=alpha,
                     weights=weights,
                     max_weights=max_weights,
@@ -379,3 +384,54 @@ class HierarchicalRiskParity(BaseHierarchicalOptimization):
 
         self.weights_ = weights
         return self
+
+
+def _apply_weight_constraints_to_split_factor(
+    alpha: float,
+    max_weights: np.ndarray,
+    min_weights: np.ndarray,
+    weights: np.ndarray,
+    left_cluster: np.ndarray,
+    right_cluster: np.ndarray,
+) -> float:
+    """
+    Apply weight constraints to the split factor alpha of the ,Hierarchical Tree
+    Clustering algorithm.
+
+    Parameters
+    ----------
+    alpha : float
+        The split factor alpha of the Hierarchical Tree Clustering algorithm.
+
+    min_weights : ndarray of shape (n_assets,)
+        The weight lower bound 1D array.
+
+    max_weights : ndarray of shape (n_assets,)
+        The weight upper bound 1D array.
+
+    weights : np.ndarray of shape (n_assets,)
+        The assets weights.
+
+    left_cluster : ndarray of shape (n_left_cluster,)
+        Indices of the left cluster weights.
+
+    right_cluster : ndarray of shape (n_right_cluster,)
+        Indices of the right cluster weights.
+
+    Returns
+    -------
+    value : float
+        The transformed split factor alpha incorporating the weight constraints.
+    """
+    alpha = min(
+        np.sum(max_weights[left_cluster]) / weights[left_cluster[0]],
+        max(np.sum(min_weights[left_cluster]) / weights[left_cluster[0]], alpha),
+    )
+    alpha = 1 - min(
+        np.sum(max_weights[right_cluster]) / weights[right_cluster[0]],
+        max(
+            np.sum(min_weights[right_cluster]) / weights[right_cluster[0]],
+            1 - alpha,
+        ),
+    )
+    return alpha

skfolio/optimization/convex/_base.py

@@ -290,7 +290,7 @@ class ConvexOptimization(BaseOptimization, ABC):
 
            * "2.5 * ref1 + 0.10 * ref2 + 0.0013 <= 2.5 * ref3"
            * "ref1 >= 2.9 * ref2"
-           * "ref1 <= ref2"
+           * "ref1 == ref2"
            * "ref1 >= ref1"
 
         With "ref1", "ref2" ... the assets names or the groups names provided
@@ -302,8 +302,8 @@ class ConvexOptimization(BaseOptimization, ABC):
 
             * "SPX >= 0.10" --> SPX weight must be greater than 10% (note that you can also use `min_weights`)
             * "SX5E + TLT >= 0.2" --> the sum of SX5E and TLT weights must be greater than 20%
-            * "US >= 0.7" --> the sum of all US weights must be greater than 70%
-            * "Equity <= 3 * Bond" --> the sum of all Equity weights must be less or equal to 3 times the sum of all Bond weights.
+            * "US == 0.7" --> the sum of all US weights must be equal to 70%
+            * "Equity == 3 * Bond" --> the sum of all Equity weights must be equal to 3 times the sum of all Bond weights.
             * "2*SPX + 3*Europe <= Bond + 0.05" --> mixing assets and group constraints
 
     groups : dict[str, list[str]] or array-like of shape (n_groups, n_assets), optional
@@ -733,15 +733,21 @@ class ConvexOptimization(BaseOptimization, ABC):
                     ),
                     name="groups",
                 )
-            a, b = equations_to_matrix(
+            a_eq, b_eq, a_ineq, b_ineq = equations_to_matrix(
                 groups=groups,
                 equations=self.linear_constraints,
                 raise_if_group_missing=False,
             )
-            if np.any(a != 0):
+            if len(a_eq) != 0:
                 constraints.append(
-                    a @ w * self._scale_constraints
-                    - b * factor * self._scale_constraints
+                    a_eq @ w * self._scale_constraints
+                    - b_eq * factor * self._scale_constraints
+                    == 0
+                )
+            if len(a_ineq) != 0:
+                constraints.append(
+                    a_ineq @ w * self._scale_constraints
+                    - b_ineq * factor * self._scale_constraints
                     <= 0
                 )
 

skfolio/optimization/convex/_distributionally_robust.py

@@ -125,7 +125,7 @@ class DistributionallyRobustCVaR(ConvexOptimization):
 
            * "2.5 * ref1 + 0.10 * ref2 + 0.0013 <= 2.5 * ref3"
            * "ref1 >= 2.9 * ref2"
-           * "ref1 <= ref2"
+           * "ref1 == ref2"
            * "ref1 >= ref1"
 
         With "ref1", "ref2" ... the assets names or the groups names provided
@@ -137,8 +137,8 @@ class DistributionallyRobustCVaR(ConvexOptimization):
 
             * "SPX >= 0.10" --> SPX weight must be greater than 10% (note that you can also use `min_weights`)
             * "SX5E + TLT >= 0.2" --> the sum of SX5E and TLT weights must be greater than 20%
-            * "US >= 0.7" --> the sum of all US weights must be greater than 70%
-            * "Equity <= 3 * Bond" --> the sum of all Equity weights must be less or equal to 3 times the sum of all Bond weights.
+            * "US == 0.7" --> the sum of all US weights must be equal to 70%
+            * "Equity == 3 * Bond" --> the sum of all Equity weights must be equal to 3 times the sum of all Bond weights.
             * "2*SPX + 3*Europe <= Bond + 0.05" --> mixing assets and group constraints
 
     groups : dict[str, list[str]] or array-like of shape (n_groups, n_assets), optional

skfolio/optimization/convex/_maximum_diversification.py

@@ -201,7 +201,7 @@ class MaximumDiversification(MeanRisk):
 
            * "2.5 * ref1 + 0.10 * ref2 + 0.0013 <= 2.5 * ref3"
            * "ref1 >= 2.9 * ref2"
-           * "ref1 <= ref2"
+           * "ref1 == ref2"
            * "ref1 >= ref1"
 
         With "ref1", "ref2" ... the assets names or the groups names provided
@@ -213,8 +213,8 @@ class MaximumDiversification(MeanRisk):
 
             * "SPX >= 0.10" --> SPX weight must be greater than 10% (note that you can also use `min_weights`)
             * "SX5E + TLT >= 0.2" --> the sum of SX5E and TLT weights must be greater than 20%
-            * "US >= 0.7" --> the sum of all US weights must be greater than 70%
-            * "Equity <= 3 * Bond" --> the sum of all Equity weights must be less or equal to 3 times the sum of all Bond weights.
+            * "US == 0.7" --> the sum of all US weights must be equal to 70%
+            * "Equity == 3 * Bond" --> the sum of all Equity weights must be equal to 3 times the sum of all Bond weights.
             * "2*SPX + 3*Europe <= Bond + 0.05" --> mixing assets and group constraints
 
     groups : dict[str, list[str]] or array-like of shape (n_groups, n_assets), optional

skfolio/optimization/convex/_mean_risk.py

@@ -334,7 +334,7 @@ class MeanRisk(ConvexOptimization):
 
            * "2.5 * ref1 + 0.10 * ref2 + 0.0013 <= 2.5 * ref3"
            * "ref1 >= 2.9 * ref2"
-           * "ref1 <= ref2"
+           * "ref1 == ref2"
            * "ref1 >= ref1"
 
         With "ref1", "ref2" ... the assets names or the groups names provided
@@ -346,8 +346,8 @@ class MeanRisk(ConvexOptimization):
 
             * "SPX >= 0.10" --> SPX weight must be greater than 10% (note that you can also use `min_weights`)
             * "SX5E + TLT >= 0.2" --> the sum of SX5E and TLT weights must be greater than 20%
-            * "US >= 0.7" --> the sum of all US weights must be greater than 70%
-            * "Equity <= 3 * Bond" --> the sum of all Equity weights must be less or equal to 3 times the sum of all Bond weights.
+            * "US == 0.7" --> the sum of all US weights must be equal to 70%
+            * "Equity == 3 * Bond" --> the sum of all Equity weights must be equal to 3 times the sum of all Bond weights.
             * "2*SPX + 3*Europe <= Bond + 0.05" --> mixing assets and group constraints
 
     groups : dict[str, list[str]] or array-like of shape (n_groups, n_assets), optional

skfolio/optimization/convex/_risk_budgeting.py

@@ -212,12 +212,12 @@ class RiskBudgeting(ConvexOptimization):
         The default (`None`) means no previous weights.
 
     linear_constraints : array-like of shape (n_constraints,), optional
-       Linear constraints.
+        Linear constraints.
         The linear constraints must match any of following patterns:
 
            * "2.5 * ref1 + 0.10 * ref2 + 0.0013 <= 2.5 * ref3"
            * "ref1 >= 2.9 * ref2"
-           * "ref1 <= ref2"
+           * "ref1 == ref2"
            * "ref1 >= ref1"
 
         With "ref1", "ref2" ... the assets names or the groups names provided
@@ -229,8 +229,8 @@ class RiskBudgeting(ConvexOptimization):
 
             * "SPX >= 0.10" --> SPX weight must be greater than 10% (note that you can also use `min_weights`)
             * "SX5E + TLT >= 0.2" --> the sum of SX5E and TLT weights must be greater than 20%
-            * "US >= 0.7" --> the sum of all US weights must be greater than 70%
-            * "Equity <= 3 * Bond" --> the sum of all Equity weights must be less or equal to 3 times the sum of all Bond weights.
+            * "US == 0.7" --> the sum of all US weights must be equal to 70%
+            * "Equity == 3 * Bond" --> the sum of all Equity weights must be equal to 3 times the sum of all Bond weights.
             * "2*SPX + 3*Europe <= Bond + 0.05" --> mixing assets and group constraints
 
     groups : dict[str, list[str]] or array-like of shape (n_groups, n_assets), optional

skfolio/prior/_black_litterman.py

@@ -208,7 +208,7 @@ class BlackLitterman(BasePrior):
                 ),
                 name="groups",
             )
-        self.picking_matrix_, self.views_ = equations_to_matrix(
+        self.picking_matrix_, self.views_, a_ineq, b_ineq = equations_to_matrix(
             groups=self.groups_,
             equations=views,
             sum_to_one=True,
@@ -216,6 +216,9 @@ class BlackLitterman(BasePrior):
             names=("groups", "views"),
         )
 
+        if len(a_ineq) != 0:
+            raise ValueError("Inequalities (<=, >=) are not supported in views")
+
         if self.view_confidences is None:
             omega = np.diag(
                 np.diag(

skfolio/utils/equations.py

@@ -10,10 +10,24 @@ import warnings
 import numpy as np
 import numpy.typing as npt
 
-from skfolio.exceptions import EquationToMatrixError, GroupNotFoundError
+from skfolio.exceptions import (
+    DuplicateGroupsError,
+    EquationToMatrixError,
+    GroupNotFoundError,
+)
 
 __all__ = ["equations_to_matrix"]
 
+_EQUALITY_OPERATORS = {"==", "="}
+_INEQUALITY_OPERATORS = {">=", "<="}
+_COMPARISON_OPERATORS = _EQUALITY_OPERATORS.union(_INEQUALITY_OPERATORS)
+_SUB_ADD_OPERATORS = {"-", "+"}
+_MUL_OPERATORS = {"*"}
+_NON_MUL_OPERATORS = _COMPARISON_OPERATORS.union(_SUB_ADD_OPERATORS)
+_OPERATORS = _NON_MUL_OPERATORS.union(_MUL_OPERATORS)
+_COMPARISON_OPERATOR_SIGNS = {">=": -1, "<=": 1, "==": 1, "=": 1}
+_SUB_ADD_OPERATOR_SIGNS = {"+": 1, "-": -1}
+
 
 def equations_to_matrix(
     groups: npt.ArrayLike,
@@ -21,9 +35,9 @@ def equations_to_matrix(
     sum_to_one: bool = False,
     raise_if_group_missing: bool = False,
     names: tuple[str, str] = ("groups", "equations"),
-) -> tuple[np.ndarray, np.ndarray]:
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
     """Convert a list of linear equations into the left and right matrices of the
-    inequality A <= B.
+    inequality A <= B and equality A == B.
 
     Parameters
     ----------
@@ -44,9 +58,9 @@ def equations_to_matrix(
 
          Example of valid equation patterns:
             * "number_1 * group_1 + number_3 <= number_4 * group_3 + number_5"
-            * "group_1 >= number * group_2"
+            * "group_1 == number * group_2"
             * "group_1 <= number"
-            * "group_1 >= number"
+            * "group_1 == number"
 
         "group_1" and "group_2" are the group names defined in `groups`.
         The second expression means that the sum of all assets in "group_1" should be
@@ -57,8 +71,8 @@ def equations_to_matrix(
                 "Equity <= 3 * Bond",
                 "US >= 1.5",
                 "Europe >= 0.5 * Japan",
-                "Japan <= 1",
-                "3*SPX + 5*SX5E <= 2*TLT + 3",
+                "Japan == 1",
+                "3*SPX + 5*SX5E == 2*TLT + 3",
             ]
 
     sum_to_one : bool
@@ -76,41 +90,104 @@ def equations_to_matrix(
 
     Returns
     -------
-    left: ndarray of shape (n_equations, n_assets)
-    right: ndarray of shape (n_equations,)
+    left_equality: ndarray of shape (n_equations_equality, n_assets)
+    right_equality: ndarray of shape (n_equations_equality,)
         The left and right matrices of the inequality A <= B.
-        If none of the group inside the equations are part of the groups, `None` is
-        returned.
+
+    left_inequality: ndarray of shape (n_equations_inequality, n_assets)
+    right_inequality: ndarray of shape (n_equations_inequality,)
+        The left and right matrices of the equality A == B.
     """
-    groups = np.asarray(groups)
-    equations = np.asarray(equations)
-    if groups.ndim != 2:
-        raise ValueError(
-            f"`{names[0]}` must be a 2D array, got {groups.ndim}D array instead."
-        )
-    if equations.ndim != 1:
-        raise ValueError(
-            f"`{names[1]}` must be a 1D array, got {equations.ndim}D array instead."
-        )
+    groups = _validate_groups(groups, name=names[0])
+    equations = _validate_equations(equations, name=names[1])
+
+    a_equality = []
+    b_equality = []
+
+    a_inequality = []
+    b_inequality = []
 
-    n_equations = len(equations)
-    n_assets = groups.shape[1]
-    a = np.zeros((n_equations, n_assets))
-    b = np.zeros(n_equations)
-    for i, string in enumerate(equations):
+    for string in equations:
         try:
-            left, right = _string_to_equation(
+            left, right, is_inequality = _string_to_equation(
                 groups=groups,
                 string=string,
                 sum_to_one=sum_to_one,
             )
-            a[i] = left
-            b[i] = right
+            if is_inequality:
+                a_inequality.append(left)
+                b_inequality.append(right)
+            else:
+                a_equality.append(left)
+                b_equality.append(right)
         except GroupNotFoundError as e:
             if raise_if_group_missing:
                 raise
             warnings.warn(str(e), stacklevel=2)
-    return a, b
+    return (
+        np.array(a_equality),
+        np.array(b_equality),
+        np.array(a_inequality),
+        np.array(b_inequality),
+    )
+
+
+def _validate_groups(groups: npt.ArrayLike, name: str = "groups") -> np.ndarray:
+    """Validate groups by checking its dim and if group names don't appear in multiple
+    levels and convert to numpy array.
+
+    Parameters
+    ----------
+    groups : array-like of shape (n_groups, n_assets)
+        2D-array of strings.
+
+    Returns
+    -------
+    groups : ndarray of shape (n_groups, n_assets)
+        2D-array of strings.
+    """
+    groups = np.asarray(groups)
+    if groups.ndim != 2:
+        raise ValueError(
+            f"`{name} must be a 2D array, got {groups.ndim}D array instead."
+        )
+    n = len(groups)
+    group_sets = [set(groups[i]) for i in range(n)]
+    for i in range(n - 1):
+        for e in group_sets[i]:
+            for j in range(i + 1, n):
+                if e in group_sets[j]:
+                    raise DuplicateGroupsError(
+                        f"'{e}' appear in two levels: {list(groups[i])} "
+                        f"and {list(groups[i])}. "
+                        f"{name} must be in only one level."
+                    )
+
+    return groups
+
+
+def _validate_equations(
+    equations: npt.ArrayLike, name: str = "equations"
+) -> np.ndarray:
+    """Validate equations by checking its dim and convert to numpy array.
+
+    Parameters
+    ----------
+    equations : array-like of shape (n_equations,)
+        1D array of equations.
+
+    Returns
+    -------
+    equations : ndarray of shape (n_equations,)
+        1D array of equations.
+    """
+    equations = np.asarray(equations)
+
+    if equations.ndim != 1:
+        raise ValueError(
+            f"`{name}` must be a 1D array, got {equations.ndim}D array instead."
+        )
+    return equations
 
 
 def _matching_array(values: np.ndarray, key: str, sum_to_one: bool) -> np.ndarray:
@@ -145,11 +222,7 @@ def _matching_array(values: np.ndarray, key: str, sum_to_one: bool) -> np.ndarra
     return arr / s
 
 
-_operator_mapping = {">=": -1, "<=": 1, "==": 1, "=": 1}
-_operator_signs = {"+": 1, "-": -1}
-
-
-def _inequality_operator_sign(operator: str) -> int:
+def _comparison_operator_sign(operator: str) -> int:
     """Convert the operators '>=', "==" and '<=' into the corresponding integer
     values -1, 1 and 1, respectively.
 
@@ -164,14 +237,14 @@ def _inequality_operator_sign(operator: str) -> int:
         Operator sign: 1 or -1.
     """
     try:
-        return _operator_mapping[operator]
+        return _COMPARISON_OPERATOR_SIGNS[operator]
     except KeyError:
         raise EquationToMatrixError(
             f"operator '{operator}' is not valid. It should be '<=' or '>='"
         ) from None
 
 
-def _operator_sign(operator: str) -> int:
+def _sub_add_operator_sign(operator: str) -> int:
     """Convert the operators '+' and '-' into 1 or -1
 
     Parameters
@@ -185,7 +258,7 @@ def _operator_sign(operator: str) -> int:
        Operator sign: 1 or -1.
     """
     try:
-        return _operator_signs[operator]
+        return _SUB_ADD_OPERATOR_SIGNS[operator]
     except KeyError:
         raise EquationToMatrixError(
             f"operator '{operator}' is not valid. It should be be '+' or '-'"
@@ -211,13 +284,41 @@ def _string_to_float(string: str) -> float:
         raise EquationToMatrixError(f"Unable to convert {string} into float") from None
 
 
+def _split_equation_string(string: str) -> list[str]:
+    """Split an equation strings by operators"""
+    comp_pattern = "(?=" + "|".join([".+\\" + e for e in _COMPARISON_OPERATORS]) + ")"
+    if not bool(re.match(comp_pattern, string)):
+        raise EquationToMatrixError(
+            f"The string must contains a comparison operator: "
+            f"{list(_COMPARISON_OPERATORS)}"
+        )
+
+    # Regex to match only '>' and '<' but not '<=' or '>='
+    invalid_pattern = r"(?<!<)(?<!<=)>(?!=)|(?<!>)<(?!=)"
+    invalid_matches = re.findall(invalid_pattern, string)
+
+    if len(invalid_matches) > 0:
+        raise EquationToMatrixError(
+            f"{invalid_matches[0]} is an invalid comparison operator. "
+            f"Valid comparison operators are: {list(_COMPARISON_OPERATORS)}"
+        )
+
+    # '==' needs to be before '='
+    operators = sorted(_OPERATORS, reverse=True)
+    pattern = "((?:" + "|".join(["\\" + e for e in operators]) + "))"
+    res = [x.strip() for x in re.split(pattern, string)]
+    res = [x for x in res if x != ""]
+    return res
+
+
 def _string_to_equation(
     groups: np.ndarray,
     string: str,
     sum_to_one: bool,
-) -> tuple[np.ndarray, float]:
+) -> tuple[np.ndarray, float, bool]:
     """Convert a string to a left 1D-array and right float of the form:
-    `groups @ left <= right`.
+    `groups @ left <= right` or `groups @ left == right` and return whether it's an
+    equality or inequality.
 
     Parameters
     ----------
@@ -232,20 +333,14 @@ def _string_to_equation(
 
     Returns
     -------
-    left: 1D-array of shape (n_assets,)
-    right: float
+    left : 1D-array of shape (n_assets,)
+    right : float
+    is_inequality : bool
     """
     n = groups.shape[1]
-    operators = ["-", "+", "*", ">=", "<=", "==", "="]
-    invalid_operators = [">", "<"]
-    pattern = re.compile(r"((?:" + "|\\".join(operators) + r"))")
-    invalid_pattern = re.compile(r"((?:" + "|\\".join(invalid_operators) + r"))")
     err_msg = f"Wrong pattern encountered while converting the string '{string}'"
 
-    res = re.split(pattern, string)
-    res = [x.strip() for x in res]
-    res = [x for x in res if x != ""]
-    iterator = iter(res)
+    iterator = iter(_split_equation_string(string))
     group_names = set(groups.flatten())
 
     def is_group(name: str) -> bool:
@@ -254,7 +349,8 @@ def _string_to_equation(
     left = np.zeros(n)
     right = 0
     main_sign = 1
-    inequality_sign = None
+    comparison_sign = None
+    is_inequality = None
     e = next(iterator, None)
     i = 0
     while True:
@@ -264,23 +360,27 @@ def _string_to_equation(
         if e is None:
             break
         sign = 1
-        if e in [">=", "<=", "==", "="]:
+        if e in _COMPARISON_OPERATORS:
+            if e in _INEQUALITY_OPERATORS:
+                is_inequality = True
+            else:
+                is_inequality = False
             main_sign = -1
-            inequality_sign = _inequality_operator_sign(e)
+            comparison_sign = _comparison_operator_sign(e)
             e = next(iterator, None)
-            if e in ["-", "+"]:
-                sign *= _operator_sign(e)
+            if e in _SUB_ADD_OPERATORS:
+                sign *= _sub_add_operator_sign(e)
                 e = next(iterator, None)
-        elif e in ["-", "+"]:
-            sign *= _operator_sign(e)
+        elif e in _SUB_ADD_OPERATORS:
+            sign *= _sub_add_operator_sign(e)
             e = next(iterator, None)
-        elif e == "*":
+        elif e in _MUL_OPERATORS:
             raise EquationToMatrixError(
                 f"{err_msg}: the character '{e}' is wrongly positioned"
             )
         sign *= main_sign
         # next can only be a number or a group
-        if e is None or e in operators:
+        if e is None or e in _OPERATORS:
             raise EquationToMatrixError(
                 f"{err_msg}: the character '{e}' is wrongly positioned"
             )
@@ -288,20 +388,14 @@ def _string_to_equation(
             arr = _matching_array(values=groups, key=e, sum_to_one=sum_to_one)
             # next can only be a '*' or an ['-', '+', '>=', '<=', '==', '='] or None
             e = next(iterator, None)
-            if e is None or e in ["-", "+", ">=", "<=", "==", "="]:
+            if e is None or e in _NON_MUL_OPERATORS:
                 left += sign * arr
-            elif e == "*":
+            elif e in _MUL_OPERATORS:
                 # next can only a number
                 e = next(iterator, None)
                 try:
                     number = float(e)
                 except ValueError:
-                    invalid_ops = invalid_pattern.findall(e)
-                    if len(invalid_ops) > 0:
-                        raise EquationToMatrixError(
-                            f"{invalid_ops[0]} is an invalid operator. Valid operators"
-                            f" are: {operators}"
-                        ) from None
                     raise GroupNotFoundError(
                         f"{err_msg}: the group '{e}' is missing from the groups"
                         f" {groups}"
@@ -317,18 +411,12 @@ def _string_to_equation(
             try:
                 number = float(e)
             except ValueError:
-                invalid_ops = invalid_pattern.findall(e)
-                if len(invalid_ops) > 0:
-                    raise EquationToMatrixError(
-                        f"{invalid_ops[0]} is an invalid operator. Valid operators are:"
-                        f" {operators}"
-                    ) from None
                 raise GroupNotFoundError(
                     f"{err_msg}: the group '{e}' is missing from the groups {groups}"
                 ) from None
             # next can only be a '*' or an operator or None
             e = next(iterator, None)
-            if e == "*":
+            if e in _MUL_OPERATORS:
                 # next can only a group
                 e = next(iterator, None)
                 if not is_group(e):
@@ -338,14 +426,14 @@ def _string_to_equation(
                 arr = _matching_array(values=groups, key=e, sum_to_one=sum_to_one)
                 left += number * sign * arr
                 e = next(iterator, None)
-            elif e is None or e in ["-", "+", ">=", "<=", "==", "="]:
+            elif e is None or e in _NON_MUL_OPERATORS:
                 right += number * sign
             else:
                 raise EquationToMatrixError(
                     f"{err_msg}: the character '{e}' is wrongly positioned"
                 )
 
-    left *= inequality_sign
-    right *= -inequality_sign
+    left *= comparison_sign
+    right *= -comparison_sign
 
-    return left, right
+    return left, right, is_inequality

skfolio/utils/stats.py

@@ -10,9 +10,11 @@ import warnings
 # Statsmodels, Copyright (C) 2006, Jonathan E. Taylor, Licensed under BSD 3 clause.
 from enum import auto
 
+import cvxpy as cp
 import numpy as np
 import scipy.cluster.hierarchy as sch
 import scipy.optimize as sco
+import scipy.sparse.linalg as scl
 import scipy.spatial.distance as scd
 import scipy.special as scs
 from scipy.sparse import csr_matrix
@@ -34,6 +36,7 @@ __all__ = [
     "compute_optimal_n_clusters",
     "rand_weights",
     "rand_weights_dirichlet",
+    "minimize_relative_weight_deviation",
 ]
 
 
@@ -488,3 +491,87 @@ def compute_optimal_n_clusters(distance: np.ndarray, linkage_matrix: np.ndarray)
     # k=0 represents one cluster
     k = np.argmax(gaps) + 2
     return k
+
+
+def minimize_relative_weight_deviation(
+    weights: np.ndarray,
+    min_weights: np.ndarray,
+    max_weights: np.ndarray,
+    solver: str = "CLARABEL",
+    solver_params: dict | None = None,
+) -> np.ndarray:
+    r"""
+    Apply weight constraints to an initial array of weights by minimizing the relative
+    weight deviation of the final weights from the initial weights.
+
+    .. math::
+            \begin{cases}
+            \begin{aligned}
+            &\min_{w} & & \Vert \frac{w - w_{init}}{w_{init}} \Vert_{2}^{2} \\
+            &\text{s.t.} & & \sum_{i=1}^{N} w_{i} = 1 \\
+            & & & w_{min} \leq w_i \leq w_{max}, \quad \forall i
+            \end{aligned}
+            \end{cases}
+
+    Parameters
+    ----------
+    weights : ndarray of shape (n_assets,)
+        Initial weights.
+
+    min_weights : ndarray of shape (n_assets,)
+        Minimum assets weights (weights lower bounds).
+
+    max_weights : ndarray of shape (n_assets,)
+        Maximum assets weights (weights upper bounds).
+
+    solver : str, default="CLARABEL"
+        The solver to use. The default is "CLARABEL" which is written in Rust and has
+        better numerical stability and performance than ECOS and SCS.
+        For more details about available solvers, check the CVXPY documentation:
+        https://www.cvxpy.org/tutorial/advanced/index.html#choosing-a-solver
+
+    solver_params : dict, optional
+        Solver parameters. For example, `solver_params=dict(verbose=True)`.
+        The default (`None`) is to use the CVXPY default.
+        For more details about solver arguments, check the CVXPY documentation:
+        https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options
+    """
+    if not (weights.shape == min_weights.shape == max_weights.shape):
+        raise ValueError("`min_weights` and `max_weights` must have same size")
+
+    if np.any(weights < 0):
+        raise ValueError("Initial weights must be strictly positive")
+
+    if not np.isclose(np.sum(weights), 1.0):
+        raise ValueError("Initial weights must sum to one")
+
+    if np.any(max_weights < min_weights):
+        raise ValueError("`min_weights` must be lower or equal to `max_weights`")
+
+    if np.all((weights >= min_weights) & (weights <= max_weights)):
+        return weights
+
+    if solver_params is None:
+        solver_params = {}
+
+    n = len(weights)
+    w = cp.Variable(n)
+
+    objective = cp.Minimize(cp.norm(w / weights - 1))
+    constraints = [cp.sum(w) == 1, w >= min_weights, w <= max_weights]
+    problem = cp.Problem(objective, constraints)
+
+    try:
+        problem.solve(solver=solver, **solver_params)
+
+        if w.value is None:
+            raise cp.SolverError("No solution found")
+
+    except (cp.SolverError, scl.ArpackNoConvergence):
+        raise cp.SolverError(
+            f"Solver '{solver}' failed. Try another"
+            " solver, or solve with solver_params=dict(verbose=True) for more"
+            " information"
+        ) from None
+
+    return w.value

{skfolio-0.4.1.dist-info → skfolio-0.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: skfolio
-Version: 0.4.1
+Version: 0.4.3
 Summary: Portfolio optimization built on top of scikit-learn
 Author-email: Hugo Delatte <delatte.hugo@gmail.com>
 Maintainer-email: Hugo Delatte <delatte.hugo@gmail.com>
@@ -599,7 +599,7 @@ K-fold Cross-Validation
     # mmp is the predicted MultiPeriodPortfolio object composed of 5 Portfolios (1 per testing fold)
 
     mmp.plot_cumulative_returns()
-    print(mmp.summary()
+    print(mmp.summary())
 
 
 Combinatorial Purged Cross-Validation

{skfolio-0.4.1.dist-info → skfolio-0.4.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
 skfolio/__init__.py,sha256=5pn5LpTz6v2j2sxGkY97cVRrSPsN3Yav9b6Uw08boEI,618
-skfolio/exceptions.py,sha256=-XniKql9QHgfitMgHsE9UXWVPdjWpNGO2dVk2SsdPWE,662
+skfolio/exceptions.py,sha256=3LCxKlxgEaIMPQPCHjo1UiL7rlJnD15dNRMyBeYyKcc,784
 skfolio/typing.py,sha256=yEZiCZ6UIyfYUqtfj9Kf2KA9mrjUbmxyzpH9uqVboJs,1378
 skfolio/cluster/__init__.py,sha256=4g-PFB_ld9BhiQ1ZPvvAorpFbRwd_p_DkeRlulDv2Hk,251
 skfolio/cluster/_hierarchical.py,sha256=16INBe5HB7ALODO3RNI8ZjOYALtMZa3U_7EP1aEIxp8,12819
@@ -45,15 +45,15 @@ skfolio/optimization/_base.py,sha256=LoRONJP70AwbFpdgqVS_g145pCx0JGkazjWvkQzT_iM
 skfolio/optimization/cluster/__init__.py,sha256=M3xVdYhNKp4e9CB7hzb4yjTxkkNCHh7Mt_KGFFrkOgs,388
 skfolio/optimization/cluster/_nco.py,sha256=J3pPd9XkrAcWaKPSW5vMdtaFpDshBvOdUudbDGQSoNI,16366
 skfolio/optimization/cluster/hierarchical/__init__.py,sha256=YnfcPHvjwB6kcG4hoQqc0NqIJKaG7OjBtmXNbOxCq08,405
-skfolio/optimization/cluster/hierarchical/_base.py,sha256=ioOBsHA-kRFV_Bvl0-PcqLOytjwy6JhAX1UV454Hfss,18079
-skfolio/optimization/cluster/hierarchical/_herc.py,sha256=gFmliW8YJZbbIjHwZ5IqTmTBIt9voLUGCZKdy8RoTvw,17956
-skfolio/optimization/cluster/hierarchical/_hrp.py,sha256=nB3W5Zm1TaKTLyRMqN6irAbXD-y-bL2b78d7VFYASa8,16511
+skfolio/optimization/cluster/hierarchical/_base.py,sha256=l8rJHCH_79FOPdDL2I0dmAWcVWnNkcXHtzt0U-L7BN8,16280
+skfolio/optimization/cluster/hierarchical/_herc.py,sha256=LPtUrvyW9G60OZhMWlZH_GHZHdX8mJHksrYGB-WPRVg,20358
+skfolio/optimization/cluster/hierarchical/_hrp.py,sha256=dn6EKiTJ1wkoFhPdst6vlXnSQvXSYsMtB2zaGNVPpyA,18115
 skfolio/optimization/convex/__init__.py,sha256=F6BPFikTo0B-7JCKazqLGEwM3RkgTNbFm5GAGkaq9Uo,570
-skfolio/optimization/convex/_base.py,sha256=-lUwlV5wv4BayzOhB1g4smaJTm4VQ1ZTiaI0JAr_LWo,75806
-skfolio/optimization/convex/_distributionally_robust.py,sha256=INm3kyuKSwdSbgVlqJuKM4P1KQ0ImQulqoO4gfh-a4Q,17823
-skfolio/optimization/convex/_maximum_diversification.py,sha256=xucjuxiJf46vNwSZ7ICWmoscDvLn3Ts0xngszXfFXC0,19512
-skfolio/optimization/convex/_mean_risk.py,sha256=IBtZovEh0FBYBL5gh0KMsBmyOsSbKTAgMK0y3Yem9p4,44188
-skfolio/optimization/convex/_risk_budgeting.py,sha256=vOPxluh7yEEX1P4wLD6S2eT6HLyBWLeFmUqAaK_SLSU,23790
+skfolio/optimization/convex/_base.py,sha256=2at6Ll4qHkN_1wvYjl-yXWTbiRJj8fhNS-bfAT88YSw,76055
+skfolio/optimization/convex/_distributionally_robust.py,sha256=tw_UNSDfAXP02khE10hpmcdlz3DQXQD7ttDqFDSHV1E,17811
+skfolio/optimization/convex/_maximum_diversification.py,sha256=IVKVbK7bh4KPkhpNWLLerl-qx9Qcmf2cIIRotP8r8nI,19500
+skfolio/optimization/convex/_mean_risk.py,sha256=H4Ik6vvIETdAZnNCA4Jhk_OTirHJg26KQZ5iLsXgaHo,44176
+skfolio/optimization/convex/_risk_budgeting.py,sha256=ntPK57Ws-_U4QAiZjXFvKUYUELv9EBoJIWqofxx-0rY,23779
 skfolio/optimization/ensemble/__init__.py,sha256=8TXxcxH2_gG3C1xtgQj9OHHr0Le8lhdejtlURL6T3ZY,158
 skfolio/optimization/ensemble/_base.py,sha256=GaNDQu6ivosYuwMrb-b0PhToCsNrmhSYyXkxeM8W4rU,3399
 skfolio/optimization/ensemble/_stacking.py,sha256=ZoICUnc_MwoXDQAR2kewCg-KIezSOIUdDV1fuf7vMyA,14168
@@ -71,7 +71,7 @@ skfolio/preprocessing/__init__.py,sha256=15A1bzfPsbfxxXgGP1gstf4R0E_347Wn18z5W5j
 skfolio/preprocessing/_returns.py,sha256=oo1Mm-UCHwq4ECjfmsRxWzzK1EPsuv-EEtnimvv_nXo,4345
 skfolio/prior/__init__.py,sha256=jql8NTiWlykPKJUXTOPdqm531mP8Pul1QAR6hXTXA6c,446
 skfolio/prior/_base.py,sha256=u9GLCKJl-Txiem5rIO-qkH3VIyem3taD6T9kMzsYPRY,1941
-skfolio/prior/_black_litterman.py,sha256=7ikhjV_pc61J_0zyDiW63MNFHIEdMP3rJhmsSq5mM_k,10220
+skfolio/prior/_black_litterman.py,sha256=W3HbpvkViEiD7AOgpdVmNYTlWKSGDgo9Y3BfSrbMIQ4,10347
 skfolio/prior/_empirical.py,sha256=K3htSj_MGX6wNL-XxkTqFxz8WeqNzek6X4YYwKUmMC4,7207
 skfolio/prior/_factor_model.py,sha256=xMWyOaJNrCM6NyDQK_-G4wCfREaThI4QvhxxGhsodII,11311
 skfolio/uncertainty_set/__init__.py,sha256=LlMHtYv9G9fgtM7m4sCSToS9et57Pm2Q2gGchTVrj6c,617
@@ -80,12 +80,12 @@ skfolio/uncertainty_set/_bootstrap.py,sha256=BRD8LhGKULkqqCBjLqU1EtCAMBkLJKEXJyg
 skfolio/uncertainty_set/_empirical.py,sha256=ACqMVTBKibJm6E3IP4TOi3MYsxKMhiEoix5D_fp9X-w,9364
 skfolio/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 skfolio/utils/bootstrap.py,sha256=3zY2kO_GQURKEcQMCasJOSByde9Mt2IAi3KJH0_a4mk,3550
-skfolio/utils/equations.py,sha256=w0HsYjA7cS0mHYsI9MpixHLkof3HN26nc14ZfqFrHlE,11047
+skfolio/utils/equations.py,sha256=MQ1w3VSM2n_j9bTIKAQA716aWKYyUqtw5yM2bU-9t-M,13745
 skfolio/utils/sorting.py,sha256=lSjMvH2L-sSj-06B3MlwBrH1rtjCeGEe4hG894W7TE0,3504
-skfolio/utils/stats.py,sha256=wuOmSt5panMMTw_pFYizLbmrclsE_4PHQfamkzJ5J2s,13937
+skfolio/utils/stats.py,sha256=bzKlF2U7BN2WonwtuwG_cL_16Z3cTAxCAw5pZgbib54,17005
 skfolio/utils/tools.py,sha256=4KrmBR9jOLiI6j0hb27gsPC--OHXo4Sp1xl-6i-k9Tg,20925
-skfolio-0.4.1.dist-info/LICENSE,sha256=F6Gi-ZJX5BlVzYK8R9NcvAkAsKa7KO29xB1OScbrH6Q,1526
-skfolio-0.4.1.dist-info/METADATA,sha256=tu4OaUrxQWNbllbaEmek2cPtZv5URQb-w7IY0_i_qUc,19610
-skfolio-0.4.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-skfolio-0.4.1.dist-info/top_level.txt,sha256=NXEaoS9Ms7t32gxkb867nV0OKlU0KmssL7IJBVo0fJs,8
-skfolio-0.4.1.dist-info/RECORD,,
+skfolio-0.4.3.dist-info/LICENSE,sha256=F6Gi-ZJX5BlVzYK8R9NcvAkAsKa7KO29xB1OScbrH6Q,1526
+skfolio-0.4.3.dist-info/METADATA,sha256=PUf5onO29CqsRRaMyrMP3y0RKw6MJ43TNQ_2hMks7n0,19611
+skfolio-0.4.3.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+skfolio-0.4.3.dist-info/top_level.txt,sha256=NXEaoS9Ms7t32gxkb867nV0OKlU0KmssL7IJBVo0fJs,8
+skfolio-0.4.3.dist-info/RECORD,,

{skfolio-0.4.1.dist-info → skfolio-0.4.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any