cvxcla 0.0.4__tar.gz

cvxcla-0.0.4/LICENSE

@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

cvxcla-0.0.4/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.1
+Name: cvxcla
+Version: 0.0.4
+Summary: Critical line algorithm for the efficient frontier
+Home-page: https://www.cvxgrp.org/cvxcla
+Author: Thomas Schmelzer
+Requires-Python: >=3.9,<3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: numpy
+Requires-Dist: plotly
+Requires-Dist: scipy (>=1.10.0)
+Project-URL: Repository, https://github.com/cvxgrp/cvxcla
+Description-Content-Type: text/markdown
+
+# [cvxcla](https://www.cvxgrp.org/cvxcla/book)
+
+[![PyPI version](https://badge.fury.io/py/cvxcla.svg)](https://badge.fury.io/py/cvxcla)
+[![Apache 2.0 License](https://img.shields.io/badge/License-APACHEv2-brightgreen.svg)](https://github.com/cvxgrp/cvxcla/blob/master/LICENSE)
+[![Downloads](https://static.pepy.tech/personalized-badge/cvxcla?period=month&units=international_system&left_color=black&right_color=orange&left_text=PyPI%20downloads%20per%20month)](https://pepy.tech/project/cvxcla)
+[![Coverage Status](https://coveralls.io/repos/github/cvxgrp/cvxcla/badge.png?branch=main)](https://coveralls.io/github/cvxgrp/cvxcla?branch=main)
+
+[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/cvxgrp/cvxcla)
+
+## Critical line algorithm
+
+The critical line algorithm is a method to compute the efficient frontier of a
+portfolio optimization problem.
+
+The algorithm has been introduced by Markowitz in
+[The Optimization of Quadratic Functions Subject to Linear Constraints](https://www.rand.org/pubs/research_memoranda/RM1438.html)
+and subsequently described in his book [Portfolio Selection](https://www.wiley.com/en-us/Portfolio+Selection%3A+Efficient+Diversification+of+Investments%2C+2nd+Edition-p-9781557861085).
+
+The algorithm is based on the observation that the efficient frontier is a piecewise
+linear function if expected return is plotted over expected variance.
+The critical line algorithm computes the turning points, e.g. the corners
+of the efficient frontier.
+
+## Literature
+
+We are using the following sources
+
+### Niedermayer and Niedermayer
+
+They suggested a method to avoid the expensive inversion of the covariance matrix.
+[Applying Markowitz's critical line algorithm](https://www.researchgate.net/publication/226987510_Applying_Markowitz%27s_Critical_Line_Algorithm)
+It turns out that implementing their method in Python is not significantly faster
+than the explicit inversion of the covariance matrix relying on LAPACK via `numpy.linalg.inv`.
+
+### Bailey and Lopez de Prado
+
+We have initially started with their code published in
+[An Open-Source Implementation of the Critical-Line Algorithm for Portfolio Optimization](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2197616).
+We have updated their original code and covered it in tests. We have made a few
+noteworthy changes:
+
+* Use a boolean numpy array to indicate whether a weight is free or blocked.
+* Rewrote the computation of the first turning point.
+* Isolated the computation of $\lambda$ and the update of weights to make them testable.
+* Use modern and immutable dataclasses throughout.
+
+The code is not part of the published package though.
+It is only used for testing purposes. We recommend it for educational purposes only.
+
+### Markowitz et al
+
+In [Avoiding the Downside: A Practical Review of the Critical
+Line Algorithm for Mean-Semivariance Portfolio Optimizatio](https://www.hudsonbaycapital.com/documents/FG/hudsonbay/research/599440_paper.pdf)
+Markowitz and a team of researchers from Hudson Bay Capital Management and Constantia
+Capital provide a step-by-step tutorial on how to implement the critical line algorithm.
+
+We address a problem they oversaw: After finding the first starting point
+all variables might be blocked. We need to enforce that one variable is labeled
+as free even it sits on a boundary otherwise the matrix needed is singular.
+
+Rather than using their involved construction of the sparse matrix
+to estimate the weights we bisect the weights into a free and a blocked part.
+We then use a linear solver to compute the weights only for the free part.
+
+We alter some of their Python code. Our experiments to combine it with Niedermayer's
+ideas to accelerate the computation of the matrix inverses did not yet justify
+the additional complexity.
+
+## Poetry
+
+We assume you share already the love for [Poetry](https://python-poetry.org).
+Once you have installed poetry you can perform
+
+```bash
+make install
+```
+
+to replicate the virtual environment we have defined in [pyproject.toml](pyproject.toml)
+and locked in [poetry.lock](poetry.lock).
+
+## Jupyter
+
+We install [JupyterLab](https://jupyter.org) on fly within the aforementioned
+virtual environment. Executing
+
+```bash
+make jupyter
+```
+
+will install and start the jupyter lab.
+

cvxcla-0.0.4/README.md

@@ -0,0 +1,90 @@
+# [cvxcla](https://www.cvxgrp.org/cvxcla/book)
+
+[![PyPI version](https://badge.fury.io/py/cvxcla.svg)](https://badge.fury.io/py/cvxcla)
+[![Apache 2.0 License](https://img.shields.io/badge/License-APACHEv2-brightgreen.svg)](https://github.com/cvxgrp/cvxcla/blob/master/LICENSE)
+[![Downloads](https://static.pepy.tech/personalized-badge/cvxcla?period=month&units=international_system&left_color=black&right_color=orange&left_text=PyPI%20downloads%20per%20month)](https://pepy.tech/project/cvxcla)
+[![Coverage Status](https://coveralls.io/repos/github/cvxgrp/cvxcla/badge.png?branch=main)](https://coveralls.io/github/cvxgrp/cvxcla?branch=main)
+
+[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/cvxgrp/cvxcla)
+
+## Critical line algorithm
+
+The critical line algorithm is a method to compute the efficient frontier of a
+portfolio optimization problem.
+
+The algorithm has been introduced by Markowitz in
+[The Optimization of Quadratic Functions Subject to Linear Constraints](https://www.rand.org/pubs/research_memoranda/RM1438.html)
+and subsequently described in his book [Portfolio Selection](https://www.wiley.com/en-us/Portfolio+Selection%3A+Efficient+Diversification+of+Investments%2C+2nd+Edition-p-9781557861085).
+
+The algorithm is based on the observation that the efficient frontier is a piecewise
+linear function if expected return is plotted over expected variance.
+The critical line algorithm computes the turning points, e.g. the corners
+of the efficient frontier.
+
+## Literature
+
+We are using the following sources
+
+### Niedermayer and Niedermayer
+
+They suggested a method to avoid the expensive inversion of the covariance matrix.
+[Applying Markowitz's critical line algorithm](https://www.researchgate.net/publication/226987510_Applying_Markowitz%27s_Critical_Line_Algorithm)
+It turns out that implementing their method in Python is not significantly faster
+than the explicit inversion of the covariance matrix relying on LAPACK via `numpy.linalg.inv`.
+
+### Bailey and Lopez de Prado
+
+We have initially started with their code published in
+[An Open-Source Implementation of the Critical-Line Algorithm for Portfolio Optimization](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2197616).
+We have updated their original code and covered it in tests. We have made a few
+noteworthy changes:
+
+* Use a boolean numpy array to indicate whether a weight is free or blocked.
+* Rewrote the computation of the first turning point.
+* Isolated the computation of $\lambda$ and the update of weights to make them testable.
+* Use modern and immutable dataclasses throughout.
+
+The code is not part of the published package though.
+It is only used for testing purposes. We recommend it for educational purposes only.
+
+### Markowitz et al
+
+In [Avoiding the Downside: A Practical Review of the Critical
+Line Algorithm for Mean-Semivariance Portfolio Optimizatio](https://www.hudsonbaycapital.com/documents/FG/hudsonbay/research/599440_paper.pdf)
+Markowitz and a team of researchers from Hudson Bay Capital Management and Constantia
+Capital provide a step-by-step tutorial on how to implement the critical line algorithm.
+
+We address a problem they oversaw: After finding the first starting point
+all variables might be blocked. We need to enforce that one variable is labeled
+as free even it sits on a boundary otherwise the matrix needed is singular.
+
+Rather than using their involved construction of the sparse matrix
+to estimate the weights we bisect the weights into a free and a blocked part.
+We then use a linear solver to compute the weights only for the free part.
+
+We alter some of their Python code. Our experiments to combine it with Niedermayer's
+ideas to accelerate the computation of the matrix inverses did not yet justify
+the additional complexity.
+
+## Poetry
+
+We assume you share already the love for [Poetry](https://python-poetry.org).
+Once you have installed poetry you can perform
+
+```bash
+make install
+```
+
+to replicate the virtual environment we have defined in [pyproject.toml](pyproject.toml)
+and locked in [poetry.lock](poetry.lock).
+
+## Jupyter
+
+We install [JupyterLab](https://jupyter.org) on fly within the aforementioned
+virtual environment. Executing
+
+```bash
+make jupyter
+```
+
+will install and start the jupyter lab.

cvxcla-0.0.4/cvx/cla/__init__.py

@@ -0,0 +1,15 @@
+#    Copyright 2023 Stanford University Convex Optimization Group
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+from cvx.cla.markowitz.cla import CLA

cvxcla-0.0.4/cvx/cla/claux.py

@@ -0,0 +1,72 @@
+#    Copyright 2023 Stanford University Convex Optimization Group
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+import logging
+from dataclasses import dataclass, field
+from typing import List
+
+import numpy as np
+
+from cvx.cla.first import init_algo
+from cvx.cla.types import MATRIX, Frontier, FrontierPoint, TurningPoint
+
+
+@dataclass(frozen=True)
+class CLAUX:
+    mean: MATRIX
+    covariance: MATRIX
+    lower_bounds: MATRIX
+    upper_bounds: MATRIX
+    A: MATRIX
+    b: MATRIX
+    turning_points: List[TurningPoint] = field(default_factory=list)
+    tol: float = 1e-5
+    logger: logging.Logger = logging.getLogger(__name__)
+
+    def __len__(self):
+        """
+        Returns the number of turning points
+        """
+        return len(self.turning_points)
+
+    def _first_turning_point(self):
+        first = init_algo(
+            mean=self.mean,
+            lower_bounds=self.lower_bounds,
+            upper_bounds=self.upper_bounds,
+        )
+        return first
+
+    def _append(self, tp: TurningPoint, tol=None):
+        tol = tol or self.tol
+
+        assert np.all(
+            tp.weights >= (self.lower_bounds - tol)
+        ), f"{(tp.weights + tol) - self.lower_bounds}"
+        assert np.all(
+            tp.weights <= (self.upper_bounds + tol)
+        ), f"{(self.upper_bounds + tol) - tp.weights}"
+        assert np.allclose(np.sum(tp.weights), 1.0), f"{np.sum(tp.weights)}"
+
+        self.turning_points.append(tp)
+
+    @property
+    def frontier(self):
+        """
+        Returns the frontier
+        """
+        return Frontier(
+            covariance=self.covariance,
+            mean=self.mean,
+            frontier=[FrontierPoint(point.weights) for point in self.turning_points],
+        )

cvxcla-0.0.4/cvx/cla/first.py

@@ -0,0 +1,142 @@
+#    Copyright 2023 Stanford University Convex Optimization Group
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+from __future__ import annotations
+
+import cvxpy as cp
+import numpy as np
+
+from cvx.cla.types import MATRIX, TurningPoint
+
+
+#
+def init_algo(mean: MATRIX, lower_bounds: MATRIX, upper_bounds: MATRIX) -> TurningPoint:
+    """The key insight behind Markowitz’s CLA is to find first the
+    turning point associated with the highest expected return, and then
+    compute the sequence of turning points, each with a lower expected
+    return than the previous. That first turning point consists in the
+    smallest subset of assets with highest return such that the sum of
+    their upper boundaries equals or exceeds one.
+
+    We sort the expected returns in descending order.
+    This gives us a sequence for searching for the
+    first free asset. All weights are initially set to their lower bounds,
+    and following the sequence from the previous step, we move those
+    weights from the lower to the upper bound until the sum of weights
+    exceeds one. If possible the last iterated weight is then reduced
+    to comply with the constraint that the sum of weights equals one.
+    This last weight is the first free asset,
+    and the resulting vector of weights the first turning point.
+    """
+
+    if np.any(lower_bounds > upper_bounds):
+        raise ValueError("Lower bounds must be less than or equal to upper bounds")
+
+    # Initialize weights to lower bounds
+    weights = np.copy(lower_bounds)
+    free = np.full_like(mean, False, dtype=np.bool_)
+
+    # Move weights from lower to upper bound
+    # until sum of weights hits or exceeds 1
+    for index in np.argsort(-mean):
+        weights[index] += np.min(
+            [upper_bounds[index] - lower_bounds[index], 1.0 - np.sum(weights)]
+        )
+        if np.sum(weights) >= 1:
+            free[index] = True
+            break
+
+    # free = _free(weights, lower_bounds, upper_bounds)
+
+    if not np.any(free):
+        #    # We have not reached the sum of weights of 1...
+        raise ValueError("Could not construct a fully invested portfolio")
+
+    # Return first turning point, the point with the highest expected return.
+    return TurningPoint(free=free, weights=weights)
+
+
+def init_algo_lp(
+    mean: MATRIX,
+    lower_bounds: MATRIX,
+    upper_bounds: MATRIX,
+    A_eq: MATRIX | None = None,
+    b_eq: MATRIX | None = None,
+    solver=cp.CLARABEL,
+    **kwargs
+    # A_ub: MATRIX | None = None,
+    # b_ub: MATRIX | None = None,
+) -> TurningPoint:
+    if A_eq is None:
+        A_eq = np.atleast_2d(np.ones_like(mean))
+
+    if b_eq is None:
+        b_eq = np.array([1.0])
+
+    # if A_ub is None:
+    #    A_ub = np.atleast_2d(np.zeros_like(mean))
+
+    # if b_ub is None:
+    #    b_ub = np.array([0.0])
+
+    w = cp.Variable(mean.shape[0], "weights")
+
+    objective = cp.Maximize(mean.T @ w)
+    constraints = [
+        A_eq @ w == b_eq,
+        # A_ub @ w <= b_ub,
+        lower_bounds <= w,
+        w <= upper_bounds,
+        cp.sum(w) == 1.0,
+    ]
+
+    problem = cp.Problem(objective, constraints)
+    problem.solve(solver=solver, **kwargs)
+    # check status of problem is optimal
+    if problem.status != cp.OPTIMAL:
+        raise ValueError("Could not construct a fully invested portfolio")
+
+    # assert problem.status == cp.OPTIMAL
+    # print(problem.status)
+    # print(status)
+
+    w = w.value
+
+    # compute the distance from the closest bound
+    # distance = np.min(
+    #    np.array([np.abs(w - lower_bounds), np.abs(upper_bounds - w)]), axis=0
+    # )
+
+    # which element has the largest distance to any bound?
+    # Even if all assets are at their bounds,
+    # we get a (somewhat random) free asset.
+    # index = np.argmax(distance)
+
+    # free = np.full_like(mean, False, dtype=np.bool_)
+    # free[index] = True
+
+    free = _free(w, lower_bounds, upper_bounds)
+
+    return TurningPoint(free=free, weights=w)
+
+
+def _free(w, lower_bounds, upper_bounds):
+    distance = np.min(
+        np.array([np.abs(w - lower_bounds), np.abs(upper_bounds - w)]), axis=0
+    )
+
+    index = np.argmax(distance)
+
+    free = np.full_like(w, False, dtype=np.bool_)
+    free[index] = True
+    return free

cvxcla-0.0.4/cvx/cla/markowitz/__init__.py

@@ -0,0 +1,13 @@
+#    Copyright 2023 Stanford University Convex Optimization Group
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.

cvxcla-0.0.4/cvx/cla/markowitz/cla.py

@@ -0,0 +1,130 @@
+#    Copyright 2023 Stanford University Convex Optimization Group
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+from dataclasses import dataclass
+
+import numpy as np
+
+from cvx.cla.claux import CLAUX
+from cvx.cla.types import TurningPoint
+
+
+@dataclass(frozen=True)
+class CLA(CLAUX):
+    def __post_init__(self):
+        ns = self.mean.shape[0]
+        m = self.A.shape[0]
+
+        # --A08-- Initialize the portfolio.
+        first = self._first_turning_point()
+        self._append(first)
+
+        # --A10-- Set the P matrix.
+        P = np.block([self.covariance, self.A.T])
+        M = np.block([[self.covariance, self.A.T], [self.A, np.zeros((m, m))]])
+
+        # --A11 -- Initialize storage for quantities # to be computed in the main loop.
+        lam = np.inf
+
+        while lam > 0:
+            last = self.turning_points[-1]
+
+            blocked = ~last.free
+            assert not np.all(blocked), "Not all variables can be blocked"
+
+            # --A13-- Create the UP, DN, and IN
+            # sets from the current state vector.
+            UP = blocked & np.isclose(last.weights, self.upper_bounds)
+            DN = blocked & np.isclose(last.weights, self.lower_bounds)
+
+            # a variable is out if it is UP or DN
+            OUT = np.logical_or(UP, DN)
+            IN = ~OUT
+
+            up = np.zeros(ns)
+            up[UP] = self.upper_bounds[UP]
+
+            dn = np.zeros(ns)
+            dn[DN] = self.lower_bounds[DN]
+
+            top = np.copy(self.mean)
+            top[OUT] = 0
+
+            _IN = np.concatenate([IN, np.ones(m, dtype=np.bool_)])
+
+            bbb = np.array(
+                [np.block([up + dn, self.b]), np.block([top, np.zeros(m)])]
+            ).T
+
+            alpha, beta = CLA._solve(M, bbb, _IN)
+
+            gamma = P @ alpha
+            delta = P @ beta - self.mean
+
+            # -A17-- Prepare the ratio matrix.
+            L = -np.inf * np.ones([ns, 4])
+
+            r_beta = beta[range(ns)]
+            r_alpha = alpha[range(ns)]
+
+            # --A18-- IN security possibly going UP.
+            i = IN & (r_beta < -self.tol)
+            L[i, 0] = (self.upper_bounds[i] - r_alpha[i]) / r_beta[i]
+
+            # --A19-- IN security possibly going DN.
+            i = IN & (r_beta > +self.tol)
+            L[i, 1] = (self.lower_bounds[i] - r_alpha[i]) / r_beta[i]
+
+            # --A20--UP security possibly going IN.
+            i = UP & (delta < -self.tol)
+            L[i, 2] = -gamma[i] / delta[i]
+
+            # --A21-- DN security possibly going IN.
+            i = DN & (delta > +self.tol)
+            L[i, 3] = -gamma[i] / delta[i]
+
+            # --A22--If all elements of ratio are negative,
+            # we have reached the end of the efficient frontier.
+            if np.max(L) < 0:
+                break
+
+            secchg, dirchg = np.unravel_index(np.argmax(L, axis=None), L.shape)
+
+            # --A25-- Set the new value of lambda_E.
+            lam = L[secchg, dirchg]
+
+            free = np.copy(last.free)
+            if dirchg == 0 or dirchg == 1:
+                free[secchg] = False
+            else:
+                free[secchg] = True
+
+            # --A27-- Compute the portfolio at this corner.
+            x = r_alpha + lam * r_beta
+
+            # --A28-- Save the data computed at this corner.
+            self._append(TurningPoint(lamb=lam, weights=x, free=free))
+
+        self._append(TurningPoint(lamb=0, weights=r_alpha, free=last.free))
+
+    @staticmethod
+    def _solve(A, b, IN):
+        OUT = ~IN
+        n = A.shape[1]
+        x = np.zeros((n, 2))
+
+        x[OUT, :] = b[OUT, :]
+        bbb = b[IN, :] - A[IN, :][:, OUT] @ x[OUT, :]
+
+        x[IN, :] = np.linalg.inv(A[IN, :][:, IN]) @ bbb
+        return x[:, 0], x[:, 1]

cvxcla-0.0.4/cvx/cla/types.py

@@ -0,0 +1,230 @@
+#    Copyright 2023 Stanford University Convex Optimization Group
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+"""
+types
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import numpy as np
+import plotly.express as px
+from numpy.typing import NDArray
+from scipy.optimize import minimize
+from typing_extensions import TypeAlias
+
+MATRIX: TypeAlias = NDArray[np.float64]
+BOOLEAN_VECTOR: TypeAlias = NDArray[np.bool_]
+
+
+@dataclass(frozen=True)
+class FrontierPoint:
+    weights: MATRIX
+
+    def __post_init__(self):
+        # check that the sum is close to 1
+        assert np.isclose(np.sum(self.weights), 1.0)
+
+    def mean(self, mean: MATRIX):
+        """
+        Computes the expected return for a turning point
+        """
+        return float(mean.T @ self.weights)
+
+    def variance(self, covariance: MATRIX):
+        """
+        Computes the expected variance for a turning point
+        """
+        return float(self.weights.T @ covariance @ self.weights)
+
+
+@dataclass(frozen=True)
+class TurningPoint(FrontierPoint):
+    """
+    A turning point is a vector of weights, a lambda value, and a boolean vector
+    indicating which assets are free. All assets that are not free are blocked.
+    """
+
+    free: BOOLEAN_VECTOR
+    lamb: float = np.inf
+
+    @property
+    def free_indices(self):
+        """
+        Returns the indices of the free assets
+        """
+        return np.where(self.free)[0]
+
+    @property
+    def blocked_indices(self):
+        """
+        Returns the indices of the blocked assets
+        """
+        return np.where(~self.free)[0]
+
+
+@dataclass(frozen=True)
+class Frontier:
+    """
+    A frontier is a list of frontier points. Some of them might be turning points.
+    """
+
+    mean: MATRIX
+    covariance: MATRIX
+    frontier: list[FrontierPoint] = field(default_factory=list)
+
+    def interpolate(self, num=100):
+        """
+        Interpolate the frontier with num-1 points between adjacent frontier points
+        Args:
+            num: The number of new points in between each pair
+
+        Returns:
+            A frontier with many new points
+        """
+
+        def _interpolate():
+            for w_left, w_right in zip(self.weights[0:-1], self.weights[1:]):
+                for lamb in np.linspace(0, 1, num):
+                    if lamb > 0:
+                        yield FrontierPoint(
+                            weights=lamb * w_left + (1 - lamb) * w_right
+                        )
+
+        points = list(_interpolate())
+        return Frontier(frontier=points, mean=self.mean, covariance=self.covariance)
+
+    def __iter__(self):
+        """
+        Iterator for all frontier points
+        """
+        yield from self.frontier
+
+    def __len__(self):
+        """
+        Number of frontier points
+        """
+        return len(self.frontier)
+
+    @property
+    def weights(self):
+        """
+        Matrix of weights. One row per point
+        """
+        return np.array([point.weights for point in self])
+
+    @property
+    def returns(self):
+        """
+        Vector of expected returns.
+        """
+        return np.array([point.mean(self.mean) for point in self])
+
+    @property
+    def variance(self):
+        """
+        Vector of expected variances.
+        """
+        return np.array([point.variance(self.covariance) for point in self])
+
+    @property
+    def sharpe_ratio(self):
+        """
+        Vector of expected Sharpe ratios.
+        """
+        return self.returns / self.volatility
+
+    @property
+    def volatility(self):
+        """
+        Vector of expected volatilities.
+        """
+        return np.sqrt(self.variance)
+
+    @property
+    def max_sharpe(self):
+        """
+        Maximal Sharpe ratio on the frontier
+
+        Returns:
+            Tuple of maximal Sharpe ratio and the weights to achieve it
+        """
+
+        def neg_sharpe(alpha, w_left, w_right):
+            # convex combination of left and right weights
+            weight = alpha * w_left + (1 - alpha) * w_right
+            # compute the variance
+            var = weight.T @ self.covariance @ weight
+            returns = self.mean.T @ weight
+            return -returns / np.sqrt(var)
+
+        sharpe_ratios = self.sharpe_ratio
+
+        # in which point is the maximal Sharpe ratio?
+        sr_position_max = np.argmax(self.sharpe_ratio)
+
+        # np.min only there for security...
+        right = np.min([sr_position_max + 1, len(self) - 1])
+        left = np.max([0, sr_position_max - 1])
+
+        # Look to the left and look to the right
+
+        if right > sr_position_max:
+            out = minimize(
+                neg_sharpe,
+                0.5,
+                args=(self.weights[sr_position_max], self.weights[right]),
+                bounds=((0, 1),),
+            )
+            var = out["x"][0]
+            w_right = (
+                var * self.weights[sr_position_max] + (1 - var) * self.weights[right]
+            )
+            sharpe_ratio_right = -out["fun"]
+        else:
+            w_right = self.weights[sr_position_max]
+            sharpe_ratio_right = sharpe_ratios[sr_position_max]
+
+        if left < sr_position_max:
+            out = minimize(
+                neg_sharpe,
+                0.5,
+                args=(self.weights[left], self.weights[sr_position_max]),
+                bounds=((0, 1),),
+            )
+            var = out["x"][0]
+            w_left = (
+                var * self.weights[left] + (1 - var) * self.weights[sr_position_max]
+            )
+            sharpe_ratio_left = -out["fun"]
+        else:
+            w_left = self.weights[sr_position_max]
+            sharpe_ratio_left = sharpe_ratios[sr_position_max]
+
+        if sharpe_ratio_left > sharpe_ratio_right:
+            return sharpe_ratio_left, w_left
+
+        return sharpe_ratio_right, w_right
+
+    def plot(self):
+        """
+        Plot the frontier
+        """
+        fig = px.line(
+            x=self.variance,
+            y=self.returns,
+            markers=True,
+            labels={"x": "Expected variance", "y": "Expected Return"},
+        )
+        return fig

cvxcla-0.0.4/pyproject.toml

@@ -0,0 +1,39 @@
+[tool.poetry]
+name = "cvxcla"
+version = "v0.0.4"
+description = "Critical line algorithm for the efficient frontier"
+authors = ["Thomas Schmelzer", "Philipp Schiele"]
+readme = "README.md"
+repository = "https://github.com/cvxgrp/cvxcla"
+packages = [{include = "cvx"}]
+homepage = "https://www.cvxgrp.org/cvxcla"
+
+[tool.poetry.dependencies]
+python = ">=3.9,<3.12"
+numpy = "*"
+scipy = ">=1.10.0"
+plotly = "*"
+
+[tool.poetry.dev-dependencies]
+loguru = "*"
+pandas = "*"
+cvxpy = "*"
+
+[tool.poetry.group.test.dependencies]
+pytest = "*"
+pytest-cov = "*"
+cvxbson = "*"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+select = ["E", "F", "I"]
+line-length = 120
+target-version = "py310"
+exclude = [
+    "*__init__.py",
+    ".venv",
+    "experiments"
+]