lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/cmake/FindHipoDeps.cmake

@@ -0,0 +1,351 @@
+# Fetch OpenBLAS
+if (BUILD_OPENBLAS)
+    include(FetchContent)
+    set(FETCHCONTENT_QUIET OFF)
+    set(FETCHCONTENT_UPDATES_DISCONNECTED ON)
+    # set(BUILD_SHARED_LIBS ON)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+    set(BUILD_TESTING OFF)
+    set(CMAKE_Fortran_COMPILER OFF)
+
+    # Define the size-minimizing flags as a list
+    set(OPENBLAS_MINIMAL_FLAGS
+        # Exclude components not used by HiGHS
+        -DONLY_CBLAS:BOOL=ON
+        -DNO_LAPACK:BOOL=ON
+        -DNO_LAPACKE:BOOL=ON
+        -DNO_COMPLEX:BOOL=ON
+        -DNO_COMPLEX16:BOOL=ON
+        -DNO_DOUBLE_COMPLEX:BOOL=ON
+        -DNO_SINGLE:BOOL=ON
+    )
+
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|armv8|arm")
+        if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+            message(FATAL_ERROR "The HiGHS build with OpenBLAS does not yet support 32-bit ARM architectures. \
+            You could try to compile OpenBLAS separately on your machine, see https://github.com/OpenMathLib/OpenBLAS. \
+            Then link with HiGHS by passing the path to the OpenBLAS installation via BLAS_ROOT. \
+            Please don't hesitate to get in touch with us with details about your related issues.")
+
+            # Unreachable, revisit later. Could not get it to work on the CI, -DNOASM=1 is not being respected and openblas
+            # keeps trying to use 64bit registers which are not available. Works fine on 32bit amd and 64bit arm.
+            message(STATUS "ARM architecture detected. 32bit.")
+
+            # list(APPEND OPENBLAS_MINIMAL_FLAGS -DARMV7:BOOL=ON)
+             # Set environment variable to disable assembly
+            # set(ENV{NOASM} "1")
+            # set(NOASM 1)
+
+            list(APPEND OPENBLAS_MINIMAL_FLAGS
+                -DTARGET=GENERIC
+                -DBINARY=32
+                -DNOASM=1
+                -DDYNAMIC_ARCH:BOOL=OFF
+                -DUSE_THREAD:BOOL=OFF
+                # Aggressively disable complex operations
+                -DNO_CGEMM:BOOL=ON
+                -DNO_ZGEMM:BOOL=ON
+                -DNO_CTRMM:BOOL=ON
+                -DNO_ZTRMM:BOOL=ON
+                -DNO_CTRSM:BOOL=ON
+                -DNO_ZTRSM:BOOL=ON
+                # Disable all Level 3 BLAS (includes TRMM, TRSM, etc.)
+                -DNO_LEVEL3:BOOL=ON
+                -DCMAKE_C_FLAGS="-march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=softfp"
+                -DCMAKE_ASM_FLAGS="-march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=softfp"
+                -DCMAKE_CXX_FLAGS="-march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=softfp"
+                # -DARM_SOFTFP_ABI=1
+                # -DCMAKE_ASM_FLAGS="-mfpu=vfpv3-d16"
+                # -DCMAKE_C_FLAGS="-march=armv7-a -mfpu=vfpv3-d16"
+                # -DCMAKE_ASM_FLAGS="-march=armv7-a -mfpu=vfpv3-d16"
+                # -DCMAKE_CXX_FLAGS="-march=armv7-a -mfpu=vfpv3-d16"
+            )
+            # list(APPEND OPENBLAS_MINIMAL_FLAGS -DTARGET=GENERIC)
+            # list(APPEND OPENBLAS_MINIMAL_FLAGS
+            #     -DDYNAMIC_ARCH:BOOL=OFF
+            #     -DUSE_THREAD:BOOL=OFF        # Simplify build
+            #     -DNO_WARMUP:BOOL=ON          # Skip warmup routine
+            #     # -DNO_GETARCH:BOOL=ON
+            #     # -DUSE_VFPV3:BOOL=ON
+            #     # -DUSE_VFPV3_D32:BOOL=OFF   # crucial: only use d0–d15
+            #     # -DNO_TRMM:BOOL=ON
+            #     # -DNO_TRSM:BOOL=ON
+            #     -DNO_L3:BOOL=ON               # skip complex Level-3 kernels
+            #     # -DCMAKE_ASM_FLAGS="-mfpu=vfpv3-d16"
+            #     # -DUSE_GENERIC:BOOL=ON
+            # )
+            # # Explicitly disable assembly
+
+            # set(CMAKE_ASM_COMPILER "")
+            # set(NOASM 1)
+
+            # set(SKIP_PARSE_GETARCH TRUE)
+        else()
+            message(STATUS "ARM architecture detected. Applying -DTARGET=ARMV8.")
+            list(APPEND OPENBLAS_MINIMAL_FLAGS -DTARGET=ARMV8)
+            # list(APPEND OPENBLAS_MINIMAL_FLAGS -DONLY_BLAS=ON -DNO_LAPACK=ON -DNO_LAPACKE=ON)
+        endif()
+    # else()
+        # list(APPEND OPENBLAS_MINIMAL_FLAGS -DONLY_BLAS=ON -DNO_LAPACK=ON -DNO_LAPACKE=ON)
+    endif()
+
+    # CMAKE_SIZEOF_VOID_P is 4 for 32-bit builds, 8 for 64-bit builds.
+    if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+        message(STATUS "32-bit target detected. Applying 32-bit configuration flags for OpenBLAS.")
+
+        if (WIN32)
+            list(APPEND OPENBLAS_MINIMAL_FLAGS -DCMAKE_GENERATOR_PLATFORM=Win32)
+        endif()
+
+        # Crucial for static linking: Force OpenBLAS to use the static runtime
+        # if (NOT BUILD_SHARED_LIBS)
+        #     set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded")
+        # endif()
+        # now global
+
+        # list(APPEND OPENBLAS_MINIMAL_FLAGS -DUSE_THREAD=OFF)
+        list(APPEND OPENBLAS_MINIMAL_FLAGS -DINTERFACE64=0)
+
+        # If the MSVC runtime library issue persists, you can try this flag as well,
+        # though CMAKE_GENERATOR_PLATFORM should usually be sufficient.
+        # list(APPEND OPENBLAS_MINIMAL_FLAGS -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreadedDLL)
+    endif()
+
+    if(UNIX AND NOT APPLE)
+        execute_process(
+            COMMAND bash -c "grep -m1 'model name' /proc/cpuinfo | grep -i skylake"
+            RESULT_VARIABLE SKYLAKE_CHECK
+            OUTPUT_QUIET
+            ERROR_QUIET
+        )
+
+        if(SKYLAKE_CHECK EQUAL 0)
+            message(STATUS "Skylake detected - adjusting OpenBLAS target to avoid register spills")
+            set(OPENBLAS_TARGET "HASWELL" CACHE STRING "OpenBLAS target architecture" FORCE)
+            set(NO_AVX512 ON CACHE BOOL "Disable AVX512" FORCE)
+            # set(CMAKE_C_FLAGS_OPENBLAS "-DTARGET=HASWELL -DNO_AVX512=1")
+        else()
+            message(STATUS "NOT Skylake")
+        endif()
+
+        if(NO_AVX512)
+            message(STATUS "NO_AVX512 - adjusting OpenBLAS possibly for valgrind")
+            set(NO_AVX512 ON CACHE BOOL "Disable AVX512" FORCE)
+            # set(CMAKE_C_FLAGS_OPENBLAS "-DTARGET=HASWELL -DNO_AVX512=1")
+        endif()
+    endif()
+
+    set(OPENBLAS_BUILD_TYPE "Release" CACHE STRING "Build type for OpenBLAS" FORCE)
+
+    # Override CMAKE_BUILD_TYPE for OpenBLAS subdirectory
+    set(CMAKE_BUILD_TYPE_BACKUP ${CMAKE_BUILD_TYPE})
+    set(CMAKE_BUILD_TYPE Release)
+
+    message(CHECK_START "Fetching OpenBLAS")
+    list(APPEND CMAKE_MESSAGE_INDENT "  ")
+    FetchContent_Declare(
+        openblas
+        GIT_REPOSITORY "https://github.com/OpenMathLib/OpenBLAS.git"
+        GIT_TAG        "v0.3.30"
+        GIT_SHALLOW TRUE
+        UPDATE_COMMAND git reset --hard
+        CMAKE_ARGS
+            ${OPENBLAS_MINIMAL_FLAGS}
+            # Force optimization even in Debug builds to avoid register spills
+            # Force high optimization and strip debug symbols for the kernels
+            # -DCMAKE_BUILD_TYPE=Release
+            # -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS_OPENBLAS}
+            # -DCMAKE_C_FLAGS="-O3 -fomit-frame-pointer"
+            # -DCMAKE_C_FLAGS_RELEASE="-O3 -fomit-frame-pointer"
+            # -DCMAKE_C_FLAGS_DEBUG="-O2 -fomit-frame-pointer"
+            # -DCORE_OPTIMIZATION="-O3"
+    )
+    FetchContent_MakeAvailable(openblas)
+
+    if (ALL_TESTS)
+        set(BUILD_TESTING ON)
+    endif()
+
+    set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE_BACKUP})
+
+    list(POP_BACK CMAKE_MESSAGE_INDENT)
+    message(CHECK_PASS "fetched")
+
+    if (TARGET openblas)
+        get_target_property(_openblas_aliased openblas ALIASED_TARGET)
+        if(_openblas_aliased)
+            set(_openblas_target ${_openblas_aliased})
+            message(STATUS "OpenBLAS is an alias for: ${_openblas_target}")
+        else()
+            set(_openblas_target openblas)
+        endif()
+    elseif (TARGET openblas_static)
+        set(_openblas_target openblas_static)
+    elseif (TARGET openblas_shared)
+        set(_openblas_target openblas_shared)
+    else()
+        message(FATAL_ERROR "OpenBLAS target not found")
+    endif()
+    message(STATUS "OpenBLAS target: ${_openblas_target}")
+
+    return()
+endif()
+
+# Find BLAS
+set(BLAS_ROOT "" CACHE STRING "Root directory of BLAS or OpenBLAS")
+if (NOT BLAS_ROOT STREQUAL "")
+    message(STATUS "BLAS_ROOT is " ${BLAS_ROOT})
+endif()
+
+set(USE_CMAKE_FIND_BLAS ON)
+
+# Optionally set the vendor:
+# set(BLA_VENDOR libblastrampoline)
+
+if (NOT USE_CMAKE_FIND_BLAS)
+    if (WIN32)
+        if (NOT (BLAS_ROOT STREQUAL ""))
+            message(STATUS "Looking for blas in " ${BLAS_ROOT})
+            set(OpenBLAS_ROOT ${BLAS_ROOT})
+            message(STATUS "OpenBLAS_ROOT is ${OpenBLAS_ROOT} ")
+            find_package(OpenBLAS CONFIG NO_DEFAULT_PATH)
+
+            if(OpenBLAS_FOUND)
+                message(STATUS "OpenBLAS CMake config path: ${OpenBLAS_DIR}")
+            else()
+                message(STATUS "OpenBLAS not found in ${BLAS_ROOT}")
+            endif()
+        endif()
+
+        if ((BLAS_ROOT STREQUAL "") OR (NOT OpenBLAS_FOUND))
+            # (NOT OpenBLAS_FOUND AND NOT BLAS_FOUND))
+            message(STATUS "Looking for blas")
+
+            find_package(OpenBLAS REQUIRED)
+
+            if(OpenBLAS_FOUND)
+                if(TARGET OpenBLAS::OpenBLAS)
+                    message(STATUS "OpenBLAS CMake config path: ${OpenBLAS_DIR}")
+                elseif(OPENBLAS_LIB)
+                    message(STATUS "Linking against OpenBLAS via raw library: ${OPENBLAS_LIB}")
+                else()
+                    # try blas
+                    # find_package(BLAS)
+                    # if (BLAS_FOUND)
+                    #     message(STATUS "Using BLAS library: ${BLAS_LIBRARIES}")
+                    #     message(STATUS "BLAS include dirs: ${BLAS_INCLUDE_DIRS}")
+                    # else()
+                    #     message(STATUS "OpenBLAS found but no target?")
+                    # endif()
+                endif()
+            else()
+                message(FATAL_ERROR "No BLAS library found")
+            endif()
+        endif()
+
+    elseif(NOT APPLE)
+        # LINUX
+
+        # If a BLAS install was specified try to use it first.
+        if (NOT (BLAS_ROOT STREQUAL ""))
+            message(STATUS "Looking for blas in " ${BLAS_ROOT})
+
+            find_library(OPENBLAS_LIB
+                NAMES openblas
+                HINTS "${BLAS_ROOT}/lib"
+                NO_DEFAULT_PATH)
+
+            if(OPENBLAS_LIB)
+                message(STATUS "Found OpenBLAS library at ${OPENBLAS_LIB}")
+            else()
+                find_library(BLAS_LIB
+                    NAMES blas
+                    HINTS "${BLAS_ROOT}/lib"
+                    NO_DEFAULT_PATH)
+
+                if(BLAS_LIB)
+                    message(STATUS "Found BLAS library at ${BLAS_LIB}")
+                else()
+                    message(STATUS "Did not find blas library at ${BLAS_ROOT}")
+                    message(STATUS "Attempting default locations search")
+                endif()
+            endif()
+        endif()
+        if ((BLAS_ROOT STREQUAL "") OR (NOT OPENBLAS_LIB AND NOT BLAS_LIB))
+
+            find_library(OPENBLAS_LIB
+                NAMES openblas
+                HINTS "${BLAS_ROOT}/lib")
+
+            if(OPENBLAS_LIB)
+                message(STATUS "Found OpenBLAS library at ${OPENBLAS_LIB}")
+            else()
+                find_library(BLAS_LIB
+                    NAMES blas
+                    HINTS "${BLAS_ROOT}/lib")
+
+                if(BLAS_LIB)
+                    message(STATUS "Found BLAS library at ${BLAS_LIB}")
+                else()
+                    message(FATAL_ERROR "No BLAS library found")
+                endif()
+            endif()
+        endif()
+    endif()
+else()
+
+    if (WIN32 AND NOT BLAS_LIBRARIES AND NOT BLA_VENDOR)
+        find_package(OpenBLAS CONFIG)
+        if(OpenBLAS_FOUND)
+            message(STATUS "OpenBLAS CMake config path: ${OpenBLAS_DIR}")
+        endif()
+    endif()
+
+    if (NOT OpenBLAS_FOUND)
+        if (NOT BLA_VENDOR)
+            if (APPLE)
+                set (BLA_VENDOR Apple)
+            elseif(LINUX)
+                set (BLA_VENDOR OpenBLAS)
+            elseif(WIN32)
+                set (BLA_VENDOR OpenBLAS)
+            endif()
+
+            find_package(BLAS QUIET)
+            if (BLAS_FOUND)
+                message(STATUS "Using BLAS library: ${BLAS_LIBRARIES}")
+                if (BLAS_INCLUDE_DIRS)
+                    message(STATUS "BLAS include dirs: ${BLAS_INCLUDE_DIRS}")
+                endif()
+            else()
+                unset(BLA_VENDOR)
+            endif()
+        else()
+            message(STATUS "Specified BLA_VENDOR: ${BLA_VENDOR}")
+        endif()
+
+        # try libblas on linux
+        if (LINUX AND NOT BLAS_FOUND)
+            find_package(BLAS QUIET)
+            if (BLAS_FOUND)
+                message(STATUS "Using BLAS library: ${BLAS_LIBRARIES}")
+                if (BLAS_INCLUDE_DIRS)
+                    message(STATUS "BLAS include dirs: ${BLAS_INCLUDE_DIRS}")
+                endif()
+            endif()
+        endif()
+
+        if (NOT BLAS_FOUND AND
+            (BUILD_SHARED_LIBS OR BUILD_CXX_EXE OR BUILD_EXAMPLES))
+            find_package(BLAS REQUIRED)
+            if (BLAS_FOUND)
+                message(STATUS "Using BLAS library: ${BLAS_LIBRARIES}")
+                if (BLAS_INCLUDE_DIRS)
+                    message(STATUS "BLAS include dirs: ${BLAS_INCLUDE_DIRS}")
+                endif()
+            else()
+                message(FATAL_ERROR "No BLAS library found!")
+            endif()
+        endif()
+    endif()
+endif()

data/ext/lpsolver-highs/cmake/README.md

@@ -0,0 +1,243 @@
+# HiGHS CMake Build Instructions
+
+| OS       | C++   | Fortran | Python   | CSharp Example | .NET |
+|:-------- | :---: | :------: | :----: | :----: | :----: |
+| Linux    | [![Status][linux_cpp_svg]][linux_cpp_link] | [![Status][linux_fortran_svg]][linux_fortran_link] | [![Status][linux_python_svg]][linux_python_link] | *(1)* | [![Status][linux_dotnet_svg]][linux_dotnet_link] |
+| MacOS    | [![Status][macos_cpp_svg]][macos_cpp_link] | [![Status][macos_fortran_svg]][macos_fortran_link]  |  [![Status][macos_python_svg]][macos_python_link] | *(1)* |[![Status][macos_dotnet_svg]][macos_dotnet_link] |
+| Windows  | [![Status][windows_cpp_svg]][windows_cpp_link] | *(2)* | [![Status][windows_python_svg]][windows_python_link] | [![Status][windows_csharp_svg]][windows_csharp_link] | [![Status][windows_dotnet_svg]][windows_dotnet_link] |
+
+[linux_cpp_svg]: https://github.com/ERGO-Code/HiGHS/actions/workflows/cmake-linux-cpp.yml/badge.svg
+[linux_cpp_link]: https://github.com/ERGO-Code/HiGHS/actions/workflows/cmake-linux-cpp.yml
+[macos_cpp_svg]: https://github.com/ERGO-Code/HiGHS/actions/workflows/cmake-macos-cpp.yml/badge.svg
+[macos_cpp_link]: https://github.com/ERGO-Code/HiGHS/actions/workflows/cmake-macos-cpp.yml
+[windows_cpp_svg]: https://github.com/ERGO-Code/HiGHS/actions/workflows/cmake-windows-cpp.yml/badge.svg
+[windows_cpp_link]: https://github.com/ERGO-Code/HiGHS/actions/workflows/cmake-windows-cpp.yml
+
+[linux_python_svg]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-python-ubuntu.yml/badge.svg
+[linux_python_link]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-python-ubuntu.yml
+[macos_python_svg]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-python-macos.yml/badge.svg
+[macos_python_link]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-python-macos.yml
+[windows_python_svg]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-python-win.yml/badge.svg
+[windows_python_link]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-python-win.yml
+
+[windows_csharp_svg]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-csharp-win.yml/badge.svg
+[windows_csharp_link]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-csharp-win.yml
+
+[linux_dotnet_svg]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-nuget-ubuntu.yml/badge.svg
+[linux_dotnet_link]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-nuget-ubuntu.yml
+[macos_dotnet_svg]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-nuget-macos.yml/badge.svg
+[macos_dotnet_link]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-nuget-macos.yml
+[windows_dotnet_svg]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-nuget-win.yml/badge.svg
+[windows_dotnet_link]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-nuget-win.yml
+
+[linux_fortran_svg]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-fortran-ubuntu.yml/badge.svg
+[linux_fortran_link]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-fortran-ubuntu.yml
+[macos_fortran_svg]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-fortran-macos.yml/badge.svg
+[macos_fortran_link]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-fortran-macos.yml
+[windows_fortran_svg]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-fortran-win.yml/badge.svg
+[windows_fortran_link]: https://github.com/ERGO-Code/HiGHS/actions/workflows/test-fortran-win.yml
+
+*(1)* CMake C# is currently only supported for Microsoft Visual Studio 11 2012 and
+  later. You can still build and run the HiGHS C# nuget package on Linux and MacOS with `dotnet`, see the workflows in the .NET column. It is only the CSharp example build with CMake that is not supported for Unix generators.
+
+*(2)* Not tested yet.
+
+<!--# ?branch=main -->
+<br>
+
+*Contents*
+
+- [HiGHS CMake Build Instructions](#highs-cmake-build-instructions)
+  - [Introduction](#introduction)
+  - [Requirement](#requirement)
+  - [Supported compilers](#supported-compilers)
+- [Build](#build)
+  - [Install](#install)
+  - [Windows](#windows)
+- [CMake Options](#cmake-options)
+- [Integrating HiGHS in your CMake Project](#integrating-highs-in-your-cmake-project)
+
+## Introduction
+
+HiGHS can be built from source using CMake: <http://www.cmake.org/>. CMake works by generating native Makefiles or build projects that can be used in the compiler environment of your choice.
+
+HiGHS can be built as a standalone project or it could be incorporated into an existing CMake project.
+
+## Requirement
+You'll need:
+
+* `CMake >= 3.15`.
+* A C++11 compiler
+
+## Supported compilers
+
+Here is a list of the supported compilers:
+
+* Clang `clang`
+* GNU `g++`
+* Intel `icc`
+* Microsoft `MSVC`
+
+# Build
+
+To build the C++ library and executable run
+
+``` bash
+cd HiGHS
+cmake -S. -B build
+cmake --build build --parallel
+```
+
+This generates HiGHS in the `build` directory and creates the [executable](@ref Executable) `build/bin/highs`, or `build/Release/bin/highs.exe` on Windows. To perform a quick test to see whether the compilation was successful, run `ctest` from within the build folder.
+
+``` bash
+ctest
+```
+
+On Windows, the configuration type must be specified:
+``` bash
+ctest -C Release
+```
+
+The default compiler for HiGHS on Windows is MSVC, to use `mingw64` some additional cmake flags are required:
+``` bash
+cmake -D CMAKE_CXX_COMPILER=g++ -D CMAKE_C_COMPILER=gcc -G "MinGW Makefiles" -S. -B build
+```
+
+
+## Install
+
+The default installation location may need administrative
+permissions. To install, after building and testing, run
+
+``` bash
+cmake --install build
+```
+
+form the root directory.
+
+To install in a specified installation directory run CMake with the
+`CMAKE_INSTALL_PREFIX` flag set:
+
+``` bash
+cmake -S. -B build -DCMAKE_INSTALL_PREFIX=/path/to/highs_install
+cmake --build build --parallel
+cmake --install build
+```
+
+## Windows
+
+By default, CMake builds the debug version of the binaries. These are generated in a directory `Debug`. To build a release version, add the option `--config Release`
+
+```shell
+    cmake -S . -B build
+    cmake --build build --config Release
+```
+
+It is also possible to specify a specific Visual studio version to build with:
+```shell
+    cmake -G "Visual Studio 17 2022" -S . -B build
+    cmake --build build
+```
+
+When building under Windows, some extra options are available.  One is building a 32 bit version or a 64 bit version. The default build is 64 bit. To build 32 bit, the following commands can be used from the `HiGHS/` directory:
+
+```shell
+    cmake -A Win32 -S . -B buildWin32
+    cmake --build buildWin32
+```
+
+Another thing specific for windows is the calling convention, particularly important for the HiGHS dynamic library (dll). The default calling convention in windows is cdecl calling convention, however, dlls are most often compiled with stdcall. Most applications which expect stdcall, can't access dlls with cdecl and vice versa. To change the default calling convention from cdecl to stdcall the following option can be added
+```shell
+    cmake -DSTDCALL=ON -S . -B build
+    cmake --build build
+```
+
+<!-- An extra note. With the legacy `-DFAST_BUILD=OFF`, under windows the build dll is called `highs.dll` however the exe expects `libhighs.dll` so a manual copy of `highs.dll` to `libhighs.dll` is needed. Of course all above options can be combined with each other. -->
+
+
+# CMake Options
+
+There are several options that can be passed to CMake to modify how the code
+is built.<br>
+To set these options and parameters, use `-D<Parameter_name>=<value>`.
+
+All CMake options are passed at configure time, i.e., by running <br>
+`cmake -S. -B<your_chosen_build_directory> -DOPTION_ONE=ON -DOPTION_TWO=OFF ...` <br>
+before running `cmake --build <your_chosen_build_directory>`<br>
+
+For example, to generate build files in a new
+subdirectory called 'build', run:
+
+```shell
+cmake -S. -Bbuild
+```
+and then build with:
+
+```shell
+cmake --build build
+```
+
+Following is a list of available options:
+| CMake Option | Default Value | Note |
+|:-------------|:--------------|:-----|
+| `CMAKE_BUILD_TYPE` | Release | see CMake documentation [here](https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html) |
+| `BUILD_SHARED_LIBS` | ON(*) |  Build shared libraries (.so or .dyld). * OFF by default on Windows |
+| `BUILD_CXX` | ON | Build C++ |
+| `FORTRAN` | OFF | Build Fortran interface |
+| `CSHARP` | OFF | Build CSharp wrapper |
+| `BUILD_DOTNET` | OFF | Build .Net package |
+| `PYTHON_BUILD_SETUP` | OFF | Build Python bindings. Called at `pip install` from pyproject.toml |
+| `ZLIB` | ON | Use ZLIB if available |
+| `ALL_TESTS` | OFF | Run unit tests and extended instance test set |
+
+<!-- Following is a list of available options, for the full list run:
+
+```shell
+cmake -S. -Bbuild -LH
+``` -->
+
+HiGHS can be integrated into other CMake-based projects.
+
+# Integrating HiGHS in your CMake Project
+
+If you already have HiGHS installed on your system, you can use `find_package()` to include HiGHS in your C++ CMake project.
+
+```
+project(LOAD_HIGHS LANGUAGES CXX)
+
+set(HIGHS_DIR path_to_highs_install/lib/cmake/highs)
+
+find_package(HIGHS REQUIRED)
+
+add_executable(main main.cpp)
+target_link_libraries(main highs::highs)
+```
+
+The line
+```
+set(HIGHS_DIR path_to_highs_install/lib/cmake/highs)
+```
+adds the HiGHS installation path to `HIGHS_DIR`. This is equivalent to building this project with
+``` bash
+cmake -DHIGHS_DIR=path_to_highs_install/lib/cmake/highs ..
+```
+
+Alternatively, if you wish to include the code of HiGHS within your project, FetchContent is also available as follows:
+
+```
+project(LOAD_HIGHS LANGUAGES CXX)
+
+include(FetchContent)
+
+FetchContent_Declare(
+    highs
+    GIT_REPOSITORY "https://github.com/ERGO-Code/HiGHS.git"
+    GIT_TAG        "latest"
+)
+
+FetchContent_MakeAvailable(highs)
+
+add_executable(main call_from_cpp.cc)
+target_link_libraries(main highs::highs)
+```