homapy 0.1.0rc0__tar.gz

homapy-0.1.0rc0/.clang-format

@@ -0,0 +1,44 @@
+---
+Language:        Cpp
+BasedOnStyle:  Chromium
+SortIncludes: Never
+IncludeBlocks: Preserve
+TabWidth: 4
+UseTab: Never
+
+AlignConsecutiveAssignments: true
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakTemplateDeclarations: true
+AlignTrailingComments: true
+BinPackArguments: false
+BinPackParameters: false
+BreakBeforeTernaryOperators: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+Cpp11BracedListStyle: true
+IndentCaseLabels: true
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 2
+NamespaceIndentation: None 
+ObjCBlockIndentWidth: 2
+ColumnLimit:     80
+AlignConsecutiveDeclarations: true
+
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterClass: true
+  AfterControlStatement: false
+  AfterEnum: true
+  AfterFunction: true
+  AfterNamespace: false
+  AfterStruct: true
+  AfterUnion: true
+  AfterExternBlock: true
+  BeforeCatch: false
+  BeforeElse: false
+...

homapy-0.1.0rc0/.github/workflows/build.yml

@@ -0,0 +1,43 @@
+name: Build
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  compile:
+    name: ${{ matrix.os }} Release
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04, windows-2022]
+
+    env:
+      CMAKE_BUILD_PARALLEL_LEVEL: 2
+      CTEST_OUTPUT_ON_FAILURE: 1
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install CUDA Toolkit
+        uses: Jimver/cuda-toolkit@v0.2.35
+        with:
+          cuda: "12.6.3"
+          method: network
+          log-file-suffix: ${{ matrix.os }}.txt
+
+      - name: Show tool versions
+        run: cmake --version && nvcc --version
+
+      - name: Configure
+        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DHOMA_BUILD_EXAMPLE=ON -DHOMA_BUILD_TESTS=ON -DHOMA_WITH_CHOLMOD=ON -DHOMA_WITH_MKL=ON -DHOMA_WITH_CUDSS=ON -DHOMA_WITH_CUDA=ON "-DCMAKE_CUDA_ARCHITECTURES=75;80;89;90"
+
+      - name: Build
+        run: cmake --build build --config Release --parallel 2
+
+      # - name: Test
+      #   run: ctest --test-dir build -C Release --output-on-failure

homapy-0.1.0rc0/.github/workflows/wheels.yml

@@ -0,0 +1,206 @@
+name: Build wheels
+
+on:
+  pull_request:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: "Publish target"
+        required: true
+        type: choice
+        default: "none"
+        options:
+          - none
+          - testpypi
+          - pypi
+
+permissions:
+  contents: read
+
+env:
+  CUDA_VERSION: "12.6.3"
+  CUDA_ARCHITECTURES: "89"
+
+jobs:
+  wheels:
+    name: Wheels (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+            artifact: homapy-wheels-linux
+          - os: windows-2022
+            artifact: homapy-wheels-windows
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install CUDA Toolkit on Windows
+        if: runner.os == 'Windows'
+        uses: Jimver/cuda-toolkit@v0.2.35
+        with:
+          cuda: ${{ env.CUDA_VERSION }}
+          method: network
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v2.21.3
+        env:
+          CIBW_BUILD: "cp39-* cp310-* cp311-* cp312-*"
+          CIBW_SKIP: "*-musllinux_*"
+          CIBW_ARCHS_LINUX: "x86_64"
+          CIBW_ARCHS_WINDOWS: "AMD64"
+          CIBW_BUILD_FRONTEND: "build"
+          CIBW_CONFIG_SETTINGS: >-
+            cmake.define.CMAKE_CUDA_ARCHITECTURES=${{ env.CUDA_ARCHITECTURES }}
+            cmake.define.HOMA_BUILD_PYTHON=ON
+            cmake.define.HOMA_BUILD_EXAMPLE=OFF
+            cmake.define.HOMA_BUILD_TESTS=OFF
+            cmake.define.HOMA_WITH_CUDA=OFF
+            cmake.define.HOMA_WITH_CHOLMOD=OFF
+            cmake.define.HOMA_WITH_MKL=OFF
+            cmake.define.HOMA_WITH_CUDSS=OFF
+            cmake.define.HOMA_WITH_LLOYD_PATCHER=OFF
+          CIBW_TEST_COMMAND: 'python -c "import homapy"'
+          CIBW_MANYLINUX_X86_64_IMAGE: "manylinux_2_28"
+          CIBW_ENVIRONMENT_LINUX: >-
+            PATH=/usr/local/cuda/bin:$PATH
+            LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH
+            CUDA_HOME=/usr/local/cuda
+            CUDA_PATH=/usr/local/cuda
+            CUDACXX=/usr/local/cuda/bin/nvcc
+          CIBW_BEFORE_ALL_LINUX: |
+            set -eux
+            dnf install -y dnf-plugins-core wget ca-certificates
+            dnf config-manager --add-repo https://developer.download.nvidia.com/compute/cuda/repos/rhel8/x86_64/cuda-rhel8.repo
+            dnf clean expire-cache
+            dnf install -y cuda-toolkit-12-6
+            ln -sfn /usr/local/cuda-12.6 /usr/local/cuda
+          CIBW_REPAIR_WHEEL_COMMAND_LINUX: >-
+            auditwheel repair
+            --exclude libcuda.so.1
+            --exclude libcudart.so.12
+            --exclude libcusolver.so.11
+            --exclude libcusparse.so.12
+            --exclude libnvJitLink.so.12
+            --exclude libnvrtc.so.12
+            -w {dest_dir} {wheel}
+
+      - name: Inspect Linux wheels
+        if: runner.os == 'Linux'
+        run: |
+          python -m pip install auditwheel
+          for wheel in wheelhouse/*.whl; do
+            auditwheel show "$wheel"
+          done
+
+      - name: Inspect Windows wheels
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          python -m pip install delvewheel
+          Get-ChildItem wheelhouse\*.whl | ForEach-Object { python -m delvewheel show $_.FullName }
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.artifact }}
+          path: wheelhouse/*.whl
+          if-no-files-found: error
+
+  sdist:
+    name: Source distribution
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build sdist
+        run: |
+          python -m pip install build
+          python -m build --sdist
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: homapy-sdist
+          path: dist/*.tar.gz
+          if-no-files-found: error
+
+  publish:
+    name: Publish package
+    runs-on: ubuntu-22.04
+    needs:
+      - wheels
+      - sdist
+    if: >-
+      startsWith(github.ref, 'refs/tags/v') ||
+      (github.event_name == 'workflow_dispatch' && github.event.inputs.publish != 'none')
+    permissions:
+      contents: read
+      id-token: write
+    environment: pypi
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Check tag matches pyproject version
+        if: startsWith(github.ref, 'refs/tags/v')
+        shell: bash
+        run: |
+          python - <<'PY'
+          import os
+          import sys
+          import tomllib
+
+          with open("pyproject.toml", "rb") as f:
+              version = tomllib.load(f)["project"]["version"]
+
+          tag = os.environ["GITHUB_REF_NAME"]
+          expected = f"v{version}"
+          if tag != expected:
+              print(f"Tag {tag!r} does not match pyproject.toml version {version!r}.")
+              print(f"Expected tag: {expected}")
+              sys.exit(1)
+
+          print(f"Publishing homapy {version} from pyproject.toml.")
+          PY
+
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: homapy-*
+          path: dist
+          merge-multiple: true
+
+      - name: Publish to TestPyPI
+        if: github.event_name == 'workflow_dispatch' && github.event.inputs.publish == 'testpypi'
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+          packages-dir: dist
+
+      - name: Publish to PyPI
+        if: startsWith(github.ref, 'refs/tags/v') || (github.event_name == 'workflow_dispatch' && github.event.inputs.publish == 'pypi')
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist

homapy-0.1.0rc0/.gitignore

@@ -0,0 +1,25 @@
+build/
+build_debug/
+cmake-build-release
+cmake-build-debug
+.vscode/
+.idea/
+.cursor/
+scripts/*.log
+scripts/*.ini
+scripts/*.nsys-rep
+scripts/*.sqlite
+scripts/*.obj
+
+# Logs anywhere in the tree
+*.log
+
+# CMake scratch dir kept outside of build/
+.tmp_build/
+
+# GUI / runtime state files (ImGui, Polyscope, etc.)
+imgui.ini
+.polyscope.ini
+*.mtx
+/scripts/examples/results
+*.pyc

homapy-0.1.0rc0/CMakeLists.txt

@@ -0,0 +1,320 @@
+cmake_minimum_required(VERSION 3.24 FATAL_ERROR)
+
+project(Homa
+        VERSION 0.1.0
+        LANGUAGES C CXX)
+
+set(HOMA_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+set(HOMA_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
+
+if(PROJECT_IS_TOP_LEVEL AND NOT CMAKE_CONFIGURATION_TYPES AND "${CMAKE_BUILD_TYPE}" STREQUAL "")
+    set(CMAKE_BUILD_TYPE Release)
+endif ()
+
+################################################################################
+# HOMA OPTIONS
+################################################################################
+option(HOMA_BUILD_EXAMPLE      "Build example executables"          OFF)
+option(HOMA_BUILD_TESTS        "Build unit tests"                   OFF)
+option(HOMA_BUILD_PYTHON       "Build Python bindings"              OFF)
+option(HOMA_WITH_CUDA          "Enable CUDA / GPU backend"          ON)
+option(HOMA_WITH_CHOLMOD       "Enable CHOLMOD linear solver"       ON)
+option(HOMA_WITH_MKL           "Enable MKL linear solver"           ON)
+option(HOMA_WITH_CUDSS         "Enable cuDSS linear solver"         ON)
+option(HOMA_WITH_LLOYD_PATCHER "Enable Lloyd-clustering patcher"    ON)
+option(HOMA_WITH_PROFILE       "Use Profile for benchmark"          OFF)
+
+set(_homa_needs_cuda OFF)
+if(HOMA_WITH_CUDA OR HOMA_WITH_CUDSS)
+    set(_homa_needs_cuda ON)
+endif()
+
+message(STATUS "HOMA_BUILD_EXAMPLE: ${HOMA_BUILD_EXAMPLE}")
+message(STATUS "HOMA_BUILD_TESTS: ${HOMA_BUILD_TESTS}")
+message(STATUS "HOMA_BUILD_PYTHON: ${HOMA_BUILD_PYTHON}")
+message(STATUS "HOMA_WITH_CUDA: ${HOMA_WITH_CUDA}")
+message(STATUS "HOMA_WITH_CHOLMOD: ${HOMA_WITH_CHOLMOD}")
+message(STATUS "HOMA_WITH_MKL: ${HOMA_WITH_MKL}")
+message(STATUS "HOMA_WITH_CUDSS: ${HOMA_WITH_CUDSS}")
+message(STATUS "HOMA_WITH_LLOYD_PATCHER: ${HOMA_WITH_LLOYD_PATCHER}")
+message(STATUS "HOMA_WITH_PROFILE: ${HOMA_WITH_PROFILE}")
+message(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
+
+if(PROJECT_IS_TOP_LEVEL)
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+endif()
+
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+if(_homa_needs_cuda AND
+   NOT DEFINED CMAKE_CUDA_ARCHITECTURES AND
+   "$ENV{CUDAARCHS}" STREQUAL "")
+    set(CMAKE_CUDA_ARCHITECTURES native CACHE STRING "CUDA architectures")
+endif()
+
+if(_homa_needs_cuda)
+    enable_language(CUDA)
+    message(STATUS "CMAKE_CUDA_ARCHITECTURES: ${CMAKE_CUDA_ARCHITECTURES}")
+endif()
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CUDA_STANDARD 20)
+set(CMAKE_CUDA_STANDARD_REQUIRED TRUE)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+
+if(_homa_needs_cuda)
+    set(CMAKE_CUDA_STANDARD 20)
+    set(CMAKE_CUDA_STANDARD_REQUIRED TRUE)
+    set(CUDA_RESOLVE_DEVICE_SYMBOLS ON)
+    set(CUDA_SEPARABLE_COMPILATION ON)
+endif()
+
+################################################################################
+# SECTION 1: Include Required Dependencies
+################################################################################
+
+set(cxx_flags
+        $<$<CXX_COMPILER_ID:MSVC>:-D_SCL_SECURE_NO_WARNINGS /openmp:experimental /MP /std:c++20 /bigobj>
+        $<$<AND:$<CXX_COMPILER_ID:GNU>,$<CONFIG:Release>>:-Wall -m64 -fopenmp -O3 -Wno-unused-function>
+        $<$<AND:$<CXX_COMPILER_ID:GNU>,$<CONFIG:Debug>>:-Wall -m64 -fopenmp -O0 -g3 -Wno-unused-function>
+)
+
+set(MSVC_XCOMPILER_FLAGS "/openmp:experimental /MP /std:c++20 /Zi")
+
+set(cuda_flags
+        #Windows stuff
+        -Xcompiler=$<$<CXX_COMPILER_ID:MSVC>:${MSVC_XCOMPILER_FLAGS}>
+        # Release
+        $<$<AND:$<CXX_COMPILER_ID:GNU>,$<CONFIG:Release>>:
+        -Xcompiler=-rdynamic,-Wall,-fopenmp,-O3,-Wno-unused-function
+        -O3
+        >
+        # Debug
+        $<$<AND:$<CXX_COMPILER_ID:GNU>,$<CONFIG:Debug>>:
+        -G
+        -O0
+        -Xptxas=-O0
+        -lineinfo
+        -Xcompiler=-rdynamic,-Wall,-fopenmp,-O0,-g3,-Wno-unused-function
+        >
+        # other common CUDA flags here
+        -rdc=true
+        --expt-extended-lambda
+        --expt-relaxed-constexpr
+        -Xptxas -warn-spills -res-usage
+        --ptxas-options=-v
+)
+
+add_library(homa_flags INTERFACE)
+target_compile_options(homa_flags INTERFACE
+        $<$<COMPILE_LANGUAGE:CXX>:${cxx_flags}>
+        $<$<COMPILE_LANGUAGE:CUDA>:${cuda_flags}>
+)
+
+# OpenMP
+find_package(OpenMP)
+if (OpenMP_CXX_FOUND)
+    target_link_libraries(homa_flags INTERFACE OpenMP::OpenMP_CXX)
+endif()
+
+if(_homa_needs_cuda)
+    find_package(CUDAToolkit REQUIRED)
+    target_link_libraries(homa_flags INTERFACE CUDA::cudart CUDA::cusparse CUDA::cusolver)
+endif()
+
+# Core deps — always needed for the homa library
+include(${HOMA_SOURCE_DIR}/cmake/recipes/eigen.cmake)
+include(${HOMA_SOURCE_DIR}/cmake/recipes/metis.cmake)
+include(${HOMA_SOURCE_DIR}/cmake/recipes/spdlog.cmake)
+# SuiteSparse/AMD is always needed: cpu_ordering_with_patch uses amd.h for local ordering
+include(${HOMA_SOURCE_DIR}/cmake/recipes/suitesparse.cmake)
+
+if(HOMA_WITH_LLOYD_PATCHER)
+    include(${HOMA_SOURCE_DIR}/cmake/recipes/lloyd_clustering.cmake)
+endif()
+
+if(HOMA_WITH_MKL)
+    set(HOMA_MKL_ALLOW_DOWNLOAD ON CACHE BOOL "Download Intel MKL wheels when an installed MKL is not found")
+    set(HOMA_MKL_VERSION "2025.3.0" CACHE STRING "Intel MKL wheel fallback version")
+    set(HOMA_MKL_INTERFACE "lp64" CACHE STRING "Intel MKL interface layer")
+    set(HOMA_MKL_THREADING "intel" CACHE STRING "Intel MKL threading layer")
+    set(HOMA_MKL_LINKING "sdl" CACHE STRING "Intel MKL linking mode")
+    set_property(CACHE HOMA_MKL_INTERFACE PROPERTY STRINGS lp64)
+    set_property(CACHE HOMA_MKL_THREADING PROPERTY STRINGS intel sequential)
+    set_property(CACHE HOMA_MKL_LINKING PROPERTY STRINGS sdl)
+    include(${HOMA_SOURCE_DIR}/cmake/recipes/mkl.cmake)
+endif()
+
+if(HOMA_WITH_CHOLMOD)
+    include(${HOMA_SOURCE_DIR}/cmake/recipes/cholmod.cmake)
+endif()
+
+if(HOMA_WITH_CUDSS)
+    set(HOMA_CUDSS_ALLOW_DOWNLOAD ON CACHE BOOL "Download NVIDIA cuDSS wheels when an installed cuDSS is not found")
+    set(HOMA_CUDSS_VERSION "0.7.1.6" CACHE STRING "NVIDIA cuDSS wheel fallback version")
+    include(${HOMA_SOURCE_DIR}/cmake/recipes/cudss.cmake)
+endif()
+
+if(HOMA_BUILD_EXAMPLE)
+    include(${HOMA_SOURCE_DIR}/cmake/recipes/cli11.cmake)
+    include(${HOMA_SOURCE_DIR}/cmake/recipes/libigl.cmake)
+endif()
+
+function(homa_configure_runtime target_name)
+    if(NOT TARGET ${target_name})
+        message(FATAL_ERROR "homa_configure_runtime: target '${target_name}' does not exist")
+    endif()
+
+    get_property(_homa_runtime_configured TARGET ${target_name} PROPERTY homa_runtime_configured)
+    if(_homa_runtime_configured)
+        return()
+    endif()
+
+    if(COMMAND homa_configure_mkl_runtime)
+        homa_configure_mkl_runtime(${target_name})
+    endif()
+    if(COMMAND homa_configure_cudss_runtime)
+        homa_configure_cudss_runtime(${target_name})
+    endif()
+
+    set_property(TARGET ${target_name} PROPERTY homa_runtime_configured TRUE)
+endfunction()
+
+# Create a dependency interface target to hold configuration
+add_library(homa_deps INTERFACE)
+
+################################################################################
+# SECTION 3: Configure Dependencies
+################################################################################
+
+if(HOMA_WITH_PROFILE)
+    target_compile_definitions(homa_deps INTERFACE USE_PROFILE)
+endif()
+
+if(TARGET Eigen3::Eigen)
+    get_target_property(EIGEN_INCLUDES Eigen3::Eigen INTERFACE_INCLUDE_DIRECTORIES)
+    message(STATUS "=== EIGEN DEBUG ===")
+    message(STATUS "Eigen3::Eigen include dirs: ${EIGEN_INCLUDES}")
+    message(STATUS "===================")
+endif()
+
+set(_homa_sources
+    src/ordering/homa.cpp    
+    src/ordering/cpu_ordering_with_patch.cpp
+    src/ordering/amd_order_helper.cpp
+    src/patching/greedy_patcher.cpp
+    src/patching/metis_patcher.cpp
+    src/utils/remove_diagonal.cpp
+    src/utils/check_valid_permutation.cpp
+	src/utils/compress_hessian.cpp
+    src/solvers/LinSysSolver.cpp	
+    include/homa/solvers/LinSysSolver.h
+	include/homa/solvers/CHOLMODSolver.h
+	include/homa/solvers/CUDSSSolver.h
+	include/homa/solvers/MKLSolver.h
+	include/homa/solvers/scalar_traits.h
+	include/homa/matrix_view.h
+	include/homa/homa.h
+	include/homa/patcher.h
+	include/homa/types.h
+	include/homa/utils/check_valid_permutation.h
+	include/homa/utils/compress_hessian.h
+	include/homa/utils/nvtx_helper.h
+	include/homa/utils/remove_diagonal.h
+	include/homa/utils/SPD_cot_matrix.h
+)
+if(HOMA_WITH_LLOYD_PATCHER)
+    list(APPEND _homa_sources src/patching/lloyd_patcher.cpp)
+endif()
+if(HOMA_WITH_CHOLMOD)
+    list(APPEND _homa_sources 
+        src/solvers/CHOLMODSolver.cpp
+        include/homa/solvers/CHOLMODSolver.h)
+endif()
+if(HOMA_WITH_MKL)
+    list(APPEND _homa_sources
+        src/solvers/MKLSolver.cpp
+        include/homa/solvers/MKLSolver.h)
+endif()
+if(HOMA_WITH_CUDSS)
+    list(APPEND _homa_sources 
+        src/solvers/CUDSSSolver.cu
+        include/homa/solvers/CUDSSSolver.h
+        include/homa/utils/cuda_error_handler.h)
+endif()
+
+add_library(homa STATIC ${_homa_sources})
+
+target_include_directories(homa
+    PUBLIC  include
+    PRIVATE src
+)
+
+set(_homa_public_libs
+    homa_deps
+    Eigen3::Eigen
+    spdlog::spdlog
+)
+
+if(HOMA_WITH_MKL)
+    list(APPEND _homa_public_libs Homa::MKL)
+endif()
+
+list(APPEND _homa_public_libs metis)
+
+target_link_libraries(homa
+    PUBLIC ${_homa_public_libs}
+    PRIVATE
+        homa_flags
+        SuiteSparse::AMD
+)
+target_include_directories(homa PRIVATE ${AMD_INCLUDE_DIR} ${SUITESPARSE_CONFIG_INCLUDE_DIR})
+target_compile_definitions(homa PUBLIC
+    $<$<CONFIG:Debug>:DEBUG>
+    $<$<CONFIG:Release>:NDEBUG>
+)
+
+if(_homa_needs_cuda)
+    target_link_libraries(homa PUBLIC CUDA::cudart)
+endif()
+
+if(HOMA_WITH_LLOYD_PATCHER)
+    target_link_libraries(homa PRIVATE mesh_clustering_lib)
+    target_compile_definitions(homa PRIVATE HOMA_WITH_LLOYD_PATCHER)
+endif()
+
+if(HOMA_WITH_MKL)
+    target_compile_definitions(homa PUBLIC USE_MKL)
+endif()
+
+if(HOMA_WITH_CHOLMOD)
+    target_link_libraries(homa PUBLIC SuiteSparse::CHOLMOD)
+    target_compile_definitions(homa PUBLIC USE_CHOLMOD)
+endif()
+
+if(HOMA_WITH_CUDSS)
+    target_link_libraries(homa PUBLIC cudss)
+    target_compile_definitions(homa PUBLIC USE_CUDSS)
+    set_property(TARGET homa PROPERTY CUDA_SEPARABLE_COMPILATION ON)
+    set_property(TARGET homa PROPERTY CUDA_RESOLVE_DEVICE_SYMBOLS ON)
+endif()
+
+add_library(Homa::homa ALIAS homa)
+
+if(HOMA_BUILD_TESTS)
+    enable_testing()
+    add_subdirectory(tests)
+endif()
+
+if(HOMA_BUILD_EXAMPLE)
+    add_library(libigl_utils INTERFACE)
+    target_link_libraries(libigl_utils INTERFACE igl::core Eigen3::Eigen)
+    target_include_directories(libigl_utils INTERFACE src/utils)
+    add_subdirectory(examples)
+
+endif()
+
+if(HOMA_BUILD_PYTHON)
+    add_subdirectory(python)
+endif()

homapy-0.1.0rc0/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2026, Behrooz Zarebavani and Ahmed Mahmoud
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.