hyhound 1.1.1__tar.gz

hyhound-1.1.1/CMakeLists.txt

@@ -0,0 +1,111 @@
+cmake_minimum_required(VERSION 3.24...4.1)
+set(CMAKE_CXX_SCAN_FOR_MODULES Off)
+project(hyhound
+    VERSION 1.1.1
+    DESCRIPTION "Hyperbolic Householder transformations for Cholesky factorization up- and downdates"
+    HOMEPAGE_URL "https://github.com/kul-optec/hyhound"
+    LANGUAGES CXX
+)
+include(CTest)
+set(PY_VERSION_SUFFIX "")
+
+# Make sure that the Python and CMake versions match
+set(PY_FULL_VERSION ${PROJECT_VERSION}${PY_VERSION_SUFFIX})
+if (DEFINED PY_BUILD_CMAKE_PROJECT_VERSION)
+    if (NOT "${PY_BUILD_CMAKE_PROJECT_VERSION}" MATCHES "^${PY_FULL_VERSION}$")
+        message(FATAL_ERROR "Version number does not match "
+                             "(${PY_BUILD_CMAKE_PROJECT_VERSION} - ${PY_FULL_VERSION}).")
+    endif()
+endif()
+
+# Options
+include(CMakeDependentOption)
+set(HYHOUND_DENSE_REAL_TYPE "double" "float" CACHE STRING
+    "The floating point types that the functions are instantiated for")
+set(HYHOUND_DENSE_INDEX_TYPE "long long" CACHE STRING
+    "The main integer type for indices and sizes")
+# Target options
+option(HYHOUND_HAVE_TWO_512_FMA_UNITS
+    "Does the CPU have 0.5 CPI 512-bit FMA" Off)
+set(HYHOUND_MAX_HYH_KERNEL_WIDTH "8" CACHE STRING
+    "Kernel size limit for the 'diagonal' kernels")
+set(HYHOUND_MAX_HYH_KERNEL_HEIGHT "32" CACHE STRING
+    "Kernel size limit for the 'below-diagonal' kernels")
+# Enable/disable optional components
+option(HYHOUND_WITH_TESTS
+    "Build the tests" ${BUILD_TESTING})
+option(HYHOUND_WITH_OCP
+    "Build the OCP solvers" Off)
+option(HYHOUND_WITH_BENCHMARKS
+    "Build the benchmarks" Off)
+option(HYHOUND_WITH_PYTHON
+    "Build the Python interface" Off)
+option(HYHOUND_WITH_PYTHON_DISPATCH
+    "Build the AVX2/AVX-512 dispatch logic for the Python interface" Off)
+# Developer options
+option(HYHOUND_WARNINGS_AS_ERRORS
+    "Enable -Werror or /WX" Off)
+option(HYHOUND_WITH_ACCURATE_BUILD_TIME
+    "Update the build time on every build" On)
+option(HYHOUND_VERIFY_ASSUMPTIONS
+    "Check assumptions at run time instead of blindly assuming" Off)
+option(HYHOUND_FORCE_TEST_DISCOVERY
+    "Query the test executables even when cross-compiling" Off)
+option(HYHOUND_DEVELOPER_MODE
+    "Enable developer options such as ccache and colored compiler output" Off)
+
+# Installation paths
+include(GNUInstallDirs)
+set(HYHOUND_INSTALL_LIBDIR "${CMAKE_INSTALL_LIBDIR}"
+    CACHE PATH "Installation directory for archives and libraries")
+set(HYHOUND_INSTALL_CMAKEDIR "${HYHOUND_INSTALL_LIBDIR}/cmake/hyhound"
+    CACHE PATH "Installation directory for CMake configuration files")
+set(HYHOUND_INSTALL_BINDIR "${CMAKE_INSTALL_BINDIR}"
+    CACHE PATH "Installation directory for binaries and DLLs")
+set(HYHOUND_INSTALL_INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}"
+    CACHE PATH "Installation directory for headers")
+option(HYHOUND_STANDALONE
+    "Install with relative RPATH to locate its own shared libraries" On)
+
+# Development
+if (PROJECT_IS_TOP_LEVEL)
+    set(CMAKE_EXPORT_COMPILE_COMMANDS On)
+endif()
+if (HYHOUND_DEVELOPER_MODE)
+    include(cmake/Develop.cmake)
+endif()
+
+# Compiler warnings
+include(cmake/Warnings.cmake)
+add_warnings_target(warnings ${HYHOUND_WARNINGS_AS_ERRORS})
+add_library(hyhound::warnings ALIAS warnings)
+
+# Other compiler and CMake options
+set(CMAKE_RELEASE_POSTFIX "")
+set(CMAKE_DEBUG_POSTFIX "_d")
+set(CMAKE_RELWITHDEBINFO_POSTFIX "_rd")
+set(CMAKE_MINSIZEREL_POSTFIX "_rs")
+
+# Locating dependencies
+if (DEFINED ENV{MKLROOT})
+    list(PREPEND CMAKE_FIND_ROOT_PATH "$ENV{MKLROOT}")
+endif()
+
+# Libraries
+add_subdirectory(src)
+
+# Tests
+if (HYHOUND_WITH_TESTS)
+    enable_testing()
+    add_subdirectory(test)
+endif()
+
+# Benchmarks
+if (HYHOUND_WITH_BENCHMARKS)
+    add_subdirectory(benchmarks)
+endif()
+
+# Python interface
+if (HYHOUND_WITH_PYTHON)
+    add_subdirectory(python)
+endif()

hyhound-1.1.1/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

hyhound-1.1.1/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: hyhound
+Version: 1.1.1
+Summary: Hyperbolic Householder transformations for Up- and Downdating Cholesky factorizations.
+Keywords: linear-algebra,cholesky,update,downdate,matrix
+Author-Email: Pieter P <pieter.p.dev@outlook.com>
+License-Expression: LGPL-3.0-or-later
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Typing :: Typed
+Project-URL: Documentation, https://kul-optec.github.io/hyhound
+Project-URL: Source, https://github.com/kul-optec/hyhound
+Project-URL: Bug Tracker, https://github.com/kul-optec/hyhound/issues
+Requires-Python: >=3.9
+Requires-Dist: numpy<3
+Provides-Extra: test
+Requires-Dist: pytest<9,>=7.2.0; extra == "test"
+Provides-Extra: docs
+Requires-Dist: sphinx==8.2.3; extra == "docs"
+Requires-Dist: sphinx-book-theme==1.1.4; extra == "docs"
+Requires-Dist: numpydoc==1.9.0; extra == "docs"
+Requires-Dist: breathe==4.36.0; extra == "docs"
+Description-Content-Type: text/x-rst
+
+.. image:: https://img.shields.io/badge/arXiv-Preprint-b31b1b
+   :target: https://arxiv.org/abs/2503.15372v1
+   :alt: arXiv Preprint
+
+.. image:: https://github.com/kul-optec/hyhound/actions/workflows/linux.yml/badge.svg
+   :target: https://github.com/kul-optec/hyhound/actions/workflows/linux.yml
+   :alt: CI: Linux
+
+.. image:: https://img.shields.io/pypi/dm/hyhound?label=PyPI&logo=python
+   :target: https://pypi.org/project/hyhound
+   :alt: PyPI Downloads
+
+
+hyhound
+=======
+
+**Hy**\perbolic **Ho**\useholder transformations for **U**\p- ‘**n**’ **D**\owndating Cholesky factorizations.
+
+
+Purpose
+-------
+
+Given a Cholesky factor :math:`L` of a dense matrix :math:`H`, the
+``hyhound::update_cholesky`` function computes the Cholesky factor
+:math:`\tilde L` of the matrix
+
+.. math::
+
+   \tilde H = \tilde L \tilde L^\top = H + A \Sigma A^\top,
+
+where :math:`H,\tilde H\in\mathbb{R}^{n\times n}` with :math:`H \succ 0`
+and :math:`\tilde H \succ 0`, :math:`A \in \mathbb{R}^{n\times m}`,
+:math:`\Sigma \in \mathbb{R}^{m\times m}` diagonal,
+and :math:`L, \tilde L\in\mathbb{R}^{n\times n}` lower triangular.
+
+Computing :math:`\tilde L` in this way is done in
+:math:`mn^2 + \mathcal{O}(n^2 + mn)` operations rather than the
+:math:`\tfrac16 n^3 + \tfrac12 mn^2 + \mathcal{O}(n^2 + mn)` operations
+required for the explicit evaluation and factorization of :math:`\tilde H`.
+When :math:`m \ll n`, this results in a considerable speedup over full
+factorization, enabling efficient low-rank updates of Cholesky
+factorizations, for use in e.g. iterative algorithms for numerical
+optimization.
+
+Additionally, hyhound includes efficient routines for updating
+factorizations of the Riccati recursion for optimal control problems.
+
+
+Preprint
+--------
+
+The paper describing the algorithms in this repository can be found on arXiv:  
+`https://arxiv.org/abs/2503.15372v1 <https://arxiv.org/abs/2503.15372v1>`_
+
+.. code-block:: bibtex
+
+   @misc{pas_blocked_2025,
+      title = {Blocked {Cholesky} factorization updates of the {Riccati} recursion using hyperbolic {Householder} transformations},
+      url = {http://arxiv.org/abs/2503.15372},
+      doi = {10.48550/arXiv.2503.15372},
+      publisher = {arXiv},
+      author = {Pas, Pieter and Patrinos, Panagiotis},
+      month = mar,
+      year = {2025},
+      note = {Accepted for publication in the Proceedings of CDC 2025}
+   }

hyhound-1.1.1/cmake/Debug.cmake

@@ -0,0 +1,23 @@
+# Strip and install debug information
+function(hyhound_install_debug_syms target component dest_lib dest_bin)
+    if (MSVC)
+        install(FILES "$<TARGET_PDB_FILE:${target}>"
+            DESTINATION ${dest_bin}
+            CONFIGURATIONS Debug RelWithDebInfo
+            COMPONENT ${component}
+            OPTIONAL EXCLUDE_FROM_ALL)
+    elseif (CMAKE_STRIP AND CMAKE_OBJCOPY)
+        set(DEBUG_FILE "$<TARGET_FILE_NAME:${target}>.debug")
+        add_custom_command(TARGET ${target} POST_BUILD
+            COMMAND "${CMAKE_STRIP}" "--only-keep-debug" "$<TARGET_FILE:${target}>" "-o" "${DEBUG_FILE}"
+            COMMAND "${CMAKE_STRIP}" "--strip-debug" "$<TARGET_FILE:${target}>"
+            COMMAND "${CMAKE_OBJCOPY}" "--add-gnu-debuglink=${DEBUG_FILE}" "$<TARGET_FILE:${target}>"
+            COMMAND "${CMAKE_COMMAND}" "-E" "echo" "Stripped into ${DEBUG_FILE}"
+            WORKING_DIRECTORY $<TARGET_FILE_DIR:${target}>)
+        install(FILES "$<TARGET_FILE_DIR:${target}>/${DEBUG_FILE}"
+            DESTINATION ${dest_lib}
+            CONFIGURATIONS Debug RelWithDebInfo
+            COMPONENT ${component}
+            EXCLUDE_FROM_ALL)
+    endif()
+endfunction()

hyhound-1.1.1/cmake/Develop.cmake

@@ -0,0 +1,12 @@
+set(CMAKE_EXPORT_COMPILE_COMMANDS On)
+set(CMAKE_C_COMPILER_LAUNCHER "sccache")
+set(CMAKE_CXX_COMPILER_LAUNCHER "sccache")
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    add_compile_options(-fdiagnostics-color=always)
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang$")
+    add_compile_options(-fcolor-diagnostics)
+endif()
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    add_compile_options(-ffunction-sections)
+    add_link_options(LINKER:--gc-sections)
+endif()

hyhound-1.1.1/cmake/Warnings.cmake

@@ -0,0 +1,128 @@
+function(add_warnings_target tgt_name warnings_as_errors)
+
+    # GCC, Clang, AppleClang
+    set(COMMON_WARNINGS_CXX
+        -fdiagnostics-show-option
+        -Wall
+        -Wextra
+        -pedantic
+        -Wpedantic
+        -pedantic-errors
+        -Wdouble-promotion
+        -Wswitch-default
+        -Wswitch-enum
+        -Wno-missing-braces
+        -Wno-psabi
+        -Wimplicit-fallthrough
+        -Wuninitialized
+        -Wconversion
+        -Wno-sign-conversion
+    )
+    set(COMMON_WARNINGS_Fortran
+        -fdiagnostics-show-option
+        -Wall
+        -Wextra
+        -Wpedantic
+        -fimplicit-none
+    )
+    set(COMMON_WARNINGS_C
+        -fdiagnostics-show-option
+        -Wall
+        -Wextra
+        -pedantic
+        -Wpedantic
+        -pedantic-errors
+        -Wimplicit-fallthrough
+        -Wuninitialized
+        -Wconversion
+        -Wno-sign-conversion
+    )
+    # GCC
+    set(GCC_WARNINGS_CXX
+        -Wno-error=unused-but-set-variable
+        -Wsuggest-override
+        -Wno-error=attributes
+        -ftemplate-backtrace-limit=99
+    )
+    if (NOT CMAKE_CXX_CLANG_TIDY)
+        list(APPEND GCC_WARNINGS_CXX -fconcepts-diagnostics-depth=99)
+    endif()
+    # Clang, AppleClang
+    set(CLANG_WARNINGS_CXX
+        -Wno-error=unknown-warning-option
+        -Wno-newline-eof
+        -Wno-error=unused-but-set-variable
+        -Winconsistent-missing-override
+        -Wno-gnu-zero-variadic-macro-arguments
+        -Wunreachable-code
+        -Wunreachable-code-break
+        -Wunreachable-code-fallthrough
+        -Wunreachable-code-return
+        -Wunreachable-code-aggressive
+        -Wno-error=self-assign-overloaded
+        -Wno-non-c-typedef-for-linkage
+        -Wno-return-type-c-linkage
+    )
+    # Flang
+    set(FLANG_WARNINGS_Fortran
+        -fimplicit-none
+    )
+    # MSVC (Microsoft)
+    set(MSVC_WARNINGS_CXX
+        /W3
+        /wd4127 # conditional expression is constant
+        /wd4458 # declaration of 'x' hides class member
+        /wd4251 # 'x' needs to have dll-interface to be used by clients of 'y'
+        /wd4305 # 'initializing': truncation from 'double' to 'float'
+        /wd4661 # no suitable definition provided for explicit template instantiation request
+        /wd5030 # attribute 'attribute-name' is not recognized
+    )
+    set(MSVC_WARNINGS_C
+        /W4
+    )
+    # Intel ICC
+    set(INTEL_WARNINGS_CXX
+        -Wall
+        -Wextra
+    )
+    set(INTEL_WARNINGS_Fortran
+        -Wall
+        -Wextra
+    )
+    set(INTEL_WARNINGS_C
+        -Wall
+        -Wextra
+    )
+
+    # Add target that defines all the warning options in its interface.
+    add_library(${tgt_name} INTERFACE)
+
+    foreach (LANG C CXX Fortran)
+        # Enable warnings as errors
+        if (warnings_as_errors)
+            list(APPEND COMMON_WARNINGS_${LANG} -Werror)
+            list(APPEND MSVC_WARNINGS_${LANG} /WX)
+            list(APPEND INTEL_WARNINGS_${LANG} -Werror)
+            list(APPEND FLANG_WARNINGS_${LANG} -Werror)
+        endif()
+        if (CMAKE_${LANG}_COMPILER_ID MATCHES "GNU")
+            target_compile_options(${tgt_name} INTERFACE
+            $<$<COMPILE_LANGUAGE:${LANG}>:$<BUILD_INTERFACE:${COMMON_WARNINGS_${LANG}} ${GCC_WARNINGS_${LANG}}>>)
+        elseif (CMAKE_${LANG}_COMPILER_ID MATCHES ".*Clang")
+            target_compile_options(${tgt_name} INTERFACE
+            $<$<COMPILE_LANGUAGE:${LANG}>:$<BUILD_INTERFACE:${COMMON_WARNINGS_${LANG}} ${CLANG_WARNINGS_${LANG}}>>)
+        elseif (CMAKE_${LANG}_COMPILER_ID MATCHES "Flang")
+            target_compile_options(${tgt_name} INTERFACE
+            $<$<COMPILE_LANGUAGE:${LANG}>:$<BUILD_INTERFACE:${FLANG_WARNINGS_${LANG}}>>)
+        elseif (CMAKE_${LANG}_COMPILER_ID MATCHES "MSVC")
+            target_compile_options(${tgt_name} INTERFACE
+                $<$<COMPILE_LANGUAGE:${LANG}>:$<BUILD_INTERFACE:${MSVC_WARNINGS_${LANG}}>>)
+        elseif (CMAKE_${LANG}_COMPILER_ID MATCHES "Intel")
+            target_compile_options(${tgt_name} INTERFACE
+            $<$<COMPILE_LANGUAGE:${LANG}>:$<BUILD_INTERFACE:${INTEL_WARNINGS_${LANG}}>>)
+        elseif (DEFINED CMAKE_${LANG}_COMPILER_ID)
+            message(WARNING "No known warnings for this ${LANG} compiler (${CMAKE_${LANG}_COMPILER_ID})")
+        endif()
+    endforeach()
+
+endfunction()

hyhound-1.1.1/conanfile.py

@@ -0,0 +1,129 @@
+import os
+
+from conan import ConanFile
+from conan.tools.cmake import CMakeToolchain, CMake, cmake_layout
+from conan.tools.build import can_run
+from conan.tools.files import save
+from conan.tools.scm import Git
+
+
+class HyhoundRecipe(ConanFile):
+    name = "hyhound"
+    version = "1.1.1"
+
+    # Optional metadata
+    license = "LGPL-3.0-or-later"
+    author = "Pieter P <pieter.p.dev@outlook.com>"
+    url = "https://github.com/kul-optec/hyhound"
+    description = "Hyperbolic Householder transformations for Cholesky factorization up- and downdates."
+    topics = "scientific software"
+
+    # Binary configuration
+    package_type = "library"
+    settings = "os", "compiler", "build_type", "arch"
+    bool_hyhound_options = {
+        "with_ocp": False,
+        "with_benchmarks": False,
+        "with_python": False,
+        "with_python_dispatch": False,
+    }
+    options = {
+        "shared": [True, False],
+        "fPIC": [True, False],
+        "real_type": ["double;float", "float;double", "double", "float"],
+        "with_conan_python": [True, False],
+    } | {k: [True, False] for k in bool_hyhound_options}
+    default_options = {
+        "shared": False,
+        "fPIC": True,
+        "real_type": "double;float",
+        "with_conan_python": False,
+    } | bool_hyhound_options
+
+    # Sources are located in the same place as this recipe, copy them to the recipe
+    exports_sources = (
+        "CMakeLists.txt",
+        "src/*",
+        "cmake/*",
+        "test/*",
+        "benchmarks/*",
+        "LICENSE",
+        "README.md",
+    )
+
+    def export_sources(self):
+        git = Git(self)
+        status_cmd = "status . --short --no-branch --untracked-files=no"
+        dirty = bool(git.run(status_cmd).strip())
+        hash = git.get_commit() + ("-dirty" if dirty else "")
+        print("Commit hash:", hash)
+        save(self, os.path.join(self.export_sources_folder, "commit.txt"), hash)
+
+    generators = ("CMakeDeps",)
+
+    def requirements(self):
+        self.requires(
+            "guanaqo/1.0.0-alpha.22", transitive_headers=True, transitive_libs=True
+        )
+        if self.options.with_ocp:
+            self.requires("eigen/5.0.0", transitive_headers=True)
+        elif self.options.with_benchmarks:
+            self.requires("eigen/5.0.0")
+        else:
+            self.test_requires("eigen/5.0.0")
+        if self.options.with_benchmarks:
+            self.requires("benchmark/1.9.4")
+        if self.options.with_python:
+            self.requires("nanobind/2.9.2")
+            if self.options.with_python_dispatch:
+                self.requires("cpu_features/0.10.1")
+            if self.options.with_conan_python:
+                self.requires("tttapa-python-dev/3.13.7")
+
+    def build_requirements(self):
+        self.test_requires("gtest/1.17.0")
+        self.tool_requires("cmake/[>=3.24 <4.2]")
+
+    def config_options(self):
+        if self.settings.get_safe("os") == "Windows":
+            self.options.rm_safe("fPIC")
+
+    def configure(self):
+        with_tests = not self.conf.get("tools.build:skip_test", default=False)
+        if self.options.with_benchmarks or self.options.with_ocp or with_tests:
+            self.options["guanaqo/*"].with_blas = True
+
+    def layout(self):
+        cmake_layout(self)
+        self.cpp.build.builddirs.append("")
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        for k in self.bool_hyhound_options:
+            value = self.options.get_safe(k)
+            if value is not None and value.value is not None:
+                tc.variables["HYHOUND_" + k.upper()] = bool(value)
+        guanaqo = self.dependencies["guanaqo"]
+        index_type = guanaqo.options.get_safe("blas_index_type", default="int")
+        real_type = str(self.options.real_type)
+        print("index_type:", index_type)
+        print("real_type: ", real_type)
+        tc.variables["HYHOUND_DENSE_INDEX_TYPE"] = index_type
+        tc.variables["HYHOUND_DENSE_REAL_TYPE"] = real_type
+        if can_run(self):
+            tc.variables["HYHOUND_FORCE_TEST_DISCOVERY"] = True
+        tc.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+        cmake.test()
+
+    def package(self):
+        cmake = CMake(self)
+        cmake.install()
+
+    def package_info(self):
+        self.cpp_info.set_property("cmake_find_mode", "none")
+        self.cpp_info.builddirs.append(os.path.join("lib", "cmake", "hyhound"))