[ { "path": ".clang-format", "content": "BasedOnStyle: Microsoft\nIndentWidth: 4\nUseTab: ForIndentation\nSortIncludes: false\nColumnLimit: 100\nAlignEscapedNewlines: Left\nAlwaysBreakTemplateDeclarations : Yes\n" }, { "path": ".github/actions/setup_optimizers_linux/action.yml", "content": "name: \"Install optimizers on linux\"\ndescription: \"Install optimizers and Setup licenses on linux\"\n\ninputs:\n GUROBI_WLS:\n description: \"...\"\n required: false\n default: ''\n COPT_CLIENT_INI:\n description: \"...\"\n required: false\n default: ''\n MOSEK_LICENSE:\n description: \"...\"\n required: false\n default: ''\n KNITRO_LICENSE:\n description: \"...\"\n required: false\n default: ''\n GITHUB_TOKEN:\n description: \"...\"\n required: true\n CHECK_LICENSE:\n description: \"...\"\n required: true\n ARCH:\n description: \"...\"\n required: true\n type: choice\n default: \"X64\"\n options:\n - \"X64\"\n - \"ARM64\"\n\nruns:\n using: \"composite\"\n steps:\n - name: Create directory to store installers\n shell: bash\n run: |\n mkdir -p ~/installers\n\n - name: Cache Installers\n id: cache-installers-linux\n uses: actions/cache@v4\n env:\n cache-name: cache-installers-linux\n with:\n path: ~/installers\n key: ${{ runner.os }}-${{ runner.arch }}-build-${{ env.cache-name }}-${{ hashFiles('optimizer_version.toml') }}\n restore-keys: |\n ${{ runner.os }}-${{ runner.arch }}-build-${{ env.cache-name }}-\n\n - if: ${{ (steps.cache-installers-linux.outputs.cache-hit != 'true') && (inputs.ARCH == 'X64') }}\n shell: bash\n name: Download X64 Installers\n run: |\n curl -L -o ~/installers/gurobi.tar.gz https://packages.gurobi.com/13.0/gurobi13.0.0_linux64.tar.gz\n curl -L -o ~/installers/copt.tar.gz https://pub.shanshu.ai/download/copt/8.0.2/linux64/CardinalOptimizer-8.0.2-lnx64.tar.gz\n curl -L -o ~/installers/mosek.tar.bz2 https://download.mosek.com/stable/10.2.0/mosektoolslinux64x86.tar.bz2\n curl -L -o ~/installers/idaes-solvers.tar.gz https://github.com/IDAES/idaes-ext/releases/download/3.4.2/idaes-solvers-ubuntu2204-x86_64.tar.gz\n\n - if: ${{ (steps.cache-installers-linux.outputs.cache-hit != 'true') && (inputs.ARCH == 'ARM64') }}\n shell: bash\n name: Download ARM64 Installers\n run: |\n curl -L -o ~/installers/gurobi.tar.gz https://packages.gurobi.com/13.0/gurobi13.0.0_armlinux64.tar.gz\n curl -L -o ~/installers/copt.tar.gz https://pub.shanshu.ai/download/copt/8.0.2/aarch64/CardinalOptimizer-8.0.2-aarch64_lnx.tar.gz\n curl -L -o ~/installers/mosek.tar.bz2 https://download.mosek.com/stable/10.2.0/mosektoolslinuxaarch64.tar.bz2\n curl -L -o ~/installers/idaes-solvers.tar.gz https://github.com/IDAES/idaes-ext/releases/download/3.4.2/idaes-solvers-ubuntu2204-aarch64.tar.gz\n\n - name: Setup Gurobi Installation Home\n if: ${{ (inputs.ARCH == 'X64') && (inputs.GUROBI_WLS != '') }}\n shell: bash\n run: |\n tar xfz ~/installers/gurobi.tar.gz -C ~/\n ls ~/gurobi1300/linux64\n # set environment variables\n export GUROBI_HOME=\"${HOME}/gurobi1300/linux64\"\n echo \"GUROBI_HOME=${GUROBI_HOME}\" >> $GITHUB_ENV\n - name: Setup Gurobi Installation Home\n if: ${{ (inputs.ARCH == 'ARM64') && (inputs.GUROBI_WLS != '') }}\n shell: bash\n run: |\n tar xfz ~/installers/gurobi.tar.gz -C ~/\n ls ~/gurobi1300/armlinux64\n # set environment variables\n export GUROBI_HOME=\"${HOME}/gurobi1300/armlinux64\"\n echo \"GUROBI_HOME=${GUROBI_HOME}\" >> $GITHUB_ENV\n - name: Setup Gurobi Installation\n if: ${{ inputs.GUROBI_WLS != '' }}\n shell: bash\n env:\n GUROBI_WLS: ${{ inputs.GUROBI_WLS }}\n run: |\n echo \"PATH=${PATH}:${GUROBI_HOME}/bin\" >> $GITHUB_ENV\n echo \"LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:${GUROBI_HOME}/lib\" >> $GITHUB_ENV\n echo $GUROBI_HOME\n\n # setup license using secrets\n echo \"$GUROBI_WLS\" > ~/gurobi.lic\n echo \"GRB_LICENSE_FILE=${HOME}/gurobi.lic\" >> $GITHUB_ENV\n - name: Test Gurobi\n if: ${{ (inputs.CHECK_LICENSE == 'true') && (inputs.GUROBI_WLS != '') }}\n shell: bash\n run: |\n gurobi_cl\n\n - name: Setup COPT Installation\n shell: bash\n env:\n COPT_CLIENT_INI: ${{ inputs.COPT_CLIENT_INI }}\n run: |\n tar xfz ~/installers/copt.tar.gz -C ~/\n ls ~/copt80\n # set environment variables\n export COPT_HOME=\"${HOME}/copt80\"\n echo \"COPT_HOME=${COPT_HOME}\" >> $GITHUB_ENV\n echo \"PATH=${PATH}:${COPT_HOME}/bin\" >> $GITHUB_ENV\n echo \"LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:${COPT_HOME}/lib\" >> $GITHUB_ENV\n echo $COPT_HOME\n\n # Just use the size-limited license\n # echo \"$COPT_CLIENT_INI\" > ~/client.ini\n # echo \"COPT_LICENSE_DIR=${HOME}\" >> $GITHUB_ENV\n - name: Test COPT\n if: ${{ inputs.CHECK_LICENSE == 'true' }}\n shell: bash\n run: |\n copt_cmd -c \"quit\"\n\n - name: Setup MOSEK Installation Env\n if: ${{ (inputs.ARCH == 'X64') && (inputs.MOSEK_LICENSE != '') }}\n shell: bash\n run: |\n tar jxf ~/installers/mosek.tar.bz2 -C ~/\n ls ~/mosek\n # set environment variables\n export MOSEK_10_2_BINDIR=\"${HOME}/mosek/10.2/tools/platform/linux64x86/bin\"\n echo \"MOSEK_10_2_BINDIR=${MOSEK_10_2_BINDIR}\" >> $GITHUB_ENV\n - name: Setup MOSEK Installation Env\n if: ${{ (inputs.ARCH == 'ARM64') && (inputs.MOSEK_LICENSE != '') }}\n shell: bash\n run: |\n tar jxf ~/installers/mosek.tar.bz2 -C ~/\n ls ~/mosek\n # set environment variables\n export MOSEK_10_2_BINDIR=\"${HOME}/mosek/10.2/tools/platform/linuxaarch64/bin\"\n echo \"MOSEK_10_2_BINDIR=${MOSEK_10_2_BINDIR}\" >> $GITHUB_ENV\n - name: Setup MOSEK Installation\n if: ${{ inputs.MOSEK_LICENSE != '' }}\n shell: bash\n env:\n MOSEK_LICENSE: ${{ inputs.MOSEK_LICENSE }}\n run: |\n echo \"PATH=${PATH}:${MOSEK_10_2_BINDIR}\" >> $GITHUB_ENV\n echo \"LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:${MOSEK_10_2_BINDIR}\" >> $GITHUB_ENV\n echo $MOSEK_10_2_BINDIR\n\n # setup license using secrets\n echo \"$MOSEK_LICENSE\" > ~/mosek.lic\n echo \"MOSEKLM_LICENSE_FILE=${HOME}/mosek.lic\" >> $GITHUB_ENV\n - name: Test MOSEK\n if: ${{ (inputs.CHECK_LICENSE == 'true') && (inputs.MOSEK_LICENSE != '') }}\n shell: bash\n run: |\n msktestlic\n\n - name: Setup IPOPT Installation\n shell: bash\n run: |\n sudo apt-get install -y libopenblas-dev liblapack3 libgfortran5\n mkdir -p ~/ipopt\n tar xfz ~/installers/idaes-solvers.tar.gz -C ~/ipopt\n echo \"PATH=${PATH}:${HOME}/ipopt\" >> $GITHUB_ENV\n echo \"LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:${HOME}/ipopt\" >> $GITHUB_ENV\n ls ~/ipopt\n - name: Test IPOPT\n shell: bash\n run: |\n ipopt -v\n\n - name: Setup KNITRO license\n if: ${{ inputs.KNITRO_LICENSE != '' }}\n shell: bash\n env:\n KNITRO_LICENSE: ${{ inputs.KNITRO_LICENSE }}\n run: |\n echo \"$KNITRO_LICENSE\" > ${HOME}/artelys_lic.txt\n echo \"ARTELYS_LICENSE=${HOME}/artelys_lic.txt\" >> $GITHUB_ENV\n - name: Install KNITRO (using pip)\n if: ${{ inputs.KNITRO_LICENSE != '' }}\n shell: bash\n run: |\n python -m pip install knitro\n" }, { "path": ".github/actions/setup_optimizers_macos/action.yml", "content": "name: \"Install optimizers on macOS\"\ndescription: \"Install optimizers and Setup licenses on macOS\"\n\ninputs:\n GUROBI_WLS:\n description: \"...\"\n required: false\n default: ''\n COPT_CLIENT_INI:\n description: \"...\"\n required: false\n default: ''\n MOSEK_LICENSE:\n description: \"...\"\n required: false\n default: ''\n KNITRO_LICENSE:\n description: \"...\"\n required: false\n default: ''\n GITHUB_TOKEN:\n description: \"...\"\n required: true\n CHECK_LICENSE:\n description: \"...\"\n required: true\n ARCH:\n description: \"...\"\n required: true\n type: choice\n default: \"X64\"\n options:\n - \"X64\"\n - \"ARM64\"\n\nruns:\n using: \"composite\"\n steps:\n - name: Create directory to store installers\n shell: bash\n run: |\n mkdir -p ~/installers\n\n - name: Cache Installers\n id: cache-installers-macos\n uses: actions/cache@v4\n env:\n cache-name: cache-installers-macos\n with:\n path: ~/installers\n key: ${{ runner.os }}-${{ runner.arch }}-build-${{ env.cache-name }}-${{ hashFiles('optimizer_version.toml') }}\n restore-keys: |\n ${{ runner.os }}-${{ runner.arch }}-build-${{ env.cache-name }}-\n\n - if: ${{ steps.cache-installers-macos.outputs.cache-hit != 'true' }}\n shell: bash\n name: Download Universal Installers\n run: |\n curl -L -o ~/installers/gurobi.pkg https://packages.gurobi.com/13.0/gurobi13.0.0_macos_universal2.pkg\n curl -L -o ~/installers/copt.tar.gz https://pub.shanshu.ai/download/copt/8.0.2/osx64/CardinalOptimizer-8.0.2-universal_mac.tar.gz\n\n - if: ${{ (steps.cache-installers-macos.outputs.cache-hit != 'true') && (inputs.ARCH == 'X64') }}\n shell: bash\n name: Download X64 Installers\n run: |\n curl -L -o ~/installers/mosek.tar.bz2 https://download.mosek.com/stable/10.2.0/mosektoolsosx64x86.tar.bz2\n curl -L -o ~/installers/idaes-solvers.tar.gz https://github.com/IDAES/idaes-ext/releases/download/3.4.2/idaes-solvers-darwin-x86_64.tar.gz\n\n - if: ${{ (steps.cache-installers-macos.outputs.cache-hit != 'true') && (inputs.ARCH == 'ARM64') }}\n shell: bash\n name: Download ARM64 Installers\n run: |\n curl -L -o ~/installers/mosek.tar.bz2 https://download.mosek.com/stable/10.2.0/mosektoolsosxaarch64.tar.bz2\n curl -L -o ~/installers/idaes-solvers.tar.gz https://github.com/IDAES/idaes-ext/releases/download/3.4.2/idaes-solvers-darwin-aarch64.tar.gz\n\n - name: Setup Gurobi Installation\n if: ${{ inputs.GUROBI_WLS != '' }}\n shell: bash\n env:\n GUROBI_WLS: ${{ inputs.GUROBI_WLS }}\n run: |\n pkgutil --expand-full ~/installers/gurobi.pkg ~/gurobi\n ls ~/gurobi\n # set environment variables\n export GUROBI_HOME=\"${HOME}/gurobi/gurobi13.0.0_macos_universal2.component.pkg/Payload/Library/gurobi1300/macos_universal2\"\n echo \"GUROBI_HOME=${GUROBI_HOME}\" >> $GITHUB_ENV\n echo \"PATH=${PATH}:${GUROBI_HOME}/bin\" >> $GITHUB_ENV\n echo \"DYLD_LIBRARY_PATH=${DYLD_LIBRARY_PATH}:${GUROBI_HOME}/lib\" >> $GITHUB_ENV\n echo $GUROBI_HOME\n ls $GUROBI_HOME\n\n # setup license using secrets\n echo \"$GUROBI_WLS\" > ~/gurobi.lic\n echo \"GRB_LICENSE_FILE=${HOME}/gurobi.lic\" >> $GITHUB_ENV\n - name: Test Gurobi\n if: ${{ (inputs.CHECK_LICENSE == 'true') && (inputs.GUROBI_WLS != '') }}\n shell: bash\n run: |\n gurobi_cl\n\n - name: Setup COPT Installation\n shell: bash\n env:\n COPT_CLIENT_INI: ${{ inputs.COPT_CLIENT_INI }}\n run: |\n tar xfz ~/installers/copt.tar.gz -C ~/\n ls ~/copt80\n # set environment variables\n export COPT_HOME=\"${HOME}/copt80\"\n echo \"COPT_HOME=${COPT_HOME}\" >> $GITHUB_ENV\n echo \"PATH=${PATH}:${COPT_HOME}/bin\" >> $GITHUB_ENV\n echo \"DYLD_LIBRARY_PATH=${DYLD_LIBRARY_PATH}:${COPT_HOME}/lib\" >> $GITHUB_ENV\n echo $COPT_HOME\n ls $COPT_HOME\n\n # Just use the size-limited license\n # echo \"$COPT_CLIENT_INI\" > ~/client.ini\n # echo \"COPT_LICENSE_DIR=${HOME}\" >> $GITHUB_ENV\n - name: Test COPT\n if: ${{ inputs.CHECK_LICENSE == 'true' }}\n shell: bash\n run: |\n copt_cmd -c \"quit\"\n\n - name: Setup MOSEK X64 Installation\n if: ${{ (inputs.ARCH == 'X64') && (inputs.MOSEK_LICENSE != '') }}\n shell: bash\n env:\n MOSEK_LICENSE: ${{ inputs.MOSEK_LICENSE }}\n run: |\n tar jxf ~/installers/mosek.tar.bz2 -C ~/\n ls ~/mosek/10.2/tools/platform\n # set environment variables\n export MOSEK_10_2_BINDIR=\"${HOME}/mosek/10.2/tools/platform/osx64x86/bin\"\n echo \"MOSEK_10_2_BINDIR=${MOSEK_10_2_BINDIR}\" >> $GITHUB_ENV\n echo \"PATH=${PATH}:${MOSEK_10_2_BINDIR}\" >> $GITHUB_ENV\n echo \"DYLD_LIBRARY_PATH=${DYLD_LIBRARY_PATH}:${MOSEK_10_2_BINDIR}\" >> $GITHUB_ENV\n echo $MOSEK_10_2_BINDIR\n ls $MOSEK_10_2_BINDIR\n\n # setup license using secrets\n echo \"$MOSEK_LICENSE\" > ~/mosek.lic\n echo \"MOSEKLM_LICENSE_FILE=${HOME}/mosek.lic\" >> $GITHUB_ENV\n - name: Setup MOSEK ARM64 Installation\n if: ${{ (inputs.ARCH == 'ARM64') && (inputs.MOSEK_LICENSE != '') }}\n shell: bash\n env:\n MOSEK_LICENSE: ${{ inputs.MOSEK_LICENSE }}\n run: |\n tar jxf ~/installers/mosek.tar.bz2 -C ~/\n ls ~/mosek/10.2/tools/platform\n # set environment variables\n export MOSEK_10_2_BINDIR=\"${HOME}/mosek/10.2/tools/platform/osxaarch64/bin\"\n echo \"MOSEK_10_2_BINDIR=${MOSEK_10_2_BINDIR}\" >> $GITHUB_ENV\n echo \"PATH=${PATH}:${MOSEK_10_2_BINDIR}\" >> $GITHUB_ENV\n echo \"DYLD_LIBRARY_PATH=${DYLD_LIBRARY_PATH}:${MOSEK_10_2_BINDIR}\" >> $GITHUB_ENV\n echo $MOSEK_10_2_BINDIR\n ls $MOSEK_10_2_BINDIR\n\n # setup license using secrets\n echo \"$MOSEK_LICENSE\" > ~/mosek.lic\n echo \"MOSEKLM_LICENSE_FILE=${HOME}/mosek.lic\" >> $GITHUB_ENV\n - name: Test MOSEK\n if: ${{ (inputs.CHECK_LICENSE == 'true') && (inputs.MOSEK_LICENSE != '') }}\n shell: bash\n run: |\n msktestlic\n\n - name: Setup IPOPT Installation\n shell: bash\n run: |\n mkdir -p ~/ipopt\n tar xfz ~/installers/idaes-solvers.tar.gz -C ~/ipopt\n echo \"PATH=${PATH}:${HOME}/ipopt\" >> $GITHUB_ENV\n echo \"DYLD_LIBRARY_PATH=${DYLD_LIBRARY_PATH}:${HOME}/ipopt\" >> $GITHUB_ENV\n ls ~/ipopt\n - name: Test IPOPT\n shell: bash\n run: |\n ipopt -v\n\n - name: Setup KNITRO License\n if: ${{ inputs.KNITRO_LICENSE != '' }}\n shell: bash\n env:\n KNITRO_LICENSE: ${{ inputs.KNITRO_LICENSE }}\n run: |\n echo \"$KNITRO_LICENSE\" > ~/artelys_lic.txt\n echo \"ARTELYS_LICENSE=${HOME}/artelys_lic.txt\" >> $GITHUB_ENV\n - name: Install KNITRO (using pip)\n if: ${{ inputs.KNITRO_LICENSE != '' }}\n shell: bash\n run: |\n python -m pip install knitro\n" }, { "path": ".github/actions/setup_optimizers_windows/action.yml", "content": "name: \"Install optimizers on windows\"\ndescription: \"Install optimizers and Setup licenses on windows\"\n\ninputs:\n GUROBI_WLS:\n description: \"...\"\n required: false\n default: ''\n COPT_CLIENT_INI:\n description: \"...\"\n required: false\n default: ''\n MOSEK_LICENSE:\n description: \"...\"\n required: false\n default: ''\n KNITRO_LICENSE:\n description: \"...\"\n required: false\n default: ''\n GITHUB_TOKEN:\n description: \"...\"\n required: true\n CHECK_LICENSE:\n description: \"...\"\n required: true\n\nruns:\n using: \"composite\"\n steps:\n - name: Install lessmsi\n shell: pwsh\n run: |\n curl -L -o D:\\lessmsi.zip https://github.com/activescott/lessmsi/releases/download/v1.10.0/lessmsi-v1.10.0.zip\n 7z x D:\\lessmsi.zip -oD:\\lessmsi\n echo \"PATH=$env:PATH;D:\\lessmsi\" >> $env:GITHUB_ENV\n - name: Test lessmsi\n shell: pwsh\n run: |\n lessmsi h\n\n - name: Create directory to store installers\n shell: pwsh\n run: |\n New-Item -ItemType Directory -Force -Path \"D:\\installers\"\n\n - name: Cache Installers\n id: cache-installers-windows\n uses: actions/cache@v4\n env:\n cache-name: cache-installers-windows\n with:\n path: D:\\installers\n key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('optimizer_version.toml') }}\n restore-keys: |\n ${{ runner.os }}-build-${{ env.cache-name }}-\n\n - if: ${{ steps.cache-installers-windows.outputs.cache-hit != 'true' }}\n shell: pwsh\n name: Download Installers\n run: |\n curl -L -o D:\\installers\\gurobi.msi https://packages.gurobi.com/13.0/Gurobi-13.0.0-win64.msi\n curl -L -o D:\\installers\\copt.zip https://pub.shanshu.ai/download/copt/8.0.2/win64/CardinalOptimizer-8.0.2-win64.zip\n curl -L -o D:\\installers\\mosek.msi https://download.mosek.com/stable/10.2.0/moseksetupwin64x86.msi\n curl -L -o D:\\installers\\idaes-solvers.tar.gz https://github.com/IDAES/idaes-ext/releases/download/3.4.2/idaes-solvers-windows-x86_64.tar.gz\n\n - name: List Installers\n shell: pwsh\n run: |\n Get-ChildItem -Path D:\\installers\n\n - name: Setup Gurobi Installation\n if: ${{ inputs.GUROBI_WLS != '' }}\n shell: pwsh\n env:\n GUROBI_WLS: ${{ inputs.GUROBI_WLS }}\n run: |\n lessmsi x D:\\installers\\gurobi.msi \"D:\\\" gurobi_cl.exe\n lessmsi x D:\\installers\\gurobi.msi \"D:\\\" gurobi130.dll gurobi130.lib\n lessmsi x D:\\installers\\gurobi.msi \"D:\\\" gurobi_c.h\n ls D:\\SourceDir\\gurobi1300\\win64\n # set environment variables\n echo \"GUROBI_HOME=D:\\SourceDir\\gurobi1300\\win64\" >> $env:GITHUB_ENV\n echo \"PATH=$env:PATH;D:\\SourceDir\\gurobi1300\\win64\\bin\" >> $env:GITHUB_ENV\n echo $env:GUROBI_HOME\n\n # setup license using secrets\n echo $env:GUROBI_WLS > D:\\gurobi.lic\n echo \"GRB_LICENSE_FILE=D:\\gurobi.lic\" >> $env:GITHUB_ENV\n - name: Test Gurobi\n if: ${{ (inputs.CHECK_LICENSE == 'true') && (inputs.GUROBI_WLS != '') }}\n shell: pwsh\n run: |\n gurobi_cl\n\n - name: Setup COPT Installation\n shell: pwsh\n env:\n COPT_CLIENT_INI: ${{ inputs.COPT_CLIENT_INI }}\n run: |\n # unzip with 7zip\n 7z x D:\\installers\\copt.zip -oD:\\\n ls D:\\copt80\n # set environment variables\n echo \"COPT_HOME=D:\\copt80\" >> $env:GITHUB_ENV\n echo \"PATH=$env:PATH;D:\\copt80\\bin\" >> $env:GITHUB_ENV\n echo $env:COPT_HOME\n\n # Just use the size-limited license\n # echo $env:COPT_CLIENT_INI > D:\\client.ini\n # echo \"COPT_LICENSE_DIR=D:\\\" >> $env:GITHUB_ENV\n - name: Test COPT\n if: ${{ inputs.CHECK_LICENSE == 'true' }}\n shell: pwsh\n run: |\n copt_cmd -c \"quit\"\n\n - name: Setup MOSEK Installation\n if: ${{ inputs.MOSEK_LICENSE != '' }}\n shell: pwsh\n env:\n MOSEK_LICENSE: ${{ inputs.MOSEK_LICENSE }}\n run: |\n lessmsi x D:\\installers\\mosek.msi \"D:\\\" msktestlic.exe\n lessmsi x D:\\installers\\mosek.msi \"D:\\\" mosek64_10_2.dll mosek64_10_2.lib tbb12.dll svml_dispmd.dll\n lessmsi x D:\\installers\\mosek.msi \"D:\\\" mosek.h\n ls D:\\SourceDir\\PFiles\\Mosek\\10.2\\tools\\platform\\win64x86\n # set environment variables\n echo \"MOSEK_10_2_BINDIR=D:\\SourceDir\\PFiles\\Mosek\\10.2\\tools\\platform\\win64x86\\bin\" >> $env:GITHUB_ENV\n echo \"PATH=$env:PATH;D:\\SourceDir\\PFiles\\Mosek\\10.2\\tools\\platform\\win64x86\\bin\" >> $env:GITHUB_ENV\n echo $env:MOSEK_10_2_BINDIR\n\n # setup license using secrets\n echo $env:MOSEK_LICENSE > D:\\mosek.lic\n echo \"MOSEKLM_LICENSE_FILE=D:\\mosek.lic\" >> $env:GITHUB_ENV\n - name: Test MOSEK\n if: ${{ (inputs.CHECK_LICENSE == 'true') && (inputs.MOSEK_LICENSE != '') }}\n shell: pwsh\n run: |\n msktestlic\n\n - name: Setup IPOPT solver\n shell: pwsh\n run: |\n 7z x -so D:\\installers\\idaes-solvers.tar.gz | 7z x -si -ttar -oD:\\ipopt\n echo \"PATH=D:\\ipopt;$env:PATH\" >> $env:GITHUB_ENV\n ls D:\\ipopt\n - name: Test IPOPT\n shell: pwsh\n run: |\n ipopt -v\n\n - name: Setup KNITRO License\n if: ${{ inputs.KNITRO_LICENSE != '' }}\n shell: pwsh\n env:\n KNITRO_LICENSE: ${{ inputs.KNITRO_LICENSE }}\n run: |\n # setup license using secrets\n echo $env:KNITRO_LICENSE > D:\\artelys_lic.txt\n echo \"ARTELYS_LICENSE=D:\\artelys_lic.txt\" >> $env:GITHUB_ENV\n - name: Install KNITRO (using pip)\n if: ${{ inputs.KNITRO_LICENSE != '' }}\n shell: pwsh\n run: |\n python -m pip install knitro\n" }, { "path": ".github/dependabot.yml", "content": "# To get started with Dependabot version updates, you'll need to specify which\n# package ecosystems to update and where the package manifests are located.\n# Please see the documentation for all configuration options:\n# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file\n\nversion: 2\nupdates:\n - package-ecosystem: \"github-actions\" # See documentation for possible values\n directory: \"/\" # Location of package manifests\n schedule:\n interval: \"weekly\"\n" }, { "path": ".github/workflows/doc-build.yml", "content": "name: gh-pages\n\non:\n push:\n branches:\n - master\n\npermissions:\n contents: write\n\njobs:\n doc_build:\n runs-on: ubuntu-latest\n\n strategy:\n fail-fast: true\n matrix:\n python-version: [\"3.13\"]\n\n env:\n PYTHON_VERSION: ${{ matrix.python-version }}\n\n steps:\n - uses: actions/checkout@v6\n - uses: actions/setup-python@v6\n with:\n python-version: ${{ matrix.python-version }}\n cache: 'pip'\n\n - uses: ./.github/actions/setup_optimizers_linux\n with:\n GUROBI_WLS: ${{ secrets.GUROBI_WLS }}\n COPT_CLIENT_INI: ${{ secrets.COPT_CLIENT_INI }}\n MOSEK_LICENSE: ${{ secrets.MOSEK_LICENSE }}\n KNITRO_LICENSE: ${{ secrets.KNITRO_LICENSE }}\n GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n CHECK_LICENSE: false\n\n - name: Build\n run: |\n python -m pip list\n python -m pip install nanobind scikit-build-core[pyproject] typing_extensions\n python -m pip install --no-build-isolation -v .\n python -c \"import pyoptinterface as poi; print(dir(poi))\"\n\n - name: Build documentation\n run: |\n pip install -r docs/requirements.txt\n cd docs\n make html\n cd ..\n\n - name: Deploy\n uses: JamesIves/github-pages-deploy-action@v4\n with:\n folder: docs/build/html\n" }, { "path": ".github/workflows/linux-build.yml", "content": "name: linux-build\n\non:\n pull_request:\n push:\n branches:\n - master\n\njobs:\n\n linux_build:\n runs-on: ${{ matrix.os }}\n\n # Only allow one build at a time otherwise we can run out of licenses\n concurrency:\n group: linux_build\n\n strategy:\n fail-fast: false\n matrix:\n os: [ubuntu-latest, ubuntu-24.04-arm]\n # python-version: [\"3.9\", \"3.10\", \"3.11\", \"3.12\"]\n python-version: [\"3.13\"]\n\n env:\n PYTHON_VERSION: ${{ matrix.python-version }}\n\n steps:\n - uses: actions/checkout@v6\n - uses: actions/setup-python@v6\n with:\n python-version: ${{ matrix.python-version }}\n cache: 'pip'\n\n - uses: ./.github/actions/setup_optimizers_linux\n with:\n GUROBI_WLS: ${{ secrets.GUROBI_WLS }}\n COPT_CLIENT_INI: ${{ secrets.COPT_CLIENT_INI }}\n MOSEK_LICENSE: ${{ secrets.MOSEK_LICENSE }}\n KNITRO_LICENSE: ${{ secrets.KNITRO_LICENSE }}\n GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n CHECK_LICENSE: true\n ARCH: ${{ runner.arch }}\n\n - name: Build\n run: |\n python -m pip list\n python -m pip install nanobind scikit-build-core[pyproject] typing_extensions\n python -m pip install --no-build-isolation -v .\n python -c \"import pyoptinterface as poi; print(dir(poi))\"\n python -m pip wheel -w dist --no-build-isolation .\n\n - name: Test\n run: |\n python -m pip install pytest numpy scipy highsbox llvmlite tccbox\n python -m pytest tests -v\n\n - name: Upload artifact\n uses: actions/upload-artifact@v7\n with:\n name: pyoptinterface-wheel-${{ runner.os }}-${{ runner.arch }}-${{ matrix.python-version }}\n path: dist/\n" }, { "path": ".github/workflows/macos-build.yml", "content": "name: macos-build\n\non:\n pull_request:\n push:\n branches:\n - master\n\njobs:\n\n macos_build:\n runs-on: ${{ matrix.os }}\n\n strategy:\n fail-fast: false\n matrix:\n os: [macos-14]\n # python-version: [\"3.9\", \"3.10\", \"3.11\", \"3.12\"]\n python-version: [\"3.11\", \"3.13\"]\n\n env:\n PYTHON_VERSION: ${{ matrix.python-version }}\n MACOSX_DEPLOYMENT_TARGET: 10.14\n\n steps:\n - uses: actions/checkout@v6\n - uses: actions/setup-python@v6\n with:\n python-version: ${{ matrix.python-version }}\n cache: 'pip'\n\n - uses: ./.github/actions/setup_optimizers_macos\n with:\n GUROBI_WLS: ${{ secrets.GUROBI_WLS }}\n COPT_CLIENT_INI: ${{ secrets.COPT_CLIENT_INI }}\n MOSEK_LICENSE: ${{ secrets.MOSEK_LICENSE }}\n KNITRO_LICENSE: ${{ secrets.KNITRO_LICENSE }}\n GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n CHECK_LICENSE: false\n ARCH: ${{ runner.arch }}\n\n - name: Build\n run: |\n python -m pip list\n python -m pip install nanobind scikit-build-core[pyproject] typing_extensions\n python -m pip install --no-build-isolation -v .\n python -c \"import pyoptinterface as poi; print(dir(poi))\"\n python -m pip wheel -w dist --no-build-isolation .\n\n - name: Test\n run: |\n python -m pip install pytest numpy scipy highsbox llvmlite tccbox\n python -m pytest tests -k \"highs or ipopt\" -v\n\n - name: Upload artifact\n uses: actions/upload-artifact@v7\n with:\n name: pyoptinterface-wheel-${{ runner.os }}-${{ runner.arch }}-${{ matrix.python-version }}\n path: dist/\n" }, { "path": ".github/workflows/wheel.yml", "content": "name: cibuildwheel\n\non:\n workflow_dispatch:\n inputs:\n publish:\n description: 'Publish wheels to PyPI: (testpypi/pypi/none)'\n required: false\n type: choice\n options:\n - testpypi\n - pypi\n - none\n default: none\n\n\njobs:\n build_wheels:\n name: Build wheels on ${{ matrix.os }}\n runs-on: ${{ matrix.os }}\n strategy:\n matrix:\n os: [ubuntu-latest, ubuntu-24.04-arm, windows-latest, macos-latest-large, macos-latest]\n\n steps:\n - uses: actions/checkout@v6\n\n - name: Build wheels\n uses: pypa/cibuildwheel@v3.4.1\n env:\n # Select wheels\n CIBW_BUILD: \"*-manylinux_x86_64 *-manylinux_aarch64 *-win_amd64 *-macosx_x86_64 *-macosx_arm64\"\n CIBW_SKIP: \"cp38-* cp3??t-*\"\n CIBW_ARCHS: \"native\"\n # use manylinux2014\n CIBW_MANYLINUX_X86_64_IMAGE: \"quay.io/pypa/manylinux2014_x86_64\"\n CIBW_MANYLINUX_AARCH64_IMAGE: \"quay.io/pypa/manylinux2014_aarch64\"\n CIBW_ENVIRONMENT_MACOS: >\n MACOSX_DEPLOYMENT_TARGET=10.14\n CIBW_TEST_COMMAND: \"python -c \\\"import pyoptinterface as poi; print(dir(poi))\\\"\"\n with:\n package-dir: .\n output-dir: wheelhouse\n config-file: \"{package}/pyproject.toml\"\n\n - uses: actions/upload-artifact@v7\n with:\n name: cibw-wheels-${{ runner.os }}-${{ runner.arch }}\n path: ./wheelhouse/*.whl\n\n publish-to-testpypi:\n name: Publish Python wheels to TestPyPI\n needs:\n - build_wheels\n runs-on: ubuntu-latest\n if: github.event.inputs.publish == 'testpypi'\n\n environment:\n name: testpypi\n url: https://test.pypi.org/p/pyoptinterface\n\n permissions:\n id-token: write # IMPORTANT: mandatory for trusted publishing\n\n steps:\n - name: Download all the dists\n uses: actions/download-artifact@v8\n with:\n pattern: cibw-wheels-*\n merge-multiple: true\n path: dist/\n - name: List all the dists\n run: ls -l dist/\n - name: Publish distribution 📦 to TestPyPI\n uses: pypa/gh-action-pypi-publish@release/v1\n with:\n repository-url: https://test.pypi.org/legacy/\n\n publish-to-pypi:\n name: Publish Python wheels to PyPI\n needs:\n - build_wheels\n runs-on: ubuntu-latest\n if: github.event.inputs.publish == 'pypi'\n\n environment:\n name: pypi\n url: https://pypi.org/project/pyoptinterface/\n\n permissions:\n id-token: write # IMPORTANT: mandatory for trusted publishing\n\n steps:\n - name: Download all the dists\n uses: actions/download-artifact@v8\n with:\n pattern: cibw-wheels-*\n merge-multiple: true\n path: dist/\n - name: List all the dists\n run: ls -l dist/\n - name: Publish distribution 📦 to PyPI\n uses: pypa/gh-action-pypi-publish@release/v1\n with:\n repository-url: https://upload.pypi.org/legacy/\n" }, { "path": ".github/workflows/windows-build.yml", "content": "name: windows-build\n\non:\n pull_request:\n push:\n branches:\n - master\n\njobs:\n\n windows_build:\n runs-on: windows-latest\n\n # Only allow one build at a time otherwise we can run out of licenses\n concurrency:\n group: windows_build\n\n strategy:\n fail-fast: false\n matrix:\n python-version: [\"3.9\", \"3.13\"]\n\n env:\n PYTHON_VERSION: ${{ matrix.python-version }}\n\n steps:\n - uses: actions/checkout@v6\n - uses: actions/setup-python@v6\n with:\n python-version: ${{ matrix.python-version }}\n cache: 'pip'\n\n - uses: ./.github/actions/setup_optimizers_windows\n with:\n GUROBI_WLS: ${{ secrets.GUROBI_WLS }}\n COPT_CLIENT_INI: ${{ secrets.COPT_CLIENT_INI }}\n MOSEK_LICENSE: ${{ secrets.MOSEK_LICENSE }}\n KNITRO_LICENSE: ${{ secrets.KNITRO_LICENSE }}\n GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n CHECK_LICENSE: true\n\n - name: Build\n run: |\n python -m pip list\n python -m pip install nanobind scikit-build-core[pyproject] typing_extensions\n python -m pip install --no-build-isolation -v .\n python -c \"import pyoptinterface as poi; print(dir(poi))\"\n python -m pip wheel -w dist --no-build-isolation .\n\n - name: Test\n run: |\n python -m pip install pytest numpy scipy highsbox llvmlite tccbox\n python -m pytest tests -v\n\n - name: Upload artifact\n uses: actions/upload-artifact@v7\n with:\n name: pyoptinterface-wheel-${{ runner.os }}-${{ runner.arch }}-${{ matrix.python-version }}\n path: dist/\n" }, { "path": ".gitignore", "content": "# Byte-compiled / optimized / DLL files\n__pycache__/\n*.py[cod]\n*$py.class\n\nbuild/\n.pytest_cache/\n.mypy_cache/\ndist/\n\n.idea/\n.vscode/\n.claude/\n\nbench/local\ndebug/\n\ndocs/jupyter_execute\ndocs/build\n\n*.lp\n*.sol" }, { "path": ".pre-commit-config.yaml", "content": "repos:\n # C++ 格式化 - clang-format\n - repo: https://github.com/pre-commit/mirrors-clang-format\n rev: v22.1.1\n hooks:\n - id: clang-format\n types_or: [c++, c]\n files: \\.(cpp|hpp|c|h|cc|cxx|hxx)$\n exclude: ^thirdparty/\n\n # Python 格式化 - black\n - repo: https://github.com/psf/black\n rev: 26.3.1\n hooks:\n - id: black\n language_version: python3\n" }, { "path": "CMakeLists.txt", "content": "cmake_minimum_required(VERSION 3.15...3.27)\n\nproject(pyoptinterface)\n\nset(CMAKE_CXX_STANDARD 20)\n# Linux: -fPIC\nset(CMAKE_POSITION_INDEPENDENT_CODE ON)\n\n# we need to ensure all shared libraries can look up its own directory to load other shared libraries\n# this is very important for CppAD users because we extract its thread_alloc as a shared library\nfunction(set_rpath target)\n if(APPLE)\n set(CMAKE_MACOSX_RPATH 1)\n set_target_properties(${target} PROPERTIES INSTALL_RPATH \"@loader_path\")\n elseif(UNIX)\n set_target_properties(${target} PROPERTIES INSTALL_RPATH \"$ORIGIN\")\n elseif(WIN32)\n endif()\nendfunction()\n\nif(MSVC)\n # Add /MP flag for multi-processor compilation\n add_compile_options(/MP)\n add_compile_options(/utf-8)\n if(CMAKE_SYSTEM_PROCESSOR MATCHES \"AMD64\")\n # use AVX2\n add_compile_options(/arch:AVX2)\n endif()\nendif()\n\nif(CMAKE_CXX_COMPILER_ID MATCHES \"GNU|Clang\")\n if(CMAKE_SYSTEM_PROCESSOR MATCHES \"x86_64\")\n # add_compile_options(-march=haswell)\n endif()\nendif()\n\nadd_subdirectory(thirdparty/fmt)\nadd_subdirectory(thirdparty/cppad)\n\nset(POI_INSTALL_DIR ${SKBUILD_PLATLIB_DIR}/pyoptinterface/_src)\n\nadd_library(core STATIC)\ntarget_sources(core PRIVATE\n include/pyoptinterface/cache_model.hpp\n include/pyoptinterface/core.hpp\n include/pyoptinterface/container.hpp\n include/pyoptinterface/dylib.hpp\n include/pyoptinterface/solver_common.hpp\n lib/cache_model.cpp\n lib/core.cpp\n)\ntarget_include_directories(core PUBLIC include thirdparty)\ntarget_link_libraries(core PUBLIC fmt)\n\nadd_library(nlexpr STATIC)\ntarget_sources(nlexpr PRIVATE\n include/pyoptinterface/nlexpr.hpp\n lib/nlexpr.cpp\n)\ntarget_include_directories(nlexpr PUBLIC include thirdparty)\ntarget_link_libraries(nlexpr PUBLIC core)\n\nadd_library(nleval STATIC)\ntarget_sources(nleval PRIVATE\n include/pyoptinterface/nleval.hpp\n lib/nleval.cpp\n)\ntarget_link_libraries(nleval PUBLIC nlexpr core)\n\nadd_library(cppad_interface STATIC)\ntarget_sources(cppad_interface PRIVATE\n include/pyoptinterface/cppad_interface.hpp\n lib/cppad_interface.cpp\n)\ntarget_include_directories(cppad_interface PUBLIC include thirdparty)\ntarget_link_libraries(cppad_interface PUBLIC nlexpr cppad)\n\nadd_library(tcc_interface STATIC)\ntarget_sources(tcc_interface PRIVATE\n include/pyoptinterface/tcc_interface.hpp\n lib/tcc_interface.cpp\n)\ntarget_include_directories(tcc_interface PUBLIC include thirdparty)\ntarget_link_libraries(tcc_interface PUBLIC fmt)\n\n# Build Python extensions\nfind_package(Python ${PYTHON_VERSION}\n REQUIRED COMPONENTS Interpreter Development.Module\n OPTIONAL_COMPONENTS Development.SABIModule)\n\n# Import nanobind through CMake's find_package mechanism\nfind_package(nanobind CONFIG REQUIRED)\n\nnanobind_add_module(\n core_ext\n\n STABLE_ABI NB_STATIC NB_DOMAIN pyoptinterface\n\n lib/core_ext.cpp\n)\ntarget_link_libraries(core_ext PUBLIC core)\ninstall(TARGETS core_ext LIBRARY DESTINATION ${POI_INSTALL_DIR})\n\nnanobind_add_module(\n nlexpr_ext\n\n STABLE_ABI NB_STATIC NB_DOMAIN pyoptinterface\n\n lib/nlexpr_ext.cpp\n)\ntarget_link_libraries(nlexpr_ext PUBLIC nlexpr)\ninstall(TARGETS nlexpr_ext LIBRARY DESTINATION ${POI_INSTALL_DIR})\n\nnanobind_add_module(\n nleval_ext\n\n STABLE_ABI NB_STATIC NB_DOMAIN pyoptinterface\n\n lib/nleval_ext.cpp\n)\ntarget_link_libraries(nleval_ext PUBLIC nleval)\ninstall(TARGETS nleval_ext LIBRARY DESTINATION ${POI_INSTALL_DIR})\n\nnanobind_add_module(\n cppad_interface_ext\n\n STABLE_ABI NB_STATIC NB_DOMAIN pyoptinterface\n\n lib/cppad_interface_ext.cpp\n)\ntarget_link_libraries(cppad_interface_ext PUBLIC cppad_interface)\ninstall(TARGETS cppad_interface_ext LIBRARY DESTINATION ${POI_INSTALL_DIR})\n\nnanobind_add_module(\n tcc_interface_ext\n\n STABLE_ABI NB_STATIC NB_DOMAIN pyoptinterface\n\n lib/tcc_interface_ext.cpp\n)\ntarget_link_libraries(tcc_interface_ext PUBLIC tcc_interface)\ninstall(TARGETS tcc_interface_ext LIBRARY DESTINATION ${POI_INSTALL_DIR})\n\n# Solvers\n\n# Gurobi\nadd_library(gurobi_model STATIC)\ntarget_sources(gurobi_model PRIVATE\n include/pyoptinterface/gurobi_model.hpp\n lib/gurobi_model.cpp\n)\ntarget_link_libraries(gurobi_model PUBLIC core nlexpr)\n\nnanobind_add_module(\n gurobi_model_ext\n\n STABLE_ABI NB_STATIC NB_DOMAIN pyoptinterface\n\n lib/gurobi_model_ext.cpp\n lib/gurobi_model_ext_constants.cpp\n)\ntarget_link_libraries(gurobi_model_ext PUBLIC gurobi_model)\ninstall(TARGETS gurobi_model_ext LIBRARY DESTINATION ${POI_INSTALL_DIR})\n\n# COPT\nadd_library(copt_model STATIC)\ntarget_sources(copt_model PRIVATE\n include/pyoptinterface/copt_model.hpp\n lib/copt_model.cpp\n)\ntarget_link_libraries(copt_model PUBLIC core nlexpr)\n\nnanobind_add_module(\n copt_model_ext\n\n STABLE_ABI NB_STATIC NB_DOMAIN pyoptinterface\n\n lib/copt_model_ext.cpp\n lib/copt_model_ext_constants.cpp\n)\ntarget_link_libraries(copt_model_ext PUBLIC copt_model)\ninstall(TARGETS copt_model_ext LIBRARY DESTINATION ${POI_INSTALL_DIR})\n\n# MOSEK\nadd_library(mosek_model STATIC)\ntarget_sources(mosek_model PRIVATE\n include/pyoptinterface/mosek_model.hpp\n lib/mosek_model.cpp\n)\ntarget_link_libraries(mosek_model PUBLIC core)\n\nnanobind_add_module(\n mosek_model_ext\n\n STABLE_ABI NB_STATIC NB_DOMAIN pyoptinterface\n\n lib/mosek_model_ext.cpp\n lib/mosek_model_ext_constants.cpp\n)\ntarget_link_libraries(mosek_model_ext PUBLIC mosek_model)\ninstall(TARGETS mosek_model_ext LIBRARY DESTINATION ${POI_INSTALL_DIR})\n\n# HiGHS\nadd_library(highs_model STATIC)\ntarget_sources(highs_model PRIVATE\n include/pyoptinterface/highs_model.hpp\n lib/highs_model.cpp\n)\ntarget_include_directories(highs_model PUBLIC thirdparty/solvers/highs)\ntarget_link_libraries(highs_model PUBLIC core)\n# target_link_libraries(highs_model PUBLIC HiGHS::HiGHS)\n\nnanobind_add_module(\n highs_model_ext\n\n STABLE_ABI NB_STATIC NB_DOMAIN pyoptinterface\n\n lib/highs_model_ext.cpp\n lib/highs_model_ext_constants.cpp\n)\ntarget_link_libraries(highs_model_ext PUBLIC highs_model)\ninstall(TARGETS highs_model_ext LIBRARY DESTINATION ${POI_INSTALL_DIR})\n\n# IPOPT\nadd_library(ipopt_model STATIC)\ntarget_sources(ipopt_model PRIVATE\n include/pyoptinterface/ipopt_model.hpp\n lib/ipopt_model.cpp\n)\ntarget_link_libraries(ipopt_model PUBLIC nlexpr nleval)\n\nnanobind_add_module(\n ipopt_model_ext\n\n STABLE_ABI NB_STATIC NB_DOMAIN pyoptinterface\n\n lib/ipopt_model_ext.cpp\n)\ntarget_link_libraries(ipopt_model_ext PUBLIC ipopt_model)\ninstall(TARGETS ipopt_model_ext LIBRARY DESTINATION ${POI_INSTALL_DIR})\n\n# XPRESS\nadd_library(xpress_model STATIC)\ntarget_sources(xpress_model PRIVATE\n include/pyoptinterface/xpress_model.hpp\n lib/xpress_model.cpp\n)\ntarget_link_libraries(xpress_model PUBLIC core nlexpr)\n\nnanobind_add_module(\n xpress_model_ext\n\n STABLE_ABI NB_STATIC NB_DOMAIN pyoptinterface\n\n lib/xpress_model_ext.cpp\n lib/xpress_model_ext_constants.cpp\n)\ntarget_link_libraries(xpress_model_ext PUBLIC xpress_model)\ninstall(TARGETS xpress_model_ext LIBRARY DESTINATION ${POI_INSTALL_DIR})\n\nif(DEFINED ENV{XPRESSDIR})\n message(STATUS \"Detected Xpress header file: $ENV{XPRESSDIR}/include\")\n target_include_directories(xpress_model PRIVATE $ENV{XPRESSDIR}/include)\n target_include_directories(xpress_model_ext PRIVATE $ENV{XPRESSDIR}/include)\nendif()\n\n# KNITRO\nadd_library(knitro_model STATIC)\ntarget_sources(knitro_model PRIVATE\n include/pyoptinterface/knitro_model.hpp\n lib/knitro_model.cpp\n)\ntarget_link_libraries(knitro_model PUBLIC core cppad_interface)\n\nnanobind_add_module(\n knitro_model_ext\n\n STABLE_ABI NB_STATIC NB_DOMAIN pyoptinterface\n\n lib/knitro_model_ext.cpp\n lib/knitro_model_ext_constants.cpp\n)\ntarget_link_libraries(knitro_model_ext PUBLIC knitro_model)\ninstall(TARGETS knitro_model_ext LIBRARY DESTINATION ${POI_INSTALL_DIR})\n\n# stub\nnanobind_add_stub(\n core_ext_stub\n INSTALL_TIME\n MODULE pyoptinterface._src.core_ext\n OUTPUT ${POI_INSTALL_DIR}/core_ext.pyi\n)\n\nnanobind_add_stub(\n nlexpr_ext_stub\n INSTALL_TIME\n MODULE pyoptinterface._src.nlexpr_ext\n OUTPUT ${POI_INSTALL_DIR}/nlexpr_ext.pyi\n)\n\nnanobind_add_stub(\n nleval_ext_stub\n INSTALL_TIME\n MODULE pyoptinterface._src.nleval_ext\n OUTPUT ${POI_INSTALL_DIR}/nleval_ext.pyi\n)\n\nnanobind_add_stub(\n cppad_interface_ext_stub\n INSTALL_TIME\n MODULE pyoptinterface._src.cppad_interface_ext\n OUTPUT ${POI_INSTALL_DIR}/cppad_interface_ext.pyi\n)\n\nnanobind_add_stub(\n tcc_interface_ext_stub\n INSTALL_TIME\n MODULE pyoptinterface._src.tcc_interface_ext\n OUTPUT ${POI_INSTALL_DIR}/tcc_interface_ext.pyi\n)\n\nnanobind_add_stub(\n gurobi_model_ext_stub\n INSTALL_TIME\n MODULE pyoptinterface._src.gurobi_model_ext\n OUTPUT ${POI_INSTALL_DIR}/gurobi_model_ext.pyi\n)\n\nnanobind_add_stub(\n copt_model_ext_stub\n INSTALL_TIME\n MODULE pyoptinterface._src.copt_model_ext\n OUTPUT ${POI_INSTALL_DIR}/copt_model_ext.pyi\n)\n\nnanobind_add_stub(\n mosek_model_ext_stub\n INSTALL_TIME\n MODULE pyoptinterface._src.mosek_model_ext\n OUTPUT ${POI_INSTALL_DIR}/mosek_model_ext.pyi\n)\n\nnanobind_add_stub(\n highs_model_ext_stub\n INSTALL_TIME\n MODULE pyoptinterface._src.highs_model_ext\n OUTPUT ${POI_INSTALL_DIR}/highs_model_ext.pyi\n)\n\nnanobind_add_stub(\n ipopt_model_ext_stub\n INSTALL_TIME\n MODULE pyoptinterface._src.ipopt_model_ext\n OUTPUT ${POI_INSTALL_DIR}/ipopt_model_ext.pyi\n)\n\nnanobind_add_stub(\n xpress_model_ext_stub\n INSTALL_TIME\n MODULE pyoptinterface._src.xpress_model_ext\n OUTPUT ${POI_INSTALL_DIR}/xpress_model_ext.pyi\n)\n\nnanobind_add_stub(\n knitro_model_ext_stub\n INSTALL_TIME\n MODULE pyoptinterface._src.knitro_model_ext\n OUTPUT ${POI_INSTALL_DIR}/knitro_model_ext.pyi\n)\n\nset(ENABLE_TEST_MAIN OFF BOOL \"Enable test c++ function with a main.cpp\")\nif(ENABLE_TEST_MAIN)\n add_executable(test_main lib/main.cpp)\n target_link_libraries(test_main PUBLIC core nleval cppad_interface)\nendif()\n" }, { "path": "GEMINI.md", "content": "# PyOptInterface Modeling Guidelines\n\nWhen modeling with `pyoptinterface_native`, adhere to these patterns.\n\n## Solver Initialization\n- Use `pyoptinterface..Model()`. Supported: `highs`, `gurobi`, `copt`, `ipopt`, `knitro`, `mosek`, `xpress`.\n- For Gurobi, you can manage environments with `poi.gurobi.Env()`.\n\n## Variables\n- `model.add_variable(lb=None, ub=None, domain=poi.VariableDomain.Continuous, name=\"\", start=None)`\n- `model.add_m_variables(shape, ...)` returns a NumPy array of variables.\n\n## Constraints\n- Linear: `model.add_linear_constraint(expr, sense, rhs)` or `model.add_linear_constraint(lhs <= rhs)`.\n- Quadratic: `model.add_quadratic_constraint(expr, sense, rhs)`.\n- Matrix: `model.add_m_linear_constraints(A, x, sense, b)`.\n- Nonlinear: Wrap in `with nl.graph():` and use `model.add_nl_constraint(expr)`.\n\n## Objective\n- `model.set_objective(expr, sense)`.\n- Nonlinear: `with nl.graph(): model.add_nl_objective(expr, sense)`.\n\n## Attributes\n- Get: `model.get_model_attribute(poi.ModelAttribute.TerminationStatus)`.\n- Set: `model.set_variable_attribute(v, poi.VariableAttribute.LowerBound, 0.0)`.\n- Results: `model.get_variable_attribute(v, poi.VariableAttribute.Value)`.\n\n## Common Utilities\n- `poi.quicksum(terms)`: Efficiently sum variables/expressions.\n- `poi.Eq`, `poi.Leq`, `poi.Geq`: Aliases for constraint senses.\n" }, { "path": "LICENSE.md", "content": "Copyright (c) 2023: Yue Yang\n\nThe PyOptInterface is licensed under the **[MPL]** version 2.0:\n\n[MPL]: https://www.mozilla.org/MPL/2.0/\n\n Mozilla Public License Version 2.0\n ==================================\n\n 1. Definitions\n --------------\n\n 1.1. \"Contributor\"\n means each individual or legal entity that creates, contributes to\n the creation of, or owns Covered Software.\n\n 1.2. \"Contributor Version\"\n means the combination of the Contributions of others (if any) used\n by a Contributor and that particular Contributor's Contribution.\n\n 1.3. \"Contribution\"\n means Covered Software of a particular Contributor.\n\n 1.4. \"Covered Software\"\n means Source Code Form to which the initial Contributor has attached\n the notice in Exhibit A, the Executable Form of such Source Code\n Form, and Modifications of such Source Code Form, in each case\n including portions thereof.\n\n 1.5. \"Incompatible With Secondary Licenses\"\n means\n\n (a) that the initial Contributor has attached the notice described\n in Exhibit B to the Covered Software; or\n\n (b) that the Covered Software was made available under the terms of\n version 1.1 or earlier of the License, but not also under the\n terms of a Secondary License.\n\n 1.6. \"Executable Form\"\n means any form of the work other than Source Code Form.\n\n 1.7. \"Larger Work\"\n means a work that combines Covered Software with other material, in \n a separate file or files, that is not Covered Software.\n\n 1.8. \"License\"\n means this document.\n\n 1.9. \"Licensable\"\n means having the right to grant, to the maximum extent possible,\n whether at the time of the initial grant or subsequently, any and\n all of the rights conveyed by this License.\n\n 1.10. \"Modifications\"\n means any of the following:\n\n (a) any file in Source Code Form that results from an addition to,\n deletion from, or modification of the contents of Covered\n Software; or\n\n (b) any new file in Source Code Form that contains any Covered\n Software.\n\n 1.11. \"Patent Claims\" of a Contributor\n means any patent claim(s), including without limitation, method,\n process, and apparatus claims, in any patent Licensable by such\n Contributor that would be infringed, but for the grant of the\n License, by the making, using, selling, offering for sale, having\n made, import, or transfer of either its Contributions or its\n Contributor Version.\n\n 1.12. \"Secondary License\"\n means either the GNU General Public License, Version 2.0, the GNU\n Lesser General Public License, Version 2.1, the GNU Affero General\n Public License, Version 3.0, or any later versions of those\n licenses.\n\n 1.13. \"Source Code Form\"\n means the form of the work preferred for making modifications.\n\n 1.14. \"You\" (or \"Your\")\n means an individual or a legal entity exercising rights under this\n License. For legal entities, \"You\" includes any entity that\n controls, is controlled by, or is under common control with You. For\n purposes of this definition, \"control\" means (a) the power, direct\n or indirect, to cause the direction or management of such entity,\n whether by contract or otherwise, or (b) ownership of more than\n fifty percent (50%) of the outstanding shares or beneficial\n ownership of such entity.\n\n 2. License Grants and Conditions\n --------------------------------\n\n 2.1. Grants\n\n Each Contributor hereby grants You a world-wide, royalty-free,\n non-exclusive license:\n\n (a) under intellectual property rights (other than patent or trademark)\n Licensable by such Contributor to use, reproduce, make available,\n modify, display, perform, distribute, and otherwise exploit its\n Contributions, either on an unmodified basis, with Modifications, or\n as part of a Larger Work; and\n\n (b) under Patent Claims of such Contributor to make, use, sell, offer\n for sale, have made, import, and otherwise transfer either its\n Contributions or its Contributor Version.\n\n 2.2. Effective Date\n\n The licenses granted in Section 2.1 with respect to any Contribution\n become effective for each Contribution on the date the Contributor first\n distributes such Contribution.\n\n 2.3. Limitations on Grant Scope\n\n The licenses granted in this Section 2 are the only rights granted under\n this License. No additional rights or licenses will be implied from the\n distribution or licensing of Covered Software under this License.\n Notwithstanding Section 2.1(b) above, no patent license is granted by a\n Contributor:\n\n (a) for any code that a Contributor has removed from Covered Software;\n or\n\n (b) for infringements caused by: (i) Your and any other third party's\n modifications of Covered Software, or (ii) the combination of its\n Contributions with other software (except as part of its Contributor\n Version); or\n\n (c) under Patent Claims infringed by Covered Software in the absence of\n its Contributions.\n\n This License does not grant any rights in the trademarks, service marks,\n or logos of any Contributor (except as may be necessary to comply with\n the notice requirements in Section 3.4).\n\n 2.4. Subsequent Licenses\n\n No Contributor makes additional grants as a result of Your choice to\n distribute the Covered Software under a subsequent version of this\n License (see Section 10.2) or under the terms of a Secondary License (if\n permitted under the terms of Section 3.3).\n\n 2.5. Representation\n\n Each Contributor represents that the Contributor believes its\n Contributions are its original creation(s) or it has sufficient rights\n to grant the rights to its Contributions conveyed by this License.\n\n 2.6. Fair Use\n\n This License is not intended to limit any rights You have under\n applicable copyright doctrines of fair use, fair dealing, or other\n equivalents.\n\n 2.7. Conditions\n\n Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted\n in Section 2.1.\n\n 3. Responsibilities\n -------------------\n\n 3.1. Distribution of Source Form\n\n All distribution of Covered Software in Source Code Form, including any\n Modifications that You create or to which You contribute, must be under\n the terms of this License. You must inform recipients that the Source\n Code Form of the Covered Software is governed by the terms of this\n License, and how they can obtain a copy of this License. You may not\n attempt to alter or restrict the recipients' rights in the Source Code\n Form.\n\n 3.2. Distribution of Executable Form\n\n If You distribute Covered Software in Executable Form then:\n\n (a) such Covered Software must also be made available in Source Code\n Form, as described in Section 3.1, and You must inform recipients of\n the Executable Form how they can obtain a copy of such Source Code\n Form by reasonable means in a timely manner, at a charge no more\n than the cost of distribution to the recipient; and\n\n (b) You may distribute such Executable Form under the terms of this\n License, or sublicense it under different terms, provided that the\n license for the Executable Form does not attempt to limit or alter\n the recipients' rights in the Source Code Form under this License.\n\n 3.3. Distribution of a Larger Work\n\n You may create and distribute a Larger Work under terms of Your choice,\n provided that You also comply with the requirements of this License for\n the Covered Software. If the Larger Work is a combination of Covered\n Software with a work governed by one or more Secondary Licenses, and the\n Covered Software is not Incompatible With Secondary Licenses, this\n License permits You to additionally distribute such Covered Software\n under the terms of such Secondary License(s), so that the recipient of\n the Larger Work may, at their option, further distribute the Covered\n Software under the terms of either this License or such Secondary\n License(s).\n\n 3.4. Notices\n\n You may not remove or alter the substance of any license notices\n (including copyright notices, patent notices, disclaimers of warranty,\n or limitations of liability) contained within the Source Code Form of\n the Covered Software, except that You may alter any license notices to\n the extent required to remedy known factual inaccuracies.\n\n 3.5. Application of Additional Terms\n\n You may choose to offer, and to charge a fee for, warranty, support,\n indemnity or liability obligations to one or more recipients of Covered\n Software. However, You may do so only on Your own behalf, and not on\n behalf of any Contributor. You must make it absolutely clear that any\n such warranty, support, indemnity, or liability obligation is offered by\n You alone, and You hereby agree to indemnify every Contributor for any\n liability incurred by such Contributor as a result of warranty, support,\n indemnity or liability terms You offer. You may include additional\n disclaimers of warranty and limitations of liability specific to any\n jurisdiction.\n\n 4. Inability to Comply Due to Statute or Regulation\n ---------------------------------------------------\n\n If it is impossible for You to comply with any of the terms of this\n License with respect to some or all of the Covered Software due to\n statute, judicial order, or regulation then You must: (a) comply with\n the terms of this License to the maximum extent possible; and (b)\n describe the limitations and the code they affect. Such description must\n be placed in a text file included with all distributions of the Covered\n Software under this License. Except to the extent prohibited by statute\n or regulation, such description must be sufficiently detailed for a\n recipient of ordinary skill to be able to understand it.\n\n 5. Termination\n --------------\n\n 5.1. The rights granted under this License will terminate automatically\n if You fail to comply with any of its terms. However, if You become\n compliant, then the rights granted under this License from a particular\n Contributor are reinstated (a) provisionally, unless and until such\n Contributor explicitly and finally terminates Your grants, and (b) on an\n ongoing basis, if such Contributor fails to notify You of the\n non-compliance by some reasonable means prior to 60 days after You have\n come back into compliance. Moreover, Your grants from a particular\n Contributor are reinstated on an ongoing basis if such Contributor\n notifies You of the non-compliance by some reasonable means, this is the\n first time You have received notice of non-compliance with this License\n from such Contributor, and You become compliant prior to 30 days after\n Your receipt of the notice.\n\n 5.2. If You initiate litigation against any entity by asserting a patent\n infringement claim (excluding declaratory judgment actions,\n counter-claims, and cross-claims) alleging that a Contributor Version\n directly or indirectly infringes any patent, then the rights granted to\n You by any and all Contributors for the Covered Software under Section\n 2.1 of this License shall terminate.\n\n 5.3. In the event of termination under Sections 5.1 or 5.2 above, all\n end user license agreements (excluding distributors and resellers) which\n have been validly granted by You or Your distributors under this License\n prior to termination shall survive termination.\n\n ************************************************************************\n * *\n * 6. Disclaimer of Warranty *\n * ------------------------- *\n * *\n * Covered Software is provided under this License on an \"as is\" *\n * basis, without warranty of any kind, either expressed, implied, or *\n * statutory, including, without limitation, warranties that the *\n * Covered Software is free of defects, merchantable, fit for a *\n * particular purpose or non-infringing. The entire risk as to the *\n * quality and performance of the Covered Software is with You. *\n * Should any Covered Software prove defective in any respect, You *\n * (not any Contributor) assume the cost of any necessary servicing, *\n * repair, or correction. This disclaimer of warranty constitutes an *\n * essential part of this License. No use of any Covered Software is *\n * authorized under this License except under this disclaimer. *\n * *\n ************************************************************************\n\n ************************************************************************\n * *\n * 7. Limitation of Liability *\n * -------------------------- *\n * *\n * Under no circumstances and under no legal theory, whether tort *\n * (including negligence), contract, or otherwise, shall any *\n * Contributor, or anyone who distributes Covered Software as *\n * permitted above, be liable to You for any direct, indirect, *\n * special, incidental, or consequential damages of any character *\n * including, without limitation, damages for lost profits, loss of *\n * goodwill, work stoppage, computer failure or malfunction, or any *\n * and all other commercial damages or losses, even if such party *\n * shall have been informed of the possibility of such damages. This *\n * limitation of liability shall not apply to liability for death or *\n * personal injury resulting from such party's negligence to the *\n * extent applicable law prohibits such limitation. Some *\n * jurisdictions do not allow the exclusion or limitation of *\n * incidental or consequential damages, so this exclusion and *\n * limitation may not apply to You. *\n * *\n ************************************************************************\n\n 8. Litigation\n -------------\n\n Any litigation relating to this License may be brought only in the\n courts of a jurisdiction where the defendant maintains its principal\n place of business and such litigation shall be governed by laws of that\n jurisdiction, without reference to its conflict-of-law provisions.\n Nothing in this Section shall prevent a party's ability to bring\n cross-claims or counter-claims.\n\n 9. Miscellaneous\n ----------------\n\n This License represents the complete agreement concerning the subject\n matter hereof. If any provision of this License is held to be\n unenforceable, such provision shall be reformed only to the extent\n necessary to make it enforceable. Any law or regulation which provides\n that the language of a contract shall be construed against the drafter\n shall not be used to construe this License against a Contributor.\n\n 10. Versions of the License\n ---------------------------\n\n 10.1. New Versions\n\n Mozilla Foundation is the license steward. Except as provided in Section\n 10.3, no one other than the license steward has the right to modify or\n publish new versions of this License. Each version will be given a\n distinguishing version number.\n\n 10.2. Effect of New Versions\n\n You may distribute the Covered Software under the terms of the version\n of the License under which You originally received the Covered Software,\n or under the terms of any subsequent version published by the license\n steward.\n\n 10.3. Modified Versions\n\n If you create software not governed by this License, and you want to\n create a new license for such software, you may create and use a\n modified version of this License if you rename the license and remove\n any references to the name of the license steward (except to note that\n such modified license differs from this License).\n\n 10.4. Distributing Source Code Form that is Incompatible With Secondary\n Licenses\n\n If You choose to distribute Source Code Form that is Incompatible With\n Secondary Licenses under the terms of this version of the License, the\n notice described in Exhibit B of this License must be attached.\n\n Exhibit A - Source Code Form License Notice\n -------------------------------------------\n\n This Source Code Form is subject to the terms of the Mozilla Public\n License, v. 2.0. If a copy of the MPL was not distributed with this\n file, You can obtain one at https://mozilla.org/MPL/2.0/.\n\n If it is not possible or desirable to put the notice in a particular\n file, then You may include the notice in a location (such as a LICENSE\n file in a relevant directory) where a recipient would be likely to look\n for such a notice.\n\n You may add additional accurate notices of copyright ownership.\n\n Exhibit B - \"Incompatible With Secondary Licenses\" Notice\n ---------------------------------------------------------\n\n This Source Code Form is \"Incompatible With Secondary Licenses\", as\n defined by the Mozilla Public License, v. 2.0.\n\nThe design and implementation of the PyOptInterface is inspired by the [JuMP.jl] project.\n\n[JuMP.jl]: https://jump.dev" }, { "path": "README.md", "content": "PyOptInterface (Python Optimization Interface)\n=======\n\n[![](https://img.shields.io/pypi/v/pyoptinterface.svg?color=brightgreen)](https://pypi.org/pypi/pyoptinterface/)\n\n**PyOptInterface** is an open-source Python library to provide a unified API to construct and solve optimization models with various optimizers.\n\nThe detailed documentation can be found [here](https://metab0t.github.io/PyOptInterface/).\n\n## Key features compared with other modeling interfaces\nIt is designed as a very thin wrapper of native C API of optimizers and attempts to provide common abstractions of an algebraic modelling environment including model, variable, constraint and expression with the least overhead of performance.\n\nThe key features of PyOptInterface include:\n- Very fast speed to construct optimization model (10x faster than Pyomo, comparable with JuMP.jl and some official Python bindings provided by vendors of optimizer)\n- Highly efficient structured automatic differentiation for nonlinear optimization with JIT compilation (faster than other NLP frameworks)\n- Low overhead to modify and re-solve the problem incrementally (including adding/removing variables/constraints, changing objective function, etc.)\n- Unified API to cover common usages, write once and the code works for all optimizers\n- You still have escape hatch to query or modify solver-specific parameter/attribute/information for different optimizers directly like the vendor-specific Python binding of optimizer\n\n## Benchmark\nThe benchmark comparing PyOptInterface with some other modeling interfaces can be found [here](https://metab0t.github.io/PyOptInterface/benchmark.html). PyOptInterface is among the fastest modeling interfaces in terms of model construction time and automatic differentiation of nonlinear optimization problems.\n\n## Installation\nPyOptInterface is available on PyPI. You can install it via pip:\n\n```\npip install pyoptinterface\n```\n\nAfter installation, you can import the package in Python console:\n```python\nimport pyoptinterface as poi\n```\n\nPyOptInterface has no dependencies other than Python itself. However, to use it with a specific optimizer, you need to install the corresponding optimizer manually. The details can be found on [the configurations of optimizers](https://metab0t.github.io/PyOptInterface/getting_started.html).\n\nIn order to provide out-of-the-box support for open source optimizers (currently we support [HiGHS](https://github.com/ERGO-Code/HiGHS)), PyOptInterface can also be installed with pre-built optimizers. You can install them via pip:\n\n```\npip install pyoptinterface[highs]\n```\n\nIt will install a full-featured binary version of HiGHS optimizer via [highsbox](http://github.com/metab0t/highsbox), which can be used with PyOptInterface.\n\n## What kind of problems can PyOptInterface solve?\nIt currently supports the following problem types:\n- Linear Programming (LP)\n- Mixed-Integer Linear Programming (MILP)\n- Quadratic Programming (QP)\n- Mixed-Integer Quadratic Programming (MIQP)\n- Quadratically Constrained Quadratic Programming (QCQP)\n- Mixed-Integer Quadratically Constrained Quadratic Programming (MIQCQP)\n- Second-Order Cone Programming (SOCP)\n- Mixed-Integer Second-Order Cone Programming (MISOCP)\n- Exponential Cone Programming (ECP)\n- Mixed-Integer Exponential Cone Programming (MIECP)\n- Nonlinear Programming (NLP)\n\n## What optimizers does PyOptInterface support?\nIt currently supports the following optimizers:\n- [COPT](https://shanshu.ai/copt) ( Commercial )\n- [Gurobi](https://www.gurobi.com/) ( Commercial )\n- [Xpress](https://www.fico.com/en/products/fico-xpress-optimization) ( Commercial )\n- [HiGHS](https://github.com/ERGO-Code/HiGHS) ( Open source )\n- [Mosek](https://www.mosek.com/) ( Commercial )\n- [Ipopt](https://github.com/coin-or/Ipopt) ( Open source )\n- [KNITRO](https://www.artelys.com/solvers/knitro/) ( Commercial )\n\n## Short Example\n```python\nimport pyoptinterface as poi\nfrom pyoptinterface import highs\n\nmodel = highs.Model()\n\nx = model.add_variable(lb=0, ub=1, domain=poi.VariableDomain.Continuous, name=\"x\")\ny = model.add_variable(lb=0, ub=1, domain=poi.VariableDomain.Integer, name=\"y\")\n\ncon = model.add_linear_constraint(x + y >= 1.2, name=\"con\")\n\nobj = 2*x\nmodel.set_objective(obj, poi.ObjectiveSense.Minimize)\n\nmodel.set_model_attribute(poi.ModelAttribute.Silent, False)\nmodel.optimize()\n\nprint(model.get_model_attribute(poi.ModelAttribute.TerminationStatus))\n# TerminationStatusCode.OPTIMAL\n\nx_val = model.get_value(x)\n# 0.2\n\ny_val = model.get_value(y)\n# 1.0\n```\n\n## Citation\nIf you use PyOptInterface in your research, please consider citing [the following paper](https://ieeexplore.ieee.org/document/10721402):\n\n```bibtex\n@article{yang2024accelerating,\n title={Accelerating Optimal Power Flow with Structure-aware Automatic Differentiation and Code Generation},\n author={Yang, Yue and Lin, Chenhui and Xu, Luo and Yang, Xiaodong and Wu, Wenchuan and Wang, Bin},\n journal={IEEE Transactions on Power Systems},\n year={2024},\n publisher={IEEE}\n}\n```\n\n## License\nPyOptInterface is licensed under MPL-2.0 License.\n\nIt uses [nanobind](https://github.com/wjakob/nanobind), [fmtlib](https://github.com/fmtlib/fmt) and [martinus/unordered_dense](https://github.com/martinus/unordered_dense) as dependencies.\n\nThe design of PyOptInterface is inspired by [JuMP.jl](https://jump.dev).\n\nSome solver-related code in `src` folder is adapted from the corresponding solver interface package in `JuMP.jl`\necosystem, which is licensed under MIT License.\n\nThe header files in `thirdparty/solvers` directory are from the corresponding distribution of optimizers and are licensed under their own licenses.\n" }, { "path": "bench/bench_linopy_cvxpy.py", "content": "import time\nfrom numpy import arange\nimport numpy as np\nimport pandas as pd\n\nimport linopy\n\nimport pyoptinterface as poi\nfrom pyoptinterface import copt, gurobi, highs\n\nimport cvxpy\n\n\ndef create_linopy_model(N):\n m = linopy.Model()\n x = m.add_variables(coords=[arange(N), arange(N)])\n y = m.add_variables(coords=[arange(N), arange(N)])\n m.add_constraints(x - y >= arange(N))\n m.add_constraints(x + y >= 0)\n m.add_objective((2 * x).sum() + y.sum())\n return m\n\n\ndef create_cvxpy_model(N):\n x = cvxpy.Variable((N, N))\n y = cvxpy.Variable((N, N))\n constraints = []\n for i in range(N):\n constraints.append(x[:, i] - y[:, i] >= np.arange(N))\n constraints.append(x + y >= 0)\n objective = cvxpy.Minimize(2 * cvxpy.sum(x) + cvxpy.sum(y))\n return cvxpy.Problem(objective, constraints)\n\n\ndef create_poi_model(Model, N):\n m = Model()\n x = m.add_m_variables((N, N))\n y = m.add_m_variables((N, N))\n for i in range(N):\n for j in range(N):\n m.add_linear_constraint(x[i, j] - y[i, j], poi.Geq, i)\n m.add_linear_constraint(x[i, j] + y[i, j], poi.Geq, 0)\n expr = poi.ExprBuilder()\n poi.quicksum_(expr, x, lambda x: 2 * x)\n poi.quicksum_(expr, y)\n m.set_objective(expr)\n return m\n\n\ndef bench(N, solver_name):\n results = {}\n\n t0 = time.time()\n Model = {\n \"copt\": copt.Model,\n \"gurobi\": gurobi.Model,\n \"highs\": highs.Model,\n }.get(solver_name, None)\n if Model:\n model = create_poi_model(Model, N)\n model.optimize()\n t1 = time.time()\n results[\"n_variables\"] = 2 * N * N\n results[\"poi\"] = t1 - t0\n\n t0 = time.time()\n model = create_linopy_model(N)\n model.solve(solver_name=solver_name, io_api=\"direct\")\n t1 = time.time()\n results[\"linopy\"] = t1 - t0\n\n t0 = time.time()\n solver = {\"gurobi\": cvxpy.GUROBI, \"copt\": cvxpy.COPT}.get(solver_name, None)\n if solver:\n model = create_cvxpy_model(N)\n model.solve(solver=cvxpy.GUROBI)\n t1 = time.time()\n results[\"cvxpy\"] = t1 - t0\n\n return results\n\n\ndef main(solver_name=\"gurobi\"):\n Ns = range(100, 501, 100)\n results = []\n for N in Ns:\n results.append(bench(N, solver_name))\n # create a DataFrame\n df = pd.DataFrame(results, index=Ns)\n\n # show result\n print(df)\n\n\nif __name__ == \"__main__\":\n # solver_name can be \"copt\", \"gurobi\", \"highs\"\n main(\"gurobi\")\n" }, { "path": "bench/bench_modify.jl", "content": "using JuMP\nimport MathOptInterface as MOI\nusing Gurobi\nusing COPT\n\nfunction bench_jump(model, N::Int, M::Int)\n I = 1:N\n @variable(model, x[I])\n\n @constraint(model, sum(x[i] for i = I) == N)\n\n @objective(model, Min, sum(i / N * x[i] for i = I))\n\n # for j in 1:M:N\n for j in [1]\n last_variable = j + M - 1\n if last_variable > N\n last_variable = N\n end\n deleted_variables = [x[i] for i in j:last_variable]\n delete(model, deleted_variables)\n optimize!(model)\n end\nend\n\nfunction gurobi_model()\n optimizer = optimizer_with_attributes(\n Gurobi.Optimizer,\n \"Presolve\" => 0,\n \"TimeLimit\" => 0.0,\n MOI.Silent() => true,\n )\n model = direct_model(optimizer)\n return model\nend\n\nfunction copt_model()\n optimizer = optimizer_with_attributes(\n COPT.Optimizer,\n \"Presolve\" => 0,\n \"TimeLimit\" => 0.0,\n MOI.Silent() => true,\n )\n model = direct_model(optimizer)\n return model\nend\n\nfunction bench_gurobi(N, M)\n model = gurobi_model()\n bench_jump(model, N, M)\nend\n\nfunction bench_copt(N, M)\n model = copt_model()\n bench_jump(model, N, M)\nend\n\nfunction main(N, M)\n time_dict = Dict{String,Float64}()\n\n println(\"N: $N, M: $M\")\n println(\"Gurobi starts\")\n t1 = time()\n bench_gurobi(N, M)\n t2 = time()\n println(\"Gurobi ends and takes \", t2 - t1, \" seconds\")\n time_dict[\"gurobi\"] = t2 - t1\n\n println(\"COPT starts\")\n t1 = time()\n bench_copt(N, M)\n t2 = time()\n println(\"COPT ends and takes \", t2 - t1, \" seconds\")\n time_dict[\"copt\"] = t2 - t1\n\n return time_dict\nend\n\nmain(5, 1)\n\nresult_dict = Dict()\nfor N in [1000000]\n for M in [10000]\n result_dict[(N, M)] = main(N, M)\n end\nend\n\nresult_dict" }, { "path": "bench/bench_modify.mod", "content": "param N;\n\nvar x{1..N} >= 0;\n\ns.t. c1: sum {i in 1..N} x[i] = N;\n\nminimize obj: sum {i in 1..N div 2} i / N * x[i];" }, { "path": "bench/bench_modify.py", "content": "import pyoptinterface as poi\nfrom pyoptinterface import gurobi, copt\n\n\nimport gurobipy as gp\nimport coptpy as cp\n\nimport time\n\n\ndef bench_poi_base(model, N, M):\n I = range(N)\n x = poi.make_nd_variable(model, I)\n\n model.set_model_attribute(poi.ModelAttribute.Silent, True)\n model.set_model_attribute(poi.ModelAttribute.TimeLimitSec, 0.0)\n model.set_raw_parameter(\"Presolve\", 0)\n\n expr = poi.ExprBuilder()\n for i in range(N):\n expr.add(i / N * x[i])\n model.set_objective(expr, poi.ObjectiveSense.Minimize)\n\n expr = poi.quicksum(x)\n model.add_linear_constraint(expr, poi.ConstraintSense.GreaterEqual, N)\n\n # for i in range(0, N, M):\n for i in [0]:\n last_variable = min(i + M, N)\n deleted_variables = [x[j] for j in range(i, last_variable)]\n model.delete_variables(deleted_variables)\n model.optimize()\n\n\ndef bench_poi_gurobi(N, M):\n model = gurobi.Model()\n bench_poi_base(model, N, M)\n\n\ndef bench_poi_copt(N, M):\n model = copt.Model()\n bench_poi_base(model, N, M)\n\n\ndef bench_gp(N, M):\n model = gp.Model()\n\n I = range(N)\n x = model.addVars(I)\n\n obj = gp.quicksum(i / N * x[i] for i in range(N))\n model.setObjective(obj)\n\n model.addConstr(x.sum() == N)\n\n model.setParam(\"OutputFlag\", 0)\n model.setParam(\"TimeLimit\", 0.0)\n model.setParam(\"Presolve\", 0)\n\n # for j in range(0, N, M):\n for j in [0]:\n last_variable = min(j + M, N)\n for k in range(j, last_variable):\n model.remove(x[k])\n model.optimize()\n\n\ndef bench_cp(N, M):\n env = cp.Envr()\n model = env.createModel(\"m\")\n\n I = range(N)\n x = model.addVars(I)\n\n model.setParam(\"Logging\", 0)\n model.setParam(\"TimeLimit\", 0.0)\n model.setParam(\"Presolve\", 0)\n\n obj = cp.quicksum(i / N * x[i] for i in range(N))\n model.setObjective(obj)\n\n model.addConstr(x.sum() == N)\n\n # for j in range(0, N, M):\n for j in [0]:\n last_variable = min(j + M, N)\n for k in range(j, last_variable):\n x[k].remove()\n model.solve()\n\n\ndef main(N, M):\n result = dict()\n\n t1 = time.perf_counter()\n bench_poi_gurobi(N, M)\n t2 = time.perf_counter()\n result[\"poi_gurobi\"] = t2 - t1\n\n t1 = time.perf_counter()\n bench_gp(N, M)\n t2 = time.perf_counter()\n result[\"gurobipy\"] = t2 - t1\n\n t1 = time.perf_counter()\n bench_poi_copt(N, M)\n t2 = time.perf_counter()\n result[\"poi_copt\"] = t2 - t1\n\n t1 = time.perf_counter()\n bench_cp(N, M)\n t2 = time.perf_counter()\n result[\"coptpy\"] = t2 - t1\n\n return result\n\n\nresult_dict = dict()\nfor N in [1000000]:\n for M in [100000]:\n print(f\"N = {N}, M = {M}\")\n result = main(N, M)\n result_dict[(N, M)] = result\n\nprint(result_dict)\n" }, { "path": "bench/bench_modify.run", "content": "param t0;\nparam t1;\nlet t0 := time();\n\nmodel bench_modify.mod;\n\nlet N := 10000;\n\noption solver_msg 0;\noption presolve 0;\noption solver 'gurobi';\noption gurobi_options 'outlev=0 timelim=2 presolve=0';\n\nsolve >NUL;\n\nfor {j in (N div 2 + 1)..N} {\n let x[j] := 0;\n solve >NUL;\n}\n\nlet t1 := time();\nprintf \"%d\\n\", t1-t0;" }, { "path": "bench/bench_static.jl", "content": "using JuMP\nusing Gurobi\nusing COPT\nusing MosekTools\n\nfunction bench_jump(model, M, N)\n @variable(model, x[1:M, 1:N] >= 0)\n\n @constraint(model, sum(x) == M * N / 2)\n\n @objective(model, Min, sum(x[i, j]^2 for i in 1:M, j in 1:N))\n\n set_silent(model)\n set_time_limit_sec(model, 0.0)\n set_optimizer_attribute(model, \"Presolve\", 0)\n\n optimize!(model)\nend\n\nfunction bench_gurobi(M::Int, N::Int)\n model = direct_model(Gurobi.Optimizer())\n bench_jump(model, M, N)\nend\n\nfunction bench_copt(M::Int, N::Int)\n model = direct_model(COPT.Optimizer())\n bench_jump(model, M, N)\nend\n\nfunction bench_mosek(M::Int, N::Int)\n model = direct_model(Mosek.Optimizer())\n bench_jump(model, M, N)\nend\n\nfunction main(M::Int, N::Int)\n println(\"Gurobi starts\")\n t1 = time()\n bench_gurobi(M, N)\n t2 = time()\n println(\"Gurobi ends and takes \", t2 - t1, \" seconds\")\n\n println(\"COPT starts\")\n t1 = time()\n bench_copt(M, N)\n t2 = time()\n println(\"COPT ends and takes \", t2 - t1, \" seconds\")\n\n println(\"Mosek starts\")\n t1 = time()\n bench_mosek(M, N)\n t2 = time()\n println(\"Mosek ends and takes \", t2 - t1, \" seconds\")\nend" }, { "path": "bench/bench_static.py", "content": "import pyoptinterface as poi\nfrom pyoptinterface import gurobi, copt, mosek\n\nimport pyomo.environ as pyo\nfrom pyomo.common.timing import TicTocTimer\n\nimport linopy\n\nimport gurobipy as gp\nimport coptpy as cp\nimport mosek as msk\n\n\ndef bench_poi_base(model, M, N):\n I = range(M)\n J = range(N)\n x = poi.make_nd_variable(model, I, J, lb=0.0)\n\n expr = poi.quicksum(x)\n con = model.add_linear_constraint(expr, poi.ConstraintSense.Equal, M * N / 2)\n\n obj = poi.quicksum(x, lambda v: v * v)\n model.set_objective(obj, poi.ObjectiveSense.Minimize)\n\n model.set_model_attribute(poi.ModelAttribute.Silent, True)\n model.set_model_attribute(poi.ModelAttribute.TimeLimitSec, 0.0)\n if isinstance(model, gurobi.Model) or isinstance(model, copt.Model):\n model.set_raw_parameter(\"Presolve\", 0)\n elif isinstance(model, mosek.Model):\n model.set_raw_parameter(\"MSK_IPAR_PRESOLVE_USE\", 0)\n\n model.optimize()\n\n\ndef bench_poi_gurobi(M, N):\n model = gurobi.Model()\n bench_poi_base(model, M, N)\n\n\ndef bench_poi_copt(M, N):\n model = copt.Model()\n bench_poi_base(model, M, N)\n\n\ndef bench_poi_mosek(M, N):\n model = mosek.Model()\n bench_poi_base(model, M, N)\n\n\ndef bench_pyomo_base(solver, M, N):\n model = pyo.ConcreteModel()\n\n I = range(M)\n J = range(N)\n model.x = pyo.Var(I, J)\n\n for var in model.x.values():\n var.setlb(0.0)\n\n model.c = pyo.Constraint(\n expr=pyo.quicksum(var for var in model.x.values()) == M * N / 2\n )\n model.o = pyo.Objective(expr=sum(v * v for v in model.x.values()))\n\n solver.solve(model, load_solutions=False)\n\n\ndef bench_pyomo_gurobi(M, N):\n solver = pyo.SolverFactory(\"gurobi_direct\")\n solver.options[\"timelimit\"] = 0.0\n solver.options[\"presolve\"] = False\n bench_pyomo_base(solver, M, N)\n\n\ndef bench_pyomo_mosek(M, N):\n solver = pyo.SolverFactory(\"mosek_direct\")\n solver.options[\"dparam.optimizer_max_time\"] = 0.0\n solver.options[\"iparam.presolve_use\"] = 0\n bench_pyomo_base(solver, M, N)\n\n\ndef bench_linopy_gurobi(M, N):\n model = linopy.Model()\n\n I = range(M)\n J = range(N)\n x = model.add_variables(lower=0.0, coords=[I, J], name=\"x\")\n\n model.add_constraints(x.sum() == M * N / 2)\n model.add_objective((x * x).sum())\n\n model.solve(\"gurobi\", io_api=\"direct\", OutputFlag=0, TimeLimit=0.0, Presolve=0)\n\n\ndef bench_gp(M, N):\n model = gp.Model()\n\n I = range(M)\n J = range(N)\n x = model.addVars(I, J, lb=0.0, name=\"x\")\n\n expr = x.sum()\n con = model.addConstr(expr == M * N / 2)\n\n obj = gp.quicksum(v * v for v in x.values())\n model.setObjective(obj)\n\n model.setParam(\"OutputFlag\", 0)\n model.setParam(\"TimeLimit\", 0.0)\n model.setParam(\"Presolve\", 0)\n\n model.optimize()\n\n\ndef bench_cp(M, N):\n env = cp.Envr()\n model = env.createModel(\"m\")\n\n I = range(M)\n J = range(N)\n x = model.addVars(I, J, lb=0.0, nameprefix=\"x\")\n\n expr = x.sum()\n con = model.addConstr(expr == M * N / 2)\n\n obj = cp.quicksum(v * v for v in x.values())\n model.setObjective(obj)\n\n model.setParam(\"Logging\", 0)\n model.setParam(\"TimeLimit\", 0.0)\n model.setParam(\"Presolve\", 0)\n\n model.solve()\n\n\ndef streamprinter(text):\n pass\n\n\ndef bench_msk(M, N):\n with msk.Env() as env:\n with env.Task(0, 0) as task:\n task.set_Stream(msk.streamtype.log, streamprinter)\n\n # Total number of variables (M*N for 'x')\n numvar = M * N\n\n # Add variables\n for j in range(numvar):\n task.appendvars(1)\n\n # Variable bounds - All variables are greater than 0.0\n for j in range(numvar):\n task.putvarbound(j, msk.boundkey.ra, 0.0, 1e9)\n\n # Objective\n indx = list(range(M * N))\n val = [2.0] * (M * N)\n task.putqobj(indx, indx, val)\n task.putobjsense(msk.objsense.minimize)\n\n # Constraint - Sum of elements in 'x' equals M * N / 2\n task.appendcons(1) # One linear constraint\n indx = list(range(M * N)) # Indices of 'x' variables\n val = [1.0] * (M * N) # Coefficients are 1\n task.putarow(0, indx, val)\n task.putconbound(0, msk.boundkey.fx, M * N / 2, M * N / 2)\n\n # Set solver parameters\n task.putdouparam(msk.dparam.optimizer_max_time, 0.0)\n task.putintparam(msk.iparam.presolve_use, msk.presolvemode.off)\n\n # Solve the problem\n task.optimize()\n\n\nM = 1000\nN = 100\ntimer = TicTocTimer()\n\ntests = [\n \"gurobi\",\n \"copt\",\n # \"mosek\",\n]\n\nif \"gurobi\" in tests:\n timer.tic(\"poi_gurobi starts\")\n bench_poi_gurobi(M, N)\n timer.toc(\"poi_gurobi ends\")\n\n timer.tic(\"linopy_gurobi starts\")\n bench_linopy_gurobi(M, N)\n timer.toc(\"linopy_gurobi ends\")\n\n timer.tic(\"gurobi starts\")\n bench_gp(M, N)\n timer.toc(\"gurobi ends\")\n\n timer.tic(\"pyomo_gurobi starts\")\n bench_pyomo_gurobi(M, N)\n timer.toc(\"pyomo_gurobi ends\")\n\nif \"copt\" in tests:\n timer.tic(\"poi_copt starts\")\n bench_poi_copt(M, N)\n timer.toc(\"poi_copt ends\")\n\n timer.tic(\"cp starts\")\n bench_cp(M, N)\n timer.toc(\"cp ends\")\n\nif \"mosek\" in tests:\n timer.tic(\"poi_mosek starts\")\n bench_poi_mosek(M, N)\n timer.toc(\"poi_mosek ends\")\n\n timer.tic(\"mosek starts\")\n bench_msk(M, N)\n timer.toc(\"mosek ends\")\n\n timer.tic(\"pyomo_mosek starts\")\n bench_pyomo_mosek(M, N)\n timer.toc(\"pyomo_mosek ends\")\n" }, { "path": "bench/nqueens/.gitignore", "content": "*.csv\n" }, { "path": "bench/nqueens/nqueens.jl", "content": "using JuMP\nimport Gurobi\nimport LinearAlgebra\n\nfunction solve_nqueens(N)\n model = direct_model(Gurobi.Optimizer())\n set_silent(model)\n set_time_limit_sec(model, 0.0)\n set_optimizer_attribute(model, \"Presolve\", 0)\n\n @variable(model, x[1:N, 1:N], Bin)\n\n for i in 1:N\n @constraint(model, sum(x[i, :]) == 1)\n @constraint(model, sum(x[:, i]) == 1)\n end\n\n for i in -(N - 1):(N-1)\n @constraint(model, sum(LinearAlgebra.diag(x, i)) <= 1)\n @constraint(model, sum(LinearAlgebra.diag(reverse(x; dims=1), i)) <= 1)\n end\n\n optimize!(model)\nend\n\nfunction main(io::IO, Ns = 800:400:2000)\n for n in Ns\n start = time()\n model = solve_nqueens(n)\n run_time = round(Int, time() - start)\n content = \"jump nqueens-$n $run_time\"\n println(stdout, content)\n println(io, content)\n end\nend\n\nmain(stdout, [5])\nopen(joinpath(@__DIR__, \"benchmarks.csv\"), \"a\") do io\n main(io)\nend" }, { "path": "bench/nqueens/nqueens_gurobipy.py", "content": "from gurobipy import *\nimport numpy as np\nimport os\nimport time\n\n\ndef solve_nqueens(N):\n model = Model(\"queens\")\n model.setParam(\"OutputFlag\", 0)\n model.setParam(\"TimeLimit\", 0.0)\n model.setParam(\"Presolve\", 0)\n\n x = np.empty((N, N), dtype=object)\n for i in range(N):\n for j in range(N):\n x[i, j] = model.addVar(vtype=GRB.BINARY)\n\n for i in range(N):\n # Row and column\n model.addConstr(quicksum(x[i, :]) == 1.0)\n model.addConstr(quicksum(x[:, i]) == 1.0)\n flipx = np.fliplr(x)\n for i in range(-N + 1, N):\n # Diagonal\n model.addConstr(quicksum(x.diagonal(i)) <= 1.0)\n # Anti-diagonal\n model.addConstr(quicksum(flipx.diagonal(i)) <= 1.0)\n\n model.optimize()\n\n\ndef main(Ns=range(800, 2001, 400)):\n dir = os.path.realpath(os.path.dirname(__file__))\n for n in Ns:\n start = time.time()\n solve_nqueens(n)\n run_time = round(time.time() - start)\n content = \"gurobipy nqueens-%i %i\" % (n, run_time)\n print(content)\n with open(dir + \"/benchmarks.csv\", \"a\") as io:\n io.write(f\"{content}\\n\")\n return\n\n\nmain()\n" }, { "path": "bench/nqueens/nqueens_poi.py", "content": "import pyoptinterface as poi\nfrom pyoptinterface import gurobi\nimport numpy as np\nimport os\nimport time\n\n\ndef solve_nqueens(N):\n model = gurobi.Model()\n\n x = np.empty((N, N), dtype=object)\n for i in range(N):\n for j in range(N):\n x[i, j] = model.add_variable(domain=poi.VariableDomain.Binary)\n\n for i in range(N):\n # Row and column\n model.add_linear_constraint(poi.quicksum(x[i, :]), poi.Eq, 1.0)\n model.add_linear_constraint(poi.quicksum(x[:, i]), poi.Eq, 1.0)\n flipx = np.fliplr(x)\n for i in range(-N + 1, N):\n # Diagonal\n model.add_linear_constraint(poi.quicksum(x.diagonal(i)), poi.Leq, 1.0)\n # Anti-diagonal\n model.add_linear_constraint(poi.quicksum(flipx.diagonal(i)), poi.Leq, 1.0)\n\n model.set_model_attribute(poi.ModelAttribute.Silent, True)\n model.set_model_attribute(poi.ModelAttribute.TimeLimitSec, 0.0)\n model.set_raw_parameter(\"Presolve\", 0)\n model.optimize()\n\n\ndef main(Ns=range(800, 2001, 400)):\n dir = os.path.realpath(os.path.dirname(__file__))\n for n in Ns:\n start = time.time()\n solve_nqueens(n)\n run_time = round(time.time() - start)\n content = \"poi nqueens-%i %i\" % (n, run_time)\n print(content)\n with open(dir + \"/benchmarks.csv\", \"a\") as io:\n io.write(f\"{content}\\n\")\n return\n\n\nmain()\n" }, { "path": "bench/nqueens/nqueens_pythonmip.py", "content": "from mip.model import *\nfrom mip import GUROBI\nimport numpy as np\nimport os\nimport time\n\n\ndef solve_nqueens(N):\n model = Model(\"queens\", solver_name=GUROBI)\n # set parameters\n model.solver.set_int_param(\"OutputFlag\", 0)\n model.solver.set_dbl_param(\"TimeLimit\", 0.0)\n model.solver.set_int_param(\"Presolve\", 0)\n\n x = np.empty((N, N), dtype=object)\n for i in range(N):\n for j in range(N):\n x[i, j] = model.add_var(var_type=\"B\")\n\n for i in range(N):\n # Row and column\n model.add_constr(xsum(x[i, :]) == 1.0)\n model.add_constr(xsum(x[:, i]) == 1.0)\n flipx = np.fliplr(x)\n for i in range(-N + 1, N):\n # Diagonal\n model.add_constr(xsum(x.diagonal(i)) <= 1.0)\n # Anti-diagonal\n model.add_constr(xsum(flipx.diagonal(i)) <= 1.0)\n\n model.optimize()\n\n\ndef main(Ns=range(800, 2001, 400)):\n dir = os.path.realpath(os.path.dirname(__file__))\n for n in Ns:\n start = time.time()\n solve_nqueens(n)\n run_time = round(time.time() - start)\n content = \"pythonmip nqueens-%i %i\" % (n, run_time)\n print(content)\n with open(dir + \"/benchmarks.csv\", \"a\") as io:\n io.write(f\"{content}\\n\")\n return\n\n\nmain()\n" }, { "path": "bench/test_delete.py", "content": "import gurobipy as gp\nimport coptpy as cp\nimport pyoptinterface as poi\nfrom pyoptinterface import copt\n\n\ndef bench_poi_base(N):\n model = copt.Model()\n I = range(N)\n x = poi.make_nd_variable(model, I, lb=0.0)\n\n model.add_linear_constraint(x[0] + x[N - 1], poi.ConstraintSense.GreaterEqual, 1.0)\n\n model.set_model_attribute(poi.ModelAttribute.Silent, False)\n model.set_model_attribute(poi.ModelAttribute.TimeLimitSec, 2.0)\n model.set_raw_parameter(\"Presolve\", 0)\n\n obj = poi.ExprBuilder()\n for i in range(N):\n obj.add(x[i] * x[i])\n model.set_objective(obj, poi.ObjectiveSense.Minimize)\n\n for i in range(N // 2):\n model.delete_variable(x[i])\n model.optimize()\n\n\ndef gp_delete(N):\n model = gp.Model()\n\n I = range(N)\n x = model.addVars(I, lb=0.0)\n\n model.addConstr(x[0] + x[N - 1] >= 1.0)\n\n obj = gp.quicksum(x[i] * x[i] for i in range(N))\n model.setObjective(obj)\n\n model.setParam(\"OutputFlag\", 1)\n model.setParam(\"TimeLimit\", 2.0)\n model.setParam(\"Presolve\", 0)\n\n for j in range(N // 2):\n model.remove(x[j])\n model.optimize()\n\n\ndef cp_delete(N):\n env = cp.Envr()\n model = env.createModel(\"m\")\n\n I = range(N)\n x = model.addVars(I, lb=0.0)\n\n model.addConstr(x[0] + x[N - 1] >= 1.0)\n\n obj = cp.quicksum(x[i] * x[i] for i in range(N))\n model.setObjective(obj)\n\n model.setParam(\"Logging\", 1)\n model.setParam(\"TimeLimit\", 2.0)\n model.setParam(\"Presolve\", 0)\n\n for j in range(N // 2):\n x[j].remove()\n model.solve()\n\n\nif __name__ == \"__main__\":\n N = 20\n cp_delete(N)\n" }, { "path": "docs/Makefile", "content": "# Minimal makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line, and also\n# from the environment for the first two.\nSPHINXOPTS ?=\nSPHINXBUILD ?= sphinx-build\nSOURCEDIR = source\nBUILDDIR = build\n\n# Put it first so that \"make\" without argument is like \"make help\".\nhelp:\n\t@$(SPHINXBUILD) -M help \"$(SOURCEDIR)\" \"$(BUILDDIR)\" $(SPHINXOPTS) $(O)\n\n.PHONY: help Makefile\n\n# Catch-all target: route all unknown targets to Sphinx using the new\n# \"make mode\" option. $(O) is meant as a shortcut for $(SPHINXOPTS).\n%: Makefile\n\t@$(SPHINXBUILD) -M $@ \"$(SOURCEDIR)\" \"$(BUILDDIR)\" $(SPHINXOPTS) $(O)\n" }, { "path": "docs/make.bat", "content": "@ECHO OFF\n\npushd %~dp0\n\nREM Command file for Sphinx documentation\n\nif \"%SPHINXBUILD%\" == \"\" (\n\tset SPHINXBUILD=sphinx-build\n)\nset SOURCEDIR=source\nset BUILDDIR=build\n\n%SPHINXBUILD% >NUL 2>NUL\nif errorlevel 9009 (\n\techo.\n\techo.The 'sphinx-build' command was not found. Make sure you have Sphinx\n\techo.installed, then set the SPHINXBUILD environment variable to point\n\techo.to the full path of the 'sphinx-build' executable. Alternatively you\n\techo.may add the Sphinx directory to PATH.\n\techo.\n\techo.If you don't have Sphinx installed, grab it from\n\techo.https://www.sphinx-doc.org/\n\texit /b 1\n)\n\nif \"%1\" == \"\" goto help\n\n%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%\ngoto end\n\n:help\n%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%\n\n:end\npopd\n" }, { "path": "docs/requirements.txt", "content": "sphinx\nmyst-parser\nmyst-nb\nsphinx-copybutton\nfuro\nnumpy\nscipy\nhighsbox\ntccbox\nllvmlite\nmatplotlib\n" }, { "path": "docs/source/api/pyoptinterface.copt.rst", "content": "pyoptinterface.copt package\n====================================\n\n.. automodule:: pyoptinterface.copt\n :members:\n :inherited-members:\n :undoc-members:\n :show-inheritance:" }, { "path": "docs/source/api/pyoptinterface.gurobi.rst", "content": "pyoptinterface.gurobi package\n====================================\n\n.. automodule:: pyoptinterface.gurobi\n :members:\n :inherited-members:\n :undoc-members:\n :show-inheritance:" }, { "path": "docs/source/api/pyoptinterface.highs.rst", "content": "pyoptinterface.highs package\n====================================\n\n.. automodule:: pyoptinterface.highs\n :members:\n :inherited-members:\n :undoc-members:\n :show-inheritance:" }, { "path": "docs/source/api/pyoptinterface.knitro.rst", "content": "pyoptinterface.knitro package\n====================================\n\n.. automodule:: pyoptinterface.knitro\n :members:\n :inherited-members:\n :undoc-members:\n :show-inheritance:\n" }, { "path": "docs/source/api/pyoptinterface.mosek.rst", "content": "pyoptinterface.mosek package\n====================================\n\n.. automodule:: pyoptinterface.mosek\n :members:\n :inherited-members:\n :undoc-members:\n :show-inheritance:" }, { "path": "docs/source/api/pyoptinterface.rst", "content": "pyoptinterface package\n===========================\n\n.. automodule:: pyoptinterface\n :members:\n :undoc-members:\n :show-inheritance:\n\nSubmodules\n-----------\n\n.. toctree::\n :maxdepth: 2\n\n pyoptinterface.gurobi.rst\n pyoptinterface.copt.rst\n pyoptinterface.xpress.rst\n pyoptinterface.mosek.rst\n pyoptinterface.highs.rst\n" }, { "path": "docs/source/api/pyoptinterface.xpress.rst", "content": "pyoptinterface.xpress package\n====================================\n\n.. automodule:: pyoptinterface.xpress\n :members:\n :inherited-members:\n :undoc-members:\n :show-inheritance:" }, { "path": "docs/source/attribute/copt.md", "content": "### Supported [model attribute](#pyoptinterface.ModelAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Name\n - ❌\n - ❌\n* - ObjectiveSense\n - ✅\n - ✅\n* - DualStatus\n - ✅\n - ❌\n* - PrimalStatus\n - ✅\n - ❌\n* - RawStatusString\n - ✅\n - ❌\n* - TerminationStatus\n - ✅\n - ❌\n* - BarrierIterations\n - ✅\n - ❌\n* - DualObjectiveValue\n - ✅\n - ❌\n* - NodeCount\n - ✅\n - ❌\n* - NumberOfThreads\n - ✅\n - ✅\n* - ObjectiveBound\n - ✅\n - ❌\n* - ObjectiveValue\n - ✅\n - ❌\n* - RelativeGap\n - ✅\n - ✅\n* - Silent\n - ✅\n - ✅\n* - SimplexIterations\n - ✅\n - ❌\n* - SolverName\n - ✅\n - ❌\n* - SolverVersion\n - ✅\n - ❌\n* - SolveTimeSec\n - ✅\n - ❌\n* - TimeLimitSec\n - ✅\n - ✅\n:::\n\n### Supported [variable attribute](#pyoptinterface.VariableAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Value\n - ✅\n - ❌\n* - LowerBound\n - ✅\n - ✅\n* - UpperBound\n - ✅\n - ✅\n* - Domain\n - ✅\n - ✅\n* - PrimalStart\n - ✅\n - ✅\n* - Name\n - ✅\n - ✅\n* - IISLowerBound\n - ✅\n - ❌\n* - IISUpperBound\n - ✅\n - ❌\n* - ReducedCost\n - ✅\n - ❌\n:::\n\n### Supported [constraint attribute](#pyoptinterface.ConstraintAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Name\n - ✅\n - ✅\n* - Primal\n - ✅\n - ❌\n* - Dual\n - ✅\n - ❌\n* - IIS\n - ✅\n - ❌\n:::\n\n" }, { "path": "docs/source/attribute/gurobi.md", "content": "### Supported [model attribute](#pyoptinterface.ModelAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Name\n - ✅\n - ✅\n* - ObjectiveSense\n - ✅\n - ✅\n* - DualStatus\n - ✅\n - ❌\n* - PrimalStatus\n - ✅\n - ❌\n* - RawStatusString\n - ✅\n - ❌\n* - TerminationStatus\n - ✅\n - ❌\n* - BarrierIterations\n - ✅\n - ❌\n* - DualObjectiveValue\n - ✅\n - ❌\n* - NodeCount\n - ✅\n - ❌\n* - NumberOfThreads\n - ✅\n - ✅\n* - ObjectiveBound\n - ✅\n - ❌\n* - ObjectiveValue\n - ✅\n - ❌\n* - RelativeGap\n - ✅\n - ✅\n* - Silent\n - ✅\n - ✅\n* - SimplexIterations\n - ✅\n - ❌\n* - SolverName\n - ✅\n - ❌\n* - SolverVersion\n - ✅\n - ❌\n* - SolveTimeSec\n - ✅\n - ❌\n* - TimeLimitSec\n - ✅\n - ✅\n:::\n\n### Supported [variable attribute](#pyoptinterface.VariableAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Value\n - ✅\n - ❌\n* - LowerBound\n - ✅\n - ✅\n* - UpperBound\n - ✅\n - ✅\n* - Domain\n - ✅\n - ✅\n* - PrimalStart\n - ✅\n - ✅\n* - Name\n - ✅\n - ✅\n* - IISLowerBound\n - ✅\n - ❌\n* - IISUpperBound\n - ✅\n - ❌\n* - ReducedCost\n - ✅\n - ❌\n:::\n\n### Supported [constraint attribute](#pyoptinterface.ConstraintAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Name\n - ✅\n - ✅\n* - Primal\n - ✅\n - ❌\n* - Dual\n - ✅\n - ❌\n* - IIS\n - ✅\n - ❌\n:::\n\n" }, { "path": "docs/source/attribute/highs.md", "content": "### Supported [model attribute](#pyoptinterface.ModelAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Name\n - ❌\n - ❌\n* - ObjectiveSense\n - ✅\n - ✅\n* - DualStatus\n - ✅\n - ❌\n* - PrimalStatus\n - ✅\n - ❌\n* - RawStatusString\n - ✅\n - ❌\n* - TerminationStatus\n - ✅\n - ❌\n* - BarrierIterations\n - ❌\n - ❌\n* - DualObjectiveValue\n - ❌\n - ❌\n* - NodeCount\n - ❌\n - ❌\n* - NumberOfThreads\n - ✅\n - ✅\n* - ObjectiveBound\n - ❌\n - ❌\n* - ObjectiveValue\n - ✅\n - ❌\n* - RelativeGap\n - ✅\n - ✅\n* - Silent\n - ✅\n - ✅\n* - SimplexIterations\n - ❌\n - ❌\n* - SolverName\n - ✅\n - ❌\n* - SolverVersion\n - ✅\n - ❌\n* - SolveTimeSec\n - ✅\n - ❌\n* - TimeLimitSec\n - ✅\n - ✅\n:::\n\n### Supported [variable attribute](#pyoptinterface.VariableAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Value\n - ✅\n - ❌\n* - LowerBound\n - ✅\n - ✅\n* - UpperBound\n - ✅\n - ✅\n* - Domain\n - ✅\n - ✅\n* - PrimalStart\n - ✅\n - ✅\n* - Name\n - ✅\n - ✅\n* - IISLowerBound\n - ❌\n - ❌\n* - IISUpperBound\n - ❌\n - ❌\n* - ReducedCost\n - ✅\n - ❌\n:::\n\n### Supported [constraint attribute](#pyoptinterface.ConstraintAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Name\n - ✅\n - ✅\n* - Primal\n - ✅\n - ❌\n* - Dual\n - ✅\n - ❌\n* - IIS\n - ❌\n - ❌\n:::\n\n" }, { "path": "docs/source/attribute/ipopt.md", "content": "### Supported [model attribute](#pyoptinterface.ModelAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Name\n - ❌\n - ❌\n* - ObjectiveSense\n - ❌\n - ❌\n* - DualStatus\n - ✅\n - ❌\n* - PrimalStatus\n - ✅\n - ❌\n* - RawStatusString\n - ✅\n - ❌\n* - TerminationStatus\n - ✅\n - ❌\n* - BarrierIterations\n - ❌\n - ❌\n* - DualObjectiveValue\n - ❌\n - ❌\n* - NodeCount\n - ❌\n - ❌\n* - NumberOfThreads\n - ❌\n - ❌\n* - ObjectiveBound\n - ❌\n - ❌\n* - ObjectiveValue\n - ✅\n - ❌\n* - RelativeGap\n - ❌\n - ❌\n* - Silent\n - ❌\n - ✅\n* - SimplexIterations\n - ❌\n - ❌\n* - SolverName\n - ✅\n - ❌\n* - SolverVersion\n - ❌\n - ❌\n* - SolveTimeSec\n - ❌\n - ❌\n* - TimeLimitSec\n - ❌\n - ✅\n:::\n\n### Supported [variable attribute](#pyoptinterface.VariableAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Value\n - ✅\n - ❌\n* - LowerBound\n - ✅\n - ✅\n* - UpperBound\n - ✅\n - ✅\n* - Domain\n - ❌\n - ❌\n* - PrimalStart\n - ✅\n - ✅\n* - Name\n - ✅\n - ✅\n* - IISLowerBound\n - ❌\n - ❌\n* - IISUpperBound\n - ❌\n - ❌\n* - ReducedCost\n - ❌\n - ❌\n:::\n\n### Supported [constraint attribute](#pyoptinterface.ConstraintAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Name\n - ❌\n - ❌\n* - Primal\n - ✅\n - ❌\n* - Dual\n - ✅\n - ❌\n* - IIS\n - ❌\n - ❌\n:::\n\n" }, { "path": "docs/source/attribute/knitro.md", "content": "### Supported [model attribute](#pyoptinterface.ModelAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Name\n - ❌\n - ❌\n* - ObjectiveSense\n - ✅\n - ✅\n* - DualStatus\n - ❌\n - ❌\n* - PrimalStatus\n - ✅\n - ❌\n* - RawStatusString\n - ✅\n - ❌\n* - TerminationStatus\n - ✅\n - ❌\n* - BarrierIterations\n - ✅\n - ❌\n* - DualObjectiveValue\n - ❌\n - ❌\n* - NodeCount\n - ✅\n - ❌\n* - NumberOfThreads\n - ✅\n - ✅\n* - ObjectiveBound\n - ✅\n - ❌\n* - ObjectiveValue\n - ✅\n - ❌\n* - RelativeGap\n - ✅\n - ❌\n* - Silent\n - ❌\n - ✅\n* - SimplexIterations\n - ❌\n - ❌\n* - SolverName\n - ✅\n - ❌\n* - SolverVersion\n - ✅\n - ❌\n* - SolveTimeSec\n - ✅\n - ❌\n* - TimeLimitSec\n - ✅\n - ✅\n:::\n\n### Supported [variable attribute](#pyoptinterface.VariableAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Value\n - ✅\n - ❌\n* - LowerBound\n - ✅\n - ✅\n* - UpperBound\n - ✅\n - ✅\n* - Domain\n - ✅\n - ✅\n* - PrimalStart\n - ❌\n - ✅\n* - Name\n - ✅\n - ✅\n* - IISLowerBound\n - ❌\n - ❌\n* - IISUpperBound\n - ❌\n - ❌\n* - ReducedCost\n - ✅\n - ❌\n:::\n\n### Supported [constraint attribute](#pyoptinterface.ConstraintAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Name\n - ✅\n - ✅\n* - Primal\n - ✅\n - ❌\n* - Dual\n - ✅\n - ❌\n:::\n" }, { "path": "docs/source/attribute/mosek.md", "content": "### Supported [model attribute](#pyoptinterface.ModelAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Name\n - ❌\n - ❌\n* - ObjectiveSense\n - ✅\n - ✅\n* - DualStatus\n - ✅\n - ❌\n* - PrimalStatus\n - ✅\n - ❌\n* - RawStatusString\n - ✅\n - ❌\n* - TerminationStatus\n - ✅\n - ❌\n* - BarrierIterations\n - ❌\n - ❌\n* - DualObjectiveValue\n - ✅\n - ❌\n* - NodeCount\n - ❌\n - ❌\n* - NumberOfThreads\n - ✅\n - ✅\n* - ObjectiveBound\n - ❌\n - ❌\n* - ObjectiveValue\n - ✅\n - ❌\n* - RelativeGap\n - ✅\n - ✅\n* - Silent\n - ✅\n - ✅\n* - SimplexIterations\n - ❌\n - ❌\n* - SolverName\n - ✅\n - ❌\n* - SolverVersion\n - ✅\n - ❌\n* - SolveTimeSec\n - ✅\n - ❌\n* - TimeLimitSec\n - ✅\n - ✅\n:::\n\n### Supported [variable attribute](#pyoptinterface.VariableAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Value\n - ✅\n - ❌\n* - LowerBound\n - ✅\n - ✅\n* - UpperBound\n - ✅\n - ✅\n* - Domain\n - ✅\n - ✅\n* - PrimalStart\n - ❌\n - ✅\n* - Name\n - ✅\n - ✅\n* - IISLowerBound\n - ❌\n - ❌\n* - IISUpperBound\n - ❌\n - ❌\n* - ReducedCost\n - ✅\n - ❌\n:::\n\n### Supported [constraint attribute](#pyoptinterface.ConstraintAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Name\n - ✅\n - ✅\n* - Primal\n - ✅\n - ❌\n* - Dual\n - ✅\n - ❌\n* - IIS\n - ❌\n - ❌\n:::\n\n" }, { "path": "docs/source/attribute/xpress.md", "content": "### Supported [model attribute](#pyoptinterface.ModelAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Name\n - ✅\n - ✅\n* - ObjectiveSense\n - ✅\n - ✅\n* - DualStatus\n - ✅\n - ❌\n* - PrimalStatus\n - ✅\n - ❌\n* - RawStatusString\n - ✅\n - ❌\n* - TerminationStatus\n - ✅\n - ❌\n* - BarrierIterations\n - ✅\n - ❌\n* - DualObjectiveValue\n - ✅\n - ❌\n* - NodeCount\n - ✅\n - ❌\n* - NumberOfThreads\n - ✅\n - ✅\n* - ObjectiveBound\n - ✅\n - ❌\n* - ObjectiveValue\n - ✅\n - ❌\n* - RelativeGap\n - ✅\n - ✅\n* - Silent\n - ✅\n - ✅\n* - SimplexIterations\n - ✅\n - ❌\n* - SolverName\n - ✅\n - ❌\n* - SolverVersion\n - ✅\n - ❌\n* - SolveTimeSec\n - ✅\n - ❌\n* - TimeLimitSec\n - ✅\n - ✅\n:::\n\n### Supported [variable attribute](#pyoptinterface.VariableAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Value\n - ✅\n - ❌\n* - LowerBound\n - ✅\n - ✅\n* - UpperBound\n - ✅\n - ✅\n* - Domain\n - ✅\n - ✅\n* - PrimalStart\n - ✅\n - ✅\n* - Name\n - ✅\n - ✅\n* - IISLowerBound\n - ✅\n - ❌\n* - IISUpperBound\n - ✅\n - ❌\n* - ReducedCost\n - ✅\n - ❌\n:::\n\n### Supported [constraint attribute](#pyoptinterface.ConstraintAttribute)\n\n:::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n* - Name\n - ✅\n - ✅\n* - Primal\n - ✅\n - ❌\n* - Dual\n - ✅\n - ❌\n* - IIS\n - ✅\n - ❌\n:::\n\n" }, { "path": "docs/source/benchmark.md", "content": "# Benchmark\n\n## Model construction time\n\nThe benchmark is adapted from [the JuMP paper](https://github.com/jump-dev/JuMPPaperBenchmarks). Eight optimization models with different sizes are selected as test cases, including four facility location models and four linear quadratic control problems. We conduct two rounds of benchmark using Gurobi and COPT as optimizer respectively. For each model, we measure the total time of modeling interface to generate model and pass it to the optimizer, and the time limit of optimizer is set to 0.0 seconds to avoid the influence of solution process.\n\nAll code to run the benchmarks is available at [https://github.com/metab0t/PyOptInterface_benchmark](https://github.com/metab0t/PyOptInterface_benchmark).\n\n:::{table} Time (second) to generate model and pass it to Gurobi optimizer.\n:widths: auto\n:align: center\n\n| Model | Variables | C++ | PyOptInterface | JuMP | gurobipy | Pyomo |\n| --------- | --------- | ---- | -------------- | ---- | -------- | ----- |\n| fac-25 | 67651 | 0.2 | 0.2 | 0.2 | 1.2 | 4.1 |\n| fac-50 | 520301 | 0.8 | 1.2 | 1.8 | 9.7 | 32.7 |\n| fac-75 | 1732951 | 2.7 | 4.1 | 6.6 | 32.5 | 119.3 |\n| fac-100 | 4080601 | 6.3 | 10.0 | 17.8 | 79.1 | 286.3 |\n| lqcp-500 | 251501 | 0.9 | 1.5 | 1.3 | 6.3 | 23.8 |\n| lqcp-1000 | 1003001 | 3.7 | 6.0 | 6.1 | 26.7 | 106.6 |\n| lqcp-1500 | 2254501 | 8.3 | 14.0 | 17.7 | 61.8 | 234.0 |\n| lqcp-2000 | 4006001 | 14.5 | 24.9 | 38.3 | 106.9 | 444.1 |\n\n:::\n\n:::{table} Time (second) to generate model and pass it to COPT optimizer.\n:widths: auto\n:align: center\n\n| Model | Variables | C++ | PyOptInterface | JuMP | coptpy | Pyomo |\n| --------- | --------- | ---- | -------------- | ---- | ------ | ----- |\n| fac-25 | 67651 | 0.3 | 0.2 | 0.3 | 0.6 | 4.1 |\n| fac-50 | 520301 | 2.2 | 1.5 | 2.7 | 5.4 | 32.8 |\n| fac-75 | 1732951 | 8.1 | 6.6 | 10.2 | 20.3 | 117.4 |\n| fac-100 | 4080601 | 22.4 | 23.4 | 30.3 | 58.0 | 284.0 |\n| lqcp-500 | 251501 | 3.8 | 3.1 | 3.0 | 6.6 | 26.4 |\n| lqcp-1000 | 1003001 | 16.0 | 15.5 | 13.9 | 28.1 | 112.1 |\n| lqcp-1500 | 2254501 | 37.6 | 32.4 | 33.7 | 64.6 | 249.3 |\n| lqcp-2000 | 4006001 | 68.2 | 60.3 | 66.2 | 118.4 | 502.4 |\n\n:::\n\nRecently, there are a lot of requests to test the performance of PyOptInterface compared with [linopy](https://github.com/PyPSA/linopy) and [cvxpy](https://github.com/cvxpy/cvxpy), so we prepare a [benchmark](https://github.com/metab0t/PyOptInterface/blob/master/bench/bench_linopy_cvxpy.py).\n\nThis is the result of benchmark, where the performance of PyOptInterface exceeds linopy and cvxpy significantly.\n\n:::{table} Time (second) to generate and solve a linear programming model with Gurobi optimizer.\n:widths: auto\n:align: center\n\n| N | Variables | PyOptInterface | linopy | cvxpy |\n| --- | --------- | -------------- | -------- | --------- |\n| 100 | 20000 | 0.076867 | 0.433379 | 0.224613 |\n| 200 | 80000 | 0.356767 | 0.959883 | 0.927248 |\n| 300 | 180000 | 0.796876 | 2.080950 | 2.681649 |\n| 400 | 320000 | 1.375459 | 3.715881 | 6.174171 |\n| 500 | 500000 | 2.222600 | 6.297467 | 12.153747 |\n\n:::\n\n## Nonlinear programming\n\nWe use the AC Optimal Power Flow problem to benchmark performance of PyOptInterface against different modeling languages. The code is released at [GitHub](https://github.com/metab0t/opf_benchmark) and the result is published by our paper [Accelerating Optimal Power Flow with Structure-aware Automatic Differentiation and Code Generation](https://ieeexplore.ieee.org/document/10721402)." }, { "path": "docs/source/callback.md", "content": "# Callback\n\n:::{attention}\nThe behavior of callback function highly depends on the optimizer and the specific problem. Please refer to the official documentation of the optimizer for more details.\n:::\n\nIn most optimization problems, we build the model, set the parameters, and then call the optimizer to solve the problem. However, in some cases, we may want to monitor the optimization process and intervene in the optimization process. For example, we may want to stop the optimization process when a certain condition is met, or we may want to record the intermediate results of the optimization process. In these cases, we can use the callback function. The callback function is a user-defined function that is called by the optimizer at specific points during the optimization process. Callback is especially useful for mixed-integer programming problems, where we can control the branch and bound process in callback functions.\n\nCallback is not supported for all optimizers. Currently, we only support callback for Gurobi, COPT, and Xpress optimizer. Because callback is tightly coupled with the optimizer, we choose not to implement a strictly unified API for callback. Instead, we try to unify the common parts of the callback API and aim to provide all callback features included in the vendored Python bindings.\n\nIn PyOptInterface, the callback function is simply a Python function that takes two arguments:\n- `model`: The instance of the [optimization model](model.md)\n- `where`: The flag indicates the stage of optimization process when our callback function is invoked. For Gurobi, the value of `where` is [CallbackCodes](https://www.gurobi.com/documentation/current/refman/cb_codes.html#sec:CallbackCodes). For COPT, the value of `where` is called as [callback contexts](https://guide.coap.online/copt/en-doc/callback.html) such as `COPT.CBCONTEXT_MIPNODE` and `COPT.CBCONTEXT_MIPRELAX`. For Xpress, the `where` value corresponds to specific callback points such as `XPRS.CB_CONTEXT.PREINTSOL` or `XPRS.CB_CONTEXT.OPTNODE`. A description of supported Xpress callbacks can be found [here](https://www.fico.com/fico-xpress-optimization/docs/latest/solver/optimizer/HTML/chapter5.html?scroll=section5002).\n\nIn the function body of the callback function, we can do the following four kinds of things:\n- Query the current information of the optimization process. For scalar information, we can use `model.cb_get_info` function to get the information, and its argument is the value of [`what`](https://www.gurobi.com/documentation/current/refman/cb_codes.html) in Gurobi and the value of [callback information](https://guide.coap.online/copt/en-doc/information.html#chapinfo-cbc) in COPT. For Xpress, use regular attribute access methods such as `model.get_raw_attribute`. For array information such as the MIP solution or relaxation, PyOptInterface provides special functions such as `model.cb_get_solution` and `model.cb_get_relaxation`.\n- Add lazy constraint: Use `model.cb_add_lazy_constraint` just like `model.add_linear_constraint` except for the `name` argument.\n- Add user cut: Use `model.cb_add_user_cut` just like `model.add_linear_constraint` except for the `name` argument.\n- Set a heuristic solution: Use `model.cb_set_solution` to set individual values of variables and use `model.cb_submit_solution` to submit the solution to the optimizer immediately (`model.cb_submit_solution` will be called automatically in the end of callback if `model.cb_set_solution` is called).\n- Terminate the optimizer: Use `model.cb_exit`.\n\nHere is an example of a callback function that stops the optimization process when the objective value reaches a certain threshold:\n\n```python\nimport pyoptinterface as poi\nfrom pyoptinterface import gurobi, copt, xpress\n\nGRB = gurobi.GRB\nCOPT = copt.COPT\nXPRS = xpress.XPRS\n\ndef cb_gurobi(model, where):\n if where == GRB.Callback.MIPSOL:\n obj = model.cb_get_info(GRB.Callback.MIPSOL_OBJ)\n if obj < 10:\n model.cb_exit()\n \ndef cb_copt(model, where):\n if where == COPT.CBCONTEXT_MIPSOL:\n obj = model.cb_get_info(\"MipCandObj\")\n if obj < 10:\n model.cb_exit()\n\ndef cb_xpress(model, where):\n if where == XPRS.CB_CONTEXT.PREINTSOL:\n obj = model.get_raw_attribute(\"LPOBJVAL\")\n if obj < 10:\n model.cb_exit()\n```\n\nTo use the callback function, we need to call `model.set_callback(cb)` to pass the callback function to the optimizer. For COPT and Xpress, `model.set_callback` needs an additional argument `where` to specify the context where the callback function is invoked. For Gurobi, the `where` argument is not needed.\n\n```python\nmodel_gurobi = gurobi.Model()\nmodel_gurobi.set_callback(cb_gurobi)\n\nmodel_copt = copt.Model()\nmodel_copt.set_callback(cb_copt, COPT.CBCONTEXT_MIPSOL)\n# callback can also be registered for multiple contexts\nmodel_copt.set_callback(cb_copt, COPT.CBCONTEXT_MIPSOL + COPT.CBCONTEXT_MIPNODE)\n\nmodel_xpress = xpress.Model()\nmodel_xpress.set_callback(cb_xpress, XPRS.CB_CONTEXT.PREINTSOL)\n# callback can also be registered for multiple contexts\nmodel_xpress.set_callback(cb_xpress, XPRS.CB_CONTEXT.PREINTSOL + XPRS.CB_CONTEXT.CUTROUND)\n```\n\nIn order to help users to migrate code using gurobipy, coptpy, and Xpress Python to PyOptInterface, we list a translation table as follows.\n\n:::{table} Callback in gurobipy and PyOptInterface\n:align: left\n\n| gurobipy | PyOptInterface |\n| -------------------------------------- | ------------------------------------------------------- |\n| `model.optimize(cb)` | `model.set_callback(cb) ` |\n| `model.cbGet(GRB.Callback.SPX_OBJVAL)` | `model.cb_get_info(GRB.Callback.SPX_OBJVAL)` |\n| `model.cbGetSolution(var)` | `model.cb_get_solution(var)` |\n| `model.cbGetNodelRel(var)` | `model.cb_get_relaxation(var)` |\n| `model.cbLazy(x[0] + x[1] <= 3)` | `model.cb_add_lazy_constraint(x[0] + x[1], poi.Leq, 3)` |\n| `model.cbCut(x[0] + x[1] <= 3)` | `model.cb_add_user_cut(x[0] + x[1], poi.Leq, 3)` |\n| `model.cbSetSolution(x, 1.0)` | `model.cb_set_solution(x, 1.0)` |\n| `objval = model.cbUseSolution()` | `objval = model.cb_submit_solution()` |\n| `model.termimate()` | `model.cb_exit()` |\n:::\n\n\n:::{table} Callback in coptpy and PyOptInterface\n:align: left\n\n| coptpy | PyOptInterface |\n| ---------------------------------------------- | ------------------------------------------------------- |\n| `model.setCallback(cb, COPT.CBCONTEXT_MIPSOL)` | `model.set_callback(cb, COPT.CBCONTEXT_MIPSOL)` |\n| `CallbackBase.getInfo(COPT.CbInfo.BestBnd)` | `model.cb_get_info(COPT.CbInfo.BestBnd)` |\n| `CallbackBase.getSolution(var)` | `model.cb_get_solution(var)` |\n| `CallbackBase.getRelaxSol(var)` | `model.cb_get_relaxation(var)` |\n| `CallbackBase.getIncumbent(var)` | `model.cb_get_incumbent(var)` |\n| `CallbackBase.addLazyConstr(x[0] + x[1] <= 3)` | `model.cb_add_lazy_constraint(x[0] + x[1], poi.Leq, 3)` |\n| `CallbackBase.addUserCut(x[0] + x[1] <= 3)` | `model.cb_add_user_cut(x[0] + x[1], poi.Leq, 3)` |\n| `CallbackBase.setSolution(x, 1.0) ` | `model.cb_set_solution(x, 1.0)` |\n| `CallbackBase.loadSolution()` | `model.cb_submit_solution()` |\n| `CallbackBase.interrupt()` | `model.cb_exit()` |\n:::\n\n:::{table} Callback in Xpress Python and PyOptInterface\n:align: left\n| Xpress Python | PyOptInterface |\n| ------------------------------------------------------ | ------------------------------------------------------------- |\n| `model.addPreIntsolCallback(cb)` | `model.set_callback(cb, XPRS.CB_CONTEXT.PREINTSOL)` |\n| `model.attributes.bestbound` | `model.get_raw_attribute(\"BESTBOUND\")` |\n| `model.getCallbackSolution(var)` | `model.cb_get_solution(var)` |\n| `model.getCallbackSolution(var)` | `model.cb_get_relaxation(var)` |\n| `model.getSolution(var)` | `model.cb_get_incumbent(var)` |\n| `model.addCuts(0, 'L', 3, [0], [0, 1], [1, 1])` | `model.cb_add_lazy_constraint(x[0] + x[1], poi.Leq, 3)` |\n| `model.addManagedCuts(1, 'L', 3, [0], [0, 1], [1, 1])` | `model.cb_add_user_cut(x[0] + x[1], poi.Leq, 3)` |\n| `model.addMipSol([x], [1.0])` | `model.cb_set_solution(x, 1.0)` + `model.cb_submit_solution()` |\n| `model.interrupt()` | `model.cb_exit()` |\n:::\n\nFor a detailed example to use callbacks in PyOptInterface, we provide a [concrete callback example](https://github.com/metab0t/PyOptInterface/blob/master/tests/tsp_cb.py) to solve the Traveling Salesman Problem (TSP) with callbacks in PyOptInterface, gurobipy, coptpy, and Xpress Python. The example is adapted from the official Gurobi example [tsp.py](https://www.gurobi.com/documentation/current/examples/tsp_py.html).\n" }, { "path": "docs/source/changelog.md", "content": "# Changelog\n\n## 0.6.1\n- Fix some bugs in Mosek interface\n- Update documentation of Knitro\n\n## 0.6.0\n- Add support for KNITRO solver, including nonlinear optimization, callbacks, license management, and documentation\n- Add support for Xpress solver, including linear, quadratic, NLP, callbacks, and reduced cost support\n- Add `ReducedCost` variable attribute\n- Add checks in IpoptModel to raise an error when accessing variable values, objective value, constraint primal or dual before calling `optimize()` or after modifying the model\n- Fix the sign of dual multiplier in IPOPT\n- Fix Hessian matrix ordering in HiGHS (sort elements in the same column by row number)\n- Fix initial value of nonlinear optimization in COPT\n- Fix `poi.ExprBuilder` operation with itself\n- Allow `poi.quicksum` for high dimensional numpy array directly without needing `.flat`\n- Support Gurobi 13, COPT 8, HiGHS 1.12\n- Support finding Gurobi in pixi environment\n- Update CppAD to 20260000 and fmt to 12.1.0\n\n## 0.5.1\n- Support llvmlite 0.45.0\n\n## 0.5.0\n- Overhaul of the nonlinear programming interface and now PyOptInterface can solve nonlinear programming problems with COPT, Gurobi and IPOPT.\n- Use `model.add_linear_constraint(x+y, (1.0, 2.0))` to add two-sided linear constraints\n- Add `poi.ScalarAffineFunction.from_numpy` to create scalar affine functions from numpy arrays quickly\n\n## 0.4.1\n- Support writing solution files in HiGHS\n- Pass the names of variables and constraints to HiGHS\n- Add `model.close()` and `env.close()` methods to allow users release the license of commercial solvers manually\n\n## 0.4.0\n- Add `model.add_m_variables` and `model.add_m_linear_constraints` matrix modeling API\n- Add `model.computeIIS` and IIS related attributes for constraint and variable\n- Implement constraint based on compare operators, now you can use `model.add_linear_constraint(x + y <= 1.0)` directly\n- Drop support for Python 3.8\n- Add wheels for Linux ARM64\n- Supports HiGHS 1.9.0 and Mosek 11\n\n## 0.3.0\n- Add `model.set_variable_bounds(variable, lb, ub)` to make it easier to change variable bounds\n- Introduce nonlinear programming support of Ipopt\n- Support new versions of optimizers\n- Various minor bug fixes\n\n## 0.2.8\n- Fix bugs in HiGHS and MOSEK when the quadratic objective function contains nondiagonal terms\n\n## 0.2.7\n- Fix bugs in HiGHS termination status\n\n## 0.2.6\n- Add rotated second-order cone support for COPT, Gurobi and Mosek\n- Add exponential cone support for COPT and Mosek\n- Requires COPT version >= 7.1.4 to support exponential cone\n\n## 0.2.5\n- Fix `add_linear_constraint` of HiGHS optimizer to consider the constant term in expression correctly\n- Make `make_tupledict` slightly faster\n\n## 0.2.4\n- Add `map` method for `tupledict` class\n- Add type stubs for C++ extension modules \n\n## 0.2.3\n- Fix a bug when deleting constraint in HiGHS\n\n## 0.2.2\n- Fix the performance issue with HiGHS optimizer\n\n## 0.2.1\n- Fix the DLL search paths on Windows\n\n## 0.2.0\n- Supports callback for Gurobi and COPT\n- Release GIL when calling `model.optimize()`\n\n## 0.1.1\n- Add `Model.write` method to write model to files\n\n## 0.1.0\n- First release on PyPI" }, { "path": "docs/source/common_model_interface.md", "content": "# Common Model Interface\n\nGenerally speaking, the following APIs are common to all optimizers except for adding constraint\nbecause different optimizers may support different types of constraints.\n\n## Model\n\n### Get/set model attributes\n\n```{py:function} model.set_model_attribute(attr, value)\n\nset the value of a model attribute\n\n:param pyoptinterface.ModelAttribute attr: the attribute to set\n:param value: the value to set\n```\n\n```{py:function} model.get_model_attribute(attr)\n\nget the value of a model attribute\n\n:param pyoptinterface.ModelAttribute attr: the attribute to get\n:return: the value of the attribute\n```\n\n## Variable\n\n### Add a variable to the model\n\n```{py:function} model.add_variable([lb=-inf, ub=+inf, domain=pyoptinterface.VariableDomain.Continuous, name=\"\"])\n\nadd a variable to the model\n\n:param float lb: the lower bound of the variable, optional, defaults to $-\\infty$\n:param float ub: the upper bound of the variable, optional, defaults to $+\\infty$\n:param pyoptinterface.VariableDomain domain: the domain of the variable, optional, defaults to \ncontinuous\n:param str name: the name of the variable, optional\n:return: the handle of the variable\n```\n\n### Add multidimensional variables to the model as \n\n```{py:function} model.add_variables(*coords, [lb=-inf, ub=+inf, domain=pyoptinterface.VariableDomain.Continuous, name=\"\"])\n\nadd a multidimensional variable to the model\n\n:param coords: the coordinates of the variable, can be a list of Iterables\n:param float lb: the lower bound of the variable, optional, defaults to $-\\infty$\n:param float ub: the upper bound of the variable, optional, defaults to $+\\infty$\n:param pyoptinterface.VariableDomain domain: the domain of the variable, optional, defaults to \ncontinuous\n:param str name: the name of the variable, optional\n:return: the multi-dimensional variable\n:rtype: pyoptinterface.tupledict\n```\n\n### Add multidimensional variables to the model as `numpy.ndarray`\n\n```{py:function} model.add_m_variables(shape, [lb=-inf, ub=+inf, domain=pyoptinterface.VariableDomain.Continuous, name=\"\"])\n\nadd a multidimensional variable to the model as `numpy.ndarray`\n\n:param shape: the shape of the variable, can be a tuple of integers or an integer\n:param float lb: the lower bound of the variable, optional, defaults to $-\\infty$\n:param float ub: the upper bound of the variable, optional, defaults to $+\\infty$\n:param pyoptinterface.VariableDomain domain: the domain of the variable, optional, defaults to \ncontinuous\n:param str name: the name of the variable, optional\n:return: the multidimensional variable\n:rtype: numpy.ndarray\n```\n\n### Get/set variable attributes\n\n```{py:function} model.set_variable_attribute(var, attr, value)\n\nset the value of a variable attribute\n\n:param var: the handle of the variable\n:param pyoptinterface.VariableAttribute attr: the attribute to set\n:param value: the value to set\n```\n\n```{py:function} model.get_variable_attribute(var, attr)\n\nget the value of a variable attribute\n\n:param var: the handle of the variable\n:param pyoptinterface.VariableAttribute attr: the attribute to get\n:return: the value of the attribute\n```\n\n### Delete variable\n\n```{py:function} model.delete_variable(var)\n\ndelete a variable from the model\n\n:param var: the handle of the variable\n```\n\n```{py:function} model.is_variable_active(var)\n\nquery whether a variable is active\n\n:param var: the handle of the variable\n:return: whether the variable is active\n:rtype: bool\n```\n\n### Modify the bounds of variable\n\n```{py:function} model.set_variable_bounds(var, lb, ub)\n\nset the lower and upper bounds of a variable\n\n:param var: the handle of the variable\n:param float lb: the new lower bound value\n:param float ub: the new upper bound value\n```\n\n## Expression\n\n### Get the value of an expression (including variable)\n\n```{py:function} model.get_value(expr_or_var)\n\nget the value of an expression or a variable after optimization\n\n:param expr_or_var: the handle of the expression or the variable\n:return: the value of the expression or the variable\n:rtype: float\n```\n\n### Pretty print expression (including variable)\n\n```{py:function} model.pprint(expr_or_var)\n\npretty print an expression in a human-readable format\n\n:param expr_or_var: the handle of the expression or the variable\n:return: the human-readable format of the expression\n:rtype: str\n```\n\n## Constraint\n\n### Add a constraint to the model\n\n- \n- \n- \n- \n\n### Add linear constraints as matrix form to the model\n\n```{py:function} model.add_m_linear_constraints(A, vars, sense, b, [name=\"\"])\n\nadd linear constraints as matrix form to the model $Ax \\le b$ or $Ax = b$ or $Ax \\ge b$\n\n:param A: the matrix of coefficients, can be a dense `numpy.ndarray` or a sparse matrix `scipy.sparse.sparray`\n:param vars: the variables in the constraints, can be a list or a 1-d `numpy.ndarray` returned by `add_m_variables`\n:param pyoptinterface.ConstraintSense sense: the sense of the constraints\n:param b: the right-hand side of the constraints, should be a 1-d `numpy.ndarray`\n:param str name: the name of the constraints, optional\n:return: the handles of linear constraints\n:rtype: numpy.ndarray\n```\n\n### Get/set constraint attributes\n\n```{py:function} model.set_constraint_attribute(con, attr, value)\n\nset the value of a constraint attribute\n\n:param con: the handle of the constraint\n:param pyoptinterface.ConstraintAttribute attr: the attribute to set\n:param value: the value to set\n```\n\n```{py:function} model.get_constraint_attribute(con, attr)\n\nget the value of a constraint attribute\n\n:param con: the handle of the constraint\n:param pyoptinterface.ConstraintAttribute attr: the attribute to get\n:return: the value of the attribute\n```\n\n### Delete constraint\n\n```{py:function} model.delete_constraint(con)\n\ndelete a constraint from the model\n\n:param con: the handle of the constraint\n```\n\n```{py:function} model.is_constraint_active(con)\n\nquery whether a constraint is active\n\n:param con: the handle of the constraint\n:return: whether the variable is active\n:rtype: bool\n```\n\n### Modify constraint\n\n```{py:function} model.set_normalized_rhs(con, value)\n\nset the right-hand side of a normalized constraint\n\n:param con: the handle of the constraint\n:param value: the new right-hand side value\n```\n\n```{py:function} model.get_normalized_rhs(con)\n\nget the right-hand side of a normalized constraint\n\n:param con: the handle of the constraint\n:return: the right-hand side value\n```\n\n```{py:function} model.set_normalized_coefficient(con, var, value)\n\nset the coefficient of a variable in a normalized constraint\n\n:param con: the handle of the constraint\n:param var: the handle of the variable\n:param value: the new coefficient value\n```\n\n```{py:function} model.get_normalized_coefficient(con, var)\n\nget the coefficient of a variable in a normalized constraint\n\n:param con: the handle of the constraint\n:param var: the handle of the variable\n:return: the coefficient value\n```\n\n## Objective\n\n### Set the objective function\n\n```{py:function} model.set_objective(expr, [sense=pyoptinterface.ObjectiveSense.Minimize])\n\nset the objective function of the model\n\n:param expr: the handle of the expression\n:param pyoptinterface.ObjectiveSense sense: the sense of the objective function (Minimize/Maximize), defaults to Minimize\n```\n\n### Modify the linear part of the objective function\n\n```{py:function} model.set_objective_coefficient(var, value)\n\nmodify the coefficient of a variable in the linear part of the objective function\n\n:param var: the handle of the variable\n:param float value: the new coefficient value\n```\n\n```{py:function} model.get_objective_coefficient(var)\n\nget the coefficient of a variable in the linear part of the objective function\n\n:param var: the handle of the variable\n:return: the coefficient value\n```" }, { "path": "docs/source/conf.py", "content": "# Configuration file for the Sphinx documentation builder.\n#\n# For the full list of built-in configuration values, see the documentation:\n# https://www.sphinx-doc.org/en/master/usage/configuration.html\n\n# -- Project information -----------------------------------------------------\n# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information\n\nproject = \"PyOptInterface\"\ncopyright = \"2024, Yue Yang\"\nauthor = \"Yue Yang\"\n\n# -- General configuration ---------------------------------------------------\n# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration\n\nextensions = [\n \"sphinx.ext.autodoc\",\n \"sphinx.ext.githubpages\",\n \"sphinx_copybutton\",\n \"myst_nb\",\n]\n\nsource_suffix = {\n \".rst\": \"restructuredtext\",\n \".ipynb\": \"myst-nb\",\n \".md\": \"myst-nb\",\n}\n\nmyst_enable_extensions = [\"colon_fence\", \"amsmath\", \"dollarmath\", \"fieldlist\"]\n\ntemplates_path = [\"_templates\"]\nexclude_patterns = []\n\n\n# -- Options for HTML output -------------------------------------------------\n# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output\n\nhtml_theme = \"furo\"\nhtml_static_path = [\"_static\"]\n" }, { "path": "docs/source/constraint.md", "content": "---\nfile_format: mystnb\nkernelspec:\n name: python3\n---\n# Constraint\n\nPyOptInterface supports the following types of constraints:\n\n- Linear Constraint\n- Quadratic Constraint\n- Second-Order Cone Constraint\n- Special Ordered Set (SOS) Constraint\n\n:::{note}\n\nNot all optimizers support all types of constraints. Please refer to the documentation of the\noptimizer you are using to see which types of constraints are supported.\n:::\n\n```{code-cell}\nimport pyoptinterface as poi\nfrom pyoptinterface import copt\n\nmodel = copt.Model()\n```\n\n## Constraint Sense\n\nThe sense of a constraint can be one of the following:\n\n- `poi.Eq`: equal\n- `poi.Leq`: less than or equal\n- `poi.Geq`: greater than or equal\n\nThey are the abbreviations of `poi.ConstraintSense.Equal`, `poi.ConstraintSense.LessEqual` or `poi.ConstraintSense.GreaterEqual` and can be used in the `sense` argument of the constraint creation functions.\n\n## Linear Constraint\nIt is defined as:\n\n$$\n\\begin{align}\n \\text{expr} &= a^T x + b &\\leq \\text{rhs} \\\\\n \\text{expr} &= a^T x + b &= \\text{rhs} \\\\\n \\text{expr} &= a^T x + b &\\geq \\text{rhs}\n\\end{align}\n$$\n\nIt can be added to the model using the `add_linear_constraint` method of the `Model` class.\n\n```{code-cell}\nx = model.add_variable(name=\"x\")\ny = model.add_variable(name=\"y\")\n\ncon = model.add_linear_constraint(2.0*x + 3.0*y, poi.Leq, 1.0)\n```\n\n```{py:function} model.add_linear_constraint(expr, sense, rhs, [name=\"\"])\n\nadd a linear constraint to the model\n\n:param expr: the expression of the constraint\n:param pyoptinterface.ConstraintSense sense: the sense of the constraint\n:param float rhs: the right-hand side of the constraint\n:param str name: the name of the constraint, optional\n:return: the handle of the constraint\n```\n\n:::{note}\n\nPyOptInterface provides , , and as alias of to represent the sense of the constraint with a shorter name.\n:::\n\nThe linear constraint can also be created with a comparison operator, like `<=`, `==`, or `>=`:\n\n```{code-cell}\nmodel.add_linear_constraint(2.0*x + 3.0*y <= 1.0)\nmodel.add_linear_constraint(2.0*x + 3.0*y == 1.0)\nmodel.add_linear_constraint(2.0*x + 3.0*y >= 1.0)\n```\n\nIf you want to express a two-sided linear constraint, you can use the `add_linear_constraint` method with a tuple to represent the left-hand side and right-hand side of the constraint like:\n\n```{code-cell}\nmodel.add_linear_constraint(2.0*x + 3.0*y, (1.0, 2.0))\n```\n\nwhich is equivalent to:\n```{code-cell}\nmodel.add_linear_constraint(2.0*x + 3.0*y, poi.Leq, 2.0)\nmodel.add_linear_constraint(2.0*x + 3.0*y, poi.Geq, 1.0)\n```\n\n:::{note}\n\nThe two-sided linear constraint is not implemented for Gurobi because of its [special handling of range constraints](https://docs.gurobi.com/projects/optimizer/en/12.0/reference/c/model.html#c.GRBaddrangeconstr).\n:::\n\n## Quadratic Constraint\nLike the linear constraint, it is defined as:\n\n$$\n\\begin{align}\n \\text{expr} &= x^TQx + a^Tx + b &\\leq \\text{rhs} \\\\\n \\text{expr} &= x^TQx + a^Tx + b &= \\text{rhs} \\\\\n \\text{expr} &= x^TQx + a^Tx + b &\\geq \\text{rhs}\n\\end{align}\n$$\n\nIt can be added to the model using the `add_quadratic_constraint` method of the `Model` class.\n\n```{code-cell}\nx = model.add_variable(name=\"x\")\ny = model.add_variable(name=\"y\")\n\nexpr = x*x + 2.0*x*y + 4.0*y*y\ncon = model.add_quadratic_constraint(expr, poi.ConstraintSense.LessEqual, 1.0)\n```\n\n```{py:function} model.add_quadratic_constraint(expr, sense, rhs, [name=\"\"])\n\nadd a quadratic constraint to the model\n\n:param expr: the expression of the constraint\n:param pyoptinterface.ConstraintSense sense: the sense of the constraint, which can be `GreaterEqual`, `Equal`, or `LessEqual`\n:param float rhs: the right-hand side of the constraint\n:param str name: the name of the constraint, optional\n:return: the handle of the constraint\n```\n\nSimilarly, the quadratic constraint can also be created with a comparison operator, like `<=`, `==`, or `>=`:\n\n```python\nmodel.add_quadratic_constraint(x*x + 2.0*x*y + 4.0*y*y <= 1.0)\nmodel.add_quadratic_constraint(x*x + 2.0*x*y + 4.0*y*y == 1.0)\nmodel.add_quadratic_constraint(x*x + 2.0*x*y + 4.0*y*y >= 1.0)\n```\n\n:::{note}\n\nSome solvers like COPT (as of 7.2.9) only supports convex quadratic constraints, which means the quadratic term must be positive semidefinite. If you try to add a non-convex quadratic constraint, an exception will be raised.\n:::\n\nThe two-sided quadratic constraint can also be created with a tuple to represent the left-hand side and right-hand side of the constraint like:\n\n```python\nmodel.add_quadratic_constraint(x*x + 2.0*x*y + 4.0*y*y, (1.0, 2.0))\n```\n:::{note}\n\nCurrently, two-sided quadratic constraint is only implemented for IPOPT.\n:::\n\n## Second-Order Cone Constraint\nIt is defined as:\n\n$$\nvariables=(t,x) \\in \\mathbb{R}^{N} : t \\ge \\lVert x \\rVert_2\n$$\n\nIt can be added to the model using the `add_second_order_cone_constraint` method of the `Model` \nclass.\n\n```{code-cell}\nN = 6\nvars = [model.add_variable() for i in range(N)]\n\ncon = model.add_second_order_cone_constraint(vars)\n```\n\nThere is another form of second-order cone constraint called as rotated second-order cone constraint, which is defined as:\n\n$$\nvariables=(t_{1},t_{2},x) \\in \\mathbb{R}^{N} : 2 t_1 t_2 \\ge \\lVert x \\rVert_2^2\n$$\n\n```{py:function} model.add_second_order_cone_constraint(variables, [name=\"\", rotated=False])\n\nadd a second order cone constraint to the model\n\n:param variables: the variables of the constraint, can be a list of variables\n:param str name: the name of the constraint, optional\n:param bool rotated: whether the constraint is a rotated second-order cone constraint, optional\n:return: the handle of the constraint\n```\n\n## Exponential Cone Constraint\nIt is defined as:\n\n$$\nvariables=(t,s,r) \\in \\mathbb{R}^{3} : t \\ge s \\exp(\\frac{r}{s}), s \\ge 0\n$$\n\nThe dual form is:\n\n$$\nvariables=(t,s,r) \\in \\mathbb{R}^{3} : t \\ge -r \\exp(\\frac{s}{r} - 1), r \\le 0\n$$\n\nCurrently, only COPT(after 7.1.4), Mosek support exponential cone constraint natively. \nXpress supports exponential cones by mapping them into generic NLP formulas at the API level. \nIt can be added to the model using the `add_exp_cone_constraint` method of the `Model` class.\n\n```{py:function} model.add_exp_cone_constraint(variables, [name=\"\", dual=False])\n\nadd a second order cone constraint to the model\n\n:param variables: the variables of the constraint, can be a list of variables\n:param str name: the name of the constraint, optional\n:param bool dual: whether the constraint is dual form of exponential cone, optional\n:return: the handle of the constraint\n```\n\n## Special Ordered Set (SOS) Constraint\nSOS constraints are used to model special structures in the optimization problem.\nIt contains two types: `SOS1` and `SOS2`, the details can be found in [Wikipedia](https://en.wikipedia.org/wiki/Special_ordered_set).\n\nIt can be added to the model using the `add_sos_constraint` method of the `Model` class.\n\n```{code-cell}\nN = 6\nvars = [model.add_variable(domain=poi.VariableDomain.Binary) for i in range(N)]\n\ncon = model.add_sos_constraint(vars, poi.SOSType.SOS1)\n```\n\n```{py:function} model.add_sos_constraint(variables, sos_type, [weights])\n\nadd a special ordered set constraint to the model\n\n:param variables: the variables of the constraint, can be a list of variables\n:param pyoptinterface.SOSType sos_type: the type of the SOS constraint, which can be `SOS1` or `SOS2`\n:param weights: the weights of the variables, optional, will be set to 1 if not provided\n:type weights: list[float]\n:return: the handle of the constraint\n```\n\n## Constraint Attributes\nAfter a constraint is created, we can query or modify its attributes. The following table lists the \nstandard [constraint attributes](#pyoptinterface.ConstraintAttribute):\n\n:::{list-table} **Standard [constraint attributes](#pyoptinterface.ConstraintAttribute)**\n:header-rows: 1\n:widths: 20 20\n\n* - Attribute name\n - Type\n* - Name\n - str\n* - Primal\n - float\n* - Dual\n - float\n* - IIS\n - bool\n:::\n\nThe most common attribute we will use is the `Dual` attribute, which represents the dual multiplier of the constraint after optimization.\n\n```python\n# get the dual multiplier of the constraint after optimization\ndual = model.get_constraint_attribute(con, poi.ConstraintAttribute.Dual)\n```\n\n## Delete constraint\nWe can delete a constraint by calling the `delete_constraint` method of the model:\n\n```python\nmodel.delete_constraint(con)\n```\n\nAfter a constraint is deleted, it cannot be used in the model anymore, otherwise an exception \nwill be raised.\n\nWe can query whether a constraint is active by calling the `is_constraint_active` method of the \nmodel:\n\n```python\nis_active = model.is_constraint_active(con)\n```\n\n## Modify constraint\nFor linear and quadratic constraints, we can modify the right-hand side of a constraint by \ncalling the `set_normalized_rhs` method of the model.\n\nFor linear constraints, we can modify the coefficients of the linear part of the constraint by\ncalling the `set_normalized_coefficient` method of the model.\n\n```python\ncon = model.add_linear_constraint(x + y, poi.Leq, 1.0)\n\n# modify the right-hand side of the constraint\nmodel.set_normalized_rhs(con, 2.0)\n\n# modify the coefficient of the linear part of the constraint\nmodel.set_normalized_coefficient(con, x, 2.0)\n```\n" }, { "path": "docs/source/container.md", "content": "---\nfile_format: mystnb\nkernelspec:\n name: python3\n---\n\n# Container\n\nIn our previous examples, we only use scalar variable, constraint and expression. However, in many cases, we need to handle a large number of variables, constraints and expressions.\n\nIn general, PyOptInterface does not restrict the ways to store these objects. You can use a list, a dictionary, or any other data structure to store them, because PyOptInterface only requires the handle of the object to manipulate it and each handle is a compact C++ object that can be easily stored and passed around. In other words, we follow the Bring Your Own Container (BYOC) principle.\n\nHowever, in the context of optimization, we often needs to represent the model in a more structured way. The most classic example is [`Set`](https://ampl.com/wp-content/uploads/Chapter-5-Simple-Sets-and-Indexing-AMPL-Book.pdf) in AMPL, which provides a flexible way to represent multi-dimensional data with custom indexing. The concept is also widely used in other optimization modeling languages, such as [JuMP](https://jump.dev/JuMP.jl/stable/manual/containers/) in Julia and [Pyomo](https://pyomo.readthedocs.io/en/stable/pyomo_modeling_components/Sets.html) in Python.\n\nIn PyOptInterface, we provide a simple container named `tupledict` to represent multidimensional data. It is a dictionary-like object that can be indexed by multiple keys. It is a convenient way to store and manipulate multi-dimensional data in PyOptInterface. The design and usage of `tupledict` is inspired by the `tupledict` in [gurobipy](https://www.gurobi.com/documentation/current/refman/py_tupledict.html).\n\nWe will use `tupledict` to demonstrate how to use a container to store and manipulate multi-dimensional data in PyOptInterface.\n\nSimply speaking, `tupledict` is a derived class of Python dict where the keys represent multidimensional indices as n-tuple, and the values are typically variables, constraints or expressions.\n\n## Create a `tupledict`\n`tuplelist` can be created by calling the `tupledict` constructor. The following example creates a `tupledict` with two keys:\n\n```{code-cell}\nimport pyoptinterface as poi\n\ntd = poi.tupledict()\ntd[1, 2] = 3\ntd[4, 5] = 6\n\nprint(td)\n```\n\nIt can also be created by passing a dictionary to the constructor:\n\n```{code-cell}\ntd = poi.tupledict({(1, 2): 3, (4, 5): 6})\n```\n\nIn most cases, we have multiple indices as the axis and define a rule to construct the `tupledict`. `make_tupledict` provide a convenient way to create a `tupledict` from a list of indices and a function that maps the indices to the values. The following example creates a `tupledict` with two keys:\n\n```{code-cell}\nI = range(3)\nJ = [6, 7]\nK = (\"Asia\", \"Europe\")\n\ndef f(i, j, k):\n return f\"value_{i}_{j}_{k}\"\n\ntd = poi.make_tupledict(I, J, K, rule=f)\n\nprint(td)\n```\n\nSometimes we need to create a `tupledict` with a sparse pattern where some combinations of indices are missing. `make_tupledict` also provides a convenient way to create a `tupledict` with a sparse pattern, you only need to return `None` when the corresponding value is unwanted. The following example creates a `tupledict` with a sparse pattern:\n\n```{code-cell}\nI = range(3)\nJ = [6, 7]\nK = (\"Asia\", \"Europe\")\n\ndef f(i, j, k):\n if i == 0 and j == 6 and k == \"Asia\":\n return \"value_0_6_Asia\"\n else:\n return None\n\ntd = poi.make_tupledict(I, J, K, rule=f)\n \nprint(td)\n```\n\nFor highly sparse patterns, you can provide the sparse indices directly to make it more efficient.\n\n```\nI = range(2)\nJ = range(8)\nK = range(8)\n\n# We only want to construct (i, j, k) where j=k\nJK = [(j, j) for j in J]\n\ndef f(i, j, k):\n return f\"value_{i}_{j}_{k}\"\n\n# JK will be flattened as j and k during construction\ntd = poi.make_tupledict(I, JK, rule=f)\n\nprint(td)\n```\n\n## Set/get values\nLike normal dictionary in Python, the values of a `tupledict` can be set or get by using the `[]` operator. The following example sets and gets the values of a `tupledict`:\n\n```{code-cell}\ntd = poi.tupledict({(1, 2): 3, (4, 5): 6})\ntd[1, 2] = 4\nprint(f\"{td[1, 2]=}\")\n\ntd[4, 8] = 7\nprint(f\"{td[4, 8]=}\")\n```\n\nAs a representation of multidimensional data, `tupledict` also provides a way to iterate some axis efficiently.\n`tupledict.select` can be used to select a subset of the `tupledict` by fixing some indices. The following example selects a subset of the `tupledict`: \n\n```{code-cell}\n\ntd = poi.make_tupledict(range(3), range(3), range(3), rule=lambda i, j, k: f\"value_{i}_{j}_{k}\")\n\n# Select the subset where i=1\n# \"*\" means wildcard that matches any value for j and k\n# select returns a generator and can be converted to a list\nsubset_values_iterator = td.select(1, \"*\", \"*\")\nsubset_values = list(subset_values_iterator)\n\n# Select the subset where j=2 and k=1\nsubset_values = list(td.select(\"*\", 2, 1))\n\n# the iterator can retuen the (key, value) pair if we pass with_key=True to select\nsubset_kv_iterator = td.select(1, \"*\", \"*\", with_key=True)\n```\n\n## Apply a function to values with `map` method\n`tupledict` provides a `map` method to apply a function to each value in the `tupledict`. The following example applies a function to each value in the `tupledict`:\n\n```{code-cell}\ntd = poi.make_tupledict(range(3), range(2), rule=lambda i, j: i+j)\ntd_new = td.map(lambda x: x*x)\ntd, td_new\n```\n\n## Building a model with `tupledict`\n`tupledict` can be used to store and manipulate multi-dimensional variables, constraints and expressions. Using it correctly will make building model more easily.\n\nThe following example demonstrates how to use `tupledict` to build a model:\n\n$$\n\n\\min \\quad & \\sum_{i=0}^{I} \\sum_{j=0}^{J} x_{ij}^2 \\\\\n\\textrm{s.t.} \\quad & \\sum_{i=0}^{I} x_{ij} = 1, \\quad \\forall j \\\\\n \\quad & x_{ij} \\geq 0, \\quad \\forall i, j\n\n$$\n\n```{code-cell}\nimport pyoptinterface as poi\nfrom pyoptinterface import highs\n\nmodel = highs.Model()\n\nI = range(10)\nJ = range(20)\n\nx = poi.make_tupledict(I, J, rule=lambda i, j: model.add_variable(lb=0, name=f\"x({i},{j})\"))\n\ndef constraint_rule(j):\n expr = poi.quicksum(x.select(\"*\", j))\n con = model.add_linear_constraint(expr, poi.ConstraintSense.Equal, 1, name=f\"con_{j}\")\n return con\n\nconstraint = poi.make_tupledict(J, rule=constraint_rule)\n\nobj = poi.quicksum(x.values(), lambda x: x*x)\nmodel.set_objective(obj, poi.ObjectiveSense.Minimize)\n\nmodel.optimize()\n\nx_value = x.map(model.get_value)\n```\n\nHere we use two utility functions to simplify how we express the sum notation\n\n```{py:function} quicksum(values, [f=None])\n\nCreate a new expression by summing up a list of values (optionally, you can apply a function to\neach value in advance)\n\n:param values: iterator of values\n:param f: a function that takes a value and returns a new value\n:return: the handle of the new expression\n:rtype: pyoptinterface.ExprBuilder\n```\n\nThere is also an in-place version:\n\n```{py:function} quicksum_(expr, values, [f=None])\n\nAdd a list of values to an existing expression (optionally, you can apply a function to each value in advance)\n\n:param pyoptinterface.ExprBuilder expr: the handle of the existing expression\n:param values: iterator of values\n:param f: a function that takes a value and returns a new value\n:return: None\n```\n\nWe notice that `poi.make_tupledict(I, J, rule=lambda i, j: model.add_variable(lb=0, name=f\"x({i},{j})\"))` is a frequently used pattern to create a `tupledict` of variables, so we provide a convenient way to create a `tupledict` of variables by calling [`model.add_variables`](#model.add_variables):\n\n```python\nx = model.add_variables(I, J, lb=0, name=\"x\")\n```\n" }, { "path": "docs/source/copt.md", "content": "# COPT\n\n## Initial setup\n\n```python\nfrom pyoptinterface import copt\n\nmodel = copt.Model()\n```\n\nYou need to follow the instructions in [Getting Started](getting_started.md#copt) to set up the optimizer correctly.\n\nIf you want to manage the license of COPT manually, you can create a `copt.Env` object and pass it to the constructor of the `copt.Model` object, otherwise we will initialize an implicit global `copt.Env` object automatically and use it.\n\n```python\nenv = copt.Env()\n\nmodel = copt.Model(env)\n```\n\n## The capability of `copt.Model`\n\n### Supported constraints\n\n:::{list-table}\n:header-rows: 1\n\n* - Constraint\n - Supported\n* - \n - ✅\n* - \n - ✅\n* - \n - ✅\n* - \n - ✅\n* - \n - ✅\n\n:::\n\n```{include} attribute/copt.md\n```\n\n\n## Solver-specific operations\n\n### Parameter\n\nFor [solver-specific parameters](https://guide.coap.online/copt/en-doc/parameter.html), we provide `get_raw_parameter` and `set_raw_parameter` methods to get and set the parameters.\n\n```python\nmodel = copt.Model()\n\n# get the value of the parameter\nvalue = model.get_raw_parameter(\"TimeLimit\")\n\n# set the value of the parameter\nmodel.set_raw_parameter(\"TimeLimit\", 10.0)\n```\n\n### Attribute\n\nCOPT supports [attribute](https://guide.coap.online/copt/en-doc/attribute.html) for the model. We provide `model.get_raw_attribute(name:str)` to get the value of attribute.\n\n### Information\n\nCOPT provides [information](https://guide.coap.online/copt/en-doc/information.html) for the model components. We provide methods to access the value of information.\n\n- Information of variable: `model.get_variable_info(variable, name: str)`\n- Information of constraint: `model.get_constraint_info(constraint, name: str)`\n\nWe also provide `copt.COPT` to contain all the constants in `coptpy.COPT`.\n\nFor number of variables (columns) in the problem:\n```python\ncols = model.get_raw_attribute(copt.COPT.Attr.Cols)\n```\n\nFor reduced cost of a variable:\n```python\nrc = model.get_variable_info(variable, copt.COPT.Info.RedCost)\n```\n\nFor upper bound of a constraint:\n```python\nub = model.get_constraint_info(constraint, copt.COPT.Info.UB)\n```" }, { "path": "docs/source/develop.md", "content": "# Developer Guide\n\nThis section is intended for developers who want to contribute to the PyOptInterface library. It provides an overview of the codebase, the development process, and the guidelines for contributing to the project.\n\n## Codebase Overview\n\nThe PyOptInterface library is a C++/Python mixed library. The core parts are implemented in C++ and exposed to Python via [nanobind](https://github.com/wjakob/nanobind). The build system is based on [scikit-build-core](https://github.com/scikit-build/scikit-build-core).\n\nThe codebase is organized as follows:\n\n- `include/pyoptinterface`: The header files of the C++ library.\n- `lib`: The source files of the C++ library.\n- `src`: The Python interface.\n- `tests`: The test cases.\n- `thirdparty`: The third-party dependencies.\n\n## Development Process\n\nSupposing you want to contribute to PyOptInterface, you can follow these steps:\n\nFirstly, fork the [PyOptInterface repository](https://github.com/metab0t/PyOptInterface) on GitHub and clone your forked repository to your local machine: `git clone https://github.com//PyOptInterface.git`.\n\nNext, you should set up the development environment. The third-party optimizers must be configured following the instructions in [getting started](getting_started.md). In order to build PyOptInterface from source, you need the following dependencies:\n- CMake\n- A recent C++ compiler (We routinely test with GCC 10, latest MSVC and Apple Clang on the CI)\n- Python 3.8 or later\n- Python packages: `scikit-build-core`, can be installed by running `pip install scikit-build-core[pyproject]`\n\nThen, you can build the project by running the following commands:\n```bash\npip install --no-build-isolation -ve .\n```\n\nYou will see a new `build` directory created in the project root. The Python package is installed in editable mode, so you can modify the source code and test the changes without reinstalling the package.\n\nAfter making changes to the code, you should run the test cases to ensure that everything is working as expected. You can run the test cases by executing the following command (installing `pytest` is required):\n```bash\npytest tests\n```\n\nThe tests of PyOptInterface are still scarce, so you are encouraged to write new test cases for the new features you add.\n\nFinally, you can submit a pull request to the [PyOptInterface repository](https://github.com/metab0t/PyOptInterface)\n\n## Building Documentation\n\nThe documentation of PyOptInterface is built using [Sphinx](https://www.sphinx-doc.org/).\n\nFirstly, you should install the dependencies for building the documentation:\n```bash\npip install -r docs/requirements.txt\n```\n\nYou can build the documentation by running the following commands:\n```bash\ncd docs\nmake html\n```\n\nThe docs are built in the `docs/build/html` directory. You can open the `index.html` file in a web browser to view the documentation.\n\n## Contributing Guidelines\n\nWhen contributing to PyOptInterface, please follow these guidelines:\n\n- Make sure that the code is well formatted and documented. The C++ code is formatted using [clang-format](https://clang.llvm.org/docs/ClangFormat.html) and the Python code is formatted using [black](https://black.readthedocs.io/en/stable/).\n- For big changes like adding interface for a new optimizer, please open a thread in [**Discussion**](https://github.com/metab0t/PyOptInterface/discussions) to discuss the design before starting the implementation.\n" }, { "path": "docs/source/examples/economic_dispatch.md", "content": "---\nfile_format: mystnb\nkernelspec:\n name: python3\n---\n# Economic Dispatch\n\nEconomic dispatch is a classic optimization problem in power systems. It is used to determine the optimal power output of a set of generators to meet the demand at the lowest cost. The problem can be formulated as a linear programming problem or a quadratic programming problem depending on the formulation used to model the economic cost.\n\nIn this example, we will show how to use PyOptInterface to solve an economic dispatch problem using the quadratic programming formulation.\n\n## Problem Formulation\n\n$$\n\\min \\quad & \\sum_{t=1}^T \\sum_{i=1}^{N_G} a_i P_{i,t}^2 + b_i P_{i,t} + c_i \\\\\n\\textrm{s.t.} \\quad & \\sum_{i=1}^{N_G} P_{i,t} = \\sum_{i=1}^{N_D} D_{i,t}\\\\\n \\quad & P_{min,i} \\leq P_{i,t} \\leq P_{max,i} \\\\\n \\quad & -Rdn_{i} \\leq P_{i,t} - P_{i,t-1} \\leq Rup_{i}\n$$\n\nWe consider a system with $N_G$ generators and $N_D$ demands. The decision variables are the power output of the generators $P_{i,t}$ for $i=1,\\ldots,N_G$ and $t=1,\\ldots,T$. The objective function is the total cost of the generators, which is the sum of the quadratic cost, the linear cost, and the constant cost. The first constraint ensures that the total power output of the generators meets the demand. The second and third constraints are the power output limits of the generators. The last constraint is the ramping limits of the generators.\n\n## Implementation\n\nFirstly, we need to create a model object. We will use the HiGHS solver in this example because it is an excellent open-source solver and supports quadratic programming problems. You need to read the [installation guide](../highs.md#initial-setup) to install the HiGHS solver manually and set the path to shared library of HiGHS as described in the guide.\n\n```{code-cell}\nimport pyoptinterface as poi\nfrom pyoptinterface import highs\n\nmodel = highs.Model()\n```\n\nThen, we need to create new variables in the model to represent the power output of the generators. We will use the [`add_variables`](#model.add_variables) method to add multidimensional variables to the model.\n\n```{code-cell}\nT = 24\nN_G = 3\nP_min = [50, 50, 50]\nP_max = [100, 100, 100]\na_cost = [0.01, 0.015, 0.02]\nb_cost = [1, 1.5, 2]\nc_cost = [0, 0, 0]\nRup = [20, 20, 20]\nRdn = [20, 20, 20]\n\nP = model.add_variables(range(N_G), range(T), name=\"P\")\n```\n\nFor the lower and upper bound of variables, we can set the corresponding [variable attribute](#pyoptinterface.VariableAttribute) to set them.\n\n```{code-cell}\nfor i in range(N_G):\n for t in range(T):\n model.set_variable_attribute(P[i, t], poi.VariableAttribute.LowerBound, P_min[i])\n model.set_variable_attribute(P[i, t], poi.VariableAttribute.UpperBound, P_max[i])\n```\n\nNext, we need to add the power balance constraint to the model. We will use the [`add_linear_constraint`](#model.add_linear_constraint) method to add a linear constraint to the model. The multidimensional constraint is managed by `tupledict` and we use the `make_tupledict` method to create a multidimensional constraint.\n\nThe total demand is assumed to be a constant in this example.\n\n```{code-cell}\ntotal_demand = [220 for _ in range(T)]\n\ndef con(t):\n lhs = poi.quicksum(P[i, t] for i in range(N_G))\n rhs = total_demand[t]\n return model.add_linear_constraint(lhs, poi.Eq, rhs, name=f\"powerbalance_{t}\")\n\npowebalance_constraints = poi.make_tupledict(range(T), rule=con)\n```\n\n```{code-cell}\ndef rampup_con(i, t):\n if t == 0:\n return None\n lhs = P[i, t] - P[i, t-1]\n rhs = Rup[i]\n return model.add_linear_constraint(lhs, poi.Leq, rhs, name=f\"rampup_{i}_{t}\")\n\nrampup_constraints = poi.make_tupledict(range(N_G), range(T), rule=rampup_con)\n\ndef rampdown_con(i, t):\n if t == 0:\n return None\n lhs = P[i, t] - P[i, t-1]\n rhs = -Rdn[i]\n return model.add_linear_constraint(lhs, poi.Geq, rhs, name=f\"rampdown_{i}_{t}\")\n\nrampdown_constraints = poi.make_tupledict(range(N_G), range(T), rule=rampdown_con)\n```\n\nThen, we need to add the quadratic objective function to the model. We will use the [`set_objective`](#model.set_objective) method to set the objective function of the model.\n\n```{code-cell}\nobj = poi.ExprBuilder()\nfor t in range(T):\n for i in range(N_G):\n obj += a_cost[i] * P[i, t] * P[i, t] + b_cost[i] * P[i, t] + c_cost[i]\nmodel.set_objective(obj)\n```\n\nFinally, we can solve the model and query the solution.\n\n```{code-cell}\nmodel.optimize()\n\nprint(model.get_model_attribute(poi.ModelAttribute.TerminationStatus))\nprint(\"Objective value: \", model.get_value(obj))\n```\n\nThe optimal value of decision variables can be queried via `get_value` function.\n\n```{code-cell}\nimport numpy as np\n\nP_value = np.fromiter(\n (model.get_value(P[i, t]) for i in range(N_G) for t in range(T)), float\n).reshape(N_G, T)\n\nP_value\n```\n\n## Change the load and solve the model again\n\nWe can change the load and solve the model again without creating a new model from scratch by modifying the right-hand side of the power balance constraint.\n\nFor example, we increase the load and solve the model again.\n\n```{code-cell}\ntotal_demand = [220 + 1.0 * t for t in range(T)]\n\nfor t in range(T):\n model.set_normalized_rhs(powebalance_constraints[t], total_demand[t])\n\nmodel.optimize()\nprint(model.get_model_attribute(poi.ModelAttribute.TerminationStatus))\nprint(\"Objective value: \", model.get_value(obj))\n\nP_value = np.fromiter(\n (model.get_value(P[i, t]) for i in range(N_G) for t in range(T)), float\n).reshape(N_G, T)\n\nprint(P_value)\n```" }, { "path": "docs/source/examples/optimal_control_rocket.md", "content": "---\nfile_format: mystnb\nkernelspec:\n name: python3\n---\n# Optimal Control of a Rocket\n\nThis example is adapted from [the JuMP tutorial](https://jump.dev/JuMP.jl/stable/tutorials/nonlinear/rocket_control/).\n\nThe goal is to show that there are explicit repeated structures in discretized optimal control problem regarded as a nonlinear program (NLP). We will use the optimal control of a rocket as an example to demonstrate how to exploit these structures to solve the problem more efficiently via PyOptInterface.\n\n## Problem Formulation\n\nThe problem is to find the optimal control of a rocket to maximize the altitude at the final time while satisfying the dynamics of the rocket. The dynamics of the rocket are described by the following ordinary differential equations (ODEs):\n\n$$\n\\begin{align*}\n\\frac{dh}{dt} &= v \\\\\n\\frac{dv}{dt} &= -g(h) + \\frac{u-D(h,v)}{m} \\\\\n\\frac{dm}{dt} &= -\\frac{u}{c}\n\\end{align*}\n$$\n\nwhere $h$ is the altitude, $v$ is the velocity, $m$ is the mass, $u$ is the thrust, $g(h)$ is the gravitational acceleration, and $D(h,v)$ is the drag force. The thrust $u$ is the control variable.\n\nThe drag force is given by $D(h,v) = D_c v^2 \\exp(-h_c \\frac{h-h_0}{h_0})$, and the gravitational acceleration is given by $g(h) = g_0 (\\frac{h_0}{h})^2$.\n\nBy discretizing the ODEs, we obtain the following nonlinear program:\n\n$$\n\\begin{align*}\n\\frac{h_{t+1}-h_t}{\\Delta t} &= v_t \\\\\n\\frac{v_{t+1}-v_t}{\\Delta t} &= -g(h_t) + \\frac{u_t-D(h_t,v_t)}{m_t} \\\\\n\\frac{m_{t+1}-m_t}{\\Delta t} &= -\\frac{u_t}{c}\n\\end{align*}\n$$\n\nwhere $h_t$, $v_t$, and $m_t$ are the altitude, velocity, and mass at time $t$, respectively, and $\\Delta t$ is the time step.\n\n## Implementation\n\nIn the discretized optimal control problem, the variables at two adjacent time points share the same algebraic relationship.\n\n```{code-cell}\nimport math\nimport pyoptinterface as poi\nfrom pyoptinterface import nl, ipopt\n\nmodel = ipopt.Model()\n\nh_0 = 1.0\nv_0 = 0.0\nm_0 = 1.0\ng_0 = 1.0\nT_c = 3.5\nh_c = 500.0\nv_c = 620.0\nm_c = 0.6\n\nc = 0.5 * math.sqrt(g_0 * h_0)\nm_f = m_c * m_0\nD_c = 0.5 * v_c * (m_0 / g_0)\nT_max = T_c * m_0 * g_0\n\nnh = 1000\n```\n\nThen, we declare variables and set boundary conditions.\n\n```{code-cell}\nh = model.add_m_variables(nh, lb=1.0)\nv = model.add_m_variables(nh, lb=0.0)\nm = model.add_m_variables(nh, lb=m_f, ub=m_0)\nT = model.add_m_variables(nh, lb=0.0, ub=T_max)\nstep = model.add_variable(lb=0.0)\n\n# Boundary conditions\nmodel.set_variable_bounds(h[0], h_0, h_0)\nmodel.set_variable_bounds(v[0], v_0, v_0)\nmodel.set_variable_bounds(m[0], m_0, m_0)\nmodel.set_variable_bounds(m[-1], m_f, m_f)\n```\n\nNext, we add the dynamics constraints.\n\n```{code-cell}\nfor i in range(nh - 1):\n with nl.graph():\n h1 = h[i]\n h2 = h[i + 1]\n v1 = v[i]\n v2 = v[i + 1]\n m1 = m[i]\n m2 = m[i + 1]\n T1 = T[i]\n T2 = T[i + 1]\n\n model.add_nl_constraint(h2 - h1 - 0.5 * step * (v1 + v2) == 0)\n\n D1 = D_c * v1 * v1 * nl.exp(-h_c * (h1 - h_0)) / h_0\n D2 = D_c * v2 * v2 * nl.exp(-h_c * (h2 - h_0)) / h_0\n g1 = g_0 * h_0 * h_0 / (h1 * h1)\n g2 = g_0 * h_0 * h_0 / (h2 * h2)\n dv1 = (T1 - D1) / m1 - g1\n dv2 = (T2 - D2) / m2 - g2\n\n model.add_nl_constraint(v2 - v1 - 0.5 * step * (dv1 + dv2) == 0)\n model.add_nl_constraint(m2 - m1 + 0.5 * step * (T1 + T2) / c == 0)\n```\n\nFinally, we add the objective function. We want to maximize the altitude at the final time, so we set the objective function to be the negative of the altitude at the final time.\n\n```{code-cell}\nmodel.set_objective(-h[-1])\n```\n\nAfter solving the problem, we can plot the results.\n\n```{code-cell}\nmodel.optimize()\n```\n\n```{code-cell}\nh_value = []\nfor i in range(nh):\n h_value.append(model.get_value(h[i]))\n\nprint(\"Optimal altitude: \", h_value[-1])\n```\n\nThe plot of the altitude of the rocket is shown below.\n\n```{code-cell}\nimport matplotlib.pyplot as plt\n\nplt.plot(h_value)\nplt.xlabel(\"Time\")\nplt.ylabel(\"Altitude\")\nplt.show()\n```\n" }, { "path": "docs/source/examples/optimal_power_flow.md", "content": "---\nfile_format: mystnb\nkernelspec:\n name: python3\n---\n# Optimal Power Flow\n\nAlternating current optimal power flow (ACOPF) is a fundamental nonlinear optimization problem in power systems. It is used to determine the optimal power flow of a power system to minimize the generation cost while satisfying the power flow equations and system constraints.\n\nIn this example, we will show how to use PyOptInterface to solve an single-period optimal power flow problem using the structured nonlinear programming formulation.\n\n## Problem Formulation\n\n$$\n\\min \\quad & \\sum_{i \\in G} a_i P_{i}^2 + b_i P_{i} + c_i \\\\\n\\textrm{s.t.} \\quad & \\theta_r = 0 \\quad & \\forall r \\in R \\\\\n \\quad & P_{min,i} \\leq P_{i} \\leq P_{max,i} \\quad & \\forall i \\in G \\\\\n \\quad & Q_{min,i} \\leq Q_{i} \\leq Q_{max,i} \\quad & \\forall i \\in G \\\\\n \\quad & V_{min,b} \\leq V_{b} \\leq V_{max,b} \\quad & \\forall b \\in BUS \\\\\n \\quad & \\sum_{i \\in G_b} P_{i} - \\sum_{i \\in D_b} L^P_{i} - G_{sh,b} V_b^2 = \\sum_{(i, j) \\in BRANCH} P_{ij} \\quad & \\forall b \\in BUS \\\\\n \\quad & \\sum_{i \\in G_b} Q_{i} - \\sum_{i \\in D_b} L^Q_{i} + B_{sh,b} V_b^2 = \\sum_{(i, j) \\in BRANCH} Q_{ij} \\quad & \\forall b \\in BUS \\\\\n \\quad & P_{ij} = G_{ij} V_i^2 - V_i V_j (G_{ij}\\cos(\\theta_i-\\theta_j)+B_{ij}\\sin(\\theta_i-\\theta_j)) \\quad & \\forall (i, j) \\in BRANCH \\\\\n \\quad & Q_{ij} = -B^C_{ij} V_i^2 - B_{ij} V_i^2 - V_i V_j (G_{ij}\\sin(\\theta_i-\\theta_j)-B_{ij}\\cos(\\theta_i-\\theta_j)) \\quad & \\forall (i, j) \\in BRANCH \\\\\n \\quad & P_{ji} = G_{ij} V_j^2 - V_i V_j (G_{ij}\\cos(\\theta_j-\\theta_i)+B_{ij}\\sin(\\theta_j-\\theta_i)) \\quad & \\forall (i, j) \\in BRANCH \\\\\n \\quad & Q_{ji} = -B^C_{ij} V_j^2 - B_{ij} V_j^2 - V_i V_j (G_{ij}\\sin(\\theta_j-\\theta_i)-B_{ij}\\cos(\\theta_j-\\theta_i)) \\quad & \\forall (i, j) \\in BRANCH \\\\\n \\quad & -S_{max,ij} \\leq P_{ij}^2 + Q_{ij}^2 \\leq S_{max,ij} \\quad & \\forall (i, j) \\in BRANCH \\\\\n \\quad & -\\Delta\\theta_{min,ij} \\leq \\theta_i - \\theta_j \\leq -\\Delta\\theta_{max,ij} \\quad & \\forall (i, j) \\in BRANCH\n$$\n\nThe decision variables are the active power output of the generators $P_{i}$, reactive power output of the generators $Q_{i}$, voltage magnitude of the buses $V_{b}$, phase angle of the buses $\\theta_{b}$ for $b \\in BUS$ and the branch power flows $P_{ij}$ and $Q_{ij}$ for $(i, j) \\in BRANCH$.\n\nThe objective function is the total cost of the generators, which is the sum of the quadratic cost, the linear cost, and the constant cost. The first constraint ensures that the phase angle of the reference bus is zero. The second and third constraints are the active and reactive power output limits of the generators. The fourth constraint is the voltage magnitude limits of the buses. The fifth and sixth constraints are the power balance equations of the buses. The seventh and eighth constraints are the power flow equations of the branches. The ninth and tenth constraints are the power flow equations of the branches in the opposite direction. The eleventh and twelfth constraints are the apparent power limits of the branches. The last constraint is the phase angle difference limits of the branches.\n\n## Implementation\n\nWe will use PJM 5-bus system as an example to demonstrate the implementation of the optimal power flow problem. The PJM 5-bus system is a small power system with 5 buses and 6 branches. The system data is shown below.\n\n```{code-cell}\n\nbranches = [\n # (from, to, R, X, B, angmin, angmax, Smax)\n (0, 1, 0.00281, 0.0281, 0.00712, -30.0, 30.0, 4.00),\n (0, 3, 0.00304, 0.0304, 0.00658, -30.0, 30.0, 4.26),\n (0, 4, 0.00064, 0.0064, 0.03126, -30.0, 30.0, 4.26),\n (1, 2, 0.00108, 0.0108, 0.01852, -30.0, 30.0, 4.26),\n (2, 3, 0.00297, 0.0297, 0.00674, -30.0, 30.0, 4.26),\n (3, 4, 0.00297, 0.0297, 0.00674, -30.0, 30.0, 2.40),\n]\n\nbuses = [\n # (Pd, Qd, Gs, Bs, Vmin, Vmax)\n (0.0, 0.0000, 0.0, 0.0, 0.9, 1.1),\n (3.0, 0.9861, 0.0, 0.0, 0.9, 1.1),\n (3.0, 0.9861, 0.0, 0.0, 0.9, 1.1),\n (4.0, 1.3147, 0.0, 0.0, 0.9, 1.1),\n (0.0, 0.0000, 0.0, 0.0, 0.9, 1.1),\n]\n\ngenerators = [\n # (bus, Pmin, Pmax, Qmin, Qmax, a, b, c)\n (0, 0.0, 0.4, -0.300, 0.300, 0.0, 1400, 0.0),\n (0, 0.0, 1.7, -1.275, 1.275, 0.0, 1500, 0.0),\n (2, 0.0, 5.2, -3.900, 3.900, 0.0, 3000, 0.0),\n (3, 0.0, 2.0, -1.500, 1.500, 0.0, 4000, 0.0),\n (4, 0.0, 6.0, -4.500, 4.500, 0.0, 1000, 0.0),\n]\n\nslack_bus = 3\n```\n\nThen we declare the variables:\n\n```{code-cell}\nimport math\nimport pyoptinterface as poi\nfrom pyoptinterface import nl, ipopt\n\nmodel = ipopt.Model()\n\nN_branch = len(branches)\nN_bus = len(buses)\nN_gen = len(generators)\n\nPbr_from = model.add_m_variables(N_branch)\nQbr_from = model.add_m_variables(N_branch)\nPbr_to = model.add_m_variables(N_branch)\nQbr_to = model.add_m_variables(N_branch)\n\nV = model.add_m_variables(N_bus, name=\"V\")\ntheta = model.add_m_variables(N_bus, name=\"theta\")\n\nfor i in range(N_bus):\n Vmin, Vmax = buses[i][4], buses[i][5]\n model.set_variable_bounds(V[i], Vmin, Vmax)\n\nmodel.set_variable_bounds(theta[slack_bus], 0.0, 0.0)\n\nP = model.add_variables(range(N_gen), name=\"P\")\nQ = model.add_variables(range(N_gen), name=\"Q\")\n\nfor i in range(N_gen):\n model.set_variable_bounds(P[i], generators[i][1], generators[i][2])\n model.set_variable_bounds(Q[i], generators[i][3], generators[i][4])\n```\n\nNext, we add the constraints:\n\n```{code-cell}\n# nonlinear constraints\nfor k in range(N_branch):\n with nl.graph():\n branch = branches[k]\n R, X, Bc2 = branch[2], branch[3], branch[4]\n\n G = R / (R**2 + X**2)\n B = -X / (R**2 + X**2)\n Bc = Bc2 / 2\n\n i = branch[0]\n j = branch[1]\n\n Vi = V[i]\n Vj = V[j]\n theta_i = theta[i]\n theta_j = theta[j]\n\n Pij = Pbr_from[k]\n Qij = Qbr_from[k]\n Pji = Pbr_to[k]\n Qji = Qbr_to[k]\n\n sin_ij = nl.sin(theta_i - theta_j)\n cos_ij = nl.cos(theta_i - theta_j)\n\n Pij_eq = G * Vi**2 - Vi * Vj * (G * cos_ij + B * sin_ij) - Pij\n Qij_eq = -(B + Bc) * Vi**2 - Vi * Vj * (G * sin_ij - B * cos_ij) - Qij\n Pji_eq = G * Vj**2 - Vi * Vj * (G * cos_ij - B * sin_ij) - Pji\n Qji_eq = -(B + Bc) * Vj**2 - Vi * Vj * (-G * sin_ij - B * cos_ij) - Qji\n\n model.add_nl_constraint(\n Pij_eq == 0.0,\n )\n model.add_nl_constraint(\n Qij_eq == 0.0,\n )\n model.add_nl_constraint(\n Pji_eq == 0.0,\n )\n model.add_nl_constraint(\n Qji_eq == 0.0,\n )\n\n# power balance constraints\nP_balance_eq = [poi.ExprBuilder() for i in range(N_bus)]\nQ_balance_eq = [poi.ExprBuilder() for i in range(N_bus)]\n\nfor b in range(N_bus):\n Pd, Qd = buses[b][0], buses[b][1]\n Gs, Bs = buses[b][2], buses[b][3]\n Vb = V[b]\n\n P_balance_eq[b] -= poi.quicksum(\n Pbr_from[k] for k in range(N_branch) if branches[k][0] == b\n )\n P_balance_eq[b] -= poi.quicksum(\n Pbr_to[k] for k in range(N_branch) if branches[k][1] == b\n )\n P_balance_eq[b] += poi.quicksum(\n P[i] for i in range(N_gen) if generators[i][0] == b\n )\n P_balance_eq[b] -= Pd\n P_balance_eq[b] -= Gs * Vb * Vb\n\n Q_balance_eq[b] -= poi.quicksum(\n Qbr_from[k] for k in range(N_branch) if branches[k][0] == b\n )\n Q_balance_eq[b] -= poi.quicksum(\n Qbr_to[k] for k in range(N_branch) if branches[k][1] == b\n )\n Q_balance_eq[b] += poi.quicksum(\n Q[i] for i in range(N_gen) if generators[i][0] == b\n )\n Q_balance_eq[b] -= Qd\n Q_balance_eq[b] += Bs * Vb * Vb\n\n model.add_quadratic_constraint(P_balance_eq[b], poi.Eq, 0.0)\n model.add_quadratic_constraint(Q_balance_eq[b], poi.Eq, 0.0)\n\nfor k in range(N_branch):\n branch = branches[k]\n\n i = branch[0]\n j = branch[1]\n\n theta_i = theta[i]\n theta_j = theta[j]\n\n angmin = branch[5] / 180 * math.pi\n angmax = branch[6] / 180 * math.pi\n\n model.add_linear_constraint(theta_i - theta_j, (angmin, angmax))\n\n Smax = branch[7]\n Pij = Pbr_from[k]\n Qij = Qbr_from[k]\n Pji = Pbr_to[k]\n Qji = Qbr_to[k]\n model.add_quadratic_constraint(Pij * Pij + Qij * Qij, poi.Leq, Smax * Smax)\n model.add_quadratic_constraint(Pji * Pji + Qji * Qji, poi.Leq, Smax * Smax)\n```\n\nFinally, we set the objective function:\n\n```{code-cell}\ncost = poi.ExprBuilder()\nfor i in range(N_gen):\n a, b, c = generators[i][5], generators[i][6], generators[i][7]\n cost += a * P[i] * P[i] + b * P[i] + c\nmodel.set_objective(cost)\n```\n\nAfter optimization, we can retrieve the optimal solution:\n\n```{code-cell}\nmodel.optimize()\n```\n\n```{code-cell}\nprint(model.get_model_attribute(poi.ModelAttribute.TerminationStatus))\n\nP_value = P.map(model.get_value)\n\nprint(\"Optimal active power output of the generators:\")\n\nfor i in range(N_gen):\n print(f\"Generator {i}: {P_value[i]}\")\n```\n" }, { "path": "docs/source/expression.md", "content": "---\nfile_format: mystnb\nkernelspec:\n name: python3\n---\n# Expression\n\n## Basic expression\n\nPyOptInterface currently supports polynomial expressions with degree up to 2, including\n- quadratic expression\n- linear expression\n- constant expression\n\nThe expression can be expressed by arithmetic operations of variables and constants. For example, we can create a quadratic expression by adding two quadratic expressions, multiplying a linear expression with a constant expression, etc.\n\n```{code-cell}\nimport pyoptinterface as poi\nfrom pyoptinterface import highs\n\nmodel = highs.Model()\n\nx = model.add_variable()\n\n# create a quadratic expression\nexpr1 = x * x + 2 * x + 1\n# create a linear expression\nexpr2 = 2 * x + 1\n\n# create a quadratic expression by adding two quadratic expressions\nexpr3 = x * expr2 + expr1\n```\n\n## Efficient expression construction\nPyOptInterface provides a special class `ExprBuilder` to construct expressions efficiently. It is especially useful when we need to construct a large expression with many terms.\n\nIt supports the following in-place assignment operations:\n- `+=`: add a term to the expression\n- `-=`: subtract a term from the expression\n- `*=`: multiply the expression with a constant or another expression\n- `/=`: divide the expression with a constant\n\nFor example, we can use `ExprBuilder` to construct the following expression efficiently:\n\n$$\n\\frac{1}{2} \\sum_{i=1}^N x_i^2 - \\sum_{i=1}^N x_i\n$$\n\n```{code-cell}\nN = 1000\nx = [model.add_variable() for _ in range(N)]\n\ndef fast_expr():\n expr = poi.ExprBuilder()\n for i in range(N):\n expr += 0.5 * x[i] * x[i]\n expr -= x[i]\n\ndef slow_expr():\n expr = 0\n for i in range(N):\n expr += 0.5 * x[i] * x[i]\n expr -= x[i]\n\n```\n\n```{code-cell}\n%time fast_expr()\n```\n\n```{code-cell}\n%time slow_expr()\n```\n\n## Pretty print expression\nIf the names of variables are specified, We can use the `pprint` method to print the expression in a human-readable format:\n\n```{code-cell}\nx = model.add_variable(name=\"x\")\ny = model.add_variable(name=\"y\")\n\nexpr = x * x + 2 * x * y + y * y\n\nmodel.pprint(expr)\n```\n\n## Value of expression\nWe can use the `get_value` method to get the value of an expression after optimization:\n\n```python\nexpr = x*y + x*x\nexpr_value = model.get_value(expr)\n```\n" }, { "path": "docs/source/faq.md", "content": "# Frequently Asked Questions\n\n## How to suppress the output of the optimizer?\n\nThere are two kinds of output that you may want to suppress:\n\n1. The log of optimization process.\n2. The default license message printed when initializing the optimizer. For example, when using Gurobi, the message is `Academic license - for non-commercial use only - expires yyyy-mm-dd`.\n\nNormally we only want to suppress the log of optimization process, you can use `model.set_model_attribute(poi.ModelAttribute.Silent, True)` to disable the output. For example:\n\n```python\nimport pyoptinterface as poi\nfrom pyoptinterface import gurobi\n\nmodel = gurobi.Model()\nmodel.set_model_attribute(poi.ModelAttribute.Silent, True)\n```\n\nSuppressing the default license message is a bit tricky and solver-specific. For Gurobi, you can use the following code:\n\n```python\nimport pyoptinterface as poi\nfrom pyoptinterface import gurobi\n\nenv = gurobi.Env(empty=True)\nenv.set_raw_parameter(\"OutputFlag\", 0)\nenv.start()\n\nmodel = gurobi.Model(env)\n```\n\n## How to add linear constraints in matrix form like $Ax \\leq b$?\n\nIn YALMIP, you can use the matrix form $Ax \\leq b$ to add linear constraints, which is quite convenient.\n\nIn PyOptInterface, you can use [`model.add_m_linear_constraints`]() to add linear constraints in matrix form.\n\n## Will PyOptInterface support new optimizers in the future?\n\nIn short, no, there are no plans to support new optimizers. Supporting a new optimizer is not a trivial task, as it requires a lot of work to implement, test and maintain the interface.\n\nBasically, a new optimizer should satisfy the following criteria to be considered for support:\n\n- Actively maintained\n- Good performance (open source or commercial)\n- Not difficult to acquire an academic license\n- Have well-defined C/C++ API\n\nSupport for a new optimizer will only happen if one or more of the following conditions are met:\n\n- I am personally interested in the optimizer and plan to use it in my research, so I am willing to invest time in implementing it.\n- Someone steps up to implement and maintain the interface for the optimizer in PyOptInterface.\n- External funding or sponsorship become available to support the development and maintenance of the optimizer interface.\n\nFinally, we are always open to external contributions. If you have a specific optimizer in mind and plan to implement it, feel free to open an issue on our GitHub repository to discuss it.\n" }, { "path": "docs/source/getting_started.md", "content": "---\nfile_format: mystnb\nkernelspec:\n name: python3\n---\n\n# Getting Started\n\n## Installation\nPyOptInterface is available on PyPI. You can install it via pip:\n\n```\npip install pyoptinterface\n```\n\nAfter installation, you can import the package in Python console:\n```python\nimport pyoptinterface as poi\n```\n\nPyOptInterface has no dependencies other than Python itself. However, to use it with a specific optimizer, you need to install the corresponding optimizer manually. The details can be found on [the configurations of optimizers](https://metab0t.github.io/PyOptInterface/getting-started.html).\n\nIn order to provide out-of-the-box support for open source optimizers (currently we support [HiGHS](https://github.com/ERGO-Code/HiGHS)), PyOptInterface can also be installed with pre-built optimizers. You can install them via pip:\n\n```\npip install pyoptinterface[highs]\n```\n\nIt will install a full-featured binary version of HiGHS optimizer via [highsbox](http://github.com/metab0t/highsbox), which can be used with PyOptInterface.\n\nIn order to use nonlinear programming solvers (currently we only support IPOPT), you should install extra dependencies like:\n\n```\npip install pyoptinterface[nlp]\n```\n\nIt will install the [`llvmlite`](https://github.com/numba/llvmlite) and [`tccbox`](https://github.com/metab0t/tccbox) package as the JIT compilers required by nonlinear programming.\n\nWe will introduce how to set up the optimizers to use with PyOptInterface in this page.\n\n## Setup of optimizers\n\nPyOptInterface uses the `Dynamic Loading` technique to load the dynamic library of optimizers at runtime, so the optimizer it uses can be changed manually without recompiling the code.\n\nThe set up of optimizers includes two approaches:\n1. Automatic detection of the installation directory of the optimizers.\n2. Manually specifying the path of the dynamic library of optimizer.\n\nWe will introduce the automatic detection and manual configuration in details\n\n## Automatic detection of the installation directory of the optimizers\n\nThe automatic detection includes three steps:\n1. Environment variable set by the installer of optimizer\n2. The official Python binding of the optimizer (if available)\n3. Search directly in the system loadable path (e.g. `/usr/lib`, `/usr/local/lib` on Linux or PATH on Windows)\n\nFor the 3rd step, we want to explain more for novices.\n\nFor example, in order to make the dynamic library of HiGHS `highs.dll`/`libhighs.so`/`libhighs.dylib` loadable, we need to put it in a loadable path recognized by the operating system. The typical loadable path on Linux is `/usr/lib`, `/usr/local/lib`, and the typical loadable path on Windows is `PATH`.\n\nOn Linux, we use the `LD_LIBRARY_PATH` environment variable to specify the dynamic library path. On macOS, we use the `DYLD_LIBRARY_PATH` environment variable to specify the dynamic library path.\n\nIf the dynamic library is in path `C:\\highs\\lib`/`/opt/highs/lib`:\n- Windows: `set PATH=%PATH%;C:\\highs\\lib`\n- Linux: `export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/highs/lib`\n- macOS: `export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:/opt/highs/lib`\n\nThe typical paths where the dynamic library of optimizers are located are as follows:\n\n:::{list-table}\n:header-rows: 1\n\n* - Optimizer\n - Windows\n - Linux\n - macOS(ARM)\n - macOS(Intel)\n* - Gurobi\n - `C:\\gurobi1101\\win64\\bin`\n - `/opt/gurobi1100/linux64/lib`\n - `/opt/gurobi1100/macos_universal2/lib`\n - `/opt/gurobi1100/macos_universal2/lib`\n* - Xpress\n - `C:\\xpressmp\\bin`\n - `/opt/xpressmp/lib`\n - `/Applications/FICO Xpress/xpressmp/lib`\n - `/Applications/FICO Xpress/xpressmp/lib`\n* - COPT\n - `C:\\Program Files\\copt80\\bin`\n - `/opt/copt80/lib`\n - `/opt/copt80/lib`\n - `/opt/copt80/lib`\n* - Mosek\n - `C:\\Program Files\\Mosek\\10.2\\tools\\platform\\win64x86\\bin`\n - `/opt/mosek/10.2/tools/platform/linux64x86/bin`\n - `/opt/mosek/10.2/tools/platform/osxaarch64/bin`\n - `/opt/mosek/10.2/tools/platform/osx64x86/bin`\n* - HiGHS\n - `D:\\highs\\bin`\n - `/opt/highs/lib`\n - `/opt/highs/lib`\n - `/opt/highs/lib`\n* - KNITRO\n - `C:\\Program Files\\Artelys\\KNITRO 15.1\\lib`\n - `/opt/knitro/15.1/lib`\n - `/opt/knitro/15.1/lib`\n - ``\n:::\n\n### Gurobi\n\nThe currently supported version is **13.0.0**. Other versions may work but are not tested.\n\nFor Gurobi, the automatic detection looks for the following things in order:\n1. The environment variable `GUROBI_HOME` set by the installer of Gurobi\n2. The installation of `gurobipy`\n3. `gurobi130.dll`/`libgurobi130.so`/`libgurobi130.dylib` in the system loadable path\n\n### Xpress\n\nThe currently supported version is **9.8**. Other versions may work but are not tested.\n\nFor Xpress, the automatic detection looks for the following things in order:\n1. The environment variable `XPRESSDIR` set by the installer of Xpress\n2. `xprs.dll`/`libxprs.so`/`libxprs.dylib` int the system loadable path\n\n### COPT\n\nThe currently supported version is **8.0.x**. Other versions may work but are not tested.\n\nFor COPT, the automatic detection looks for the following things in order:\n1. The environment variable `COPT_HOME` set by the installer of COPT\n2. `copt.dll`/`libcopt.so`/`libcopt.dylib` in the system loadable path\n\n### Mosek\n\nThe currently supported version is **10.2.x**. Other versions may work but are not tested.\n\nFor Mosek, the automatic detection looks for the following things in order:\n1. The environment variable `MOSEK_10_2_BINDIR` set by the installer of Mosek\n2. The installation of `mosek` PyPI package\n3. `mosek64_10_2.dll`/`libmosek64.so`/`libmosek64.dylib` in the system loadable path\n\n### HiGHS\n\nThe currently supported version is **1.12.x**. Other versions may work but are not tested.\n\nFor HiGHS, the automatic detection looks for the following things in order:\n1. The environment variable `HiGHS_HOME` set by the user\n2. The installation of `highsbox` PyPI package (recommended)\n3. `highs.dll`/`libhighs.so`/`libhighs.dylib` in the system\n\nFor HiGHS, we recommend installing the `highsbox` PyPI package, which provides a full-featured binary version of HiGHS optimizer for you.\n\n### Ipopt\n\nThe currently supported version is **3.14.x**. Other versions may work but are not tested.\n\nFor Ipopt, the automatic detection looks for the following things in order:\n1. `ipopt.dll`/`libipopt.so`/`libipopt.dylib` in the system, we also look for `ipopt-3.dll`/`libipopt.dll`/`libipopt-3.dll` on Windows.\n\nWe recommend using the official binary from [GitHub](https://github.com/coin-or/Ipopt/releases) if you work on Windows, since compiling Ipopt on Windows from source is not an easy task.\n\n### KNITRO\n\nThe currently supported version is **15.1.x**. Other versions may work but are not tested.\n\nFor KNITRO, the automatic detection looks for the following things in order:\n1. The environment variable `KNITRODIR` set by the installer of KNITRO\n2. `knitro.dll`/`libknitro.so`/`libknitro.dylib` in the system loadable path\n3. The installation of `knitro` PyPI package.\n\nKNITRO dropped support for MacOS intel since version 15.0, so using KNITRO on MacOS intel is not supported.\n\n## Manually specifying the path of the dynamic library of optimizer\n\nIf the automatic detection fails or you want to use the optimizer in a customized location, you can manually specify the path of the dynamic library of the optimizer.\n\nWe take HiGHS as an example. Whether the optimizer has been successfully loaded can be checked via the following code:\n\n```python\nfrom pyoptinterface import highs\n\nprint(highs.is_library_loaded())\n```\n\nIf the optimizer has not been successfully loaded, you can manually specify the path of the dynamic library of the optimizer via the following code:\n\n```python\nret = highs.load_library(\"path/to/libhighs.so\")\n\nprint(f\"Loading from custom path manually: {ret}\")\n```\n\nThe `load_library` function returns `True` if the library is successfully loaded, otherwise it returns `False`.\n\nIf you want to revert to use the automatic detection, you can call the `autoload_library` function:\n\n```python\nret = highs.autoload_library()\n\nprint(f\"Loading from automatically detected location: {ret}\")\n```\n\nFor other optimizers, just replace `highs` with the corresponding optimizer name like `gurobi`, `xpress`, `copt`, `mosek`.\n\nThe typical paths where the dynamic library of optimizers are located are as follows:\n\n:::{list-table}\n:header-rows: 1\n\n* - Optimizer\n - Windows\n - Linux\n - macOS(ARM)\n - macOS(Intel)\n* - Gurobi\n - `C:\\gurobi1101\\win64\\bin\\gurobi110.dll`\n - `/opt/gurobi1100/linux64/lib/libgurobi110.so`\n - `/opt/gurobi1100/macos_universal2/lib/libgurobi110.dylib`\n - `/opt/gurobi1100/macos_universal2/lib/libgurobi110.dylib`\n* - COPT\n - `C:\\Program Files\\copt71\\bin\\copt.dll`\n - `/opt/copt72/lib/libcopt.so`\n - `/opt/copt72/lib/libcopt.dylib`\n - `/opt/copt72/lib/libcopt.dylib`\n* - Xpress\n - `C:\\xpressmp\\bin\\xprs.dll`\n - `/opt/xpressmp/lib/libxprs.so`\n - `/Applications/FICO Xpress/xpressmp/lib/libxprs.dylib`\n - `/Applications/FICO Xpress/xpressmp/lib/libxprs.dylib`\n* - Mosek\n - `C:\\Program Files\\Mosek\\10.2\\tools\\platform\\win64x86\\bin\\mosek64_10_1.dll`\n - `/opt/mosek/10.2/tools/platform/linux64x86/bin/libmosek64.so`\n - `/opt/mosek/10.2/tools/platform/osxaarch64/bin/libmosek64.dylib`\n - `/opt/mosek/10.2/tools/platform/osx64x86/bin/libmosek64.dylib`\n* - HiGHS\n - `D:\\highs\\bin\\highs.dll`\n - `/opt/highs/lib/libhighs.so`\n - `/opt/highs/lib/libhighs.dylib`\n - `/opt/highs/lib/libhighs.dylib`\n* - KNITRO\n - `C:\\Program Files\\Artelys\\KNITRO 15.1\\lib\\knitro.dll`\n - `/opt/knitro/15.1/lib/libknitro.so`\n - `/opt/knitro/15.1/lib/libknitro.dylib`\n - ``\n:::\n\n## Let's build a simple model and solve it\nAfter setting up the optimizers, we can build a simple model and solve it.\nAs the first step, we will solve the following simple Quadratic Programming (QP) problem:\n\n```{math}\n\\min \\quad & x^{2}_{1} + 2x^{2}_{2} \\\\\n\\textrm{s.t.} \\quad & x_{1} + x_{2} = 1 \\\\\n \\quad & x_{1}, x_{2} \\geq 0\n```\n\nFirst, we need to create a model object:\n\n```{code-cell}\nimport pyoptinterface as poi\nfrom pyoptinterface import highs\n# from pyoptinterface import copt, gurobi, xpress, mosek (if you want to use other optimizers)\n\nmodel = highs.Model()\n```\n\nThen, we need to add variables to the model:\n```{code-cell}\nx1 = model.add_variable(lb=0, name=\"x1\")\nx2 = model.add_variable(lb=0, name=\"x2\")\n```\nThe `lb` argument specifies the lower bound of the variable. It is optional and defaults to $-\\infty$.\n\nThe `name` argument is optional and can be used to specify the name of the variable.\n\nThen, we need to add constraints to the model:\n```{code-cell}\ncon = model.add_linear_constraint(x1+x2, poi.ConstraintSense.Equal, 1, name=\"con\")\n```\n`model.add_linear_constraint` adds a linear constraint to the model.\n- The first argument `x1+x2` is the left-hand side of the constraint.\n- The second argument is the sense of the constraint. It can be `poi.ConstraintSense.Equal`, `poi.ConstraintSense.LessEqual` or `poi.ConstraintSense.GreaterEqual` which can also be written as `poi.Eq`, `poi.Leq`, and `poi.Geq`.\n- The third argument is the right-hand side of the constraint. It must be a constant.\n- The fourth argument is optional and can be used to specify the name of the constraint.\n\nFinally, we need to set the objective function and solve the model:\n```{code-cell}\nobj = x1*x1 + 2*x2*x2\nmodel.set_objective(obj, poi.ObjectiveSense.Minimize)\n```\n\nThe model can be solved via:\n```{code-cell}\nmodel.optimize()\n```\nThe HiGHS optimizer will be invoked to solve the model and writes the log to the console.\n\nWe can query the status of the model via:\n```{code-cell}\nmodel.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n```\n\nThe solution of the model can be queried via:\n```{code-cell}\nprint(\"x1 = \", model.get_value(x1))\nprint(\"x2 = \", model.get_value(x2))\nprint(\"obj = \", model.get_value(obj))\n```\n" }, { "path": "docs/source/gurobi.md", "content": "# Gurobi\n\n## Initial setup\n\n```python\nfrom pyoptinterface import gurobi\n\nmodel = gurobi.Model()\n```\n\nYou need to follow the instructions in [Getting Started](getting_started.md#gurobi) to set up the optimizer correctly.\n\nIf you want to manage the license of Gurobi manually, you can create a `gurobi.Env` object and pass it to the constructor of the `gurobi.Model` object, otherwise we will initialize an implicit global `gurobi.Env` object automatically and use it.\n\n```python\nenv = gurobi.Env()\n\nmodel = gurobi.Model(env)\n```\n\nFor example, you can set the parameter of the `gurobi.Env` object to choose the licensing behavior.\n\n```python\nenv = gurobi.Env(empty=True)\nenv.set_raw_parameter(\"ComputeServer\", \"myserver1:32123\")\nenv.set_raw_parameter(\"ServerPassword\", \"pass\")\nenv.start()\n\nmodel = gurobi.Model(env)\n```\n\nFor users who want to release the license immediately after the optimization, you can call the `close` method of all models created and the `gurobi.Env` object. It applies to other commercial solvers supported as well.\n\n```python\nenv = gurobi.Env()\nmodel = gurobi.Model(env)\n\n# do something with the model\n\nmodel.close()\nenv.close()\n```\n\n## The capability of `gurobi.Model`\n\n### Supported constraints\n\n:::{list-table}\n:header-rows: 1\n\n* - Constraint\n - Supported\n* - \n - ✅\n* - \n - ✅\n* - \n - ✅\n* - \n - ✅\n\n:::\n\n```{include} attribute/gurobi.md\n```\n\n\n## Solver-specific operations\n\n### Parameter\n\nFor [solver-specific parameters](https://docs.gurobi.com/projects/optimizer/en/current/reference/parameters.html), we provide `get_raw_parameter` and `set_raw_parameter` methods to get and set the parameters.\n\n```python\nmodel = gurobi.Model()\n\n# get the value of the parameter\nvalue = model.get_raw_parameter(\"TimeLimit\")\n\n# set the value of the parameter\nmodel.set_raw_parameter(\"TimeLimit\", 10.0)\n```\n\n### Attribute\n\nGurobi supports a lot of [attributes](https://docs.gurobi.com/projects/optimizer/en/current/reference/attributes.html) for the model, variable, and constraint. We provide methods to get or set the value of the attribute.\n\n- Model attribute: `model.get_model_raw_attribute(name: str)` and `model.set_model_raw_attribute(name: str, value: Any)`\n- Variable attribute: `model.get_variable_raw_attribute(variable, name: str)` and `model.set_variable_raw_attribute(variable, name: str, value: Any)`\n- Constraint attribute: `model.get_constraint_raw_attribute(constraint, name: str)` and `model.set_constraint_raw_attribute(constraint, name: str, value: Any)`\n\nWe also provide `gurobi.GRB` to contain all the constants in `gurobipy.GRB`.\n\nFor model status:\n```python\nstatus = model.get_model_raw_attribute(gurobi.GRB.Attr.Status)\n\nif status == gurobi.GRB.OPTIMAL:\n ...\nelif status == gurobi.GRB.INFEASIBLE:\n ...\n```\n\nFor reduced cost of a variable:\n```python\nrc = model.get_variable_raw_attribute(variable, gurobi.GRB.Attr.RC)\n```\n\nFor right-hand side value of a constraint:\n```python\nrhs = model.get_constraint_raw_attribute(constraint, gurobi.GRB.Attr.RHS)\n```\n" }, { "path": "docs/source/highs.md", "content": "# HiGHS\n\n## Initial setup\n\n```python\nfrom pyoptinterface import highs\n\nmodel = highs.Model()\n```\n\nYou need to follow the instructions in [Getting Started](getting_started.md#highs) to set up the optimizer correctly.\n\n## The capability of `highs.Model`\n\n### Supported constraints\n\n:::{list-table}\n:header-rows: 1\n\n* - Constraint\n - Supported\n* - \n - ✅\n* - \n - ❌\n* - \n - ❌\n* - \n - ❌\n\n:::\n\n```{include} attribute/highs.md\n```\n\n\n## Solver-specific operations\n\n### Parameter\n\nFor [solver-specific parameters](https://ergo-code.github.io/HiGHS/stable/options/definitions/), we provide `get_raw_parameter` and `set_raw_parameter` methods to get and set the parameters.\n\n```python\nmodel = highs.Model()\n\n# get the value of the parameter\nvalue = model.get_raw_parameter(\"time_limit\")\n\n# set the value of the parameter\nmodel.set_raw_parameter(\"time_limit\", 10.0)\n```\n\n### Information\n\nHiGHS provides [information](https://ergo-code.github.io/HiGHS/stable/structures/classes/HighsInfo/) for the model. We provide `model.get_raw_information(name: str)` method to access the value of information.\n" }, { "path": "docs/source/index.md", "content": "```{include} ../../README.md\n```\n\n## Contents\n```{toctree}\n:maxdepth: 2\n:titlesonly:\n:caption: User Guide\n\ngetting_started.md\nbenchmark.md\nfaq.md\nmodel.md\nvariable.md\nexpression.md\nconstraint.md\nobjective.md\nnonlinear.md\ncontainer.md\nnumpy.md\nstructure.md\ncommon_model_interface.md\ninfeasibility.md\ncallback.md\ngurobi.md\nxpress.md\ncopt.md\nmosek.md\nhighs.md\nipopt.md\nknitro.md\nchangelog.md\n```\n\n```{toctree}\n:maxdepth: 2\n:titlesonly:\n:caption: Examples\n\nexamples/economic_dispatch.md\nexamples/optimal_power_flow.md\nexamples/optimal_control_rocket.md\n```\n\n```{toctree}\n:maxdepth: 2\n:titlesonly:\n:caption: Advanced\n\ndevelop.md\n```\n\n```{toctree}\n:maxdepth: 1\n:titlesonly:\n:caption: API docs\n\napi/pyoptinterface.rst\n```\n\n## Indices and tables\n\n- {ref}`genindex`\n- {ref}`modindex`\n- {ref}`search`\n" }, { "path": "docs/source/infeasibility.md", "content": "---\nfile_format: mystnb\nkernelspec:\n name: python3\n---\n\n# Infeasibility Analysis\n\nThe optimization model is not ways feasible, and the optimizer may tell us some information about the infeasibility to diagnose the problem. There are two ways to handle the infeasibilities:\n\n- Find the IIS (Irreducible Infeasible Set) to identify the minimal set of constraints that cause the infeasibility.\n- Relax the constraints and solve a weaker problem to find out which constraints are violated and how much.\n\nPyOptInterface currently supports the first method to find the IIS (only with Gurobi, Xpress, and COPT). The following code snippet shows how to find the IIS of an infeasible model:\n\n```{code-cell}\nimport pyoptinterface as poi\nfrom pyoptinterface import copt\n\nmodel = copt.Model()\n\nx = model.add_variable(lb=0.0, name=\"x\")\ny = model.add_variable(lb=0.0, name=\"y\")\n\ncon1 = model.add_linear_constraint(x + y, poi.Geq, 5.0)\ncon2 = model.add_linear_constraint(x + 2 * y, poi.Leq, 1.0)\n\nmodel.set_objective(x)\n\nmodel.computeIIS()\n\ncon1_iis = model.get_constraint_attribute(con1, poi.ConstraintAttribute.IIS)\ncon2_iis = model.get_constraint_attribute(con2, poi.ConstraintAttribute.IIS)\n\nprint(f\"Constraint 1 IIS: {con1_iis}\")\nprint(f\"Constraint 2 IIS: {con2_iis}\")\n```\n\nThis code snippet creates an infeasible model with two constraints and finds the IIS of the model. Obviously, the constraints are contradictory because `x + 2 * y <= 1` and `x + y >= 5` cannot be satisfied at the same time when `x` and `y` are non-negative. The optimizer will detect that the model is infeasible and return the IIS, which is the set of constraints that cause the infeasibility. We can query whether a constraint is in the IIS by calling `get_constraint_attribute` with the `ConstraintAttribute.IIS` attribute.\n\nSometimes, the bounds of the variables are not consistent with the constraints, and we need to query the IIS of the bounds of variables by calling `get_variable_attribute` with the `VariableAttribute.IISLowerBound` and `VariableAttribute.IISUpperBound` attributes.\n\nThe following code snippet shows how to tell if the bounds of a variable are in the IIS:\n\n```{code-cell}\nmodel = copt.Model()\n\nx = model.add_variable(lb=0.0, ub=2.0, name=\"x\")\ny = model.add_variable(lb=0.0, ub=3.0, name=\"y\")\n\ncon1 = model.add_linear_constraint(x + y, poi.Geq, 6.0)\n\nmodel.set_objective(x)\n\nmodel.computeIIS()\n\ncon1_iis = model.get_constraint_attribute(con1, poi.ConstraintAttribute.IIS)\nx_lb_iis = model.get_variable_attribute(x, poi.VariableAttribute.IISLowerBound)\nx_ub_iis = model.get_variable_attribute(x, poi.VariableAttribute.IISUpperBound)\ny_lb_iis = model.get_variable_attribute(y, poi.VariableAttribute.IISLowerBound)\ny_ub_iis = model.get_variable_attribute(y, poi.VariableAttribute.IISUpperBound)\n\nprint(f\"Constraint 1 IIS: {con1_iis}\")\nprint(f\"Variable x lower bound IIS: {x_lb_iis}\")\nprint(f\"Variable x upper bound IIS: {x_ub_iis}\")\nprint(f\"Variable y lower bound IIS: {y_lb_iis}\")\nprint(f\"Variable y upper bound IIS: {y_ub_iis}\")\n```\n" }, { "path": "docs/source/ipopt.md", "content": "# Ipopt\n\n## Initial setup\n\n```python\nfrom pyoptinterface import ipopt\n\nmodel = ipopt.Model()\n```\n\nYou need to follow the instructions in [Getting Started](getting_started.md#ipopt) to set up the optimizer correctly.\n\n:::{attention}\n\nDue to the internal API design of Ipopt, the `ipopt.Model` lacks some features compared to other solvers. Some of these restrictions may be lifted in the future.\n\n- It does not support `delete_variable` and `delete_constraint` methods.\n- It does not support incremental modification of linear constraint like `set_normalized_rhs` and `set_normalized_coefficient`.\n- It only supports to minimize the objective function. If you want to maximize the objective function, you need to multiply the objective function by -1 manually.\n:::\n\n## The capability of `ipopt.Model`\n\n### Supported constraints\n\n:::{list-table}\n:header-rows: 1\n\n* - Constraint\n - Supported\n* - \n - ✅\n* - \n - ✅\n* - \n - ❌\n* - \n - ❌\n* - \n - ✅\n\n:::\n\n```{include} attribute/ipopt.md\n```\n\n\n## Solver-specific operations\n\n### Parameter\n\nFor [solver-specific parameters](https://coin-or.github.io/Ipopt/OPTIONS.html), we provide `set_raw_parameter` methods to get and set the parameters.\n\n```python\nmodel = ipopt.Model()\n\n# set the value of the parameter\nmodel.set_raw_parameter(\"tol\", 1e-5)\nmodel.set_raw_parameter(\"max_iter\", 200)\n\n# For HSL library\nmodel.set_raw_parameter(\"hsllib\", \"/path/to/libhsl.so\")\nmodel.set_raw_parameter(\"linear_solver\", \"ma27\")\n```\n\n## JIT compiler used by Ipopt interface\n\nThe interface of Ipopt uses the JIT compiler to compile the nonlinear objective function, constraints and their derivatives. We have two implementations of JIT based on `llvmlite` and `tccbox`(Tiny C Compiler). The default JIT compiler is `llvmlite` and we advise you to use it for better performance brought by optimization capability of LLVM. If you want to use `tccbox`, you can specify `jit=\"C\"` when creating the `ipopt.Model` object.\n\n```python\nmodel = ipopt.Model()\n# equivalent to\nmodel = ipopt.Model(jit=\"LLVM\")\n\n# If you want to use tccbox\nmodel = ipopt.Model(jit=\"C\")\n```\n" }, { "path": "docs/source/knitro.md", "content": "# KNITRO\n\n## Initial setup\n\n```python\nfrom pyoptinterface import knitro\n\nmodel = knitro.Model()\n```\n\nYou need to follow the instructions in [Getting Started](getting_started.md#knitro) to set up the optimizer correctly.\n\nIf you want to manage the license of KNITRO manually, you can create a `knitro.Env` object and pass it to the constructor of the `knitro.Model` object, otherwise a check of the license will be performed when initializing the `knitro.Model` object.\n\n```python\nenv = knitro.Env()\nmodel = knitro.Model(env)\n```\n\nFor users who want to release the license immediately after the optimization, you can call the `close` method of all models created and the `knitro.Env` object.\n\n```python\nenv = knitro.Env()\nmodel = knitro.Model(env)\n# do something with the model\nmodel.close()\nenv.close()\n```\n\n## The capability of `knitro.Model`\n\n### Supported constraints\n\n:::{list-table}\n:header-rows: 1\n* - Constraint\n - Supported\n* - \n - ✅\n* - \n - ✅\n* - \n - ✅\n* - \n - ❌\n* - \n - ❌\n* - \n - ✅\n:::\n\n```{include} attribute/knitro.md\n```\n\n## Solver-specific operations\n\n### Parameters\n\nFor [solver-specific parameters](https://www.artelys.com/app/docs/knitro/2_userGuide/knitroOptions.html), we provide `get_raw_parameter` and `set_raw_parameter` methods to get and set the parameters.\n\n```python\nmodel = knitro.Model()\n\n# Set the value of a parameter by name\nmodel.set_raw_parameter(\"nlp_algorithm\", 1)\nmodel.set_raw_parameter(\"feastol\", 1e-8)\nmodel.set_raw_parameter(\"opttol\", 1e-8)\n\n# Set the value of a parameter by ID (using knitro.KN constants)\nmodel.set_raw_parameter(knitro.KN.PARAM_MAXIT, 1000)\n```\n\nWe also provide `knitro.KN` to contain common constants from the KNITRO C API.\n\n```python\n# Using constants for parameter IDs\nmodel.set_raw_parameter(knitro.KN.PARAM_FEASTOL, 1e-6)\n\n# Algorithm selection\nmodel.set_raw_parameter(knitro.KN.PARAM_NLP_ALGORITHM, knitro.KN.NLP_ALG_BAR_DIRECT)\n\n# Output level\nmodel.set_raw_parameter(knitro.KN.PARAM_OUTLEV, knitro.KN.OUTLEV_ITER)\n\n# MIP parameters\nmodel.set_raw_parameter(knitro.KN.PARAM_MIP_METHOD, knitro.KN.MIP_METHOD_BB)\nmodel.set_raw_parameter(knitro.KN.PARAM_MIP_OPTGAPREL, 1e-4)\n```\n\n### Variable and Constraint Properties\n\nCommon variable and constraint properties are provided through PyOptInterface dedicated methods:\n\n**Variable methods:**\n- **Bounds**: `set_variable_lb`, `get_variable_lb`, `set_variable_ub`, `get_variable_ub`\n- **Type and name**: `set_variable_name`, `get_variable_name`, `set_variable_domain`\n- **Starting point**: `set_variable_start`\n- **Solution values**: `get_value`, `get_variable_rc`\n\n**Constraint methods:**\n- **Name**: `set_constraint_name`, `get_constraint_name`\n- **Solution values**: `get_constraint_primal`, `get_constraint_dual`\n\n**Usage examples:**\n\nVariable properties:\n```python\n# Bounds\nmodel.set_variable_lb(variable, 0.0)\nlb = model.get_variable_lb(variable)\nmodel.set_variable_ub(variable, 10.0)\nub = model.get_variable_ub(variable)\n\n# Type and name\nmodel.set_variable_name(variable, \"x\")\nname = model.get_variable_name(variable)\n\n# Starting point\nmodel.set_variable_start(variable, 1.0)\n\n# Solution values\nvalue = model.get_value(variable)\nrc = model.get_variable_rc(variable)\n```\n\nConstraint properties:\n```python\n# Name\nmodel.set_constraint_name(constraint, \"c1\")\nname = model.get_constraint_name(constraint)\n\n# Solution values\nprimal = model.get_constraint_primal(constraint)\ndual = model.get_constraint_dual(constraint)\n```\n\n## Support for KNITRO callbacks\n\nUnfortunately, KNITRO's callback interface is not supported in PyOptInterface at the moment.\n" }, { "path": "docs/source/model.md", "content": "---\nfile_format: mystnb\nkernelspec:\n name: python3\n---\n\n# Model\n\nModel is the central class of the PyOptInterface package. It provides the interface to the solver and the user. The user can add variables, constraints and the objective function to the model. The model can be solved and the solution can be queried.\n\nIn this document we will only discuss the common interface of the model. For solver-specific interface, please refer to the documentation of the corresponding solver.\n\n## Create a model\nA model is a concrete instance tied to a specific solver. To create a model, we need to import the corresponding module and call the constructor of the model class. For example, to create a HiGHS model, we can do:\n\n```{code-cell}\nimport pyoptinterface as poi\nfrom pyoptinterface import highs\n\nmodel = highs.Model()\n```\n\nYou can replace `highs` with the name of the solver you want to use. The available solvers includes `copt`, `gurobi`, `highs` and `mosek`.\n\nMost commercial solvers require a `Environment`-like object to be initialized before creating a model in order to manage the license.\n\nBy default, PyOptInterface creates the global environment for each solver. If you want to create a model in a specific environment, you can pass the environment object to the constructor of the model class. The details can be found on the documentation of the corresponding optimizer: [Gurobi](gurobi.md), [HiGHS](highs.md), [COPT](copt.md), [Xpress](xpress.md), [MOSEK](mosek.md).\n\n```python\nenv = gurobi.Env()\nmodel = gurobi.Model(env)\n```\n\n## Inspect and customize the model\nWe can query and modify the parameters of the model to manipulate the behavior of the underlying solver.\n\nLike the design in `JuMP.jl`, we define a small subset of parameters that are common to all solvers. They are defined as [pyoptinterface.ModelAttribute](#pyoptinterface.ModelAttribute) enum class.\nThe meanings of these standard attributes are the same as [Model attributes](https://jump.dev/JuMP.jl/stable/moi/reference/models/#Model-attributes) and [Optimizer attributes](https://jump.dev/JuMP.jl/stable/moi/reference/models/#Optimizer-attributes) in MathOptInterface.jl.\n\n:::{list-table} **Standard [model attributes](#pyoptinterface.ModelAttribute)**\n:header-rows: 1\n:widths: 20 20\n\n* - Attribute name\n - Type\n* - Name\n - str\n* - ObjectiveSense\n - [ObjectiveSense](project:#pyoptinterface.ObjectiveSense)\n* - DualStatus\n - [ResultStatusCode](project:#pyoptinterface.ResultStatusCode)\n* - PrimalStatus\n - [ResultStatusCode](project:#pyoptinterface.ResultStatusCode)\n* - RawStatusString\n - str\n* - TerminationStatus\n - [TerminationStatusCode](project:#pyoptinterface.TerminationStatusCode)\n* - BarrierIterations\n - int\n* - DualObjectiveValue\n - float\n* - NodeCount\n - int\n* - NumberOfThreads\n - int\n* - ObjectiveBound\n - float\n* - ObjectiveValue\n - float\n* - RelativeGap\n - float\n* - Silent\n - float\n* - SimplexIterations\n - int\n* - SolverName\n - str\n* - SolverVersion\n - str\n* - SolveTimeSec\n - float\n* - TimeLimitSec\n - float\n:::\n\nWe can set the value of a parameter by calling the `set_model_attribute` method of the model:\n\n```{code-cell}\n# suppress the output of the solver\nmodel.set_model_attribute(poi.ModelAttribute.Silent, False)\n# set the time limit to 10 seconds\nmodel.set_model_attribute(poi.ModelAttribute.TimeLimitSec, 10.0)\n```\n\nThe value of parameter can be queried by calling the `get_model_attribute` method of the model.\n\nFor example, we build and solve a simple quadratic programming model, then query the objective value of the model:\n\n```{code-cell}\nx = model.add_variables(range(2), lb=0.0, ub=1.0)\nmodel.add_linear_constraint(x[0] + x[1], poi.Eq, 1.0)\n\nmodel.set_objective(x[0]*x[0] + x[1]*x[1], sense=poi.ObjectiveSense.Minimize)\n\nmodel.optimize()\n\nobjval = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n\nprint(f\"Objective value: {objval}\")\n```\n\nBesides the standard attributes, we can also set/get the solver-specific attributes by calling the `set_raw_parameter`/`get_raw_parameter` method of the model:\n\n```python\n# Gurobi\nmodel.set_raw_parameter(\"OutputFlag\", 0)\n# COPT\nmodel.set_raw_parameter(\"Presolve\", 0)\n# Xpress\nmodel.set_raw_control(\"XPRS_OUTPUTLOG\", 0)\n# MOSEK\nmodel.set_raw_parameter(\"MSK_IPAR_INTPNT_BASIS\", 0)\n```\n\n## Solve the model\nWe can solve the model by calling the `optimize` method of the model:\n\n```python\nmodel.optimize()\n```\n\n## Query the solution\nWe can query the termination status of the model after optimization by query the `TerminationStatus` attribute of the model:\n\n```{code-cell}\n# tell if the optimizer obtains the optimal solution\ntermination_status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\nassert termination_status == poi.TerminationStatusCode.OPTIMAL\n```\n\nFor value of variables and expressions, we can use `get_value` method of the model:\n\n```{code-cell}\nx0_value = model.get_value(x[0])\nexpr_value = model.get_value(x[0]*x[0])\n\nprint(f\"x[0] = {x0_value}\")\nprint(f\"x[0]^2 = {expr_value}\")\n```\n\n## Write the model to file\nThe optimization model can be written to file in LP, MPS or other formats. The `write` method of the model can be used to write the model to file:\n\n```{code-cell}\nmodel.write(\"model.lp\")\n```\n\nThe file format is determined by the file extension. Because we use the native IO procedure of the optimizer, their supported file formats and the content of output files may vary. Please refer to the documentation of the corresponding optimizer for more details.\n\n- COPT: [Doc](https://guide.coap.online/copt/en-doc/fileformats.html)\n- Gurobi: [Doc](https://www.gurobi.com/documentation/current/refman/c_write.html)\n- HiGHS: [Doc](https://ergo-code.github.io/HiGHS/stable/interfaces/c/#Highs_writeModel-Tuple{Any,%20Any})\n- Mosek: [Doc](https://docs.mosek.com/latest/capi/supported-file-formats.html)\n- Xpress: [`.lp`, `.mps`](https://www.fico.com/fico-xpress-optimization/docs/latest/solver/optimizer/python/HTML/problem.writeProb.html), \n [`.svf`](https://www.fico.com/fico-xpress-optimization/docs/latest/solver/optimizer/python/HTML/problem.saveAs.html),\n [`.bss`](https://www.fico.com/fico-xpress-optimization/docs/latest/solver/optimizer/python/HTML/problem.writeBasis.html),\n [`.asc`, `.hdr`](https://www.fico.com/fico-xpress-optimization/docs/latest/solver/optimizer/python/HTML/problem.writeSol.html),\n [`.sol`](https://www.fico.com/fico-xpress-optimization/docs/latest/solver/optimizer/python/HTML/problem.writeBinSol.html),\n [`.prt`](https://www.fico.com/fico-xpress-optimization/docs/latest/solver/optimizer/python/HTML/problem.writePrtSol.html),\n [`.slx`](https://www.fico.com/fico-xpress-optimization/docs/latest/solver/optimizer/python/HTML/problem.writeSlxSol.html),\n\n" }, { "path": "docs/source/mosek.md", "content": "# Mosek\n\n## Initial setup\n\n```python\nfrom pyoptinterface import mosek\n\nmodel = mosek.Model()\n```\n\nYou need to follow the instructions in [Getting Started](getting_started.md#mosek) to set up the optimizer correctly.\n\nIf you want to manage the license of Mosek manually, you can create a `mosek.Env` object and pass it to the constructor of the `mosek.Model` object, otherwise we will initialize an implicit global `mosek.Env` object automatically and use it.\n\n```python\nenv = mosek.Env()\n\nmodel = mosek.Model(env)\n```\n\n## The capability of `mosek.Model`\n\n### Supported constraints\n\n:::{list-table}\n:header-rows: 1\n\n* - Constraint\n - Supported\n* - \n - ✅\n* - \n - ✅\n* - \n - ✅\n* - \n - ✅\n* - \n - ❌\n\n:::\n\n```{include} attribute/mosek.md\n```\n\n## Solver-specific operations\n\n### Parameter\n\nFor [solver-specific parameters](https://docs.mosek.com/latest/capi/param-groups.html), we provide `get_raw_parameter` and `set_raw_parameter` methods to get and set the parameters.\n\n```python\nmodel = mosek.Model()\n\n# get the value of the parameter\nvalue = model.get_raw_parameter(\"MSK_DPAR_OPTIMIZER_MAX_TIME\")\n\n# set the value of the parameter\nmodel.set_raw_parameter(\"MSK_DPAR_OPTIMIZER_MAX_TIME\", 10.0)\n```\n\n### Information\n\nMosek provides [information](https://docs.mosek.com/latest/capi/solver-infitems.html) for the model. We provide `model.get_raw_information(name: str)` method to access the value of information.\n" }, { "path": "docs/source/nonlinear.md", "content": "---\nfile_format: mystnb\nkernelspec:\n name: python3\n---\n# Nonlinear Programming\n\n## Introduction\n\nCompared with the linear and quadratic expressions and objectives we have discussed in the previous sections, nonlinear programming is more general and can handle a wider range of problems. In this section, we will introduce how to use PyOptInterface to formulate and solve general nonlinear programming problems.\n\n:::{note}\n\nBefore trying out the code snippets, please ensure that you have completed the installation of PyOptInterface with correct dependencies via `pip install pyoptinterface[nlp]` and solvers that support nonlinear programming (IPOPT, COPT, Xpress, Gurobi, KNITRO) as described in the [Getting Started](getting_started.md) section.\n:::\n\n## Construct nonlinear expressions\n\nNonlinear expressions are more complex than linear and quadratic expressions, and they can include various nonlinear functions such as trigonometric functions, exponential functions, logarithmic functions, etc. In PyOptInterface, we must declare a `nl.graph()` context to construct nonlinear expressions. The `nl.graph()` context is used to trace the computational graph of the nonlinear expression, which allows PyOptInterface to automatically differentiate the expression and calculate the gradients and Hessians.\n\n```{code-cell}\nimport pyoptinterface as poi\nfrom pyoptinterface import nl, ipopt\n\nmodel = ipopt.Model()\n\nx = model.add_variable(name=\"x\")\ny = model.add_variable(name=\"y\")\n\nwith nl.graph():\n z = nl.exp(x) * nl.pow(y, 2)\n model.add_nl_constraint(z <= 10.0)\n```\n\nIn the code snippet above, we first import the `nl` module, which contains the nonlinear programming utilities including a set of nonlinear functions that can be used in PyOptInterface. Then, we create an `ipopt.Model` object to represent the optimization problem.\n\nWe then add two variables `x` and `y` to the model. After that, we enter the `nl.graph()` context, where we can construct nonlinear expressions using the functions provided by the `nl` module. In this case, we define a nonlinear expression `z = exp(x) * pow(y, 2)` and add a nonlinear constraint `z <= 10.0` to the model.\n\nIn the `nl.graph()` context, we can use various nonlinear functions provided by the `nl` module to construct nonlinear expressions. The functions are designed to be similar to the mathematical notation, making it easy to read and write nonlinear expressions.\n\nPyOptInterface currently supports the following nonlinear operators:\n\n:::{list-table} **Unary functions**\n:header-rows: 1\n\n* - Operator\n - Example\n* - `-` (negation)\n - `y = -x`\n* - sin\n - `y = nl.sin(x)`\n* - cos\n - `y = nl.cos(x)`\n* - tan\n - `y = nl.tan(x)`\n* - asin\n - `y = nl.asin(x)`\n* - acos\n - `y = nl.acos(x)`\n* - atan\n - `y = nl.atan(x)`\n* - abs\n - `y = nl.abs(x)`\n* - sqrt\n - `y = nl.sqrt(x)`\n* - exp\n - `y = nl.exp(x)`\n* - log\n - `y = nl.log(x)`\n* - log10\n - `y = nl.log10(x)`\n:::\n\n:::{list-table} **Binary functions**\n:header-rows: 1\n\n* - Operator\n - Example\n* - `+`\n - `z = x + y`\n* - `-`\n - `z = x - y`\n* - `*`\n - `z = x * y`\n* - `/`\n - `z = x / y`\n* - `**`\n - `z = x ** y`\n* - pow\n - `z = nl.pow(x, y)`\n:::\n\nWe can also use `nl.ifelse` to implement the conditional operator. For example, the following code snippet defines a absolute value function $f(x) = |x|$:\n\n```{code-cell}\ndef f(x):\n return nl.ifelse(x >= 0, x, -x)\n\nwith nl.graph():\n y = f(x)\n model.add_nl_constraint(y <= 2)\n```\n\n`nl.ifelse` accepts three arguments: a condition, a value when the condition is true, and a value when the condition is false. The function returns the value of the second argument if the condition is true; otherwise, it returns the value of the third argument. The condition variable must be a boolean variable, which can be obtained by comparing two variables using the comparison operators `==`, `!=`, `<`, `<=`, `>`, and `>=`.\n\nAnother interesting fact is that you can construct nonlinear expressions in the context of `nl.graph` that are prohibited outside the context. For example, you can construct $(x+2)^3$ in the following way:\n\n```{code-cell}\nwith nl.graph():\n z = (x + 2) ** 3\n\n# Illegal outside nl.graph context because it is a nonlinear expression\n# z = (x + 2) ** 3 # This will raise an error\n```\n\n## Nonlinear constraints and objectives\n\nAfter constructing nonlinear expressions, we can use them in constraints and objectives. For example, the following code snippet defines a nonlinear programming problem.\n\n```{code-cell}\nmodel = ipopt.Model()\nx = model.add_variable(lb = 0.0)\ny = model.add_variable(lb = 0.0)\n\nwith nl.graph():\n model.add_nl_constraint(x ** 4 + y ** 4 <= 4.0)\n model.add_nl_constraint(x * y >= 1.0)\n\n model.add_nl_objective(nl.exp(x) + nl.exp(y))\n\nmodel.optimize()\n```\n\n```{code-cell}\nx_value = model.get_value(x)\ny_value = model.get_value(y)\n\nprint(f\"x = {x_value}, y = {y_value}\")\n```\n\nNonlinear constraint can be declared by calling `add_nl_constraint` method. Like the linear and quadratic constraints, you can specify the sense/right-hand-side of constraint, use an interval of values to represent a two-sided constraint, or use a comparison operator like `<=`, `==`, or `>=` to create the constraint.\n\n```{code-cell}\n# One-sided nonlinear constraint\nwith nl.graph():\n model.add_nl_constraint(x ** 2 + y ** 2 <= 1.0)\n # equivalent to\n model.add_nl_constraint(x ** 2 + y ** 2, poi.Leq, 1.0)\n\n# Two-sided nonlinear constraint\nwith nl.graph():\n model.add_nl_constraint(x ** 2 + y ** 2, (1.0, 2.0))\n # equivalent to\n model.add_nl_constraint(x ** 2 + y ** 2, poi.Leq, 2.0)\n model.add_nl_constraint(x ** 2 + y ** 2, poi.Geq, 1.0)\n```\n\nSimilarly, the nonlinear objective can be declared by calling `add_nl_objective` method. It is noteworthy that `add_nl_objective` only adds a nonlinear term to the objective and can be called multiple times to construct a sum of nonlinear terms as objective.\n\n```{code-cell}\n# Nonlinear objective\nwith nl.graph():\n model.add_nl_objective(nl.sin(x) + nl.cos(y))\n```\n\nBecause the nonlinear expressions are captured by the current `nl.graph()` context, both `add_nl_constraint` and `add_nl_objective` methods must be called within the same `nl.graph()` context. If you try to call them outside the context, it will raise an error.\n\nFinally, we will use the well-known [Rosenbrock function](https://jump.dev/JuMP.jl/stable/tutorials/nonlinear/simple_examples/#The-Rosenbrock-function) as another example:\n\n```{code-cell}\nfrom pyoptinterface import nl, ipopt\n\nmodel = ipopt.Model()\n\nx = model.add_variable()\ny = model.add_variable()\n\nwith nl.graph():\n model.add_nl_objective((1 - x) ** 2 + 100 * (y - x ** 2) ** 2)\n\nmodel.optimize()\n```\n\n```{code-cell}\nx_value = model.get_value(x)\ny_value = model.get_value(y)\n\nprint(f\"x = {x_value}, y = {y_value}\")\n```\n\n## Mixing nonlinear and linear/quadratic constraints together\n\nIntroducing nonlinear functions does not prevent you from using the `add_linear_constraint`, `add_quadratic_constraint` methods. You can add both nonlinear constraints and linear/quadratic constraints in the same optimization problem.\n\nWe will use the [clnlbeam problem](https://jump.dev/JuMP.jl/stable/tutorials/nonlinear/simple_examples/#The-clnlbeam-problem) as example:\n\n```{code-cell}\nfrom pyoptinterface import nl, ipopt\nimport pyoptinterface as poi\n\nmodel = ipopt.Model()\n\nN = 1000\nh = 1 / N\nalpha = 350\n\nt = model.add_m_variables(N + 1, lb=-1.0, ub=1.0)\nx = model.add_m_variables(N + 1, lb=-0.05, ub=0.05)\nu = model.add_m_variables(N + 1)\n\nfor i in range(N):\n with nl.graph():\n model.add_nl_objective(\n 0.5 * h * (u[i] * u[i] + u[i + 1] * u[i + 1])\n + 0.5 * alpha * h * (nl.cos(t[i]) + nl.cos(t[i + 1]))\n )\n model.add_nl_constraint(\n x[i + 1] - x[i] - 0.5 * h * (nl.sin(t[i]) + nl.sin(t[i + 1])) == 0.0\n )\n model.add_linear_constraint(\n t[i + 1] - t[i] - 0.5 * h * u[i + 1] - 0.5 * h * u[i] == 0.0\n )\n\nmodel.optimize()\n```\n\n```{code-cell}\nobjective_value = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n\nprint(f\"Objective value: {objective_value}\")\n```\n\n## How to use `nl.graph` to capture the similar structure\n\nYou might be wondering how to place the `nl.graph()` context manager correctly in your code. The key is to ensure that all nonlinear constraints and objectives that share the same structure are enclosed within the same `nl.graph()` context.\n\nAs a rule of thumb, `nl.graph` should always be used inside the `for` loop instead of outside, so that each graph will have the same pattern and PyOptInterface can recognize the similar structures to accelerate the automatic differentiation process. This is particularly important when you have a large number of nonlinear constraints or objectives that share the same structure, as it can significantly improve the performance of the optimization process as discussed in our research paper [Accelerating Optimal Power Flow with Structure-aware Automatic Differentiation and Code Generation](https://ieeexplore.ieee.org/document/10721402).\n\nIn the clnlbeam example above, we have placed the `nl.graph()` context inside the `for` loop, which allows us to capture the structure of the nonlinear constraints and objectives for each iteration.\n\n## More complex examples\n\nIn practice, the nonlinear constraints may have the same structure but with different parameters, we encourage you to read our [optimal power flow](examples/optimal_power_flow.md) and [optimal control](examples/optimal_control_rocket.md) examples to learn how to construct more complex nonlinear programming problems.\n" }, { "path": "docs/source/numpy.md", "content": "---\nfile_format: mystnb\nkernelspec:\n name: python3\n---\n\n# Matrix Modeling\n\nIn the previous [container](container.md) section, we have introduced the `tupledict` container to store and manipulate multidimensional data.\n\nHowever, due to the Bring Your Own Container (BYOC) principle, variables and constraints in PyOptInterface can just simple Python objects that can be stored in Numpy `ndarray` directly as a multidimensional array, and you can enjoy the features of Numpy such like [fancy-indexing](https://numpy.org/doc/stable/user/basics.indexing.html) automatically.\n\n## N-queen problem\n\nWe will use N-queens problem as example to show how to use Numpy `ndarray` as container to store 2-dimensional variables and construct optimization model.\n\nFirstly, we import the necessary modules:\n\n```{code-cell}\nimport numpy as np\nimport pyoptinterface as poi\nfrom pyoptinterface import highs\n\nmodel = highs.Model()\n```\n\nThen we create a 2-dimensional variable `x` with shape $N \\times N$ to represent the placement of queens. Each element of `x` is a binary variable that indicates whether a queen is placed at the corresponding position. We use `object` as the data type of `x` to store the binary variables. The following code snippet creates the variables:\n\n```{code-cell}\nN = 8\n\nx = np.empty((N, N), dtype=object)\nfor i in range(N):\n for j in range(N):\n x[i, j] = model.add_variable(domain=poi.VariableDomain.Binary)\n```\n\nNext, we add the constraints to ensure that each row, each column has exact one queen, and each diagonal has at most one queen. \n\n```{code-cell}\nfor i in range(N):\n # Row and column\n model.add_linear_constraint(poi.quicksum(x[i, :]), poi.Eq, 1.0)\n model.add_linear_constraint(poi.quicksum(x[:, i]), poi.Eq, 1.0)\nfor i in range(-N+1, N):\n # Diagonal\n model.add_linear_constraint(poi.quicksum(x.diagonal(i)), poi.Leq, 1.0)\n # Anti-diagonal\n model.add_linear_constraint(poi.quicksum(np.fliplr(x).diagonal(i)), poi.Leq, 1.0)\n```\n\nFinally, we solve the model.\n\n```{code-cell}\nmodel.optimize()\n\nprint(\"Termination status:\", model.get_model_attribute(poi.ModelAttribute.TerminationStatus))\n```\n\nThe solution can be obtained and visualized by the following code:\n\n```{code-cell}\nget_v = np.vectorize(lambda x: model.get_value(x))\nx_value = get_v(x)\n\nprint(x_value.astype(int))\n```\n\n## Built-in functions to add variables and constraints as Numpy `ndarray`\n\nAlthough you can construct the `ndarray` of variables and constraints manually, PyOptInterface provides built-in functions to simplify the process. The following code snippet shows how to use the built-in functions to add variables and constraints as Numpy `ndarray`:\n\n```{code-cell}\nmodel = highs.Model()\n\nx = model.add_m_variables(N)\n\nA = np.eye(N)\nb_ub = np.ones(N)\nb_lb = np.ones(N)\n\nmodel.add_m_linear_constraints(A, x, poi.Leq, b_ub)\nmodel.add_m_linear_constraints(A, x, poi.Geq, b_lb)\n\nmodel.set_objective(poi.quicksum(x))\n\nmodel.optimize()\n```\n\nHere we use two built-in functions `add_m_variables` and `add_m_linear_constraints` to add variables and constraints as Numpy `ndarray` respectively.\n\nThe reference of these functions are listed in and .\n\n`add_m_variables` returns a `ndarray` of variables with the specified shape.\n\n`add_m_linear_constraints` adds multiple linear constraints to the model at once formulated as $Ax \\le b$ or $Ax = b$ or $Ax \\ge b$ where the matrix $A$ can be a dense `numpy.ndarray` or a sparse matrix `scipy.sparse.sparray`.\n" }, { "path": "docs/source/objective.md", "content": "# Objective\n\nThe objective is a function of the variables that the optimization algorithm seeks to minimize or maximize.\n\nCurrently PyOptInterface supports the following types of objective functions:\n- Linear objective function\n- Quadratic objective function\n\nThe objective function is typically minimized, but it can also be maximized. The objective function is defined as:\n\n```python\nobjective = x*x\nmodel.set_objective(objective, poi.ObjectiveSense.Minimize)\n```\n\nwhere `objective` is the handle of the objective function and `sense` is the optimization sense, which can be either `pyoptinterface.ObjectiveSense.Minimize` or `pyoptinterface.ObjectiveSense.Maximize`.\n\nThe `set_objective` function can be called multiple times to change the objective function of the model.\n\n## Modify objective function\n\nThe linear part of the objective function can be modified by calling the `set_objective_coefficient` method of the model:\n\n```python\nobj = 2*x + 3*y\nmodel.set_objective(obj, poi.ObjectiveSense.Minimize)\n\n# modify the coefficient of the variable x\nmodel.set_objective_coefficient(x, 5)\n```\n" }, { "path": "docs/source/roadmap.md", "content": "## Roadmap\n\nThis is the roadmap for the project. It is a living document and will be updated as the project progresses.\n\n- Write model to lp, mps files\n- User-defined callbacks in optimization (like JuMP.jl, we can support lazy constraints and user-cuts to selected solvers)\n- Compute conflict constraints of infeasible model" }, { "path": "docs/source/structure.md", "content": "---\nfile_format: mystnb\nkernelspec:\n name: python3\n---\n\n# Building Bigger Optimization Model\n\nIn this document, we will introduce how to decompose the process of building a large optimization model into smaller parts and how to compose them together. This is a common practice in optimization modeling to make the code more readable and maintainable.\n\nGenerally speaking, we need two important parts to build an optimization model:\n\n1. A [model](model.md) object that represents the optimization problem and communicates with the underlying optimizer. Due to the lightweight design philosophy of PyOptInterface, the model object is just a thin wrapper around the optimizer API, and it does not store the optimization problem itself. The model object is responsible for creating and managing variables, constraints, and the objective function, as well as solving the optimization problem.\n2. A dict-like container to store the variables and constraints. We recommend the [`types.SimpleNamespace`](https://docs.python.org/3/library/types.html#types.SimpleNamespace) object as the container to store the variables and constraints. It is a simple way to store and manipulate the optimization problem in Python. You can use attribute access to get and set the variables and constraints.\n```{code-cell}\nimport types\n\ncontainer = types.SimpleNamespace()\ncontainer.x = 1\ncontainer.y = 2\n\nprint(container.x, container.y)\n```\n\nThus, we can define a class to represent the optimization model and use the container to store the variables and constraints.\n```{code-cell}\nimport numpy as np\nimport pyoptinterface as poi\nfrom pyoptinterface import highs\n\nclass OptModel:\n def __init__(self):\n self.container = types.SimpleNamespace()\n self.model = highs.Model()\n```\n\nThen we can define small functions to declare the variables and constraints and add them to the model. We take the N-queens problem as an example.\n```{code-cell}\ndef declare_queen_variables(m:OptModel, N):\n model = m.model\n x = np.empty((N, N), dtype=object)\n for i in range(N):\n for j in range(N):\n x[i, j] = model.add_variable(domain=poi.VariableDomain.Binary)\n container = m.container\n container.x = x\n container.N = N\n\ndef add_row_column_constraints(m:OptModel):\n container = m.container\n N = container.N\n x = container.x\n model = m.model\n\n for i in range(N):\n # Row and column\n model.add_linear_constraint(poi.quicksum(x[i, :]), poi.Eq, 1.0)\n model.add_linear_constraint(poi.quicksum(x[:, i]), poi.Eq, 1.0)\n\ndef add_diagonal_constraints(m:OptModel):\n container = m.container\n N = container.N\n x = container.x\n model = m.model\n\n for i in range(-N+1, N):\n # Diagonal\n model.add_linear_constraint(poi.quicksum(x.diagonal(i)), poi.Leq, 1.0)\n # Anti-diagonal\n model.add_linear_constraint(poi.quicksum(np.fliplr(x).diagonal(i)), poi.Leq, 1.0)\n```\n\nFinally, we can compose these functions to build the optimization model and solve it.\n```{code-cell}\nm = OptModel()\n\nN = 8\ndeclare_queen_variables(m, N)\nadd_row_column_constraints(m)\nadd_diagonal_constraints(m)\n\nm.model.optimize()\n\nprint(\"Termination status:\", m.model.get_model_attribute(poi.ModelAttribute.TerminationStatus))\n```\n" }, { "path": "docs/source/variable.md", "content": "# Variable\n\nVariable represents a decision variable in the optimization problem. It can be created by calling the [`add_variable`](#model.add_variable) method of the model:\n\n```python\nimport pyoptinterface as poi\nfrom pyoptinterface import highs\n\nmodel = highs.Model()\n\nx = model.add_variable(lb=0, ub=1.0, domain=poi.VariableDomain.Continuous, name=\"x\")\n```\n\n## Variable Attributes\nAfter a variable is created, we can query or modify its attributes. The following table lists the standard [variable attributes](#pyoptinterface.VariableAttribute):\n\n:::{list-table} **Standard [variable attributes](#pyoptinterface.VariableAttribute)**\n:header-rows: 1\n:widths: 20 20\n\n* - Attribute name\n - Type\n* - Name\n - str\n* - LowerBound\n - float\n* - UpperBound\n - float\n* - Domain\n - [VariableDomain](project:#pyoptinterface.VariableDomain)\n* - PrimalStart\n - float\n* - Value\n - float\n* - IISLowerBound\n - bool\n* - IISUpperBound\n - bool\n* - ReducedCost\n - float\n:::\n\n```python\n# set the lower bound of the variable\nmodel.set_variable_attribute(x, poi.VariableAttribute.LowerBound, 0.0)\n# set the upper bound of the variable\nmodel.set_variable_attribute(x, poi.VariableAttribute.UpperBound, 1.0)\n\n# For mixed-integer programming, we can set the initial value of the variable\nmodel.set_variable_attribute(x, poi.VariableAttribute.PrimalStart, 0.5)\n\n# get the value of the variable after optimization\nx_value = model.get_variable_attribute(x, poi.VariableAttribute.Value)\n```\n\nThe most common operation is to set the bounds of the variable. We can use the [`set_variable_bounds`](#model.set_variable_bounds) method of the model to set the lower and upper bounds of the variable at the same time:\n\n```python\nx = model.add_variable(name=\"x\")\nmodel.set_variable_bounds(x, 0.0, 1.0)\n```\n\n## Delete variable\nWe can delete a variable by calling the [`delete_variable`](#model.delete_variable) method of the model:\n\n```python\nmodel.delete_variable(x)\n```\n\nAfter a variable is deleted, it cannot be used in the model anymore, otherwise an exception will be raised.\n\nWe can query whether a variable is active by calling the [`is_variable_active`](#model.is_variable_active) method of the model:\n\n```python\nis_active = model.is_variable_active(x)\n```\n" }, { "path": "docs/source/xpress.md", "content": "# Xpress\n\n## Initial setup\n\n```python\nfrom pyoptinterface import xpress\nmodel = xpress.Model()\n```\n\nYou need to follow the instructions in [Getting Started](getting_started.md#xpress) to set up the optimizer correctly.\n\nIf you want to manage the license of Xpress manually, you can create a `xpress.Env` object and pass it to the constructor of the `xpress.Model` object, otherwise we will initialize an implicit global `xpress.Env` object automatically and use it.\n\n```python\nenv = xpress.Env()\nmodel = xpress.Model(env)\n```\n\nFor users who want to release the license immediately after the optimization, you can call the `close` method of all models created and the `xpress.Env` object.\n\n```python\nenv = xpress.Env()\nmodel = xpress.Model(env)\n# do something with the model\nmodel.close()\nenv.close()\n```\n\n## The capability of `xpress.Model`\n\n### Supported constraints\n\n:::{list-table}\n:header-rows: 1\n* - Constraint\n - Supported\n* - \n - ✅\n* - \n - ✅\n* - \n - ✅\n* - \n - ✅\n* - \n - ✅\n* - \n - ✅\n:::\n\n```{include} attribute/xpress.md\n```\n\n## Solver-specific operations\n\n### Controls and Attributes\n\nXpress uses different terminology than PyOptInterface:\n- **Controls** govern the solution procedure and output format (similar to PyOptInterface parameters)\n- **Attributes** are read-only properties of the problem and solution\n\nPyOptInterface maps these as follows:\n- PyOptInterface **parameters** correspond to Xpress controls\n- PyOptInterface **attributes** may access Xpress controls, attributes, or variable/constraint properties through dedicated methods\n\n### Controls (Parameters)\n\nFor [solver-specific controls](https://www.fico.com/fico-xpress-optimization/docs/latest/solver/optimizer/HTML/chapter7.html), we provide `get_raw_control` and `set_raw_control` methods.\n\n```python\nmodel = xpress.Model()\n# Get the value of a control\nvalue = model.get_raw_control(\"XPRS_TIMELIMIT\")\n# Set the value of a control\nmodel.set_raw_control(\"XPRS_TIMELIMIT\", 10.0)\n```\n\n### Attributes\n\nFor [problem attributes](https://www.fico.com/fico-xpress-optimization/docs/latest/solver/optimizer/HTML/chapter8.html), we provide `get_raw_attribute` method.\n\n```python\n# Get number of columns in the problem\ncols = model.get_raw_attribute(\"XPRS_COLS\")\n```\n\nWe also provide `xpress.XPRS` to contain common constants from the Xpress C API.\n\n```python\n# Using constants\nvalue = model.get_raw_control_dbl_by_id(xpress.XPRS.TIMELIMIT)\n```\n\n### Variable and Constraint Properties\n\nCommon variable and constraint properties are provided through PyOptInterface dedicated methods:\n\n**Variable methods:**\n- **Bounds**: `set_variable_lowerbound`, `get_variable_lowerbound`, `set_variable_upperbound`, `get_variable_upperbound`, `set_variable_bounds`\n- **Objective**: `set_objective_coefficient`, `get_objective_coefficient`\n- **Type and name**: `set_variable_type`, `get_variable_type`, `set_variable_name`, `get_variable_name`\n- **Solution values**: `get_variable_value`, `get_variable_rc`, `get_variable_primal_ray`\n- **Basis status**: `is_variable_basic`, `is_variable_nonbasic_lb`, `is_variable_nonbasic_ub`, `is_variable_superbasic`\n- **IIS information**: `is_variable_lowerbound_IIS`, `is_variable_upperbound_IIS`\n\n**Constraint methods:**\n- **Definition**: `set_constraint_sense`, `get_constraint_sense`, `set_constraint_rhs`, `get_constraint_rhs`, `set_constraint_name`, `get_constraint_name`\n- **Coefficients**: `set_normalized_coefficient`, `get_normalized_coefficient`, `set_normalized_rhs`, `get_normalized_rhs`\n- **Solution values**: `get_constraint_dual`, `get_constraint_slack`, `get_constraint_dual_ray`\n- **Basis status**: `is_constraint_basic`, `is_constraint_nonbasic_lb`, `is_constraint_nonbasic_ub`, `is_constraint_superbasic`\n- **IIS information**: `is_constraint_in_IIS`\n\n**Usage examples:**\n\nVariable properties:\n```python\n# Bounds\nmodel.set_variable_lowerbound(variable, 0.0)\nlb = model.get_variable_lowerbound(variable)\nmodel.set_variable_upperbound(variable, 10.0)\nub = model.get_variable_upperbound(variable)\n\n# Objective coefficient\nmodel.set_objective_coefficient(variable, 2.0)\ncoef = model.get_objective_coefficient(variable)\n\n# Type and name\nmodel.set_variable_type(variable, VariableDomain.Integer)\nvtype = model.get_variable_type(variable)\nmodel.set_variable_name(variable, \"x\")\nname = model.get_variable_name(variable)\n\n# Solution values\nvalue = model.get_variable_value(variable)\nrc = model.get_variable_rc(variable)\nray = model.get_variable_primal_ray(variable)\n\n# Basis status\nif model.is_variable_basic(variable):\n ...\n```\n\nConstraint properties:\n```python\n# Sense and RHS\nmodel.set_constraint_sense(constraint, ConstraintSense.LessEqual)\nsense = model.get_constraint_sense(constraint)\nmodel.set_constraint_rhs(constraint, 5.0)\nrhs = model.get_constraint_rhs(constraint)\n\n# Name\nmodel.set_constraint_name(constraint, \"c1\")\nname = model.get_constraint_name(constraint)\n\n# Solution values\ndual = model.get_constraint_dual(constraint)\nslack = model.get_constraint_slack(constraint)\nray = model.get_constraint_dual_ray(constraint)\n\n# Basis status\nif model.is_constraint_basic(constraint):\n ...\n```\n" }, { "path": "include/pyoptinterface/cache_model.hpp", "content": "#pragma once\n\n#include \n#include \n#include \n\n// This file defines some common utilities to store the optimization model in a compact way\n\ntemplate \nstruct LinearExpressionCache\n{\n\tstd::vector column_ptr = {0};\n\tstd::vector variables;\n\tstd::vector coefficients;\n\n\ttemplate \n\tvoid add_row(std::span row_variables, std::span row_coefficients)\n\t{\n\t\tvariables.insert(variables.end(), row_variables.begin(), row_variables.end());\n\t\tcoefficients.insert(coefficients.end(), row_coefficients.begin(), row_coefficients.end());\n\t\tcolumn_ptr.push_back(variables.size());\n\t}\n};\n\ntemplate \nstruct QuadraticExpressionCache\n{\n\tstd::vector column_ptr = {0};\n\tstd::vector variable_1s;\n\tstd::vector variable_2s;\n\tstd::vector coefficients;\n\n\tstd::vector lin_column_ptr = {0};\n\tstd::vector lin_variables;\n\tstd::vector lin_coefficients;\n\n\ttemplate \n\tvoid add_row(std::span row_variable_1s, std::span row_variable_2s,\n\t std::span row_quadratic_coefficients,\n\t std::span row_lin_variables, std::span row_lin_coefficients)\n\t{\n\t\tvariable_1s.insert(variable_1s.end(), row_variable_1s.begin(), row_variable_1s.end());\n\t\tvariable_2s.insert(variable_2s.end(), row_variable_2s.begin(), row_variable_2s.end());\n\t\tcoefficients.insert(coefficients.end(), row_quadratic_coefficients.begin(),\n\t\t row_quadratic_coefficients.end());\n\t\tcolumn_ptr.push_back(variable_1s.size());\n\n\t\tlin_variables.insert(lin_variables.end(), row_lin_variables.begin(),\n\t\t row_lin_variables.end());\n\t\tlin_coefficients.insert(lin_coefficients.end(), row_lin_coefficients.begin(),\n\t\t row_lin_coefficients.end());\n\t\tlin_column_ptr.push_back(lin_variables.size());\n\t}\n};\n" }, { "path": "include/pyoptinterface/container.hpp", "content": "#pragma once\n\n#include \n#include \n#include \n#include \n\n#include \"pyoptinterface/core.hpp\"\n\n// index as the key, variable as the value\n// index is monotone increasing\n// if we want to delete\ta index, we can set the value to -1\ntemplate \nclass MonotoneVector\n{\n private:\n\tstd::vector m_data;\n\tT m_start = 0;\n\tT m_update_start = 0;\n\tstd::size_t m_last_correct_index = 0;\n\tstd::size_t m_cardinality = 0;\n\n public:\n\tMonotoneVector() = default;\n\tMonotoneVector(T start) : m_start(start), m_update_start(start)\n\t{\n\t}\n\n\tIndexT add_index()\n\t{\n\t\tIndexT index = m_data.size();\n\t\tm_data.push_back(m_start);\n\t\tm_cardinality += 1;\n\t\treturn index;\n\t}\n\tvoid delete_index(const IndexT &index)\n\t{\n\t\tif (m_data[index] < 0)\n\t\t{\n\t\t\treturn;\n\t\t}\n\t\tif (index < m_last_correct_index)\n\t\t{\n\t\t\tm_update_start = m_data[index];\n\t\t\tm_last_correct_index = index;\n\t\t}\n\t\tm_data[index] = -1;\n\t\tm_cardinality -= 1;\n\t}\n\tbool has_index(const IndexT &index)\n\t{\n\t\treturn get_index(index) >= 0;\n\t}\n\tT get_index(const IndexT &index)\n\t{\n\t\tif (index >= m_data.size())\n\t\t{\n\t\t\tthrow std::runtime_error(\"Index out of range\");\n\t\t}\n\t\tif (m_data[index] >= 0 && index > m_last_correct_index)\n\t\t{\n\t\t\tupdate_to(index);\n\t\t}\n\t\treturn m_data[index];\n\t}\n\tstd::size_t num_active_indices() const\n\t{\n\t\treturn m_cardinality;\n\t}\n\tstd::vector get_active_indices() const\n\t{\n\t\tstd::vector indices;\n\t\tindices.reserve(m_cardinality);\n\t\tfor (IndexT i = 0; i < m_data.size(); i++)\n\t\t{\n\t\t\tif (m_data[i] >= 0)\n\t\t\t{\n\t\t\t\tindices.push_back(i);\n\t\t\t}\n\t\t}\n\t\treturn indices;\n\t}\n\tvoid update_to(IndexT index)\n\t{\n\t\t// we ensure that m_data[index] >= 0\n\t\tT counter = m_update_start;\n\t\tconstexpr int STEP_STATE = 1;\n\t\tconstexpr int JUMP_STATE = 2;\n\t\tint state;\n\t\tstd::size_t jump_start_index;\n\t\tif (m_data[m_last_correct_index] < 0)\n\t\t{\n\t\t\tstate = JUMP_STATE;\n\t\t\tjump_start_index = m_last_correct_index;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tstate = STEP_STATE;\n\t\t\tcounter++;\n\t\t}\n\t\tfor (IndexT i = m_last_correct_index + 1; i <= index;)\n\t\t{\n\t\t\tswitch (state)\n\t\t\t{\n\t\t\tcase JUMP_STATE:\n\t\t\t\tif (m_data[i] >= 0)\n\t\t\t\t{\n\t\t\t\t\tm_data[jump_start_index] = -i;\n\t\t\t\t\tstate = STEP_STATE;\n\t\t\t\t\tgoto CONTINUE_STEP;\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\tCONTINUE_JUMP:\n\t\t\t\t\tT new_i = -m_data[i];\n\t\t\t\t\tif (new_i > index)\n\t\t\t\t\t{\n\t\t\t\t\t\ti = new_i;\n\t\t\t\t\t}\n\t\t\t\t\telse\n\t\t\t\t\t{\n\t\t\t\t\t\ti++;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase STEP_STATE:\n\t\t\t\tif (m_data[i] < 0)\n\t\t\t\t{\n\t\t\t\t\tstate = JUMP_STATE;\n\t\t\t\t\tjump_start_index = i;\n\t\t\t\t\tgoto CONTINUE_JUMP;\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\tCONTINUE_STEP:\n\t\t\t\t\tm_data[i] = counter;\n\t\t\t\t\tcounter++;\n\t\t\t\t\ti++;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthrow std::runtime_error(\"Unknown state\");\n\t\t\t}\n\t\t}\n\t\tm_last_correct_index = index;\n\t\tm_update_start = m_data[index];\n\t}\n\tvoid clear()\n\t{\n\t\tm_data.clear();\n\t\tm_update_start = m_start;\n\t\tm_last_correct_index = 0;\n\t\tm_cardinality = 0;\n\t}\n};\n\ntemplate \nclass ChunkedBitVector\n{\n public:\n\tChunkedBitVector(ResultT start = 0) : m_start(start)\n\t{\n\t\tclear();\n\t}\n\n\tIndexT add_index()\n\t{\n\t\tIndexT result;\n\t\tif (m_next_bit == CHUNK_WIDTH)\n\t\t{\n\t\t\tresult = m_data.size() << LOG2_CHUNK_WIDTH;\n\n\t\t\tm_data.push_back(1);\n\t\t\tm_cumulated_ranks.push_back(m_cumulated_ranks.back());\n\t\t\tm_chunk_ranks.push_back(-1);\n\t\t\tm_next_bit = 1;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tauto last_chunk_end = (m_data.size() - 1) << LOG2_CHUNK_WIDTH;\n\t\t\tresult = last_chunk_end + m_next_bit;\n\t\t\tChunkT &last_chunk = m_data.back();\n\t\t\t// set m_next_bit to 1\n\t\t\tlast_chunk |= (ChunkT{1} << m_next_bit);\n\t\t\tm_next_bit++;\n\t\t}\n\t\treturn result;\n\t}\n\n\t// Add N new indices, return the start of index\n\tIndexT add_indices(int N)\n\t{\n\t\tassert(N >= 0);\n\t\tif (N == 1)\n\t\t{\n\t\t\treturn add_index();\n\t\t}\n\n\t\tauto current_size = m_data.size();\n\t\tauto last_chunk_end = (current_size - 1) << LOG2_CHUNK_WIDTH;\n\t\tIndexT result = last_chunk_end + m_next_bit;\n\n\t\t// all bits set to 1\n\t\tChunkT newelement = ~0;\n\n\t\t// The current chunk needs to be filled as 1\n\t\tint extra_bits_in_current_chunk = CHUNK_WIDTH - m_next_bit;\n\t\textra_bits_in_current_chunk = std::min(extra_bits_in_current_chunk, N);\n\t\tif (extra_bits_in_current_chunk > 0)\n\t\t{\n\t\t\tChunkT &last_chunk = m_data.back();\n\t\t\t// set the bits in [m_next_bit, m_next_bit + extra_bits_in_current_chunk) to 1\n\t\t\tChunkT mask = (newelement << (m_next_bit)) &\n\t\t\t (newelement >> (CHUNK_WIDTH - m_next_bit - extra_bits_in_current_chunk));\n\t\t\tlast_chunk |= mask;\n\t\t}\n\n\t\tN -= extra_bits_in_current_chunk;\n\t\tif (N <= 0)\n\t\t{\n\t\t\tm_next_bit += extra_bits_in_current_chunk;\n\t\t\treturn result;\n\t\t}\n\n\t\tauto N_full_elements = N >> LOG2_CHUNK_WIDTH;\n\t\tauto N_remaining_bits = N & (CHUNK_WIDTH - 1);\n\n\t\tif (N_full_elements > 0)\n\t\t{\n\t\t\tauto new_size = current_size + N_full_elements;\n\t\t\tm_data.resize(new_size, newelement);\n\t\t\tm_cumulated_ranks.resize(new_size, m_cumulated_ranks.back());\n\t\t\tm_chunk_ranks.resize(new_size, CHUNK_WIDTH);\n\t\t}\n\t\tif (N_remaining_bits > 0)\n\t\t{\n\t\t\t// set the bits in [0, N_remaining_bits) to 1\n\t\t\tChunkT remaining_chunk = (ChunkT{1} << N_remaining_bits) - 1;\n\t\t\tm_data.push_back(remaining_chunk);\n\t\t\tm_cumulated_ranks.push_back(m_cumulated_ranks.back());\n\t\t\tm_chunk_ranks.push_back(N_remaining_bits);\n\n\t\t\tm_next_bit = N_remaining_bits;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tm_next_bit = CHUNK_WIDTH;\n\t\t}\n\t\treturn result;\n\t}\n\n\tvoid delete_index(const IndexT &index)\n\t{\n\t\tstd::size_t chunk_index;\n\t\tstd::uint8_t bit_index;\n\t\tlocate_index(index, chunk_index, bit_index);\n\t\tif (chunk_index >= m_data.size())\n\t\t{\n\t\t\treturn;\n\t\t}\n\t\tChunkT &chunk = m_data[chunk_index];\n\t\tChunkT mask = ChunkT{1} << bit_index;\n\t\tif (chunk & mask)\n\t\t{\n\t\t\t// set bit_index to 0\n\t\t\tchunk &= ~(mask);\n\t\t\t// m_last_correct_chunk ensures m_cumulated_ranks[0, m_last_correct_chunk]\n\t\t\t// and m_chunk_ranks[0, m_last_correct_chunk) are all correct\n\t\t\t// m_last_correct_chunk > chunk_index means that m_cumulated_ranks(chunk_index, +inf)\n\t\t\t// should be recalculated\n\t\t\tif (m_last_correct_chunk > chunk_index)\n\t\t\t{\n\t\t\t\tm_last_correct_chunk = chunk_index;\n\t\t\t}\n\t\t\t// rank of this chunk should also be recalculated\n\t\t\tm_chunk_ranks[chunk_index] = -1;\n\t\t}\n\t}\n\n\tbool has_index(const IndexT &index) const\n\t{\n\t\tstd::size_t chunk_index;\n\t\tstd::uint8_t bit_index;\n\t\tlocate_index(index, chunk_index, bit_index);\n\t\tconst ChunkT &chunk = m_data[chunk_index];\n\t\treturn chunk & (ChunkT{1} << bit_index);\n\t}\n\n\tResultT get_index(const IndexT &index)\n\t{\n\t\tif (index >= m_data.size() * CHUNK_WIDTH)\n\t\t{\n\t\t\treturn -1;\n\t\t}\n\t\tstd::size_t chunk_index;\n\t\tstd::uint8_t bit_index;\n\t\tlocate_index(index, chunk_index, bit_index);\n\t\tChunkT &chunk = m_data[chunk_index];\n\t\tbool bit = chunk & (ChunkT{1} << bit_index);\n\n\t\tif (!bit)\n\t\t{\n\t\t\treturn -1;\n\t\t}\n\t\tif (chunk_index > m_last_correct_chunk)\n\t\t{\n\t\t\tupdate_to(chunk_index);\n\t\t}\n\t\t// count the 1 on the right of bit_index\n\t\tChunkT mask = (ChunkT{1} << bit_index) - 1;\n\t\tstd::uint8_t current_chunk_index = std::popcount(chunk & mask);\n\t\treturn m_cumulated_ranks[chunk_index] + current_chunk_index;\n\t}\n\n\tvoid update_to(std::size_t chunk_index)\n\t{\n\t\t// m_cumulated_ranks[0, m_last_correct_chunk] and m_chunk_ranks[0, m_last_correct_chunk) are\n\t\t// all correct\n\t\t// we need to update m_cumulated_ranks[m_last_correct_chunk + 1, chunk_index]\n\t\t// and m_chunk_ranks[m_last_correct_chunk, chunk_index)\n\t\tfor (int ichunk = m_last_correct_chunk; ichunk < chunk_index; ichunk++)\n\t\t{\n\t\t\tif (m_chunk_ranks[ichunk] < 0)\n\t\t\t{\n\t\t\t\tm_chunk_ranks[ichunk] = std::popcount(m_data[ichunk]);\n\t\t\t}\n\t\t\tm_cumulated_ranks[ichunk + 1] = m_cumulated_ranks[ichunk] + m_chunk_ranks[ichunk];\n\t\t}\n\t\tm_last_correct_chunk = chunk_index;\n\t}\n\n\tvoid locate_index(IndexT index, std::size_t &chunk_index, std::uint8_t &bit_index) const\n\t{\n\t\tchunk_index = index >> LOG2_CHUNK_WIDTH;\n\t\tbit_index = index & (CHUNK_WIDTH - 1);\n\t}\n\n\tvoid clear()\n\t{\n\t\tm_data.resize(1, 0);\n\t\tm_cumulated_ranks.resize(1, m_start);\n\t\tm_chunk_ranks.resize(1, -1);\n\t\tm_last_correct_chunk = 0;\n\t\tm_next_bit = 0;\n\t}\n\n private:\n\tenum : std::uint8_t\n\t{\n\t\tCHUNK_WIDTH = sizeof(ChunkT) * 8,\n\t\tLOG2_CHUNK_WIDTH = std::countr_zero(CHUNK_WIDTH)\n\t};\n\n\tResultT m_start;\n\n\tstd::vector m_data;\n\tstd::vector m_cumulated_ranks;\n\tstd::vector m_chunk_ranks; // -1 represents tainted\n\tstd::size_t m_last_correct_chunk;\n\tstd::uint8_t m_next_bit;\n};\n\ntemplate \nclass SimpleMonotoneVector\n{\n private:\n\tstd::vector m_data;\n\tT m_start = 0;\n\n public:\n\tSimpleMonotoneVector() = default;\n\tSimpleMonotoneVector(T start) : m_start(start)\n\t{\n\t}\n\n\tIndexT add_index()\n\t{\n\t\tIndexT index = m_data.size();\n\t\tm_data.push_back(index);\n\t\treturn index;\n\t}\n\tvoid delete_index(const IndexT &index)\n\t{\n\t\tif (m_data[index] < 0)\n\t\t{\n\t\t\treturn;\n\t\t}\n\t\tm_data[index] = -1;\n\t\tfor (IndexT i = index + 1; i < m_data.size(); i++)\n\t\t{\n\t\t\tm_data[i] -= 1;\n\t\t}\n\t}\n\tbool has_index(const IndexT &index)\n\t{\n\t\treturn get_index(index) >= 0;\n\t}\n\tT get_index(const IndexT &index)\n\t{\n\t\tif (index >= m_data.size())\n\t\t{\n\t\t\tthrow std::runtime_error(\"Index out of range\");\n\t\t}\n\t\treturn m_data[index];\n\t}\n\tvoid clear()\n\t{\n\t\tm_data.clear();\n\t}\n};\n\ntemplate \nusing MonotoneIndexer = ChunkedBitVector;\n// using MonotoneIndexer = SimpleMonotoneVector;\n" }, { "path": "include/pyoptinterface/copt_model.hpp", "content": "#pragma once\n\n#include \n\n#include \"solvers/copt/copt.h\"\n\n#include \"pyoptinterface/core.hpp\"\n#include \"pyoptinterface/container.hpp\"\n#include \"pyoptinterface/nlexpr.hpp\"\n#define USE_NLMIXIN\n#include \"pyoptinterface/solver_common.hpp\"\n#include \"pyoptinterface/dylib.hpp\"\n\nextern \"C\"\n{\n\tint COPT_SearchParamAttr(copt_prob *prob, const char *name, int *p_type);\n}\n\n#define APILIST \\\n\tB(COPT_GetRetcodeMsg); \\\n\tB(COPT_CreateProb); \\\n\tB(COPT_DeleteProb); \\\n\tB(COPT_WriteMps); \\\n\tB(COPT_WriteLp); \\\n\tB(COPT_WriteCbf); \\\n\tB(COPT_WriteBin); \\\n\tB(COPT_WriteBasis); \\\n\tB(COPT_WriteSol); \\\n\tB(COPT_WriteMst); \\\n\tB(COPT_WriteParam); \\\n\tB(COPT_AddCol); \\\n\tB(COPT_DelCols); \\\n\tB(COPT_AddRow); \\\n\tB(COPT_AddQConstr); \\\n\tB(COPT_AddSOSs); \\\n\tB(COPT_AddCones); \\\n\tB(COPT_AddExpCones); \\\n\tB(COPT_AddNLConstr); \\\n\tB(COPT_DelRows); \\\n\tB(COPT_DelQConstrs); \\\n\tB(COPT_DelSOSs); \\\n\tB(COPT_DelCones); \\\n\tB(COPT_DelExpCones); \\\n\tB(COPT_DelQuadObj); \\\n\tB(COPT_ReplaceColObj); \\\n\tB(COPT_SetObjConst); \\\n\tB(COPT_SetObjSense); \\\n\tB(COPT_SetQuadObj); \\\n\tB(COPT_SetNLObj); \\\n\tB(COPT_Solve); \\\n\tB(COPT_SearchParamAttr); \\\n\tB(COPT_SetIntParam); \\\n\tB(COPT_SetDblParam); \\\n\tB(COPT_GetIntParam); \\\n\tB(COPT_GetDblParam); \\\n\tB(COPT_GetIntAttr); \\\n\tB(COPT_GetDblAttr); \\\n\tB(COPT_GetColInfo); \\\n\tB(COPT_GetColName); \\\n\tB(COPT_SetColNames); \\\n\tB(COPT_GetColType); \\\n\tB(COPT_SetColType); \\\n\tB(COPT_SetColLower); \\\n\tB(COPT_SetColUpper); \\\n\tB(COPT_GetRowInfo); \\\n\tB(COPT_GetQConstrInfo); \\\n\tB(COPT_GetNLConstrInfo); \\\n\tB(COPT_GetRowName); \\\n\tB(COPT_GetQConstrName); \\\n\tB(COPT_GetNLConstrName); \\\n\tB(COPT_SetRowNames); \\\n\tB(COPT_SetQConstrNames); \\\n\tB(COPT_SetNLConstrNames); \\\n\tB(COPT_AddMipStart); \\\n\tB(COPT_SetNLPrimalStart); \\\n\tB(COPT_GetQConstrRhs); \\\n\tB(COPT_SetRowLower); \\\n\tB(COPT_SetRowUpper); \\\n\tB(COPT_SetQConstrRhs); \\\n\tB(COPT_GetElem); \\\n\tB(COPT_SetElem); \\\n\tB(COPT_SetColObj); \\\n\tB(COPT_GetBanner); \\\n\tB(COPT_SetCallback); \\\n\tB(COPT_GetCallbackInfo); \\\n\tB(COPT_AddCallbackSolution); \\\n\tB(COPT_AddCallbackLazyConstr); \\\n\tB(COPT_AddCallbackUserCut); \\\n\tB(COPT_Interrupt); \\\n\tB(COPT_CreateEnv); \\\n\tB(COPT_CreateEnvWithConfig); \\\n\tB(COPT_DeleteEnv); \\\n\tB(COPT_CreateEnvConfig); \\\n\tB(COPT_DeleteEnvConfig); \\\n\tB(COPT_SetEnvConfig); \\\n\tB(COPT_ComputeIIS); \\\n\tB(COPT_GetColLowerIIS); \\\n\tB(COPT_GetColUpperIIS); \\\n\tB(COPT_GetRowLowerIIS); \\\n\tB(COPT_GetRowUpperIIS); \\\n\tB(COPT_GetSOSIIS); \\\n\tB(COPT_SetLogCallback);\n\nnamespace copt\n{\n#define B DYLIB_EXTERN_DECLARE\nAPILIST\n#undef B\n\nbool is_library_loaded();\n\nbool load_library(const std::string &path);\n} // namespace copt\n\nclass COPTEnvConfig\n{\n public:\n\tCOPTEnvConfig();\n\t~COPTEnvConfig();\n\n\tvoid set(const char *param_name, const char *value);\n\n private:\n\tcopt_env_config *m_config;\n\n\tfriend class COPTEnv;\n};\n\nclass COPTEnv\n{\n public:\n\tCOPTEnv();\n\tCOPTEnv(COPTEnvConfig &config);\n\t~COPTEnv();\n\n\tvoid close();\n\n private:\n\tcopt_env *m_env;\n\n\tfriend class COPTModel;\n};\n\nstruct COPTfreemodelT\n{\n\tvoid operator()(copt_prob *model) const\n\t{\n\t\tcopt::COPT_DeleteProb(&model);\n\t};\n};\n\nclass COPTModel;\nusing COPTCallback = std::function;\n\nstruct COPTCallbackUserdata\n{\n\tvoid *model = nullptr;\n\tCOPTCallback callback;\n\tint n_variables = 0;\n\tint where = 0;\n\t// store result of cbget\n\tbool cb_get_mipsol_called = false;\n\tstd::vector mipsol;\n\tbool cb_get_mipnoderel_called = false;\n\tstd::vector mipnoderel;\n\tbool cb_get_mipincumbent_called = false;\n\tstd::vector mipincumbent;\n\t// Cache for cbsolution\n\tbool cb_set_solution_called = false;\n\tstd::vector heuristic_solution;\n\tbool cb_requires_submit_solution = false;\n};\n\nusing COPTLoggingCallback = std::function;\n\nstruct COPTLoggingCallbackUserdata\n{\n\tCOPTLoggingCallback callback;\n};\n\nclass COPTModel : public OnesideLinearConstraintMixin,\n public TwosideLinearConstraintMixin,\n public OnesideQuadraticConstraintMixin,\n public TwosideNLConstraintMixin,\n public LinearObjectiveMixin,\n public PPrintMixin,\n public GetValueMixin\n{\n public:\n\tCOPTModel() = default;\n\tCOPTModel(const COPTEnv &env);\n\tvoid init(const COPTEnv &env);\n\tvoid close();\n\n\tdouble get_infinity() const;\n\n\tvoid write(const std::string &filename);\n\n\tVariableIndex add_variable(VariableDomain domain = VariableDomain::Continuous,\n\t double lb = -COPT_INFINITY, double ub = COPT_INFINITY,\n\t const char *name = nullptr);\n\tvoid delete_variable(const VariableIndex &variable);\n\tvoid delete_variables(const Vector &variables);\n\tbool is_variable_active(const VariableIndex &variable);\n\tdouble get_variable_value(const VariableIndex &variable);\n\tstd::string pprint_variable(const VariableIndex &variable);\n\tvoid set_variable_bounds(const VariableIndex &variable, double lb, double ub);\n\n\tConstraintIndex add_linear_constraint(const ScalarAffineFunction &function,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr);\n\tConstraintIndex add_linear_constraint(const ScalarAffineFunction &function,\n\t const std::tuple &interval,\n\t const char *name = nullptr);\n\tConstraintIndex add_quadratic_constraint(const ScalarQuadraticFunction &function,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr);\n\tConstraintIndex add_sos_constraint(const Vector &variables, SOSType sos_type);\n\tConstraintIndex add_sos_constraint(const Vector &variables, SOSType sos_type,\n\t const Vector &weights);\n\n\t// x[0]^2 >= x[1]^2 + x[2]^2 + ... + x[n-1]^2\n\tConstraintIndex add_second_order_cone_constraint(const Vector &variables,\n\t const char *name, bool rotated = false);\n\n\tConstraintIndex add_exp_cone_constraint(const Vector &variables,\n\t const char *name, bool dual = false);\n\n\t// Nonlinear constraint\n\tvoid decode_expr(const ExpressionGraph &graph, const ExpressionHandle &expr,\n\t std::vector &opcodes, std::vector &constants);\n\tvoid decode_graph_prefix_order(ExpressionGraph &graph, const ExpressionHandle &result,\n\t std::vector &opcodes, std::vector &constants);\n\tConstraintIndex add_single_nl_constraint(ExpressionGraph &graph, const ExpressionHandle &result,\n\t const std::tuple &interval,\n\t const char *name = nullptr);\n\n\tvoid delete_constraint(const ConstraintIndex &constraint);\n\tbool is_constraint_active(const ConstraintIndex &constraint);\n\n\tvoid _set_affine_objective(const ScalarAffineFunction &function, ObjectiveSense sense,\n\t bool clear_quadratic);\n\tvoid set_objective(const ScalarAffineFunction &function, ObjectiveSense sense);\n\tvoid set_objective(const ScalarQuadraticFunction &function, ObjectiveSense sense);\n\tvoid set_objective(const ExprBuilder &function, ObjectiveSense sense);\n\n\tvoid add_single_nl_objective(ExpressionGraph &graph, const ExpressionHandle &result);\n\tvoid set_nl_objective();\n\n\tvoid optimize();\n\tvoid *get_raw_model();\n\tstd::string version_string();\n\n\t/*\n\t * Returns the type of a COPT parameter or attribute, given its name.\n\t * -1: unknown\n\t * 0: double parameter\n\t * 1: int parameter\n\t * 2: double attribute\n\t * 3: int attribute\n\t *\n\t * Use undocumented COPT function\n\t * int COPT_SearchParamAttr(copt_prob* prob, const char* name, int* p_type)\n\t */\n\tint raw_parameter_attribute_type(const char *name);\n\n\t// parameter\n\tvoid set_raw_parameter_int(const char *param_name, int value);\n\tvoid set_raw_parameter_double(const char *param_name, double value);\n\tint get_raw_parameter_int(const char *param_name);\n\tdouble get_raw_parameter_double(const char *param_name);\n\n\t// attribute\n\tint get_raw_attribute_int(const char *attr_name);\n\tdouble get_raw_attribute_double(const char *attr_name);\n\n\t// Accessing information of problem\n\tdouble get_variable_info(const VariableIndex &variable, const char *info_name);\n\tstd::string get_variable_name(const VariableIndex &variable);\n\tvoid set_variable_name(const VariableIndex &variable, const char *name);\n\tVariableDomain get_variable_type(const VariableIndex &variable);\n\tvoid set_variable_type(const VariableIndex &variable, VariableDomain domain);\n\tvoid set_variable_lower_bound(const VariableIndex &variable, double lb);\n\tvoid set_variable_upper_bound(const VariableIndex &variable, double ub);\n\n\tdouble get_constraint_info(const ConstraintIndex &constraint, const char *info_name);\n\tstd::string get_constraint_name(const ConstraintIndex &constraint);\n\tvoid set_constraint_name(const ConstraintIndex &constraint, const char *name);\n\n\tvoid set_obj_sense(ObjectiveSense sense);\n\n\t// MIPStart\n\tvoid add_mip_start(const Vector &variables, const Vector &values);\n\t// NLP start\n\tvoid add_nl_start(const Vector &variables, const Vector &values);\n\n\t// Modifications of model\n\t// 1. set/get RHS of a constraint\n\tdouble get_normalized_rhs(const ConstraintIndex &constraint);\n\tvoid set_normalized_rhs(const ConstraintIndex &constraint, double value);\n\t// 2. set/get coefficient of variable in constraint\n\tdouble get_normalized_coefficient(const ConstraintIndex &constraint,\n\t const VariableIndex &variable);\n\tvoid set_normalized_coefficient(const ConstraintIndex &constraint,\n\t const VariableIndex &variable, double value);\n\t// 3. set/get linear coefficient of variable in objective\n\tdouble get_objective_coefficient(const VariableIndex &variable);\n\tvoid set_objective_coefficient(const VariableIndex &variable, double value);\n\n\tint _variable_index(const VariableIndex &variable);\n\tint _checked_variable_index(const VariableIndex &variable);\n\tint _constraint_index(const ConstraintIndex &constraint);\n\tint _checked_constraint_index(const ConstraintIndex &constraint);\n\n\t// Control logging\n\tvoid set_logging(const COPTLoggingCallback &callback);\n\n\tCOPTLoggingCallbackUserdata m_logging_callback_userdata;\n\n\t// Callback\n\tvoid set_callback(const COPTCallback &callback, int cbctx);\n\n\t// For callback\n\tbool has_callback = false;\n\tvoid *m_cbdata = nullptr;\n\tCOPTCallbackUserdata m_callback_userdata;\n\n\tint cb_get_info_int(const std::string &what);\n\tdouble cb_get_info_double(const std::string &what);\n\tvoid cb_get_info_doublearray(const std::string &what);\n\n\tdouble cb_get_solution(const VariableIndex &variable);\n\tdouble cb_get_relaxation(const VariableIndex &variable);\n\tdouble cb_get_incumbent(const VariableIndex &variable);\n\tvoid cb_set_solution(const VariableIndex &variable, double value);\n\tdouble cb_submit_solution();\n\n\tvoid cb_exit();\n\n\tvoid cb_add_lazy_constraint(const ScalarAffineFunction &function, ConstraintSense sense,\n\t CoeffT rhs);\n\tvoid cb_add_lazy_constraint(const ExprBuilder &function, ConstraintSense sense, CoeffT rhs);\n\tvoid cb_add_user_cut(const ScalarAffineFunction &function, ConstraintSense sense, CoeffT rhs);\n\tvoid cb_add_user_cut(const ExprBuilder &function, ConstraintSense sense, CoeffT rhs);\n\n\t// IIS related\n\tvoid computeIIS();\n\tint _get_variable_upperbound_IIS(const VariableIndex &variable);\n\tint _get_variable_lowerbound_IIS(const VariableIndex &variable);\n\tint _get_constraint_IIS(const ConstraintIndex &constraint);\n\n private:\n\tMonotoneIndexer m_variable_index;\n\n\tMonotoneIndexer m_linear_constraint_index;\n\n\tMonotoneIndexer m_quadratic_constraint_index;\n\n\tMonotoneIndexer m_sos_constraint_index;\n\n\tMonotoneIndexer m_cone_constraint_index;\n\n\tMonotoneIndexer m_exp_cone_constraint_index;\n\n\tMonotoneIndexer m_nl_constraint_index;\n\n\t// Store the nonlinear objectives\n\tint m_nl_objective_num = 0;\n\tstd::vector m_nl_objective_opcodes = {COPT_NL_SUM, 0};\n\tstd::vector m_nl_objective_constants;\n\n\t/* COPT part */\n\tstd::unique_ptr m_model;\n};\n" }, { "path": "include/pyoptinterface/core.hpp", "content": "#pragma once\n\n#include \n#include \n#include \n#include \"ankerl/unordered_dense.h\"\n\nusing IndexT = std::int32_t;\nusing CoeffT = double;\n\nconstexpr CoeffT COEFTHRESHOLD = 1e-12;\n\ntemplate \nusing Hashmap = ankerl::unordered_dense::map;\n\ntemplate \nusing Hashset = ankerl::unordered_dense::set;\n\ntemplate \nusing Vector = std::vector;\n\nstruct VariableIndex;\nstruct ScalarAffineFunction;\nstruct ScalarQuadraticFunction;\nstruct ExprBuilder;\n\nenum class VariableDomain\n{\n\tContinuous,\n\tInteger,\n\tBinary,\n\tSemiContinuous,\n};\n\nstruct VariableIndex\n{\n\tIndexT index;\n\n\tVariableIndex() = default;\n\tVariableIndex(IndexT v);\n};\n\nstruct ScalarAffineFunction\n{\n\tVector coefficients;\n\tVector variables;\n\tstd::optional constant;\n\n\tScalarAffineFunction() = default;\n\tScalarAffineFunction(CoeffT v);\n\tScalarAffineFunction(const VariableIndex &v);\n\t// v * c\n\tScalarAffineFunction(const VariableIndex &v, CoeffT c);\n\t// v * c1 + c2\n\tScalarAffineFunction(const VariableIndex &v, CoeffT c1, CoeffT c2);\n\tScalarAffineFunction(const Vector &, const Vector &);\n\tScalarAffineFunction(const Vector &, const Vector &,\n\t const std::optional &);\n\n\tScalarAffineFunction(const ExprBuilder &t);\n\n\tsize_t size() const;\n\tvoid canonicalize(CoeffT threshold = COEFTHRESHOLD);\n\n\tvoid reserve(size_t n);\n\tvoid add_term(const VariableIndex &v, CoeffT c);\n\tvoid add_constant(CoeffT c);\n};\n\nstruct ScalarQuadraticFunction\n{\n\tVector coefficients;\n\tVector variable_1s;\n\tVector variable_2s;\n\tstd::optional affine_part;\n\n\tScalarQuadraticFunction() = default;\n\tScalarQuadraticFunction(const Vector &, const Vector &, const Vector &);\n\tScalarQuadraticFunction(const Vector &, const Vector &, const Vector &,\n\t const std::optional &);\n\tScalarQuadraticFunction(const ExprBuilder &t);\n\n\tsize_t size() const;\n\tvoid canonicalize(CoeffT threshold = COEFTHRESHOLD);\n\n\tvoid reserve_quadratic(size_t n);\n\tvoid reserve_affine(size_t n);\n\tvoid add_quadratic_term(const VariableIndex &v1, const VariableIndex &v2, CoeffT c);\n\tvoid add_affine_term(const VariableIndex &v, CoeffT c);\n\tvoid add_constant(CoeffT c);\n};\n\nstruct VariablePair\n{\n\tIndexT var_1;\n\tIndexT var_2;\n\n\tbool operator==(const VariablePair &x) const;\n\tbool operator<(const VariablePair &x) const;\n\n\tVariablePair() = default;\n\tVariablePair(IndexT v1, IndexT v2) : var_1(v1), var_2(v2)\n\t{\n\t}\n};\n\ntemplate <>\nstruct ankerl::unordered_dense::hash\n{\n\tusing is_avalanching = void;\n\n\t[[nodiscard]] auto operator()(VariablePair const &x) const noexcept -> uint64_t\n\t{\n\t\tstatic_assert(std::has_unique_object_representations_v);\n\t\treturn detail::wyhash::hash(&x, sizeof(x));\n\t}\n};\n\nstruct ExprBuilder\n{\n\tHashmap quadratic_terms;\n\tHashmap affine_terms;\n\tstd::optional constant_term;\n\n\tExprBuilder() = default;\n\tExprBuilder(CoeffT c);\n\tExprBuilder(const VariableIndex &v);\n\tExprBuilder(const ScalarAffineFunction &a);\n\tExprBuilder(const ScalarQuadraticFunction &q);\n\n\tExprBuilder &operator+=(CoeffT c);\n\tExprBuilder &operator+=(const VariableIndex &v);\n\tExprBuilder &operator+=(const ScalarAffineFunction &a);\n\tExprBuilder &operator+=(const ScalarQuadraticFunction &q);\n\tExprBuilder &operator+=(const ExprBuilder &t);\n\n\tExprBuilder &operator-=(CoeffT c);\n\tExprBuilder &operator-=(const VariableIndex &v);\n\tExprBuilder &operator-=(const ScalarAffineFunction &a);\n\tExprBuilder &operator-=(const ScalarQuadraticFunction &q);\n\tExprBuilder &operator-=(const ExprBuilder &t);\n\n\tExprBuilder &operator*=(CoeffT c);\n\tExprBuilder &operator*=(const VariableIndex &v);\n\tExprBuilder &operator*=(const ScalarAffineFunction &a);\n\tExprBuilder &operator*=(const ScalarQuadraticFunction &q);\n\tExprBuilder &operator*=(const ExprBuilder &t);\n\n\tExprBuilder &operator/=(CoeffT c);\n\n\tbool empty() const;\n\tint degree() const;\n\n\tvoid reserve_quadratic(size_t n);\n\tvoid reserve_affine(size_t n);\n\n\tvoid clear();\n\tvoid clean_nearzero_terms(CoeffT threshold = COEFTHRESHOLD);\n\tvoid _add_quadratic_term(IndexT i, IndexT j, CoeffT coeff);\n\tvoid _set_quadratic_coef(IndexT i, IndexT j, CoeffT coeff);\n\tvoid add_quadratic_term(const VariableIndex &i, const VariableIndex &j, CoeffT coeff);\n\tvoid set_quadratic_coef(const VariableIndex &i, const VariableIndex &j, CoeffT coeff);\n\tvoid _add_affine_term(IndexT i, CoeffT coeff);\n\tvoid _set_affine_coef(IndexT i, CoeffT coeff);\n\tvoid add_affine_term(const VariableIndex &i, CoeffT coeff);\n\tvoid set_affine_coef(const VariableIndex &i, CoeffT coeff);\n};\n\nauto operator+(const VariableIndex &a, CoeffT b) -> ScalarAffineFunction;\nauto operator+(CoeffT a, const VariableIndex &b) -> ScalarAffineFunction;\nauto operator+(const VariableIndex &a, const VariableIndex &b) -> ScalarAffineFunction;\nauto operator+(const ScalarAffineFunction &a, CoeffT b) -> ScalarAffineFunction;\nauto operator+(CoeffT a, const ScalarAffineFunction &b) -> ScalarAffineFunction;\nauto operator+(const ScalarAffineFunction &a, const VariableIndex &b) -> ScalarAffineFunction;\nauto operator+(const VariableIndex &a, const ScalarAffineFunction &b) -> ScalarAffineFunction;\nauto operator+(const ScalarAffineFunction &a, const ScalarAffineFunction &b)\n -> ScalarAffineFunction;\nauto operator+(const ScalarQuadraticFunction &a, CoeffT b) -> ScalarQuadraticFunction;\nauto operator+(CoeffT a, const ScalarQuadraticFunction &b) -> ScalarQuadraticFunction;\nauto operator+(const ScalarQuadraticFunction &a, const VariableIndex &b) -> ScalarQuadraticFunction;\nauto operator+(const VariableIndex &a, const ScalarQuadraticFunction &b) -> ScalarQuadraticFunction;\nauto operator+(const ScalarQuadraticFunction &a, const ScalarAffineFunction &b)\n -> ScalarQuadraticFunction;\nauto operator+(const ScalarAffineFunction &a, const ScalarQuadraticFunction &b)\n -> ScalarQuadraticFunction;\nauto operator+(const ScalarQuadraticFunction &a, const ScalarQuadraticFunction &b)\n -> ScalarQuadraticFunction;\n\nauto operator-(const VariableIndex &a, CoeffT b) -> ScalarAffineFunction;\nauto operator-(CoeffT a, const VariableIndex &b) -> ScalarAffineFunction;\nauto operator-(const VariableIndex &a, const VariableIndex &b) -> ScalarAffineFunction;\nauto operator-(const ScalarAffineFunction &a, CoeffT b) -> ScalarAffineFunction;\nauto operator-(CoeffT a, const ScalarAffineFunction &b) -> ScalarAffineFunction;\nauto operator-(const ScalarAffineFunction &a, const VariableIndex &b) -> ScalarAffineFunction;\nauto operator-(const VariableIndex &a, const ScalarAffineFunction &b) -> ScalarAffineFunction;\nauto operator-(const ScalarAffineFunction &a, const ScalarAffineFunction &b)\n -> ScalarAffineFunction;\nauto operator-(const ScalarQuadraticFunction &a, CoeffT b) -> ScalarQuadraticFunction;\nauto operator-(CoeffT a, const ScalarQuadraticFunction &b) -> ScalarQuadraticFunction;\nauto operator-(const ScalarQuadraticFunction &a, const VariableIndex &b) -> ScalarQuadraticFunction;\nauto operator-(const VariableIndex &a, const ScalarQuadraticFunction &b) -> ScalarQuadraticFunction;\nauto operator-(const ScalarQuadraticFunction &a, const ScalarAffineFunction &b)\n -> ScalarQuadraticFunction;\nauto operator-(const ScalarAffineFunction &a, const ScalarQuadraticFunction &b)\n -> ScalarQuadraticFunction;\nauto operator-(const ScalarQuadraticFunction &a, const ScalarQuadraticFunction &b)\n -> ScalarQuadraticFunction;\n\nauto operator*(const VariableIndex &a, CoeffT b) -> ScalarAffineFunction;\nauto operator*(CoeffT a, const VariableIndex &b) -> ScalarAffineFunction;\nauto operator*(const VariableIndex &a, const VariableIndex &b) -> ScalarQuadraticFunction;\nauto operator*(const ScalarAffineFunction &a, CoeffT b) -> ScalarAffineFunction;\nauto operator*(CoeffT a, const ScalarAffineFunction &b) -> ScalarAffineFunction;\nauto operator*(const ScalarAffineFunction &a, const VariableIndex &b) -> ScalarQuadraticFunction;\nauto operator*(const VariableIndex &a, const ScalarAffineFunction &b) -> ScalarQuadraticFunction;\nauto operator*(const ScalarAffineFunction &a, const ScalarAffineFunction &b)\n -> ScalarQuadraticFunction;\nauto operator*(const ScalarQuadraticFunction &a, CoeffT b) -> ScalarQuadraticFunction;\nauto operator*(CoeffT a, const ScalarQuadraticFunction &b) -> ScalarQuadraticFunction;\n\nauto operator/(const VariableIndex &a, CoeffT b) -> ScalarAffineFunction;\nauto operator/(const ScalarAffineFunction &a, CoeffT b) -> ScalarAffineFunction;\nauto operator/(const ScalarQuadraticFunction &a, CoeffT b) -> ScalarQuadraticFunction;\n\n// unary minus operator\nauto operator-(const VariableIndex &a) -> ScalarAffineFunction;\nauto operator-(const ScalarAffineFunction &a) -> ScalarAffineFunction;\nauto operator-(const ScalarQuadraticFunction &a) -> ScalarQuadraticFunction;\nauto operator-(const ExprBuilder &a) -> ExprBuilder;\n\n// Operator overloading for\tExprBuilder\n// Sadly, they are inefficient than the +=,-=,*=,/= functions but they are important for a\n// user-friendly interface\n// The functions are like ScalarQuadraticFunction but returns a ExprBuilder\nauto operator+(const ExprBuilder &a, CoeffT b) -> ExprBuilder;\nauto operator+(CoeffT b, const ExprBuilder &a) -> ExprBuilder;\nauto operator+(const ExprBuilder &a, const VariableIndex &b) -> ExprBuilder;\nauto operator+(const VariableIndex &b, const ExprBuilder &a) -> ExprBuilder;\nauto operator+(const ExprBuilder &a, const ScalarAffineFunction &b) -> ExprBuilder;\nauto operator+(const ScalarAffineFunction &b, const ExprBuilder &a) -> ExprBuilder;\nauto operator+(const ExprBuilder &a, const ScalarQuadraticFunction &b) -> ExprBuilder;\nauto operator+(const ScalarQuadraticFunction &b, const ExprBuilder &a) -> ExprBuilder;\nauto operator+(const ExprBuilder &a, const ExprBuilder &b) -> ExprBuilder;\n\nauto operator-(const ExprBuilder &a, CoeffT b) -> ExprBuilder;\nauto operator-(CoeffT b, const ExprBuilder &a) -> ExprBuilder;\nauto operator-(const ExprBuilder &a, const VariableIndex &b) -> ExprBuilder;\nauto operator-(const VariableIndex &b, const ExprBuilder &a) -> ExprBuilder;\nauto operator-(const ExprBuilder &a, const ScalarAffineFunction &b) -> ExprBuilder;\nauto operator-(const ScalarAffineFunction &b, const ExprBuilder &a) -> ExprBuilder;\nauto operator-(const ExprBuilder &a, const ScalarQuadraticFunction &b) -> ExprBuilder;\nauto operator-(const ScalarQuadraticFunction &b, const ExprBuilder &a) -> ExprBuilder;\nauto operator-(const ExprBuilder &a, const ExprBuilder &b) -> ExprBuilder;\n\nauto operator*(const ExprBuilder &a, CoeffT b) -> ExprBuilder;\nauto operator*(CoeffT b, const ExprBuilder &a) -> ExprBuilder;\nauto operator*(const ExprBuilder &a, const VariableIndex &b) -> ExprBuilder;\nauto operator*(const VariableIndex &b, const ExprBuilder &a) -> ExprBuilder;\nauto operator*(const ExprBuilder &a, const ScalarAffineFunction &b) -> ExprBuilder;\nauto operator*(const ScalarAffineFunction &b, const ExprBuilder &a) -> ExprBuilder;\nauto operator*(const ExprBuilder &a, const ScalarQuadraticFunction &b) -> ExprBuilder;\nauto operator*(const ScalarQuadraticFunction &b, const ExprBuilder &a) -> ExprBuilder;\nauto operator*(const ExprBuilder &a, const ExprBuilder &b) -> ExprBuilder;\n\nauto operator/(const ExprBuilder &a, CoeffT b) -> ExprBuilder;\n\nenum class ConstraintType\n{\n\tLinear,\n\tQuadratic,\n\tSOS,\n\tSecondOrderCone,\n\tExponentialCone,\n\tNL,\n\tSolverDefined,\n};\n\nenum class SOSType\n{\n\tSOS1,\n\tSOS2,\n};\n\nenum class ConstraintSense\n{\n\tLessEqual,\n\tGreaterEqual,\n\tEqual\n};\n\nstruct ConstraintIndex\n{\n\tConstraintType type;\n\tIndexT index;\n\n\tConstraintIndex() = default;\n\tConstraintIndex(ConstraintType t, IndexT i) : type(t), index(i)\n\t{\n\t}\n};\n\n// struct LinearConstraint\n//{\n//\tScalarAffineFunction function;\n//\tConstraintSense sense;\n//\tCoeffT rhs;\n// };\n//\n// struct QuadraticConstraint\n//{\n//\tScalarQuadraticFunction function;\n//\tConstraintSense sense;\n//\tCoeffT rhs;\n// };\n//\n// struct SOSConstraint\n//{\n//\tVector variables;\n//\tVector weights;\n// };\n\nenum class ObjectiveSense\n{\n\tMinimize,\n\tMaximize\n};\n" }, { "path": "include/pyoptinterface/cppad_interface.hpp", "content": "#pragma once\n\n#include \"cppad/cppad.hpp\"\n#include \"pyoptinterface/nlexpr.hpp\"\n#include \"pyoptinterface/nleval.hpp\"\n\nusing ADFunDouble = CppAD::ADFun;\n\nADFunDouble dense_jacobian(const ADFunDouble &f);\n\nusing sparsity_pattern_t = CppAD::sparse_rc>;\n\nstruct JacobianHessianSparsityPattern\n{\n\tsparsity_pattern_t jacobian;\n\tsparsity_pattern_t hessian;\n\tsparsity_pattern_t reduced_hessian;\n};\n\nJacobianHessianSparsityPattern jacobian_hessian_sparsity(ADFunDouble &f,\n HessianSparsityType hessian_sparsity);\n\n// [p, x] -> Jacobian\nADFunDouble sparse_jacobian(const ADFunDouble &f, const sparsity_pattern_t &pattern_jac,\n const std::vector &x_values,\n const std::vector &p_values);\n\n// [p, w, x] -> \\Sigma w_i * Hessian_i\nADFunDouble sparse_hessian(const ADFunDouble &f, const sparsity_pattern_t &pattern_hes,\n const sparsity_pattern_t &pattern_subset,\n const std::vector &x_values,\n const std::vector &p_values);\n\n// Transform ExpressionGraph to CppAD function\n// selected: indices of outputs to trace, empty means all outputs\nADFunDouble cppad_trace_graph_constraints(const ExpressionGraph &graph,\n const std::vector &selected = {});\nADFunDouble cppad_trace_graph_objective(const ExpressionGraph &graph,\n const std::vector &selected = {},\n bool aggregate = true);\n\nstruct CppADAutodiffGraph\n{\n\tCppAD::cpp_graph f_graph, jacobian_graph, hessian_graph;\n};\n\n// Generate computational graph for the CppAD function (itself, Jacobian and Hessian)\n// Analyze its sparsity as well\nvoid cppad_autodiff(ADFunDouble &f, AutodiffSymbolicStructure &structure, CppADAutodiffGraph &graph,\n const std::vector &x_values, const std::vector &p_values);\n" }, { "path": "include/pyoptinterface/dylib.hpp", "content": "#pragma once\n\n#if defined(_MSC_VER)\n#define WIN32_LEAN_AND_MEAN\n#define NOMINMAX\n#include \n#else\n#include \n#endif\n\nclass DynamicLibrary\n{\n public:\n\tDynamicLibrary() : handle(nullptr)\n\t{\n\t}\n\n\t~DynamicLibrary()\n\t{\n\t\tif (handle != nullptr)\n\t\t{\n#if defined(_MSC_VER)\n\t\t\tFreeLibrary(static_cast(handle));\n#else\n\t\t\tdlclose(handle);\n#endif\n\t\t}\n\t}\n\n\tbool try_load(const char *library)\n\t{\n#if defined(_MSC_VER)\n\t\thandle = static_cast(LoadLibraryA(library));\n\n\t\tif (handle == nullptr)\n\t\t{\n\t\t\thandle = static_cast(LoadLibraryExA(library, NULL,\n\t\t\t LOAD_LIBRARY_SEARCH_DEFAULT_DIRS |\n\t\t\t LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR));\n\t\t}\n\n#else\n\t\thandle = dlopen(library, RTLD_NOW);\n#endif\n\t\treturn handle != nullptr;\n\t}\n\n\tbool LibraryIsLoaded() const\n\t{\n\t\treturn handle != nullptr;\n\t}\n\n\tvoid *get_symbol(const char *name)\n\t{\n#if defined(_MSC_VER)\n\t\tFARPROC function_address = GetProcAddress(static_cast(handle), name);\n#else\n\t\tvoid *function_address = dlsym(handle, name);\n#endif\n\n\t\treturn reinterpret_cast(function_address);\n\t}\n\n private:\n\tvoid *handle = nullptr;\n};\n\n// Next we will introduce some magic macros to declare function pointers and load them from dynamic\n// library robustly\n\n#define DYLIB_EXTERN_DECLARE(f) extern decltype(&::f) f\n#define DYLIB_DECLARE(f) decltype(&::f) f = nullptr\n\n#define DYLIB_LOAD_INIT \\\n\tankerl::unordered_dense::map _function_pointers; \\\n\tbool _load_success = true\n\n#define DYLIB_LOAD_FUNCTION(f) \\\n\t{ \\\n\t\tauto ptr = reinterpret_cast(lib.get_symbol(#f)); \\\n\t\tif (ptr == nullptr) \\\n\t\t{ \\\n\t\t\tfmt::print(\"function {} is not loaded correctly\\n\", #f); \\\n\t\t\t_load_success = false; \\\n\t\t} \\\n\t\t_function_pointers[#f] = reinterpret_cast(ptr); \\\n\t}\n\n#define IS_DYLIB_LOAD_SUCCESS _load_success\n\n#define DYLIB_SAVE_FUNCTION(f) f = reinterpret_cast(_function_pointers[#f])\n" }, { "path": "include/pyoptinterface/gurobi_model.hpp", "content": "#pragma once\n\n#include \n\n#include \"solvers/gurobi/gurobi_c.h\"\n\n#include \"pyoptinterface/core.hpp\"\n#include \"pyoptinterface/container.hpp\"\n#include \"pyoptinterface/nlexpr.hpp\"\n#define USE_NLMIXIN\n#include \"pyoptinterface/solver_common.hpp\"\n#include \"pyoptinterface/dylib.hpp\"\n\n// define Gurobi C APIs\n#define APILIST \\\n\tB(GRBnewmodel); \\\n\tB(GRBfreemodel); \\\n\tB(GRBreset); \\\n\tB(GRBgetenv); \\\n\tB(GRBwrite); \\\n\tB(GRBaddvar); \\\n\tB(GRBdelvars); \\\n\tB(GRBaddconstr); \\\n\tB(GRBaddqconstr); \\\n\tB(GRBaddsos); \\\n\tB(GRBaddgenconstrNL); \\\n\tB(GRBdelconstrs); \\\n\tB(GRBdelqconstrs); \\\n\tB(GRBdelsos); \\\n\tB(GRBdelgenconstrs); \\\n\tB(GRBdelq); \\\n\tB(GRBsetdblattrarray); \\\n\tB(GRBaddqpterms); \\\n\tB(GRBoptimize); \\\n\tB(GRBupdatemodel); \\\n\tB(GRBgetparamtype); \\\n\tB(GRBsetintparam); \\\n\tB(GRBsetdblparam); \\\n\tB(GRBsetstrparam); \\\n\tB(GRBgetintparam); \\\n\tB(GRBgetdblparam); \\\n\tB(GRBgetstrparam); \\\n\tB(GRBgetattrinfo); \\\n\tB(GRBsetintattr); \\\n\tB(GRBsetdblattr); \\\n\tB(GRBsetstrattr); \\\n\tB(GRBgetintattr); \\\n\tB(GRBgetdblattr); \\\n\tB(GRBgetstrattr); \\\n\tB(GRBgetdblattrarray); \\\n\tB(GRBgetdblattrlist); \\\n\tB(GRBsetdblattrlist); \\\n\tB(GRBsetintattrelement); \\\n\tB(GRBsetcharattrelement); \\\n\tB(GRBsetdblattrelement); \\\n\tB(GRBsetstrattrelement); \\\n\tB(GRBgetintattrelement); \\\n\tB(GRBgetcharattrelement); \\\n\tB(GRBgetdblattrelement); \\\n\tB(GRBgetstrattrelement); \\\n\tB(GRBgetcoeff); \\\n\tB(GRBchgcoeffs); \\\n\tB(GRBgeterrormsg); \\\n\tB(GRBversion); \\\n\tB(GRBsetcallbackfunc); \\\n\tB(GRBcbget); \\\n\tB(GRBcbproceed); \\\n\tB(GRBterminate); \\\n\tB(GRBcbsolution); \\\n\tB(GRBcblazy); \\\n\tB(GRBcbcut); \\\n\tB(GRBemptyenv); \\\n\tB(GRBloadenv); \\\n\tB(GRBfreeenv); \\\n\tB(GRBstartenv); \\\n\tB(GRBsetlogcallbackfunc); \\\n\tB(GRBconverttofixed); \\\n\tB(GRBcomputeIIS);\n\nnamespace gurobi\n{\n#define B DYLIB_EXTERN_DECLARE\nAPILIST\n#undef B\n\nbool is_library_loaded();\n\nbool load_library(const std::string &path);\n} // namespace gurobi\n\nclass GurobiEnv\n{\n public:\n\tGurobiEnv(bool empty = false);\n\t~GurobiEnv();\n\n\t// parameter\n\tint raw_parameter_type(const char *param_name);\n\tvoid set_raw_parameter_int(const char *param_name, int value);\n\tvoid set_raw_parameter_double(const char *param_name, double value);\n\tvoid set_raw_parameter_string(const char *param_name, const char *value);\n\n\tvoid start();\n\tvoid close();\n\n\tvoid check_error(int error);\n\n\tGRBenv *m_env = nullptr;\n};\n\nstruct GRBfreemodelT\n{\n\tvoid operator()(GRBmodel *model) const\n\t{\n\t\tgurobi::GRBfreemodel(model);\n\t};\n};\n\nclass GurobiModel;\nusing GurobiCallback = std::function;\n\nstruct GurobiCallbackUserdata\n{\n\tvoid *model = nullptr;\n\tGurobiCallback callback;\n\tint n_variables = 0;\n\tint where = 0;\n\t// store result of cbget\n\tbool cb_get_mipsol_called = false;\n\tstd::vector mipsol;\n\tbool cb_get_mipnoderel_called = false;\n\tstd::vector mipnoderel;\n\t// Cache for cbsolution\n\tbool cb_set_solution_called = false;\n\tstd::vector heuristic_solution;\n\tbool cb_requires_submit_solution = false;\n};\n\nusing GurobiLoggingCallback = std::function;\n\nstruct GurobiLoggingCallbackUserdata\n{\n\tGurobiLoggingCallback callback;\n};\n\nclass GurobiModel : public OnesideLinearConstraintMixin,\n public OnesideQuadraticConstraintMixin,\n public TwosideNLConstraintMixin,\n public LinearObjectiveMixin,\n public PPrintMixin,\n public GetValueMixin\n{\n public:\n\tGurobiModel() = default;\n\tGurobiModel(const GurobiEnv &env);\n\tvoid init(const GurobiEnv &env);\n\tvoid close();\n\n\tvoid _reset(int clearall);\n\n\tdouble get_infinity() const;\n\n\tvoid write(const std::string &filename);\n\n\tVariableIndex add_variable(VariableDomain domain = VariableDomain::Continuous,\n\t double lb = -GRB_INFINITY, double ub = GRB_INFINITY,\n\t const char *name = nullptr);\n\tvoid delete_variable(const VariableIndex &variable);\n\tvoid delete_variables(const Vector &variables);\n\tbool is_variable_active(const VariableIndex &variable);\n\tdouble get_variable_value(const VariableIndex &variable);\n\tstd::string pprint_variable(const VariableIndex &variable);\n\tvoid set_variable_bounds(const VariableIndex &variable, double lb, double ub);\n\n\tvoid set_variable_name(const VariableIndex &variable, const char *name);\n\tvoid set_constraint_name(const ConstraintIndex &constraint, const char *name);\n\n\tConstraintIndex add_linear_constraint(const ScalarAffineFunction &function,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr);\n\tConstraintIndex add_quadratic_constraint(const ScalarQuadraticFunction &function,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr);\n\tConstraintIndex add_sos_constraint(const Vector &variables, SOSType sos_type);\n\tConstraintIndex add_sos_constraint(const Vector &variables, SOSType sos_type,\n\t const Vector &weights);\n\n\t// Nonlinear constraint\n\tvoid information_of_expr(const ExpressionGraph &graph, const ExpressionHandle &expr,\n\t int &opcode, double &data);\n\tvoid decode_graph(const ExpressionGraph &graph, const ExpressionHandle &result,\n\t std::vector &opcodes, std::vector &parents,\n\t std::vector &datas);\n\tConstraintIndex add_single_nl_constraint(const ExpressionGraph &graph,\n\t const ExpressionHandle &result,\n\t const std::tuple &interval,\n\t const char *name = nullptr);\n\n\tvoid delete_constraint(const ConstraintIndex &constraint);\n\tbool is_constraint_active(const ConstraintIndex &constraint);\n\n\tvoid _set_affine_objective(const ScalarAffineFunction &function, ObjectiveSense sense,\n\t bool clear_quadratic);\n\tvoid set_objective(const ScalarAffineFunction &function, ObjectiveSense sense);\n\tvoid set_objective(const ScalarQuadraticFunction &function, ObjectiveSense sense);\n\tvoid set_objective(const ExprBuilder &function, ObjectiveSense sense);\n\n\tvoid add_single_nl_objective(ExpressionGraph &graph, const ExpressionHandle &result);\n\tvoid set_nl_objective();\n\n\tvoid optimize();\n\tvoid update();\n\tvoid *get_raw_model();\n\tstd::string version_string();\n\n\t// parameter\n\tint raw_parameter_type(const char *param_name);\n\tvoid set_raw_parameter_int(const char *param_name, int value);\n\tvoid set_raw_parameter_double(const char *param_name, double value);\n\tvoid set_raw_parameter_string(const char *param_name, const char *value);\n\tint get_raw_parameter_int(const char *param_name);\n\tdouble get_raw_parameter_double(const char *param_name);\n\tstd::string get_raw_parameter_string(const char *param_name);\n\n\t// attribute\n\tint raw_attribute_type(const char *attr_name);\n\n\t// model attribute\n\tvoid set_model_raw_attribute_int(const char *attr_name, int value);\n\tvoid set_model_raw_attribute_double(const char *attr_name, double value);\n\tvoid set_model_raw_attribute_string(const char *attr_name, const char *value);\n\tint get_model_raw_attribute_int(const char *attr_name);\n\tdouble get_model_raw_attribute_double(const char *attr_name);\n\tstd::string get_model_raw_attribute_string(const char *attr_name);\n\n\tstd::vector get_model_raw_attribute_vector_double(const char *attr_name, int start,\n\t int len);\n\tstd::vector get_model_raw_attribute_list_double(const char *attr_name,\n\t const std::vector &ind);\n\n\t// variable attribute\n\tvoid set_variable_raw_attribute_int(const VariableIndex &variable, const char *attr_name,\n\t int value);\n\tvoid set_variable_raw_attribute_char(const VariableIndex &variable, const char *attr_name,\n\t char value);\n\tvoid set_variable_raw_attribute_double(const VariableIndex &variable, const char *attr_name,\n\t double value);\n\tvoid set_variable_raw_attribute_string(const VariableIndex &variable, const char *attr_name,\n\t const char *value);\n\tint get_variable_raw_attribute_int(const VariableIndex &variable, const char *attr_name);\n\tchar get_variable_raw_attribute_char(const VariableIndex &variable, const char *attr_name);\n\tdouble get_variable_raw_attribute_double(const VariableIndex &variable, const char *attr_name);\n\tstd::string get_variable_raw_attribute_string(const VariableIndex &variable,\n\t const char *attr_name);\n\n\tint _variable_index(const VariableIndex &variable);\n\tint _checked_variable_index(const VariableIndex &variable);\n\n\t// constraint attribute\n\tvoid set_constraint_raw_attribute_int(const ConstraintIndex &constraint, const char *attr_name,\n\t int value);\n\tvoid set_constraint_raw_attribute_char(const ConstraintIndex &constraint, const char *attr_name,\n\t char value);\n\tvoid set_constraint_raw_attribute_double(const ConstraintIndex &constraint,\n\t const char *attr_name, double value);\n\tvoid set_constraint_raw_attribute_string(const ConstraintIndex &constraint,\n\t const char *attr_name, const char *value);\n\tint get_constraint_raw_attribute_int(const ConstraintIndex &constraint, const char *attr_name);\n\tchar get_constraint_raw_attribute_char(const ConstraintIndex &constraint,\n\t const char *attr_name);\n\tdouble get_constraint_raw_attribute_double(const ConstraintIndex &constraint,\n\t const char *attr_name);\n\tstd::string get_constraint_raw_attribute_string(const ConstraintIndex &constraint,\n\t const char *attr_name);\n\n\tint _constraint_index(const ConstraintIndex &constraint);\n\tint _checked_constraint_index(const ConstraintIndex &constraint);\n\n\t// Modifications of model\n\t// 1. set/get RHS of a constraint\n\tdouble get_normalized_rhs(const ConstraintIndex &constraint);\n\tvoid set_normalized_rhs(const ConstraintIndex &constraint, double value);\n\t// 2. set/get coefficient of variable in constraint\n\tdouble get_normalized_coefficient(const ConstraintIndex &constraint,\n\t const VariableIndex &variable);\n\tvoid set_normalized_coefficient(const ConstraintIndex &constraint,\n\t const VariableIndex &variable, double value);\n\t// 3. set/get linear coefficient of variable in objective\n\tdouble get_objective_coefficient(const VariableIndex &variable);\n\tvoid set_objective_coefficient(const VariableIndex &variable, double value);\n\n\t// Gurobi-specific convertofixed\n\tvoid _converttofixed();\n\n\t// IIS related\n\tvoid computeIIS();\n\n\t// Non-exported functions\n\tvoid check_error(int error);\n\n\t// Control logging\n\tvoid set_logging(const GurobiLoggingCallback &callback);\n\n\tGurobiLoggingCallbackUserdata m_logging_callback_userdata;\n\n\t// Callback\n\tvoid set_callback(const GurobiCallback &callback);\n\n\t// For callback\n\tbool has_callback = false;\n\tvoid *m_cbdata = nullptr;\n\tGurobiCallbackUserdata m_callback_userdata;\n\n\tint cb_get_info_int(int what);\n\tdouble cb_get_info_double(int what);\n\tvoid cb_get_info_doublearray(int what);\n\n\tdouble cb_get_solution(const VariableIndex &variable);\n\tdouble cb_get_relaxation(const VariableIndex &variable);\n\tvoid cb_set_solution(const VariableIndex &variable, double value);\n\tdouble cb_submit_solution();\n\n\tvoid cb_exit();\n\n\tvoid cb_add_lazy_constraint(const ScalarAffineFunction &function, ConstraintSense sense,\n\t CoeffT rhs);\n\tvoid cb_add_lazy_constraint(const ExprBuilder &function, ConstraintSense sense, CoeffT rhs);\n\tvoid cb_add_user_cut(const ScalarAffineFunction &function, ConstraintSense sense, CoeffT rhs);\n\tvoid cb_add_user_cut(const ExprBuilder &function, ConstraintSense sense, CoeffT rhs);\n\n private:\n\tMonotoneIndexer m_variable_index;\n\n\tMonotoneIndexer m_linear_constraint_index;\n\n\tMonotoneIndexer m_quadratic_constraint_index;\n\n\tMonotoneIndexer m_sos_constraint_index;\n\n\tMonotoneIndexer m_general_constraint_index;\n\t// Gurobi only accepts y = f(x) style nonlinear constraint\n\t// so for each lb <= f(x) <= ub, we need to convert it to\n\t// lb <= y <= ub, and add y = f(x) as a nonlinear constraint\n\t// y is called the result variable (resvar)\n\tHashmap m_nlcon_resvar_map;\n\t// for each nonlinear term in objective function, we need to record the resvar to set their\n\t// coefficient in objective as 1.0\n\t// add f(x) to the objective is divided into two steps:\n\t// 1. add a new nonlinear constraint y = f(x)\n\t// 2. set the coefficient of y in objective to 1.0\n\tint m_nlobj_num = 0;\n\tstd::vector m_nlobj_con_indices;\n\tstd::vector m_nlobj_resvar_indices;\n\n\t/* flag to indicate whether the model needs update */\n\tenum : std::uint64_t\n\t{\n\t\tm_variable_creation = 1,\n\t\tm_variable_deletion = 1 << 1,\n\t\tm_linear_constraint_creation = 1 << 2,\n\t\tm_linear_constraint_deletion = 1 << 3,\n\t\tm_quadratic_constraint_creation = 1 << 4,\n\t\tm_quadratic_constraint_deletion = 1 << 5,\n\t\tm_sos_constraint_creation = 1 << 6,\n\t\tm_sos_constraint_deletion = 1 << 7,\n\t\tm_general_constraint_creation = 1 << 8,\n\t\tm_general_constraint_deletion = 1 << 9,\n\t\tm_objective_update = 1 << 10,\n\t\tm_attribute_update = 1 << 11,\n\t\tm_constraint_coefficient_update = 1 << 12,\n\t};\n\tstd::uint64_t m_update_flag = 0;\n\tvoid _update_for_information();\n\tvoid _update_for_variable_index();\n\tvoid _update_for_constraint_index(ConstraintType type);\n\n\t/* Gurobi part */\n\tGRBenv *m_env = nullptr;\n\tstd::unique_ptr m_model;\n};\n" }, { "path": "include/pyoptinterface/highs_model.hpp", "content": "#pragma once\n\n#include \n\n#include \"interfaces/highs_c_api.h\"\n#include \"lp_data/HConst.h\"\n\n#include \"pyoptinterface/core.hpp\"\n#include \"pyoptinterface/container.hpp\"\n#include \"pyoptinterface/solver_common.hpp\"\n#include \"pyoptinterface/dylib.hpp\"\n\n#define APILIST \\\n\tB(Highs_create); \\\n\tB(Highs_destroy); \\\n\tB(Highs_writeModel); \\\n\tB(Highs_writeSolution); \\\n\tB(Highs_writeSolutionPretty); \\\n\tB(Highs_addCol); \\\n\tB(Highs_passColName); \\\n\tB(Highs_getColName); \\\n\tB(Highs_getNumCol); \\\n\tB(Highs_changeColIntegrality); \\\n\tB(Highs_deleteColsBySet); \\\n\tB(Highs_addRow); \\\n\tB(Highs_passRowName); \\\n\tB(Highs_getRowName); \\\n\tB(Highs_getNumRow); \\\n\tB(Highs_deleteRowsBySet); \\\n\tB(Highs_passHessian); \\\n\tB(Highs_changeColsCostByRange); \\\n\tB(Highs_changeObjectiveOffset); \\\n\tB(Highs_changeObjectiveSense); \\\n\tB(Highs_run); \\\n\tB(Highs_getNumCols); \\\n\tB(Highs_getNumRows); \\\n\tB(Highs_getModelStatus); \\\n\tB(Highs_getDualRay); \\\n\tB(Highs_getPrimalRay); \\\n\tB(Highs_getIntInfoValue); \\\n\tB(Highs_getSolution); \\\n\tB(Highs_getHessianNumNz); \\\n\tB(Highs_getBasis); \\\n\tB(Highs_version); \\\n\tB(Highs_getRunTime); \\\n\tB(Highs_getOptionType); \\\n\tB(Highs_setBoolOptionValue); \\\n\tB(Highs_setIntOptionValue); \\\n\tB(Highs_setDoubleOptionValue); \\\n\tB(Highs_setStringOptionValue); \\\n\tB(Highs_getBoolOptionValue); \\\n\tB(Highs_getIntOptionValue); \\\n\tB(Highs_getDoubleOptionValue); \\\n\tB(Highs_getStringOptionValue); \\\n\tB(Highs_getInfoType); \\\n\tB(Highs_getInt64InfoValue); \\\n\tB(Highs_getDoubleInfoValue); \\\n\tB(Highs_getColIntegrality); \\\n\tB(Highs_changeColsBoundsBySet); \\\n\tB(Highs_getColsBySet); \\\n\tB(Highs_getObjectiveSense); \\\n\tB(Highs_getObjectiveValue); \\\n\tB(Highs_getColsByRange); \\\n\tB(Highs_setSolution); \\\n\tB(Highs_getRowsBySet); \\\n\tB(Highs_changeRowsBoundsBySet); \\\n\tB(Highs_changeCoeff); \\\n\tB(Highs_changeColCost);\n\nnamespace highs\n{\n#define B DYLIB_EXTERN_DECLARE\nAPILIST\n#undef B\n\nbool is_library_loaded();\n\nbool load_library(const std::string &path);\n} // namespace highs\n\nstruct HighsfreemodelT\n{\n\tvoid operator()(void *model) const\n\t{\n\t\thighs::Highs_destroy(model);\n\t};\n};\n\nenum class HighsSolutionStatus\n{\n\tOPTIMIZE_NOT_CALLED,\n\tOPTIMIZE_OK,\n\tOPTIMIZE_ERROR,\n};\n\nstruct POIHighsSolution\n{\n\tHighsSolutionStatus status = HighsSolutionStatus::OPTIMIZE_NOT_CALLED;\n\tHighsInt model_status;\n\tstd::vector colvalue;\n\tstd::vector coldual;\n\tstd::vector colstatus;\n\tstd::vector rowvalue;\n\tstd::vector rowdual;\n\tstd::vector rowstatus;\n\tHighsInt primal_solution_status;\n\tHighsInt dual_solution_status;\n\tbool has_primal_ray;\n\tbool has_dual_ray;\n\tstd::vector primal_ray;\n\tstd::vector dual_ray;\n};\n\nclass POIHighsModel : public OnesideLinearConstraintMixin,\n public TwosideLinearConstraintMixin,\n public LinearObjectiveMixin,\n public PPrintMixin,\n public GetValueMixin\n{\n public:\n\tPOIHighsModel();\n\tvoid init();\n\tvoid close();\n\n\tvoid write(const std::string &filename, bool pretty);\n\n\tVariableIndex add_variable(VariableDomain domain = VariableDomain::Continuous,\n\t double lb = -kHighsInf, double ub = kHighsInf,\n\t const char *name = nullptr);\n\tvoid delete_variable(const VariableIndex &variable);\n\tvoid delete_variables(const Vector &variables);\n\tbool is_variable_active(const VariableIndex &variable);\n\tdouble get_variable_value(const VariableIndex &variable);\n\tstd::string pprint_variable(const VariableIndex &variable);\n\tvoid set_variable_bounds(const VariableIndex &variable, double lb, double ub);\n\n\tConstraintIndex add_linear_constraint(const ScalarAffineFunction &function,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr);\n\tConstraintIndex add_linear_constraint(const ScalarAffineFunction &function,\n\t const std::tuple &interval,\n\t const char *name = nullptr);\n\tConstraintIndex add_quadratic_constraint(const ScalarQuadraticFunction &function,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr);\n\n\tvoid delete_constraint(const ConstraintIndex &constraint);\n\tbool is_constraint_active(const ConstraintIndex &constraint);\n\n\tvoid _set_affine_objective(const ScalarAffineFunction &function, ObjectiveSense sense,\n\t bool clear_quadratic);\n\tvoid set_objective(const ScalarAffineFunction &function, ObjectiveSense sense);\n\tvoid set_objective(const ScalarQuadraticFunction &function, ObjectiveSense sense);\n\tvoid set_objective(const ExprBuilder &function, ObjectiveSense sense);\n\n\tvoid optimize();\n\tvoid *get_raw_model();\n\tstd::string version_string();\n\n\tdouble getruntime();\n\tint getnumrow();\n\tint getnumcol();\n\n\t// option\n\tint raw_option_type(const char *param_name);\n\tvoid set_raw_option_bool(const char *param_name, bool value);\n\tvoid set_raw_option_int(const char *param_name, int value);\n\tvoid set_raw_option_double(const char *param_name, double value);\n\tvoid set_raw_option_string(const char *param_name, const char *value);\n\tbool get_raw_option_bool(const char *param_name);\n\tint get_raw_option_int(const char *param_name);\n\tdouble get_raw_option_double(const char *param_name);\n\tstd::string get_raw_option_string(const char *param_name);\n\n\t// information\n\tint raw_info_type(const char *info_name);\n\tint get_raw_info_int(const char *info_name);\n\tstd::int64_t get_raw_info_int64(const char *info_name);\n\tdouble get_raw_info_double(const char *info_name);\n\n\t// Accessing information of m_problem\n\tstd::string get_variable_name(const VariableIndex &variable);\n\tvoid set_variable_name(const VariableIndex &variable, const char *name);\n\tVariableDomain get_variable_type(const VariableIndex &variable);\n\tvoid set_variable_type(const VariableIndex &variable, VariableDomain domain);\n\tdouble get_variable_lower_bound(const VariableIndex &variable);\n\tdouble get_variable_upper_bound(const VariableIndex &variable);\n\tvoid set_variable_lower_bound(const VariableIndex &variable, double lb);\n\tvoid set_variable_upper_bound(const VariableIndex &variable, double ub);\n\n\tstd::string get_constraint_name(const ConstraintIndex &constraint);\n\tvoid set_constraint_name(const ConstraintIndex &constraint, const char *name);\n\tdouble get_constraint_primal(const ConstraintIndex &constraint);\n\tdouble get_constraint_dual(const ConstraintIndex &constraint);\n\n\t// dual of variable as reduced cost\n\tdouble get_variable_dual(const VariableIndex &variable);\n\n\tObjectiveSense get_obj_sense();\n\tvoid set_obj_sense(ObjectiveSense sense);\n\tdouble get_obj_value();\n\n\tHighsInt _variable_index(const VariableIndex &variable);\n\tHighsInt _checked_variable_index(const VariableIndex &variable);\n\tHighsInt _constraint_index(const ConstraintIndex &constraint);\n\tHighsInt _checked_constraint_index(const ConstraintIndex &constraint);\n\n\t// Primal start\n\tvoid set_primal_start(const Vector &variables, const Vector &values);\n\n\t// Modifications of model\n\t// 1. set/get RHS of a constraint\n\tdouble get_normalized_rhs(const ConstraintIndex &constraint);\n\tvoid set_normalized_rhs(const ConstraintIndex &constraint, double value);\n\t// 2. set/get coefficient of variable in constraint\n\tdouble get_normalized_coefficient(const ConstraintIndex &constraint,\n\t const VariableIndex &variable);\n\tvoid set_normalized_coefficient(const ConstraintIndex &constraint,\n\t const VariableIndex &variable, double value);\n\t// 3. set/get linear coefficient of variable in objective\n\tdouble get_objective_coefficient(const VariableIndex &variable);\n\tvoid set_objective_coefficient(const VariableIndex &variable, double value);\n\n private:\n\tMonotoneIndexer m_variable_index;\n\n\tMonotoneIndexer m_linear_constraint_index;\n\n\t// Highs does not discriminate between integer variable and binary variable\n\t// So we need to keep track of binary variables\n\tHashset binary_variables;\n\n\t/* Highs part */\n\tstd::unique_ptr m_model;\n\n public:\n\t// cache the solution\n\tPOIHighsSolution m_solution;\n\t// cache the number of variable and constraints because querying them via HiGHS API is very\n\t// expensive\n\tHighsInt m_n_variables = 0;\n\tHighsInt m_n_constraints = 0;\n};\n" }, { "path": "include/pyoptinterface/ipopt_model.hpp", "content": "#pragma once\n\n#include \"solvers/ipopt/IpStdCInterface.h\"\n#include \"pyoptinterface/nlexpr.hpp\"\n#include \"pyoptinterface/nleval.hpp\"\n#include \"pyoptinterface/dylib.hpp\"\n#include \"pyoptinterface/solver_common.hpp\"\n#include \n#include \n\n#define APILIST \\\n\tB(CreateIpoptProblem); \\\n\tB(FreeIpoptProblem); \\\n\tB(AddIpoptStrOption); \\\n\tB(AddIpoptNumOption); \\\n\tB(AddIpoptIntOption); \\\n\tB(IpoptSolve);\n\nnamespace ipopt\n{\n#define B DYLIB_EXTERN_DECLARE\nAPILIST\n#undef B\n\nbool is_library_loaded();\n\nbool load_library(const std::string &path);\n} // namespace ipopt\n\nstruct IpoptfreeproblemT\n{\n\tvoid operator()(IpoptProblemInfo *model) const\n\t{\n\t\tipopt::FreeIpoptProblem(model);\n\t};\n};\n\nstruct IpoptResult\n{\n\tbool is_valid = false;\n\t// store results\n\tstd::vector x, g, mult_g, mult_x_L, mult_x_U;\n\tdouble obj_val;\n};\n\nstruct IpoptModel : public OnesideLinearConstraintMixin,\n public TwosideLinearConstraintMixin,\n public OnesideQuadraticConstraintMixin,\n public TwosideQuadraticConstraintMixin,\n public LinearObjectiveMixin,\n public PPrintMixin,\n public GetValueMixin\n{\n\t/* Methods */\n\tIpoptModel();\n\tvoid close();\n\n\tVariableIndex add_variable(double lb = -INFINITY, double ub = INFINITY, double start = 0.0,\n\t const char *name = nullptr);\n\tdouble get_variable_lb(const VariableIndex &variable);\n\tdouble get_variable_ub(const VariableIndex &variable);\n\tvoid set_variable_lb(const VariableIndex &variable, double lb);\n\tvoid set_variable_ub(const VariableIndex &variable, double ub);\n\tvoid set_variable_bounds(const VariableIndex &variable, double lb, double ub);\n\n\tdouble get_variable_start(const VariableIndex &variable);\n\tvoid set_variable_start(const VariableIndex &variable, double start);\n\n\tstd::string get_variable_name(const VariableIndex &variable);\n\tvoid set_variable_name(const VariableIndex &variable, const std::string &name);\n\n\tdouble get_variable_value(const VariableIndex &variable);\n\n\tstd::string pprint_variable(const VariableIndex &variable);\n\n\tdouble get_obj_value();\n\tint _constraint_internal_index(const ConstraintIndex &constraint);\n\tdouble get_constraint_primal(const ConstraintIndex &constraint);\n\tdouble get_constraint_dual(const ConstraintIndex &constraint);\n\n\tConstraintIndex add_linear_constraint(const ScalarAffineFunction &f, ConstraintSense sense,\n\t double rhs, const char *name = nullptr);\n\tConstraintIndex add_linear_constraint(const ScalarAffineFunction &f,\n\t const std::tuple &interval,\n\t const char *name = nullptr);\n\n\tConstraintIndex add_quadratic_constraint(const ScalarQuadraticFunction &f,\n\t ConstraintSense sense, double rhs,\n\t const char *name = nullptr);\n\tConstraintIndex add_quadratic_constraint(const ScalarQuadraticFunction &f,\n\t const std::tuple &interval,\n\t const char *name = nullptr);\n\n\tvoid set_objective(const ScalarAffineFunction &expr, ObjectiveSense sense);\n\tvoid set_objective(const ScalarQuadraticFunction &expr, ObjectiveSense sense);\n\tvoid set_objective(const ExprBuilder &expr, ObjectiveSense sense);\n\n\tvoid _set_linear_objective(const ScalarAffineFunction &expr);\n\tvoid _set_quadratic_objective(const ScalarQuadraticFunction &expr);\n\n\t// new implementation\n\tsize_t n_graph_instances = 0;\n\tstd::vector> m_graph_instance_variables;\n\tstd::vector> m_graph_instance_constants;\n\t// record graph instances with constraint output and objective output\n\tstruct GraphInstancesInfo\n\t{\n\t\t// hash of this graph instance\n\t\tstd::vector hashes;\n\t\t// index of this graph instance\n\t\tstd::vector instance_indices;\n\n\t\tsize_t n_instances_since_last_aggregation;\n\t} nl_constraint_info, nl_objective_info;\n\n\t// length = n_graph_instances\n\tstruct GraphInstancesGroupInfo\n\t{\n\t\t// which group it belongs to\n\t\tstd::vector group_indices;\n\t\t// the number in that group\n\t\tstd::vector group_orders;\n\t} nl_constraint_group_info, nl_objective_group_info;\n\n\t// graph groups\n\tstruct\n\t{\n\t\tHashmap hash_to_group;\n\t\tsize_t n_group = 0;\n\t\tstd::vector representative_graph_indices;\n\t\tstd::vector> instance_indices;\n\t\tstd::vector autodiff_structures;\n\t\tstd::vector autodiff_evaluators;\n\n\t\t// where to store the hessian matrix, each group length = n_instance * local_hessian_nnz\n\t\tstd::vector> hessian_indices;\n\t} nl_constraint_groups;\n\n\tstruct\n\t{\n\t\tHashmap hash_to_group;\n\t\tsize_t n_group = 0;\n\t\tstd::vector representative_graph_indices;\n\t\tstd::vector> instance_indices;\n\t\tstd::vector autodiff_structures;\n\t\tstd::vector autodiff_evaluators;\n\n\t\t// where to store the gradient vector, each group length = n_instance * local_jacobian_nnz\n\t\tstd::vector> gradient_indices;\n\t\t// where to store the hessian matrix, each group length = n_instance * local_hessian_nnz\n\t\tstd::vector> hessian_indices;\n\t} nl_objective_groups;\n\n\tint add_graph_index();\n\tvoid finalize_graph_instance(size_t graph_index, const ExpressionGraph &graph);\n\tint aggregate_nl_constraint_groups();\n\tint get_nl_constraint_group_representative(int group_index) const;\n\tint aggregate_nl_objective_groups();\n\tint get_nl_objective_group_representative(int group_index) const;\n\n\tvoid assign_nl_constraint_group_autodiff_structure(int group_index,\n\t const AutodiffSymbolicStructure &structure);\n\tvoid assign_nl_constraint_group_autodiff_evaluator(\n\t int group_index, const ConstraintAutodiffEvaluator &evaluator);\n\tvoid assign_nl_objective_group_autodiff_structure(int group_index,\n\t const AutodiffSymbolicStructure &structure);\n\tvoid assign_nl_objective_group_autodiff_evaluator(int group_index,\n\t const ObjectiveAutodiffEvaluator &evaluator);\n\n\tConstraintIndex add_single_nl_constraint(size_t graph_index, const ExpressionGraph &graph,\n\t double lb, double ub);\n\n\t// void clear_nl_objective();\n\n\tvoid analyze_structure();\n\tvoid optimize();\n\n\t// load current solution as\tinitial guess\n\tvoid load_current_solution();\n\n\t// set options\n\tvoid set_raw_option_int(const std::string &name, int value);\n\tvoid set_raw_option_double(const std::string &name, double value);\n\tvoid set_raw_option_string(const std::string &name, const std::string &value);\n\n\t/* Members */\n\n\tsize_t n_variables = 0;\n\n\tsize_t n_nl_constraints = 0;\n\t/*\n\t * record the constraint indices mapping from the monotonic one (the order of adding\n\t * constraint) to the reordered one (linear, quadratic, NL group 0 -> con0, con1 ,..., conN0, NL\n\t * group1 -> con0, con1,..., conN1)\n\t */\n\t// this is maintained when adding NL constraint\n\tstruct ConstraintGraphMembership\n\t{\n\t\t// which graph it belongs to\n\t\tint graph;\n\t\t// the rank in that graph\n\t\tint rank;\n\t};\n\t// record the graph a nonlinear constraint belongs to\n\tstd::vector nl_constraint_graph_memberships;\n\n\t// this vector is constructed before optimization\n\t// ext means the external monotonic order\n\t// int means the internal order that passes to Ipopt\n\tstd::vector nl_constraint_map_ext2int;\n\n\t// we need a sparse vector to store the gradient\n\tstd::vector sparse_gradient_values;\n\tstd::vector sparse_gradient_indices;\n\n\tstd::vector m_var_lb, m_var_ub, m_var_init;\n\tstd::vector m_linear_con_lb, m_linear_con_ub, m_quadratic_con_lb, m_quadratic_con_ub,\n\t m_nl_con_lb, m_nl_con_ub, m_con_lb, m_con_ub;\n\n\tHashmap m_var_names;\n\n\tsize_t m_jacobian_nnz = 0;\n\tstd::vector m_jacobian_rows, m_jacobian_cols;\n\n\tsize_t m_hessian_nnz = 0;\n\tstd::vector m_hessian_rows, m_hessian_cols;\n\tHashmap, int> m_hessian_index_map;\n\n\tLinearEvaluator m_linear_con_evaluator;\n\tQuadraticEvaluator m_quadratic_con_evaluator;\n\n\tstd::optional m_linear_obj_evaluator;\n\tstd::optional m_quadratic_obj_evaluator;\n\n\tNonlinearEvaluator m_nl_evaluator;\n\n\t// The options of the Ipopt solver, we cache them before constructing the m_problem\n\tHashmap m_options_int;\n\tHashmap m_options_num;\n\tHashmap m_options_str;\n\n\tIpoptResult m_result;\n\tbool m_is_dirty = true;\n\tenum ApplicationReturnStatus m_status;\n\n\tstd::unique_ptr m_problem = nullptr;\n};\n" }, { "path": "include/pyoptinterface/knitro_model.hpp", "content": "#pragma once\n\n#include \n#include \n#include \n#include \n\n#include \"solvers/knitro/knitro.h\"\n\n#include \"pyoptinterface/core.hpp\"\n#include \"pyoptinterface/container.hpp\"\n#include \"pyoptinterface/cppad_interface.hpp\"\n#define USE_NLMIXIN\n#include \"pyoptinterface/solver_common.hpp\"\n#include \"pyoptinterface/dylib.hpp\"\n\n// Define Knitro C APIs to be dynamically loaded\n#define APILIST \\\n\tB(KN_checkout_license); \\\n\tB(KN_release_license); \\\n\tB(KN_new_lm); \\\n\tB(KN_new); \\\n\tB(KN_free); \\\n\tB(KN_update); \\\n\tB(KN_solve); \\\n\tB(KN_get_param_id); \\\n\tB(KN_get_param_type); \\\n\tB(KN_set_int_param); \\\n\tB(KN_set_char_param); \\\n\tB(KN_set_double_param); \\\n\tB(KN_get_int_param); \\\n\tB(KN_get_double_param); \\\n\tB(KN_add_var); \\\n\tB(KN_add_con); \\\n\tB(KN_set_var_lobnd); \\\n\tB(KN_set_var_upbnd); \\\n\tB(KN_get_var_lobnd); \\\n\tB(KN_get_var_upbnd); \\\n\tB(KN_set_var_type); \\\n\tB(KN_get_var_type); \\\n\tB(KN_set_var_name); \\\n\tB(KN_get_var_name); \\\n\tB(KN_set_con_lobnd); \\\n\tB(KN_set_con_upbnd); \\\n\tB(KN_get_con_lobnd); \\\n\tB(KN_get_con_upbnd); \\\n\tB(KN_set_con_name); \\\n\tB(KN_get_con_name); \\\n\tB(KN_set_obj_goal); \\\n\tB(KN_get_obj_goal); \\\n\tB(KN_set_var_primal_init_value); \\\n\tB(KN_add_obj_constant); \\\n\tB(KN_del_obj_constant); \\\n\tB(KN_add_obj_linear_struct); \\\n\tB(KN_del_obj_linear_struct_all); \\\n\tB(KN_add_obj_quadratic_struct); \\\n\tB(KN_del_obj_quadratic_struct_all); \\\n\tB(KN_chg_obj_linear_term); \\\n\tB(KN_add_con_constant); \\\n\tB(KN_add_con_linear_struct); \\\n\tB(KN_add_con_linear_term); \\\n\tB(KN_add_con_quadratic_struct); \\\n\tB(KN_add_con_quadratic_term); \\\n\tB(KN_chg_con_linear_term); \\\n\tB(KN_add_eval_callback); \\\n\tB(KN_set_cb_user_params); \\\n\tB(KN_set_cb_grad); \\\n\tB(KN_set_cb_hess); \\\n\tB(KN_del_obj_eval_callback_all); \\\n\tB(KN_get_var_primal_value); \\\n\tB(KN_get_var_dual_value); \\\n\tB(KN_get_con_value); \\\n\tB(KN_get_con_dual_value); \\\n\tB(KN_get_obj_value); \\\n\tB(KN_get_number_iters); \\\n\tB(KN_get_mip_number_nodes); \\\n\tB(KN_get_mip_relaxation_bnd); \\\n\tB(KN_get_mip_rel_gap); \\\n\tB(KN_get_solve_time_real); \\\n\tB(KN_get_release);\n\nnamespace knitro\n{\n#define B DYLIB_EXTERN_DECLARE\nAPILIST\n#undef B\n\nbool is_library_loaded();\n\nbool load_library(const std::string &path);\n\nbool has_valid_license();\n} // namespace knitro\n\nstruct KNITROFreeProblemT\n{\n\tvoid operator()(KN_context *kc) const\n\t{\n\t\tif (kc != nullptr)\n\t\t{\n\t\t\tknitro::KN_free(&kc);\n\t\t}\n\t}\n};\n\nstruct KNITROFreeLicenseT\n{\n\tvoid operator()(LM_context *lmc) const\n\t{\n\t\tif (lmc != nullptr)\n\t\t{\n\t\t\tknitro::KN_release_license(&lmc);\n\t\t}\n\t}\n};\n\nenum ObjectiveFlags\n{\n\tOBJ_CONSTANT = 1 << 0, // 0x01\n\tOBJ_LINEAR = 1 << 1, // 0x02\n\tOBJ_QUADRATIC = 1 << 2, // 0x04\n\tOBJ_NONLINEAR = 1 << 3 // 0x08\n};\n\nenum ConstraintSenseFlags\n{\n\tCON_LOBND = 1 << 0, // 0x01\n\tCON_UPBND = 1 << 1, // 0x02\n};\n\ntemplate \nstruct CallbackPattern\n{\n\tstd::vector indexCons;\n\tstd::vector objGradIndexVars;\n\tstd::vector jacIndexCons;\n\tstd::vector jacIndexVars;\n\tstd::vector hessIndexVars1;\n\tstd::vector hessIndexVars2;\n};\n\nusing namespace CppAD;\n\ntemplate \nstruct CallbackEvaluator\n{\n\n\tstatic inline constexpr const char *CLRNG = \"cppad\";\n\n\tstd::vector indexVars;\n\tstd::vector indexCons;\n\n\tADFun fun; /// < CppAD tape.\n\tADFun jfun; /// < CppAD tape for Aggregated Jacobian\n\n\t/// Sparsity patterns\n\tsparse_rc> jp;\n\tsparse_rc> hp;\n\n\t/// Workspaces for Jacobian and Hessian calculations\n\tsparse_jac_work jw;\n\tsparse_jac_work hw;\n\n\t/// Temporary vectors for evaluations\n\tvector x;\n\tvector xw;\n\tsparse_rcv, vector> jac;\n\tsparse_rcv, vector> hes;\n\n\tvoid setup()\n\t{\n\t\tfun.optimize();\n\t\tsize_t nx = fun.Domain();\n\t\tsize_t ny = fun.Range();\n\n\t\tvector dom(nx, true);\n\t\tvector rng(ny, true);\n\t\tfun.subgraph_sparsity(dom, rng, false, jp);\n\n\t\tADFun, V> af = fun.base2ad();\n\t\tvector> jaxw(nx + ny);\n\t\tIndependent(jaxw);\n\t\tvector> jax(nx);\n\t\tvector> jaw(ny);\n\t\tvector> jaz(nx);\n\t\tfor (size_t i = 0; i < nx; i++)\n\t\t{\n\t\t\tjax[i] = jaxw[i];\n\t\t}\n\t\tfor (size_t i = 0; i < ny; i++)\n\t\t{\n\t\t\tjaw[i] = jaxw[nx + i];\n\t\t}\n\t\taf.Forward(0, jax);\n\t\tjaz = af.Reverse(1, jaw);\n\t\tjfun.Dependent(jaxw, jaz);\n\t\tjfun.optimize();\n\t\tvector jdom(nx + ny, false);\n\t\tfor (size_t i = 0; i < nx; i++)\n\t\t{\n\t\t\tjdom[i] = true;\n\t\t}\n\t\tvector jrng(nx, true);\n\t\tsparse_rc> hsp;\n\t\tjfun.subgraph_sparsity(jdom, jrng, false, hsp);\n\n\t\tauto &hrow = hsp.row();\n\t\tauto &hcol = hsp.col();\n\t\tfor (size_t k = 0; k < hsp.nnz(); k++)\n\t\t{\n\t\t\tif (hrow[k] <= hcol[k])\n\t\t\t{\n\t\t\t\thp.push_back(hrow[k], hcol[k]);\n\t\t\t}\n\t\t}\n\t\tx.resize(nx);\n\t\txw.resize(nx + ny);\n\t\tjac = sparse_rcv, vector>(jp);\n\t\thes = sparse_rcv, vector>(hp);\n\t}\n\n\tbool is_objective() const\n\t{\n\t\treturn indexCons.empty();\n\t}\n\n\tvoid eval_fun(const V *req_x, V *res_y)\n\t{\n\t\tcopy(fun.Domain(), req_x, indexVars.data(), x.data());\n\t\tauto y = fun.Forward(0, x);\n\t\tint mode = is_objective() ? 2 : 0;\n\t\tcopy(fun.Range(), y.data(), (const I *)nullptr, res_y, mode);\n\t}\n\n\tvoid eval_jac(const V *req_x, V *res_jac)\n\t{\n\t\tcopy(fun.Domain(), req_x, indexVars.data(), x.data());\n\t\tfun.sparse_jac_rev(x, jac, jp, CLRNG, jw);\n\t\tcopy(jac.nnz(), jac.val().data(), (const I *)nullptr, res_jac);\n\t}\n\n\tvoid eval_hess(const V *req_x, const V *req_w, V *res_hess)\n\t{\n\t\tcopy(fun.Domain(), req_x, indexVars.data(), xw.data());\n\t\tint mode = is_objective() ? 1 : 0;\n\t\tcopy(fun.Range(), req_w, indexCons.data(), xw.data() + fun.Domain(), mode);\n\t\tjfun.sparse_jac_rev(xw, hes, hp, CLRNG, hw);\n\t\tcopy(hes.nnz(), hes.val().data(), (const I *)nullptr, res_hess);\n\t}\n\n\tCallbackPattern get_callback_pattern() const\n\t{\n\t\tCallbackPattern p;\n\t\tp.indexCons = indexCons;\n\n\t\tauto &jrow = jp.row();\n\t\tauto &jcol = jp.col();\n\t\tif (indexCons.empty())\n\t\t{\n\t\t\tfor (size_t k = 0; k < jp.nnz(); k++)\n\t\t\t{\n\t\t\t\tp.objGradIndexVars.push_back(indexVars[jcol[k]]);\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\tfor (size_t k = 0; k < jp.nnz(); k++)\n\t\t\t{\n\t\t\t\tp.jacIndexCons.push_back(indexCons[jrow[k]]);\n\t\t\t\tp.jacIndexVars.push_back(indexVars[jcol[k]]);\n\t\t\t}\n\t\t}\n\n\t\tauto &hrow = hp.row();\n\t\tauto &hcol = hp.col();\n\t\tfor (size_t k = 0; k < hp.nnz(); k++)\n\t\t{\n\t\t\tp.hessIndexVars1.push_back(indexVars[hrow[k]]);\n\t\t\tp.hessIndexVars2.push_back(indexVars[hcol[k]]);\n\t\t}\n\n\t\treturn p;\n\t}\n\n private:\n\t// Copy mode:\n\t// - 0: normal copy\n\t// - 1: duplicate (copy first element of src to all elements of dst)\n\t// - 2: aggregate (sum all elements of src and copy to all elements of dst)\n\tstatic void copy(const size_t n, const V *src, const I *idx, V *dst, int mode = 0)\n\t{\n\t\tif (mode == 1)\n\t\t{\n\t\t\tfor (size_t i = 0; i < n; i++)\n\t\t\t{\n\t\t\t\tdst[i] = src[0];\n\t\t\t}\n\t\t}\n\t\telse if (mode == 2)\n\t\t{\n\t\t\tif (n == 0)\n\t\t\t{\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tdst[0] = src[0];\n\t\t\tfor (size_t i = 1; i < n; i++)\n\t\t\t{\n\t\t\t\tdst[0] += src[i];\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\tif (idx == nullptr)\n\t\t\t{\n\t\t\t\tfor (size_t i = 0; i < n; i++)\n\t\t\t\t{\n\t\t\t\t\tdst[i] = src[i];\n\t\t\t\t}\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tfor (size_t i = 0; i < n; i++)\n\t\t\t\t{\n\t\t\t\t\tdst[i] = src[idx[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n};\n\ninline bool is_name_empty(const char *name)\n{\n\treturn name == nullptr || name[0] == '\\0';\n}\n\ninline int knitro_var_type(VariableDomain domain)\n{\n\tswitch (domain)\n\t{\n\tcase VariableDomain::Continuous:\n\t\treturn KN_VARTYPE_CONTINUOUS;\n\tcase VariableDomain::Integer:\n\t\treturn KN_VARTYPE_INTEGER;\n\tcase VariableDomain::Binary:\n\t\treturn KN_VARTYPE_BINARY;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown variable domain\");\n\t}\n}\n\ninline VariableDomain knitro_variable_domain(int var_type)\n{\n\tswitch (var_type)\n\t{\n\tcase KN_VARTYPE_CONTINUOUS:\n\t\treturn VariableDomain::Continuous;\n\tcase KN_VARTYPE_INTEGER:\n\t\treturn VariableDomain::Integer;\n\tcase KN_VARTYPE_BINARY:\n\t\treturn VariableDomain::Binary;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown variable type\");\n\t}\n}\n\ninline int knitro_obj_goal(ObjectiveSense sense)\n{\n\tswitch (sense)\n\t{\n\tcase ObjectiveSense::Minimize:\n\t\treturn KN_OBJGOAL_MINIMIZE;\n\tcase ObjectiveSense::Maximize:\n\t\treturn KN_OBJGOAL_MAXIMIZE;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown objective sense\");\n\t}\n}\n\ninline ObjectiveSense knitro_obj_sense(int goal)\n{\n\tswitch (goal)\n\t{\n\tcase KN_OBJGOAL_MINIMIZE:\n\t\treturn ObjectiveSense::Minimize;\n\tcase KN_OBJGOAL_MAXIMIZE:\n\t\treturn ObjectiveSense::Maximize;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown objective goal\");\n\t}\n}\n\ninline void knitro_throw(int error)\n{\n\tif (error != 0)\n\t{\n\t\tthrow std::runtime_error(fmt::format(\"KNITRO error code: {}\", error));\n\t}\n}\n\nclass KNITROEnv\n{\n public:\n\tKNITROEnv(bool empty = false);\n\n\tKNITROEnv(const KNITROEnv &) = delete;\n\tKNITROEnv &operator=(const KNITROEnv &) = delete;\n\n\tKNITROEnv(KNITROEnv &&) = default;\n\tKNITROEnv &operator=(KNITROEnv &&) = default;\n\n\tvoid start();\n\tbool empty() const;\n\tstd::shared_ptr get_lm() const;\n\tvoid close();\n\n private:\n\tvoid _check_error(int code) const;\n\tstd::shared_ptr m_lm = nullptr;\n};\n\nclass KNITROModel : public OnesideLinearConstraintMixin,\n public TwosideLinearConstraintMixin,\n public OnesideQuadraticConstraintMixin,\n public TwosideQuadraticConstraintMixin,\n public TwosideNLConstraintMixin,\n public LinearObjectiveMixin,\n public PPrintMixin,\n public GetValueMixin\n{\n public:\n\t// Constructor/Init/Close\n\tKNITROModel();\n\tKNITROModel(const KNITROEnv &env);\n\n\tKNITROModel(const KNITROModel &) = delete;\n\tKNITROModel &operator=(const KNITROModel &) = delete;\n\n\tKNITROModel(KNITROModel &&) = default;\n\tKNITROModel &operator=(KNITROModel &&) = default;\n\n\tvoid init();\n\tvoid init(const KNITROEnv &env);\n\tvoid close();\n\n\t// Model information\n\tdouble get_infinity() const;\n\tstd::string get_solver_name() const;\n\tstd::string get_release() const;\n\n\t// Variable functions\n\tVariableIndex add_variable(VariableDomain domain = VariableDomain::Continuous,\n\t double lb = -KN_INFINITY, double ub = KN_INFINITY,\n\t const char *name = nullptr);\n\tvoid delete_variable(const VariableIndex &variable);\n\tdouble get_variable_lb(const VariableIndex &variable) const;\n\tdouble get_variable_ub(const VariableIndex &variable) const;\n\tvoid set_variable_lb(const VariableIndex &variable, double lb);\n\tvoid set_variable_ub(const VariableIndex &variable, double ub);\n\tvoid set_variable_bounds(const VariableIndex &variable, double lb, double ub);\n\tdouble get_variable_value(const VariableIndex &variable) const;\n\tvoid set_variable_start(const VariableIndex &variable, double start);\n\tstd::string get_variable_name(const VariableIndex &variable) const;\n\tvoid set_variable_name(const VariableIndex &variable, const std::string &name);\n\tvoid set_variable_domain(const VariableIndex &variable, VariableDomain domain);\n\tVariableDomain get_variable_domain(const VariableIndex &variable) const;\n\tdouble get_variable_rc(const VariableIndex &variable) const;\n\tstd::string pprint_variable(const VariableIndex &variable) const;\n\n\t// Constraint functions\n\tConstraintIndex add_linear_constraint(const ScalarAffineFunction &f, ConstraintSense sense,\n\t double rhs, const char *name = nullptr);\n\tConstraintIndex add_linear_constraint(const ScalarAffineFunction &f,\n\t const std::tuple &interval,\n\t const char *name = nullptr);\n\tConstraintIndex add_quadratic_constraint(const ScalarQuadraticFunction &f,\n\t ConstraintSense sense, double rhs,\n\t const char *name = nullptr);\n\tConstraintIndex add_quadratic_constraint(const ScalarQuadraticFunction &f,\n\t const std::tuple &interval,\n\t const char *name = nullptr);\n\tConstraintIndex add_second_order_cone_constraint(const Vector &variables,\n\t const char *name, bool rotated);\n\tConstraintIndex add_single_nl_constraint(ExpressionGraph &graph, const ExpressionHandle &result,\n\t const std::tuple &interval,\n\t const char *name = nullptr);\n\tConstraintIndex add_single_nl_constraint_sense_rhs(ExpressionGraph &graph,\n\t const ExpressionHandle &result,\n\t ConstraintSense sense, double rhs,\n\t const char *name = nullptr);\n\tvoid delete_constraint(const ConstraintIndex &constraint);\n\tvoid set_constraint_name(const ConstraintIndex &constraint, const std::string &name);\n\tstd::string get_constraint_name(const ConstraintIndex &constraint) const;\n\tdouble get_constraint_primal(const ConstraintIndex &constraint) const;\n\tdouble get_constraint_dual(const ConstraintIndex &constraint) const;\n\tvoid set_normalized_rhs(const ConstraintIndex &constraint, double rhs);\n\tdouble get_normalized_rhs(const ConstraintIndex &constraint) const;\n\tvoid set_normalized_coefficient(const ConstraintIndex &constraint,\n\t const VariableIndex &variable, double coefficient);\n\n\t// Objective functions\n\tvoid set_objective(const ScalarAffineFunction &f, ObjectiveSense sense);\n\tvoid set_objective(const ScalarQuadraticFunction &f, ObjectiveSense sense);\n\tvoid set_objective(const ExprBuilder &expr, ObjectiveSense sense);\n\tvoid add_single_nl_objective(ExpressionGraph &graph, const ExpressionHandle &result);\n\tdouble get_obj_value() const;\n\tvoid set_obj_sense(ObjectiveSense sense);\n\tObjectiveSense get_obj_sense() const;\n\tvoid set_objective_coefficient(const VariableIndex &variable, double coefficient);\n\n\t// Solve functions\n\tvoid optimize();\n\n\t// Solve information\n\tsize_t get_number_iterations() const;\n\tsize_t get_mip_node_count() const;\n\tdouble get_obj_bound() const;\n\tdouble get_mip_relative_gap() const;\n\tdouble get_solve_time() const;\n\n\t// Model state\n\tbool dirty() const;\n\tbool empty() const;\n\n\t// Solve status\n\tint get_solve_status() const;\n\n\t// Parameter management\n\ttemplate \n\tvoid set_raw_parameter(const std::string &name, T value)\n\t{\n\t\tint param_id = _get_value(knitro::KN_get_param_id, name.c_str());\n\t\tset_raw_parameter(param_id, value);\n\t}\n\n\ttemplate \n\tvoid set_raw_parameter(int param_id, T value)\n\t{\n\t\tif constexpr (std::is_same_v)\n\t\t{\n\t\t\t_set_value(knitro::KN_set_int_param, param_id, value);\n\t\t}\n\t\telse if constexpr (std::is_same_v)\n\t\t{\n\t\t\t_set_value(knitro::KN_set_double_param, param_id, value);\n\t\t}\n\t\telse if constexpr (std::is_same_v || std::is_same_v)\n\t\t{\n\t\t\tif constexpr (std::is_same_v)\n\t\t\t{\n\t\t\t\t_set_value(knitro::KN_set_char_param, param_id, value.c_str());\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\t_set_value(knitro::KN_set_char_param, param_id, value);\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\tstatic_assert(std::is_same_v || std::is_same_v ||\n\t\t\t std::is_same_v || std::is_same_v,\n\t\t\t \"T must be int, double, std::string, or const char*\");\n\t\t}\n\t}\n\n\ttemplate \n\tT get_raw_parameter(const std::string &name)\n\t{\n\t\tint param_id = _get_value(knitro::KN_get_param_id, name.c_str());\n\t\treturn get_raw_parameter(param_id);\n\t}\n\n\ttemplate \n\tT get_raw_parameter(int param_id)\n\t{\n\t\tif constexpr (std::is_same_v)\n\t\t{\n\t\t\treturn _get_value(knitro::KN_get_int_param, param_id);\n\t\t}\n\t\telse if constexpr (std::is_same_v)\n\t\t{\n\t\t\treturn _get_value(knitro::KN_get_double_param, param_id);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tstatic_assert(std::is_same_v || std::is_same_v,\n\t\t\t \"T must be int or double for get_raw_parameter\");\n\t\t}\n\t}\n\n\t// Internal helpers\n\tvoid _check_error(int error) const;\n\tvoid _mark_dirty();\n\tvoid _unmark_dirty();\n\tvoid _check_dirty() const;\n\tKNINT _variable_index(const VariableIndex &variable) const;\n\tKNINT _constraint_index(const ConstraintIndex &constraint) const;\n\n\tsize_t get_num_vars() const;\n\tsize_t get_num_cons(std::optional type = std::nullopt) const;\n\n private:\n\t// Member variables\n\tsize_t m_n_vars = 0;\n\tstd::unordered_map m_n_cons_map;\n\tstd::shared_ptr m_lm = nullptr;\n\tstd::unique_ptr m_kc = nullptr;\n\n\tstd::unordered_map>> m_soc_aux_cons;\n\tstd::unordered_map m_con_sense_flags;\n\tuint8_t m_obj_flag = 0;\n\n\tstruct Outputs\n\t{\n\t\tstd::vector objective_outputs;\n\t\tstd::vector constraint_outputs;\n\t\tstd::vector constraints;\n\t};\n\n\tusing Evaluator = CallbackEvaluator;\n\n\tstd::unordered_map m_pending_outputs;\n\tstd::vector> m_evaluators;\n\tbool m_has_pending_callbacks = false;\n\tint m_solve_status = 0;\n\tbool m_is_dirty = true;\n\n private:\n\tvoid _init();\n\tvoid _reset_state();\n\tstd::tuple _sense_to_interval(ConstraintSense sense, double rhs);\n\tvoid _update_con_sense_flags(const ConstraintIndex &constraint, ConstraintSense sense);\n\n\tvoid _set_linear_constraint(const ConstraintIndex &constraint, const ScalarAffineFunction &f);\n\tvoid _set_quadratic_constraint(const ConstraintIndex &constraint,\n\t const ScalarQuadraticFunction &f);\n\tvoid _set_second_order_cone_constraint(const ConstraintIndex &constraint,\n\t const Vector &variables);\n\tvoid _set_second_order_cone_constraint_rotated(const ConstraintIndex &constraint,\n\t const Vector &variables);\n\tvoid _set_linear_objective(const ScalarAffineFunction &f);\n\tvoid _set_quadratic_objective(const ScalarQuadraticFunction &f);\n\tvoid _reset_objective();\n\tvoid _add_graph(ExpressionGraph &graph);\n\tvoid _add_pending_callbacks();\n\tvoid _add_callbacks(const ExpressionGraph &graph, const Outputs &outputs);\n\tvoid _add_callback(const ExpressionGraph &graph, const std::vector &outputs,\n\t const std::vector &constraints);\n\tvoid _register_callback(Evaluator *evaluator);\n\tvoid _update();\n\tvoid _pre_solve();\n\tvoid _solve();\n\tvoid _post_solve();\n\n\ttemplate \n\tConstraintIndex _add_constraint_impl(ConstraintType type,\n\t const std::tuple &interval,\n\t const char *name, const F &setter)\n\t{\n\t\tKNINT indexCon;\n\t\tint error = knitro::KN_add_con(m_kc.get(), &indexCon);\n\t\t_check_error(error);\n\n\t\tIndexT index = indexCon;\n\t\tConstraintIndex constraint(type, index);\n\n\t\tdouble lb = std::get<0>(interval);\n\t\tdouble ub = std::get<1>(interval);\n\n\t\terror = knitro::KN_set_con_lobnd(m_kc.get(), indexCon, lb);\n\t\t_check_error(error);\n\t\terror = knitro::KN_set_con_upbnd(m_kc.get(), indexCon, ub);\n\t\t_check_error(error);\n\n\t\tsetter(constraint);\n\n\t\tif (!is_name_empty(name))\n\t\t{\n\t\t\terror = knitro::KN_set_con_name(m_kc.get(), indexCon, name);\n\t\t\t_check_error(error);\n\t\t}\n\n\t\tm_con_sense_flags[indexCon] = CON_UPBND;\n\n\t\tauto it = m_n_cons_map.find(type);\n\t\tif (it != m_n_cons_map.end())\n\t\t{\n\t\t\tit->second++;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tm_n_cons_map[type] = 1;\n\t\t}\n\n\t\tm_is_dirty = true;\n\n\t\treturn constraint;\n\t}\n\n\ttemplate \n\tConstraintIndex _add_constraint_with_sense(const S &function, ConstraintSense sense, double rhs,\n\t const char *name, const F &add)\n\t{\n\t\tauto interval = _sense_to_interval(sense, rhs);\n\t\tauto constraint = add(function, interval, name);\n\t\t_update_con_sense_flags(constraint, sense);\n\t\treturn constraint;\n\t}\n\n\ttemplate \n\tvoid _set_objective_impl(ObjectiveSense sense, const F &setter)\n\t{\n\t\t_reset_objective();\n\t\tsetter();\n\t\tset_obj_sense(sense);\n\t\tm_is_dirty = true;\n\t}\n\n\ttemplate \n\tusing Getter = std::function;\n\ttemplate \n\tusing Setter = std::function;\n\n\ttemplate \n\tV _get_value(Getter get) const\n\t{\n\t\tV value;\n\t\tint error = get(m_kc.get(), &value);\n\t\t_check_error(error);\n\t\treturn value;\n\t}\n\n\ttemplate \n\tvoid _set_value(Setter set, V value)\n\t{\n\t\tint error = set(m_kc.get(), value);\n\t\t_check_error(error);\n\t}\n\n\ttemplate \n\tusing GetterMap = std::function;\n\ttemplate \n\tusing SetterMap = std::function;\n\n\ttemplate \n\tV _get_value(GetterMap get, K key) const\n\t{\n\t\tV value;\n\t\tint error = get(m_kc.get(), key, &value);\n\t\t_check_error(error);\n\t\treturn value;\n\t}\n\n\ttemplate \n\tvoid _set_value(SetterMap set, K key, V value)\n\t{\n\t\tint error = set(m_kc.get(), key, value);\n\t\t_check_error(error);\n\t}\n\n\ttemplate \n\tstd::string _get_name(F get, K key, const char *prefix) const\n\t{\n\t\tchar name[1024];\n\t\tname[0] = '\\0';\n\t\tint error = get(m_kc.get(), key, 1024, name);\n\t\t_check_error(error);\n\n\t\tif (name[0] != '\\0')\n\t\t{\n\t\t\treturn std::string(name);\n\t\t}\n\t\telse\n\t\t{\n\t\t\treturn fmt::format(\"{}{}\", prefix, key);\n\t\t}\n\t}\n\n\ttemplate \n\tKNINT _get_index(const I &index) const\n\t{\n\t\treturn index.index;\n\t}\n};\n" }, { "path": "include/pyoptinterface/mosek_model.hpp", "content": "#pragma once\n\n#include \n\n#ifdef _MSC_VER\n#include \"solvers/mosek/mosek_win.h\"\n#else\n#include \"solvers/mosek/mosek_linux.h\"\n#endif\n\n#include \"pyoptinterface/core.hpp\"\n#include \"pyoptinterface/container.hpp\"\n#include \"pyoptinterface/solver_common.hpp\"\n#include \"pyoptinterface/dylib.hpp\"\n\n#define APILIST \\\n\tB(MSK_getcodedesc); \\\n\tB(MSK_makeemptytask); \\\n\tB(MSK_deletetask); \\\n\tB(MSK_writedata); \\\n\tB(MSK_writesolution); \\\n\tB(MSK_appendvars); \\\n\tB(MSK_getnumvar); \\\n\tB(MSK_putvartype); \\\n\tB(MSK_putvarbound); \\\n\tB(MSK_putvarname); \\\n\tB(MSK_removevars); \\\n\tB(MSK_getxxslice); \\\n\tB(MSK_appendcons); \\\n\tB(MSK_getnumcon); \\\n\tB(MSK_putarow); \\\n\tB(MSK_putconbound); \\\n\tB(MSK_putconname); \\\n\tB(MSK_putqconk); \\\n\tB(MSK_getnumafe); \\\n\tB(MSK_appendafes); \\\n\tB(MSK_putafefentrylist); \\\n\tB(MSK_appendquadraticconedomain); \\\n\tB(MSK_appendrquadraticconedomain); \\\n\tB(MSK_appendprimalexpconedomain); \\\n\tB(MSK_appenddualexpconedomain); \\\n\tB(MSK_appendacc); \\\n\tB(MSK_putaccname); \\\n\tB(MSK_getaccn); \\\n\tB(MSK_getaccafeidxlist); \\\n\tB(MSK_appendrdomain); \\\n\tB(MSK_putacc); \\\n\tB(MSK_removecons); \\\n\tB(MSK_putqobj); \\\n\tB(MSK_putcslice); \\\n\tB(MSK_putcfix); \\\n\tB(MSK_optimize); \\\n\tB(MSK_whichparam); \\\n\tB(MSK_putnaintparam); \\\n\tB(MSK_putnadouparam); \\\n\tB(MSK_putnastrparam); \\\n\tB(MSK_getnaintparam); \\\n\tB(MSK_getnadouparam); \\\n\tB(MSK_getnastrparam); \\\n\tB(MSK_getnaintinf); \\\n\tB(MSK_getnadouinf); \\\n\tB(MSK_getprosta); \\\n\tB(MSK_getsolsta); \\\n\tB(MSK_getprimalobj); \\\n\tB(MSK_getdualobj); \\\n\tB(MSK_linkfunctotaskstream); \\\n\tB(MSK_getvarname); \\\n\tB(MSK_getvartype); \\\n\tB(MSK_getvarbound); \\\n\tB(MSK_putxxslice); \\\n\tB(MSK_getxcslice); \\\n\tB(MSK_getyslice); \\\n\tB(MSK_getslxslice); \\\n\tB(MSK_getsuxslice); \\\n\tB(MSK_getconnamelen); \\\n\tB(MSK_getconname); \\\n\tB(MSK_getobjsense); \\\n\tB(MSK_putobjsense); \\\n\tB(MSK_getconbound); \\\n\tB(MSK_getaij); \\\n\tB(MSK_putaij); \\\n\tB(MSK_getcj); \\\n\tB(MSK_putcj); \\\n\tB(MSK_getversion); \\\n\tB(MSK_solutiondef); \\\n\tB(MSK_makeenv); \\\n\tB(MSK_deleteenv); \\\n\tB(MSK_putlicensecode);\n\nnamespace mosek\n{\n#define B(f) extern decltype(&::f) f\n\nAPILIST\n\n#undef B\n\nbool is_library_loaded();\n\nbool load_library(const std::string &path);\n} // namespace mosek\n\nclass MOSEKEnv\n{\n public:\n\tMOSEKEnv();\n\t~MOSEKEnv();\n\tvoid close();\n\n\tvoid putlicensecode(const std::vector &code);\n\n private:\n\tMSKenv_t m_env;\n\n\tfriend class MOSEKModel;\n};\n\nstruct MOSEKfreemodelT\n{\n\tvoid operator()(MSKtask *model) const\n\t{\n\t\tmosek::MSK_deletetask(&model);\n\t};\n};\n\nusing MOSEKLoggingCallback = std::function;\n\nstruct MOSEKLoggingCallbackUserdata\n{\n\tMOSEKLoggingCallback callback;\n};\n\nclass MOSEKModel : public OnesideLinearConstraintMixin,\n public TwosideLinearConstraintMixin,\n public OnesideQuadraticConstraintMixin,\n public LinearObjectiveMixin,\n public PPrintMixin,\n public GetValueMixin\n{\n public:\n\tbool m_is_dirty = true;\n\tMOSEKModel() = default;\n\tMOSEKModel(const MOSEKEnv &env);\n\tvoid init(const MOSEKEnv &env);\n\tvoid close();\n\n\tvoid write(const std::string &filename);\n\n\tVariableIndex add_variable(VariableDomain domain = VariableDomain::Continuous,\n\t double lb = -MSK_INFINITY, double ub = MSK_INFINITY,\n\t const char *name = nullptr);\n\t/*VariableIndex add_variables(int N, VariableDomain domain = VariableDomain::Continuous,\n\t double lb = -MSK_INFINITY, double ub = MSK_INFINITY);*/\n\tvoid delete_variable(const VariableIndex &variable);\n\tvoid delete_variables(const Vector &variables);\n\tbool is_variable_active(const VariableIndex &variable);\n\tdouble get_variable_value(const VariableIndex &variable);\n\tstd::string pprint_variable(const VariableIndex &variable);\n\tvoid set_variable_bounds(const VariableIndex &variable, double lb, double ub);\n\n\tConstraintIndex add_linear_constraint(const ScalarAffineFunction &function,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr);\n\tConstraintIndex add_linear_constraint(const ScalarAffineFunction &function,\n\t const std::tuple &interval,\n\t const char *name = nullptr);\n\tConstraintIndex add_quadratic_constraint(const ScalarQuadraticFunction &function,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr);\n\n\tstd::vector add_variables_as_afe(const Vector &variables);\n\tConstraintIndex add_variables_in_cone_constraint(const Vector &variables,\n\t MSKint64t domain_index, ConstraintType type,\n\t const char *name);\n\n\tConstraintIndex add_second_order_cone_constraint(const Vector &variables,\n\t const char *name, bool rotated = false);\n\n\tConstraintIndex add_exp_cone_constraint(const Vector &variables,\n\t const char *name, bool dual = false);\n\n\tvoid delete_constraint(const ConstraintIndex &constraint);\n\tbool is_constraint_active(const ConstraintIndex &constraint);\n\n\tvoid _set_affine_objective(const ScalarAffineFunction &function, ObjectiveSense sense,\n\t bool clear_quadratic);\n\tvoid set_objective(const ScalarAffineFunction &function, ObjectiveSense sense);\n\tvoid set_objective(const ScalarQuadraticFunction &function, ObjectiveSense sense);\n\tvoid set_objective(const ExprBuilder &function, ObjectiveSense sense);\n\n\tint optimize();\n\tvoid *get_raw_model();\n\tstd::string version_string();\n\n\t// solution\n\tMSKsoltypee get_current_solution();\n\tstd::optional select_available_solution_after_optimization();\n\n\t// parameter\n\tint raw_parameter_type(const char *name);\n\n\tvoid set_raw_parameter_int(const char *param_name, int value);\n\tvoid set_raw_parameter_double(const char *param_name, double value);\n\tvoid set_raw_parameter_string(const char *param_name, const char *value);\n\tint get_raw_parameter_int(const char *param_name);\n\tdouble get_raw_parameter_double(const char *param_name);\n\tstd::string get_raw_parameter_string(const char *param_name);\n\n\t// information\n\tint get_raw_information_int(const char *attr_name);\n\tdouble get_raw_information_double(const char *attr_name);\n\n\tMSKint32t getnumvar();\n\tMSKint32t getnumcon();\n\tint getprosta();\n\tint getsolsta();\n\tdouble getprimalobj();\n\tdouble getdualobj();\n\n\tvoid disable_log();\n\n\t// Accessing information of problem\n\tstd::string get_variable_name(const VariableIndex &variable);\n\tvoid set_variable_name(const VariableIndex &variable, const char *name);\n\tVariableDomain get_variable_type(const VariableIndex &variable);\n\tvoid set_variable_type(const VariableIndex &variable, VariableDomain domain);\n\tdouble get_variable_lower_bound(const VariableIndex &variable);\n\tdouble get_variable_upper_bound(const VariableIndex &variable);\n\tvoid set_variable_lower_bound(const VariableIndex &variable, double lb);\n\tvoid set_variable_upper_bound(const VariableIndex &variable, double ub);\n\tvoid set_variable_primal(const VariableIndex &variable, double primal);\n\n\t// reduced cost of variable\n\tdouble get_variable_dual(const VariableIndex &variable);\n\n\tdouble get_constraint_primal(const ConstraintIndex &constraint);\n\tdouble get_constraint_dual(const ConstraintIndex &constraint);\n\tstd::string get_constraint_name(const ConstraintIndex &constraint);\n\tvoid set_constraint_name(const ConstraintIndex &constraint, const char *name);\n\n\tObjectiveSense get_obj_sense();\n\tvoid set_obj_sense(ObjectiveSense sense);\n\n\t// Modifications of model\n\t// 1. set/get RHS of a constraint\n\tdouble get_normalized_rhs(const ConstraintIndex &constraint);\n\tvoid set_normalized_rhs(const ConstraintIndex &constraint, double value);\n\t// 2. set/get coefficient of variable in constraint\n\tdouble get_normalized_coefficient(const ConstraintIndex &constraint,\n\t const VariableIndex &variable);\n\tvoid set_normalized_coefficient(const ConstraintIndex &constraint,\n\t const VariableIndex &variable, double value);\n\t// 3. set/get linear coefficient of variable in objective\n\tdouble get_objective_coefficient(const VariableIndex &variable);\n\tvoid set_objective_coefficient(const VariableIndex &variable, double value);\n\n\tMSKint32t _variable_index(const VariableIndex &variable);\n\tMSKint32t _checked_variable_index(const VariableIndex &variable);\n\tMSKint32t _constraint_index(const ConstraintIndex &constraint);\n\tMSKint32t _checked_constraint_index(const ConstraintIndex &constraint);\n\n\t// Control logging\n\tvoid set_logging(const MOSEKLoggingCallback &callback);\n\n\tMOSEKLoggingCallbackUserdata m_logging_callback_userdata;\n\n private:\n\tMonotoneIndexer m_variable_index;\n\n\tMonotoneIndexer m_linear_quadratic_constraint_index;\n\n\t// ACC cannot be removed from the model, so we just keeps track of the state whether it is\n\t// deleted If a constraint is deleted, we will not remove it from the model, but just mark it as\n\t// deleted and set the domain to R^n (i.e. no constraint)\n\tstd::vector m_acc_index;\n\n\t// Mosek does not discriminate between integer variable and binary variable\n\t// So we need to keep track of binary variables\n\tHashset binary_variables;\n\n\t// Cache current available solution after optimization\n\tstd::optional m_soltype;\n\n\t/* MOSEK part */\n\tstd::unique_ptr m_model;\n};\n" }, { "path": "include/pyoptinterface/nleval.hpp", "content": "#pragma once\n\n#include \n#include \n\n#include \"pyoptinterface/core.hpp\"\n#include \"pyoptinterface/nlexpr.hpp\"\n\nenum class HessianSparsityType\n{\n\tUpper,\n\tLower\n};\n\nstruct AutodiffSymbolicStructure\n{\n\tsize_t nx = 0, np = 0, ny = 0;\n\n\tstd::vector m_jacobian_rows, m_jacobian_cols;\n\tsize_t m_jacobian_nnz = 0;\n\tstd::vector m_hessian_rows, m_hessian_cols;\n\tsize_t m_hessian_nnz = 0;\n\n\tbool has_parameter = false;\n\tbool has_jacobian = false;\n\tbool has_hessian = false;\n};\n\n// define the jit-compiled function pointer\nusing f_funcptr = void (*)(const double *x, const double *p, double *y, const int *xi);\nusing jacobian_funcptr = void (*)(const double *x, const double *p, double *jacobian,\n const int *xi);\nusing additive_grad_funcptr = void (*)(const double *x, const double *p, double *grad,\n const int *xi, const int *gradi);\nusing hessian_funcptr = void (*)(const double *x, const double *p, const double *w, double *hessian,\n const int *xi, const int *hessiani);\n\n// no parameter version\nusing f_funcptr_noparam = void (*)(const double *x, double *y, const int *xi);\nusing jacobian_funcptr_noparam = void (*)(const double *x, double *jacobian, const int *xi);\nusing additive_grad_funcptr_noparam = void (*)(const double *x, double *grad, const int *xi,\n const int *gradi);\nusing hessian_funcptr_noparam = void (*)(const double *x, const double *w, double *hessian,\n const int *xi, const int *hessiani);\n\nstruct ConstraintAutodiffEvaluator\n{\n\tunion {\n\t\tf_funcptr p = nullptr;\n\t\tf_funcptr_noparam nop;\n\t} f_eval;\n\tunion {\n\t\tjacobian_funcptr p = nullptr;\n\t\tjacobian_funcptr_noparam nop;\n\t} jacobian_eval;\n\tunion {\n\t\thessian_funcptr p = nullptr;\n\t\thessian_funcptr_noparam nop;\n\t} hessian_eval;\n\n\tConstraintAutodiffEvaluator() = default;\n\n\tConstraintAutodiffEvaluator(bool has_parameter, uintptr_t fp, uintptr_t jp, uintptr_t hp);\n};\n\nstruct ObjectiveAutodiffEvaluator\n{\n\tunion {\n\t\tf_funcptr p = nullptr;\n\t\tf_funcptr_noparam nop;\n\t} f_eval;\n\tunion {\n\t\tadditive_grad_funcptr p = nullptr;\n\t\tadditive_grad_funcptr_noparam nop;\n\t} grad_eval;\n\tunion {\n\t\thessian_funcptr p = nullptr;\n\t\thessian_funcptr_noparam nop;\n\t} hessian_eval;\n\n\tObjectiveAutodiffEvaluator() = default;\n\n\tObjectiveAutodiffEvaluator(bool has_parameter, uintptr_t fp, uintptr_t ajp, uintptr_t hp);\n};\n\n#define restrict __restrict\n\nstruct LinearEvaluator\n{\n\tint n_constraints = 0;\n\n\tstd::vector coefs;\n\tstd::vector indices;\n\n\tstd::vector constant_values;\n\tstd::vector constant_indices;\n\n\tstd::vector constraint_intervals = {0};\n\n\tvoid add_row(const ScalarAffineFunction &f);\n\n\tvoid eval_function(const double *restrict x, double *restrict f);\n\tvoid analyze_jacobian_structure(size_t &global_jacobian_nnz,\n\t std::vector &global_jacobian_rows,\n\t std::vector &global_jacobian_cols) const;\n\tvoid eval_jacobian(const double *restrict x, double *restrict jacobian) const;\n};\n\nstruct QuadraticEvaluator\n{\n\tint n_constraints = 0;\n\n\tstd::vector diag_coefs;\n\tstd::vector diag_indices;\n\tstd::vector diag_intervals = {0};\n\n\tstd::vector offdiag_coefs;\n\tstd::vector offdiag_rows;\n\tstd::vector offdiag_cols;\n\tstd::vector offdiag_intervals = {0};\n\n\tstd::vector linear_coefs;\n\tstd::vector linear_indices;\n\tstd::vector linear_intervals = {0};\n\n\tstd::vector linear_constant_values;\n\tstd::vector linear_constant_indices;\n\n\tint jacobian_nnz = 0;\n\n\t// This is the constant part\n\t// jacobian_constant.size() = jacobian_nnz\n\tstd::vector jacobian_constant;\n\tstd::vector jacobian_variable_indices;\n\tstd::vector jacobian_constraint_intervals = {0};\n\t// jacobian_diag_indices.size() = diag_indices.size()\n\tstd::vector jacobian_diag_indices;\n\t// jacobian_offdiag_row_indices.size() = offdiag_rows.size()\n\tstd::vector jacobian_offdiag_row_indices;\n\tstd::vector jacobian_offdiag_col_indices;\n\n\t// Hessian\n\t// = diag_coefs.size()\n\tstd::vector hessian_diag_indices;\n\t// = offdiag_coefs.size()\n\tstd::vector hessian_offdiag_indices;\n\n\tvoid add_row(const ScalarQuadraticFunction &f);\n\n\tvoid eval_function(const double *restrict x, double *restrict f) const;\n\tvoid analyze_jacobian_structure(size_t row_base, size_t &global_jacobian_nnz,\n\t std::vector &global_jacobian_rows,\n\t std::vector &global_jacobian_cols) const;\n\tvoid eval_jacobian(const double *restrict x, double *restrict jacobian) const;\n\tvoid analyze_hessian_structure(size_t &global_hessian_nnz,\n\t std::vector &global_hessian_rows,\n\t std::vector &global_hessian_cols,\n\t Hashmap, int> &hessian_index_map,\n\t HessianSparsityType hessian_type);\n\tvoid eval_lagrangian_hessian(const double *restrict lambda, double *restrict hessian) const;\n};\n\nstruct NonlinearEvaluator\n{\n\t// How many graph instances are there\n\tsize_t n_graph_instances = 0;\n\t// record the inputs of graph instances\n\tstruct GraphInput\n\t{\n\t\tstd::vector variables;\n\t\tstd::vector constants;\n\t};\n\tstd::vector graph_inputs;\n\t// record graph instances with constraint output and objective output\n\tstruct GraphHash\n\t{\n\t\t// hash of this graph instance\n\t\tuint64_t hash;\n\t\t// index of this graph instance\n\t\tint index;\n\t};\n\tstruct GraphHashes\n\t{\n\t\tstd::vector hashes;\n\t\tsize_t n_hashes_since_last_aggregation = 0;\n\t} constraint_graph_hashes, objective_graph_hashes;\n\n\t// length = n_graph_instances\n\t// record which group this graph instance belongs to\n\tstruct GraphGroupMembership\n\t{\n\t\t// which group it belongs to\n\t\tint group;\n\t\t// the rank in that group\n\t\tint rank;\n\t};\n\tstd::vector constraint_group_memberships, objective_group_memberships;\n\t// record which index of constraint this graph starts\n\tstd::vector constraint_indices_offsets;\n\n\t// graph groups\n\tstruct ConstraintGraphGroup\n\t{\n\t\tstd::vector instance_indices;\n\t\tAutodiffSymbolicStructure autodiff_structure;\n\t\tConstraintAutodiffEvaluator autodiff_evaluator;\n\n\t\t// where to store the hessian matrix\n\t\t// length = instance_indices.size() * hessian_nnz\n\t\tstd::vector hessian_indices;\n\t};\n\tstd::vector constraint_groups;\n\tHashmap hash_to_constraint_group;\n\n\tstruct ObjectiveGraphGroup\n\t{\n\t\tstd::vector instance_indices;\n\t\tAutodiffSymbolicStructure autodiff_structure;\n\t\tObjectiveAutodiffEvaluator autodiff_evaluator;\n\t\t// where to store the gradient vector\n\t\t// length = instance_indices.size() * jacobian_nnz\n\t\tstd::vector gradient_indices;\n\t\t// where to store the hessian matrix\n\t\t// length = instance_indices.size() * hessian_nnz\n\t\tstd::vector hessian_indices;\n\t};\n\tstd::vector objective_groups;\n\tHashmap hash_to_objective_group;\n\n\tint add_graph_instance();\n\tvoid finalize_graph_instance(size_t graph_index, const ExpressionGraph &graph);\n\tint aggregate_constraint_groups();\n\tint get_constraint_group_representative(int group_index) const;\n\tint aggregate_objective_groups();\n\tint get_objective_group_representative(int group_index) const;\n\n\tvoid assign_constraint_group_autodiff_structure(int group_index,\n\t const AutodiffSymbolicStructure &structure);\n\tvoid assign_constraint_group_autodiff_evaluator(int group_index,\n\t const ConstraintAutodiffEvaluator &evaluator);\n\tvoid assign_objective_group_autodiff_structure(int group_index,\n\t const AutodiffSymbolicStructure &structure);\n\tvoid assign_objective_group_autodiff_evaluator(int group_index,\n\t const ObjectiveAutodiffEvaluator &evaluator);\n\n\tvoid calculate_constraint_graph_instances_offset();\n\n\t// functions to evaluate the nonlinear constraints and objectives\n\n\t// f\n\tvoid eval_constraints(const double *restrict x, double *restrict f) const;\n\tdouble eval_objective(const double *restrict x) const;\n\n\t// first order derivative\n\tvoid analyze_constraints_jacobian_structure(size_t row_base, size_t &global_jacobian_nnz,\n\t std::vector &global_jacobian_rows,\n\t std::vector &global_jacobian_cols);\n\tvoid analyze_objective_gradient_structure(std::vector &global_gradient_cols,\n\t Hashmap &sparse_gradient_map);\n\n\tvoid eval_constraints_jacobian(const double *restrict x, double *restrict jacobian) const;\n\tvoid eval_objective_gradient(const double *restrict x, double *restrict grad_f) const;\n\n\t// second order derivative\n\tvoid analyze_constraints_hessian_structure(\n\t size_t &global_hessian_nnz, std::vector &global_hessian_rows,\n\t std::vector &global_hessian_cols,\n\t Hashmap, int> &hessian_index_map, HessianSparsityType hessian_type);\n\tvoid analyze_objective_hessian_structure(size_t &global_hessian_nnz,\n\t std::vector &global_hessian_rows,\n\t std::vector &global_hessian_cols,\n\t Hashmap, int> &hessian_index_map,\n\t HessianSparsityType hessian_type);\n\n\tvoid eval_lagrangian_hessian(const double *restrict x, const double *restrict lambda,\n\t const double sigma, double *restrict hessian) const;\n};" }, { "path": "include/pyoptinterface/nlexpr.hpp", "content": "#pragma once\n\n#include \n#include \n\n#include \"ankerl/unordered_dense.h\"\n#include \"core.hpp\"\n\nusing NodeId = uint32_t;\nusing EntityId = int;\n\nusing VariableNode = EntityId;\nusing ConstantNode = double;\nusing ParameterNode = EntityId;\n\nenum class ArrayType\n{\n\tConstant,\n\tVariable,\n\tParameter,\n\tUnary,\n\tBinary,\n\tTernary,\n\tNary\n};\n\nenum class UnaryOperator\n{\n\tNeg,\n\tSin,\n\tCos,\n\tTan,\n\tAsin,\n\tAcos,\n\tAtan,\n\tAbs,\n\tSqrt,\n\tExp,\n\tLog,\n\tLog10\n};\n\nenum class BinaryOperator\n{\n\tSub,\n\tDiv,\n\tPow,\n\n\t// compare\n\tLessThan,\n\tLessEqual,\n\tEqual,\n\tNotEqual,\n\tGreaterEqual,\n\tGreaterThan,\n\n\t// Compatibility issue where some solvers only accepts two-arg multiplication\n\tAdd2,\n\tMul2\n};\n\nbool is_binary_compare_op(BinaryOperator op);\n\nenum class TernaryOperator\n{\n\tIfThenElse,\n};\n\nenum class NaryOperator\n{\n\tAdd,\n\tMul,\n};\n\nstd::string unary_operator_to_string(UnaryOperator op);\nstd::string binary_operator_to_string(BinaryOperator op);\nstd::string ternary_operator_to_string(TernaryOperator op);\nstd::string nary_operator_to_string(NaryOperator op);\n\nstruct ExpressionHandle\n{\n\tArrayType array;\n\tNodeId id;\n\n\tbool operator==(const ExpressionHandle &x) const;\n\n\tExpressionHandle() = default;\n\tExpressionHandle(ArrayType array, NodeId id) : array(array), id(id)\n\t{\n\t}\n\n\tstd::string to_string() const;\n};\n\ntemplate <>\nstruct ankerl::unordered_dense::hash\n{\n\tusing is_avalanching = void;\n\n\t[[nodiscard]] auto operator()(ExpressionHandle const &x) const noexcept -> uint64_t\n\t{\n\t\tstatic_assert(std::has_unique_object_representations_v);\n\t\treturn detail::wyhash::hash(&x, sizeof(x));\n\t}\n};\n\nstruct UnaryNode\n{\n\tUnaryOperator op;\n\tExpressionHandle operand;\n\n\tUnaryNode(UnaryOperator op, ExpressionHandle operand) : op(op), operand(operand)\n\t{\n\t}\n};\n\nstruct BinaryNode\n{\n\tBinaryOperator op;\n\tExpressionHandle left;\n\tExpressionHandle right;\n\n\tBinaryNode(BinaryOperator op, ExpressionHandle left, ExpressionHandle right)\n\t : op(op), left(left), right(right)\n\t{\n\t}\n};\n\nstruct TernaryNode\n{\n\tTernaryOperator op;\n\tExpressionHandle left;\n\tExpressionHandle middle;\n\tExpressionHandle right;\n\n\tTernaryNode(TernaryOperator op, ExpressionHandle left, ExpressionHandle middle,\n\t ExpressionHandle right)\n\t : op(op), left(left), middle(middle), right(right)\n\t{\n\t}\n};\n\nstruct NaryNode\n{\n\tNaryOperator op;\n\tstd::vector operands;\n\n\tNaryNode(NaryOperator op, const std::vector &operands)\n\t : op(op), operands(operands)\n\t{\n\t}\n};\n\nstruct ExpressionGraph\n{\n\tHashmap m_variable_index_map;\n\tstd::vector m_variables;\n\tstd::vector m_constants;\n\tstd::vector m_parameters;\n\tstd::vector m_unaries;\n\tstd::vector m_binaries;\n\tstd::vector m_ternaries;\n\tstd::vector m_naries;\n\n\tstd::vector m_constraint_outputs;\n\tstd::vector m_objective_outputs;\n\n\tExpressionGraph() = default;\n\n\tstd::string to_string() const;\n\n\tsize_t n_variables() const;\n\tsize_t n_constants() const;\n\tsize_t n_parameters() const;\n\n\tExpressionHandle add_variable(EntityId id);\n\n\tExpressionHandle add_constant(double value);\n\n\tExpressionHandle add_parameter(EntityId id);\n\n\tExpressionHandle add_unary(UnaryOperator op, ExpressionHandle operand);\n\n\tExpressionHandle add_binary(BinaryOperator op, ExpressionHandle left, ExpressionHandle right);\n\n\tExpressionHandle add_ternary(TernaryOperator op, ExpressionHandle left, ExpressionHandle middle,\n\t ExpressionHandle right);\n\n\tExpressionHandle add_nary(NaryOperator op, const std::vector &operands);\n\tExpressionHandle add_repeat_nary(NaryOperator op, ExpressionHandle operand, int N);\n\n\tvoid append_nary(const ExpressionHandle &expression, const ExpressionHandle &operand);\n\n\tNaryOperator get_nary_operator(const ExpressionHandle &expression) const;\n\n\tvoid add_constraint_output(const ExpressionHandle &expression);\n\tvoid add_objective_output(const ExpressionHandle &expression);\n\tbool has_constraint_output() const;\n\tbool has_objective_output() const;\n\n\t// Merge VariableIndex/ScalarAffineFunction/ScalarQuadraticFunction/ExprBuilder into\n\t// ExpressionGraph\n\tExpressionHandle merge_variableindex(const VariableIndex &v);\n\tExpressionHandle merge_scalaraffinefunction(const ScalarAffineFunction &f);\n\tExpressionHandle merge_scalarquadraticfunction(const ScalarQuadraticFunction &f);\n\tExpressionHandle merge_exprbuilder(const ExprBuilder &expr);\n\n\t// recognize compare expression\n\tbool is_compare_expression(const ExpressionHandle &expr) const;\n\n\t// tag the structure\n\tuint64_t main_structure_hash() const;\n\tuint64_t constraint_structure_hash(uint64_t hash) const;\n\tuint64_t objective_structure_hash(uint64_t hash) const;\n};\n\nvoid unpack_comparison_expression(ExpressionGraph &graph, const ExpressionHandle &expr,\n ExpressionHandle &real_expr, double &lb, double &ub);\n" }, { "path": "include/pyoptinterface/solver_common.hpp", "content": "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \"fmt/format.h\"\n#include \"fmt/ranges.h\"\n#include \"pyoptinterface/core.hpp\"\n\ntemplate \nconcept OnesideLinearConstraintMixinConcept = requires(T &model) {\n\t{\n\t\tmodel.add_linear_constraint(ScalarAffineFunction(), ConstraintSense::Equal, 0.0, \"\")\n\t} -> std::same_as;\n};\n\ntemplate \nclass OnesideLinearConstraintMixin\n{\n private:\n\tT *get_base()\n\t{\n\t\tstatic_assert(OnesideLinearConstraintMixinConcept);\n\t\treturn static_cast(this);\n\t}\n\n public:\n\tConstraintIndex add_linear_constraint_from_var(const VariableIndex &variable,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr)\n\t{\n\t\tScalarAffineFunction f(variable);\n\t\treturn get_base()->add_linear_constraint(f, sense, rhs, name);\n\t}\n\tConstraintIndex add_linear_constraint_from_expr(const ExprBuilder &function,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr)\n\t{\n\t\tif (function.degree() >= 2)\n\t\t{\n\t\t\tthrow std::runtime_error(\"add_linear_constraint expects linear expression but receives \"\n\t\t\t \"a quadratic expression.\");\n\t\t}\n\t\tScalarAffineFunction f(function);\n\t\treturn get_base()->add_linear_constraint(f, sense, rhs, name);\n\t}\n};\n\ntemplate \nconcept TwosideLinearConstraintMixinConcept = requires(T &model) {\n\t{\n\t\tmodel.add_linear_constraint(ScalarAffineFunction(), std::make_tuple(0.0, 1.0), \"\")\n\t} -> std::same_as;\n};\n\ntemplate \nclass TwosideLinearConstraintMixin\n{\n private:\n\tT *get_base()\n\t{\n\t\tstatic_assert(TwosideLinearConstraintMixinConcept);\n\t\treturn static_cast(this);\n\t}\n\n public:\n\tConstraintIndex add_linear_interval_constraint_from_var(\n\t const VariableIndex &variable, const std::tuple &interval,\n\t const char *name = nullptr)\n\t{\n\t\tScalarAffineFunction f(variable);\n\t\treturn get_base()->add_linear_constraint(f, interval, name);\n\t}\n\tConstraintIndex add_linear_interval_constraint_from_expr(\n\t const ExprBuilder &function, const std::tuple &interval,\n\t const char *name = nullptr)\n\t{\n\t\tScalarAffineFunction f(function);\n\t\treturn get_base()->add_linear_constraint(f, interval, name);\n\t}\n};\n\ntemplate \nconcept OnesideQuadraticConstraintMixinConcept = requires(T &model) {\n\t{\n\t\tmodel.add_quadratic_constraint(ScalarQuadraticFunction(), ConstraintSense::Equal, 0.0, \"\")\n\t} -> std::same_as;\n};\n\ntemplate \nclass OnesideQuadraticConstraintMixin\n{\n private:\n\tT *get_base()\n\t{\n\t\tstatic_assert(OnesideQuadraticConstraintMixinConcept);\n\t\treturn static_cast(this);\n\t}\n\n public:\n\tConstraintIndex add_quadratic_constraint_from_var(const VariableIndex &variable,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr)\n\t{\n\t\tScalarQuadraticFunction f(variable);\n\t\treturn get_base()->add_quadratic_constraint(f, sense, rhs, name);\n\t}\n\tConstraintIndex add_quadratic_constraint_from_saf(const ScalarAffineFunction &function,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr)\n\t{\n\t\tScalarQuadraticFunction f(function);\n\t\treturn get_base()->add_quadratic_constraint(f, sense, rhs, name);\n\t}\n\tConstraintIndex add_quadratic_constraint_from_expr(const ExprBuilder &function,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr)\n\t{\n\t\tScalarQuadraticFunction f(function);\n\t\treturn get_base()->add_quadratic_constraint(f, sense, rhs, name);\n\t}\n};\n\ntemplate \nconcept TwosideQuadraticConstraintMixinConcept = requires(T &model) {\n\t{\n\t\tmodel.add_quadratic_constraint(ScalarQuadraticFunction(), std::make_tuple(0.0, 1.0), \"\")\n\t} -> std::same_as;\n};\n\ntemplate \nclass TwosideQuadraticConstraintMixin\n{\n private:\n\tT *get_base()\n\t{\n\t\tstatic_assert(TwosideQuadraticConstraintMixinConcept);\n\t\treturn static_cast(this);\n\t}\n\n public:\n\tConstraintIndex add_quadratic_interval_constraint_from_var(\n\t const VariableIndex &variable, const std::tuple &interval,\n\t const char *name = nullptr)\n\t{\n\t\tScalarQuadraticFunction f(variable);\n\t\treturn get_base()->add_quadratic_constraint(f, interval, name);\n\t}\n\tConstraintIndex add_quadratic_interval_constraint_from_expr(\n\t const ExprBuilder &function, const std::tuple &interval,\n\t const char *name = nullptr)\n\t{\n\t\tScalarQuadraticFunction f(function);\n\t\treturn get_base()->add_quadratic_constraint(f, interval, name);\n\t}\n};\n\n#ifdef USE_NLMIXIN\n#include \"pyoptinterface/nlexpr.hpp\"\n\ntemplate \nconcept TwosideNLConstraintMixinConcept = requires(T &model) {\n\t{\n\t\tmodel.add_single_nl_constraint(std::declval(), ExpressionHandle(),\n\t\t std::make_tuple(0.0, 1.0), \"\")\n\t} -> std::same_as;\n\t{ model.get_infinity() } -> std::convertible_to;\n};\n\ntemplate \nclass TwosideNLConstraintMixin\n{\n private:\n\tT *get_base()\n\t{\n\t\tstatic_assert(TwosideNLConstraintMixinConcept);\n\t\treturn static_cast(this);\n\t}\n\n public:\n\tConstraintIndex add_single_nl_constraint_sense_rhs(ExpressionGraph &graph,\n\t const ExpressionHandle &result,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr)\n\t{\n\t\tdouble infinity = get_base()->get_infinity();\n\n\t\tdouble lb, ub;\n\n\t\tif (sense == ConstraintSense::Equal)\n\t\t{\n\t\t\tlb = rhs;\n\t\t\tub = rhs;\n\t\t}\n\t\telse if (sense == ConstraintSense::LessEqual)\n\t\t{\n\t\t\tlb = -infinity;\n\t\t\tub = rhs;\n\t\t}\n\t\telse if (sense == ConstraintSense::GreaterEqual)\n\t\t{\n\t\t\tlb = rhs;\n\t\t\tub = infinity;\n\t\t}\n\n\t\treturn get_base()->add_single_nl_constraint(graph, result, {lb, ub}, name);\n\t}\n\n\tConstraintIndex add_single_nl_constraint_from_comparison(ExpressionGraph &graph,\n\t const ExpressionHandle &expr,\n\t const char *name)\n\t{\n\t\tExpressionHandle real_expr;\n\t\tdouble lb = -get_base()->get_infinity(), ub = get_base()->get_infinity();\n\t\tunpack_comparison_expression(graph, expr, real_expr, lb, ub);\n\t\tauto constraint = get_base()->add_single_nl_constraint(graph, real_expr, {lb, ub}, name);\n\t\treturn constraint;\n\t}\n};\n#endif\n\ntemplate \nconcept GetValueMixinConcept = requires(T &model) {\n\t{ model.get_variable_value(VariableIndex()) } -> std::convertible_to;\n};\n\ntemplate \nclass GetValueMixin\n{\n private:\n\tT *get_base()\n\t{\n\t\tstatic_assert(GetValueMixinConcept);\n\t\treturn static_cast(this);\n\t}\n\n public:\n\tdouble get_expression_value(const ScalarAffineFunction &function)\n\t{\n\t\tT *model = get_base();\n\t\tauto N = function.size();\n\t\tdouble value = 0.0;\n\t\tfor (auto i = 0; i < N; ++i)\n\t\t{\n\t\t\tvalue += function.coefficients[i] * model->get_variable_value(function.variables[i]);\n\t\t}\n\t\tvalue += function.constant.value_or(0.0);\n\t\treturn value;\n\t}\n\tdouble get_expression_value(const ScalarQuadraticFunction &function)\n\t{\n\t\tT *model = get_base();\n\t\tauto N = function.size();\n\t\tdouble value = 0.0;\n\t\tfor (auto i = 0; i < N; ++i)\n\t\t{\n\t\t\tauto var1 = function.variable_1s[i];\n\t\t\tauto var2 = function.variable_2s[i];\n\t\t\tauto coef = function.coefficients[i];\n\t\t\tauto v1 = model->get_variable_value(var1);\n\t\t\tif (var1 == var2)\n\t\t\t{\n\t\t\t\tvalue += coef * v1 * v1;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tauto v2 = model->get_variable_value(var2);\n\t\t\t\tvalue += coef * v1 * v2;\n\t\t\t}\n\t\t}\n\t\tif (function.affine_part)\n\t\t{\n\t\t\tauto affine_value = model->get_expression_value(function.affine_part.value());\n\t\t\tvalue += affine_value;\n\t\t}\n\t\treturn value;\n\t}\n\tdouble get_expression_value(const ExprBuilder &function)\n\t{\n\t\tT *model = get_base();\n\t\tdouble value = 0.0;\n\t\tfor (const auto &[varpair, coef] : function.quadratic_terms)\n\t\t{\n\t\t\tauto var1 = varpair.var_1;\n\t\t\tauto var2 = varpair.var_2;\n\n\t\t\tauto v1 = model->get_variable_value(var1);\n\t\t\tif (var1 == var2)\n\t\t\t{\n\t\t\t\tvalue += coef * v1 * v1;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tauto v2 = model->get_variable_value(var2);\n\t\t\t\tvalue += coef * v1 * v2;\n\t\t\t}\n\t\t}\n\t\tfor (const auto &[var, coef] : function.affine_terms)\n\t\t{\n\t\t\tvalue += coef * model->get_variable_value(var);\n\t\t}\n\t\tvalue += function.constant_term.value_or(0.0);\n\t\treturn value;\n\t}\n};\n\ntemplate \nconcept PPrintMixinConcept = requires(T &model) {\n\t{ model.pprint_variable(VariableIndex()) } -> std::convertible_to;\n};\n\ntemplate \nclass PPrintMixin\n{\n private:\n\tT *get_base()\n\t{\n\t\tstatic_assert(PPrintMixinConcept);\n\t\treturn static_cast(this);\n\t}\n\n public:\n\tstd::string pprint_expression(const ScalarAffineFunction &function, int precision = 4)\n\t{\n\t\tT *model = get_base();\n\t\tauto N = function.size();\n\t\tstd::vector terms;\n\t\tterms.reserve(N + 1);\n\t\tfor (auto i = 0; i < N; ++i)\n\t\t{\n\t\t\tauto &coef = function.coefficients[i];\n\t\t\tstd::string var_str = model->pprint_variable(function.variables[i]);\n\t\t\tstd::string term;\n\t\t\tif (coef > 0)\n\t\t\t{\n\t\t\t\tterm = fmt::format(\"{:.{}g}*{}\", coef, precision, var_str);\n\t\t\t}\n\t\t\telse if (coef < 0)\n\t\t\t{\n\t\t\t\tterm = fmt::format(\"({:.{}g})*{}\", coef, precision, var_str);\n\t\t\t}\n\t\t\tterms.push_back(term);\n\t\t}\n\t\tif (function.constant)\n\t\t{\n\t\t\tterms.push_back(fmt::format(\"{:.{}g}\", function.constant.value(), precision));\n\t\t}\n\t\treturn fmt::format(\"{}\", fmt::join(terms, \"+\"));\n\t}\n\tstd::string pprint_expression(const ScalarQuadraticFunction &function, int precision = 4)\n\t{\n\t\tT *model = get_base();\n\t\tauto N = function.size();\n\t\tstd::vector terms;\n\t\tterms.reserve(N + 1);\n\t\tfor (auto i = 0; i < N; ++i)\n\t\t{\n\t\t\tauto &coef = function.coefficients[i];\n\t\t\tstd::string var1_str = model->pprint_variable(function.variable_1s[i]);\n\t\t\tstd::string var2_str;\n\t\t\tif (function.variable_1s[i] == function.variable_2s[i])\n\t\t\t{\n\t\t\t\tvar2_str = var1_str;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tvar2_str = model->pprint_variable(function.variable_2s[i]);\n\t\t\t}\n\t\t\tstd::string term;\n\t\t\tif (coef > 0)\n\t\t\t{\n\t\t\t\tterm = fmt::format(\"{:.{}g}*{}*{}\", coef, precision, var1_str, var2_str);\n\t\t\t}\n\t\t\telse if (coef < 0)\n\t\t\t{\n\t\t\t\tterm = fmt::format(\"({:.{}g})*{}*{}\", coef, precision, var1_str, var2_str);\n\t\t\t}\n\t\t\tterms.push_back(term);\n\t\t}\n\t\tif (function.affine_part)\n\t\t{\n\t\t\tauto affine_value = model->pprint_expression(function.affine_part.value(), precision);\n\t\t\tterms.push_back(affine_value);\n\t\t}\n\t\treturn fmt::format(\"{}\", fmt::join(terms, \"+\"));\n\t}\n\tstd::string pprint_expression(const ExprBuilder &function, int precision = 4)\n\t{\n\t\tT *model = get_base();\n\t\tstd::vector terms;\n\t\tterms.reserve(function.quadratic_terms.size() + function.affine_terms.size() + 1);\n\t\tfor (const auto &[varpair, coef] : function.quadratic_terms)\n\t\t{\n\t\t\tstd::string var1_str = model->pprint_variable(varpair.var_1);\n\t\t\tstd::string var2_str;\n\t\t\tif (varpair.var_1 == varpair.var_2)\n\t\t\t{\n\t\t\t\tvar2_str = var1_str;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tvar2_str = model->pprint_variable(varpair.var_2);\n\t\t\t}\n\t\t\tstd::string term;\n\t\t\tif (coef > 0)\n\t\t\t{\n\t\t\t\tterm = fmt::format(\"{:.{}g}*{}*{}\", coef, precision, var1_str, var2_str);\n\t\t\t}\n\t\t\telse if (coef < 0)\n\t\t\t{\n\t\t\t\tterm = fmt::format(\"({:.{}g})*{}*{}\", coef, precision, var1_str, var2_str);\n\t\t\t}\n\t\t\tterms.push_back(term);\n\t\t}\n\t\tfor (const auto &[var, coef] : function.affine_terms)\n\t\t{\n\t\t\tauto term = fmt::format(\"{:.{}g}*{}\", coef, precision, model->pprint_variable(var));\n\t\t\tterms.push_back(term);\n\t\t}\n\t\tif (function.constant_term)\n\t\t{\n\t\t\tauto term = fmt::format(\"{:.{}g}\", function.constant_term.value(), precision);\n\t\t\tterms.push_back(term);\n\t\t}\n\t\treturn fmt::format(\"{}\", fmt::join(terms, \"+\"));\n\t}\n};\n\ntemplate \nconcept LinearObjectiveMixinConcept = requires(T &model) {\n\t{ model.set_objective(ScalarAffineFunction(), ObjectiveSense()) } -> std::same_as;\n};\n\ntemplate \nclass LinearObjectiveMixin\n{\n private:\n\tT *get_base()\n\t{\n\t\tstatic_assert(LinearObjectiveMixinConcept);\n\t\treturn static_cast(this);\n\t}\n\n public:\n\tvoid set_objective_as_constant(CoeffT c, ObjectiveSense sense)\n\t{\n\t\tT *model = get_base();\n\t\tmodel->set_objective(ScalarAffineFunction(c), sense);\n\t}\n\tvoid set_objective_as_variable(const VariableIndex &variable, ObjectiveSense sense)\n\t{\n\t\tT *model = get_base();\n\t\tmodel->set_objective(ScalarAffineFunction(variable), sense);\n\t}\n};\n\n/* This concept combined with partial specialization causes ICE on gcc 10 */\n// template \n// concept VarIndexModel = requires(T *model, const VariableIndex &v) {\n//\t{\n//\t\tmodel->_variable_index(v)\n//\t} -> std::convertible_to;\n// };\n#define VarIndexModel typename\n\ntemplate \nstruct AffineFunctionPtrForm\n{\n\tNZT numnz;\n\tIDXT *index;\n\tVALT *value;\n\tstd::vector index_storage;\n\tstd::vector value_storage;\n\n\ttemplate \n\tvoid make(T *model, const ScalarAffineFunction &function)\n\t{\n\t\tauto f_numnz = function.size();\n\t\tnumnz = f_numnz;\n\t\tindex_storage.resize(numnz);\n\t\tfor (int i = 0; i < numnz; ++i)\n\t\t{\n\t\t\tindex_storage[i] = model->_variable_index(function.variables[i]);\n\t\t}\n\t\tindex = index_storage.data();\n\t\tif constexpr (std::is_same_v)\n\t\t{\n\t\t\tvalue = (VALT *)function.coefficients.data();\n\t\t}\n\t\telse\n\t\t{\n\t\t\tvalue_storage.resize(numnz);\n\t\t\tfor (int i = 0; i < numnz; ++i)\n\t\t\t{\n\t\t\t\tvalue_storage[i] = function.coefficients[i];\n\t\t\t}\n\t\t}\n\t}\n};\n\ntemplate \nstruct QuadraticFunctionPtrForm\n{\n\tNZT numnz;\n\tIDXT *row;\n\tIDXT *col;\n\tVALT *value;\n\tstd::vector row_storage;\n\tstd::vector col_storage;\n\tstd::vector value_storage;\n\n\ttemplate \n\tvoid make(T *model, const ScalarQuadraticFunction &function)\n\t{\n\t\tauto f_numnz = function.size();\n\t\tnumnz = f_numnz;\n\t\trow_storage.resize(numnz);\n\t\tcol_storage.resize(numnz);\n\t\tfor (int i = 0; i < numnz; ++i)\n\t\t{\n\t\t\trow_storage[i] = model->_variable_index(function.variable_1s[i]);\n\t\t\tif (function.variable_1s[i] == function.variable_2s[i])\n\t\t\t{\n\t\t\t\tcol_storage[i] = row_storage[i];\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tcol_storage[i] = model->_variable_index(function.variable_2s[i]);\n\t\t\t}\n\t\t}\n\t\trow = row_storage.data();\n\t\tcol = col_storage.data();\n\t\tif constexpr (std::is_same_v)\n\t\t{\n\t\t\tvalue = (VALT *)function.coefficients.data();\n\t\t}\n\t\telse\n\t\t{\n\t\t\tvalue_storage.resize(numnz);\n\t\t\tfor (int i = 0; i < numnz; ++i)\n\t\t\t{\n\t\t\t\tvalue_storage[i] = function.coefficients[i];\n\t\t\t}\n\t\t}\n\t}\n};\n\nenum class HessianTriangular\n{\n\tUpper,\n\tLower,\n};\n\ntemplate \nstruct CSCMatrix\n{\n\tNZT numnz;\n\tNZT numcol;\n\tstd::vector values_CSC;\n\tstd::vector rows_CSC;\n\tstd::vector colStarts_CSC;\n\n\ttemplate \n\tvoid make(T *model, const ScalarQuadraticFunction &function, int i_numcol,\n\t HessianTriangular triangular_format)\n\t{\n\t\tauto f_numnz = function.size();\n\t\tnumnz = f_numnz;\n\t\tnumcol = i_numcol;\n\n\t\tstd::vector rows(numnz); // Row indices\n\t\tstd::vector cols(numnz); // Column indices\n\t\tstd::vector values(numnz); // Values\n\t\tfor (int i = 0; i < numnz; ++i)\n\t\t{\n\t\t\tauto v1 = model->_variable_index(function.variable_1s[i]);\n\t\t\tauto v2 = v1;\n\t\t\tif (function.variable_1s[i] != function.variable_2s[i])\n\t\t\t{\n\t\t\t\tv2 = model->_variable_index(function.variable_2s[i]);\n\t\t\t}\n\n\t\t\tif (triangular_format == HessianTriangular::Upper)\n\t\t\t{\n\t\t\t\tif (v1 > v2)\n\t\t\t\t{\n\t\t\t\t\tstd::swap(v1, v2);\n\t\t\t\t}\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tif (v1 < v2)\n\t\t\t\t{\n\t\t\t\t\tstd::swap(v1, v2);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (v1 < 0 || v2 < 0)\n\t\t\t{\n\t\t\t\tthrow std::runtime_error(\n\t\t\t\t \"Variable index in quadratic function cannot be negative!\");\n\t\t\t}\n\n\t\t\trows[i] = v1;\n\t\t\tcols[i] = v2;\n\n\t\t\tauto coef = function.coefficients[i];\n\t\t\tif (v1 != v2)\n\t\t\t{\n\t\t\t\t// Non-diagonal element, should multiply by 0.5\n\t\t\t\tcoef *= 0.5;\n\t\t\t}\n\t\t\tvalues[i] = coef;\n\t\t}\n\n\t\t// Sorting based on column indices\n\t\tstd::vector idx(numnz);\n\t\tstd::iota(idx.begin(), idx.end(), 0);\n\t\tstd::sort(idx.begin(), idx.end(), [&](int i, int j) {\n\t\t\tif (cols[i] == cols[j])\n\t\t\t{\n\t\t\t\treturn rows[i] < rows[j];\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\treturn cols[i] < cols[j];\n\t\t\t}\n\t\t});\n\n\t\t// Creating CSC arrays\n\t\tvalues_CSC.reserve(numnz);\n\t\trows_CSC.reserve(numnz);\n\t\tcolStarts_CSC.resize(numcol + 1, 0);\n\n\t\tint currentCol = 0;\n\t\tfor (auto i : idx)\n\t\t{\n\t\t\twhile (currentCol < cols[i])\n\t\t\t{\n\t\t\t\tcolStarts_CSC[currentCol + 1] = values_CSC.size();\n\t\t\t\tcurrentCol++;\n\t\t\t}\n\t\t\tvalues_CSC.push_back(values[i]);\n\t\t\trows_CSC.push_back(rows[i]);\n\t\t}\n\n\t\t// Filling up remaining columns in colStarts_CSC\n\t\tstd::fill(colStarts_CSC.begin() + currentCol + 1, colStarts_CSC.end(), numnz);\n\t}\n};\n" }, { "path": "include/pyoptinterface/tcc_interface.hpp", "content": "#pragma once\n\n#include \n#include \n\n#include \"tcc/libtcc.h\"\n\n#include \"ankerl/unordered_dense.h\"\n#include \"pyoptinterface/dylib.hpp\"\n\n#define APILIST \\\n\tB(tcc_new); \\\n\tB(tcc_delete); \\\n\tB(tcc_add_include_path); \\\n\tB(tcc_add_sysinclude_path); \\\n\tB(tcc_define_symbol); \\\n\tB(tcc_undefine_symbol); \\\n\tB(tcc_compile_string); \\\n\tB(tcc_set_output_type); \\\n\tB(tcc_add_library_path); \\\n\tB(tcc_add_library); \\\n\tB(tcc_add_symbol); \\\n\tB(tcc_relocate); \\\n\tB(tcc_get_symbol);\n\nnamespace tcc\n{\n#define B DYLIB_EXTERN_DECLARE\nAPILIST\n#undef B\n\nbool is_library_loaded();\n\nbool load_library(const std::string &path);\n} // namespace tcc\n\nstruct TCCFreeT\n{\n\tvoid operator()(TCCState *state) const\n\t{\n\t\ttcc::tcc_delete(state);\n\t};\n};\n\nstruct TCCInstance\n{\n\tTCCInstance() = default;\n\tvoid init();\n\n\tvoid add_include_path(const std::string &path);\n\tvoid add_sysinclude_path(const std::string &path);\n\n\tvoid add_library_path(const std::string &path);\n\tvoid add_library(const std::string &name);\n\n\tvoid import_math_symbols();\n\tvoid compile_string(const std::string &code);\n\n\tuintptr_t get_symbol(const std::string &name);\n\n\tstd::unique_ptr m_state;\n};" }, { "path": "include/pyoptinterface/xpress_model.hpp", "content": "#pragma\n\n#include \n#include \n#include \n\n// #include \n#include \"../thirdparty/solvers/xpress/xpress_forward_decls.h\"\n\n#include \"pyoptinterface/core.hpp\"\n#include \"pyoptinterface/container.hpp\"\n#define USE_NLMIXIN\n#include \"pyoptinterface/solver_common.hpp\"\n#include \"pyoptinterface/dylib.hpp\"\n\n// PyOptInterface has been compiled and tested with Xpress version 46.1.1\n#define XPRS_VER_MAJOR 46\n#define XPRS_VER_MINOR 1\n#define XPRS_VER_BUILD 1\n\n#if POI_XPVERSION_MAJOR < XPRS_VER_MAJOR\n#warning \"System Xpress library major version is older than the officially supported version. \" \\\n \"Some features may not work correctly.\"\n#endif\n\n// Xpress Callback Abstraction Layer\n//\n// Xpress supports multiple callbacks that we want to expose to PyOptInterface as \"contexts\" to\n// match the design of other solver interfaces. To bridge Xpress's multiple-callback system to\n// PyOptInterface's single-callback-with-context model, we need to repeat the same setup for each\n// callback: define the low-level C function, register it with Xpress, handle its arguments, and\n// bind everything through Nanobind.\n//\n// Rather than copy-paste this boilerplate for each callback (error-prone and hard to maintain), we\n// use macros to generate everything from a single list.\n//\n// How does it work:\n// We define XPRSCB_LIST below with all supported callbacks and their signatures. This list is\n// parameterized by two macros that let us generate different code from the same data:\n//\n// MACRO - Receives callback metadata (ID, name, return type, arguments) and expands to whatever\n// we're generating (function declarations, enum values, registration code, etc.)\n//\n// ARG - Formats each callback *optional* argument. MACRO receives arguments wrapped by ARG, so it\n// can extract type/name information as needed.\n//\n// When we need to do something with all callbacks (e.g., declare wrapper functions), we pass\n// specific MACRO and ARG definitions to XPRSCB_LIST, and it generates the code.\n//\n// MACRO is invoked with:\n// 1. ID - Unique number for enum bit-flags (0-63, used for callback identification)\n// 2. NAME - Xpress callback name (e.g., \"optnode\" for XPRSaddcboptnode)\n// 3. RET - Return type of the Xpress callback function\n// 4. ...ARGS - Callback arguments (excluding XPRSprob and void* which are always first),\n// each wrapped in ARG(TYPE, NAME)\n//\n// ARG is invoked with:\n// 1. TYPE - Argument type from Xpress documentation\n// 2. NAME - Argument name from Xpress documentation\n//\n// Example: To declare all callback wrappers, define MACRO to generate a function declaration and\n// ARG to format parameters, then invoke XPRSCB_LIST(MACRO, ARG).\n\n// clang-format off\n#define XPRSCB_LIST(MACRO, ARG) \\\n\tMACRO(0, bariteration, void, \\\n ARG(int *, p_action)) \\\n\tMACRO(1, barlog, int) \\\n\tMACRO(2, afterobjective, void) \\\n\tMACRO(3, beforeobjective, void) \\\n\tMACRO(5, presolve, void) \\\n\tMACRO(6, checktime,int) \\\n\tMACRO(7, chgbranchobject, void, \\\n ARG(XPRSbranchobject, obranch) \\\n ARG(XPRSbranchobject *, p_newobject)) \\\n\tMACRO(8, cutlog, int) \\\n\tMACRO(9, cutround, void, \\\n ARG(int, ifxpresscuts) \\\n ARG(int*, p_action)) \\\n\tMACRO(10, destroymt, void) \\\n\tMACRO(11, gapnotify, void, \\\n ARG(double*, p_relgapnotifytarget) \\\n ARG(double*, p_absgapnotifytarget) \\\n ARG(double*, p_absgapnotifyobjtarget) \\\n ARG(double*, p_absgapnotifyboundtarget)) \\\n\tMACRO(12, miplog, int) \\\n\tMACRO(13, infnode, void) \\\n\tMACRO(14, intsol, void) \\\n\tMACRO(15, lplog, int) \\\n\tMACRO(16, message, void, \\\n ARG(const char*, msg) \\\n ARG(int, msglen) \\\n ARG(int, msgtype)) \\\n /* This CB is currently incompatible with this wapper design \n MACRO(17, mipthread, void, \\\n ARG(XPRSprob, threadprob)) */ \\\n\tMACRO(18, newnode, void, \\\n ARG(int, parentnode) \\\n ARG(int, node) \\\n ARG(int, branch)) \\\n\tMACRO(19, nodecutoff, void, \\\n ARG(int, node)) \\\n\tMACRO(20, nodelpsolved, void) \\\n\tMACRO(21, optnode, void, \\\n ARG(int*, p_infeasible)) \\\n\tMACRO(22, preintsol, void, \\\n ARG(int, soltype) \\\n ARG(int*, p_reject) \\\n ARG(double*, p_cutoff)) \\\n\tMACRO(23, prenode, void, \\\n ARG(int*, p_infeasible)) \\\n\tMACRO(24, usersolnotify, void, \\\n ARG(const char*, solname) \\\n ARG(int, status))\n// clang-format on\n\n// Common callbacks optional arguments formatting macros:\n#define XPRSCB_ARG_IGNORE(TYPE, NAME) // Ingore arguments\n#define XPRSCB_ARG_FN(TYPE, NAME) , TYPE NAME // As args of a function\n#define XPRSCB_ARG_TYPE(TYPE, NAME) , TYPE // As args of a template\n\n// Expand to 2 elements of APILIST\n#define XPRSCB_ADDREMOVE_FN(ID, NAME, ...) \\\n\tB(XPRSaddcb##NAME); \\\n\tB(XPRSremovecb##NAME);\n\n// Define Xpress C APIs list.\n// Similar idea to the CBs list, here the B macro is externally provided as in the other solvers\n// interface implementation.\n#define APILIST \\\n\tB(XPRSaddcols64); \\\n\tB(XPRSaddcuts64); \\\n\tB(XPRSaddmanagedcuts64); \\\n\tB(XPRSaddmipsol); \\\n\tB(XPRSaddnames); \\\n\tB(XPRSaddqmatrix64); \\\n\tB(XPRSaddrows64); \\\n\tB(XPRSaddsets64); \\\n\tB(XPRSbeginlicensing); \\\n\tB(XPRSchgbounds); \\\n\tB(XPRSchgcoef); \\\n\tB(XPRSchgcoltype); \\\n\tB(XPRSchgmqobj64); \\\n\tB(XPRSchgobj); \\\n\tB(XPRSchgobjsense); \\\n\tB(XPRSchgrhs); \\\n\tB(XPRSchgrowtype); \\\n\tB(XPRScreateprob); \\\n\tB(XPRSdelcols); \\\n\tB(XPRSdelobj); \\\n\tB(XPRSdelqmatrix); \\\n\tB(XPRSdelrows); \\\n\tB(XPRSdelsets); \\\n\tB(XPRSdestroyprob); \\\n\tB(XPRSendlicensing); \\\n\tB(XPRSfree); \\\n\tB(XPRSgetattribinfo); \\\n\tB(XPRSgetbasisval); \\\n\tB(XPRSgetcallbacksolution); \\\n\tB(XPRSgetcoef); \\\n\tB(XPRSgetcoltype); \\\n\tB(XPRSgetcontrolinfo); \\\n\tB(XPRSgetdblattrib); \\\n\tB(XPRSgetdblcontrol); \\\n\tB(XPRSgetdualray); \\\n\tB(XPRSgetduals); \\\n\tB(XPRSgetiisdata); \\\n\tB(XPRSgetintattrib64); \\\n\tB(XPRSgetintcontrol64); \\\n\tB(XPRSgetlasterror); \\\n\tB(XPRSgetlb); \\\n\tB(XPRSgetlicerrmsg); \\\n\tB(XPRSgetlpsol); \\\n\tB(XPRSgetnamelist); \\\n\tB(XPRSgetobj); \\\n\tB(XPRSgetprimalray); \\\n\tB(XPRSgetprobname); \\\n\tB(XPRSgetredcosts); \\\n\tB(XPRSgetrhs); \\\n\tB(XPRSgetrowtype); \\\n\tB(XPRSgetslacks); \\\n\tB(XPRSgetsolution); \\\n\tB(XPRSgetstrattrib); \\\n\tB(XPRSgetstrcontrol); \\\n\tB(XPRSgetstringattrib); \\\n\tB(XPRSgetstringcontrol); \\\n\tB(XPRSgetub); \\\n\tB(XPRSgetversion); \\\n\tB(XPRSgetversionnumbers); \\\n\tB(XPRSiisall); \\\n\tB(XPRSiisfirst); \\\n\tB(XPRSinit); \\\n\tB(XPRSinterrupt); \\\n\tB(XPRSlicense); \\\n\tB(XPRSnlpaddformulas); \\\n\tB(XPRSnlploadformulas); \\\n\tB(XPRSnlppostsolve); \\\n\tB(XPRSoptimize); \\\n\tB(XPRSpostsolve); \\\n\tB(XPRSpresolverow); \\\n\tB(XPRSsaveas); \\\n\tB(XPRSsetdblcontrol); \\\n\tB(XPRSsetintcontrol); \\\n\tB(XPRSsetintcontrol64); \\\n\tB(XPRSsetlogfile); \\\n\tB(XPRSsetprobname); \\\n\tB(XPRSsetstrcontrol); \\\n\tB(XPRSwritebasis); \\\n\tB(XPRSwritebinsol); \\\n\tB(XPRSwriteprob); \\\n\tB(XPRSwriteprtsol); \\\n\tB(XPRSwriteslxsol); \\\n\tB(XPRSwritesol); \\\n\tXPRSCB_LIST(XPRSCB_ADDREMOVE_FN, XPRSCB_ARG_IGNORE);\n\nnamespace xpress\n{\n// Define xpress function inside the xpress namespace\n#define B DYLIB_EXTERN_DECLARE\nAPILIST\n#undef B\n\n// Libray loading functions\nbool is_library_loaded();\nbool load_library(const std::string &path);\nstd::pair license(int p_i, const char *p_c);\nbool beginlicensing();\nvoid endlicensing();\n\n// Xpress doesn't have an Env pointer, however, POI manages environment\n// initialization with an OOP interface.\nstruct Env\n{\n\tEnv(const char *path = nullptr);\n\t~Env();\n\tvoid close();\n\n\tstatic inline std::mutex mtx;\n\tstatic inline int init_count = 0;\n\tbool initialized = false;\n};\n\n// Some of the Xpress enums are here re-defined to enforce type safety\n// Types associated with Xpress attribute and controls\nenum class CATypes : int\n{\n\tNOTDEFINED = POI_XPRS_TYPE_NOTDEFINED,\n\tINT = POI_XPRS_TYPE_INT,\n\tINT64 = POI_XPRS_TYPE_INT64,\n\tDOUBLE = POI_XPRS_TYPE_DOUBLE,\n\tSTRING = POI_XPRS_TYPE_STRING,\n};\n\nenum class SOLSTATUS : int\n{\n\tNOTFOUND = POI_XPRS_SOLSTATUS_NOTFOUND,\n\tOPTIMAL = POI_XPRS_SOLSTATUS_OPTIMAL,\n\tFEASIBLE = POI_XPRS_SOLSTATUS_FEASIBLE,\n\tINFEASIBLE = POI_XPRS_SOLSTATUS_INFEASIBLE,\n\tUNBOUNDED = POI_XPRS_SOLSTATUS_UNBOUNDED\n};\n\nenum class SOLVESTATUS : int\n{\n\tUNSTARTED = POI_XPRS_SOLVESTATUS_UNSTARTED,\n\tSTOPPED = POI_XPRS_SOLVESTATUS_STOPPED,\n\tFAILED = POI_XPRS_SOLVESTATUS_FAILED,\n\tCOMPLETED = POI_XPRS_SOLVESTATUS_COMPLETED\n};\n\nenum class LPSTATUS : int\n{\n\tUNSTARTED = POI_XPRS_LP_UNSTARTED,\n\tOPTIMAL = POI_XPRS_LP_OPTIMAL,\n\tINFEAS = POI_XPRS_LP_INFEAS,\n\tCUTOFF = POI_XPRS_LP_CUTOFF,\n\tUNFINISHED = POI_XPRS_LP_UNFINISHED,\n\tUNBOUNDED = POI_XPRS_LP_UNBOUNDED,\n\tCUTOFF_IN_DUAL = POI_XPRS_LP_CUTOFF_IN_DUAL,\n\tUNSOLVED = POI_XPRS_LP_UNSOLVED,\n\tNONCONVEX = POI_XPRS_LP_NONCONVEX\n};\n\nenum class MIPSTATUS : int\n{\n\tNOT_LOADED = POI_XPRS_MIP_NOT_LOADED,\n\tLP_NOT_OPTIMAL = POI_XPRS_MIP_LP_NOT_OPTIMAL,\n\tLP_OPTIMAL = POI_XPRS_MIP_LP_OPTIMAL,\n\tNO_SOL_FOUND = POI_XPRS_MIP_NO_SOL_FOUND,\n\tSOLUTION = POI_XPRS_MIP_SOLUTION,\n\tINFEAS = POI_XPRS_MIP_INFEAS,\n\tOPTIMAL = POI_XPRS_MIP_OPTIMAL,\n\tUNBOUNDED = POI_XPRS_MIP_UNBOUNDED\n};\n\nenum class NLPSTATUS : int\n{\n\tUNSTARTED = POI_XPRS_NLPSTATUS_UNSTARTED,\n\tSOLUTION = POI_XPRS_NLPSTATUS_SOLUTION,\n\tLOCALLY_OPTIMAL = POI_XPRS_NLPSTATUS_LOCALLY_OPTIMAL,\n\tOPTIMAL = POI_XPRS_NLPSTATUS_OPTIMAL,\n\tNOSOLUTION = POI_XPRS_NLPSTATUS_NOSOLUTION,\n\tLOCALLY_INFEASIBLE = POI_XPRS_NLPSTATUS_LOCALLY_INFEASIBLE,\n\tINFEASIBLE = POI_XPRS_NLPSTATUS_INFEASIBLE,\n\tUNBOUNDED = POI_XPRS_NLPSTATUS_UNBOUNDED,\n\tUNFINISHED = POI_XPRS_NLPSTATUS_UNFINISHED,\n\tUNSOLVED = POI_XPRS_NLPSTATUS_UNSOLVED,\n};\n\nenum class IISSOLSTATUS : int\n{\n\tUNSTARTED = POI_XPRS_IIS_UNSTARTED,\n\tFEASIBLE = POI_XPRS_IIS_FEASIBLE,\n\tCOMPLETED = POI_XPRS_IIS_COMPLETED,\n\tUNFINISHED = POI_XPRS_IIS_UNFINISHED\n};\n\nenum class SOLAVAILABLE : int\n{\n\tNOTFOUND = POI_XPRS_SOLAVAILABLE_NOTFOUND,\n\tOPTIMAL = POI_XPRS_SOLAVAILABLE_OPTIMAL,\n\tFEASIBLE = POI_XPRS_SOLAVAILABLE_FEASIBLE\n};\n\nenum class OPTIMIZETYPE : int\n{\n\tNONE = POI_XPRS_OPTIMIZETYPE_NONE,\n\tLP = POI_XPRS_OPTIMIZETYPE_LP,\n\tMIP = POI_XPRS_OPTIMIZETYPE_MIP,\n\tLOCAL = POI_XPRS_OPTIMIZETYPE_LOCAL,\n\tGLOBAL = POI_XPRS_OPTIMIZETYPE_GLOBAL\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// CALLBACKS TYPES AND DEFINITIONS //\n////////////////////////////////////////////////////////////////////////////////\n\n// Callback contexts enum. Defines an unique id for each callback/context.\n// The values of this enum class are defined as bitflags, to allow for multiple context manipulation\n// using a single uint64 value.\nenum class CB_CONTEXT : unsigned long long\n{\n// Define a enum element\n#define XPRSCB_ENUM(ID, NAME, ...) NAME = (1ULL << ID),\n\tXPRSCB_LIST(XPRSCB_ENUM, XPRSCB_ARG_IGNORE)\n#undef XPRSCB_ENUM\n};\n\nclass Model; // Define later in this file\nusing Callback = std::function; // Callback opaque container\n\n// xpress::Model operates in two modes to handle callback local XPRSprob objects:\n//\n// MAIN mode - The model owns its XPRSprob and manages all optimization state normally.\n// CALLBACK mode - A temporary, non-owning wrapper around Xpress's thread-local problem clone that\n// gets passed to callbacks. Since Xpress creates separate problem clones for callbacks, we need to\n// temporarily \"borrow\" this clone while preserving xpress::Model's internal state\n// (variable/constraint indexers, etc.) without copies.\n//\n// During a callback, we swap the XPRSprob pointer from the main model into the callback pointer,\n// execute the user's callback with a full xpress::Model object, then swap it back.\n//\n// Thread safety: This swap-based design assumes callbacks execute sequentially. Python's GIL\n// enforces this anyway (only one callback can execute Python code at a time), and we configure\n// Xpress to mutex callbacks invocations, so concurrent callback execution isn't an issue.\nenum class XPRESS_MODEL_MODE\n{\n\tMAIN, // Owns XPRSprob; holds global callback state\n\tCALLBACK_, // Non-owning wrapper around Xpress's callback problem clone\n};\n\n// Simple conditional struct that define the ret_code field only if it is not void\ntemplate \nstruct ReturnValue\n{\n\tT ret_code;\n\tT get_return_value() const\n\t{\n\t\treturn ret_code;\n\t}\n};\n\ntemplate <>\nstruct ReturnValue\n{\n\tvoid get_return_value() const {};\n};\n\n// Since we use the CB macro list, we get the original types passed at the low-level CBs\n// This helper struct is used to inject type-exceptions on the callback struct field types. In most\n// cases this is not required, except when dealing with pointers to opaque objects, which Nanobind\n// doesn't handle automatically.\ntemplate \nstruct StructFieldType\n{\n\tusing type = T; // Default behavior: just use the original type\n};\n\n// (At the best of my knowledge) Nanobind does not support binding for opaque types (pointers to\n// declared structs but whose definition is not available in that point). Some callbacks works with\n// opaque objects that are passed around (e.g., branch object), we don't need to access them,\n// just to pass them back to other Xpress APIs.\n\n// XPRSbranchobject is a pointer to an opaque type, which nanobind struggle with. So we pass it\n// as an opaque void*, which nanobind knows how to handle.\ntemplate <>\nstruct StructFieldType\n{\n\tusing type = void *;\n};\n\ntemplate <>\nstruct StructFieldType\n{\n\tusing type = void *;\n};\n\n// Callback Argument Structs\n//\n// PyOptInterface callbacks have a uniform signature: callback(model, context). On the other hand,\n// Xpress callbacks have varying signatures with callback-specific arguments (e.g., node IDs,\n// branching info, solution status). To bridge this gap, we generate a struct for each callback type\n// that holds its specific arguments.\n//\n// During a callback, we populate the appropriate struct with the current arguments, and we provide\n// it to the CB through the \"Model.cb_get_arguments\" function. The Python callback can then access\n// these arguments as named fields.\n//\n// For example, the 'optnode' callback receives an int* p_infeasible parameter. We generate:\n// struct optnode_struct { int* p_infeasible; };\n// The Python callback accesses this as: model.cb_get_arguments().p_infeasible\n\n#define XPRSCB_ARG_STRUCT(TYPE, NAME) StructFieldType::type NAME;\n#define XPRSCB_STRUCT(ID, NAME, RET, ...) \\\n\tstruct NAME##_struct : ReturnValue \\\n\t{ \\\n\t\t__VA_ARGS__ \\\n\t};\nXPRSCB_LIST(XPRSCB_STRUCT, XPRSCB_ARG_STRUCT)\n#undef XPRSCB_STRUCT\n\n// Callback Data Variant\n//\n// We use std::variant to store pointers to callback-specific argument structs, rather than\n// a generic void*. This provides two benefits:\n//\n// 1. Type safety - The variant ensures we can only store pointers to known callback structs,\n// catching type errors at compile time.\n//\n// 2. Automatic Python binding - Nanobind automatically converts std::variant to Python union\n// types, giving Python callbacks properly-typed access to callback arguments without manual\n// type casting or wrapper code.\n//\n// The variant contains nullptr_t plus a pointer type for each callback struct (e.g.,\n// optnode_struct*, intsol_struct*, etc.)\n#define XPRSCB_STRUCT_NAME(ID, NAME, RET, ...) , NAME##_struct *\nusing xpress_cbs_data =\n std::variant;\n#undef XPRSCB_STRUCT_NAME\n\n// Type-value pair mainly used for NLP formulas\nstruct Tvp\n{\n\tint type;\n\tdouble value;\n};\n\n// xpress::Model - Main solver interface for building and solving Xpress optimization models.\n// Inherits standard PyOptInterface modeling API through CRTP mixins for constraints, objectives,\n// and solution queries.\nclass Model : public OnesideLinearConstraintMixin,\n public TwosideLinearConstraintMixin,\n public OnesideQuadraticConstraintMixin,\n public TwosideNLConstraintMixin,\n public LinearObjectiveMixin,\n public PPrintMixin,\n public GetValueMixin\n{\n\n public:\n\tModel() = default;\n\t~Model();\n\n\t// Avoid involuntary copies\n\tModel(const Model &) = delete;\n\tModel &operator=(const Model &) = delete;\n\n\t// Move is fine, and we need it to wrap callback XPRSprob\n\tModel(Model &&) noexcept = default;\n\tModel &operator=(Model &&) noexcept = default;\n\n\tModel(const Env &env);\n\tvoid init(const Env &env);\n\tvoid close();\n\n\tvoid optimize();\n\tbool _is_mip();\n\tstatic double get_infinity();\n\tvoid write(const std::string &filename);\n\tstd::string get_problem_name();\n\tvoid set_problem_name(const std::string &probname);\n\tvoid add_mip_start(const std::vector &variables,\n\t const std::vector &values);\n\tvoid *get_raw_model();\n\tvoid computeIIS();\n\tstd::string version_string();\n\n\t// Index mappings\n\tint _constraint_index(ConstraintIndex constraint);\n\tint _variable_index(VariableIndex variable);\n\tint _checked_constraint_index(ConstraintIndex constraint);\n\tint _checked_variable_index(VariableIndex variable);\n\n\t// Variables\n\tVariableIndex add_variable(VariableDomain domain = VariableDomain::Continuous,\n\t double lb = POI_XPRS_MINUSINFINITY,\n\t double ub = POI_XPRS_PLUSINFINITY, const char *name = nullptr);\n\tvoid delete_variable(VariableIndex variable);\n\tvoid delete_variables(const Vector &variables);\n\tvoid set_objective_coefficient(VariableIndex variable, double value);\n\tvoid set_variable_bounds(VariableIndex variable, double lb, double ub);\n\tvoid set_variable_lowerbound(VariableIndex variable, double lb);\n\tvoid set_variable_name(VariableIndex variable, const char *name);\n\tvoid set_variable_type(VariableIndex variable, VariableDomain vtype);\n\tvoid set_variable_upperbound(VariableIndex variable, double ub);\n\tbool is_variable_active(VariableIndex variable);\n\tbool is_variable_basic(VariableIndex variable);\n\tbool is_variable_lowerbound_IIS(VariableIndex variable);\n\tbool is_variable_nonbasic_lb(VariableIndex variable);\n\tbool is_variable_nonbasic_ub(VariableIndex variable);\n\tbool is_variable_superbasic(VariableIndex variable);\n\tbool is_variable_upperbound_IIS(VariableIndex variable);\n\tdouble get_objective_coefficient(VariableIndex variable);\n\tdouble get_variable_lowerbound(VariableIndex variable);\n\tdouble get_variable_primal_ray(VariableIndex variable);\n\tdouble get_variable_rc(VariableIndex variable);\n\tdouble get_variable_upperbound(VariableIndex variable);\n\tdouble get_variable_value(VariableIndex variable);\n\tstd::string get_variable_name(VariableIndex variable);\n\tstd::string pprint_variable(VariableIndex variable);\n\tVariableDomain get_variable_type(VariableIndex variable);\n\n\t// Constraints\n\tConstraintIndex add_exp_cone_constraint(const Vector &variables,\n\t const char *name, bool dual);\n\tConstraintIndex add_linear_constraint(const ScalarAffineFunction &function,\n\t const std::tuple &interval,\n\t const char *name);\n\tConstraintIndex add_linear_constraint(const ScalarAffineFunction &function,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr);\n\tConstraintIndex add_quadratic_constraint(const ScalarQuadraticFunction &function,\n\t ConstraintSense sense, CoeffT rhs,\n\t const char *name = nullptr);\n\tConstraintIndex add_second_order_cone_constraint(const Vector &variables,\n\t const char *name, bool rotated);\n\tConstraintIndex add_single_nl_constraint(ExpressionGraph &graph, const ExpressionHandle &result,\n\t const std::tuple &interval,\n\t const char *name = nullptr);\n\tConstraintIndex add_sos_constraint(const Vector &variables, SOSType sos_type,\n\t const Vector &weights);\n\tConstraintIndex add_sos_constraint(const Vector &variables, SOSType sos_type);\n\tvoid delete_constraint(ConstraintIndex constraint);\n\tvoid set_constraint_name(ConstraintIndex constraint, const char *name);\n\tvoid set_constraint_rhs(ConstraintIndex constraint, CoeffT rhs);\n\tvoid set_constraint_sense(ConstraintIndex constraint, ConstraintSense sense);\n\tvoid set_normalized_coefficient(ConstraintIndex constraint, VariableIndex variable,\n\t double value);\n\tvoid set_normalized_rhs(ConstraintIndex constraint, double value);\n\tbool is_constraint_active(ConstraintIndex constraint);\n\tbool is_constraint_basic(ConstraintIndex constraint);\n\tbool is_constraint_in_IIS(ConstraintIndex constraint);\n\tbool is_constraint_nonbasic_lb(ConstraintIndex constraint);\n\tbool is_constraint_nonbasic_ub(ConstraintIndex constraint);\n\tbool is_constraint_superbasic(ConstraintIndex constraint);\n\tdouble get_constraint_dual_ray(ConstraintIndex constraint);\n\tdouble get_constraint_dual(ConstraintIndex constraint);\n\tdouble get_constraint_slack(ConstraintIndex constraint);\n\tdouble get_normalized_coefficient(ConstraintIndex constraint, VariableIndex variable);\n\tdouble get_normalized_rhs(ConstraintIndex constraint);\n\tCoeffT get_constraint_rhs(ConstraintIndex constraint);\n\tstd::string get_constraint_name(ConstraintIndex constraint);\n\tConstraintSense get_constraint_sense(ConstraintIndex constraint);\n\n\t// Objective function\n\tvoid set_objective(const ScalarAffineFunction &function, ObjectiveSense sense);\n\tvoid set_objective(const ScalarQuadraticFunction &function, ObjectiveSense sense);\n\tvoid set_objective(const ExprBuilder &function, ObjectiveSense sense);\n\tvoid add_single_nl_objective(ExpressionGraph &graph, const ExpressionHandle &result);\n\n\t// Xpress->POI exit status mappings\n\tLPSTATUS get_lp_status();\n\tMIPSTATUS get_mip_status();\n\tNLPSTATUS get_nlp_status();\n\tSOLSTATUS get_sol_status();\n\tSOLVESTATUS get_solve_status();\n\tOPTIMIZETYPE get_optimize_type();\n\tIISSOLSTATUS get_iis_sol_status();\n\n\t// Native Attribute/Control access using integer IDs\n\tvoid set_raw_control_dbl_by_id(int control, double value);\n\tvoid set_raw_control_int_by_id(int control, XPRSint64 value);\n\tvoid set_raw_control_str_by_id(int control, const char *value);\n\tXPRSint64 get_raw_control_int_by_id(int control);\n\tdouble get_raw_control_dbl_by_id(int control);\n\tstd::string get_raw_control_str_by_id(int control);\n\n\tXPRSint64 get_raw_attribute_int_by_id(int attrib);\n\tdouble get_raw_attribute_dbl_by_id(int attrib);\n\tstd::string get_raw_attribute_str_by_id(int attrib);\n\n\t// Attribute/Control access through string IDs (converted to integer IDs)\n\tvoid set_raw_control_int(const char *control, XPRSint64 value);\n\tvoid set_raw_control_dbl(const char *control, double value);\n\tvoid set_raw_control_str(const char *control, const char *value);\n\tXPRSint64 get_raw_control_int(const char *control);\n\tdouble get_raw_control_dbl(const char *control);\n\tstd::string get_raw_control_str(const char *control);\n\n\tXPRSint64 get_raw_attribute_int(const char *attrib);\n\tdouble get_raw_attribute_dbl(const char *attrib);\n\tstd::string get_raw_attribute_str(const char *attrib);\n\n\t// Type generic Attribute/Control access through string IDs\n\tusing xprs_type_variant_t = std::variant;\n\tvoid set_raw_control(const char *control, xprs_type_variant_t &value);\n\txprs_type_variant_t get_raw_attribute(const char *attrib);\n\txprs_type_variant_t get_raw_control(const char *control);\n\n\t// Callback\n\tvoid set_callback(const Callback &callback, unsigned long long cbctx);\n\txpress_cbs_data cb_get_arguments();\n\n\tdouble cb_get_solution(VariableIndex variable);\n\tdouble cb_get_relaxation(VariableIndex variable);\n\tdouble cb_get_incumbent(VariableIndex variable);\n\tvoid cb_set_solution(VariableIndex variable, double value);\n\tvoid cb_submit_solution();\n\n\tvoid cb_exit();\n\n\t// NOTE: Xpress only provide ways to add local cuts, so, all these functions map to the same\n\t// XPRSaddcuts operation\n\tvoid cb_add_lazy_constraint(const ScalarAffineFunction &function, ConstraintSense sense,\n\t CoeffT rhs);\n\tvoid cb_add_lazy_constraint(const ExprBuilder &function, ConstraintSense sense, CoeffT rhs);\n\tvoid cb_add_user_cut(const ScalarAffineFunction &function, ConstraintSense sense, CoeffT rhs);\n\tvoid cb_add_user_cut(const ExprBuilder &function, ConstraintSense sense, CoeffT rhs);\n\n private: // HELPER FUNCTIONS\n\tvoid _check(int error);\n\tvoid _clear_caches();\n\n\t// Modeling helpers\n\tvoid _set_entity_name(int etype, int index, const char *name);\n\tConstraintIndex _add_sos_constraint(const Vector &variables, SOSType sos_type,\n\t const Vector &weights);\n\tstd::string _get_entity_name(int etype, int eidx);\n\tchar _get_variable_bound_IIS(VariableIndex variable);\n\tint _get_basis_stat(int entity_idx, bool is_row = false);\n\n\t// NLP helpers\n\tTvp _decode_expr(const ExpressionGraph &graph, const ExpressionHandle &expr);\n\tstd::pair, std::vector> _decode_graph_postfix_order(\n\t ExpressionGraph &graph, const ExpressionHandle &result);\n\n\t// Attributes/Controls helpers\n\tint _get_checked_attribute_id(const char *attrib, CATypes expected,\n\t CATypes backup = CATypes::NOTDEFINED);\n\tint _get_checked_control_id(const char *control, CATypes expected,\n\t CATypes backup = CATypes::NOTDEFINED);\n\tstd::pair _get_attribute_info(const char *attrib);\n\tstd::pair _get_control_info(const char *control);\n\n\t// Callback/Mode helpers\n\tvoid _check_expected_mode(XPRESS_MODEL_MODE mode);\n\tvoid _ensure_postsolved();\n\tdouble _cb_get_context_solution(VariableIndex variable);\n\tvoid _cb_add_cut(const ScalarAffineFunction &function, ConstraintSense sense, CoeffT rhs);\n\tXPRSprob _toggle_model_mode(XPRSprob model);\n\n private: // TYPES\n\t// Helper struct used to spawn lower level C callbacks with matching signature\n\ttemplate \n\tstruct CbWrap;\n\n\t// XPRSprob deleter to automatically RAII using unique_ptr\n\tstruct ProbDeleter\n\t{\n\t\tvoid operator()(XPRSprob prob)\n\t\t{\n\t\t\tif (xpress::XPRSdestroyprob(prob) != 0)\n\t\t\t{\n\t\t\t\tthrow std::runtime_error(\"Error while destroying Xpress problem object\");\n\t\t\t}\n\t\t}\n\t};\n\n private: // MEMBER VARIABLES\n\t// Xpress problem pointer\n\tstd::unique_ptr m_model;\n\n\t// Current operating mode (MAIN or CALLBACK) - enables runtime validation that\n\t// callback-only methods aren't called outside callbacks and vice versa\n\tXPRESS_MODEL_MODE m_mode;\n\n\t// Index management for variables and constraints\n\t// Note that Xpress uses the same index set to refer to almost all its constraint types. The\n\t// only exception are SOS which are handled in a separate pool.\n\tMonotoneIndexer m_variable_index;\n\tMonotoneIndexer m_constraint_index;\n\tMonotoneIndexer m_sos_constraint_index;\n\n\t// Tracks whether the model requires postsolving before queries can be made.\n\t// When optimization is interrupted, the model remains in a presolved state where variable\n\t// and constraint indices don't match the original problem structure. Querying model data\n\t// in this state would return incorrect results. Postsolving restores the original index\n\t// mappings but discards all optimization progress, forcing any subsequent optimization\n\t// to restart from scratch.\n\tbool m_need_postsolve = false;\n\n\t// Any non-linear or non-convex quadratic constraint is handled with Xpress non linear solver.\n\t// We keep count of all the non-linear (strictly speaking) constraints.\n\tint m_quad_nl_constr_num = 0;\n\tbool has_quad_objective = false;\n\n\tbool has_nlp_objective = false;\n\tVariableIndex m_nlp_obj_variable;\n\tConstraintIndex m_nlp_obj_constraint;\n\n\t// Cached vectors\n\tstd::vector m_primal_ray;\n\tstd::vector m_dual_ray;\n\tstd::vector m_iis_cols;\n\tstd::vector m_iss_rows;\n\tstd::vector m_iis_bound_types;\n\n\t// Message callback state - we register a default handler but allow user override\n\tbool is_default_message_cb_set;\n\n\t// User callback and active contexts\n\tCallback m_callback = nullptr;\n\tunsigned long long m_curr_contexts = 0; // Bitwise OR of enabled callback contexts\n\n\t// Exception propagation - if a callback throws, we capture it here to let Xpress\n\t// complete cleanup gracefully before rethrowing to Python\n\tstd::vector m_captured_exceptions;\n\n\t// Current callback context being executed\n\tCB_CONTEXT cb_where;\n\n\t// Heuristic solution builder - accumulates (variable, value) pairs during callback;\n\t// submitted to Xpress when callback completes\n\tstd::vector> cb_sol_cache;\n\n\t// Callback-specific arguments - variant holding pointers to context-specific structs\n\t// (e.g., optnode_struct*, intsol_struct*) based on current callback type\n\txpress_cbs_data cb_args = nullptr;\n};\n} // namespace xpress\n" }, { "path": "lib/cache_model.cpp", "content": "// #include \n//\n// #include \"pyoptinterface/core.hpp\"\n// #include \"pyoptinterface/container.hpp\"\n//\n// struct VariableInfo\n//{\n//\tVariableDomain domain;\n// };\n//\n// class CacheModel\n//{\n// public:\n//\tVariableIndex add_variable(VariableDomain domain = VariableDomain::Continuous);\n//\tvoid delete_variable(const VariableIndex &variable);\n//\tbool is_variable_active(const VariableIndex &variable) const;\n//\n//\tConstraintIndex add_linear_constraint(const LinearConstraint &constraint);\n//\tConstraintIndex add_quadratic_constraint(const QuadraticConstraint &constraint);\n//\tConstraintIndex add_sos1_constraint(const SOSConstraint &constraint);\n//\tConstraintIndex add_sos2_constraint(const SOSConstraint &constraint);\n//\n//\tvoid delete_constraint(const ConstraintIndex &constraint);\n//\n//\tbool is_constraint_active(const ConstraintIndex &constraint) const;\n//\n// private:\n//\tint num_variable = 0;\n//\tMonotoneVector m_variable_index;\n//\tVector> m_variables;\n//\n//\tint num_linear_constraint = 0;\n//\tMonotoneVector m_linear_constraint_index;\n//\tVector> m_linear_constraints;\n//\n//\tint num_quadratic_constraint = 0;\n//\tMonotoneVector m_quadratic_constraint_index;\n//\tVector> m_quadratic_constraints;\n//\n//\tint num_sos1_constraint = 0;\n//\tMonotoneVector m_sos1_constraint_index;\n//\tVector> m_sos1_constraints;\n//\n//\tint num_sos2_constraint = 0;\n//\tMonotoneVector m_sos2_constraint_index;\n//\tVector> m_sos2_constraints;\n// };\n//\n// VariableIndex CacheModel::add_variable(VariableDomain domain)\n//{\n//\tIndexT index = m_variable_index.add_index();\n//\tm_variables.push_back(VariableInfo{domain});\n//\tnum_variable++;\n//\treturn VariableIndex(index);\n// }\n//\n// void CacheModel::delete_variable(const VariableIndex &variable)\n//{\n//\tm_variable_index.delete_index(variable.index);\n//\tm_variables[variable.index] = std::nullopt;\n//\tnum_variable--;\n// }\n//\n// bool CacheModel::is_variable_active(const VariableIndex &variable) const\n//{\n//\treturn m_variables[variable.index].has_value();\n// }\n//\n// ConstraintIndex CacheModel::add_linear_constraint(const LinearConstraint &constraint)\n//{\n//\tIndexT index = m_linear_constraint_index.add_index();\n//\tm_linear_constraints.push_back(constraint);\n//\tnum_linear_constraint++;\n//\treturn ConstraintIndex{ConstraintType::Linear, index};\n// }\n//\n// ConstraintIndex CacheModel::add_quadratic_constraint(const QuadraticConstraint &constraint)\n//{\n//\tIndexT index = m_quadratic_constraint_index.add_index();\n//\tm_quadratic_constraints.push_back(constraint);\n//\tnum_quadratic_constraint++;\n//\treturn ConstraintIndex{ConstraintType::Quadratic, index};\n// }\n//\n// ConstraintIndex CacheModel::add_sos1_constraint(const SOSConstraint &constraint)\n//{\n//\tIndexT index = m_sos1_constraint_index.add_index();\n//\tm_sos1_constraints.push_back(constraint);\n//\tnum_sos1_constraint++;\n//\treturn ConstraintIndex{ConstraintType::SOS1, index};\n// }\n//\n// ConstraintIndex CacheModel::add_sos2_constraint(const SOSConstraint &constraint)\n//{\n//\tIndexT index = m_sos2_constraint_index.add_index();\n//\tm_sos2_constraints.push_back(constraint);\n//\tnum_sos2_constraint++;\n//\treturn ConstraintIndex{ConstraintType::SOS2, index};\n// }\n//\n// void CacheModel::delete_constraint(const ConstraintIndex &constraint)\n//{\n//\tauto index = constraint.index;\n//\tswitch (constraint.type)\n//\t{\n//\tcase ConstraintType::Linear:\n//\t\tm_linear_constraint_index.delete_index(index);\n//\t\tm_linear_constraints[index] = std::nullopt;\n//\t\tnum_linear_constraint--;\n//\t\tbreak;\n//\tcase ConstraintType::Quadratic:\n//\t\tm_quadratic_constraint_index.delete_index(index);\n//\t\tm_quadratic_constraints[index] = std::nullopt;\n//\t\tnum_quadratic_constraint--;\n//\t\tbreak;\n//\tcase ConstraintType::SOS1:\n//\t\tm_sos1_constraint_index.delete_index(index);\n//\t\tm_sos1_constraints[index] = std::nullopt;\n//\t\tnum_sos1_constraint--;\n//\t\tbreak;\n//\tcase ConstraintType::SOS2:\n//\t\tm_sos2_constraint_index.delete_index(index);\n//\t\tm_sos2_constraints[index] = std::nullopt;\n//\t\tnum_sos2_constraint--;\n//\t\tbreak;\n//\t}\n// }\n//\n// bool CacheModel::is_constraint_active(const ConstraintIndex &constraint) const\n//{\n//\tauto index = constraint.index;\n//\tswitch (constraint.type)\n//\t{\n//\tcase ConstraintType::Linear:\n//\t\treturn m_linear_constraint_index.has_index(index);\n//\tcase ConstraintType::Quadratic:\n//\t\treturn m_quadratic_constraint_index.has_index(index);\n//\tcase ConstraintType::SOS1:\n//\t\treturn m_sos1_constraint_index.has_index(index);\n//\tcase ConstraintType::SOS2:\n//\t\treturn m_sos2_constraint_index.has_index(index);\n//\t}\n// }\n" }, { "path": "lib/copt_model.cpp", "content": "#include \"pyoptinterface/copt_model.hpp\"\n#include \"fmt/core.h\"\n\n#include \n\nnamespace copt\n{\n#define B DYLIB_DECLARE\nAPILIST\n#undef B\n\nstatic DynamicLibrary lib;\nstatic bool is_loaded = false;\n\nbool is_library_loaded()\n{\n\treturn is_loaded;\n}\n\nbool load_library(const std::string &path)\n{\n\tbool success = lib.try_load(path.c_str());\n\tif (!success)\n\t{\n\t\treturn false;\n\t}\n\n\tDYLIB_LOAD_INIT;\n\n#define B DYLIB_LOAD_FUNCTION\n\tAPILIST\n#undef B\n\n\tif (IS_DYLIB_LOAD_SUCCESS)\n\t{\n#define B DYLIB_SAVE_FUNCTION\n\t\tAPILIST\n#undef B\n\t\tis_loaded = true;\n\t\treturn true;\n\t}\n\telse\n\t{\n\t\treturn false;\n\t}\n}\n} // namespace copt\n\nstatic void check_error(int error)\n{\n\tif (error)\n\t{\n\t\tchar errmsg[COPT_BUFFSIZE];\n\n\t\tcopt::COPT_GetRetcodeMsg(error, errmsg, COPT_BUFFSIZE);\n\t\tthrow std::runtime_error(errmsg);\n\t}\n}\n\nstatic char copt_con_sense(ConstraintSense sense)\n{\n\tswitch (sense)\n\t{\n\tcase ConstraintSense::LessEqual:\n\t\treturn COPT_LESS_EQUAL;\n\tcase ConstraintSense::Equal:\n\t\treturn COPT_EQUAL;\n\tcase ConstraintSense::GreaterEqual:\n\t\treturn COPT_GREATER_EQUAL;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint sense\");\n\t}\n}\n\nstatic int copt_obj_sense(ObjectiveSense sense)\n{\n\tswitch (sense)\n\t{\n\tcase ObjectiveSense::Minimize:\n\t\treturn COPT_MINIMIZE;\n\tcase ObjectiveSense::Maximize:\n\t\treturn COPT_MAXIMIZE;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown objective sense\");\n\t}\n}\n\nstatic char copt_vtype(VariableDomain domain)\n{\n\tswitch (domain)\n\t{\n\tcase VariableDomain::Continuous:\n\t\treturn COPT_CONTINUOUS;\n\tcase VariableDomain::Integer:\n\t\treturn COPT_INTEGER;\n\tcase VariableDomain::Binary:\n\t\treturn COPT_BINARY;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown variable domain\");\n\t}\n}\n\nstatic VariableDomain copt_vtype_to_domain(char vtype)\n{\n\tswitch (vtype)\n\t{\n\tcase COPT_CONTINUOUS:\n\t\treturn VariableDomain::Continuous;\n\tcase COPT_INTEGER:\n\t\treturn VariableDomain::Integer;\n\tcase COPT_BINARY:\n\t\treturn VariableDomain::Binary;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown variable domain\");\n\t}\n}\n\nstatic int copt_sostype(SOSType type)\n{\n\tswitch (type)\n\t{\n\tcase SOSType::SOS1:\n\t\treturn COPT_SOS_TYPE1;\n\tcase SOSType::SOS2:\n\t\treturn COPT_SOS_TYPE2;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown SOS type\");\n\t}\n}\n\nCOPTModel::COPTModel(const COPTEnv &env)\n{\n\tinit(env);\n}\n\nvoid COPTModel::init(const COPTEnv &env)\n{\n\tif (!copt::is_library_loaded())\n\t{\n\t\tthrow std::runtime_error(\"COPT library is not loaded\");\n\t}\n\tcopt_prob *model;\n\tint error = copt::COPT_CreateProb(env.m_env, &model);\n\tcheck_error(error);\n\tm_model = std::unique_ptr(model);\n}\n\nvoid COPTModel::close()\n{\n\tm_model.reset();\n}\n\ndouble COPTModel::get_infinity() const\n{\n\treturn COPT_INFINITY;\n}\n\nvoid COPTModel::write(const std::string &filename)\n{\n\tint error;\n\tif (filename.ends_with(\".mps\"))\n\t{\n\t\terror = copt::COPT_WriteMps(m_model.get(), filename.c_str());\n\t}\n\telse if (filename.ends_with(\".lp\"))\n\t{\n\t\terror = copt::COPT_WriteLp(m_model.get(), filename.c_str());\n\t}\n\telse if (filename.ends_with(\".cbf\"))\n\t{\n\t\terror = copt::COPT_WriteCbf(m_model.get(), filename.c_str());\n\t}\n\telse if (filename.ends_with(\".bin\"))\n\t{\n\t\terror = copt::COPT_WriteBin(m_model.get(), filename.c_str());\n\t}\n\telse if (filename.ends_with(\".bas\"))\n\t{\n\t\terror = copt::COPT_WriteBasis(m_model.get(), filename.c_str());\n\t}\n\telse if (filename.ends_with(\".sol\"))\n\t{\n\t\terror = copt::COPT_WriteSol(m_model.get(), filename.c_str());\n\t}\n\telse if (filename.ends_with(\".mst\"))\n\t{\n\t\terror = copt::COPT_WriteMst(m_model.get(), filename.c_str());\n\t}\n\telse if (filename.ends_with(\".par\"))\n\t{\n\t\terror = copt::COPT_WriteParam(m_model.get(), filename.c_str());\n\t}\n\telse\n\t{\n\t\tthrow std::runtime_error(\"Unknown file extension\");\n\t}\n\tcheck_error(error);\n}\n\nVariableIndex COPTModel::add_variable(VariableDomain domain, double lb, double ub, const char *name)\n{\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\tIndexT index = m_variable_index.add_index();\n\tVariableIndex variable(index);\n\n\tchar vtype = copt_vtype(domain);\n\tint error = copt::COPT_AddCol(m_model.get(), 0.0, 0, NULL, NULL, vtype, lb, ub, name);\n\tcheck_error(error);\n\n\treturn variable;\n}\n\nvoid COPTModel::delete_variable(const VariableIndex &variable)\n{\n\tif (!is_variable_active(variable))\n\t{\n\t\tthrow std::runtime_error(\"Variable does not exist\");\n\t}\n\n\tint variable_column = _variable_index(variable);\n\tint error = copt::COPT_DelCols(m_model.get(), 1, &variable_column);\n\tcheck_error(error);\n\n\tm_variable_index.delete_index(variable.index);\n}\n\nvoid COPTModel::delete_variables(const Vector &variables)\n{\n\tint n_variables = variables.size();\n\tif (n_variables == 0)\n\t\treturn;\n\n\tstd::vector columns;\n\tcolumns.reserve(n_variables);\n\tfor (int i = 0; i < n_variables; i++)\n\t{\n\t\tif (!is_variable_active(variables[i]))\n\t\t{\n\t\t\tcontinue;\n\t\t}\n\t\tauto column = _variable_index(variables[i]);\n\t\tcolumns.push_back(column);\n\t}\n\n\tint error = copt::COPT_DelCols(m_model.get(), columns.size(), columns.data());\n\tcheck_error(error);\n\n\tfor (int i = 0; i < n_variables; i++)\n\t{\n\t\tm_variable_index.delete_index(variables[i].index);\n\t}\n}\n\nbool COPTModel::is_variable_active(const VariableIndex &variable)\n{\n\treturn m_variable_index.has_index(variable.index);\n}\n\ndouble COPTModel::get_variable_value(const VariableIndex &variable)\n{\n\treturn get_variable_info(variable, COPT_DBLINFO_VALUE);\n}\n\nstd::string COPTModel::pprint_variable(const VariableIndex &variable)\n{\n\treturn get_variable_name(variable);\n}\n\nvoid COPTModel::set_variable_bounds(const VariableIndex &variable, double lb, double ub)\n{\n\tauto column = _checked_variable_index(variable);\n\tint error;\n\terror = copt::COPT_SetColLower(m_model.get(), 1, &column, &lb);\n\tcheck_error(error);\n\terror = copt::COPT_SetColUpper(m_model.get(), 1, &column, &ub);\n\tcheck_error(error);\n}\n\nConstraintIndex COPTModel::add_linear_constraint(const ScalarAffineFunction &function,\n ConstraintSense sense, CoeffT rhs,\n const char *name)\n{\n\tIndexT index = m_linear_constraint_index.add_index();\n\tConstraintIndex constraint_index(ConstraintType::Linear, index);\n\n\tAffineFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\n\tint numnz = ptr_form.numnz;\n\tint *cind = ptr_form.index;\n\tdouble *cval = ptr_form.value;\n\tchar g_sense = copt_con_sense(sense);\n\tdouble g_rhs = rhs - function.constant.value_or(0.0);\n\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\n\tint error = copt::COPT_AddRow(m_model.get(), numnz, cind, cval, g_sense, g_rhs, g_rhs, name);\n\tcheck_error(error);\n\treturn constraint_index;\n}\n\nConstraintIndex COPTModel::add_linear_constraint(const ScalarAffineFunction &function,\n const std::tuple &interval,\n const char *name)\n{\n\tauto lb = std::get<0>(interval);\n\tauto ub = std::get<1>(interval);\n\n\tif (function.constant.has_value())\n\t{\n\t\tlb -= function.constant.value_or(0.0);\n\t\tub -= function.constant.value_or(0.0);\n\t}\n\n\tIndexT index = m_linear_constraint_index.add_index();\n\tConstraintIndex constraint_index(ConstraintType::Linear, index);\n\n\tAffineFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\n\tint numnz = ptr_form.numnz;\n\tint *cind = ptr_form.index;\n\tdouble *cval = ptr_form.value;\n\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\n\tint error = copt::COPT_AddRow(m_model.get(), numnz, cind, cval, 0, lb, ub, name);\n\tcheck_error(error);\n\treturn constraint_index;\n\n\treturn ConstraintIndex();\n}\n\nConstraintIndex COPTModel::add_quadratic_constraint(const ScalarQuadraticFunction &function,\n ConstraintSense sense, CoeffT rhs,\n const char *name)\n{\n\tIndexT index = m_quadratic_constraint_index.add_index();\n\tConstraintIndex constraint_index(ConstraintType::Quadratic, index);\n\n\tconst auto &affine_part = function.affine_part;\n\n\tint numlnz = 0;\n\tint *lind = NULL;\n\tdouble *lval = NULL;\n\tAffineFunctionPtrForm affine_ptr_form;\n\tif (affine_part.has_value())\n\t{\n\t\tconst auto &affine_function = affine_part.value();\n\t\taffine_ptr_form.make(this, affine_function);\n\t\tnumlnz = affine_ptr_form.numnz;\n\t\tlind = affine_ptr_form.index;\n\t\tlval = affine_ptr_form.value;\n\t}\n\n\tQuadraticFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\tint numqnz = ptr_form.numnz;\n\tint *qrow = ptr_form.row;\n\tint *qcol = ptr_form.col;\n\tdouble *qval = ptr_form.value;\n\n\tchar g_sense = copt_con_sense(sense);\n\tdouble g_rhs = rhs;\n\tif (affine_part)\n\t\tg_rhs -= affine_part->constant.value_or(0.0);\n\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\n\tint error = copt::COPT_AddQConstr(m_model.get(), numlnz, lind, lval, numqnz, qrow, qcol, qval,\n\t g_sense, g_rhs, name);\n\tcheck_error(error);\n\treturn constraint_index;\n}\n\nConstraintIndex COPTModel::add_sos_constraint(const Vector &variables,\n SOSType sos_type)\n{\n\tVector weights(variables.size(), 1.0);\n\treturn add_sos_constraint(variables, sos_type, weights);\n}\n\nConstraintIndex COPTModel::add_sos_constraint(const Vector &variables,\n SOSType sos_type, const Vector &weights)\n{\n\tIndexT index = m_sos_constraint_index.add_index();\n\tConstraintIndex constraint_index(ConstraintType::SOS, index);\n\n\tint numsos = 1;\n\tint nummembers = variables.size();\n\tint types = copt_sostype(sos_type);\n\tint beg[] = {0};\n\tint cnt[] = {nummembers};\n\tstd::vector ind_v(nummembers);\n\tfor (int i = 0; i < nummembers; i++)\n\t{\n\t\tind_v[i] = _variable_index(variables[i].index);\n\t}\n\tint *ind = ind_v.data();\n\tdouble *weight = (double *)weights.data();\n\n\tint error = copt::COPT_AddSOSs(m_model.get(), numsos, &types, beg, cnt, ind, weight);\n\tcheck_error(error);\n\treturn constraint_index;\n}\n\nConstraintIndex COPTModel::add_second_order_cone_constraint(const Vector &variables,\n const char *name, bool rotated)\n{\n\tIndexT index = m_cone_constraint_index.add_index();\n\tConstraintIndex constraint_index(ConstraintType::SecondOrderCone, index);\n\n\tint N = variables.size();\n\tstd::vector ind_v(N);\n\tfor (int i = 0; i < N; i++)\n\t{\n\t\tind_v[i] = _checked_variable_index(variables[i]);\n\t}\n\n\tint cone = COPT_CONE_QUAD;\n\tif (rotated)\n\t{\n\t\tcone = COPT_CONE_RQUAD;\n\t}\n\n\tint coneType[] = {cone};\n\tint coneBeg[] = {0};\n\tint coneCnt[] = {N};\n\tint *coneIdx = ind_v.data();\n\n\tint error = copt::COPT_AddCones(m_model.get(), 1, coneType, coneBeg, coneCnt, coneIdx);\n\tcheck_error(error);\n\n\t// COPT does not support name for cone constraints\n\n\treturn constraint_index;\n}\n\nConstraintIndex COPTModel::add_exp_cone_constraint(const Vector &variables,\n const char *name, bool dual)\n{\n\tIndexT index = m_exp_cone_constraint_index.add_index();\n\tConstraintIndex constraint_index(ConstraintType::ExponentialCone, index);\n\n\tint N = variables.size();\n\tif (N != 3)\n\t{\n\t\tthrow std::runtime_error(\"Exponential cone constraint must have 3 variables\");\n\t}\n\n\tstd::vector ind_v(N);\n\tfor (int i = 0; i < N; i++)\n\t{\n\t\tind_v[i] = _checked_variable_index(variables[i]);\n\t}\n\n\tint cone = COPT_EXPCONE_PRIMAL;\n\tif (dual)\n\t{\n\t\tcone = COPT_EXPCONE_DUAL;\n\t}\n\n\tint coneType[] = {cone};\n\tint coneBeg[] = {0};\n\tint coneCnt[] = {N};\n\tint *coneIdx = ind_v.data();\n\n\tint error = copt::COPT_AddExpCones(m_model.get(), 1, coneType, coneIdx);\n\tcheck_error(error);\n\n\t// COPT does not support name for cone constraints\n\n\treturn constraint_index;\n}\n\nint unary_opcode(const UnaryOperator &op)\n{\n\tswitch (op)\n\t{\n\tcase UnaryOperator::Neg:\n\t\treturn COPT_NL_NEG;\n\tcase UnaryOperator::Sin:\n\t\treturn COPT_NL_SIN;\n\tcase UnaryOperator::Cos:\n\t\treturn COPT_NL_COS;\n\tcase UnaryOperator::Tan:\n\t\treturn COPT_NL_TAN;\n\tcase UnaryOperator::Asin:\n\t\treturn COPT_NL_ASIN;\n\tcase UnaryOperator::Acos:\n\t\treturn COPT_NL_ACOS;\n\tcase UnaryOperator::Atan:\n\t\treturn COPT_NL_ATAN;\n\tcase UnaryOperator::Abs:\n\t\treturn COPT_NL_ABS;\n\tcase UnaryOperator::Sqrt:\n\t\treturn COPT_NL_SQRT;\n\tcase UnaryOperator::Exp:\n\t\treturn COPT_NL_EXP;\n\tcase UnaryOperator::Log:\n\t\treturn COPT_NL_LOG;\n\tcase UnaryOperator::Log10:\n\t\treturn COPT_NL_LOG10;\n\tdefault: {\n\t\tauto opname = unary_operator_to_string(op);\n\t\tauto msg = fmt::format(\"Unknown unary operator for COPT: {}\", opname);\n\t\tthrow std::runtime_error(msg);\n\t}\n\t}\n}\n\nint binary_opcode(const BinaryOperator &op)\n{\n\tswitch (op)\n\t{\n\tcase BinaryOperator::Sub:\n\t\treturn COPT_NL_MINUS;\n\tcase BinaryOperator::Div:\n\t\treturn COPT_NL_DIV;\n\tcase BinaryOperator::Pow:\n\t\treturn COPT_NL_POW;\n\tcase BinaryOperator::Mul2:\n\t\treturn COPT_NL_MULT;\n\tdefault: {\n\t\tauto opname = binary_operator_to_string(op);\n\t\tauto msg = fmt::format(\"Unknown binary operator for COPT: {}\", opname);\n\t\tthrow std::runtime_error(msg);\n\t}\n\t}\n}\n\nint nary_opcode(const NaryOperator &op)\n{\n\tswitch (op)\n\t{\n\tcase NaryOperator::Add:\n\t\treturn COPT_NL_SUM;\n\tdefault: {\n\t\tauto opname = nary_operator_to_string(op);\n\t\tauto msg = fmt::format(\"Unknown n-ary operator for COPT: {}\", opname);\n\t\tthrow std::runtime_error(msg);\n\t}\n\t}\n}\n\nvoid COPTModel::decode_expr(const ExpressionGraph &graph, const ExpressionHandle &expr,\n std::vector &opcodes, std::vector &constants)\n{\n\tauto array_type = expr.array;\n\tauto index = expr.id;\n\tswitch (array_type)\n\t{\n\tcase ArrayType::Constant: {\n\t\topcodes.push_back(COPT_NL_GET);\n\t\tconstants.push_back(graph.m_constants[index]);\n\t\tbreak;\n\t}\n\tcase ArrayType::Variable: {\n\t\tauto column = _checked_variable_index(graph.m_variables[index]);\n\t\topcodes.push_back(column);\n\t\tbreak;\n\t}\n\tcase ArrayType::Parameter: {\n\t\tthrow std::runtime_error(\"Parameter is not supported in COPT\");\n\t\tbreak;\n\t}\n\tcase ArrayType::Unary: {\n\t\tauto &unary = graph.m_unaries[index];\n\t\tint opcode = unary_opcode(unary.op);\n\t\topcodes.push_back(opcode);\n\t\tbreak;\n\t}\n\tcase ArrayType::Binary: {\n\t\tauto &binary = graph.m_binaries[index];\n\t\tint opcode = binary_opcode(binary.op);\n\t\topcodes.push_back(opcode);\n\t\tbreak;\n\t}\n\tcase ArrayType::Ternary: {\n\t\tthrow std::runtime_error(\"Ternary operator is not supported in COPT\");\n\t\tbreak;\n\t}\n\tcase ArrayType::Nary: {\n\t\tauto &nary = graph.m_naries[index];\n\t\tint opcode = nary_opcode(nary.op);\n\t\tint n_operands = nary.operands.size();\n\n\t\tif (opcode == COPT_NL_SUM && n_operands == 1)\n\t\t{\n\t\t\t// COPT errors when sum 1 operand\n\t\t}\n\t\telse\n\t\t{\n\t\t\topcodes.push_back(opcode);\n\t\t\topcodes.push_back(n_operands);\n\t\t}\n\t}\n\tbreak;\n\t}\n}\n\nvoid COPTModel::decode_graph_prefix_order(ExpressionGraph &graph, const ExpressionHandle &result,\n std::vector &opcodes, std::vector &constants)\n{\n\tstd::stack expr_stack;\n\n\t// init stack\n\texpr_stack.push(result);\n\n\twhile (!expr_stack.empty())\n\t{\n\t\tauto expr = expr_stack.top();\n\t\texpr_stack.pop();\n\n\t\t// We need to convert the n-arg multiplication to 2-arg multiplication\n\t\tif (expr.array == ArrayType::Nary && graph.m_naries[expr.id].op == NaryOperator::Mul)\n\t\t{\n\t\t\tauto &nary = graph.m_naries[expr.id];\n\t\t\tint n_operands = nary.operands.size();\n\n\t\t\tif (n_operands == 1)\n\t\t\t{\n\t\t\t\texpr = nary.operands[0];\n\t\t\t}\n\t\t\telse if (n_operands >= 2)\n\t\t\t{\n\t\t\t\tExpressionHandle left = nary.operands[0];\n\t\t\t\tExpressionHandle right = nary.operands[1];\n\t\t\t\tExpressionHandle new_expr = graph.add_binary(BinaryOperator::Mul2, left, right);\n\t\t\t\tfor (int i = 2; i < n_operands; i++)\n\t\t\t\t{\n\t\t\t\t\tnew_expr = graph.add_binary(BinaryOperator::Mul2, new_expr, nary.operands[i]);\n\t\t\t\t}\n\t\t\t\texpr = new_expr;\n\t\t\t}\n\t\t}\n\n\t\tdecode_expr(graph, expr, opcodes, constants);\n\n\t\tauto array_type = expr.array;\n\t\tauto index = expr.id;\n\t\tswitch (array_type)\n\t\t{\n\t\tcase ArrayType::Unary: {\n\t\t\tauto &unary = graph.m_unaries[index];\n\t\t\texpr_stack.push(unary.operand);\n\t\t\tbreak;\n\t\t}\n\t\tcase ArrayType::Binary: {\n\t\t\tauto &binary = graph.m_binaries[index];\n\t\t\texpr_stack.push(binary.right);\n\t\t\texpr_stack.push(binary.left);\n\t\t\tbreak;\n\t\t}\n\t\tcase ArrayType::Nary: {\n\t\t\tauto &nary = graph.m_naries[index];\n\t\t\tfor (int i = nary.operands.size() - 1; i >= 0; i--)\n\t\t\t{\n\t\t\t\texpr_stack.push(nary.operands[i]);\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\tdefault:\n\t\t\tbreak;\n\t\t}\n\t}\n}\n\nConstraintIndex COPTModel::add_single_nl_constraint(ExpressionGraph &graph,\n const ExpressionHandle &result,\n const std::tuple &interval,\n const char *name)\n{\n\tdouble lb = std::get<0>(interval);\n\tdouble ub = std::get<1>(interval);\n\n\tstd::vector opcodes;\n\tstd::vector constants;\n\n\tdecode_graph_prefix_order(graph, result, opcodes, constants);\n\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\n\t// add NL constraint\n\tint error =\n\t copt::COPT_AddNLConstr(m_model.get(), opcodes.size(), constants.size(), opcodes.data(),\n\t constants.data(), 0, nullptr, nullptr, 0, lb, ub, name);\n\tcheck_error(error);\n\n\tIndexT constraint_index = m_nl_constraint_index.add_index();\n\n\tConstraintIndex constraint(ConstraintType::NL, constraint_index);\n\n\treturn constraint;\n}\n\nvoid COPTModel::delete_constraint(const ConstraintIndex &constraint)\n{\n\tint error = 0;\n\tint constraint_row = _constraint_index(constraint);\n\tif (constraint_row >= 0)\n\t{\n\t\tswitch (constraint.type)\n\t\t{\n\t\tcase ConstraintType::Linear:\n\t\t\tm_linear_constraint_index.delete_index(constraint.index);\n\t\t\terror = copt::COPT_DelRows(m_model.get(), 1, &constraint_row);\n\t\t\tbreak;\n\t\tcase ConstraintType::Quadratic:\n\t\t\tm_quadratic_constraint_index.delete_index(constraint.index);\n\t\t\terror = copt::COPT_DelQConstrs(m_model.get(), 1, &constraint_row);\n\t\t\tbreak;\n\t\tcase ConstraintType::SOS:\n\t\t\tm_sos_constraint_index.delete_index(constraint.index);\n\t\t\terror = copt::COPT_DelSOSs(m_model.get(), 1, &constraint_row);\n\t\t\tbreak;\n\t\tcase ConstraintType::SecondOrderCone:\n\t\t\tm_cone_constraint_index.delete_index(constraint.index);\n\t\t\terror = copt::COPT_DelCones(m_model.get(), 1, &constraint_row);\n\t\t\tbreak;\n\t\tcase ConstraintType::ExponentialCone:\n\t\t\tm_exp_cone_constraint_index.delete_index(constraint.index);\n\t\t\terror = copt::COPT_DelExpCones(m_model.get(), 1, &constraint_row);\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t\t}\n\t}\n\tcheck_error(error);\n}\n\nbool COPTModel::is_constraint_active(const ConstraintIndex &constraint)\n{\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\t\treturn m_linear_constraint_index.has_index(constraint.index);\n\tcase ConstraintType::Quadratic:\n\t\treturn m_quadratic_constraint_index.has_index(constraint.index);\n\tcase ConstraintType::SOS:\n\t\treturn m_sos_constraint_index.has_index(constraint.index);\n\tcase ConstraintType::SecondOrderCone:\n\t\treturn m_cone_constraint_index.has_index(constraint.index);\n\tcase ConstraintType::ExponentialCone:\n\t\treturn m_exp_cone_constraint_index.has_index(constraint.index);\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n}\n\nvoid COPTModel::_set_affine_objective(const ScalarAffineFunction &function, ObjectiveSense sense,\n bool clear_quadratic)\n{\n\tint error = 0;\n\tif (clear_quadratic)\n\t{\n\t\t// First delete all quadratic terms\n\t\terror = copt::COPT_DelQuadObj(m_model.get());\n\t\tcheck_error(error);\n\t}\n\n\t// Set Obj attribute of each variable\n\tint n_variables = get_raw_attribute_int(COPT_INTATTR_COLS);\n\tstd::vector ind_v(n_variables);\n\tfor (int i = 0; i < n_variables; i++)\n\t{\n\t\tind_v[i] = i;\n\t}\n\tstd::vector obj_v(n_variables, 0.0);\n\n\tint numnz = function.size();\n\tfor (int i = 0; i < numnz; i++)\n\t{\n\t\tauto column = _variable_index(function.variables[i]);\n\t\tif (column < 0)\n\t\t{\n\t\t\tthrow std::runtime_error(\"Variable does not exist\");\n\t\t}\n\t\tobj_v[column] = function.coefficients[i];\n\t}\n\n\terror = copt::COPT_ReplaceColObj(m_model.get(), n_variables, ind_v.data(), obj_v.data());\n\tcheck_error(error);\n\terror = copt::COPT_SetObjConst(m_model.get(), function.constant.value_or(0.0));\n\tcheck_error(error);\n\n\tint obj_sense = copt_obj_sense(sense);\n\terror = copt::COPT_SetObjSense(m_model.get(), obj_sense);\n\tcheck_error(error);\n}\n\nvoid COPTModel::set_objective(const ScalarAffineFunction &function, ObjectiveSense sense)\n{\n\t_set_affine_objective(function, sense, true);\n}\n\nvoid COPTModel::set_objective(const ScalarQuadraticFunction &function, ObjectiveSense sense)\n{\n\tint error = 0;\n\t// First delete all quadratic terms\n\terror = copt::COPT_DelQuadObj(m_model.get());\n\tcheck_error(error);\n\n\t// Add quadratic term\n\tint numqnz = function.size();\n\tif (numqnz > 0)\n\t{\n\t\tQuadraticFunctionPtrForm ptr_form;\n\t\tptr_form.make(this, function);\n\t\tint numqnz = ptr_form.numnz;\n\t\tint *qrow = ptr_form.row;\n\t\tint *qcol = ptr_form.col;\n\t\tdouble *qval = ptr_form.value;\n\n\t\terror = copt::COPT_SetQuadObj(m_model.get(), numqnz, qrow, qcol, qval);\n\t\tcheck_error(error);\n\t}\n\n\t// Affine part\n\tconst auto &affine_part = function.affine_part;\n\tif (affine_part)\n\t{\n\t\tconst auto &affine_function = affine_part.value();\n\t\t_set_affine_objective(affine_function, sense, false);\n\t}\n\telse\n\t{\n\t\tScalarAffineFunction zero;\n\t\t_set_affine_objective(zero, sense, false);\n\t}\n}\n\nvoid COPTModel::set_objective(const ExprBuilder &function, ObjectiveSense sense)\n{\n\tauto deg = function.degree();\n\tif (deg <= 1)\n\t{\n\t\tScalarAffineFunction f(function);\n\t\tset_objective(f, sense);\n\t}\n\telse if (deg == 2)\n\t{\n\t\tScalarQuadraticFunction f(function);\n\t\tset_objective(f, sense);\n\t}\n\telse\n\t{\n\t\tthrow std::runtime_error(\"Objective must be linear or quadratic\");\n\t}\n}\n\nvoid COPTModel::add_single_nl_objective(ExpressionGraph &graph, const ExpressionHandle &result)\n{\n\tdecode_graph_prefix_order(graph, result, m_nl_objective_opcodes, m_nl_objective_constants);\n\n\tm_nl_objective_num += 1;\n\tm_nl_objective_opcodes[1] = m_nl_objective_num;\n}\n\nvoid COPTModel::set_nl_objective()\n{\n\tint error = 0;\n\tif (m_nl_objective_num > 0)\n\t{\n\t\tint nToken = m_nl_objective_opcodes.size();\n\t\tint nTokenElem = m_nl_objective_constants.size();\n\t\tint *token = m_nl_objective_opcodes.data();\n\t\tdouble *tokenElem = m_nl_objective_constants.data();\n\n\t\tif (m_nl_objective_num == 1)\n\t\t{\n\t\t\tnToken -= 2;\n\t\t\ttoken += 2;\n\t\t}\n\n\t\t/*fmt::print(\"COPT_SetNLObj opcodes: {}\\n\", std::vector(token, token + nToken));\n\t\tfmt::print(\"COPT_SetNLObj constants: {}\\n\",\n\t\t std::vector(tokenElem, tokenElem + nTokenElem));*/\n\n\t\terror = copt::COPT_SetNLObj(m_model.get(), nToken, nTokenElem, token, tokenElem);\n\t\tcheck_error(error);\n\t}\n}\n\nvoid COPTModel::optimize()\n{\n\tif (has_callback)\n\t{\n\t\t// Store the number of variables for the callback\n\t\tm_callback_userdata.n_variables = get_raw_attribute_int(\"Cols\");\n\t}\n\tset_nl_objective();\n\tint error = copt::COPT_Solve(m_model.get());\n\tcheck_error(error);\n}\n\nint COPTModel::raw_parameter_attribute_type(const char *name)\n{\n\tint retval;\n\tint error = copt::COPT_SearchParamAttr(m_model.get(), name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nvoid COPTModel::set_raw_parameter_int(const char *param_name, int value)\n{\n\tint error = copt::COPT_SetIntParam(m_model.get(), param_name, value);\n\tcheck_error(error);\n}\n\nvoid COPTModel::set_raw_parameter_double(const char *param_name, double value)\n{\n\tint error = copt::COPT_SetDblParam(m_model.get(), param_name, value);\n\tcheck_error(error);\n}\n\nint COPTModel::get_raw_parameter_int(const char *param_name)\n{\n\tint retval;\n\tint error = copt::COPT_GetIntParam(m_model.get(), param_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble COPTModel::get_raw_parameter_double(const char *param_name)\n{\n\tdouble retval;\n\tint error = copt::COPT_GetDblParam(m_model.get(), param_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nint COPTModel::get_raw_attribute_int(const char *attr_name)\n{\n\tint retval;\n\tint error = copt::COPT_GetIntAttr(m_model.get(), attr_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble COPTModel::get_raw_attribute_double(const char *attr_name)\n{\n\tdouble retval;\n\tint error = copt::COPT_GetDblAttr(m_model.get(), attr_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble COPTModel::get_variable_info(const VariableIndex &variable, const char *info_name)\n{\n\tauto column = _checked_variable_index(variable);\n\tdouble retval;\n\tint error = copt::COPT_GetColInfo(m_model.get(), info_name, 1, &column, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nstd::string COPTModel::get_variable_name(const VariableIndex &variable)\n{\n\tauto column = _checked_variable_index(variable);\n\tint error;\n\tint reqsize;\n\terror = copt::COPT_GetColName(m_model.get(), column, NULL, 0, &reqsize);\n\tcheck_error(error);\n\tstd::string retval(reqsize - 1, '\\0');\n\terror = copt::COPT_GetColName(m_model.get(), column, retval.data(), reqsize, &reqsize);\n\tcheck_error(error);\n\treturn retval;\n}\n\nvoid COPTModel::set_variable_name(const VariableIndex &variable, const char *name)\n{\n\tauto column = _checked_variable_index(variable);\n\tconst char *names[] = {name};\n\tint error = copt::COPT_SetColNames(m_model.get(), 1, &column, names);\n\tcheck_error(error);\n}\n\nVariableDomain COPTModel::get_variable_type(const VariableIndex &variable)\n{\n\tauto column = _checked_variable_index(variable);\n\tchar vtype;\n\tint error = copt::COPT_GetColType(m_model.get(), 1, &column, &vtype);\n\tcheck_error(error);\n\treturn copt_vtype_to_domain(vtype);\n}\n\nvoid COPTModel::set_variable_type(const VariableIndex &variable, VariableDomain domain)\n{\n\tchar vtype = copt_vtype(domain);\n\tauto column = _checked_variable_index(variable);\n\tint error = copt::COPT_SetColType(m_model.get(), 1, &column, &vtype);\n\tcheck_error(error);\n}\n\nvoid COPTModel::set_variable_lower_bound(const VariableIndex &variable, double lb)\n{\n\tauto column = _checked_variable_index(variable);\n\tint error = copt::COPT_SetColLower(m_model.get(), 1, &column, &lb);\n\tcheck_error(error);\n}\n\nvoid COPTModel::set_variable_upper_bound(const VariableIndex &variable, double ub)\n{\n\tauto column = _checked_variable_index(variable);\n\tint error = copt::COPT_SetColUpper(m_model.get(), 1, &column, &ub);\n\tcheck_error(error);\n}\n\ndouble COPTModel::get_constraint_info(const ConstraintIndex &constraint, const char *info_name)\n{\n\tint row = _checked_constraint_index(constraint);\n\tdouble retval;\n\tint num = 1;\n\tint error;\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\t\terror = copt::COPT_GetRowInfo(m_model.get(), info_name, num, &row, &retval);\n\t\tbreak;\n\tcase ConstraintType::Quadratic:\n\t\terror = copt::COPT_GetQConstrInfo(m_model.get(), info_name, num, &row, &retval);\n\t\tbreak;\n\tcase ConstraintType::NL:\n\t\terror = copt::COPT_GetNLConstrInfo(m_model.get(), info_name, num, &row, &retval);\n\t\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n\tcheck_error(error);\n\treturn retval;\n}\n\nstd::string COPTModel::get_constraint_name(const ConstraintIndex &constraint)\n{\n\tint row = _checked_constraint_index(constraint);\n\tint error;\n\tint reqsize;\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\t\terror = copt::COPT_GetRowName(m_model.get(), row, NULL, 0, &reqsize);\n\t\tbreak;\n\tcase ConstraintType::Quadratic:\n\t\terror = copt::COPT_GetQConstrName(m_model.get(), row, NULL, 0, &reqsize);\n\t\tbreak;\n\tcase ConstraintType::NL:\n\t\terror = copt::COPT_GetNLConstrName(m_model.get(), row, NULL, 0, &reqsize);\n\t\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n\tcheck_error(error);\n\tstd::string retval(reqsize - 1, '\\0');\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\t\terror = copt::COPT_GetRowName(m_model.get(), row, retval.data(), reqsize, &reqsize);\n\t\tbreak;\n\tcase ConstraintType::Quadratic:\n\t\terror = copt::COPT_GetQConstrName(m_model.get(), row, retval.data(), reqsize, &reqsize);\n\t\tbreak;\n\t}\n\tcheck_error(error);\n\treturn retval;\n}\n\nvoid COPTModel::set_constraint_name(const ConstraintIndex &constraint, const char *name)\n{\n\tint row = _checked_constraint_index(constraint);\n\tconst char *names[] = {name};\n\tint error;\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\t\terror = copt::COPT_SetRowNames(m_model.get(), 1, &row, names);\n\t\tbreak;\n\tcase ConstraintType::Quadratic:\n\t\terror = copt::COPT_SetQConstrNames(m_model.get(), 1, &row, names);\n\t\tbreak;\n\tcase ConstraintType::NL:\n\t\terror = copt::COPT_SetNLConstrNames(m_model.get(), 1, &row, names);\n\t\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n\tcheck_error(error);\n}\n\nvoid COPTModel::set_obj_sense(ObjectiveSense sense)\n{\n\tint obj_sense = copt_obj_sense(sense);\n\tint error = copt::COPT_SetObjSense(m_model.get(), obj_sense);\n\tcheck_error(error);\n}\n\nvoid COPTModel::add_mip_start(const Vector &variables, const Vector &values)\n{\n\tif (variables.size() != values.size())\n\t{\n\t\tthrow std::runtime_error(\"Number of variables and values do not match\");\n\t}\n\tint numnz = variables.size();\n\tif (numnz == 0)\n\t\treturn;\n\n\tstd::vector ind_v(numnz);\n\tfor (int i = 0; i < numnz; i++)\n\t{\n\t\tind_v[i] = _variable_index(variables[i].index);\n\t}\n\tint *ind = ind_v.data();\n\tdouble *val = (double *)values.data();\n\n\tint error = copt::COPT_AddMipStart(m_model.get(), numnz, ind, val);\n\tcheck_error(error);\n}\n\nvoid COPTModel::add_nl_start(const Vector &variables, const Vector &values)\n{\n\tif (variables.size() != values.size())\n\t{\n\t\tthrow std::runtime_error(\"Number of variables and values do not match\");\n\t}\n\tint numnz = variables.size();\n\tif (numnz == 0)\n\t\treturn;\n\n\tstd::vector ind_v(numnz);\n\tfor (int i = 0; i < numnz; i++)\n\t{\n\t\tind_v[i] = _variable_index(variables[i].index);\n\t}\n\tint *ind = ind_v.data();\n\tdouble *val = (double *)values.data();\n\n\tint error = copt::COPT_SetNLPrimalStart(m_model.get(), numnz, ind, val);\n\tcheck_error(error);\n}\n\ndouble COPTModel::get_normalized_rhs(const ConstraintIndex &constraint)\n{\n\tint row = _checked_constraint_index(constraint);\n\tint num = 1;\n\tint error;\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear: {\n\t\tdouble lb, ub;\n\t\terror = copt::COPT_GetRowInfo(m_model.get(), COPT_DBLINFO_LB, num, &row, &lb);\n\t\tcheck_error(error);\n\t\terror = copt::COPT_GetRowInfo(m_model.get(), COPT_DBLINFO_UB, num, &row, &ub);\n\t\tcheck_error(error);\n\n\t\tbool lb_inf = lb < -COPT_INFINITY + 1.0;\n\t\tbool ub_inf = ub > COPT_INFINITY - 1.0;\n\n\t\tif (!lb_inf)\n\t\t\treturn lb;\n\t\tif (!ub_inf)\n\t\t\treturn ub;\n\n\t\tthrow std::runtime_error(\"Constraint has no finite bound\");\n\t}\n\tbreak;\n\tcase ConstraintType::Quadratic: {\n\t\tdouble rhs;\n\t\terror = copt::COPT_GetQConstrRhs(m_model.get(), num, &row, &rhs);\n\t\tcheck_error(error);\n\t\treturn rhs;\n\t}\n\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type to get_normalized_rhs\");\n\t}\n}\n\nvoid COPTModel::set_normalized_rhs(const ConstraintIndex &constraint, double value)\n{\n\tint row = _checked_constraint_index(constraint);\n\tint num = 1;\n\tint error;\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear: {\n\t\tdouble lb, ub;\n\n\t\terror = copt::COPT_GetRowInfo(m_model.get(), COPT_DBLINFO_LB, num, &row, &lb);\n\t\tcheck_error(error);\n\t\terror = copt::COPT_GetRowInfo(m_model.get(), COPT_DBLINFO_UB, num, &row, &ub);\n\t\tcheck_error(error);\n\n\t\tbool lb_inf = lb < -COPT_INFINITY + 1.0;\n\t\tbool ub_inf = ub > COPT_INFINITY - 1.0;\n\n\t\tif (!lb_inf)\n\t\t{\n\t\t\terror = copt::COPT_SetRowLower(m_model.get(), num, &row, &value);\n\t\t\tcheck_error(error);\n\t\t}\n\t\tif (!ub_inf)\n\t\t{\n\t\t\terror = copt::COPT_SetRowUpper(m_model.get(), num, &row, &value);\n\t\t\tcheck_error(error);\n\t\t}\n\n\t\tif (lb_inf && ub_inf)\n\t\t{\n\t\t\tthrow std::runtime_error(\"Constraint has no finite bound\");\n\t\t}\n\t}\n\tbreak;\n\tcase ConstraintType::Quadratic: {\n\t\terror = copt::COPT_SetQConstrRhs(m_model.get(), num, &row, &value);\n\t\tcheck_error(error);\n\t}\n\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type to set_normalized_rhs\");\n\t}\n}\n\ndouble COPTModel::get_normalized_coefficient(const ConstraintIndex &constraint,\n const VariableIndex &variable)\n{\n\tif (constraint.type != ConstraintType::Linear)\n\t{\n\t\tthrow std::runtime_error(\"Only linear constraint supports get_normalized_coefficient\");\n\t}\n\tint row = _checked_constraint_index(constraint);\n\tint col = _checked_variable_index(variable);\n\tdouble retval;\n\tint error = copt::COPT_GetElem(m_model.get(), col, row, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nvoid COPTModel::set_normalized_coefficient(const ConstraintIndex &constraint,\n const VariableIndex &variable, double value)\n{\n\tif (constraint.type != ConstraintType::Linear)\n\t{\n\t\tthrow std::runtime_error(\"Only linear constraint supports set_normalized_coefficient\");\n\t}\n\tint row = _checked_constraint_index(constraint);\n\tint col = _checked_variable_index(variable);\n\tint error = copt::COPT_SetElem(m_model.get(), col, row, value);\n\tcheck_error(error);\n}\n\ndouble COPTModel::get_objective_coefficient(const VariableIndex &variable)\n{\n\treturn get_variable_info(variable, COPT_DBLINFO_OBJ);\n}\n\nvoid COPTModel::set_objective_coefficient(const VariableIndex &variable, double value)\n{\n\tauto column = _checked_variable_index(variable);\n\tint error = copt::COPT_SetColObj(m_model.get(), 1, &column, &value);\n\tcheck_error(error);\n}\n\nint COPTModel::_variable_index(const VariableIndex &variable)\n{\n\treturn m_variable_index.get_index(variable.index);\n}\n\nint COPTModel::_checked_variable_index(const VariableIndex &variable)\n{\n\tint column = _variable_index(variable);\n\tif (column < 0)\n\t{\n\t\tthrow std::runtime_error(\"Variable does not exist\");\n\t}\n\treturn column;\n}\n\nint COPTModel::_constraint_index(const ConstraintIndex &constraint)\n{\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\t\treturn m_linear_constraint_index.get_index(constraint.index);\n\tcase ConstraintType::Quadratic:\n\t\treturn m_quadratic_constraint_index.get_index(constraint.index);\n\tcase ConstraintType::SOS:\n\t\treturn m_sos_constraint_index.get_index(constraint.index);\n\tcase ConstraintType::SecondOrderCone:\n\t\treturn m_cone_constraint_index.get_index(constraint.index);\n\tcase ConstraintType::ExponentialCone:\n\t\treturn m_exp_cone_constraint_index.get_index(constraint.index);\n\tcase ConstraintType::NL:\n\t\treturn m_nl_constraint_index.get_index(constraint.index);\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n}\n\nint COPTModel::_checked_constraint_index(const ConstraintIndex &constraint)\n{\n\tint row = _constraint_index(constraint);\n\tif (row < 0)\n\t{\n\t\tthrow std::runtime_error(\"Constraint does not exist\");\n\t}\n\treturn row;\n}\n\nvoid *COPTModel::get_raw_model()\n{\n\treturn m_model.get();\n}\n\nstd::string COPTModel::version_string()\n{\n\tchar buffer[COPT_BUFFSIZE];\n\tcopt::COPT_GetBanner(buffer, COPT_BUFFSIZE);\n\treturn buffer;\n}\n\nCOPTEnv::COPTEnv()\n{\n\tif (!copt::is_library_loaded())\n\t{\n\t\tthrow std::runtime_error(\"COPT library is not loaded\");\n\t}\n\tint error = copt::COPT_CreateEnv(&m_env);\n\tcheck_error(error);\n}\n\nCOPTEnv::COPTEnv(COPTEnvConfig &config)\n{\n\tif (!copt::is_library_loaded())\n\t{\n\t\tthrow std::runtime_error(\"COPT library is not loaded\");\n\t}\n\tint error = copt::COPT_CreateEnvWithConfig(config.m_config, &m_env);\n\tcheck_error(error);\n}\n\nCOPTEnv::~COPTEnv()\n{\n\tint error = copt::COPT_DeleteEnv(&m_env);\n\tcheck_error(error);\n}\n\nvoid COPTEnv::close()\n{\n\tif (m_env != nullptr)\n\t{\n\t\tcopt::COPT_DeleteEnv(&m_env);\n\t}\n\tm_env = nullptr;\n}\n\nCOPTEnvConfig::COPTEnvConfig()\n{\n\tif (!copt::is_library_loaded())\n\t{\n\t\tthrow std::runtime_error(\"COPT library is not loaded\");\n\t}\n\tint error = copt::COPT_CreateEnvConfig(&m_config);\n\tcheck_error(error);\n}\n\nCOPTEnvConfig::~COPTEnvConfig()\n{\n\tint error = copt::COPT_DeleteEnvConfig(&m_config);\n\tcheck_error(error);\n}\n\nvoid COPTEnvConfig::set(const char *param_name, const char *value)\n{\n\tint error = copt::COPT_SetEnvConfig(m_config, param_name, value);\n\tcheck_error(error);\n}\n\n// Logging callback\nstatic void RealLoggingCallbackFunction(char *msg, void *logdata)\n{\n\tauto real_logdata = static_cast(logdata);\n\tauto &callback = real_logdata->callback;\n\tcallback(msg);\n}\n\nvoid COPTModel::set_logging(const COPTLoggingCallback &callback)\n{\n\tm_logging_callback_userdata.callback = callback;\n\tint error = copt::COPT_SetLogCallback(m_model.get(), &RealLoggingCallbackFunction,\n\t &m_logging_callback_userdata);\n\tcheck_error(error);\n}\n\n// Callback\nstatic int RealCOPTCallbackFunction(copt_prob *prob, void *cbdata, int cbctx, void *userdata)\n{\n\tauto real_userdata = static_cast(userdata);\n\tauto model = static_cast(real_userdata->model);\n\tauto &callback = real_userdata->callback;\n\n\tmodel->m_cbdata = cbdata;\n\tmodel->m_callback_userdata.where = cbctx;\n\tmodel->m_callback_userdata.cb_get_mipsol_called = false;\n\tmodel->m_callback_userdata.cb_get_mipnoderel_called = false;\n\tmodel->m_callback_userdata.cb_get_mipincumbent_called = false;\n\tmodel->m_callback_userdata.cb_set_solution_called = false;\n\tmodel->m_callback_userdata.cb_requires_submit_solution = false;\n\tcallback(model, cbctx);\n\n\tif (model->m_callback_userdata.cb_requires_submit_solution)\n\t{\n\t\tmodel->cb_submit_solution();\n\t}\n\n\treturn COPT_RETCODE_OK;\n}\n\nvoid COPTModel::set_callback(const COPTCallback &callback, int cbctx)\n{\n\tm_callback_userdata.model = this;\n\tm_callback_userdata.callback = callback;\n\n\tint error = copt::COPT_SetCallback(m_model.get(), RealCOPTCallbackFunction, cbctx,\n\t &m_callback_userdata);\n\tcheck_error(error);\n\n\thas_callback = true;\n}\n\nint COPTModel::cb_get_info_int(const std::string &what)\n{\n\tint retval;\n\tint error = copt::COPT_GetCallbackInfo(m_cbdata, what.c_str(), &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble COPTModel::cb_get_info_double(const std::string &what)\n{\n\tdouble retval;\n\tint error = copt::COPT_GetCallbackInfo(m_cbdata, what.c_str(), &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nvoid COPTModel::cb_get_info_doublearray(const std::string &what)\n{\n\tint n_vars = m_callback_userdata.n_variables;\n\tdouble *val = nullptr;\n\tif (what == COPT_CBINFO_MIPCANDIDATE)\n\t{\n\t\tm_callback_userdata.mipsol.resize(n_vars);\n\t\tval = m_callback_userdata.mipsol.data();\n\t}\n\telse if (what == COPT_CBINFO_RELAXSOLUTION)\n\t{\n\t\tm_callback_userdata.mipnoderel.resize(n_vars);\n\t\tval = m_callback_userdata.mipnoderel.data();\n\t}\n\telse if (what == COPT_CBINFO_INCUMBENT)\n\t{\n\t\tm_callback_userdata.mipincumbent.resize(n_vars);\n\t\tval = m_callback_userdata.mipincumbent.data();\n\t}\n\telse\n\t{\n\t\tthrow std::runtime_error(\"Invalid what for cb_get_info_doublearray\");\n\t}\n\tint error = copt::COPT_GetCallbackInfo(m_cbdata, what.c_str(), val);\n\tcheck_error(error);\n}\n\ndouble COPTModel::cb_get_solution(const VariableIndex &variable)\n{\n\tauto &userdata = m_callback_userdata;\n\tif (!userdata.cb_get_mipsol_called)\n\t{\n\t\tcb_get_info_doublearray(COPT_CBINFO_MIPCANDIDATE);\n\t\tuserdata.cb_get_mipsol_called = true;\n\t}\n\tauto index = _variable_index(variable);\n\treturn userdata.mipsol[index];\n}\n\ndouble COPTModel::cb_get_relaxation(const VariableIndex &variable)\n{\n\tauto &userdata = m_callback_userdata;\n\tif (!userdata.cb_get_mipnoderel_called)\n\t{\n\t\tcb_get_info_doublearray(COPT_CBINFO_RELAXSOLUTION);\n\t\tuserdata.cb_get_mipnoderel_called = true;\n\t}\n\tauto index = _variable_index(variable);\n\treturn userdata.mipnoderel[index];\n}\n\ndouble COPTModel::cb_get_incumbent(const VariableIndex &variable)\n{\n\tauto &userdata = m_callback_userdata;\n\tif (!userdata.cb_get_mipincumbent_called)\n\t{\n\t\tcb_get_info_doublearray(COPT_CBINFO_INCUMBENT);\n\t\tuserdata.cb_get_mipincumbent_called = true;\n\t}\n\tauto index = _variable_index(variable);\n\treturn userdata.mipincumbent[index];\n}\n\nvoid COPTModel::cb_set_solution(const VariableIndex &variable, double value)\n{\n\tauto &userdata = m_callback_userdata;\n\tif (!userdata.cb_set_solution_called)\n\t{\n\t\tuserdata.heuristic_solution.resize(userdata.n_variables, COPT_UNDEFINED);\n\t\tuserdata.cb_set_solution_called = true;\n\t}\n\tuserdata.heuristic_solution[_variable_index(variable)] = value;\n\tm_callback_userdata.cb_requires_submit_solution = true;\n}\n\ndouble COPTModel::cb_submit_solution()\n{\n\tif (!m_callback_userdata.cb_set_solution_called)\n\t{\n\t\tthrow std::runtime_error(\"No solution is set in the callback!\");\n\t}\n\tdouble obj;\n\tint error = copt::COPT_AddCallbackSolution(m_cbdata,\n\t m_callback_userdata.heuristic_solution.data(), &obj);\n\tcheck_error(error);\n\tm_callback_userdata.cb_requires_submit_solution = false;\n\treturn obj;\n}\n\nvoid COPTModel::cb_exit()\n{\n\tint error = copt::COPT_Interrupt(m_model.get());\n\tcheck_error(error);\n}\n\nvoid COPTModel::cb_add_lazy_constraint(const ScalarAffineFunction &function, ConstraintSense sense,\n CoeffT rhs)\n{\n\tAffineFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\n\tint numnz = ptr_form.numnz;\n\tint *cind = ptr_form.index;\n\tdouble *cval = ptr_form.value;\n\tchar g_sense = copt_con_sense(sense);\n\tdouble g_rhs = rhs - function.constant.value_or(0.0);\n\n\tint error = copt::COPT_AddCallbackLazyConstr(m_cbdata, numnz, cind, cval, g_sense, g_rhs);\n\tcheck_error(error);\n}\n\nvoid COPTModel::cb_add_lazy_constraint(const ExprBuilder &function, ConstraintSense sense,\n CoeffT rhs)\n{\n\tScalarAffineFunction f(function);\n\tcb_add_lazy_constraint(f, sense, rhs);\n}\n\nvoid COPTModel::cb_add_user_cut(const ScalarAffineFunction &function, ConstraintSense sense,\n CoeffT rhs)\n{\n\tAffineFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\n\tint numnz = ptr_form.numnz;\n\tint *cind = ptr_form.index;\n\tdouble *cval = ptr_form.value;\n\tchar g_sense = copt_con_sense(sense);\n\tdouble g_rhs = rhs - function.constant.value_or(0.0);\n\n\tint error = copt::COPT_AddCallbackUserCut(m_cbdata, numnz, cind, cval, g_sense, g_rhs);\n\tcheck_error(error);\n}\n\nvoid COPTModel::cb_add_user_cut(const ExprBuilder &function, ConstraintSense sense, CoeffT rhs)\n{\n\tScalarAffineFunction f(function);\n\tcb_add_user_cut(f, sense, rhs);\n}\n\nvoid COPTModel::computeIIS()\n{\n\tint error = copt::COPT_ComputeIIS(m_model.get());\n\tcheck_error(error);\n}\n\nint COPTModel::_get_variable_upperbound_IIS(const VariableIndex &variable)\n{\n\tauto column = _checked_variable_index(variable);\n\tint retval;\n\tint error = copt::COPT_GetColUpperIIS(m_model.get(), 1, &column, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nint COPTModel::_get_variable_lowerbound_IIS(const VariableIndex &variable)\n{\n\tauto column = _checked_variable_index(variable);\n\tint retval;\n\tint error = copt::COPT_GetColLowerIIS(m_model.get(), 1, &column, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nint COPTModel::_get_constraint_IIS(const ConstraintIndex &constraint)\n{\n\tint row = _checked_constraint_index(constraint);\n\tint num = 1;\n\tint error;\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear: {\n\t\tint lb_iis, ub_iis;\n\n\t\terror = copt::COPT_GetRowLowerIIS(m_model.get(), num, &row, &lb_iis);\n\t\tcheck_error(error);\n\n\t\terror = copt::COPT_GetRowUpperIIS(m_model.get(), num, &row, &ub_iis);\n\t\tcheck_error(error);\n\n\t\treturn lb_iis + ub_iis;\n\t}\n\tbreak;\n\tcase ConstraintType::SOS: {\n\t\tint iis;\n\t\terror = copt::COPT_GetSOSIIS(m_model.get(), num, &row, &iis);\n\t\tcheck_error(error);\n\t\treturn iis;\n\t}\n\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type to get IIS state\");\n\t}\n}\n" }, { "path": "lib/copt_model_ext.cpp", "content": "#include \n#include \n#include \n#include \n#include \n\n#include \"pyoptinterface/copt_model.hpp\"\n\nnamespace nb = nanobind;\n\nextern void bind_copt_constants(nb::module_ &m);\n\nNB_MODULE(copt_model_ext, m)\n{\n\tm.import_(\"pyoptinterface._src.core_ext\");\n\n\tm.def(\"is_library_loaded\", &copt::is_library_loaded);\n\tm.def(\"load_library\", &copt::load_library);\n\n\tbind_copt_constants(m);\n\n\tnb::class_(m, \"EnvConfig\").def(nb::init<>()).def(\"set\", &COPTEnvConfig::set);\n\n\tnb::class_(m, \"Env\")\n\t .def(nb::init<>())\n\t .def(nb::init())\n\t .def(\"close\", &COPTEnv::close);\n\n#define BIND_F(f) .def(#f, &COPTModel::f)\n\tnb::class_(m, \"RawModel\")\n\t .def(nb::init<>())\n\t .def(nb::init())\n\t // clang-format off\n\t BIND_F(init)\n\t BIND_F(write)\n\t BIND_F(close)\n\t // clang-format on\n\n\t .def(\"add_variable\", &COPTModel::add_variable,\n\t nb::arg(\"domain\") = VariableDomain::Continuous, nb::arg(\"lb\") = -COPT_INFINITY,\n\t nb::arg(\"ub\") = COPT_INFINITY, nb::arg(\"name\") = \"\")\n\t // clang-format off\n\t BIND_F(delete_variable)\n\t BIND_F(delete_variables)\n\t BIND_F(is_variable_active)\n\t // clang-format on\n\t .def(\"set_variable_bounds\", &COPTModel::set_variable_bounds, nb::arg(\"variable\"),\n\t nb::arg(\"lb\"), nb::arg(\"ub\"))\n\n\t .def(\"get_value\", nb::overload_cast(&COPTModel::get_variable_value))\n\t .def(\"get_value\",\n\t nb::overload_cast(&COPTModel::get_expression_value))\n\t .def(\"get_value\",\n\t nb::overload_cast(&COPTModel::get_expression_value))\n\t .def(\"get_value\", nb::overload_cast(&COPTModel::get_expression_value))\n\n\t .def(\"pprint\", &COPTModel::pprint_variable)\n\t .def(\"pprint\",\n\t nb::overload_cast(&COPTModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\t .def(\"pprint\",\n\t nb::overload_cast(&COPTModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\t .def(\"pprint\", nb::overload_cast(&COPTModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\n\t .def(\"_add_linear_constraint\",\n\t nb::overload_cast(\n\t &COPTModel::add_linear_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\",\n\t nb::overload_cast &,\n\t const char *>(&COPTModel::add_linear_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &COPTModel::add_linear_constraint_from_var, nb::arg(\"expr\"),\n\t nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &COPTModel::add_linear_interval_constraint_from_var,\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &COPTModel::add_linear_constraint_from_expr, nb::arg(\"expr\"),\n\t nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &COPTModel::add_linear_interval_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\n\t .def(\"_add_quadratic_constraint\", &COPTModel::add_quadratic_constraint, nb::arg(\"expr\"),\n\t nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_quadratic_constraint\", &COPTModel::add_quadratic_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"add_second_order_cone_constraint\", &COPTModel::add_second_order_cone_constraint,\n\t nb::arg(\"variables\"), nb::arg(\"name\") = \"\", nb::arg(\"rotated\") = false)\n\t .def(\"add_exp_cone_constraint\", &COPTModel::add_exp_cone_constraint, nb::arg(\"variables\"),\n\t nb::arg(\"name\") = \"\", nb::arg(\"dual\") = false)\n\t .def(\"add_sos_constraint\", nb::overload_cast &, SOSType>(\n\t &COPTModel::add_sos_constraint))\n\t .def(\"add_sos_constraint\",\n\t nb::overload_cast &, SOSType, const Vector &>(\n\t &COPTModel::add_sos_constraint))\n\n\t .def(\"_add_single_nl_constraint\", &COPTModel::add_single_nl_constraint, nb::arg(\"graph\"),\n\t nb::arg(\"result\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_single_nl_constraint\", &COPTModel::add_single_nl_constraint_sense_rhs,\n\t nb::arg(\"graph\"), nb::arg(\"result\"), nb::arg(\"sense\"), nb::arg(\"rhs\"),\n\t nb::arg(\"name\") = \"\")\n\t .def(\"_add_single_nl_constraint\", &COPTModel::add_single_nl_constraint_from_comparison,\n\t nb::arg(\"graph\"), nb::arg(\"expr\"), nb::arg(\"name\") = \"\")\n\n\t // clang-format off\n\t\tBIND_F(delete_constraint)\n\t\tBIND_F(is_constraint_active)\n\t // clang-format on\n\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &COPTModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &COPTModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(&COPTModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\", &COPTModel::set_objective_as_variable, nb::arg(\"expr\"),\n\t nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\", &COPTModel::set_objective_as_constant, nb::arg(\"expr\"),\n\t nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\n\t .def(\"_add_single_nl_objective\", &COPTModel::add_single_nl_objective)\n\n\t .def(\"cb_add_lazy_constraint\",\n\t nb::overload_cast(\n\t &COPTModel::cb_add_lazy_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"))\n\t .def(\"cb_add_lazy_constraint\",\n\t nb::overload_cast(\n\t &COPTModel::cb_add_lazy_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"))\n\t .def(\"cb_add_user_cut\",\n\t nb::overload_cast(\n\t &COPTModel::cb_add_user_cut),\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"))\n\t .def(\"cb_add_user_cut\",\n\t nb::overload_cast(\n\t &COPTModel::cb_add_user_cut),\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"))\n\n\t .def(\"optimize\", &COPTModel::optimize, nb::call_guard())\n\n\t // clang-format off\n\t BIND_F(version_string)\n\t BIND_F(get_raw_model)\n\n\t\tBIND_F(set_logging)\n\n\t\tBIND_F(set_callback)\n\t\tBIND_F(cb_get_info_int)\n\t\tBIND_F(cb_get_info_double)\n\t\tBIND_F(cb_get_solution)\n\t\tBIND_F(cb_get_relaxation)\n\t\tBIND_F(cb_get_incumbent)\n\t\tBIND_F(cb_set_solution)\n\t\tBIND_F(cb_submit_solution)\n\t\tBIND_F(cb_exit)\n\n\t BIND_F(raw_parameter_attribute_type)\n\n\t BIND_F(set_raw_parameter_int)\n\t BIND_F(set_raw_parameter_double)\n\t BIND_F(get_raw_parameter_int)\n\t BIND_F(get_raw_parameter_double)\n\n\t BIND_F(get_raw_attribute_int)\n\t BIND_F(get_raw_attribute_double)\n\n\t\tBIND_F(get_variable_info)\n\t BIND_F(set_variable_name)\n\t BIND_F(get_variable_name)\n\t BIND_F(set_variable_type)\n\t BIND_F(get_variable_type)\n\t BIND_F(set_variable_lower_bound)\n\t BIND_F(set_variable_upper_bound)\n\n\t\tBIND_F(get_constraint_info)\n\t BIND_F(set_constraint_name)\n\t BIND_F(get_constraint_name)\n\n\t BIND_F(set_obj_sense)\n\n\t BIND_F(add_mip_start)\n\t BIND_F(add_nl_start)\n\n\t\tBIND_F(get_normalized_rhs)\n\t\tBIND_F(set_normalized_rhs)\n\t\tBIND_F(get_normalized_coefficient)\n\t\tBIND_F(set_normalized_coefficient)\n\t\tBIND_F(get_objective_coefficient)\n\t\tBIND_F(set_objective_coefficient)\n\n\t\tBIND_F(computeIIS)\n\t\tBIND_F(_get_variable_upperbound_IIS)\n\t\tBIND_F(_get_variable_lowerbound_IIS)\n\t\tBIND_F(_get_constraint_IIS)\n\t // clang-format on\n\t ;\n}" }, { "path": "lib/copt_model_ext_constants.cpp", "content": "#include \n\nnamespace nb = nanobind;\n\nvoid bind_copt_constants(nb::module_ &m)\n{\n\tnb::module_ COPT = m.def_submodule(\"COPT\");\n\tCOPT.attr(\"BASIS_BASIC\") = 1;\n\tCOPT.attr(\"BASIS_FIXED\") = 4;\n\tCOPT.attr(\"BASIS_LOWER\") = 0;\n\tCOPT.attr(\"BASIS_SUPERBASIC\") = 3;\n\tCOPT.attr(\"BASIS_UPPER\") = 2;\n\tCOPT.attr(\"BINARY\") = \"B\";\n\tCOPT.attr(\"CBCONTEXT_INCUMBENT\") = 8;\n\tCOPT.attr(\"CBCONTEXT_MIPNODE\") = 4;\n\tCOPT.attr(\"CBCONTEXT_MIPRELAX\") = 1;\n\tCOPT.attr(\"CBCONTEXT_MIPSOL\") = 2;\n\tCOPT.attr(\"CLIENT_CAFILE\") = \"CaFile\";\n\tCOPT.attr(\"CLIENT_CERTFILE\") = \"CertFile\";\n\tCOPT.attr(\"CLIENT_CERTKEYFILE\") = \"CertKeyFile\";\n\tCOPT.attr(\"CLIENT_CLUSTER\") = \"Cluster\";\n\tCOPT.attr(\"CLIENT_FLOATING\") = \"Floating\";\n\tCOPT.attr(\"CLIENT_PASSWORD\") = \"PassWord\";\n\tCOPT.attr(\"CLIENT_PORT\") = \"Port\";\n\tCOPT.attr(\"CLIENT_PRIORITY\") = \"Priority\";\n\tCOPT.attr(\"CLIENT_WAITTIME\") = \"WaitTime\";\n\tCOPT.attr(\"CLIENT_WEBACESSKEY\") = \"WebAccessKey\";\n\tCOPT.attr(\"CLIENT_WEBLICENSEID\") = \"WebLicenseId\";\n\tCOPT.attr(\"CLIENT_WEBSERVER\") = \"WebServer\";\n\tCOPT.attr(\"CLIENT_WEBTOKENDURATION\") = \"WebTokenDuration\";\n\tCOPT.attr(\"CONE_QUAD\") = 1;\n\tCOPT.attr(\"CONE_RQUAD\") = 2;\n\tCOPT.attr(\"CONTINUOUS\") = \"C\";\n\tCOPT.attr(\"EQUAL\") = \"E\";\n\tCOPT.attr(\"EXPCONE_DUAL\") = 4;\n\tCOPT.attr(\"EXPCONE_PRIMAL\") = 3;\n\tCOPT.attr(\"FREE\") = \"N\";\n\tCOPT.attr(\"GENCONSTR_ABS\") = 1;\n\tCOPT.attr(\"GENCONSTR_AND\") = 2;\n\tCOPT.attr(\"GENCONSTR_MAX\") = 3;\n\tCOPT.attr(\"GENCONSTR_MIN\") = 4;\n\tCOPT.attr(\"GENCONSTR_OR\") = 5;\n\tCOPT.attr(\"GENCONSTR_PWL\") = 6;\n\tCOPT.attr(\"GREATER_EQUAL\") = \"G\";\n\tCOPT.attr(\"IMPRECISE\") = 7;\n\tCOPT.attr(\"INDICATOR_IF\") = 1;\n\tCOPT.attr(\"INDICATOR_IFANDONLYIF\") = 3;\n\tCOPT.attr(\"INDICATOR_ONLYIF\") = 2;\n\tCOPT.attr(\"INFEASIBLE\") = 2;\n\tCOPT.attr(\"INFINITY\") = 1e+30;\n\tCOPT.attr(\"INF_OR_UNB\") = 4;\n\tCOPT.attr(\"INTEGER\") = \"I\";\n\tCOPT.attr(\"INTERRUPTED\") = 10;\n\tCOPT.attr(\"ITERLIMIT\") = 11;\n\tCOPT.attr(\"LESS_EQUAL\") = \"L\";\n\tCOPT.attr(\"MAXIMIZE\") = -1;\n\tCOPT.attr(\"MINIMIZE\") = 1;\n\tCOPT.attr(\"NODELIMIT\") = 6;\n\tCOPT.attr(\"NUMERICAL\") = 5;\n\tCOPT.attr(\"OPTIMAL\") = 1;\n\tCOPT.attr(\"RANGE\") = \"R\";\n\tCOPT.attr(\"SOS_TYPE1\") = 1;\n\tCOPT.attr(\"SOS_TYPE2\") = 2;\n\tCOPT.attr(\"TIMEOUT\") = 8;\n\tCOPT.attr(\"UNBOUNDED\") = 3;\n\tCOPT.attr(\"UNDEFINED\") = 1e+40;\n\tCOPT.attr(\"UNFINISHED\") = 9;\n\tCOPT.attr(\"UNSTARTED\") = 0;\n\tCOPT.attr(\"VERSION_MAJOR\") = 8;\n\tCOPT.attr(\"VERSION_MINOR\") = 0;\n\tCOPT.attr(\"VERSION_TECHNICAL\") = 1;\n\n\tnb::module_ Attr = COPT.def_submodule(\"Attr\");\n\tAttr.attr(\"AffineCones\") = \"AffineCones\";\n\tAttr.attr(\"BarrierIter\") = \"BarrierIter\";\n\tAttr.attr(\"BestBnd\") = \"BestBnd\";\n\tAttr.attr(\"BestGap\") = \"BestGap\";\n\tAttr.attr(\"BestObj\") = \"BestObj\";\n\tAttr.attr(\"Bins\") = \"Bins\";\n\tAttr.attr(\"Cols\") = \"Cols\";\n\tAttr.attr(\"Cones\") = \"Cones\";\n\tAttr.attr(\"Elems\") = \"Elems\";\n\tAttr.attr(\"ExpCones\") = \"ExpCones\";\n\tAttr.attr(\"FeasRelaxObj\") = \"FeasRelaxObj\";\n\tAttr.attr(\"HasBasis\") = \"HasBasis\";\n\tAttr.attr(\"HasBranchFactor\") = \"HasBranchFactor\";\n\tAttr.attr(\"HasDualFarkas\") = \"HasDualFarkas\";\n\tAttr.attr(\"HasFeasRelaxSol\") = \"HasFeasRelaxSol\";\n\tAttr.attr(\"HasIIS\") = \"HasIIS\";\n\tAttr.attr(\"HasLpSol\") = \"HasLpSol\";\n\tAttr.attr(\"HasMipSol\") = \"HasMipSol\";\n\tAttr.attr(\"HasNLObj\") = \"HasNLObj\";\n\tAttr.attr(\"HasPrimalRay\") = \"HasPrimalRay\";\n\tAttr.attr(\"HasPsdObj\") = \"HasPSDObj\";\n\tAttr.attr(\"HasQObj\") = \"HasQObj\";\n\tAttr.attr(\"HasSensitivity\") = \"HasSensitivity\";\n\tAttr.attr(\"IISCols\") = \"IISCols\";\n\tAttr.attr(\"IISIndicators\") = \"IISIndicators\";\n\tAttr.attr(\"IISRows\") = \"IISRows\";\n\tAttr.attr(\"IISSOSs\") = \"IISSOSs\";\n\tAttr.attr(\"Indicators\") = \"Indicators\";\n\tAttr.attr(\"Ints\") = \"Ints\";\n\tAttr.attr(\"IsMIP\") = \"IsMIP\";\n\tAttr.attr(\"IsMinIIS\") = \"IsMinIIS\";\n\tAttr.attr(\"LmiConstrs\") = \"LMIConstrs\";\n\tAttr.attr(\"LpObjVal\") = \"LpObjVal\";\n\tAttr.attr(\"LpStatus\") = \"LpStatus\";\n\tAttr.attr(\"MipStatus\") = \"MipStatus\";\n\tAttr.attr(\"MultiObjs\") = \"MultiObjs\";\n\tAttr.attr(\"NLConstrs\") = \"NLConstrs\";\n\tAttr.attr(\"NLElems\") = \"NLElems\";\n\tAttr.attr(\"NodeCnt\") = \"NodeCnt\";\n\tAttr.attr(\"ObjConst\") = \"ObjConst\";\n\tAttr.attr(\"ObjSense\") = \"ObjSense\";\n\tAttr.attr(\"PDLPIter\") = \"PDLPIter\";\n\tAttr.attr(\"PoolSols\") = \"PoolSols\";\n\tAttr.attr(\"PsdCols\") = \"PSDCols\";\n\tAttr.attr(\"PsdConstrs\") = \"PSDConstrs\";\n\tAttr.attr(\"PsdElems\") = \"PSDElems\";\n\tAttr.attr(\"QConstrs\") = \"QConstrs\";\n\tAttr.attr(\"QElems\") = \"QElems\";\n\tAttr.attr(\"Rows\") = \"Rows\";\n\tAttr.attr(\"SimplexIter\") = \"SimplexIter\";\n\tAttr.attr(\"SolvingTime\") = \"SolvingTime\";\n\tAttr.attr(\"Soss\") = \"Soss\";\n\tAttr.attr(\"SymMats\") = \"SymMats\";\n\tAttr.attr(\"TuneResults\") = \"TuneResults\";\n\n\tnb::module_ Param = COPT.def_submodule(\"Param\");\n\tParam.attr(\"AbsGap\") = \"AbsGap\";\n\tParam.attr(\"BarHomogeneous\") = \"BarHomogeneous\";\n\tParam.attr(\"BarIterLimit\") = \"BarIterLimit\";\n\tParam.attr(\"BarOrder\") = \"BarOrder\";\n\tParam.attr(\"BarStart\") = \"BarStart\";\n\tParam.attr(\"BarThreads\") = \"BarThreads\";\n\tParam.attr(\"ConflictAnalysis\") = \"ConflictAnalysis\";\n\tParam.attr(\"Crossover\") = \"Crossover\";\n\tParam.attr(\"CrossoverThreads\") = \"CrossoverThreads\";\n\tParam.attr(\"CutLevel\") = \"CutLevel\";\n\tParam.attr(\"DivingHeurLevel\") = \"DivingHeurLevel\";\n\tParam.attr(\"DualPerturb\") = \"DualPerturb\";\n\tParam.attr(\"DualPrice\") = \"DualPrice\";\n\tParam.attr(\"DualTol\") = \"DualTol\";\n\tParam.attr(\"Dualize\") = \"Dualize\";\n\tParam.attr(\"FAPHeurLevel\") = \"FAPHeurLevel\";\n\tParam.attr(\"FeasRelaxMode\") = \"FeasRelaxMode\";\n\tParam.attr(\"FeasTol\") = \"FeasTol\";\n\tParam.attr(\"GPUDevice\") = \"GPUDevice\";\n\tParam.attr(\"GPUMode\") = \"GPUMode\";\n\tParam.attr(\"HeurLevel\") = \"HeurLevel\";\n\tParam.attr(\"IISMethod\") = \"IISMethod\";\n\tParam.attr(\"IntTol\") = \"IntTol\";\n\tParam.attr(\"LazyConstraints\") = \"LazyConstraints\";\n\tParam.attr(\"LinearizeIndicators\") = \"LinearizeIndicators\";\n\tParam.attr(\"LinearizeSos\") = \"LinearizeSos\";\n\tParam.attr(\"LogToConsole\") = \"LogToConsole\";\n\tParam.attr(\"Logging\") = \"Logging\";\n\tParam.attr(\"LpMethod\") = \"LpMethod\";\n\tParam.attr(\"MatrixTol\") = \"MatrixTol\";\n\tParam.attr(\"MipStartMode\") = \"MipStartMode\";\n\tParam.attr(\"MipStartNodeLimit\") = \"MipStartNodeLimit\";\n\tParam.attr(\"MipTasks\") = \"MipTasks\";\n\tParam.attr(\"MultiObjAbsTol\") = \"MultiObjAbsTol\";\n\tParam.attr(\"MultiObjParamMode\") = \"MultiObjParamMode\";\n\tParam.attr(\"MultiObjPriority\") = \"MultiObjPriority\";\n\tParam.attr(\"MultiObjRelTol\") = \"MultiObjRelTol\";\n\tParam.attr(\"MultiObjTimeLimit\") = \"MultiObjTimeLimit\";\n\tParam.attr(\"MultiObjWeight\") = \"MultiObjWeight\";\n\tParam.attr(\"NLPIterLimit\") = \"NLPIterLimit\";\n\tParam.attr(\"NLPLinScale\") = \"NLPLinScale\";\n\tParam.attr(\"NLPMuUpdate\") = \"NLPMuUpdate\";\n\tParam.attr(\"NLPTol\") = \"NLPTol\";\n\tParam.attr(\"NodeCutRounds\") = \"NodeCutRounds\";\n\tParam.attr(\"NodeLimit\") = \"NodeLimit\";\n\tParam.attr(\"NonConvex\") = \"NonConvex\";\n\tParam.attr(\"PDLPTol\") = \"PDLPTol\";\n\tParam.attr(\"Presolve\") = \"Presolve\";\n\tParam.attr(\"RelGap\") = \"RelGap\";\n\tParam.attr(\"ReqFarkasRay\") = \"ReqFarkasRay\";\n\tParam.attr(\"ReqSensitivity\") = \"ReqSensitivity\";\n\tParam.attr(\"RootCutLevel\") = \"RootCutLevel\";\n\tParam.attr(\"RootCutRounds\") = \"RootCutRounds\";\n\tParam.attr(\"RoundingHeurLevel\") = \"RoundingHeurLevel\";\n\tParam.attr(\"SDPMethod\") = \"SDPMethod\";\n\tParam.attr(\"Scaling\") = \"Scaling\";\n\tParam.attr(\"SimplexThreads\") = \"SimplexThreads\";\n\tParam.attr(\"SolTimeLimit\") = \"SolTimeLimit\";\n\tParam.attr(\"StrongBranching\") = \"StrongBranching\";\n\tParam.attr(\"SubMipHeurLevel\") = \"SubMipHeurLevel\";\n\tParam.attr(\"Threads\") = \"Threads\";\n\tParam.attr(\"TimeLimit\") = \"TimeLimit\";\n\tParam.attr(\"TreeCutLevel\") = \"TreeCutLevel\";\n\tParam.attr(\"TuneMeasure\") = \"TuneMeasure\";\n\tParam.attr(\"TuneMethod\") = \"TuneMethod\";\n\tParam.attr(\"TuneMode\") = \"TuneMode\";\n\tParam.attr(\"TuneOutputLevel\") = \"TuneOutputLevel\";\n\tParam.attr(\"TunePermutes\") = \"TunePermutes\";\n\tParam.attr(\"TuneTargetRelGap\") = \"TuneTargetRelGap\";\n\tParam.attr(\"TuneTargetTime\") = \"TuneTargetTime\";\n\tParam.attr(\"TuneTimeLimit\") = \"TuneTimeLimit\";\n\n\tnb::module_ Info = COPT.def_submodule(\"Info\");\n\tInfo.attr(\"BranchFactor\") = \"BranchFactor\";\n\tInfo.attr(\"Dual\") = \"Dual\";\n\tInfo.attr(\"DualFarkas\") = \"DualFarkas\";\n\tInfo.attr(\"LB\") = \"LB\";\n\tInfo.attr(\"Obj\") = \"Obj\";\n\tInfo.attr(\"PrimalRay\") = \"PrimalRay\";\n\tInfo.attr(\"RedCost\") = \"RedCost\";\n\tInfo.attr(\"RelaxLB\") = \"RelaxLB\";\n\tInfo.attr(\"RelaxUB\") = \"RelaxUB\";\n\tInfo.attr(\"RelaxValue\") = \"RelaxValue\";\n\tInfo.attr(\"SALBLow\") = \"SALBLow\";\n\tInfo.attr(\"SALBUp\") = \"SALBUp\";\n\tInfo.attr(\"SAObjLow\") = \"SAObjLow\";\n\tInfo.attr(\"SAObjUp\") = \"SAObjUp\";\n\tInfo.attr(\"SAUBLow\") = \"SAUBLow\";\n\tInfo.attr(\"SAUBUp\") = \"SAUBUp\";\n\tInfo.attr(\"Slack\") = \"Slack\";\n\tInfo.attr(\"UB\") = \"UB\";\n\tInfo.attr(\"Value\") = \"Value\";\n\n\tnb::module_ CbInfo = COPT.def_submodule(\"CbInfo\");\n\tCbInfo.attr(\"BestBnd\") = \"BestBnd\";\n\tCbInfo.attr(\"BestObj\") = \"BestObj\";\n\tCbInfo.attr(\"HasIncumbent\") = \"HasIncumbent\";\n\tCbInfo.attr(\"Incumbent\") = \"Incumbent\";\n\tCbInfo.attr(\"MipCandObj\") = \"MipCandObj\";\n\tCbInfo.attr(\"MipCandidate\") = \"MipCandidate\";\n\tCbInfo.attr(\"NodeStatus\") = \"NodeStatus\";\n\tCbInfo.attr(\"RelaxSolObj\") = \"RelaxSolObj\";\n\tCbInfo.attr(\"RelaxSolution\") = \"RelaxSolution\";\n}\n" }, { "path": "lib/core.cpp", "content": "#include \"pyoptinterface/core.hpp\"\n#include \n#include \n\n#include \"fmt/core.h\"\n\nVariableIndex::VariableIndex(IndexT v) : index(v)\n{\n}\n\nScalarAffineFunction::ScalarAffineFunction(CoeffT c) : constant(c)\n{\n}\nScalarAffineFunction::ScalarAffineFunction(const VariableIndex &v)\n : coefficients({1.0}), variables({v.index})\n{\n}\nScalarAffineFunction::ScalarAffineFunction(const VariableIndex &v, CoeffT c)\n : coefficients({c}), variables({v.index})\n{\n}\nScalarAffineFunction::ScalarAffineFunction(const VariableIndex &v, CoeffT c1, CoeffT c2)\n : coefficients({c1}), variables({v.index}), constant(c2)\n{\n}\nScalarAffineFunction::ScalarAffineFunction(const Vector &a, const Vector &b)\n : coefficients(a), variables(b)\n{\n}\nScalarAffineFunction::ScalarAffineFunction(const Vector &a, const Vector &b,\n const std::optional &c)\n : coefficients(a), variables(b), constant(c)\n{\n}\nScalarAffineFunction::ScalarAffineFunction(const ExprBuilder &t)\n{\n\tconst auto &affine_terms = t.affine_terms;\n\n\tauto N = affine_terms.size();\n\tcoefficients.reserve(N);\n\tvariables.reserve(N);\n\n\tfor (auto &[v, c] : affine_terms)\n\t{\n\t\tcoefficients.push_back(c);\n\t\tvariables.push_back(v);\n\t}\n\tif (t.constant_term)\n\t{\n\t\tconstant = t.constant_term.value();\n\t}\n}\n\nsize_t ScalarAffineFunction::size() const\n{\n\treturn coefficients.size();\n}\nvoid ScalarAffineFunction::canonicalize(CoeffT threshold)\n{\n\tExprBuilder t(*this);\n\tt.clean_nearzero_terms(threshold);\n\n\t// *this = ScalarAffineFunction(t);\n\t// sort coefficients and variable lock by lock with std::views::zip\n\t// std::ranges::sort(std::views::zip(variables, coefficients));\n\n\tvariables.clear();\n\tvariables.reserve(t.affine_terms.size());\n\tfor (const auto &it : t.affine_terms)\n\t{\n\t\tvariables.push_back(it.first);\n\t}\n\tstd::sort(variables.begin(), variables.end());\n\tcoefficients.clear();\n\tcoefficients.reserve(variables.size());\n\tfor (const auto &it : variables)\n\t{\n\t\tcoefficients.push_back(t.affine_terms[it]);\n\t}\n\tconstant = t.constant_term;\n}\n\nvoid ScalarAffineFunction::reserve(size_t n)\n{\n\tcoefficients.reserve(n);\n\tvariables.reserve(n);\n}\n\nvoid ScalarAffineFunction::add_term(const VariableIndex &v, CoeffT c)\n{\n\tcoefficients.push_back(c);\n\tvariables.push_back(v.index);\n}\n\nvoid ScalarAffineFunction::add_constant(CoeffT c)\n{\n\tconstant = constant.value_or(0.0) + c;\n}\n\nScalarQuadraticFunction::ScalarQuadraticFunction(const Vector &c, const Vector &v1,\n const Vector &v2)\n : coefficients(c), variable_1s(v1), variable_2s(v2)\n{\n}\nScalarQuadraticFunction::ScalarQuadraticFunction(const Vector &c, const Vector &v1,\n const Vector &v2,\n const std::optional &a)\n : coefficients(c), variable_1s(v1), variable_2s(v2), affine_part(a)\n{\n}\nScalarQuadraticFunction::ScalarQuadraticFunction(const ExprBuilder &t)\n{\n\tconst auto &quadratic_terms = t.quadratic_terms;\n\tauto N = quadratic_terms.size();\n\tcoefficients.reserve(N);\n\tvariable_1s.reserve(N);\n\tvariable_2s.reserve(N);\n\n\tfor (auto &[vp, c] : quadratic_terms)\n\t{\n\t\tcoefficients.push_back(c);\n\t\tvariable_1s.push_back(vp.var_1);\n\t\tvariable_2s.push_back(vp.var_2);\n\t}\n\tif (!t.affine_terms.empty() || t.constant_term)\n\t{\n\t\taffine_part = ScalarAffineFunction(t);\n\t}\n}\nsize_t ScalarQuadraticFunction::size() const\n{\n\treturn coefficients.size();\n}\nvoid ScalarQuadraticFunction::canonicalize(CoeffT threshold)\n{\n\tExprBuilder t(*this);\n\tt.clean_nearzero_terms(threshold);\n\n\t// *this = ScalarQuadraticFunction(t);\n\t// std::ranges::sort(std::views::zip(variable_1s, variable_2s, coefficients));\n\n\tauto N = t.quadratic_terms.size();\n\tstd::vector varpairs;\n\tvarpairs.reserve(N);\n\tfor (const auto &it : t.quadratic_terms)\n\t{\n\t\tvarpairs.emplace_back(it.first);\n\t}\n\tstd::sort(varpairs.begin(), varpairs.end());\n\tvariable_1s.clear();\n\tvariable_1s.reserve(N);\n\tvariable_2s.clear();\n\tvariable_2s.reserve(N);\n\tcoefficients.clear();\n\tcoefficients.reserve(N);\n\tfor (const auto &it : varpairs)\n\t{\n\t\tvariable_1s.push_back(it.var_1);\n\t\tvariable_2s.push_back(it.var_2);\n\t\tcoefficients.push_back(t.quadratic_terms[it]);\n\t}\n\n\tif (affine_part)\n\t{\n\t\tauto &affine_function = affine_part.value();\n\t\taffine_function.canonicalize(threshold);\n\t}\n}\n\nvoid ScalarQuadraticFunction::reserve_quadratic(size_t n)\n{\n\tcoefficients.reserve(n);\n\tvariable_1s.reserve(n);\n\tvariable_2s.reserve(n);\n}\n\nvoid ScalarQuadraticFunction::reserve_affine(size_t n)\n{\n\tif (n > 0)\n\t{\n\t\tif (!affine_part)\n\t\t{\n\t\t\taffine_part = ScalarAffineFunction();\n\t\t}\n\t\taffine_part.value().reserve(n);\n\t}\n}\n\nvoid ScalarQuadraticFunction::add_quadratic_term(const VariableIndex &v1, const VariableIndex &v2,\n CoeffT c)\n{\n\tcoefficients.push_back(c);\n\tvariable_1s.push_back(v1.index);\n\tvariable_2s.push_back(v2.index);\n}\n\nvoid ScalarQuadraticFunction::add_affine_term(const VariableIndex &v, CoeffT c)\n{\n\tif (!affine_part)\n\t{\n\t\taffine_part = ScalarAffineFunction();\n\t}\n\taffine_part.value().add_term(v, c);\n}\n\nvoid ScalarQuadraticFunction::add_constant(CoeffT c)\n{\n\tif (!affine_part)\n\t{\n\t\taffine_part = ScalarAffineFunction(c);\n\t}\n\telse\n\t{\n\t\taffine_part.value().add_constant(c);\n\t}\n}\n\nbool VariablePair::operator==(const VariablePair &x) const\n{\n\treturn var_1 == x.var_1 && var_2 == x.var_2;\n}\nbool VariablePair::operator<(const VariablePair &x) const\n{\n\tif (var_1 != x.var_1)\n\t\treturn var_1 < x.var_1;\n\telse\n\t\treturn var_2 < x.var_2;\n}\n\nExprBuilder::ExprBuilder(CoeffT c)\n{\n\toperator+=(c);\n}\n\nExprBuilder::ExprBuilder(const VariableIndex &v)\n{\n\toperator+=(v);\n}\n\nExprBuilder::ExprBuilder(const ScalarAffineFunction &a)\n{\n\tauto N = a.coefficients.size();\n\taffine_terms.reserve(N);\n\n\toperator+=(a);\n}\n\nExprBuilder::ExprBuilder(const ScalarQuadraticFunction &q)\n{\n\tif (q.affine_part)\n\t{\n\t\taffine_terms.reserve(q.affine_part.value().coefficients.size());\n\t}\n\tauto N = q.coefficients.size();\n\tquadratic_terms.reserve(N);\n\n\toperator+=(q);\n}\n\nbool ExprBuilder::empty() const\n{\n\treturn quadratic_terms.empty() && affine_terms.empty() && !constant_term;\n}\n\nint ExprBuilder::degree() const\n{\n\tif (!quadratic_terms.empty())\n\t{\n\t\treturn 2;\n\t}\n\tif (!affine_terms.empty())\n\t{\n\t\treturn 1;\n\t}\n\treturn 0;\n}\n\nvoid ExprBuilder::reserve_quadratic(size_t n)\n{\n\tquadratic_terms.reserve(n);\n}\n\nvoid ExprBuilder::reserve_affine(size_t n)\n{\n\taffine_terms.reserve(n);\n}\n\nvoid ExprBuilder::clear()\n{\n\tquadratic_terms.clear();\n\taffine_terms.clear();\n\tconstant_term.reset();\n}\n\nvoid ExprBuilder::clean_nearzero_terms(CoeffT threshold)\n{\n\t// clear all coefficients if abs(coefficient) < threshold\n\tfor (auto it = quadratic_terms.begin(); it != quadratic_terms.end();)\n\t{\n\t\tif (std::abs(it->second) < threshold)\n\t\t{\n\t\t\tit = quadratic_terms.erase(it);\n\t\t}\n\t\telse\n\t\t{\n\t\t\t++it;\n\t\t}\n\t}\n\tfor (auto it = affine_terms.begin(); it != affine_terms.end();)\n\t{\n\t\tif (std::abs(it->second) < threshold)\n\t\t{\n\t\t\tit = affine_terms.erase(it);\n\t\t}\n\t\telse\n\t\t{\n\t\t\t++it;\n\t\t}\n\t}\n\tif (constant_term && std::abs(*constant_term) < threshold)\n\t{\n\t\tconstant_term.reset();\n\t}\n}\n\nvoid ExprBuilder::_add_quadratic_term(IndexT i, IndexT j, CoeffT coeff)\n{\n\tif (i > j)\n\t{\n\t\tstd::swap(i, j);\n\t}\n\tVariablePair vp{i, j};\n\tauto ret = quadratic_terms.emplace(vp, coeff);\n\tif (!ret.second)\n\t{\n\t\tauto &iter = ret.first;\n\t\titer->second += coeff;\n\t}\n}\nvoid ExprBuilder::_set_quadratic_coef(IndexT i, IndexT j, CoeffT coeff)\n{\n\tif (i > j)\n\t{\n\t\tstd::swap(i, j);\n\t}\n\tVariablePair vp{i, j};\n\tauto ret = quadratic_terms.emplace(vp, coeff);\n\tif (!ret.second)\n\t{\n\t\tauto &iter = ret.first;\n\t\titer->second = coeff;\n\t}\n}\nvoid ExprBuilder::add_quadratic_term(const VariableIndex &i, const VariableIndex &j, CoeffT coeff)\n{\n\t_add_quadratic_term(i.index, j.index, coeff);\n}\nvoid ExprBuilder::set_quadratic_coef(const VariableIndex &i, const VariableIndex &j, CoeffT coeff)\n{\n\t_set_quadratic_coef(i.index, j.index, coeff);\n}\n\nvoid ExprBuilder::_add_affine_term(IndexT i, CoeffT coeff)\n{\n\tauto ret = affine_terms.emplace(i, coeff);\n\tif (!ret.second)\n\t{\n\t\tauto &iter = ret.first;\n\t\titer->second += coeff;\n\t}\n}\nvoid ExprBuilder::_set_affine_coef(IndexT i, CoeffT coeff)\n{\n\tauto ret = affine_terms.emplace(i, coeff);\n\tif (!ret.second)\n\t{\n\t\tauto &iter = ret.first;\n\t\titer->second = coeff;\n\t}\n}\nvoid ExprBuilder::add_affine_term(const VariableIndex &i, CoeffT coeff)\n{\n\t_add_affine_term(i.index, coeff);\n}\nvoid ExprBuilder::set_affine_coef(const VariableIndex &i, CoeffT coeff)\n{\n\t_set_affine_coef(i.index, coeff);\n}\n\nExprBuilder &ExprBuilder::operator+=(CoeffT c)\n{\n\tconstant_term = constant_term.value_or(0.0) + c;\n\treturn *this;\n}\nExprBuilder &ExprBuilder::operator+=(const VariableIndex &v)\n{\n\t_add_affine_term(v.index, 1.0);\n\treturn *this;\n}\nExprBuilder &ExprBuilder::operator+=(const ScalarAffineFunction &a)\n{\n\tauto N = a.coefficients.size();\n\tfor (auto i = 0; i < N; i++)\n\t{\n\t\t_add_affine_term(a.variables[i], a.coefficients[i]);\n\t}\n\n\tif (a.constant)\n\t{\n\t\tconstant_term = constant_term.value_or(0.0) + a.constant.value();\n\t}\n\treturn *this;\n}\nExprBuilder &ExprBuilder::operator+=(const ScalarQuadraticFunction &q)\n{\n\tif (q.affine_part)\n\t{\n\t\toperator+=(q.affine_part.value());\n\t}\n\n\tauto N = q.coefficients.size();\n\tfor (auto i = 0; i < N; i++)\n\t{\n\t\t_add_quadratic_term(q.variable_1s[i], q.variable_2s[i], q.coefficients[i]);\n\t}\n\treturn *this;\n}\nExprBuilder &ExprBuilder::operator+=(const ExprBuilder &t)\n{\n\tif (this == &t)\n\t{\n\t\tfor (auto &[varpair, c] : quadratic_terms)\n\t\t{\n\t\t\tc *= 2.0;\n\t\t}\n\t\tfor (auto &[v, c] : affine_terms)\n\t\t{\n\t\t\tc *= 2.0;\n\t\t}\n\t\tif (constant_term)\n\t\t{\n\t\t\tconstant_term = constant_term.value() * 2.0;\n\t\t}\n\t}\n\telse\n\t{\n\t\tfor (const auto &[varpair, c] : t.quadratic_terms)\n\t\t{\n\t\t\t_add_quadratic_term(varpair.var_1, varpair.var_2, c);\n\t\t}\n\t\tfor (const auto &[v, c] : t.affine_terms)\n\t\t{\n\t\t\t_add_affine_term(v, c);\n\t\t}\n\t\tif (t.constant_term)\n\t\t{\n\t\t\tconstant_term = constant_term.value_or(0.0) + t.constant_term.value();\n\t\t}\n\t}\n\treturn *this;\n}\n\nExprBuilder &ExprBuilder::operator-=(CoeffT c)\n{\n\tconstant_term = constant_term.value_or(0.0) - c;\n\treturn *this;\n}\nExprBuilder &ExprBuilder::operator-=(const VariableIndex &v)\n{\n\t_add_affine_term(v.index, -1.0);\n\treturn *this;\n}\nExprBuilder &ExprBuilder::operator-=(const ScalarAffineFunction &a)\n{\n\tauto N = a.coefficients.size();\n\tfor (auto i = 0; i < N; i++)\n\t{\n\t\t_add_affine_term(a.variables[i], -a.coefficients[i]);\n\t}\n\n\tif (a.constant)\n\t{\n\t\tconstant_term = constant_term.value_or(0.0) - a.constant.value();\n\t}\n\treturn *this;\n}\nExprBuilder &ExprBuilder::operator-=(const ScalarQuadraticFunction &q)\n{\n\tif (q.affine_part)\n\t{\n\t\toperator-=(q.affine_part.value());\n\t}\n\n\tauto N = q.coefficients.size();\n\tfor (auto i = 0; i < N; i++)\n\t{\n\t\t_add_quadratic_term(q.variable_1s[i], q.variable_2s[i], -q.coefficients[i]);\n\t}\n\treturn *this;\n}\nExprBuilder &ExprBuilder::operator-=(const ExprBuilder &t)\n{\n\tif (this == &t)\n\t{\n\t\tquadratic_terms.clear();\n\t\taffine_terms.clear();\n\t\tconstant_term.reset();\n\t}\n\telse\n\t{\n\t\tfor (const auto &[varpair, c] : t.quadratic_terms)\n\t\t{\n\t\t\t_add_quadratic_term(varpair.var_1, varpair.var_2, -c);\n\t\t}\n\t\tfor (const auto &[v, c] : t.affine_terms)\n\t\t{\n\t\t\t_add_affine_term(v, -c);\n\t\t}\n\t\tif (t.constant_term)\n\t\t{\n\t\t\tconstant_term = constant_term.value_or(0.0) - t.constant_term.value();\n\t\t}\n\t}\n\treturn *this;\n}\n\nExprBuilder &ExprBuilder::operator*=(CoeffT c)\n{\n\tfor (auto &[varpair, cc] : quadratic_terms)\n\t{\n\t\tcc *= c;\n\t}\n\tfor (auto &[v, cc] : affine_terms)\n\t{\n\t\tcc *= c;\n\t}\n\tif (constant_term)\n\t{\n\t\tconstant_term = constant_term.value() * c;\n\t}\n\treturn *this;\n}\nExprBuilder &ExprBuilder::operator*=(const VariableIndex &v)\n{\n\tauto deg = degree();\n\tif (deg > 1)\n\t{\n\t\tthrow std::logic_error(\n\t\t fmt::format(\"ExprBuilder with degree {} cannot multiply with VariableIndex\", deg));\n\t}\n\n\tauto N = affine_terms.size();\n\tquadratic_terms.reserve(N);\n\tfor (const auto &[var2, c] : affine_terms)\n\t{\n\t\t_add_quadratic_term(v.index, var2, c);\n\t}\n\n\tif (constant_term)\n\t{\n\t\taffine_terms = {{v.index, constant_term.value()}};\n\t\tconstant_term.reset();\n\t}\n\telse\n\t{\n\t\taffine_terms.clear();\n\t}\n\treturn *this;\n}\nExprBuilder &ExprBuilder::operator*=(const ScalarAffineFunction &a)\n{\n\tauto deg = degree();\n\tif (deg > 1)\n\t{\n\t\tthrow std::logic_error(fmt::format(\n\t\t \"ExprBuilder with degree {} cannot multiply with ScalarAffineFunction\", deg));\n\t}\n\n\tauto N1 = affine_terms.size();\n\tauto N2 = a.size();\n\tquadratic_terms.reserve(N1 * N2 / 2);\n\tfor (const auto &[xi, ci] : affine_terms)\n\t{\n\t\tfor (int j = 0; j < a.size(); j++)\n\t\t{\n\t\t\tauto dj = a.coefficients[j];\n\t\t\tauto xj = a.variables[j];\n\t\t\t_add_quadratic_term(xi, xj, ci * dj);\n\t\t}\n\t}\n\n\tif (a.constant)\n\t{\n\t\tauto d0 = a.constant.value();\n\t\tfor (auto &[_, ci] : affine_terms)\n\t\t{\n\t\t\tci *= d0;\n\t\t}\n\t}\n\telse\n\t{\n\t\taffine_terms.clear();\n\t}\n\n\tif (constant_term)\n\t{\n\t\tauto c0 = constant_term.value();\n\t\tfor (int j = 0; j < a.size(); j++)\n\t\t{\n\t\t\tauto dj = a.coefficients[j];\n\t\t\tauto xj = a.variables[j];\n\t\t\t_add_affine_term(xj, c0 * dj);\n\t\t}\n\t}\n\n\tif (a.constant && constant_term)\n\t{\n\t\tconstant_term = a.constant.value() * constant_term.value();\n\t}\n\telse\n\t{\n\t\tconstant_term.reset();\n\t}\n\treturn *this;\n}\nExprBuilder &ExprBuilder::operator*=(const ScalarQuadraticFunction &q)\n{\n\tauto deg = degree();\n\tif (deg > 0)\n\t{\n\t\tthrow std::logic_error(fmt::format(\n\t\t \"ExprBuilder with degree {} cannot multiply with ScalarQuadraticFunction\", deg));\n\t}\n\n\tif (!constant_term)\n\t\treturn *this;\n\n\tauto c = constant_term.value();\n\t{\n\t\tauto N = q.coefficients.size();\n\t\tquadratic_terms.reserve(N);\n\t\tfor (auto i = 0; i < N; i++)\n\t\t{\n\t\t\t_add_quadratic_term(q.variable_1s[i], q.variable_2s[i], c * q.coefficients[i]);\n\t\t}\n\t}\n\tif (q.affine_part)\n\t{\n\t\tauto &affine_part = q.affine_part.value();\n\t\tauto N = affine_part.coefficients.size();\n\t\taffine_terms.reserve(N);\n\t\tfor (auto i = 0; i < N; i++)\n\t\t{\n\t\t\t_add_affine_term(affine_part.variables[i], c * affine_part.coefficients[i]);\n\t\t}\n\n\t\tif (affine_part.constant)\n\t\t{\n\t\t\tconstant_term = c * affine_part.constant.value();\n\t\t}\n\t\telse\n\t\t{\n\t\t\tconstant_term.reset();\n\t\t}\n\t}\n\telse\n\t{\n\t\tconstant_term.reset();\n\t}\n\treturn *this;\n}\nExprBuilder &ExprBuilder::operator*=(const ExprBuilder &t)\n{\n\tauto deg1 = degree();\n\tauto deg2 = t.degree();\n\tif (deg1 + deg2 > 2)\n\t{\n\t\tthrow std::logic_error(fmt::format(\n\t\t \"ExprBuilder with degree {} cannot multiply with ExprBuilder with degree {}\", deg1,\n\t\t deg2));\n\t}\n\n\tif (this == &t)\n\t{\n\t\tauto deg = deg1;\n\n\t\tif (deg == 0)\n\t\t{\n\t\t\tif (constant_term)\n\t\t\t{\n\t\t\t\tauto c = constant_term.value();\n\t\t\t\tconstant_term = c * c;\n\t\t\t}\n\t\t}\n\t\telse\n\t\t// deg = 1\n\t\t{\n\t\t\tauto N = affine_terms.size();\n\t\t\tquadratic_terms.reserve(N * N / 2);\n\t\t\tfor (const auto &[xi, ci] : affine_terms)\n\t\t\t{\n\t\t\t\tfor (const auto &[xj, cj] : affine_terms)\n\t\t\t\t{\n\t\t\t\t\t_add_quadratic_term(xi, xj, ci * cj);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (constant_term)\n\t\t\t{\n\t\t\t\tauto d0 = constant_term.value();\n\t\t\t\tfor (auto &[_, ci] : affine_terms)\n\t\t\t\t{\n\t\t\t\t\tci *= 2.0 * d0;\n\t\t\t\t}\n\t\t\t\tconstant_term = d0 * d0;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\taffine_terms.clear();\n\t\t\t}\n\t\t}\n\t}\n\telse\n\t{\n\t\tif (deg1 == 0)\n\t\t{\n\t\t\tif (constant_term)\n\t\t\t{\n\t\t\t\tauto c = constant_term.value();\n\n\t\t\t\tauto N = t.quadratic_terms.size();\n\t\t\t\tquadratic_terms.reserve(N);\n\t\t\t\tfor (const auto &[varpair, c2] : t.quadratic_terms)\n\t\t\t\t{\n\t\t\t\t\t_add_quadratic_term(varpair.var_1, varpair.var_2, c * c2);\n\t\t\t\t}\n\n\t\t\t\tN = t.affine_terms.size();\n\t\t\t\taffine_terms.reserve(N);\n\t\t\t\tfor (const auto &[v, c1] : t.affine_terms)\n\t\t\t\t{\n\t\t\t\t\t_add_affine_term(v, c * c1);\n\t\t\t\t}\n\n\t\t\t\tif (t.constant_term)\n\t\t\t\t{\n\t\t\t\t\tconstant_term = c * t.constant_term.value();\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tconstant_term.reset();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse if (deg1 == 1)\n\t\t{\n\t\t\tif (deg2 == 1)\n\t\t\t{\n\t\t\t\tauto N1 = affine_terms.size();\n\t\t\t\tauto N2 = t.affine_terms.size();\n\t\t\t\tquadratic_terms.reserve(N1 * N2 / 2);\n\t\t\t\tfor (const auto &[xi, ci] : affine_terms)\n\t\t\t\t{\n\t\t\t\t\tfor (const auto &[xj, dj] : t.affine_terms)\n\t\t\t\t\t{\n\t\t\t\t\t\t_add_quadratic_term(xi, xj, ci * dj);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (t.constant_term)\n\t\t\t{\n\t\t\t\tauto d0 = t.constant_term.value();\n\t\t\t\tfor (auto &[_, ci] : affine_terms)\n\t\t\t\t{\n\t\t\t\t\tci *= d0;\n\t\t\t\t}\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\taffine_terms.clear();\n\t\t\t}\n\n\t\t\tif (constant_term)\n\t\t\t{\n\t\t\t\tauto c0 = constant_term.value();\n\t\t\t\tfor (const auto &[xj, dj] : t.affine_terms)\n\t\t\t\t{\n\t\t\t\t\t_add_affine_term(xj, c0 * dj);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (t.constant_term && constant_term)\n\t\t\t{\n\t\t\t\tconstant_term = t.constant_term.value() * constant_term.value();\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tconstant_term.reset();\n\t\t\t}\n\t\t}\n\t\telse if (deg1 == 2)\n\t\t{\n\t\t\tif (t.constant_term)\n\t\t\t{\n\t\t\t\tauto c = t.constant_term.value();\n\n\t\t\t\tfor (auto &[_, c2] : quadratic_terms)\n\t\t\t\t{\n\t\t\t\t\tc2 *= c;\n\t\t\t\t}\n\n\t\t\t\tfor (auto &[_, c1] : affine_terms)\n\t\t\t\t{\n\t\t\t\t\tc1 *= c;\n\t\t\t\t}\n\n\t\t\t\tif (constant_term)\n\t\t\t\t{\n\t\t\t\t\tconstant_term = c * constant_term.value();\n\t\t\t\t}\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tclear();\n\t\t\t}\n\t\t}\n\t}\n\treturn *this;\n}\n\nExprBuilder &ExprBuilder::operator/=(CoeffT c)\n{\n\tfor (auto &[varpair, cc] : quadratic_terms)\n\t{\n\t\tcc /= c;\n\t}\n\tfor (auto &[v, cc] : affine_terms)\n\t{\n\t\tcc /= c;\n\t}\n\tif (constant_term)\n\t{\n\t\tconstant_term = constant_term.value() / c;\n\t}\n\treturn *this;\n}\n\n// Operator overloading functions\n\nauto operator+(const VariableIndex &a, CoeffT b) -> ScalarAffineFunction\n{\n\treturn ScalarAffineFunction(a, 1.0, b);\n}\nauto operator+(CoeffT a, const VariableIndex &b) -> ScalarAffineFunction\n{\n\treturn b + a;\n}\n\nauto operator+(const VariableIndex &a, const VariableIndex &b) -> ScalarAffineFunction\n{\n\treturn ScalarAffineFunction({1.0, 1.0}, {a.index, b.index});\n}\n\nauto operator+(const ScalarAffineFunction &a, CoeffT b) -> ScalarAffineFunction\n{\n\tCoeffT new_constant = a.constant.value_or(0.0) + b;\n\treturn ScalarAffineFunction(a.coefficients, a.variables, new_constant);\n}\nauto operator+(CoeffT a, const ScalarAffineFunction &b) -> ScalarAffineFunction\n{\n\treturn b + a;\n}\n\nauto operator+(const ScalarAffineFunction &a, const VariableIndex &b) -> ScalarAffineFunction\n{\n\tauto coefficients = a.coefficients;\n\tauto variables = a.variables;\n\tcoefficients.push_back(1.0);\n\tvariables.push_back(b.index);\n\treturn ScalarAffineFunction(coefficients, variables, a.constant);\n}\nauto operator+(const VariableIndex &a, const ScalarAffineFunction &b) -> ScalarAffineFunction\n{\n\treturn b + a;\n}\n\nauto operator+(const ScalarAffineFunction &a, const ScalarAffineFunction &b) -> ScalarAffineFunction\n{\n\tExprBuilder t(a);\n\tt.operator+=(b);\n\treturn ScalarAffineFunction(t);\n}\n\nauto operator+(const ScalarQuadraticFunction &a, CoeffT b) -> ScalarQuadraticFunction\n{\n\tScalarAffineFunction affine_part;\n\tif (a.affine_part)\n\t{\n\t\taffine_part = operator+(a.affine_part.value(), b);\n\t}\n\telse\n\t{\n\t\taffine_part = ScalarAffineFunction(b);\n\t}\n\treturn ScalarQuadraticFunction(a.coefficients, a.variable_1s, a.variable_2s, affine_part);\n}\nauto operator+(CoeffT a, const ScalarQuadraticFunction &b) -> ScalarQuadraticFunction\n{\n\treturn b + a;\n}\n\nauto operator+(const ScalarQuadraticFunction &a, const VariableIndex &b) -> ScalarQuadraticFunction\n{\n\tScalarAffineFunction affine_part;\n\tif (a.affine_part)\n\t{\n\t\taffine_part = operator+(a.affine_part.value(), b);\n\t}\n\telse\n\t{\n\t\taffine_part = ScalarAffineFunction(b);\n\t}\n\treturn ScalarQuadraticFunction(a.coefficients, a.variable_1s, a.variable_2s, affine_part);\n}\nauto operator+(const VariableIndex &a, const ScalarQuadraticFunction &b) -> ScalarQuadraticFunction\n{\n\treturn b + a;\n}\n\nauto operator+(const ScalarQuadraticFunction &a, const ScalarAffineFunction &b)\n -> ScalarQuadraticFunction\n{\n\tScalarAffineFunction affine_part;\n\tif (a.affine_part)\n\t{\n\t\taffine_part = operator+(a.affine_part.value(), b);\n\t}\n\telse\n\t{\n\t\taffine_part = b;\n\t}\n\treturn ScalarQuadraticFunction(a.coefficients, a.variable_1s, a.variable_2s, affine_part);\n}\nauto operator+(const ScalarAffineFunction &a, const ScalarQuadraticFunction &b)\n -> ScalarQuadraticFunction\n{\n\treturn b + a;\n}\n\nauto operator+(const ScalarQuadraticFunction &a, const ScalarQuadraticFunction &b)\n -> ScalarQuadraticFunction\n{\n\tExprBuilder t(a);\n\tt.operator+=(b);\n\treturn ScalarQuadraticFunction(t);\n}\n\nauto operator-(const VariableIndex &a, CoeffT b) -> ScalarAffineFunction\n{\n\treturn ScalarAffineFunction(a, 1.0, -b);\n}\n\nauto operator-(CoeffT a, const VariableIndex &b) -> ScalarAffineFunction\n{\n\treturn ScalarAffineFunction(b, -1.0, a);\n}\n\nauto operator-(const VariableIndex &a, const VariableIndex &b) -> ScalarAffineFunction\n{\n\treturn ScalarAffineFunction({1.0, -1.0}, {a.index, b.index});\n}\n\nauto operator-(const ScalarAffineFunction &a, CoeffT b) -> ScalarAffineFunction\n{\n\treturn operator+(a, -b);\n}\n\nauto operator-(CoeffT a, const ScalarAffineFunction &b) -> ScalarAffineFunction\n{\n\treturn operator+(operator*(b, -1.0), a);\n}\n\nauto operator-(const ScalarAffineFunction &a, const VariableIndex &b) -> ScalarAffineFunction\n{\n\tauto coefficients = a.coefficients;\n\tauto variables = a.variables;\n\tcoefficients.push_back(-1.0);\n\tvariables.push_back(b.index);\n\treturn ScalarAffineFunction(coefficients, variables, a.constant);\n}\n\nauto operator-(const VariableIndex &a, const ScalarAffineFunction &b) -> ScalarAffineFunction\n{\n\treturn operator+(operator*(b, -1.0), a);\n}\n\nauto operator-(const ScalarAffineFunction &a, const ScalarAffineFunction &b) -> ScalarAffineFunction\n{\n\treturn operator+(a, operator*(b, -1.0));\n}\n\nauto operator-(const ScalarQuadraticFunction &a, CoeffT b) -> ScalarQuadraticFunction\n{\n\treturn operator+(a, -b);\n}\n\nauto operator-(CoeffT a, const ScalarQuadraticFunction &b) -> ScalarQuadraticFunction\n{\n\treturn operator+(operator*(b, -1.0), a);\n}\n\nauto operator-(const ScalarQuadraticFunction &a, const VariableIndex &b) -> ScalarQuadraticFunction\n{\n\treturn operator+(a, ScalarAffineFunction(b, -1.0));\n}\n\nauto operator-(const VariableIndex &a, const ScalarQuadraticFunction &b) -> ScalarQuadraticFunction\n{\n\treturn operator+(operator*(b, -1.0), a);\n}\n\nauto operator-(const ScalarQuadraticFunction &a, const ScalarAffineFunction &b)\n -> ScalarQuadraticFunction\n{\n\treturn operator+(a, operator*(b, -1.0));\n}\n\nauto operator-(const ScalarAffineFunction &a, const ScalarQuadraticFunction &b)\n -> ScalarQuadraticFunction\n{\n\treturn operator+(operator*(b, -1.0), a);\n}\n\nauto operator-(const ScalarQuadraticFunction &a, const ScalarQuadraticFunction &b)\n -> ScalarQuadraticFunction\n{\n\treturn operator+(a, operator*(b, -1.0));\n}\n\nauto operator*(const VariableIndex &a, CoeffT b) -> ScalarAffineFunction\n{\n\treturn ScalarAffineFunction(a, b);\n}\nauto operator*(CoeffT a, const VariableIndex &b) -> ScalarAffineFunction\n{\n\treturn b * a;\n}\n\nauto operator*(const VariableIndex &a, const VariableIndex &b) -> ScalarQuadraticFunction\n{\n\treturn ScalarQuadraticFunction({1.0}, {a.index}, {b.index});\n}\n\nauto operator*(const ScalarAffineFunction &a, CoeffT b) -> ScalarAffineFunction\n{\n\tScalarAffineFunction aa = a;\n\tfor (auto &c : aa.coefficients)\n\t{\n\t\tc *= b;\n\t}\n\tif (aa.constant)\n\t{\n\t\taa.constant = aa.constant.value() * b;\n\t}\n\treturn aa;\n}\nauto operator*(CoeffT a, const ScalarAffineFunction &b) -> ScalarAffineFunction\n{\n\treturn b * a;\n}\n\nauto operator*(const ScalarAffineFunction &a, const VariableIndex &b) -> ScalarQuadraticFunction\n{\n\tauto &coefficients = a.coefficients;\n\tauto &variable_1s = a.variables;\n\tauto variable_2s = Vector(variable_1s.size(), b.index);\n\n\tstd::optional affine_part;\n\tif (a.constant)\n\t{\n\t\taffine_part = operator*(b, a.constant.value());\n\t}\n\n\treturn ScalarQuadraticFunction(coefficients, variable_1s, variable_2s, affine_part);\n}\nauto operator*(const VariableIndex &a, const ScalarAffineFunction &b) -> ScalarQuadraticFunction\n{\n\treturn b * a;\n}\n\nauto operator*(const ScalarAffineFunction &a, const ScalarAffineFunction &b)\n -> ScalarQuadraticFunction\n{\n\tauto t = ExprBuilder();\n\n\tfor (int i = 0; i < a.coefficients.size(); i++)\n\t{\n\t\tauto ci = a.coefficients[i];\n\t\tauto xi = a.variables[i];\n\t\tfor (int j = 0; j < b.coefficients.size(); j++)\n\t\t{\n\t\t\tauto dj = b.coefficients[j];\n\t\t\tauto xj = b.variables[j];\n\t\t\tt._add_quadratic_term(xi, xj, ci * dj);\n\t\t}\n\t}\n\tif (b.constant)\n\t{\n\t\tauto d0 = b.constant.value();\n\t\tfor (int i = 0; i < a.coefficients.size(); i++)\n\t\t{\n\t\t\tauto ci = a.coefficients[i];\n\t\t\tauto xi = a.variables[i];\n\t\t\tt._add_affine_term(xi, ci * d0);\n\t\t}\n\t}\n\tif (a.constant)\n\t{\n\t\tauto c0 = a.constant.value();\n\t\tfor (int j = 0; j < b.coefficients.size(); j++)\n\t\t{\n\t\t\tauto dj = b.coefficients[j];\n\t\t\tauto xj = b.variables[j];\n\t\t\tt._add_affine_term(xj, c0 * dj);\n\t\t}\n\t}\n\tif (a.constant && b.constant)\n\t{\n\t\tt.constant_term = a.constant.value() * b.constant.value();\n\t}\n\treturn ScalarQuadraticFunction(t);\n}\n\nauto operator*(const ScalarQuadraticFunction &a, CoeffT b) -> ScalarQuadraticFunction\n{\n\tScalarQuadraticFunction aa = a;\n\tfor (auto &c : aa.coefficients)\n\t{\n\t\tc *= b;\n\t}\n\tif (aa.affine_part)\n\t{\n\t\taa.affine_part = operator*(aa.affine_part.value(), b);\n\t}\n\treturn aa;\n}\nauto operator*(CoeffT a, const ScalarQuadraticFunction &b) -> ScalarQuadraticFunction\n{\n\treturn b * a;\n}\n\nauto operator/(const VariableIndex &a, CoeffT b) -> ScalarAffineFunction\n{\n\treturn a * (1.0 / b);\n}\n\nauto operator/(const ScalarAffineFunction &a, CoeffT b) -> ScalarAffineFunction\n{\n\treturn a * (1.0 / b);\n}\n\nauto operator/(const ScalarQuadraticFunction &a, CoeffT b) -> ScalarQuadraticFunction\n{\n\treturn a * (1.0 / b);\n}\n\nauto operator-(const VariableIndex &a) -> ScalarAffineFunction\n{\n\treturn a * -1.0;\n}\n\nauto operator-(const ScalarAffineFunction &a) -> ScalarAffineFunction\n{\n\treturn a * -1.0;\n}\n\nauto operator-(const ScalarQuadraticFunction &a) -> ScalarQuadraticFunction\n{\n\treturn a * -1.0;\n}\n\nauto operator-(const ExprBuilder &a) -> ExprBuilder\n{\n\treturn a * -1.0;\n}\n\nauto operator+(const ExprBuilder &a, CoeffT b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator+=(b);\n\treturn e;\n}\nauto operator+(CoeffT b, const ExprBuilder &a) -> ExprBuilder\n{\n\treturn a + b;\n}\n\nauto operator+(const ExprBuilder &a, const VariableIndex &b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator+=(b);\n\treturn e;\n}\nauto operator+(const VariableIndex &b, const ExprBuilder &a) -> ExprBuilder\n{\n\treturn a + b;\n}\n\nauto operator+(const ExprBuilder &a, const ScalarAffineFunction &b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator+=(b);\n\treturn e;\n}\nauto operator+(const ScalarAffineFunction &b, const ExprBuilder &a) -> ExprBuilder\n{\n\treturn a + b;\n}\n\nauto operator+(const ExprBuilder &a, const ScalarQuadraticFunction &b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator+=(b);\n\treturn e;\n}\nauto operator+(const ScalarQuadraticFunction &b, const ExprBuilder &a) -> ExprBuilder\n{\n\treturn a + b;\n}\n\nauto operator+(const ExprBuilder &a, const ExprBuilder &b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator+=(b);\n\treturn e;\n}\n\nauto operator-(const ExprBuilder &a, CoeffT b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator-=(b);\n\treturn e;\n}\nauto operator-(CoeffT b, const ExprBuilder &a) -> ExprBuilder\n{\n\tExprBuilder e = a - b;\n\te.operator*=(-1.0);\n\treturn e;\n}\n\nauto operator-(const ExprBuilder &a, const VariableIndex &b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator-=(b);\n\treturn e;\n}\nauto operator-(const VariableIndex &b, const ExprBuilder &a) -> ExprBuilder\n{\n\tExprBuilder e = a - b;\n\te.operator*=(-1.0);\n\treturn e;\n}\n\nauto operator-(const ExprBuilder &a, const ScalarAffineFunction &b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator-=(b);\n\treturn e;\n}\nauto operator-(const ScalarAffineFunction &b, const ExprBuilder &a) -> ExprBuilder\n{\n\tExprBuilder e = a - b;\n\te.operator*=(-1.0);\n\treturn e;\n}\n\nauto operator-(const ExprBuilder &a, const ScalarQuadraticFunction &b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator-=(b);\n\treturn e;\n}\nauto operator-(const ScalarQuadraticFunction &b, const ExprBuilder &a) -> ExprBuilder\n{\n\tExprBuilder e = a - b;\n\te.operator*=(-1.0);\n\treturn e;\n}\n\nauto operator-(const ExprBuilder &a, const ExprBuilder &b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator-=(b);\n\treturn e;\n}\n\nauto operator*(const ExprBuilder &a, CoeffT b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator*=(b);\n\treturn e;\n}\nauto operator*(CoeffT b, const ExprBuilder &a) -> ExprBuilder\n{\n\treturn a * b;\n}\n\nauto operator*(const ExprBuilder &a, const VariableIndex &b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator*=(b);\n\treturn e;\n}\nauto operator*(const VariableIndex &b, const ExprBuilder &a) -> ExprBuilder\n{\n\treturn a * b;\n}\n\nauto operator*(const ExprBuilder &a, const ScalarAffineFunction &b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator*=(b);\n\treturn e;\n}\nauto operator*(const ScalarAffineFunction &b, const ExprBuilder &a) -> ExprBuilder\n{\n\treturn a * b;\n}\n\nauto operator*(const ExprBuilder &a, const ScalarQuadraticFunction &b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator*=(b);\n\treturn e;\n}\nauto operator*(const ScalarQuadraticFunction &b, const ExprBuilder &a) -> ExprBuilder\n{\n\treturn a * b;\n}\n\nauto operator*(const ExprBuilder &a, const ExprBuilder &b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator*=(b);\n\treturn e;\n}\n\nauto operator/(const ExprBuilder &a, CoeffT b) -> ExprBuilder\n{\n\tExprBuilder e = a;\n\te.operator/=(b);\n\treturn e;\n}\n" }, { "path": "lib/core_ext.cpp", "content": "#include \n#include \n#include \n#include \n#include \n\n#include \"pyoptinterface/core.hpp\"\n#include \"pyoptinterface/container.hpp\"\n\n#include \n#include \n\nnamespace nb = nanobind;\n\nusing CoeffNdarrayT = nb::ndarray, nb::any_contig>;\nusing IndexNdarrayT = nb::ndarray, nb::any_contig>;\n\nNB_MODULE(core_ext, m)\n{\n\tnb::set_leak_warnings(false);\n\n\t// VariableDomain\n\tnb::enum_(m, \"VariableDomain\", nb::is_arithmetic())\n\t .value(\"Continuous\", VariableDomain::Continuous)\n\t .value(\"Integer\", VariableDomain::Integer)\n\t .value(\"Binary\", VariableDomain::Binary)\n\t .value(\"SemiContinuous\", VariableDomain::SemiContinuous);\n\n\t// ConstraintSense\n\tnb::enum_(m, \"ConstraintSense\")\n\t .value(\"LessEqual\", ConstraintSense::LessEqual)\n\t .value(\"Equal\", ConstraintSense::Equal)\n\t .value(\"GreaterEqual\", ConstraintSense::GreaterEqual);\n\n\t// ConstraintType\n\tnb::enum_(m, \"ConstraintType\")\n\t .value(\"Linear\", ConstraintType::Linear)\n\t .value(\"Quadratic\", ConstraintType::Quadratic)\n\t .value(\"SOS\", ConstraintType::SOS)\n\t .value(\"SecondOrderCone\", ConstraintType::SecondOrderCone)\n\t .value(\"ExponentialCone\", ConstraintType::ExponentialCone);\n\n\tnb::enum_(m, \"SOSType\").value(\"SOS1\", SOSType::SOS1).value(\"SOS2\", SOSType::SOS2);\n\n\t// ObjectiveSense\n\tnb::enum_(m, \"ObjectiveSense\")\n\t .value(\"Minimize\", ObjectiveSense::Minimize)\n\t .value(\"Maximize\", ObjectiveSense::Maximize);\n\n\tnb::class_(m, \"VariableIndex\")\n\t .def(nb::init())\n\t .def_ro(\"index\", &VariableIndex::index)\n\t .def(-nb::self)\n\t .def(nb::self + CoeffT())\n\t .def(CoeffT() + nb::self)\n\t .def(nb::self + VariableIndex())\n\t .def(nb::self + ScalarAffineFunction())\n\t .def(nb::self + ScalarQuadraticFunction())\n\t .def(nb::self - CoeffT())\n\t .def(CoeffT() - nb::self)\n\t .def(nb::self - VariableIndex())\n\t .def(nb::self - ScalarAffineFunction())\n\t .def(nb::self - ScalarQuadraticFunction())\n\t .def(nb::self * CoeffT())\n\t .def(CoeffT() * nb::self)\n\t .def(nb::self * VariableIndex())\n\t .def(nb::self * ScalarAffineFunction())\n\t .def(nb::self / CoeffT());\n\n\tnb::class_(m, \"ConstraintIndex\")\n\t .def(nb::init())\n\t .def_ro(\"type\", &ConstraintIndex::type)\n\t .def_ro(\"index\", &ConstraintIndex::index);\n\n\tnb::class_(m, \"ScalarAffineFunction\")\n\t .def(nb::init<>())\n\t .def(nb::init())\n\t .def(nb::init())\n\t .def(nb::init())\n\t .def(nb::init())\n\t .def(nb::init &, const Vector &>(), nb::arg(\"coefficients\"),\n\t nb::arg(\"variables\"))\n\t .def(nb::init &, const Vector &, CoeffT>(),\n\t nb::arg(\"coefficients\"), nb::arg(\"variables\"), nb::arg(\"constant\"))\n\n\t // ndarray constructor\n\t .def_static(\n\t \"from_numpy\",\n\t [](CoeffNdarrayT coefficients, IndexNdarrayT variables) {\n\t\t auto *expr = new ScalarAffineFunction();\n\n\t\t auto n = coefficients.size();\n\n\t\t expr->coefficients.resize(n);\n\t\t std::span coeffs(coefficients.data(), n);\n\t\t std::ranges::copy(coeffs, expr->coefficients.begin());\n\n\t\t n = variables.size();\n\t\t expr->variables.resize(n);\n\t\t std::span vars(variables.data(), n);\n\t\t std::ranges::copy(vars, expr->variables.begin());\n\n\t\t expr->constant.reset();\n\n\t\t return expr;\n\t },\n\t nb::arg(\"coefficients\"), nb::arg(\"variables\"), nb::rv_policy::take_ownership)\n\t .def_static(\n\t \"from_numpy\",\n\t [](CoeffNdarrayT coefficients, IndexNdarrayT variables, CoeffT constant) {\n\t\t auto *expr = new ScalarAffineFunction();\n\n\t\t auto n = coefficients.size();\n\n\t\t expr->coefficients.resize(n);\n\t\t std::span coeffs(coefficients.data(), n);\n\t\t std::ranges::copy(coeffs, expr->coefficients.begin());\n\n\t\t n = variables.size();\n\t\t expr->variables.resize(n);\n\t\t std::span vars(variables.data(), n);\n\t\t std::ranges::copy(vars, expr->variables.begin());\n\n\t\t expr->constant = constant;\n\n\t\t return expr;\n\t },\n\t nb::arg(\"coefficients\"), nb::arg(\"variables\"), nb::arg(\"constant\"),\n\t nb::rv_policy::take_ownership)\n\n\t .def(nb::init())\n\t .def_ro(\"coefficients\", &ScalarAffineFunction::coefficients)\n\t .def_ro(\"variables\", &ScalarAffineFunction::variables)\n\t .def_ro(\"constant\", &ScalarAffineFunction::constant)\n\t .def(\"size\", &ScalarAffineFunction::size)\n\t .def(\"canonicalize\", &ScalarAffineFunction::canonicalize,\n\t nb::arg(\"threshold\") = COEFTHRESHOLD)\n\t .def(\"reserve\", &ScalarAffineFunction::reserve)\n\t .def(\"add_term\", &ScalarAffineFunction::add_term)\n\t .def(\"add_constant\", &ScalarAffineFunction::add_constant)\n\t .def(-nb::self)\n\t .def(nb::self + CoeffT())\n\t .def(CoeffT() + nb::self)\n\t .def(nb::self + VariableIndex())\n\t .def(nb::self + ScalarAffineFunction())\n\t .def(nb::self + ScalarQuadraticFunction())\n\t .def(nb::self - CoeffT())\n\t .def(CoeffT() - nb::self)\n\t .def(nb::self - VariableIndex())\n\t .def(nb::self - ScalarAffineFunction())\n\t .def(nb::self - ScalarQuadraticFunction())\n\t .def(nb::self * CoeffT())\n\t .def(CoeffT() * nb::self)\n\t .def(nb::self * VariableIndex())\n\t .def(nb::self * ScalarAffineFunction())\n\t .def(nb::self / CoeffT());\n\n\tnb::class_(m, \"ScalarQuadraticFunction\")\n\t .def(nb::init<>())\n\t .def(nb::init &, const Vector &, const Vector &>(),\n\t nb::arg(\"coefficients\"), nb::arg(\"var1s\"), nb::arg(\"var2s\"))\n\t .def(nb::init &, const Vector &, const Vector &,\n\t const ScalarAffineFunction &>(),\n\t nb::arg(\"coefficients\"), nb::arg(\"var1s\"), nb::arg(\"var2s\"), nb::arg(\"affine_part\"))\n\t .def(nb::init())\n\t .def_ro(\"coefficients\", &ScalarQuadraticFunction::coefficients)\n\t .def_ro(\"variable_1s\", &ScalarQuadraticFunction::variable_1s)\n\t .def_ro(\"variable_2s\", &ScalarQuadraticFunction::variable_2s)\n\t .def_ro(\"affine_part\", &ScalarQuadraticFunction::affine_part)\n\t .def(\"size\", &ScalarQuadraticFunction::size)\n\t .def(\"canonicalize\", &ScalarQuadraticFunction::canonicalize,\n\t nb::arg(\"threshold\") = COEFTHRESHOLD)\n\t .def(\"reserve_quadratic\", &ScalarQuadraticFunction::reserve_quadratic)\n\t .def(\"reserve_affine\", &ScalarQuadraticFunction::reserve_affine)\n\t .def(\"add_quadratic_term\", &ScalarQuadraticFunction::add_quadratic_term)\n\t .def(\"add_affine_term\", &ScalarQuadraticFunction::add_affine_term)\n\t .def(\"add_constant\", &ScalarQuadraticFunction::add_constant)\n\t .def(-nb::self)\n\t .def(nb::self + CoeffT())\n\t .def(CoeffT() + nb::self)\n\t .def(nb::self + VariableIndex())\n\t .def(nb::self + ScalarAffineFunction())\n\t .def(nb::self + ScalarQuadraticFunction())\n\t .def(nb::self - CoeffT())\n\t .def(CoeffT() - nb::self)\n\t .def(nb::self - VariableIndex())\n\t .def(nb::self - ScalarAffineFunction())\n\t .def(nb::self - ScalarQuadraticFunction())\n\t .def(nb::self * CoeffT())\n\t .def(CoeffT() * nb::self)\n\t .def(nb::self / CoeffT());\n\n\tnb::class_(m, \"VariablePair\").def(nb::init());\n\n\tnb::class_(m, \"ExprBuilder\")\n\t .def(nb::init<>())\n\t .def(nb::init())\n\t .def(nb::init())\n\t .def(nb::init())\n\t .def(nb::init())\n\t .def(\"empty\", &ExprBuilder::empty)\n\t .def(\"degree\", &ExprBuilder::degree)\n\t .def(\"reserve_quadratic\", &ExprBuilder::reserve_quadratic)\n\t .def(\"reserve_affine\", &ExprBuilder::reserve_affine)\n\t .def(\"clear\", &ExprBuilder::clear)\n\t .def(\"clean_nearzero_terms\", &ExprBuilder::clean_nearzero_terms,\n\t nb::arg(\"threshold\") = COEFTHRESHOLD)\n\t .def(\"add_quadratic_term\", &ExprBuilder::add_quadratic_term)\n\t .def(\"set_quadratic_coef\", &ExprBuilder::set_quadratic_coef)\n\t .def(\"add_affine_term\", &ExprBuilder::add_affine_term)\n\t .def(\"set_affine_coef\", &ExprBuilder::set_affine_coef)\n\t .def(-nb::self)\n\t .def(nb::self += CoeffT(), nb::rv_policy::none)\n\t .def(nb::self += VariableIndex(), nb::rv_policy::none)\n\t .def(nb::self += ScalarAffineFunction(), nb::rv_policy::none)\n\t .def(nb::self += ScalarQuadraticFunction(), nb::rv_policy::none)\n\t .def(nb::self += ExprBuilder(), nb::rv_policy::none)\n\t .def(nb::self -= CoeffT(), nb::rv_policy::none)\n\t .def(nb::self -= VariableIndex(), nb::rv_policy::none)\n\t .def(nb::self -= ScalarAffineFunction(), nb::rv_policy::none)\n\t .def(nb::self -= ScalarQuadraticFunction(), nb::rv_policy::none)\n\t .def(nb::self -= ExprBuilder(), nb::rv_policy::none)\n\t .def(nb::self *= CoeffT(), nb::rv_policy::none)\n\t .def(nb::self *= VariableIndex(), nb::rv_policy::none)\n\t .def(nb::self *= ScalarAffineFunction(), nb::rv_policy::none)\n\t .def(nb::self *= ScalarQuadraticFunction(), nb::rv_policy::none)\n\t .def(nb::self *= ExprBuilder(), nb::rv_policy::none)\n\t .def(nb::self /= CoeffT(), nb::rv_policy::none)\n\t .def(nb::self + CoeffT())\n\t .def(CoeffT() + nb::self)\n\t .def(nb::self + VariableIndex())\n\t .def(nb::self + ScalarAffineFunction())\n\t .def(nb::self + ScalarQuadraticFunction())\n\t .def(nb::self + ExprBuilder())\n\t .def(VariableIndex() + nb::self)\n\t .def(ScalarAffineFunction() + nb::self)\n\t .def(ScalarQuadraticFunction() + nb::self)\n\t .def(nb::self - CoeffT())\n\t .def(CoeffT() - nb::self)\n\t .def(nb::self - VariableIndex())\n\t .def(nb::self - ScalarAffineFunction())\n\t .def(nb::self - ScalarQuadraticFunction())\n\t .def(nb::self - ExprBuilder())\n\t .def(VariableIndex() - nb::self)\n\t .def(ScalarAffineFunction() - nb::self)\n\t .def(ScalarQuadraticFunction() - nb::self)\n\t .def(nb::self * CoeffT())\n\t .def(CoeffT() * nb::self)\n\t .def(nb::self * VariableIndex())\n\t .def(nb::self * ScalarAffineFunction())\n\t .def(nb::self * ScalarQuadraticFunction())\n\t .def(nb::self * ExprBuilder())\n\t .def(VariableIndex() * nb::self)\n\t .def(ScalarAffineFunction() * nb::self)\n\t .def(ScalarQuadraticFunction() * nb::self)\n\t .def(nb::self / CoeffT());\n\n\t// We need to test the functionality of MonotoneIndexer\n\tusing IntMonotoneIndexer = MonotoneIndexer;\n\tnb::class_(m, \"IntMonotoneIndexer\")\n\t .def(nb::init<>())\n\t .def(\"add_index\", &IntMonotoneIndexer::add_index)\n\t .def(\"get_index\", &IntMonotoneIndexer::get_index)\n\t .def(\"delete_index\", &IntMonotoneIndexer::delete_index);\n}\n" }, { "path": "lib/cppad_interface.cpp", "content": "#include \"pyoptinterface/cppad_interface.hpp\"\n\n#include \"fmt/core.h\"\n\nstatic const std::string opt_options = \"no_compare_op no_conditional_skip no_cumulative_sum_op\";\n\nADFunDouble dense_jacobian(const ADFunDouble &f)\n{\n\tusing CppAD::AD;\n\tusing CppAD::ADFun;\n\tusing CppAD::Independent;\n\tusing Base = double;\n\n\tsize_t nx = f.Domain();\n\tsize_t ny = f.Range();\n\tsize_t np = f.size_dyn_ind();\n\tstd::vector> apx(np + nx), ax(nx), ap(np), aj(nx * ny);\n\tADFun, Base> af = f.base2ad();\n\tIndependent(apx);\n\tfor (size_t i = 0; i < np; i++)\n\t\tap[i] = apx[i];\n\tfor (size_t i = 0; i < nx; i++)\n\t\tax[i] = apx[np + i];\n\taf.new_dynamic(ap);\n\taj = af.Jacobian(ax);\n\tADFun jac;\n\tjac.Dependent(apx, aj);\n\n\tjac.optimize(opt_options);\n\n\treturn jac;\n}\n\nJacobianHessianSparsityPattern jacobian_hessian_sparsity(ADFunDouble &f,\n HessianSparsityType hessian_sparsity)\n{\n\tusing s_vector = std::vector;\n\tusing CppAD::sparse_rc;\n\n\tsize_t nx = f.Domain();\n\tsize_t ny = f.Range();\n\tsize_t np = f.size_dyn_ind();\n\n\tJacobianHessianSparsityPattern jachess;\n\n\t// We must compute the jacobian sparsity first\n\t{\n\t\t// sparsity pattern for the identity matrix\n\t\tsize_t nr = nx;\n\t\tsize_t nc = nx;\n\t\tsize_t nnz_in = nx;\n\t\tsparsity_pattern_t pattern_jac_in(nr, nc, nnz_in);\n\t\tfor (size_t k = 0; k < nnz_in; k++)\n\t\t{\n\t\t\tsize_t r = k;\n\t\t\tsize_t c = k;\n\t\t\tpattern_jac_in.set(k, r, c);\n\t\t}\n\t\t// compute sparsity pattern for J(x) = F'(x)\n\t\tconst bool transpose = false;\n\t\tconst bool dependency = false;\n\t\tconst bool internal_bool = true;\n\t\tsparsity_pattern_t pattern_jac;\n\t\tf.for_jac_sparsity(pattern_jac_in, transpose, dependency, internal_bool, pattern_jac);\n\n\t\tjachess.jacobian = pattern_jac;\n\t}\n\n\tstd::vector select_range(ny, true);\n\tconst bool transpose = false;\n\tconst bool internal_bool = true;\n\tsparsity_pattern_t pattern_hes;\n\tf.rev_hes_sparsity(select_range, transpose, internal_bool, pattern_hes);\n\n\tjachess.hessian = pattern_hes;\n\n\t// Filter the sparsity pattern\n\tsparsity_pattern_t pattern_hes_partial;\n\tpattern_hes_partial.resize(nx, nx, 0);\n\tif (hessian_sparsity == HessianSparsityType::Upper)\n\t{\n\t\tfor (int i = 0; i < pattern_hes.nnz(); i++)\n\t\t{\n\t\t\tauto r = pattern_hes.row()[i];\n\t\t\tauto c = pattern_hes.col()[i];\n\t\t\tif (r <= c)\n\t\t\t{\n\t\t\t\tpattern_hes_partial.push_back(r, c);\n\t\t\t}\n\t\t}\n\t}\n\telse if (hessian_sparsity == HessianSparsityType::Lower)\n\t{\n\t\tfor (int i = 0; i < pattern_hes.nnz(); i++)\n\t\t{\n\t\t\tauto r = pattern_hes.row()[i];\n\t\t\tauto c = pattern_hes.col()[i];\n\t\t\tif (r >= c)\n\t\t\t{\n\t\t\t\tpattern_hes_partial.push_back(r, c);\n\t\t\t}\n\t\t}\n\t}\n\tjachess.reduced_hessian = pattern_hes_partial;\n\treturn jachess;\n}\n\nADFunDouble sparse_jacobian(const ADFunDouble &f, const sparsity_pattern_t &pattern_jac,\n const std::vector &x_values,\n const std::vector &p_values)\n{\n\tusing CppAD::AD;\n\tusing CppAD::ADFun;\n\tusing CppAD::Independent;\n\tusing Base = double;\n\n\tsize_t nx = f.Domain();\n\tsize_t ny = f.Range();\n\tsize_t np = f.size_dyn_ind();\n\tstd::vector> apx(np + nx), ax(nx), ap(np);\n\tfor (size_t i = 0; i < np; i++)\n\t{\n\t\tapx[i] = p_values[i];\n\t}\n\tfor (size_t i = 0; i < nx; i++)\n\t{\n\t\tapx[np + i] = x_values[i];\n\t}\n\tADFun, Base> af = f.base2ad();\n\tIndependent(apx);\n\tfor (size_t i = 0; i < np; i++)\n\t{\n\t\tap[i] = apx[i];\n\t}\n\tfor (size_t i = 0; i < nx; i++)\n\t{\n\t\tax[i] = apx[np + i];\n\t}\n\taf.new_dynamic(ap);\n\tCppAD::sparse_rcv, std::vector>> subset(pattern_jac);\n\tCppAD::sparse_jac_work work;\n\tstd::string coloring = \"cppad\";\n\tsize_t n_color = af.sparse_jac_rev(ax, subset, pattern_jac, coloring, work);\n\tADFun jacobian;\n\tjacobian.Dependent(apx, subset.val());\n\n\tjacobian.optimize(opt_options);\n\n\treturn jacobian;\n}\n\nADFunDouble sparse_hessian(const ADFunDouble &f, const sparsity_pattern_t &pattern_hes,\n const sparsity_pattern_t &pattern_subset,\n const std::vector &x_values, const std::vector &p_values)\n{\n\tusing CppAD::AD;\n\tusing CppAD::ADFun;\n\tusing CppAD::Independent;\n\tusing Base = double;\n\n\tsize_t nx = f.Domain();\n\tsize_t ny = f.Range();\n\tsize_t np = f.size_dyn_ind();\n\tsize_t nw = ny;\n\tstd::vector> apwx(np + nw + nx), ax(nx), ap(np), aw(nw);\n\tfor (size_t i = 0; i < np; i++)\n\t{\n\t\tapwx[i] = p_values[i];\n\t}\n\tfor (size_t i = 0; i < nw; i++)\n\t{\n\t\tapwx[np + i] = 1.0;\n\t}\n\tfor (size_t i = 0; i < nx; i++)\n\t{\n\t\tapwx[np + nw + i] = x_values[i];\n\t}\n\tADFun, Base> af = f.base2ad();\n\tIndependent(apwx);\n\tfor (size_t i = 0; i < np; i++)\n\t{\n\t\tap[i] = apwx[i];\n\t}\n\tfor (size_t i = 0; i < nw; i++)\n\t{\n\t\taw[i] = apwx[np + i];\n\t}\n\tfor (size_t i = 0; i < nx; i++)\n\t{\n\t\tax[i] = apwx[np + nw + i];\n\t}\n\taf.new_dynamic(ap);\n\tCppAD::sparse_rcv, std::vector>> subset(pattern_subset);\n\tCppAD::sparse_hes_work work;\n\tstd::string coloring = \"cppad.symmetric\";\n\tsize_t n_sweep = af.sparse_hes(ax, aw, subset, pattern_hes, coloring, work);\n\tADFun hessian;\n\thessian.Dependent(apwx, subset.val());\n\n\thessian.optimize(opt_options);\n\n\treturn hessian;\n}\n\nCppAD::AD cppad_build_unary_expression(UnaryOperator op, const CppAD::AD &operand)\n{\n\tswitch (op)\n\t{\n\tcase UnaryOperator::Neg: {\n\t\treturn -operand;\n\t}\n\tcase UnaryOperator::Sin: {\n\t\treturn CppAD::sin(operand);\n\t}\n\tcase UnaryOperator::Cos: {\n\t\treturn CppAD::cos(operand);\n\t}\n\tcase UnaryOperator::Tan: {\n\t\treturn CppAD::tan(operand);\n\t}\n\tcase UnaryOperator::Asin: {\n\t\treturn CppAD::asin(operand);\n\t}\n\tcase UnaryOperator::Acos: {\n\t\treturn CppAD::acos(operand);\n\t}\n\tcase UnaryOperator::Atan: {\n\t\treturn CppAD::atan(operand);\n\t}\n\tcase UnaryOperator::Abs: {\n\t\treturn CppAD::abs(operand);\n\t}\n\tcase UnaryOperator::Sqrt: {\n\t\treturn CppAD::sqrt(operand);\n\t}\n\tcase UnaryOperator::Exp: {\n\t\treturn CppAD::exp(operand);\n\t}\n\tcase UnaryOperator::Log: {\n\t\treturn CppAD::log(operand);\n\t}\n\tcase UnaryOperator::Log10: {\n\t\treturn CppAD::log10(operand);\n\t}\n\tdefault: {\n\t\tauto msg = \"Invalid unary operator \" + unary_operator_to_string(op);\n\t\tthrow std::runtime_error(msg);\n\t}\n\t}\n}\n\nCppAD::AD cppad_build_binary_expression(BinaryOperator op, const CppAD::AD &left,\n const CppAD::AD &right)\n{\n\tswitch (op)\n\t{\n\tcase BinaryOperator::Sub: {\n\t\treturn left - right;\n\t}\n\tcase BinaryOperator::Div: {\n\t\treturn left / right;\n\t}\n\tcase BinaryOperator::Pow: {\n\t\treturn CppAD::pow(left, right);\n\t}\n\tcase BinaryOperator::LessThan:\n\tcase BinaryOperator::LessEqual:\n\tcase BinaryOperator::Equal:\n\tcase BinaryOperator::NotEqual:\n\tcase BinaryOperator::GreaterEqual:\n\tcase BinaryOperator::GreaterThan: {\n\t\tthrow std::runtime_error(\"Currently comparision operator can only be used with ifelse \"\n\t\t \"function and cannot be evaluated as value\");\n\t}\n\tdefault: {\n\t\tauto msg = \"Invalid binary operator \" + binary_operator_to_string(op);\n\t\tthrow std::runtime_error(msg);\n\t}\n\t}\n}\n\nCppAD::AD cppad_build_ternary_expression(BinaryOperator compare_op,\n const CppAD::AD &compare_left,\n const CppAD::AD &compare_right,\n const CppAD::AD &then_result,\n const CppAD::AD &else_result)\n{\n\tswitch (compare_op)\n\t{\n\tcase BinaryOperator::LessThan: {\n\t\treturn CppAD::CondExpLt(compare_left, compare_right, then_result, else_result);\n\t}\n\tcase BinaryOperator::LessEqual: {\n\t\treturn CppAD::CondExpLe(compare_left, compare_right, then_result, else_result);\n\t}\n\tcase BinaryOperator::Equal: {\n\t\treturn CppAD::CondExpEq(compare_left, compare_right, then_result, else_result);\n\t}\n\tcase BinaryOperator::NotEqual: {\n\t\treturn CppAD::CondExpEq(compare_left, compare_right, else_result, then_result);\n\t}\n\tcase BinaryOperator::GreaterEqual: {\n\t\treturn CppAD::CondExpGe(compare_left, compare_right, then_result, else_result);\n\t}\n\tcase BinaryOperator::GreaterThan: {\n\t\treturn CppAD::CondExpGt(compare_left, compare_right, then_result, else_result);\n\t}\n\tdefault: {\n\t\tauto msg = \"Invalid compare operator \" + binary_operator_to_string(compare_op);\n\t\tthrow std::runtime_error(msg);\n\t}\n\t}\n}\n\nCppAD::AD cppad_build_nary_expression(NaryOperator op,\n const std::vector> &operands)\n{\n\tif (operands.size() == 0)\n\t\treturn CppAD::AD(0.0);\n\n\tCppAD::AD result = operands[0];\n\tswitch (op)\n\t{\n\tcase NaryOperator::Add: {\n\t\tfor (auto i = 1; i < operands.size(); i++)\n\t\t{\n\t\t\tresult += operands[i];\n\t\t}\n\t\tbreak;\n\t}\n\tcase NaryOperator::Mul: {\n\t\tfor (auto i = 1; i < operands.size(); i++)\n\t\t{\n\t\t\tresult *= operands[i];\n\t\t}\n\t\tbreak;\n\t}\n\tdefault: {\n\t\tauto msg = \"Invalid nary operator \" + nary_operator_to_string(op);\n\t\tthrow std::runtime_error(msg);\n\t}\n\t}\n\treturn result;\n}\n\nCppAD::AD cppad_trace_expression(\n const ExpressionGraph &graph, const ExpressionHandle &expression,\n const std::vector> &x, const std::vector> &p,\n ankerl::unordered_dense::map> &seen_expressions)\n{\n\tauto it = seen_expressions.find(expression);\n\tif (it != seen_expressions.end())\n\t{\n\t\treturn it->second;\n\t}\n\tCppAD::AD result;\n\tauto id = expression.id;\n\tswitch (expression.array)\n\t{\n\tcase ArrayType::Variable: {\n\t\tresult = x[id];\n\t\tbreak;\n\t}\n\tcase ArrayType::Constant: {\n\t\tresult = p[id];\n\t\tbreak;\n\t}\n\tcase ArrayType::Parameter: {\n\t\tthrow std::runtime_error(\"Parameter is not supported in cppad_trace_expression\");\n\t\tbreak;\n\t}\n\tcase ArrayType::Unary: {\n\t\tauto &unary = graph.m_unaries[id];\n\t\tauto operand = cppad_trace_expression(graph, unary.operand, x, p, seen_expressions);\n\t\tresult = cppad_build_unary_expression(unary.op, operand);\n\t\tseen_expressions[expression] = result;\n\t\tbreak;\n\t}\n\tcase ArrayType::Binary: {\n\t\tauto &binary = graph.m_binaries[id];\n\t\tauto left = cppad_trace_expression(graph, binary.left, x, p, seen_expressions);\n\t\tauto right = cppad_trace_expression(graph, binary.right, x, p, seen_expressions);\n\t\tresult = cppad_build_binary_expression(binary.op, left, right);\n\t\tseen_expressions[expression] = result;\n\t\tbreak;\n\t}\n\tcase ArrayType::Ternary: {\n\t\tauto &ifelsethen_body = graph.m_ternaries[id];\n\t\tauto &condition = ifelsethen_body.left;\n\t\tassert(condition.array == ArrayType::Binary);\n\n\t\tauto &condition_body = graph.m_binaries[condition.id];\n\t\tBinaryOperator compare_op = condition_body.op;\n\t\tassert(is_binary_compare_op(compare_op));\n\n\t\tCppAD::AD compare_left =\n\t\t cppad_trace_expression(graph, condition_body.left, x, p, seen_expressions);\n\t\tCppAD::AD compare_right =\n\t\t cppad_trace_expression(graph, condition_body.right, x, p, seen_expressions);\n\n\t\tCppAD::AD then_result =\n\t\t cppad_trace_expression(graph, ifelsethen_body.middle, x, p, seen_expressions);\n\t\tCppAD::AD else_result =\n\t\t cppad_trace_expression(graph, ifelsethen_body.right, x, p, seen_expressions);\n\n\t\tresult = cppad_build_ternary_expression(compare_op, compare_left, compare_right,\n\t\t then_result, else_result);\n\t\tseen_expressions[expression] = result;\n\t\tbreak;\n\t}\n\tcase ArrayType::Nary: {\n\t\tauto &nary = graph.m_naries[id];\n\t\tstd::vector> operand_values;\n\t\tfor (auto &operand : nary.operands)\n\t\t{\n\t\t\tauto operand_value = cppad_trace_expression(graph, operand, x, p, seen_expressions);\n\t\t\toperand_values.push_back(operand_value);\n\t\t}\n\t\tresult = cppad_build_nary_expression(nary.op, operand_values);\n\t\tseen_expressions[expression] = result;\n\t\tbreak;\n\t}\n\tdefault: {\n\t\tthrow std::runtime_error(\"Invalid array type\");\n\t}\n\t}\n\treturn result;\n}\n\nADFunDouble cppad_trace_graph_constraints(const ExpressionGraph &graph,\n const std::vector &selected)\n{\n\tankerl::unordered_dense::map> seen_expressions;\n\n\tauto N_inputs = graph.n_variables();\n\tstd::vector> x(N_inputs);\n\n\tauto N_parameters = graph.n_constants();\n\tstd::vector> p(N_parameters);\n\t// Must assign value to parameter, otherwise p will be zero\n\t// and CppAD::pow(x, p) will be 0\n\tfor (size_t i = 0; i < N_parameters; i++)\n\t{\n\t\tp[i] = graph.m_constants[i];\n\t}\n\n\tif (N_parameters > 0)\n\t{\n\t\tCppAD::Independent(x, p);\n\t}\n\telse\n\t{\n\t\tCppAD::Independent(x);\n\t}\n\n\tauto &outputs = graph.m_constraint_outputs;\n\n\tstd::vector indices;\n\tif (selected.empty())\n\t{\n\t\tindices.reserve(outputs.size());\n\t\tfor (size_t i = 0; i < outputs.size(); i++)\n\t\t{\n\t\t\tindices.push_back(i);\n\t\t}\n\t}\n\telse\n\t{\n\t\tindices = selected;\n\t}\n\n\tauto N_outputs = indices.size();\n\tstd::vector> y(N_outputs);\n\n\t// Trace the selected outputs\n\tfor (size_t i = 0; i < N_outputs; i++)\n\t{\n\t\tauto idx = indices[i];\n\t\tauto &output = outputs[idx];\n\t\ty[i] = cppad_trace_expression(graph, output, x, p, seen_expressions);\n\t}\n\n\tADFunDouble f;\n\tf.Dependent(x, y);\n\n\treturn f;\n}\n\nADFunDouble cppad_trace_graph_objective(const ExpressionGraph &graph,\n const std::vector &selected, bool aggregate)\n{\n\tankerl::unordered_dense::map> seen_expressions;\n\n\tauto N_inputs = graph.n_variables();\n\tstd::vector> x(N_inputs);\n\n\tauto N_parameters = graph.n_constants();\n\tstd::vector> p(N_parameters);\n\tfor (size_t i = 0; i < N_parameters; i++)\n\t{\n\t\tp[i] = graph.m_constants[i];\n\t}\n\n\tif (N_parameters > 0)\n\t{\n\t\tCppAD::Independent(x, p);\n\t}\n\telse\n\t{\n\t\tCppAD::Independent(x);\n\t}\n\n\tauto &outputs = graph.m_objective_outputs;\n\n\tstd::vector indices;\n\tif (selected.empty())\n\t{\n\t\tindices.reserve(outputs.size());\n\t\tfor (size_t i = 0; i < outputs.size(); i++)\n\t\t{\n\t\t\tindices.push_back(i);\n\t\t}\n\t}\n\telse\n\t{\n\t\tindices = selected;\n\t}\n\n\tauto N_outputs = indices.size();\n\tstd::vector> y(N_outputs);\n\n\tfor (size_t i = 0; i < N_outputs; i++)\n\t{\n\t\tauto idx = indices[i];\n\t\tauto &output = outputs[idx];\n\t\ty[i] = cppad_trace_expression(graph, output, x, p, seen_expressions);\n\t}\n\n\tADFunDouble f;\n\n\tif (aggregate)\n\t{\n\t\tCppAD::AD y_sum = 0.0;\n\t\tfor (size_t i = 0; i < N_outputs; i++)\n\t\t{\n\t\t\ty_sum += y[i];\n\t\t}\n\t\tf.Dependent(x, {y_sum});\n\t}\n\telse\n\t{\n\t\tf.Dependent(x, y);\n\t}\n\n\treturn f;\n}\n\nvoid cppad_autodiff(ADFunDouble &f, AutodiffSymbolicStructure &structure, CppADAutodiffGraph &graph,\n const std::vector &x_values, const std::vector &p_values)\n{\n\tauto nx = f.Domain();\n\tauto np = f.size_dyn_ind();\n\tassert(x_values.size() == nx);\n\tassert(p_values.size() == np);\n\n\tauto ny = f.Range();\n\n\tstructure.nx = nx;\n\tstructure.np = np;\n\tstructure.ny = ny;\n\tstructure.has_parameter = np > 0;\n\n\tf.to_graph(graph.f_graph);\n\n\tauto sparsity = jacobian_hessian_sparsity(f, HessianSparsityType::Upper);\n\n\t{\n\t\tauto &pattern = sparsity.jacobian;\n\t\tauto &m_jacobian_rows = structure.m_jacobian_rows;\n\t\tauto &m_jacobian_cols = structure.m_jacobian_cols;\n\t\tauto &m_jacobian_nnz = structure.m_jacobian_nnz;\n\t\tfor (int i = 0; i < pattern.nnz(); i++)\n\t\t{\n\t\t\tauto r = pattern.row()[i];\n\t\t\tauto c = pattern.col()[i];\n\t\t\tm_jacobian_rows.push_back(r);\n\t\t\tm_jacobian_cols.push_back(c);\n\t\t}\n\t\tm_jacobian_nnz = pattern.nnz();\n\t}\n\n\t{\n\t\tauto &pattern = sparsity.reduced_hessian;\n\t\tauto &m_hessian_rows = structure.m_hessian_rows;\n\t\tauto &m_hessian_cols = structure.m_hessian_cols;\n\t\tauto &m_hessian_nnz = structure.m_hessian_nnz;\n\t\tfor (int i = 0; i < pattern.nnz(); i++)\n\t\t{\n\t\t\tauto r = pattern.row()[i];\n\t\t\tauto c = pattern.col()[i];\n\t\t\tm_hessian_rows.push_back(r);\n\t\t\tm_hessian_cols.push_back(c);\n\t\t}\n\t\tm_hessian_nnz = pattern.nnz();\n\t}\n\n\tif (structure.m_jacobian_nnz > 0)\n\t{\n\t\tstructure.has_jacobian = true;\n\t\tADFunDouble jacobian = sparse_jacobian(f, sparsity.jacobian, x_values, p_values);\n\t\tjacobian.to_graph(graph.jacobian_graph);\n\t}\n\n\tif (structure.m_hessian_nnz > 0)\n\t{\n\t\tstructure.has_hessian = true;\n\t\tADFunDouble hessian =\n\t\t sparse_hessian(f, sparsity.hessian, sparsity.reduced_hessian, x_values, p_values);\n\t\thessian.to_graph(graph.hessian_graph);\n\t}\n}\n" }, { "path": "lib/cppad_interface_ext.cpp", "content": "#include \n#include \n#include \n#include \n#include \n\nnamespace nb = nanobind;\n\n#include \"pyoptinterface/cppad_interface.hpp\"\n\nusing graph_op_enum = CppAD::graph::graph_op_enum;\n\nstruct cpp_graph_cursor\n{\n\tsize_t op_index = 0;\n\tsize_t arg_index = 0;\n};\n\ngraph_op_enum cursor_op(CppAD::cpp_graph &graph, cpp_graph_cursor &cursor)\n{\n\treturn graph.operator_vec_get(cursor.op_index);\n}\n\nsize_t cursor_n_arg(CppAD::cpp_graph &graph, cpp_graph_cursor &cursor)\n{\n\tauto op = cursor_op(graph, cursor);\n\n\tsize_t n_arg = 0;\n\n\tswitch (op)\n\t{\n\t// unary operators\n\tcase graph_op_enum::abs_graph_op:\n\tcase graph_op_enum::acos_graph_op:\n\tcase graph_op_enum::acosh_graph_op:\n\tcase graph_op_enum::asin_graph_op:\n\tcase graph_op_enum::asinh_graph_op:\n\tcase graph_op_enum::atan_graph_op:\n\tcase graph_op_enum::atanh_graph_op:\n\tcase graph_op_enum::cos_graph_op:\n\tcase graph_op_enum::cosh_graph_op:\n\tcase graph_op_enum::erf_graph_op:\n\tcase graph_op_enum::erfc_graph_op:\n\tcase graph_op_enum::exp_graph_op:\n\tcase graph_op_enum::expm1_graph_op:\n\tcase graph_op_enum::log1p_graph_op:\n\tcase graph_op_enum::log_graph_op:\n\tcase graph_op_enum::neg_graph_op:\n\tcase graph_op_enum::sign_graph_op:\n\tcase graph_op_enum::sin_graph_op:\n\tcase graph_op_enum::sinh_graph_op:\n\tcase graph_op_enum::sqrt_graph_op:\n\tcase graph_op_enum::tan_graph_op:\n\tcase graph_op_enum::tanh_graph_op:\n\t\tn_arg = 1;\n\t\tbreak;\n\n\t// binary operators\n\tcase graph_op_enum::add_graph_op:\n\tcase graph_op_enum::azmul_graph_op:\n\tcase graph_op_enum::div_graph_op:\n\tcase graph_op_enum::mul_graph_op:\n\tcase graph_op_enum::pow_graph_op:\n\tcase graph_op_enum::sub_graph_op:\n\t\tn_arg = 2;\n\t\tbreak;\n\n\t// conditional operators\n\tcase graph_op_enum::cexp_eq_graph_op:\n\tcase graph_op_enum::cexp_le_graph_op:\n\tcase graph_op_enum::cexp_lt_graph_op:\n\t\tn_arg = 4;\n\t\tbreak;\n\n\tdefault: {\n\t\tstd::string op_name = CppAD::local::graph::op_enum2name[op];\n\t\tauto message = \"Unknown graph_op: \" + op_name;\n\t\tthrow std::runtime_error(message);\n\t}\n\tbreak;\n\t}\n\n\treturn n_arg;\n}\n\nvoid advance_graph_cursor(CppAD::cpp_graph &graph, cpp_graph_cursor &cursor)\n{\n\tauto n_arg = cursor_n_arg(graph, cursor);\n\tcursor.arg_index += n_arg;\n\tcursor.op_index++;\n}\n\nNB_MODULE(cppad_interface_ext, m)\n{\n\tnb::enum_(m, \"graph_op\")\n\t .value(\"abs\", graph_op_enum::abs_graph_op)\n\t .value(\"acos\", graph_op_enum::acos_graph_op)\n\t .value(\"acosh\", graph_op_enum::acosh_graph_op)\n\t .value(\"add\", graph_op_enum::add_graph_op)\n\t .value(\"asin\", graph_op_enum::asin_graph_op)\n\t .value(\"asinh\", graph_op_enum::asinh_graph_op)\n\t .value(\"atan\", graph_op_enum::atan_graph_op)\n\t .value(\"atanh\", graph_op_enum::atanh_graph_op)\n\t .value(\"atom4\", graph_op_enum::atom4_graph_op)\n\t .value(\"atom\", graph_op_enum::atom_graph_op)\n\t .value(\"azmul\", graph_op_enum::azmul_graph_op)\n\t .value(\"cexp_eq\", graph_op_enum::cexp_eq_graph_op)\n\t .value(\"cexp_le\", graph_op_enum::cexp_le_graph_op)\n\t .value(\"cexp_lt\", graph_op_enum::cexp_lt_graph_op)\n\t .value(\"comp_eq\", graph_op_enum::comp_eq_graph_op)\n\t .value(\"comp_le\", graph_op_enum::comp_le_graph_op)\n\t .value(\"comp_lt\", graph_op_enum::comp_lt_graph_op)\n\t .value(\"comp_ne\", graph_op_enum::comp_ne_graph_op)\n\t .value(\"cos\", graph_op_enum::cos_graph_op)\n\t .value(\"cosh\", graph_op_enum::cosh_graph_op)\n\t .value(\"discrete\", graph_op_enum::discrete_graph_op)\n\t .value(\"div\", graph_op_enum::div_graph_op)\n\t .value(\"erf\", graph_op_enum::erf_graph_op)\n\t .value(\"erfc\", graph_op_enum::erfc_graph_op)\n\t .value(\"exp\", graph_op_enum::exp_graph_op)\n\t .value(\"expm1\", graph_op_enum::expm1_graph_op)\n\t .value(\"log1p\", graph_op_enum::log1p_graph_op)\n\t .value(\"log\", graph_op_enum::log_graph_op)\n\t .value(\"mul\", graph_op_enum::mul_graph_op)\n\t .value(\"neg\", graph_op_enum::neg_graph_op)\n\t .value(\"pow\", graph_op_enum::pow_graph_op)\n\t .value(\"print\", graph_op_enum::print_graph_op)\n\t .value(\"sign\", graph_op_enum::sign_graph_op)\n\t .value(\"sin\", graph_op_enum::sin_graph_op)\n\t .value(\"sinh\", graph_op_enum::sinh_graph_op)\n\t .value(\"sqrt\", graph_op_enum::sqrt_graph_op)\n\t .value(\"sub\", graph_op_enum::sub_graph_op)\n\t .value(\"sum\", graph_op_enum::sum_graph_op)\n\t .value(\"tan\", graph_op_enum::tan_graph_op)\n\t .value(\"tanh\", graph_op_enum::tanh_graph_op);\n\n\tnb::class_(m, \"cpp_graph_cursor\")\n\t .def(nb::init<>())\n\t .def_ro(\"op_index\", &cpp_graph_cursor::op_index)\n\t .def_ro(\"arg_index\", &cpp_graph_cursor::arg_index);\n\n\tnb::class_(m, \"cpp_graph\")\n\t .def(nb::init<>())\n\t .def_prop_ro(\"n_dynamic_ind\", [](CppAD::cpp_graph &g) { return g.n_dynamic_ind_get(); })\n\t .def_prop_ro(\"n_variable_ind\", [](CppAD::cpp_graph &g) { return g.n_variable_ind_get(); })\n\t .def_prop_ro(\"n_constant\", [](CppAD::cpp_graph &g) { return g.constant_vec_size(); })\n\t .def_prop_ro(\"n_dependent\", [](CppAD::cpp_graph &g) { return g.dependent_vec_size(); })\n\t .def_prop_ro(\"n_operator\", [](CppAD::cpp_graph &g) { return g.operator_vec_size(); })\n\t .def_prop_ro(\"n_operator_arg\", [](CppAD::cpp_graph &g) { return g.operator_arg_size(); })\n\t .def(\"constant_vec_get\", &CppAD::cpp_graph::constant_vec_get)\n\t .def(\"dependent_vec_get\", &CppAD::cpp_graph::dependent_vec_get)\n\t .def(\"__str__\",\n\t [](CppAD::cpp_graph &g) {\n\t\t std::ostringstream oss;\n\t\t g.print(oss);\n\t\t return oss.str();\n\t })\n\t .def(\"get_cursor_op\", &cursor_op)\n\t .def(\"get_cursor_n_arg\", &cursor_n_arg)\n\t .def(\"get_cursor_args\",\n\t [](CppAD::cpp_graph &graph, cpp_graph_cursor &cursor) {\n\t\t auto n_arg = cursor_n_arg(graph, cursor);\n\t\t nb::list args;\n\t\t for (size_t i = 0; i < n_arg; i++)\n\t\t {\n\t\t\t auto arg = graph.operator_arg_get(cursor.arg_index + i);\n\t\t\t args.append(nb::int_(arg));\n\t\t }\n\t\t return args;\n\t })\n\t .def(\"next_cursor\", &advance_graph_cursor);\n\n\tnb::class_(m, \"ADFunDouble\")\n\t .def(nb::init<>())\n\t .def_prop_ro(\"nx\", [](const ADFunDouble &f) { return f.Domain(); })\n\t .def_prop_ro(\"ny\", [](const ADFunDouble &f) { return f.Range(); })\n\t .def_prop_ro(\"np\", [](const ADFunDouble &f) { return f.size_dyn_ind(); })\n\t .def(\"to_graph\", &ADFunDouble::to_graph);\n\n\tnb::class_(m, \"CppADAutodiffGraph\")\n\t .def(nb::init<>())\n\t .def_ro(\"f\", &CppADAutodiffGraph::f_graph)\n\t .def_ro(\"jacobian\", &CppADAutodiffGraph::jacobian_graph)\n\t .def_ro(\"hessian\", &CppADAutodiffGraph::hessian_graph);\n\n\tm.def(\"cppad_trace_graph_constraints\", cppad_trace_graph_constraints, nb::arg(\"graph\"),\n\t nb::arg(\"selected\") = std::vector{});\n\tm.def(\"cppad_trace_graph_objective\", cppad_trace_graph_objective, nb::arg(\"graph\"),\n\t nb::arg(\"selected\") = std::vector{}, nb::arg(\"aggregate\") = true);\n\tm.def(\"cppad_autodiff\", &cppad_autodiff);\n}\n" }, { "path": "lib/gurobi_model.cpp", "content": "#include \"pyoptinterface/gurobi_model.hpp\"\n#include \"fmt/core.h\"\n\n#include \n\nextern \"C\"\n{\n\tint __stdcall GRBloadenvinternal(GRBenv **envP, const char *logfilename, int major, int minor,\n\t int tech);\n\tint __stdcall GRBemptyenvinternal(GRBenv **envP, int major, int minor, int tech);\n\tint __stdcall GRBloadenv_1200(GRBenv **envP, const char *logfile);\n\tint __stdcall GRBemptyenv_1200(GRBenv **envP);\n}\n\nnamespace gurobi\n{\n#define B DYLIB_DECLARE\nAPILIST\n#undef B\n\n// Gurobi 12.0.0 workarounds\nDYLIB_DECLARE(GRBloadenvinternal);\nDYLIB_DECLARE(GRBemptyenvinternal);\n\nstatic DynamicLibrary lib;\nstatic bool is_loaded = false;\n\nbool is_library_loaded()\n{\n\treturn is_loaded;\n}\n\nbool load_library(const std::string &path)\n{\n\tbool success = lib.try_load(path.c_str());\n\tif (!success)\n\t{\n\t\treturn false;\n\t}\n\n\tDYLIB_LOAD_INIT;\n\n#define B DYLIB_LOAD_FUNCTION\n\tAPILIST\n#undef B\n\n\t// We have to deal with Gurobi 12.0.0 where some functions are absent from the dynamic library\n\t{\n\t\tint major, minor, techinical;\n\t\tauto GRBversion_p =\n\t\t reinterpret_cast(_function_pointers[\"GRBversion\"]);\n\t\tif (GRBversion_p != nullptr)\n\t\t{\n\t\t\tGRBversion_p(&major, &minor, &techinical);\n\n\t\t\tif (major == 12 && minor == 0 && techinical == 0)\n\t\t\t{\n\t\t\t\tDYLIB_LOAD_FUNCTION(GRBloadenvinternal);\n\t\t\t\tDYLIB_LOAD_FUNCTION(GRBemptyenvinternal);\n\t\t\t\t_function_pointers[\"GRBloadenv\"] = reinterpret_cast(&GRBloadenv_1200);\n\t\t\t\t_function_pointers[\"GRBemptyenv\"] = reinterpret_cast(&GRBemptyenv_1200);\n\n\t\t\t\t// Now check there is no nullptr in _function_pointers\n\t\t\t\t_load_success = true;\n\t\t\t\tfor (auto &pair : _function_pointers)\n\t\t\t\t{\n\t\t\t\t\tif (pair.second == nullptr)\n\t\t\t\t\t{\n\t\t\t\t\t\tfmt::print(\"function {} is not loaded correctly\\n\", pair.first);\n\t\t\t\t\t\t_load_success = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (_load_success)\n\t\t\t\t{\n\t\t\t\t\tDYLIB_SAVE_FUNCTION(GRBloadenvinternal);\n\t\t\t\t\tDYLIB_SAVE_FUNCTION(GRBemptyenvinternal);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tif (IS_DYLIB_LOAD_SUCCESS)\n\t{\n#define B DYLIB_SAVE_FUNCTION\n\t\tAPILIST\n#undef B\n\t\tis_loaded = true;\n\t\treturn true;\n\t}\n\telse\n\t{\n\t\treturn false;\n\t}\n}\n} // namespace gurobi\n\nint GRBloadenv_1200(GRBenv **envP, const char *logfile)\n{\n\treturn gurobi::GRBloadenvinternal(envP, logfile, 12, 0, 0);\n}\n\nint GRBemptyenv_1200(GRBenv **envP)\n{\n\treturn gurobi::GRBemptyenvinternal(envP, 12, 0, 0);\n}\n\nstatic char gurobi_con_sense(ConstraintSense sense)\n{\n\tswitch (sense)\n\t{\n\tcase ConstraintSense::LessEqual:\n\t\treturn GRB_LESS_EQUAL;\n\tcase ConstraintSense::Equal:\n\t\treturn GRB_EQUAL;\n\tcase ConstraintSense::GreaterEqual:\n\t\treturn GRB_GREATER_EQUAL;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint sense\");\n\t}\n}\n\nstatic int gurobi_obj_sense(ObjectiveSense sense)\n{\n\tswitch (sense)\n\t{\n\tcase ObjectiveSense::Minimize:\n\t\treturn GRB_MINIMIZE;\n\tcase ObjectiveSense::Maximize:\n\t\treturn GRB_MAXIMIZE;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown objective sense\");\n\t}\n}\n\nstatic char gurobi_vtype(VariableDomain domain)\n{\n\tswitch (domain)\n\t{\n\tcase VariableDomain::Continuous:\n\t\treturn GRB_CONTINUOUS;\n\tcase VariableDomain::Integer:\n\t\treturn GRB_INTEGER;\n\tcase VariableDomain::Binary:\n\t\treturn GRB_BINARY;\n\tcase VariableDomain::SemiContinuous:\n\t\treturn GRB_SEMICONT;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown variable domain\");\n\t}\n}\n\nstatic int gurobi_sostype(SOSType type)\n{\n\tswitch (type)\n\t{\n\tcase SOSType::SOS1:\n\t\treturn GRB_SOS_TYPE1;\n\tcase SOSType::SOS2:\n\t\treturn GRB_SOS_TYPE2;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown SOS type\");\n\t}\n}\n\nGurobiModel::GurobiModel(const GurobiEnv &env)\n{\n\tinit(env);\n}\n\nvoid GurobiModel::init(const GurobiEnv &env)\n{\n\tif (!gurobi::is_library_loaded())\n\t{\n\t\tthrow std::runtime_error(\"Gurobi library is not loaded\");\n\t}\n\n\tGRBmodel *model;\n\tint error = gurobi::GRBnewmodel(env.m_env, &model, NULL, 0, NULL, NULL, NULL, NULL, NULL);\n\tcheck_error(error);\n\tm_env = gurobi::GRBgetenv(model);\n\tm_model = std::unique_ptr(model);\n}\n\nvoid GurobiModel::close()\n{\n\tm_model.reset();\n}\n\nvoid GurobiModel::_reset(int clearall)\n{\n\tint error = gurobi::GRBreset(m_model.get(), clearall);\n\tcheck_error(error);\n}\n\ndouble GurobiModel::get_infinity() const\n{\n\treturn GRB_INFINITY;\n}\n\nvoid GurobiModel::write(const std::string &filename)\n{\n\tint error = gurobi::GRBwrite(m_model.get(), filename.c_str());\n\tcheck_error(error);\n}\n\nVariableIndex GurobiModel::add_variable(VariableDomain domain, double lb, double ub,\n const char *name)\n{\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\tIndexT index = m_variable_index.add_index();\n\tVariableIndex variable(index);\n\n\t// Create a new Gurobi variable\n\tchar vtype = gurobi_vtype(domain);\n\tint error = gurobi::GRBaddvar(m_model.get(), 0, NULL, NULL, 0.0, lb, ub, vtype, name);\n\tcheck_error(error);\n\n\tm_update_flag |= m_variable_creation;\n\n\treturn variable;\n}\n\nvoid GurobiModel::delete_variable(const VariableIndex &variable)\n{\n\tif (!is_variable_active(variable))\n\t{\n\t\tthrow std::runtime_error(\"Variable does not exist\");\n\t}\n\n\t// Delete the corresponding Gurobi variable\n\tint variable_column = _variable_index(variable);\n\tint error = gurobi::GRBdelvars(m_model.get(), 1, &variable_column);\n\tcheck_error(error);\n\n\tm_variable_index.delete_index(variable.index);\n\n\tm_update_flag |= m_variable_deletion;\n}\n\nvoid GurobiModel::delete_variables(const Vector &variables)\n{\n\tint n_variables = variables.size();\n\tif (n_variables == 0)\n\t\treturn;\n\n\tstd::vector columns;\n\tcolumns.reserve(n_variables);\n\tfor (int i = 0; i < n_variables; i++)\n\t{\n\t\tif (!is_variable_active(variables[i]))\n\t\t{\n\t\t\tcontinue;\n\t\t}\n\t\tauto column = _variable_index(variables[i]);\n\t\tcolumns.push_back(column);\n\t}\n\n\tint error = gurobi::GRBdelvars(m_model.get(), columns.size(), columns.data());\n\tcheck_error(error);\n\n\tfor (int i = 0; i < n_variables; i++)\n\t{\n\t\tm_variable_index.delete_index(variables[i].index);\n\t}\n\n\tm_update_flag |= m_variable_deletion;\n}\n\nbool GurobiModel::is_variable_active(const VariableIndex &variable)\n{\n\treturn m_variable_index.has_index(variable.index);\n}\n\ndouble GurobiModel::get_variable_value(const VariableIndex &variable)\n{\n\treturn get_variable_raw_attribute_double(variable, GRB_DBL_ATTR_X);\n}\n\nstd::string GurobiModel::pprint_variable(const VariableIndex &variable)\n{\n\treturn get_variable_raw_attribute_string(variable, GRB_STR_ATTR_VARNAME);\n}\n\nvoid GurobiModel::set_variable_bounds(const VariableIndex &variable, double lb, double ub)\n{\n\tauto column = _checked_variable_index(variable);\n\tint error;\n\terror = gurobi::GRBsetdblattrelement(m_model.get(), GRB_DBL_ATTR_LB, column, lb);\n\tcheck_error(error);\n\terror = gurobi::GRBsetdblattrelement(m_model.get(), GRB_DBL_ATTR_UB, column, ub);\n\tcheck_error(error);\n\tm_update_flag |= m_attribute_update;\n}\n\nvoid GurobiModel::set_variable_name(const VariableIndex &variable, const char *name)\n{\n\tset_variable_raw_attribute_string(variable, GRB_STR_ATTR_VARNAME, name);\n}\n\nvoid GurobiModel::set_constraint_name(const ConstraintIndex &constraint, const char *name)\n{\n\tconst char *attr_name;\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\t\tattr_name = GRB_STR_ATTR_CONSTRNAME;\n\t\tbreak;\n\tcase ConstraintType::Quadratic:\n\t\tattr_name = GRB_STR_ATTR_QCNAME;\n\t\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type to set name!\");\n\t}\n\tset_constraint_raw_attribute_string(constraint, attr_name, name);\n}\n\nConstraintIndex GurobiModel::add_linear_constraint(const ScalarAffineFunction &function,\n ConstraintSense sense, CoeffT rhs,\n const char *name)\n{\n\tIndexT index = m_linear_constraint_index.add_index();\n\tConstraintIndex constraint_index(ConstraintType::Linear, index);\n\n\t// Create a new Gurobi linear constraint\n\tAffineFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\n\tint numnz = ptr_form.numnz;\n\tint *cind = ptr_form.index;\n\tdouble *cval = ptr_form.value;\n\tchar g_sense = gurobi_con_sense(sense);\n\tdouble g_rhs = rhs - function.constant.value_or(0.0);\n\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\n\tint error = gurobi::GRBaddconstr(m_model.get(), numnz, cind, cval, g_sense, g_rhs, name);\n\tcheck_error(error);\n\t// _require_update();\n\n\tm_update_flag |= m_linear_constraint_creation;\n\n\treturn constraint_index;\n}\n\nConstraintIndex GurobiModel::add_quadratic_constraint(const ScalarQuadraticFunction &function,\n ConstraintSense sense, CoeffT rhs,\n const char *name)\n{\n\tIndexT index = m_quadratic_constraint_index.add_index();\n\tConstraintIndex constraint_index(ConstraintType::Quadratic, index);\n\n\t// Create a new Gurobi quadratic constraint\n\tconst auto &affine_part = function.affine_part;\n\n\tint numlnz = 0;\n\tint *lind = NULL;\n\tdouble *lval = NULL;\n\tAffineFunctionPtrForm affine_ptr_form;\n\tif (affine_part.has_value())\n\t{\n\t\tconst auto &affine_function = affine_part.value();\n\t\taffine_ptr_form.make(this, affine_function);\n\t\tnumlnz = affine_ptr_form.numnz;\n\t\tlind = affine_ptr_form.index;\n\t\tlval = affine_ptr_form.value;\n\t}\n\n\tQuadraticFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\tint numqnz = ptr_form.numnz;\n\tint *qrow = ptr_form.row;\n\tint *qcol = ptr_form.col;\n\tdouble *qval = ptr_form.value;\n\n\tchar g_sense = gurobi_con_sense(sense);\n\tdouble g_rhs = rhs;\n\tif (affine_part)\n\t\tg_rhs -= affine_part->constant.value_or(0.0);\n\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\n\tint error = gurobi::GRBaddqconstr(m_model.get(), numlnz, lind, lval, numqnz, qrow, qcol, qval,\n\t g_sense, g_rhs, name);\n\tcheck_error(error);\n\n\tm_update_flag |= m_quadratic_constraint_creation;\n\n\treturn constraint_index;\n}\n\nConstraintIndex GurobiModel::add_sos_constraint(const Vector &variables,\n SOSType sos_type)\n{\n\tVector weights(variables.size(), 1.0);\n\treturn add_sos_constraint(variables, sos_type, weights);\n}\n\nConstraintIndex GurobiModel::add_sos_constraint(const Vector &variables,\n SOSType sos_type, const Vector &weights)\n{\n\tIndexT index = m_sos_constraint_index.add_index();\n\tConstraintIndex constraint_index(ConstraintType::SOS, index);\n\n\t// Create a new Gurobi SOS constraint\n\tint numsos = 1;\n\tint nummembers = variables.size();\n\tint types = gurobi_sostype(sos_type);\n\tint beg[] = {0, nummembers};\n\tstd::vector ind_v(nummembers);\n\tfor (int i = 0; i < nummembers; i++)\n\t{\n\t\tind_v[i] = _variable_index(variables[i].index);\n\t}\n\tint *ind = ind_v.data();\n\tdouble *weight = (double *)weights.data();\n\n\tint error = gurobi::GRBaddsos(m_model.get(), numsos, nummembers, &types, beg, ind, weight);\n\tcheck_error(error);\n\n\tm_update_flag |= m_sos_constraint_creation;\n\n\treturn constraint_index;\n}\n\nint unary_opcode(const UnaryOperator &op)\n{\n\tswitch (op)\n\t{\n\tcase UnaryOperator::Neg:\n\t\treturn GRB_OPCODE_UMINUS;\n\tcase UnaryOperator::Sin:\n\t\treturn GRB_OPCODE_SIN;\n\tcase UnaryOperator::Cos:\n\t\treturn GRB_OPCODE_COS;\n\tcase UnaryOperator::Tan:\n\t\treturn GRB_OPCODE_TAN;\n\tcase UnaryOperator::Sqrt:\n\t\treturn GRB_OPCODE_SQRT;\n\tcase UnaryOperator::Exp:\n\t\treturn GRB_OPCODE_EXP;\n\tcase UnaryOperator::Log:\n\t\treturn GRB_OPCODE_LOG;\n\tcase UnaryOperator::Log10:\n\t\treturn GRB_OPCODE_LOG10;\n\tdefault: {\n\t\tauto opname = unary_operator_to_string(op);\n\t\tauto msg = fmt::format(\"Unknown unary operator for Gurobi: {}\", opname);\n\t\tthrow std::runtime_error(msg);\n\t}\n\t}\n}\n\nint binary_opcode(const BinaryOperator &op)\n{\n\tswitch (op)\n\t{\n\tcase BinaryOperator::Sub:\n\t\treturn GRB_OPCODE_MINUS;\n\tcase BinaryOperator::Div:\n\t\treturn GRB_OPCODE_DIVIDE;\n\tcase BinaryOperator::Pow:\n\t\treturn GRB_OPCODE_POW;\n\tdefault: {\n\t\tauto opname = binary_operator_to_string(op);\n\t\tauto msg = fmt::format(\"Unknown binary operator for Gurobi: {}\", opname);\n\t\tthrow std::runtime_error(msg);\n\t}\n\t}\n}\n\nint nary_opcode(const NaryOperator &op)\n{\n\tswitch (op)\n\t{\n\tcase NaryOperator::Add:\n\t\treturn GRB_OPCODE_PLUS;\n\tcase NaryOperator::Mul:\n\t\treturn GRB_OPCODE_MULTIPLY;\n\tdefault: {\n\t\tauto opname = nary_operator_to_string(op);\n\t\tauto msg = fmt::format(\"Unknown n-ary operator for Gurobi: {}\", opname);\n\t\tthrow std::runtime_error(msg);\n\t}\n\t}\n}\n\nvoid GurobiModel::information_of_expr(const ExpressionGraph &graph, const ExpressionHandle &expr,\n int &opcode, double &data)\n{\n\tauto array_type = expr.array;\n\tauto index = expr.id;\n\tswitch (array_type)\n\t{\n\tcase ArrayType::Constant: {\n\t\topcode = GRB_OPCODE_CONSTANT;\n\t\tdata = graph.m_constants[index];\n\t\tbreak;\n\t}\n\tcase ArrayType::Variable: {\n\t\topcode = GRB_OPCODE_VARIABLE;\n\t\tdata = _checked_variable_index(graph.m_variables[index]);\n\t\tbreak;\n\t}\n\tcase ArrayType::Parameter: {\n\t\tthrow std::runtime_error(\"Parameter is not supported in Gurobi\");\n\t\tbreak;\n\t}\n\tcase ArrayType::Unary: {\n\t\tauto &unary = graph.m_unaries[index];\n\t\topcode = unary_opcode(unary.op);\n\t\tdata = 0.0;\n\t\tbreak;\n\t}\n\tcase ArrayType::Binary: {\n\t\tauto &binary = graph.m_binaries[index];\n\t\topcode = binary_opcode(binary.op);\n\t\tdata = 0.0;\n\t\tbreak;\n\t}\n\tcase ArrayType::Ternary: {\n\t\tthrow std::runtime_error(\"Ternary operator is not supported in Gurobi\");\n\t\tbreak;\n\t}\n\tcase ArrayType::Nary: {\n\t\tauto &nary = graph.m_naries[index];\n\t\topcode = nary_opcode(nary.op);\n\t\tdata = 0.0;\n\t\tbreak;\n\t}\n\t}\n}\n\nvoid GurobiModel::decode_graph(const ExpressionGraph &graph, const ExpressionHandle &result,\n std::vector &opcodes, std::vector &parents,\n std::vector &datas)\n{\n\tstd::stack expr_stack;\n\tstd::stack parent_stack;\n\n\t// init stack\n\texpr_stack.push(result);\n\tparent_stack.push(-1);\n\n\twhile (!expr_stack.empty())\n\t{\n\t\tauto expr = expr_stack.top();\n\t\texpr_stack.pop();\n\t\tauto parent = parent_stack.top();\n\t\tparent_stack.pop();\n\n\t\tint opcode;\n\t\tdouble data;\n\t\tinformation_of_expr(graph, expr, opcode, data);\n\n\t\tauto current_parent = opcodes.size();\n\t\topcodes.push_back(opcode);\n\t\tparents.push_back(parent);\n\t\tdatas.push_back(data);\n\n\t\tauto array_type = expr.array;\n\t\tauto index = expr.id;\n\t\tswitch (array_type)\n\t\t{\n\t\tcase ArrayType::Unary: {\n\t\t\tauto &unary = graph.m_unaries[index];\n\t\t\texpr_stack.push(unary.operand);\n\t\t\tparent_stack.push(current_parent);\n\t\t\tbreak;\n\t\t}\n\t\tcase ArrayType::Binary: {\n\t\t\tauto &binary = graph.m_binaries[index];\n\t\t\texpr_stack.push(binary.right);\n\t\t\texpr_stack.push(binary.left);\n\t\t\tparent_stack.push(current_parent);\n\t\t\tparent_stack.push(current_parent);\n\t\t\tbreak;\n\t\t}\n\t\tcase ArrayType::Nary: {\n\t\t\tauto &nary = graph.m_naries[index];\n\t\t\tfor (int i = nary.operands.size() - 1; i >= 0; i--)\n\t\t\t{\n\t\t\t\texpr_stack.push(nary.operands[i]);\n\t\t\t\tparent_stack.push(current_parent);\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\tdefault:\n\t\t\tbreak;\n\t\t}\n\t}\n}\n\nConstraintIndex GurobiModel::add_single_nl_constraint(const ExpressionGraph &graph,\n const ExpressionHandle &result,\n const std::tuple &interval,\n const char *name)\n{\n\tdouble lb = std::get<0>(interval);\n\tdouble ub = std::get<1>(interval);\n\n\tstd::vector opcodes, parents;\n\tstd::vector datas;\n\n\tdecode_graph(graph, result, opcodes, parents, datas);\n\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\n\t// add a slack variable\n\tVariableIndex resvar = add_variable(VariableDomain::Continuous, lb, ub, name);\n\tauto resvar_column = _variable_index(resvar);\n\n\t// add NL constraint\n\tint error = gurobi::GRBaddgenconstrNL(m_model.get(), name, resvar_column, opcodes.size(),\n\t opcodes.data(), datas.data(), parents.data());\n\tcheck_error(error);\n\n\tIndexT constraint_index = m_general_constraint_index.add_index();\n\n\tConstraintIndex constraint(ConstraintType::NL, constraint_index);\n\tm_nlcon_resvar_map.emplace(constraint_index, resvar.index);\n\n\tm_update_flag |= m_general_constraint_creation;\n\n\treturn constraint;\n}\n\nvoid GurobiModel::delete_constraint(const ConstraintIndex &constraint)\n{\n\t// Delete the corresponding Gurobi constraint\n\tint error = 0;\n\tint constraint_row = _constraint_index(constraint);\n\tif (constraint_row >= 0)\n\t{\n\t\tswitch (constraint.type)\n\t\t{\n\t\tcase ConstraintType::Linear:\n\t\t\tm_linear_constraint_index.delete_index(constraint.index);\n\t\t\terror = gurobi::GRBdelconstrs(m_model.get(), 1, &constraint_row);\n\t\t\tm_update_flag |= m_linear_constraint_deletion;\n\t\t\tbreak;\n\t\tcase ConstraintType::Quadratic:\n\t\t\tm_quadratic_constraint_index.delete_index(constraint.index);\n\t\t\terror = gurobi::GRBdelqconstrs(m_model.get(), 1, &constraint_row);\n\t\t\tm_update_flag |= m_quadratic_constraint_deletion;\n\t\t\tbreak;\n\t\tcase ConstraintType::SOS:\n\t\t\tm_sos_constraint_index.delete_index(constraint.index);\n\t\t\terror = gurobi::GRBdelsos(m_model.get(), 1, &constraint_row);\n\t\t\tm_update_flag |= m_sos_constraint_deletion;\n\t\t\tbreak;\n\t\tcase ConstraintType::NL: {\n\t\t\tm_general_constraint_index.delete_index(constraint.index);\n\t\t\terror = gurobi::GRBdelgenconstrs(m_model.get(), 1, &constraint_row);\n\t\t\t// delete the corresponding resvar variable as well\n\t\t\tauto resvar = m_nlcon_resvar_map.at(constraint.index);\n\t\t\tdelete_variable(VariableIndex(resvar));\n\t\t\tm_update_flag |= m_general_constraint_deletion;\n\t\t\tbreak;\n\t\t}\n\t\tdefault:\n\t\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t\t}\n\t}\n\tcheck_error(error);\n}\n\nbool GurobiModel::is_constraint_active(const ConstraintIndex &constraint)\n{\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\t\treturn m_linear_constraint_index.has_index(constraint.index);\n\tcase ConstraintType::Quadratic:\n\t\treturn m_quadratic_constraint_index.has_index(constraint.index);\n\tcase ConstraintType::SOS:\n\t\treturn m_sos_constraint_index.has_index(constraint.index);\n\tcase ConstraintType::NL:\n\t\treturn m_general_constraint_index.has_index(constraint.index);\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n}\n\nvoid GurobiModel::_set_affine_objective(const ScalarAffineFunction &function, ObjectiveSense sense,\n bool clear_quadratic)\n{\n\tint error = 0;\n\tif (clear_quadratic)\n\t{\n\t\t// First delete all quadratic terms\n\t\terror = gurobi::GRBdelq(m_model.get());\n\t\tcheck_error(error);\n\t}\n\n\t// Set Obj attribute of each variable\n\tint n_variables = get_model_raw_attribute_int(GRB_INT_ATTR_NUMVARS);\n\tstd::vector obj_v(n_variables, 0.0);\n\n\tint numnz = function.size();\n\tfor (int i = 0; i < numnz; i++)\n\t{\n\t\tauto column = _variable_index(function.variables[i]);\n\t\tif (column < 0)\n\t\t{\n\t\t\tthrow std::runtime_error(\"Variable does not exist\");\n\t\t}\n\t\tobj_v[column] = function.coefficients[i];\n\t}\n\n\terror = gurobi::GRBsetdblattrarray(m_model.get(), \"Obj\", 0, n_variables, obj_v.data());\n\tcheck_error(error);\n\terror = gurobi::GRBsetdblattr(m_model.get(), \"ObjCon\", function.constant.value_or(0.0));\n\tcheck_error(error);\n\n\tint obj_sense = gurobi_obj_sense(sense);\n\tset_model_raw_attribute_int(\"ModelSense\", obj_sense);\n\n\tm_update_flag |= m_objective_update;\n}\n\nvoid GurobiModel::set_objective(const ScalarAffineFunction &function, ObjectiveSense sense)\n{\n\t_set_affine_objective(function, sense, true);\n}\n\nvoid GurobiModel::set_objective(const ScalarQuadraticFunction &function, ObjectiveSense sense)\n{\n\tint error = 0;\n\t// First delete all quadratic terms\n\terror = gurobi::GRBdelq(m_model.get());\n\tcheck_error(error);\n\n\t// Add quadratic term\n\tint numqnz = function.size();\n\tif (numqnz > 0)\n\t{\n\t\tQuadraticFunctionPtrForm ptr_form;\n\t\tptr_form.make(this, function);\n\t\tint numqnz = ptr_form.numnz;\n\t\tint *qrow = ptr_form.row;\n\t\tint *qcol = ptr_form.col;\n\t\tdouble *qval = ptr_form.value;\n\n\t\terror = gurobi::GRBaddqpterms(m_model.get(), numqnz, qrow, qcol, qval);\n\t\tcheck_error(error);\n\t}\n\n\t// Affine part\n\tconst auto &affine_part = function.affine_part;\n\tif (affine_part)\n\t{\n\t\tconst auto &affine_function = affine_part.value();\n\t\t_set_affine_objective(affine_function, sense, false);\n\t}\n\telse\n\t{\n\t\tScalarAffineFunction zero;\n\t\t_set_affine_objective(zero, sense, false);\n\t}\n}\n\nvoid GurobiModel::set_objective(const ExprBuilder &function, ObjectiveSense sense)\n{\n\tauto deg = function.degree();\n\tif (deg <= 1)\n\t{\n\t\tScalarAffineFunction f(function);\n\t\tset_objective(f, sense);\n\t}\n\telse if (deg == 2)\n\t{\n\t\tScalarQuadraticFunction f(function);\n\t\tset_objective(f, sense);\n\t}\n\telse\n\t{\n\t\tthrow std::runtime_error(\"Objective must be linear or quadratic\");\n\t}\n}\n\nvoid GurobiModel::add_single_nl_objective(ExpressionGraph &graph, const ExpressionHandle &result)\n{\n\tstd::vector opcodes, parents;\n\tstd::vector datas;\n\n\tdecode_graph(graph, result, opcodes, parents, datas);\n\n\t// add a slack variable\n\tVariableIndex resvar = add_variable(VariableDomain::Continuous);\n\tauto resvar_column = _variable_index(resvar);\n\n\t// add NL constraint\n\tint error = gurobi::GRBaddgenconstrNL(m_model.get(), nullptr, resvar_column, opcodes.size(),\n\t opcodes.data(), datas.data(), parents.data());\n\tcheck_error(error);\n\n\tIndexT constraint_index = m_general_constraint_index.add_index();\n\n\tm_nlobj_num += 1;\n\tm_nlobj_con_indices.push_back(constraint_index);\n\tm_nlobj_resvar_indices.push_back(resvar.index);\n\n\tm_update_flag |= m_general_constraint_creation;\n}\n\nvoid GurobiModel::set_nl_objective()\n{\n\tif (m_nlobj_num > 0)\n\t{\n\t\tstd::vector resvar_columns(m_nlobj_num);\n\t\tstd::vector resvar_objcoefs(m_nlobj_num);\n\t\tstd::fill(resvar_objcoefs.begin(), resvar_objcoefs.end(), 1.0);\n\n\t\tfor (int i = 0; i < m_nlobj_num; i++)\n\t\t{\n\t\t\tauto resvar = m_nlobj_resvar_indices[i];\n\t\t\tresvar_columns[i] = _variable_index(resvar);\n\t\t}\n\n\t\tint error = gurobi::GRBsetdblattrlist(m_model.get(), GRB_DBL_ATTR_OBJ, m_nlobj_num,\n\t\t resvar_columns.data(), resvar_objcoefs.data());\n\t\tcheck_error(error);\n\t}\n}\n\nvoid GurobiModel::optimize()\n{\n\tif (has_callback)\n\t{\n\t\t// Store the number of variables for the callback\n\t\tm_callback_userdata.n_variables = get_model_raw_attribute_int(GRB_INT_ATTR_NUMVARS);\n\t}\n\tset_nl_objective();\n\tm_update_flag = 0;\n\tint error = gurobi::GRBoptimize(m_model.get());\n\tcheck_error(error);\n}\n\nvoid GurobiModel::update()\n{\n\tint error = gurobi::GRBupdatemodel(m_model.get());\n\tcheck_error(error);\n\tm_update_flag = 0;\n}\n\nint GurobiModel::raw_parameter_type(const char *param_name)\n{\n\treturn gurobi::GRBgetparamtype(m_env, param_name);\n}\n\nvoid GurobiModel::set_raw_parameter_int(const char *param_name, int value)\n{\n\tint error = gurobi::GRBsetintparam(m_env, param_name, value);\n\tcheck_error(error);\n}\n\nvoid GurobiModel::set_raw_parameter_double(const char *param_name, double value)\n{\n\tint error = gurobi::GRBsetdblparam(m_env, param_name, value);\n\tcheck_error(error);\n}\n\nvoid GurobiModel::set_raw_parameter_string(const char *param_name, const char *value)\n{\n\tint error = gurobi::GRBsetstrparam(m_env, param_name, value);\n\tcheck_error(error);\n}\n\nint GurobiModel::get_raw_parameter_int(const char *param_name)\n{\n\tint retval;\n\tint error = gurobi::GRBgetintparam(m_env, param_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble GurobiModel::get_raw_parameter_double(const char *param_name)\n{\n\tdouble retval;\n\tint error = gurobi::GRBgetdblparam(m_env, param_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nstd::string GurobiModel::get_raw_parameter_string(const char *param_name)\n{\n\tchar retval[GRB_MAX_STRLEN];\n\tint error = gurobi::GRBgetstrparam(m_env, param_name, retval);\n\tcheck_error(error);\n\treturn std::string(retval);\n}\n\nint GurobiModel::raw_attribute_type(const char *attr_name)\n{\n\tint datatypeP;\n\tint error = gurobi::GRBgetattrinfo(m_model.get(), attr_name, &datatypeP, NULL, NULL);\n\tcheck_error(error);\n\treturn datatypeP;\n}\n\nvoid GurobiModel::set_model_raw_attribute_int(const char *attr_name, int value)\n{\n\tint error = gurobi::GRBsetintattr(m_model.get(), attr_name, value);\n\tcheck_error(error);\n\tm_update_flag |= m_attribute_update;\n}\n\nvoid GurobiModel::set_model_raw_attribute_double(const char *attr_name, double value)\n{\n\tint error = gurobi::GRBsetdblattr(m_model.get(), attr_name, value);\n\tcheck_error(error);\n\tm_update_flag |= m_attribute_update;\n}\n\nvoid GurobiModel::set_model_raw_attribute_string(const char *attr_name, const char *value)\n{\n\tint error = gurobi::GRBsetstrattr(m_model.get(), attr_name, value);\n\tcheck_error(error);\n\tm_update_flag |= m_attribute_update;\n}\n\nint GurobiModel::get_model_raw_attribute_int(const char *attr_name)\n{\n\t_update_for_information();\n\tint retval;\n\tint error = gurobi::GRBgetintattr(m_model.get(), attr_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble GurobiModel::get_model_raw_attribute_double(const char *attr_name)\n{\n\t_update_for_information();\n\tdouble retval;\n\tint error = gurobi::GRBgetdblattr(m_model.get(), attr_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nstd::string GurobiModel::get_model_raw_attribute_string(const char *attr_name)\n{\n\t_update_for_information();\n\tchar *retval;\n\tint error = gurobi::GRBgetstrattr(m_model.get(), attr_name, &retval);\n\tcheck_error(error);\n\treturn std::string(retval);\n}\n\nstd::vector GurobiModel::get_model_raw_attribute_vector_double(const char *attr_name,\n int start, int len)\n{\n\t_update_for_information();\n\tstd::vector retval(len);\n\tint error = gurobi::GRBgetdblattrarray(m_model.get(), attr_name, start, len, retval.data());\n\tcheck_error(error);\n\treturn retval;\n}\n\nstd::vector GurobiModel::get_model_raw_attribute_list_double(const char *attr_name,\n const std::vector &ind)\n{\n\t_update_for_information();\n\tstd::vector retval(ind.size());\n\tint error = gurobi::GRBgetdblattrlist(m_model.get(), attr_name, ind.size(), (int *)ind.data(),\n\t retval.data());\n\tcheck_error(error);\n\treturn retval;\n}\n\nvoid GurobiModel::set_variable_raw_attribute_int(const VariableIndex &variable,\n const char *attr_name, int value)\n{\n\tauto column = _checked_variable_index(variable);\n\tint error = gurobi::GRBsetintattrelement(m_model.get(), attr_name, column, value);\n\tcheck_error(error);\n\tm_update_flag |= m_attribute_update;\n}\n\nvoid GurobiModel::set_variable_raw_attribute_char(const VariableIndex &variable,\n const char *attr_name, char value)\n{\n\tauto column = _checked_variable_index(variable);\n\tint error = gurobi::GRBsetcharattrelement(m_model.get(), attr_name, column, value);\n\tcheck_error(error);\n\tm_update_flag |= m_attribute_update;\n}\n\nvoid GurobiModel::set_variable_raw_attribute_double(const VariableIndex &variable,\n const char *attr_name, double value)\n{\n\tauto column = _checked_variable_index(variable);\n\tint error = gurobi::GRBsetdblattrelement(m_model.get(), attr_name, column, value);\n\tcheck_error(error);\n\tm_update_flag |= m_attribute_update;\n}\n\nvoid GurobiModel::set_variable_raw_attribute_string(const VariableIndex &variable,\n const char *attr_name, const char *value)\n{\n\tauto column = _checked_variable_index(variable);\n\tint error = gurobi::GRBsetstrattrelement(m_model.get(), attr_name, column, value);\n\tcheck_error(error);\n\tm_update_flag |= m_attribute_update;\n}\n\nint GurobiModel::get_variable_raw_attribute_int(const VariableIndex &variable,\n const char *attr_name)\n{\n\t_update_for_information();\n\tauto column = _checked_variable_index(variable);\n\tint retval;\n\tint error = gurobi::GRBgetintattrelement(m_model.get(), attr_name, column, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nchar GurobiModel::get_variable_raw_attribute_char(const VariableIndex &variable,\n const char *attr_name)\n{\n\t_update_for_information();\n\tauto column = _checked_variable_index(variable);\n\tchar retval;\n\tint error = gurobi::GRBgetcharattrelement(m_model.get(), attr_name, column, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble GurobiModel::get_variable_raw_attribute_double(const VariableIndex &variable,\n const char *attr_name)\n{\n\t_update_for_information();\n\tauto column = _checked_variable_index(variable);\n\tdouble retval;\n\tint error = gurobi::GRBgetdblattrelement(m_model.get(), attr_name, column, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nstd::string GurobiModel::get_variable_raw_attribute_string(const VariableIndex &variable,\n const char *attr_name)\n{\n\t_update_for_information();\n\tauto column = _checked_variable_index(variable);\n\tchar *retval;\n\tint error = gurobi::GRBgetstrattrelement(m_model.get(), attr_name, column, &retval);\n\tcheck_error(error);\n\treturn std::string(retval);\n}\n\nint GurobiModel::_variable_index(const VariableIndex &variable)\n{\n\t_update_for_variable_index();\n\treturn m_variable_index.get_index(variable.index);\n}\n\nint GurobiModel::_checked_variable_index(const VariableIndex &variable)\n{\n\tint column = _variable_index(variable);\n\tif (column < 0)\n\t{\n\t\tthrow std::runtime_error(\"Variable does not exist\");\n\t}\n\treturn column;\n}\n\nvoid GurobiModel::set_constraint_raw_attribute_int(const ConstraintIndex &constraint,\n const char *attr_name, int value)\n{\n\tint row = _checked_constraint_index(constraint);\n\tint error = gurobi::GRBsetintattrelement(m_model.get(), attr_name, row, value);\n\tcheck_error(error);\n\tm_update_flag |= m_attribute_update;\n}\n\nvoid GurobiModel::set_constraint_raw_attribute_char(const ConstraintIndex &constraint,\n const char *attr_name, char value)\n{\n\tint row = _checked_constraint_index(constraint);\n\tint error = gurobi::GRBsetcharattrelement(m_model.get(), attr_name, row, value);\n\tcheck_error(error);\n\tm_update_flag |= m_attribute_update;\n}\n\nvoid GurobiModel::set_constraint_raw_attribute_double(const ConstraintIndex &constraint,\n const char *attr_name, double value)\n{\n\tint row = _checked_constraint_index(constraint);\n\tint error = gurobi::GRBsetdblattrelement(m_model.get(), attr_name, row, value);\n\tcheck_error(error);\n\tm_update_flag |= m_attribute_update;\n}\n\nvoid GurobiModel::set_constraint_raw_attribute_string(const ConstraintIndex &constraint,\n const char *attr_name, const char *value)\n{\n\tint row = _checked_constraint_index(constraint);\n\tint error = gurobi::GRBsetstrattrelement(m_model.get(), attr_name, row, value);\n\tcheck_error(error);\n\tm_update_flag |= m_attribute_update;\n}\n\nint GurobiModel::get_constraint_raw_attribute_int(const ConstraintIndex &constraint,\n const char *attr_name)\n{\n\t_update_for_information();\n\tint row = _checked_constraint_index(constraint);\n\tint retval;\n\tint error = gurobi::GRBgetintattrelement(m_model.get(), attr_name, row, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nchar GurobiModel::get_constraint_raw_attribute_char(const ConstraintIndex &constraint,\n const char *attr_name)\n{\n\t_update_for_information();\n\tint row = _checked_constraint_index(constraint);\n\tchar retval;\n\tint error = gurobi::GRBgetcharattrelement(m_model.get(), attr_name, row, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble GurobiModel::get_constraint_raw_attribute_double(const ConstraintIndex &constraint,\n const char *attr_name)\n{\n\t_update_for_information();\n\tint row = _checked_constraint_index(constraint);\n\tdouble retval;\n\tint error = gurobi::GRBgetdblattrelement(m_model.get(), attr_name, row, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nstd::string GurobiModel::get_constraint_raw_attribute_string(const ConstraintIndex &constraint,\n const char *attr_name)\n{\n\t_update_for_information();\n\tint row = _checked_constraint_index(constraint);\n\tchar *retval;\n\tint error = gurobi::GRBgetstrattrelement(m_model.get(), attr_name, row, &retval);\n\tcheck_error(error);\n\treturn std::string(retval);\n}\n\ndouble GurobiModel::get_normalized_rhs(const ConstraintIndex &constraint)\n{\n\tconst char *name;\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\t\tname = GRB_DBL_ATTR_RHS;\n\t\tbreak;\n\tcase ConstraintType::Quadratic:\n\t\tname = GRB_DBL_ATTR_QCRHS;\n\t\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type to get_normalized_rhs\");\n\t}\n\treturn get_constraint_raw_attribute_double(constraint, name);\n}\n\nvoid GurobiModel::set_normalized_rhs(const ConstraintIndex &constraint, double value)\n{\n\tconst char *name;\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\t\tname = GRB_DBL_ATTR_RHS;\n\t\tbreak;\n\tcase ConstraintType::Quadratic:\n\t\tname = GRB_DBL_ATTR_QCRHS;\n\t\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type to set_normalized_rhs\");\n\t}\n\tset_constraint_raw_attribute_double(constraint, name, value);\n}\n\ndouble GurobiModel::get_normalized_coefficient(const ConstraintIndex &constraint,\n const VariableIndex &variable)\n{\n\tif (constraint.type != ConstraintType::Linear)\n\t{\n\t\tthrow std::runtime_error(\"Only linear constraint supports get_normalized_coefficient\");\n\t}\n\t_update_for_information();\n\tint row = _checked_constraint_index(constraint);\n\tint col = _checked_variable_index(variable);\n\tdouble retval;\n\tint error = gurobi::GRBgetcoeff(m_model.get(), row, col, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nvoid GurobiModel::set_normalized_coefficient(const ConstraintIndex &constraint,\n const VariableIndex &variable, double value)\n{\n\tif (constraint.type != ConstraintType::Linear)\n\t{\n\t\tthrow std::runtime_error(\"Only linear constraint supports set_normalized_coefficient\");\n\t}\n\tint row = _checked_constraint_index(constraint);\n\tint col = _checked_variable_index(variable);\n\tint error = gurobi::GRBchgcoeffs(m_model.get(), 1, &row, &col, &value);\n\tcheck_error(error);\n\tm_update_flag |= m_constraint_coefficient_update;\n}\n\ndouble GurobiModel::get_objective_coefficient(const VariableIndex &variable)\n{\n\treturn get_variable_raw_attribute_double(variable, GRB_DBL_ATTR_OBJ);\n}\n\nvoid GurobiModel::set_objective_coefficient(const VariableIndex &variable, double value)\n{\n\tset_variable_raw_attribute_double(variable, GRB_DBL_ATTR_OBJ, value);\n}\n\nvoid GurobiModel::_converttofixed()\n{\n\tint error = gurobi::GRBconverttofixed(m_model.get());\n\tcheck_error(error);\n}\n\nvoid GurobiModel::computeIIS()\n{\n\tint error = gurobi::GRBcomputeIIS(m_model.get());\n\tcheck_error(error);\n}\n\nint GurobiModel::_constraint_index(const ConstraintIndex &constraint)\n{\n\t_update_for_constraint_index(constraint.type);\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\t\treturn m_linear_constraint_index.get_index(constraint.index);\n\tcase ConstraintType::Quadratic:\n\t\treturn m_quadratic_constraint_index.get_index(constraint.index);\n\tcase ConstraintType::SOS:\n\t\treturn m_sos_constraint_index.get_index(constraint.index);\n\tcase ConstraintType::NL:\n\t\treturn m_general_constraint_index.get_index(constraint.index);\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n}\n\nint GurobiModel::_checked_constraint_index(const ConstraintIndex &constraint)\n{\n\tint row = _constraint_index(constraint);\n\tif (row < 0)\n\t{\n\t\tthrow std::runtime_error(\"Variable does not exist\");\n\t}\n\treturn row;\n}\n\nvoid GurobiModel::check_error(int error)\n{\n\tif (error)\n\t{\n\t\tthrow std::runtime_error(gurobi::GRBgeterrormsg(m_env));\n\t}\n}\n\nvoid GurobiModel::_update_for_information()\n{\n\tif (m_update_flag)\n\t{\n\t\tupdate();\n\t}\n}\n\nvoid GurobiModel::_update_for_variable_index()\n{\n\tif (m_update_flag & m_variable_deletion)\n\t{\n\t\tupdate();\n\t}\n}\n\nvoid GurobiModel::_update_for_constraint_index(ConstraintType type)\n{\n\tbool need_update = false;\n\tswitch (type)\n\t{\n\tcase ConstraintType::Linear:\n\t\t// Adding new linear constraints does not need to update the model\n\t\tneed_update = m_update_flag & m_linear_constraint_deletion;\n\t\tbreak;\n\tcase ConstraintType::Quadratic:\n\t\tneed_update =\n\t\t m_update_flag & (m_quadratic_constraint_creation | m_quadratic_constraint_deletion);\n\t\tbreak;\n\tcase ConstraintType::SOS:\n\t\tneed_update = m_update_flag & (m_sos_constraint_creation | m_sos_constraint_deletion);\n\t\tbreak;\n\tcase ConstraintType::NL:\n\t\tneed_update =\n\t\t m_update_flag & (m_general_constraint_creation | m_general_constraint_deletion);\n\t\tbreak;\n\t}\n\tif (need_update)\n\t{\n\t\tupdate();\n\t}\n}\n\nvoid *GurobiModel::get_raw_model()\n{\n\treturn m_model.get();\n}\n\nstd::string GurobiModel::version_string()\n{\n\tint major, minor, techinical;\n\tgurobi::GRBversion(&major, &minor, &techinical);\n\tstd::string version = fmt::format(\"v{}.{}.{}\", major, minor, techinical);\n\treturn version;\n}\n\nGurobiEnv::GurobiEnv(bool empty)\n{\n\tif (!gurobi::is_library_loaded())\n\t{\n\t\tthrow std::runtime_error(\"Gurobi library is not loaded\");\n\t}\n\n\tint error = 0;\n\tif (empty)\n\t{\n\t\terror = gurobi::GRBemptyenv(&m_env);\n\t}\n\telse\n\t{\n\t\terror = gurobi::GRBloadenv(&m_env, NULL);\n\t}\n\tcheck_error(error);\n}\n\nGurobiEnv::~GurobiEnv()\n{\n\tclose();\n}\n\nint GurobiEnv::raw_parameter_type(const char *param_name)\n{\n\treturn gurobi::GRBgetparamtype(m_env, param_name);\n}\n\nvoid GurobiEnv::set_raw_parameter_int(const char *param_name, int value)\n{\n\tint error = gurobi::GRBsetintparam(m_env, param_name, value);\n\tcheck_error(error);\n}\n\nvoid GurobiEnv::set_raw_parameter_double(const char *param_name, double value)\n{\n\tint error = gurobi::GRBsetdblparam(m_env, param_name, value);\n\tcheck_error(error);\n}\n\nvoid GurobiEnv::set_raw_parameter_string(const char *param_name, const char *value)\n{\n\tint error = gurobi::GRBsetstrparam(m_env, param_name, value);\n\tcheck_error(error);\n}\n\nvoid GurobiEnv::start()\n{\n\tint error = gurobi::GRBstartenv(m_env);\n\tcheck_error(error);\n}\n\nvoid GurobiEnv::close()\n{\n\tif (m_env != nullptr)\n\t{\n\t\tgurobi::GRBfreeenv(m_env);\n\t}\n\tm_env = nullptr;\n}\n\nvoid GurobiEnv::check_error(int error)\n{\n\tif (error)\n\t{\n\t\tthrow std::runtime_error(gurobi::GRBgeterrormsg(m_env));\n\t}\n}\n\n// Logging callback\nstatic int RealLoggingCallbackFunction(char *msg, void *logdata)\n{\n\tauto real_logdata = static_cast(logdata);\n\tauto &callback = real_logdata->callback;\n\tcallback(msg);\n\treturn 0;\n}\n\nvoid GurobiModel::set_logging(const GurobiLoggingCallback &callback)\n{\n\tm_logging_callback_userdata.callback = callback;\n\tint error = gurobi::GRBsetlogcallbackfunc(m_model.get(), &RealLoggingCallbackFunction,\n\t &m_logging_callback_userdata);\n\tcheck_error(error);\n}\n\n// Callback\nstatic int RealGurobiCallbackFunction(GRBmodel *, void *cbdata, int where, void *usrdata)\n{\n\tauto real_userdata = static_cast(usrdata);\n\tauto model = static_cast(real_userdata->model);\n\tauto &callback = real_userdata->callback;\n\n\tmodel->m_cbdata = cbdata;\n\tmodel->m_callback_userdata.where = where;\n\tmodel->m_callback_userdata.cb_get_mipsol_called = false;\n\tmodel->m_callback_userdata.cb_get_mipnoderel_called = false;\n\tmodel->m_callback_userdata.cb_set_solution_called = false;\n\tmodel->m_callback_userdata.cb_requires_submit_solution = false;\n\tcallback(model, where);\n\n\tif (model->m_callback_userdata.cb_requires_submit_solution)\n\t{\n\t\tmodel->cb_submit_solution();\n\t}\n\n\treturn 0;\n}\n\nvoid GurobiModel::set_callback(const GurobiCallback &callback)\n{\n\tm_callback_userdata.model = this;\n\tm_callback_userdata.callback = callback;\n\n\tint error =\n\t gurobi::GRBsetcallbackfunc(m_model.get(), RealGurobiCallbackFunction, &m_callback_userdata);\n\tcheck_error(error);\n\n\thas_callback = true;\n}\n\nint GurobiModel::cb_get_info_int(int what)\n{\n\tint retval;\n\tint error = gurobi::GRBcbget(m_cbdata, m_callback_userdata.where, what, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble GurobiModel::cb_get_info_double(int what)\n{\n\tdouble retval;\n\tint error = gurobi::GRBcbget(m_cbdata, m_callback_userdata.where, what, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nvoid GurobiModel::cb_get_info_doublearray(int what)\n{\n\tint n_vars = m_callback_userdata.n_variables;\n\tdouble *val = nullptr;\n\tif (what == GRB_CB_MIPSOL_SOL)\n\t{\n\t\tm_callback_userdata.mipsol.resize(n_vars);\n\t\tval = m_callback_userdata.mipsol.data();\n\t}\n\telse if (what == GRB_CB_MIPNODE_REL)\n\t{\n\t\tm_callback_userdata.mipnoderel.resize(n_vars);\n\t\tval = m_callback_userdata.mipnoderel.data();\n\t}\n\telse\n\t{\n\t\tthrow std::runtime_error(\"Invalid what for cb_get_info_doublearray\");\n\t}\n\tint error = gurobi::GRBcbget(m_cbdata, m_callback_userdata.where, what, val);\n\tcheck_error(error);\n}\n\ndouble GurobiModel::cb_get_solution(const VariableIndex &variable)\n{\n\tauto &userdata = m_callback_userdata;\n\tif (!userdata.cb_get_mipsol_called)\n\t{\n\t\tcb_get_info_doublearray(GRB_CB_MIPSOL_SOL);\n\t\tuserdata.cb_get_mipsol_called = true;\n\t}\n\tauto index = _variable_index(variable);\n\treturn userdata.mipsol[index];\n}\n\ndouble GurobiModel::cb_get_relaxation(const VariableIndex &variable)\n{\n\tauto &userdata = m_callback_userdata;\n\tif (!userdata.cb_get_mipnoderel_called)\n\t{\n\t\tcb_get_info_doublearray(GRB_CB_MIPNODE_REL);\n\t\tuserdata.cb_get_mipnoderel_called = true;\n\t}\n\tauto index = _variable_index(variable);\n\treturn userdata.mipnoderel[index];\n}\n\nvoid GurobiModel::cb_set_solution(const VariableIndex &variable, double value)\n{\n\tauto &userdata = m_callback_userdata;\n\tif (!userdata.cb_set_solution_called)\n\t{\n\t\tuserdata.heuristic_solution.resize(userdata.n_variables, GRB_UNDEFINED);\n\t\tuserdata.cb_set_solution_called = true;\n\t}\n\tuserdata.heuristic_solution[_variable_index(variable)] = value;\n\tm_callback_userdata.cb_requires_submit_solution = true;\n}\n\ndouble GurobiModel::cb_submit_solution()\n{\n\tif (!m_callback_userdata.cb_set_solution_called)\n\t{\n\t\tthrow std::runtime_error(\"No solution is set in the callback!\");\n\t}\n\tdouble obj;\n\tint error =\n\t gurobi::GRBcbsolution(m_cbdata, m_callback_userdata.heuristic_solution.data(), &obj);\n\tcheck_error(error);\n\tm_callback_userdata.cb_requires_submit_solution = false;\n\treturn obj;\n}\n\nvoid GurobiModel::cb_add_lazy_constraint(const ScalarAffineFunction &function,\n ConstraintSense sense, CoeffT rhs)\n{\n\tAffineFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\n\tint numnz = ptr_form.numnz;\n\tint *cind = ptr_form.index;\n\tdouble *cval = ptr_form.value;\n\tchar g_sense = gurobi_con_sense(sense);\n\tdouble g_rhs = rhs - function.constant.value_or(0.0);\n\n\tint error = gurobi::GRBcblazy(m_cbdata, numnz, cind, cval, g_sense, g_rhs);\n\tcheck_error(error);\n}\n\nvoid GurobiModel::cb_exit()\n{\n\tgurobi::GRBterminate(m_model.get());\n}\n\nvoid GurobiModel::cb_add_lazy_constraint(const ExprBuilder &function, ConstraintSense sense,\n CoeffT rhs)\n{\n\tScalarAffineFunction f(function);\n\tcb_add_lazy_constraint(f, sense, rhs);\n}\n\nvoid GurobiModel::cb_add_user_cut(const ScalarAffineFunction &function, ConstraintSense sense,\n CoeffT rhs)\n{\n\tAffineFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\n\tint numnz = ptr_form.numnz;\n\tint *cind = ptr_form.index;\n\tdouble *cval = ptr_form.value;\n\tchar g_sense = gurobi_con_sense(sense);\n\tdouble g_rhs = rhs - function.constant.value_or(0.0);\n\n\tint error = gurobi::GRBcbcut(m_cbdata, numnz, cind, cval, g_sense, g_rhs);\n\tcheck_error(error);\n}\n\nvoid GurobiModel::cb_add_user_cut(const ExprBuilder &function, ConstraintSense sense, CoeffT rhs)\n{\n\tScalarAffineFunction f(function);\n\tcb_add_user_cut(f, sense, rhs);\n}\n" }, { "path": "lib/gurobi_model_ext.cpp", "content": "#include \n#include \n#include \n#include \n#include \n\n#include \"pyoptinterface/gurobi_model.hpp\"\n\nnamespace nb = nanobind;\n\nextern void bind_gurobi_constants(nb::module_ &m);\n\nNB_MODULE(gurobi_model_ext, m)\n{\n\tm.import_(\"pyoptinterface._src.core_ext\");\n\n\tm.def(\"is_library_loaded\", &gurobi::is_library_loaded);\n\tm.def(\"load_library\", &gurobi::load_library);\n\n\tbind_gurobi_constants(m);\n\n#define BIND_F(f) .def(#f, &GurobiEnv::f)\n\tnb::class_(m, \"RawEnv\")\n\t .def(nb::init(), nb::arg(\"empty\") = false)\n\t // clang-format off\n\t\tBIND_F(start)\n\t\tBIND_F(close)\n\t\tBIND_F(raw_parameter_type)\n\t\tBIND_F(set_raw_parameter_int)\n\t\tBIND_F(set_raw_parameter_double)\n\t\tBIND_F(set_raw_parameter_string)\n\t // clang-format on\n\t ;\n\n#undef BIND_F\n#define BIND_F(f) .def(#f, &GurobiModel::f)\n\tnb::class_(m, \"RawModel\")\n\t .def(nb::init<>())\n\t .def(nb::init())\n\t // clang-format off\n\t\tBIND_F(init)\n\t\tBIND_F(close)\n\t\tBIND_F(write)\n\t // clang-format on\n\t .def(\"_reset\", &GurobiModel::_reset, nb::arg(\"clearall\") = 0)\n\n\t .def(\"add_variable\", &GurobiModel::add_variable,\n\t nb::arg(\"domain\") = VariableDomain::Continuous, nb::arg(\"lb\") = -GRB_INFINITY,\n\t nb::arg(\"ub\") = GRB_INFINITY, nb::arg(\"name\") = \"\")\n\t // clang-format off\n\t\tBIND_F(delete_variable)\n\t\tBIND_F(delete_variables)\n\t\tBIND_F(is_variable_active)\n\t // clang-format on\n\t .def(\"set_variable_bounds\", &GurobiModel::set_variable_bounds, nb::arg(\"variable\"),\n\t nb::arg(\"lb\"), nb::arg(\"ub\"))\n\n\t .def(\"get_value\", &GurobiModel::get_variable_value)\n\t .def(\"get_value\",\n\t nb::overload_cast(&GurobiModel::get_expression_value))\n\t .def(\"get_value\",\n\t nb::overload_cast(&GurobiModel::get_expression_value))\n\t .def(\"get_value\",\n\t nb::overload_cast(&GurobiModel::get_expression_value))\n\n\t .def(\"pprint\", &GurobiModel::pprint_variable)\n\t .def(\"pprint\",\n\t nb::overload_cast(&GurobiModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\t .def(\"pprint\",\n\t nb::overload_cast(\n\t &GurobiModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\t .def(\"pprint\", nb::overload_cast(&GurobiModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\n\t // clang-format off\n\t\tBIND_F(set_variable_name)\n\t\tBIND_F(set_constraint_name)\n\t // clang-format on\n\n\t .def(\"_add_linear_constraint\", &GurobiModel::add_linear_constraint, nb::arg(\"expr\"),\n\t nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &GurobiModel::add_linear_constraint_from_var,\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &GurobiModel::add_linear_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_quadratic_constraint\", &GurobiModel::add_quadratic_constraint, nb::arg(\"expr\"),\n\t nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_quadratic_constraint\", &GurobiModel::add_quadratic_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"add_sos_constraint\", nb::overload_cast &, SOSType>(\n\t &GurobiModel::add_sos_constraint))\n\t .def(\"add_sos_constraint\",\n\t nb::overload_cast &, SOSType, const Vector &>(\n\t &GurobiModel::add_sos_constraint))\n\n\t .def(\"_add_single_nl_constraint\", &GurobiModel::add_single_nl_constraint, nb::arg(\"graph\"),\n\t nb::arg(\"result\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_single_nl_constraint\", &GurobiModel::add_single_nl_constraint_sense_rhs,\n\t nb::arg(\"graph\"), nb::arg(\"result\"), nb::arg(\"sense\"), nb::arg(\"rhs\"),\n\t nb::arg(\"name\") = \"\")\n\t .def(\"_add_single_nl_constraint\", &GurobiModel::add_single_nl_constraint_from_comparison,\n\t nb::arg(\"graph\"), nb::arg(\"expr\"), nb::arg(\"name\") = \"\")\n\n\t // clang-format off\n\t\tBIND_F(delete_constraint)\n\t\tBIND_F(is_constraint_active)\n\t // clang-format on\n\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &GurobiModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &GurobiModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(&GurobiModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &GurobiModel::set_objective_as_variable),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(&GurobiModel::set_objective_as_constant),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\n\t .def(\"_add_single_nl_objective\", &GurobiModel::add_single_nl_objective)\n\n\t .def(\"cb_add_lazy_constraint\",\n\t nb::overload_cast(\n\t &GurobiModel::cb_add_lazy_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"))\n\t .def(\"cb_add_lazy_constraint\",\n\t nb::overload_cast(\n\t &GurobiModel::cb_add_lazy_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"))\n\t .def(\"cb_add_user_cut\",\n\t nb::overload_cast(\n\t &GurobiModel::cb_add_user_cut),\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"))\n\t .def(\"cb_add_user_cut\",\n\t nb::overload_cast(\n\t &GurobiModel::cb_add_user_cut),\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"))\n\n\t .def(\"optimize\", &GurobiModel::optimize, nb::call_guard())\n\n\t // clang-format off\n\t\tBIND_F(update)\n\t\tBIND_F(version_string)\n\t\tBIND_F(get_raw_model)\n\n\t\tBIND_F(set_logging)\n\n\t\tBIND_F(set_callback)\n\t\tBIND_F(cb_get_info_int)\n\t\tBIND_F(cb_get_info_double)\n\t\tBIND_F(cb_get_solution)\n\t\tBIND_F(cb_get_relaxation)\n\t\tBIND_F(cb_set_solution)\n\t\tBIND_F(cb_submit_solution)\n\t\tBIND_F(cb_exit)\n\n\t\tBIND_F(raw_parameter_type)\n\t\tBIND_F(set_raw_parameter_int)\n\t\tBIND_F(set_raw_parameter_double)\n\t\tBIND_F(set_raw_parameter_string)\n\t\tBIND_F(get_raw_parameter_int)\n\t\tBIND_F(get_raw_parameter_double)\n\t\tBIND_F(get_raw_parameter_string)\n\n\t\tBIND_F(raw_attribute_type)\n\n\t\tBIND_F(set_model_raw_attribute_int)\n\t\tBIND_F(set_model_raw_attribute_double)\n\t\tBIND_F(set_model_raw_attribute_string)\n\t\tBIND_F(get_model_raw_attribute_int)\n\t\tBIND_F(get_model_raw_attribute_double)\n\t\tBIND_F(get_model_raw_attribute_string)\n\t\tBIND_F(get_model_raw_attribute_vector_double)\n\t\tBIND_F(get_model_raw_attribute_list_double)\n\n\t\tBIND_F(set_variable_raw_attribute_int)\n\t\tBIND_F(set_variable_raw_attribute_char)\n\t\tBIND_F(set_variable_raw_attribute_double)\n\t\tBIND_F(set_variable_raw_attribute_string)\n\t\tBIND_F(get_variable_raw_attribute_int)\n\t\tBIND_F(get_variable_raw_attribute_char)\n\t\tBIND_F(get_variable_raw_attribute_double)\n\t\tBIND_F(get_variable_raw_attribute_string)\n\n\t\tBIND_F(set_constraint_raw_attribute_int)\n\t\tBIND_F(set_constraint_raw_attribute_char)\n\t\tBIND_F(set_constraint_raw_attribute_double)\n\t\tBIND_F(set_constraint_raw_attribute_string)\n\t\tBIND_F(get_constraint_raw_attribute_int)\n\t\tBIND_F(get_constraint_raw_attribute_char)\n\t\tBIND_F(get_constraint_raw_attribute_double)\n\t\tBIND_F(get_constraint_raw_attribute_string)\n\n\t\tBIND_F(get_normalized_rhs)\n\t\tBIND_F(set_normalized_rhs)\n\t\tBIND_F(get_normalized_coefficient)\n\t\tBIND_F(set_normalized_coefficient)\n\t\tBIND_F(get_objective_coefficient)\n\t\tBIND_F(set_objective_coefficient)\n\n\t\tBIND_F(_converttofixed)\n\n\t\tBIND_F(computeIIS)\n\t // clang-format on\n\t ;\n}" }, { "path": "lib/gurobi_model_ext_constants.cpp", "content": "#include \n\nnamespace nb = nanobind;\n\nvoid bind_gurobi_constants(nb::module_ &m)\n{\n\tnb::module_ GRB = m.def_submodule(\"GRB\");\n\tGRB.attr(\"BARHOMOGENEOUS_AUTO\") = -1;\n\tGRB.attr(\"BARHOMOGENEOUS_OFF\") = 0;\n\tGRB.attr(\"BARHOMOGENEOUS_ON\") = 1;\n\tGRB.attr(\"BARORDER_AMD\") = 0;\n\tGRB.attr(\"BARORDER_AUTOMATIC\") = -1;\n\tGRB.attr(\"BARORDER_NESTEDDISSECTION\") = 1;\n\tGRB.attr(\"BASIC\") = 0;\n\tGRB.attr(\"BATCH_ABORTED\") = 3;\n\tGRB.attr(\"BATCH_COMPLETED\") = 5;\n\tGRB.attr(\"BATCH_CREATED\") = 1;\n\tGRB.attr(\"BATCH_FAILED\") = 4;\n\tGRB.attr(\"BATCH_SUBMITTED\") = 2;\n\tGRB.attr(\"BINARY\") = \"B\";\n\tGRB.attr(\"CONTINUOUS\") = \"C\";\n\tGRB.attr(\"CUTOFF\") = 6;\n\tGRB.attr(\"CUTS_AGGRESSIVE\") = 2;\n\tGRB.attr(\"CUTS_AUTO\") = -1;\n\tGRB.attr(\"CUTS_CONSERVATIVE\") = 1;\n\tGRB.attr(\"CUTS_OFF\") = 0;\n\tGRB.attr(\"CUTS_VERYAGGRESSIVE\") = 3;\n\tGRB.attr(\"DEFAULT_CS_PORT\") = 61000;\n\tGRB.attr(\"EQUAL\") = \"=\";\n\tGRB.attr(\"ERROR_CALLBACK\") = 10011;\n\tGRB.attr(\"ERROR_CLOUD\") = 10028;\n\tGRB.attr(\"ERROR_CSWORKER\") = 10030;\n\tGRB.attr(\"ERROR_DATA_NOT_AVAILABLE\") = 10005;\n\tGRB.attr(\"ERROR_DUPLICATES\") = 10018;\n\tGRB.attr(\"ERROR_EXCEED_2B_NONZEROS\") = 10025;\n\tGRB.attr(\"ERROR_FAILED_TO_CREATE_MODEL\") = 20002;\n\tGRB.attr(\"ERROR_FILE_READ\") = 10012;\n\tGRB.attr(\"ERROR_FILE_WRITE\") = 10013;\n\tGRB.attr(\"ERROR_IIS_NOT_INFEASIBLE\") = 10015;\n\tGRB.attr(\"ERROR_INDEX_OUT_OF_RANGE\") = 10006;\n\tGRB.attr(\"ERROR_INTERNAL\") = 20003;\n\tGRB.attr(\"ERROR_INVALID_ARGUMENT\") = 10003;\n\tGRB.attr(\"ERROR_INVALID_PIECEWISE_OBJ\") = 10026;\n\tGRB.attr(\"ERROR_JOB_REJECTED\") = 10023;\n\tGRB.attr(\"ERROR_MODEL_MODIFICATION\") = 10029;\n\tGRB.attr(\"ERROR_NETWORK\") = 10022;\n\tGRB.attr(\"ERROR_NODEFILE\") = 10019;\n\tGRB.attr(\"ERROR_NOT_FOR_MIP\") = 10016;\n\tGRB.attr(\"ERROR_NOT_IN_MODEL\") = 20001;\n\tGRB.attr(\"ERROR_NOT_SUPPORTED\") = 10024;\n\tGRB.attr(\"ERROR_NO_LICENSE\") = 10009;\n\tGRB.attr(\"ERROR_NULL_ARGUMENT\") = 10002;\n\tGRB.attr(\"ERROR_NUMERIC\") = 10014;\n\tGRB.attr(\"ERROR_OPTIMIZATION_IN_PROGRESS\") = 10017;\n\tGRB.attr(\"ERROR_OUT_OF_MEMORY\") = 10001;\n\tGRB.attr(\"ERROR_QCP_EQUALITY_CONSTRAINT\") = 10021;\n\tGRB.attr(\"ERROR_Q_NOT_PSD\") = 10020;\n\tGRB.attr(\"ERROR_SECURITY\") = 10032;\n\tGRB.attr(\"ERROR_SIZE_LIMIT_EXCEEDED\") = 10010;\n\tGRB.attr(\"ERROR_TUNE_MODEL_TYPES\") = 10031;\n\tGRB.attr(\"ERROR_UNKNOWN_ATTRIBUTE\") = 10004;\n\tGRB.attr(\"ERROR_UNKNOWN_PARAMETER\") = 10007;\n\tGRB.attr(\"ERROR_UPDATEMODE_CHANGE\") = 10027;\n\tGRB.attr(\"ERROR_VALUE_OUT_OF_RANGE\") = 10008;\n\tGRB.attr(\"FEASRELAX_CARDINALITY\") = 2;\n\tGRB.attr(\"FEASRELAX_LINEAR\") = 0;\n\tGRB.attr(\"FEASRELAX_QUADRATIC\") = 1;\n\tGRB.attr(\"GENCONSTR_ABS\") = 2;\n\tGRB.attr(\"GENCONSTR_AND\") = 3;\n\tGRB.attr(\"GENCONSTR_COS\") = 16;\n\tGRB.attr(\"GENCONSTR_EXP\") = 10;\n\tGRB.attr(\"GENCONSTR_EXPA\") = 11;\n\tGRB.attr(\"GENCONSTR_INDICATOR\") = 7;\n\tGRB.attr(\"GENCONSTR_LOG\") = 12;\n\tGRB.attr(\"GENCONSTR_LOGA\") = 13;\n\tGRB.attr(\"GENCONSTR_LOGISTIC\") = 18;\n\tGRB.attr(\"GENCONSTR_MAX\") = 0;\n\tGRB.attr(\"GENCONSTR_MIN\") = 1;\n\tGRB.attr(\"GENCONSTR_NL\") = 6;\n\tGRB.attr(\"GENCONSTR_NORM\") = 5;\n\tGRB.attr(\"GENCONSTR_OR\") = 4;\n\tGRB.attr(\"GENCONSTR_POLY\") = 9;\n\tGRB.attr(\"GENCONSTR_POW\") = 14;\n\tGRB.attr(\"GENCONSTR_PWL\") = 8;\n\tGRB.attr(\"GENCONSTR_SIN\") = 15;\n\tGRB.attr(\"GENCONSTR_TAN\") = 17;\n\tGRB.attr(\"GREATER_EQUAL\") = \">\";\n\tGRB.attr(\"INFEASIBLE\") = 3;\n\tGRB.attr(\"INFINITY\") = 1e+100;\n\tGRB.attr(\"INF_OR_UNBD\") = 4;\n\tGRB.attr(\"INPROGRESS\") = 14;\n\tGRB.attr(\"INTEGER\") = \"I\";\n\tGRB.attr(\"INTERRUPTED\") = 11;\n\tGRB.attr(\"ITERATION_LIMIT\") = 7;\n\tGRB.attr(\"LESS_EQUAL\") = \"<\";\n\tGRB.attr(\"LOADED\") = 1;\n\tGRB.attr(\"LOCALLY_INFEASIBLE\") = 19;\n\tGRB.attr(\"LOCALLY_OPTIMAL\") = 18;\n\tGRB.attr(\"MAXIMIZE\") = -1;\n\tGRB.attr(\"MAXINT\") = 2000000000;\n\tGRB.attr(\"MAX_CONCURRENT\") = 64;\n\tGRB.attr(\"MAX_NAMELEN\") = 255;\n\tGRB.attr(\"MAX_STRLEN\") = 512;\n\tGRB.attr(\"MAX_TAGLEN\") = 10240;\n\tGRB.attr(\"MEM_LIMIT\") = 17;\n\tGRB.attr(\"METHOD_AUTO\") = -1;\n\tGRB.attr(\"METHOD_BARRIER\") = 2;\n\tGRB.attr(\"METHOD_CONCURRENT\") = 3;\n\tGRB.attr(\"METHOD_DETERMINISTIC_CONCURRENT\") = 4;\n\tGRB.attr(\"METHOD_DETERMINISTIC_CONCURRENT_SIMPLEX\") = 5;\n\tGRB.attr(\"METHOD_DUAL\") = 1;\n\tGRB.attr(\"METHOD_NONE\") = -1;\n\tGRB.attr(\"METHOD_PDHG\") = 6;\n\tGRB.attr(\"METHOD_PRIMAL\") = 0;\n\tGRB.attr(\"MINIMIZE\") = 1;\n\tGRB.attr(\"MIPFOCUS_BALANCED\") = 0;\n\tGRB.attr(\"MIPFOCUS_BESTBOUND\") = 3;\n\tGRB.attr(\"MIPFOCUS_FEASIBILITY\") = 1;\n\tGRB.attr(\"MIPFOCUS_OPTIMALITY\") = 2;\n\tGRB.attr(\"NODE_LIMIT\") = 8;\n\tGRB.attr(\"NONBASIC_LOWER\") = -1;\n\tGRB.attr(\"NONBASIC_UPPER\") = -2;\n\tGRB.attr(\"NUMERIC\") = 12;\n\tGRB.attr(\"OPCODE_CONSTANT\") = 0;\n\tGRB.attr(\"OPCODE_COS\") = 10;\n\tGRB.attr(\"OPCODE_DIVIDE\") = 5;\n\tGRB.attr(\"OPCODE_EXP\") = 13;\n\tGRB.attr(\"OPCODE_LOG\") = 14;\n\tGRB.attr(\"OPCODE_LOG10\") = 16;\n\tGRB.attr(\"OPCODE_LOG2\") = 15;\n\tGRB.attr(\"OPCODE_LOGISTIC\") = 17;\n\tGRB.attr(\"OPCODE_MINUS\") = 3;\n\tGRB.attr(\"OPCODE_MULTIPLY\") = 4;\n\tGRB.attr(\"OPCODE_PLUS\") = 2;\n\tGRB.attr(\"OPCODE_POW\") = 12;\n\tGRB.attr(\"OPCODE_SIGNPOW\") = 19;\n\tGRB.attr(\"OPCODE_SIN\") = 9;\n\tGRB.attr(\"OPCODE_SQRT\") = 8;\n\tGRB.attr(\"OPCODE_SQUARE\") = 7;\n\tGRB.attr(\"OPCODE_TAN\") = 11;\n\tGRB.attr(\"OPCODE_TANH\") = 18;\n\tGRB.attr(\"OPCODE_UMINUS\") = 6;\n\tGRB.attr(\"OPCODE_VARIABLE\") = 1;\n\tGRB.attr(\"OPTIMAL\") = 2;\n\tGRB.attr(\"PARTITION_CLEANUP\") = 1;\n\tGRB.attr(\"PARTITION_EARLY\") = 16;\n\tGRB.attr(\"PARTITION_NODES\") = 2;\n\tGRB.attr(\"PARTITION_ROOTEND\") = 4;\n\tGRB.attr(\"PARTITION_ROOTSTART\") = 8;\n\tGRB.attr(\"PHASE_MIP_IMPROVE\") = 2;\n\tGRB.attr(\"PHASE_MIP_NOREL\") = 0;\n\tGRB.attr(\"PHASE_MIP_SEARCH\") = 1;\n\tGRB.attr(\"PRESOLVE_AGGRESSIVE\") = 2;\n\tGRB.attr(\"PRESOLVE_AUTO\") = -1;\n\tGRB.attr(\"PRESOLVE_CONSERVATIVE\") = 1;\n\tGRB.attr(\"PRESOLVE_OFF\") = 0;\n\tGRB.attr(\"SEMICONT\") = \"S\";\n\tGRB.attr(\"SEMIINT\") = \"N\";\n\tGRB.attr(\"SIMPLEXPRICING_AUTO\") = -1;\n\tGRB.attr(\"SIMPLEXPRICING_DEVEX\") = 2;\n\tGRB.attr(\"SIMPLEXPRICING_PARTIAL\") = 0;\n\tGRB.attr(\"SIMPLEXPRICING_STEEPEST_EDGE\") = 1;\n\tGRB.attr(\"SIMPLEXPRICING_STEEPEST_QUICK\") = 3;\n\tGRB.attr(\"SOLUTION_LIMIT\") = 10;\n\tGRB.attr(\"SOS_TYPE1\") = 1;\n\tGRB.attr(\"SOS_TYPE2\") = 2;\n\tGRB.attr(\"SUBOPTIMAL\") = 13;\n\tGRB.attr(\"SUPERBASIC\") = -3;\n\tGRB.attr(\"TIME_LIMIT\") = 9;\n\tGRB.attr(\"UNBOUNDED\") = 5;\n\tGRB.attr(\"UNDEFINED\") = 1e+101;\n\tGRB.attr(\"USER_OBJ_LIMIT\") = 15;\n\tGRB.attr(\"VARBRANCH_AUTO\") = -1;\n\tGRB.attr(\"VARBRANCH_MAX_INFEAS\") = 2;\n\tGRB.attr(\"VARBRANCH_PSEUDO_REDUCED\") = 0;\n\tGRB.attr(\"VARBRANCH_PSEUDO_SHADOW\") = 1;\n\tGRB.attr(\"VARBRANCH_STRONG\") = 3;\n\tGRB.attr(\"VERSION_MAJOR\") = 13;\n\tGRB.attr(\"VERSION_MINOR\") = 0;\n\tGRB.attr(\"VERSION_TECHNICAL\") = 0;\n\tGRB.attr(\"WORK_LIMIT\") = 16;\n\n\tnb::module_ Attr = GRB.def_submodule(\"Attr\");\n\tAttr.attr(\"BarIterCount\") = \"BarIterCount\";\n\tAttr.attr(\"BarPi\") = \"BarPi\";\n\tAttr.attr(\"BarStatus\") = \"BarStatus\";\n\tAttr.attr(\"BarX\") = \"BarX\";\n\tAttr.attr(\"BatchErrorCode\") = \"BatchErrorCode\";\n\tAttr.attr(\"BatchErrorMessage\") = \"BatchErrorMessage\";\n\tAttr.attr(\"BatchID\") = \"BatchID\";\n\tAttr.attr(\"BatchStatus\") = \"BatchStatus\";\n\tAttr.attr(\"BoundSVio\") = \"BoundSVio\";\n\tAttr.attr(\"BoundSVioIndex\") = \"BoundSVioIndex\";\n\tAttr.attr(\"BoundSVioSum\") = \"BoundSVioSum\";\n\tAttr.attr(\"BoundVio\") = \"BoundVio\";\n\tAttr.attr(\"BoundVioIndex\") = \"BoundVioIndex\";\n\tAttr.attr(\"BoundVioSum\") = \"BoundVioSum\";\n\tAttr.attr(\"BranchPriority\") = \"BranchPriority\";\n\tAttr.attr(\"CBasis\") = \"CBasis\";\n\tAttr.attr(\"CTag\") = \"CTag\";\n\tAttr.attr(\"ComplVio\") = \"ComplVio\";\n\tAttr.attr(\"ComplVioIndex\") = \"ComplVioIndex\";\n\tAttr.attr(\"ComplVioSum\") = \"ComplVioSum\";\n\tAttr.attr(\"ConcurrentWinMethod\") = \"ConcurrentWinMethod\";\n\tAttr.attr(\"ConstrName\") = \"ConstrName\";\n\tAttr.attr(\"ConstrResidual\") = \"ConstrResidual\";\n\tAttr.attr(\"ConstrResidualIndex\") = \"ConstrResidualIndex\";\n\tAttr.attr(\"ConstrResidualSum\") = \"ConstrResidualSum\";\n\tAttr.attr(\"ConstrSResidual\") = \"ConstrSResidual\";\n\tAttr.attr(\"ConstrSResidualIndex\") = \"ConstrSResidualIndex\";\n\tAttr.attr(\"ConstrSResidualSum\") = \"ConstrSResidualSum\";\n\tAttr.attr(\"ConstrSVio\") = \"ConstrSVio\";\n\tAttr.attr(\"ConstrSVioIndex\") = \"ConstrSVioIndex\";\n\tAttr.attr(\"ConstrSVioSum\") = \"ConstrSVioSum\";\n\tAttr.attr(\"ConstrVio\") = \"ConstrVio\";\n\tAttr.attr(\"ConstrVioIndex\") = \"ConstrVioIndex\";\n\tAttr.attr(\"ConstrVioSum\") = \"ConstrVioSum\";\n\tAttr.attr(\"DNumNZs\") = \"DNumNZs\";\n\tAttr.attr(\"DStart\") = \"DStart\";\n\tAttr.attr(\"DualResidual\") = \"DualResidual\";\n\tAttr.attr(\"DualResidualIndex\") = \"DualResidualIndex\";\n\tAttr.attr(\"DualResidualSum\") = \"DualResidualSum\";\n\tAttr.attr(\"DualSResidual\") = \"DualSResidual\";\n\tAttr.attr(\"DualSResidualIndex\") = \"DualSResidualIndex\";\n\tAttr.attr(\"DualSResidualSum\") = \"DualSResidualSum\";\n\tAttr.attr(\"DualSVio\") = \"DualSVio\";\n\tAttr.attr(\"DualSVioIndex\") = \"DualSVioIndex\";\n\tAttr.attr(\"DualSVioSum\") = \"DualSVioSum\";\n\tAttr.attr(\"DualVio\") = \"DualVio\";\n\tAttr.attr(\"DualVioIndex\") = \"DualVioIndex\";\n\tAttr.attr(\"DualVioSum\") = \"DualVioSum\";\n\tAttr.attr(\"FarkasDual\") = \"FarkasDual\";\n\tAttr.attr(\"FarkasProof\") = \"FarkasProof\";\n\tAttr.attr(\"Fingerprint\") = \"Fingerprint\";\n\tAttr.attr(\"FuncNonlinear\") = \"FuncNonlinear\";\n\tAttr.attr(\"FuncPieceError\") = \"FuncPieceError\";\n\tAttr.attr(\"FuncPieceLength\") = \"FuncPieceLength\";\n\tAttr.attr(\"FuncPieceRatio\") = \"FuncPieceRatio\";\n\tAttr.attr(\"FuncPieces\") = \"FuncPieces\";\n\tAttr.attr(\"GenConstrName\") = \"GenConstrName\";\n\tAttr.attr(\"GenConstrType\") = \"GenConstrType\";\n\tAttr.attr(\"IISConstr\") = \"IISConstr\";\n\tAttr.attr(\"IISConstrForce\") = \"IISConstrForce\";\n\tAttr.attr(\"IISGenConstr\") = \"IISGenConstr\";\n\tAttr.attr(\"IISGenConstrForce\") = \"IISGenConstrForce\";\n\tAttr.attr(\"IISLB\") = \"IISLB\";\n\tAttr.attr(\"IISLBForce\") = \"IISLBForce\";\n\tAttr.attr(\"IISMinimal\") = \"IISMinimal\";\n\tAttr.attr(\"IISQConstr\") = \"IISQConstr\";\n\tAttr.attr(\"IISQConstrForce\") = \"IISQConstrForce\";\n\tAttr.attr(\"IISSOS\") = \"IISSOS\";\n\tAttr.attr(\"IISSOSForce\") = \"IISSOSForce\";\n\tAttr.attr(\"IISUB\") = \"IISUB\";\n\tAttr.attr(\"IISUBForce\") = \"IISUBForce\";\n\tAttr.attr(\"IntVio\") = \"IntVio\";\n\tAttr.attr(\"IntVioIndex\") = \"IntVioIndex\";\n\tAttr.attr(\"IntVioSum\") = \"IntVioSum\";\n\tAttr.attr(\"IsMIP\") = \"IsMIP\";\n\tAttr.attr(\"IsMultiObj\") = \"IsMultiObj\";\n\tAttr.attr(\"IsQCP\") = \"IsQCP\";\n\tAttr.attr(\"IsQP\") = \"IsQP\";\n\tAttr.attr(\"IterCount\") = \"IterCount\";\n\tAttr.attr(\"Kappa\") = \"Kappa\";\n\tAttr.attr(\"KappaExact\") = \"KappaExact\";\n\tAttr.attr(\"LB\") = \"LB\";\n\tAttr.attr(\"Lazy\") = \"Lazy\";\n\tAttr.attr(\"LicenseExpiration\") = \"LicenseExpiration\";\n\tAttr.attr(\"MIPGap\") = \"MIPGap\";\n\tAttr.attr(\"MaxBound\") = \"MaxBound\";\n\tAttr.attr(\"MaxCoeff\") = \"MaxCoeff\";\n\tAttr.attr(\"MaxMemUsed\") = \"MaxMemUsed\";\n\tAttr.attr(\"MaxObjCoeff\") = \"MaxObjCoeff\";\n\tAttr.attr(\"MaxQCCoeff\") = \"MaxQCCoeff\";\n\tAttr.attr(\"MaxQCLCoeff\") = \"MaxQCLCoeff\";\n\tAttr.attr(\"MaxQCRHS\") = \"MaxQCRHS\";\n\tAttr.attr(\"MaxQObjCoeff\") = \"MaxQObjCoeff\";\n\tAttr.attr(\"MaxRHS\") = \"MaxRHS\";\n\tAttr.attr(\"MaxVio\") = \"MaxVio\";\n\tAttr.attr(\"MemUsed\") = \"MemUsed\";\n\tAttr.attr(\"MinBound\") = \"MinBound\";\n\tAttr.attr(\"MinCoeff\") = \"MinCoeff\";\n\tAttr.attr(\"MinObjCoeff\") = \"MinObjCoeff\";\n\tAttr.attr(\"MinQCCoeff\") = \"MinQCCoeff\";\n\tAttr.attr(\"MinQCLCoeff\") = \"MinQCLCoeff\";\n\tAttr.attr(\"MinQCRHS\") = \"MinQCRHS\";\n\tAttr.attr(\"MinQObjCoeff\") = \"MinQObjCoeff\";\n\tAttr.attr(\"MinRHS\") = \"MinRHS\";\n\tAttr.attr(\"ModelName\") = \"ModelName\";\n\tAttr.attr(\"ModelSense\") = \"ModelSense\";\n\tAttr.attr(\"NLBarIterCount\") = \"NLBarIterCount\";\n\tAttr.attr(\"NodeCount\") = \"NodeCount\";\n\tAttr.attr(\"NumBinVars\") = \"NumBinVars\";\n\tAttr.attr(\"NumConstrs\") = \"NumConstrs\";\n\tAttr.attr(\"NumGenConstrs\") = \"NumGenConstrs\";\n\tAttr.attr(\"NumIntVars\") = \"NumIntVars\";\n\tAttr.attr(\"NumNZs\") = \"NumNZs\";\n\tAttr.attr(\"NumObj\") = \"NumObj\";\n\tAttr.attr(\"NumObjPasses\") = \"NumObjPasses\";\n\tAttr.attr(\"NumPWLObjVars\") = \"NumPWLObjVars\";\n\tAttr.attr(\"NumQCNZs\") = \"NumQCNZs\";\n\tAttr.attr(\"NumQConstrs\") = \"NumQConstrs\";\n\tAttr.attr(\"NumQNZs\") = \"NumQNZs\";\n\tAttr.attr(\"NumSOS\") = \"NumSOS\";\n\tAttr.attr(\"NumScenarios\") = \"NumScenarios\";\n\tAttr.attr(\"NumStart\") = \"NumStart\";\n\tAttr.attr(\"NumVars\") = \"NumVars\";\n\tAttr.attr(\"Obj\") = \"Obj\";\n\tAttr.attr(\"ObjBound\") = \"ObjBound\";\n\tAttr.attr(\"ObjBoundC\") = \"ObjBoundC\";\n\tAttr.attr(\"ObjCon\") = \"ObjCon\";\n\tAttr.attr(\"ObjN\") = \"ObjN\";\n\tAttr.attr(\"ObjNAbsTol\") = \"ObjNAbsTol\";\n\tAttr.attr(\"ObjNCon\") = \"ObjNCon\";\n\tAttr.attr(\"ObjNName\") = \"ObjNName\";\n\tAttr.attr(\"ObjNPass\") = \"ObjNPass\";\n\tAttr.attr(\"ObjNPriority\") = \"ObjNPriority\";\n\tAttr.attr(\"ObjNRelTol\") = \"ObjNRelTol\";\n\tAttr.attr(\"ObjNVal\") = \"ObjNVal\";\n\tAttr.attr(\"ObjNWeight\") = \"ObjNWeight\";\n\tAttr.attr(\"ObjPassNIterCount\") = \"ObjPassNIterCount\";\n\tAttr.attr(\"ObjPassNMIPGap\") = \"ObjPassNMIPGap\";\n\tAttr.attr(\"ObjPassNNodeCount\") = \"ObjPassNNodeCount\";\n\tAttr.attr(\"ObjPassNObjBound\") = \"ObjPassNObjBound\";\n\tAttr.attr(\"ObjPassNObjVal\") = \"ObjPassNObjVal\";\n\tAttr.attr(\"ObjPassNOpenNodeCount\") = \"ObjPassNOpenNodeCount\";\n\tAttr.attr(\"ObjPassNRuntime\") = \"ObjPassNRuntime\";\n\tAttr.attr(\"ObjPassNStatus\") = \"ObjPassNStatus\";\n\tAttr.attr(\"ObjPassNWork\") = \"ObjPassNWork\";\n\tAttr.attr(\"ObjVal\") = \"ObjVal\";\n\tAttr.attr(\"PDHGIterCount\") = \"PDHGIterCount\";\n\tAttr.attr(\"PStart\") = \"PStart\";\n\tAttr.attr(\"PWLObjCvx\") = \"PWLObjCvx\";\n\tAttr.attr(\"Partition\") = \"Partition\";\n\tAttr.attr(\"Pi\") = \"Pi\";\n\tAttr.attr(\"PoolIgnore\") = \"PoolIgnore\";\n\tAttr.attr(\"PoolNBoundVio\") = \"PoolNBoundVio\";\n\tAttr.attr(\"PoolNBoundVioIndex\") = \"PoolNBoundVioIndex\";\n\tAttr.attr(\"PoolNBoundVioSum\") = \"PoolNBoundVioSum\";\n\tAttr.attr(\"PoolNConstrVio\") = \"PoolNConstrVio\";\n\tAttr.attr(\"PoolNConstrVioIndex\") = \"PoolNConstrVioIndex\";\n\tAttr.attr(\"PoolNConstrVioSum\") = \"PoolNConstrVioSum\";\n\tAttr.attr(\"PoolNIntVio\") = \"PoolNIntVio\";\n\tAttr.attr(\"PoolNIntVioIndex\") = \"PoolNIntVioIndex\";\n\tAttr.attr(\"PoolNIntVioSum\") = \"PoolNIntVioSum\";\n\tAttr.attr(\"PoolNMaxVio\") = \"PoolNMaxVio\";\n\tAttr.attr(\"PoolNObjVal\") = \"PoolNObjVal\";\n\tAttr.attr(\"PoolNX\") = \"PoolNX\";\n\tAttr.attr(\"PoolObjBound\") = \"PoolObjBound\";\n\tAttr.attr(\"PoolObjVal\") = \"PoolObjVal\";\n\tAttr.attr(\"PreFixVal\") = \"PreFixVal\";\n\tAttr.attr(\"QCName\") = \"QCName\";\n\tAttr.attr(\"QCPi\") = \"QCPi\";\n\tAttr.attr(\"QCRHS\") = \"QCRHS\";\n\tAttr.attr(\"QCSense\") = \"QCSense\";\n\tAttr.attr(\"QCSlack\") = \"QCSlack\";\n\tAttr.attr(\"QCTag\") = \"QCTag\";\n\tAttr.attr(\"RC\") = \"RC\";\n\tAttr.attr(\"RHS\") = \"RHS\";\n\tAttr.attr(\"Runtime\") = \"Runtime\";\n\tAttr.attr(\"SALBLow\") = \"SALBLow\";\n\tAttr.attr(\"SALBUp\") = \"SALBUp\";\n\tAttr.attr(\"SAObjLow\") = \"SAObjLow\";\n\tAttr.attr(\"SAObjUp\") = \"SAObjUp\";\n\tAttr.attr(\"SARHSLow\") = \"SARHSLow\";\n\tAttr.attr(\"SARHSUp\") = \"SARHSUp\";\n\tAttr.attr(\"SAUBLow\") = \"SAUBLow\";\n\tAttr.attr(\"SAUBUp\") = \"SAUBUp\";\n\tAttr.attr(\"ScenNLB\") = \"ScenNLB\";\n\tAttr.attr(\"ScenNName\") = \"ScenNName\";\n\tAttr.attr(\"ScenNObj\") = \"ScenNObj\";\n\tAttr.attr(\"ScenNObjBound\") = \"ScenNObjBound\";\n\tAttr.attr(\"ScenNObjVal\") = \"ScenNObjVal\";\n\tAttr.attr(\"ScenNRHS\") = \"ScenNRHS\";\n\tAttr.attr(\"ScenNUB\") = \"ScenNUB\";\n\tAttr.attr(\"ScenNX\") = \"ScenNX\";\n\tAttr.attr(\"Sense\") = \"Sense\";\n\tAttr.attr(\"Slack\") = \"Slack\";\n\tAttr.attr(\"SolCount\") = \"SolCount\";\n\tAttr.attr(\"Start\") = \"Start\";\n\tAttr.attr(\"Status\") = \"Status\";\n\tAttr.attr(\"TuneResultCount\") = \"TuneResultCount\";\n\tAttr.attr(\"UB\") = \"UB\";\n\tAttr.attr(\"UnbdRay\") = \"UnbdRay\";\n\tAttr.attr(\"VBasis\") = \"VBasis\";\n\tAttr.attr(\"VTag\") = \"VTag\";\n\tAttr.attr(\"VType\") = \"VType\";\n\tAttr.attr(\"VarHintPri\") = \"VarHintPri\";\n\tAttr.attr(\"VarHintVal\") = \"VarHintVal\";\n\tAttr.attr(\"VarName\") = \"VarName\";\n\tAttr.attr(\"VarPreStat\") = \"VarPreStat\";\n\tAttr.attr(\"Work\") = \"Work\";\n\tAttr.attr(\"X\") = \"X\";\n\tAttr.attr(\"Xn\") = \"Xn\";\n\n\tnb::module_ Param = GRB.def_submodule(\"Param\");\n\tParam.attr(\"AggFill\") = \"AggFill\";\n\tParam.attr(\"Aggregate\") = \"Aggregate\";\n\tParam.attr(\"BQPCuts\") = \"BQPCuts\";\n\tParam.attr(\"BarConvTol\") = \"BarConvTol\";\n\tParam.attr(\"BarCorrectors\") = \"BarCorrectors\";\n\tParam.attr(\"BarHomogeneous\") = \"BarHomogeneous\";\n\tParam.attr(\"BarIterLimit\") = \"BarIterLimit\";\n\tParam.attr(\"BarOrder\") = \"BarOrder\";\n\tParam.attr(\"BarQCPConvTol\") = \"BarQCPConvTol\";\n\tParam.attr(\"BestBdStop\") = \"BestBdStop\";\n\tParam.attr(\"BestObjStop\") = \"BestObjStop\";\n\tParam.attr(\"BranchDir\") = \"BranchDir\";\n\tParam.attr(\"CSAPIAccessID\") = \"CSAPIAccessID\";\n\tParam.attr(\"CSAPISecret\") = \"CSAPISecret\";\n\tParam.attr(\"CSAppName\") = \"CSAppName\";\n\tParam.attr(\"CSAuthToken\") = \"CSAuthToken\";\n\tParam.attr(\"CSBatchMode\") = \"CSBatchMode\";\n\tParam.attr(\"CSClientLog\") = \"CSClientLog\";\n\tParam.attr(\"CSGroup\") = \"CSGroup\";\n\tParam.attr(\"CSIdleTimeout\") = \"CSIdleTimeout\";\n\tParam.attr(\"CSManager\") = \"CSManager\";\n\tParam.attr(\"CSPriority\") = \"CSPriority\";\n\tParam.attr(\"CSQueueTimeout\") = \"CSQueueTimeout\";\n\tParam.attr(\"CSRouter\") = \"CSRouter\";\n\tParam.attr(\"CSTLSInsecure\") = \"CSTLSInsecure\";\n\tParam.attr(\"CliqueCuts\") = \"CliqueCuts\";\n\tParam.attr(\"CloudAccessID\") = \"CloudAccessID\";\n\tParam.attr(\"CloudHost\") = \"CloudHost\";\n\tParam.attr(\"CloudPool\") = \"CloudPool\";\n\tParam.attr(\"CloudSecretKey\") = \"CloudSecretKey\";\n\tParam.attr(\"ComputeServer\") = \"ComputeServer\";\n\tParam.attr(\"ConcurrentJobs\") = \"ConcurrentJobs\";\n\tParam.attr(\"ConcurrentMIP\") = \"ConcurrentMIP\";\n\tParam.attr(\"ConcurrentMethod\") = \"ConcurrentMethod\";\n\tParam.attr(\"CoverCuts\") = \"CoverCuts\";\n\tParam.attr(\"Crossover\") = \"Crossover\";\n\tParam.attr(\"CrossoverBasis\") = \"CrossoverBasis\";\n\tParam.attr(\"CutAggPasses\") = \"CutAggPasses\";\n\tParam.attr(\"CutPasses\") = \"CutPasses\";\n\tParam.attr(\"Cutoff\") = \"Cutoff\";\n\tParam.attr(\"Cuts\") = \"Cuts\";\n\tParam.attr(\"DegenMoves\") = \"DegenMoves\";\n\tParam.attr(\"Disconnected\") = \"Disconnected\";\n\tParam.attr(\"DisplayInterval\") = \"DisplayInterval\";\n\tParam.attr(\"DistributedMIPJobs\") = \"DistributedMIPJobs\";\n\tParam.attr(\"DualImpliedCuts\") = \"DualImpliedCuts\";\n\tParam.attr(\"DualReductions\") = \"DualReductions\";\n\tParam.attr(\"FeasRelaxBigM\") = \"FeasRelaxBigM\";\n\tParam.attr(\"FeasibilityTol\") = \"FeasibilityTol\";\n\tParam.attr(\"FixVarsInIndicators\") = \"FixVarsInIndicators\";\n\tParam.attr(\"FlowCoverCuts\") = \"FlowCoverCuts\";\n\tParam.attr(\"FlowPathCuts\") = \"FlowPathCuts\";\n\tParam.attr(\"FuncMaxVal\") = \"FuncMaxVal\";\n\tParam.attr(\"FuncNonlinear\") = \"FuncNonlinear\";\n\tParam.attr(\"FuncPieceError\") = \"FuncPieceError\";\n\tParam.attr(\"FuncPieceLength\") = \"FuncPieceLength\";\n\tParam.attr(\"FuncPieceRatio\") = \"FuncPieceRatio\";\n\tParam.attr(\"FuncPieces\") = \"FuncPieces\";\n\tParam.attr(\"GUBCoverCuts\") = \"GUBCoverCuts\";\n\tParam.attr(\"GomoryPasses\") = \"GomoryPasses\";\n\tParam.attr(\"Heuristics\") = \"Heuristics\";\n\tParam.attr(\"IISMethod\") = \"IISMethod\";\n\tParam.attr(\"IgnoreNames\") = \"IgnoreNames\";\n\tParam.attr(\"ImpliedCuts\") = \"ImpliedCuts\";\n\tParam.attr(\"ImproveStartGap\") = \"ImproveStartGap\";\n\tParam.attr(\"ImproveStartNodes\") = \"ImproveStartNodes\";\n\tParam.attr(\"ImproveStartTime\") = \"ImproveStartTime\";\n\tParam.attr(\"ImproveStartWork\") = \"ImproveStartWork\";\n\tParam.attr(\"InfProofCuts\") = \"InfProofCuts\";\n\tParam.attr(\"InfUnbdInfo\") = \"InfUnbdInfo\";\n\tParam.attr(\"InheritParams\") = \"InheritParams\";\n\tParam.attr(\"IntFeasTol\") = \"IntFeasTol\";\n\tParam.attr(\"IntegralityFocus\") = \"IntegralityFocus\";\n\tParam.attr(\"IterationLimit\") = \"IterationLimit\";\n\tParam.attr(\"JSONSolDetail\") = \"JSONSolDetail\";\n\tParam.attr(\"JobID\") = \"JobID\";\n\tParam.attr(\"LPWarmStart\") = \"LPWarmStart\";\n\tParam.attr(\"LazyConstraints\") = \"LazyConstraints\";\n\tParam.attr(\"LicenseID\") = \"LicenseID\";\n\tParam.attr(\"LiftProjectCuts\") = \"LiftProjectCuts\";\n\tParam.attr(\"LogFile\") = \"LogFile\";\n\tParam.attr(\"LogToConsole\") = \"LogToConsole\";\n\tParam.attr(\"MIPFocus\") = \"MIPFocus\";\n\tParam.attr(\"MIPGap\") = \"MIPGap\";\n\tParam.attr(\"MIPGapAbs\") = \"MIPGapAbs\";\n\tParam.attr(\"MIPSepCuts\") = \"MIPSepCuts\";\n\tParam.attr(\"MIQCPMethod\") = \"MIQCPMethod\";\n\tParam.attr(\"MIRCuts\") = \"MIRCuts\";\n\tParam.attr(\"MarkowitzTol\") = \"MarkowitzTol\";\n\tParam.attr(\"MasterKnapsackCuts\") = \"MasterKnapsackCuts\";\n\tParam.attr(\"MemLimit\") = \"MemLimit\";\n\tParam.attr(\"Method\") = \"Method\";\n\tParam.attr(\"MinRelNodes\") = \"MinRelNodes\";\n\tParam.attr(\"MixingCuts\") = \"MixingCuts\";\n\tParam.attr(\"ModKCuts\") = \"ModKCuts\";\n\tParam.attr(\"MultiObjMethod\") = \"MultiObjMethod\";\n\tParam.attr(\"MultiObjPre\") = \"MultiObjPre\";\n\tParam.attr(\"NLBarCFeasTol\") = \"NLBarCFeasTol\";\n\tParam.attr(\"NLBarDFeasTol\") = \"NLBarDFeasTol\";\n\tParam.attr(\"NLBarIterLimit\") = \"NLBarIterLimit\";\n\tParam.attr(\"NLBarPFeasTol\") = \"NLBarPFeasTol\";\n\tParam.attr(\"NLPHeur\") = \"NLPHeur\";\n\tParam.attr(\"NetworkAlg\") = \"NetworkAlg\";\n\tParam.attr(\"NetworkCuts\") = \"NetworkCuts\";\n\tParam.attr(\"NoRelHeurSolutions\") = \"NoRelHeurSolutions\";\n\tParam.attr(\"NoRelHeurTime\") = \"NoRelHeurTime\";\n\tParam.attr(\"NoRelHeurWork\") = \"NoRelHeurWork\";\n\tParam.attr(\"NodeLimit\") = \"NodeLimit\";\n\tParam.attr(\"NodeMethod\") = \"NodeMethod\";\n\tParam.attr(\"NodefileDir\") = \"NodefileDir\";\n\tParam.attr(\"NodefileStart\") = \"NodefileStart\";\n\tParam.attr(\"NonConvex\") = \"NonConvex\";\n\tParam.attr(\"NormAdjust\") = \"NormAdjust\";\n\tParam.attr(\"NumericFocus\") = \"NumericFocus\";\n\tParam.attr(\"OBBT\") = \"OBBT\";\n\tParam.attr(\"ObjNumber\") = \"ObjNumber\";\n\tParam.attr(\"ObjPassNumber\") = \"ObjPassNumber\";\n\tParam.attr(\"ObjScale\") = \"ObjScale\";\n\tParam.attr(\"OptimalityTarget\") = \"OptimalityTarget\";\n\tParam.attr(\"OptimalityTol\") = \"OptimalityTol\";\n\tParam.attr(\"OutputFlag\") = \"OutputFlag\";\n\tParam.attr(\"PDHGAbsTol\") = \"PDHGAbsTol\";\n\tParam.attr(\"PDHGConvTol\") = \"PDHGConvTol\";\n\tParam.attr(\"PDHGGPU\") = \"PDHGGPU\";\n\tParam.attr(\"PDHGIterLimit\") = \"PDHGIterLimit\";\n\tParam.attr(\"PDHGRelTol\") = \"PDHGRelTol\";\n\tParam.attr(\"PSDCuts\") = \"PSDCuts\";\n\tParam.attr(\"PSDTol\") = \"PSDTol\";\n\tParam.attr(\"PartitionPlace\") = \"PartitionPlace\";\n\tParam.attr(\"PerturbValue\") = \"PerturbValue\";\n\tParam.attr(\"PoolGap\") = \"PoolGap\";\n\tParam.attr(\"PoolGapAbs\") = \"PoolGapAbs\";\n\tParam.attr(\"PoolSearchMode\") = \"PoolSearchMode\";\n\tParam.attr(\"PoolSolutions\") = \"PoolSolutions\";\n\tParam.attr(\"PreCrush\") = \"PreCrush\";\n\tParam.attr(\"PreDepRow\") = \"PreDepRow\";\n\tParam.attr(\"PreDual\") = \"PreDual\";\n\tParam.attr(\"PreMIQCPForm\") = \"PreMIQCPForm\";\n\tParam.attr(\"PrePasses\") = \"PrePasses\";\n\tParam.attr(\"PreQLinearize\") = \"PreQLinearize\";\n\tParam.attr(\"PreSOS1BigM\") = \"PreSOS1BigM\";\n\tParam.attr(\"PreSOS1Encoding\") = \"PreSOS1Encoding\";\n\tParam.attr(\"PreSOS2BigM\") = \"PreSOS2BigM\";\n\tParam.attr(\"PreSOS2Encoding\") = \"PreSOS2Encoding\";\n\tParam.attr(\"PreSparsify\") = \"PreSparsify\";\n\tParam.attr(\"Presolve\") = \"Presolve\";\n\tParam.attr(\"ProjImpliedCuts\") = \"ProjImpliedCuts\";\n\tParam.attr(\"PumpPasses\") = \"PumpPasses\";\n\tParam.attr(\"QCPDual\") = \"QCPDual\";\n\tParam.attr(\"Quad\") = \"Quad\";\n\tParam.attr(\"RINS\") = \"RINS\";\n\tParam.attr(\"RLTCuts\") = \"RLTCuts\";\n\tParam.attr(\"Record\") = \"Record\";\n\tParam.attr(\"RelaxLiftCuts\") = \"RelaxLiftCuts\";\n\tParam.attr(\"ResultFile\") = \"ResultFile\";\n\tParam.attr(\"ScaleFlag\") = \"ScaleFlag\";\n\tParam.attr(\"ScenarioNumber\") = \"ScenarioNumber\";\n\tParam.attr(\"Seed\") = \"Seed\";\n\tParam.attr(\"ServerPassword\") = \"ServerPassword\";\n\tParam.attr(\"ServerTimeout\") = \"ServerTimeout\";\n\tParam.attr(\"SiftMethod\") = \"SiftMethod\";\n\tParam.attr(\"Sifting\") = \"Sifting\";\n\tParam.attr(\"SimplexPricing\") = \"SimplexPricing\";\n\tParam.attr(\"SoftMemLimit\") = \"SoftMemLimit\";\n\tParam.attr(\"SolFiles\") = \"SolFiles\";\n\tParam.attr(\"SolutionLimit\") = \"SolutionLimit\";\n\tParam.attr(\"SolutionNumber\") = \"SolutionNumber\";\n\tParam.attr(\"SolutionTarget\") = \"SolutionTarget\";\n\tParam.attr(\"StartNodeLimit\") = \"StartNodeLimit\";\n\tParam.attr(\"StartNumber\") = \"StartNumber\";\n\tParam.attr(\"StartTimeLimit\") = \"StartTimeLimit\";\n\tParam.attr(\"StartWorkLimit\") = \"StartWorkLimit\";\n\tParam.attr(\"StrongCGCuts\") = \"StrongCGCuts\";\n\tParam.attr(\"SubMIPCuts\") = \"SubMIPCuts\";\n\tParam.attr(\"SubMIPNodes\") = \"SubMIPNodes\";\n\tParam.attr(\"Symmetry\") = \"Symmetry\";\n\tParam.attr(\"TSPort\") = \"TSPort\";\n\tParam.attr(\"ThreadLimit\") = \"ThreadLimit\";\n\tParam.attr(\"Threads\") = \"Threads\";\n\tParam.attr(\"TimeLimit\") = \"TimeLimit\";\n\tParam.attr(\"TokenServer\") = \"TokenServer\";\n\tParam.attr(\"TuneCleanup\") = \"TuneCleanup\";\n\tParam.attr(\"TuneCriterion\") = \"TuneCriterion\";\n\tParam.attr(\"TuneDynamicJobs\") = \"TuneDynamicJobs\";\n\tParam.attr(\"TuneJobs\") = \"TuneJobs\";\n\tParam.attr(\"TuneMetric\") = \"TuneMetric\";\n\tParam.attr(\"TuneOutput\") = \"TuneOutput\";\n\tParam.attr(\"TuneResults\") = \"TuneResults\";\n\tParam.attr(\"TuneTargetMIPGap\") = \"TuneTargetMIPGap\";\n\tParam.attr(\"TuneTargetTime\") = \"TuneTargetTime\";\n\tParam.attr(\"TuneTimeLimit\") = \"TuneTimeLimit\";\n\tParam.attr(\"TuneTrials\") = \"TuneTrials\";\n\tParam.attr(\"UpdateMode\") = \"UpdateMode\";\n\tParam.attr(\"UserName\") = \"UserName\";\n\tParam.attr(\"VarBranch\") = \"VarBranch\";\n\tParam.attr(\"WLSAccessID\") = \"WLSAccessID\";\n\tParam.attr(\"WLSConfig\") = \"WLSConfig\";\n\tParam.attr(\"WLSProxy\") = \"WLSProxy\";\n\tParam.attr(\"WLSSecret\") = \"WLSSecret\";\n\tParam.attr(\"WLSToken\") = \"WLSToken\";\n\tParam.attr(\"WLSTokenDuration\") = \"WLSTokenDuration\";\n\tParam.attr(\"WLSTokenRefresh\") = \"WLSTokenRefresh\";\n\tParam.attr(\"WorkLimit\") = \"WorkLimit\";\n\tParam.attr(\"WorkerPassword\") = \"WorkerPassword\";\n\tParam.attr(\"WorkerPool\") = \"WorkerPool\";\n\tParam.attr(\"ZeroHalfCuts\") = \"ZeroHalfCuts\";\n\tParam.attr(\"ZeroObjNodes\") = \"ZeroObjNodes\";\n\n\tnb::module_ Callback = GRB.def_submodule(\"Callback\");\n\tCallback.attr(\"BARRIER\") = 7;\n\tCallback.attr(\"BARRIER_COMPL\") = 7006;\n\tCallback.attr(\"BARRIER_DUALINF\") = 7005;\n\tCallback.attr(\"BARRIER_DUALOBJ\") = 7003;\n\tCallback.attr(\"BARRIER_ITRCNT\") = 7001;\n\tCallback.attr(\"BARRIER_PRIMINF\") = 7004;\n\tCallback.attr(\"BARRIER_PRIMOBJ\") = 7002;\n\tCallback.attr(\"IIS\") = 9;\n\tCallback.attr(\"IIS_BOUNDGUESS\") = 9006;\n\tCallback.attr(\"IIS_BOUNDMAX\") = 9005;\n\tCallback.attr(\"IIS_BOUNDMIN\") = 9004;\n\tCallback.attr(\"IIS_CONSTRGUESS\") = 9003;\n\tCallback.attr(\"IIS_CONSTRMAX\") = 9002;\n\tCallback.attr(\"IIS_CONSTRMIN\") = 9001;\n\tCallback.attr(\"MAXMEMUSED\") = 6005;\n\tCallback.attr(\"MEMUSED\") = 6004;\n\tCallback.attr(\"MESSAGE\") = 6;\n\tCallback.attr(\"MIP\") = 3;\n\tCallback.attr(\"MIPNODE\") = 5;\n\tCallback.attr(\"MIPNODE_BRVAR\") = 5007;\n\tCallback.attr(\"MIPNODE_NODCNT\") = 5005;\n\tCallback.attr(\"MIPNODE_OBJBND\") = 5004;\n\tCallback.attr(\"MIPNODE_OBJBST\") = 5003;\n\tCallback.attr(\"MIPNODE_OPENSCENARIOS\") = 5008;\n\tCallback.attr(\"MIPNODE_PHASE\") = 5009;\n\tCallback.attr(\"MIPNODE_REL\") = 5002;\n\tCallback.attr(\"MIPNODE_SOLCNT\") = 5006;\n\tCallback.attr(\"MIPNODE_STATUS\") = 5001;\n\tCallback.attr(\"MIPSOL\") = 4;\n\tCallback.attr(\"MIPSOL_NODCNT\") = 4005;\n\tCallback.attr(\"MIPSOL_OBJ\") = 4002;\n\tCallback.attr(\"MIPSOL_OBJBND\") = 4004;\n\tCallback.attr(\"MIPSOL_OBJBST\") = 4003;\n\tCallback.attr(\"MIPSOL_OPENSCENARIOS\") = 4007;\n\tCallback.attr(\"MIPSOL_PHASE\") = 4008;\n\tCallback.attr(\"MIPSOL_SOL\") = 4001;\n\tCallback.attr(\"MIPSOL_SOLCNT\") = 4006;\n\tCallback.attr(\"MIP_CUTCNT\") = 3004;\n\tCallback.attr(\"MIP_ITRCNT\") = 3006;\n\tCallback.attr(\"MIP_NODCNT\") = 3002;\n\tCallback.attr(\"MIP_NODLFT\") = 3005;\n\tCallback.attr(\"MIP_OBJBND\") = 3001;\n\tCallback.attr(\"MIP_OBJBST\") = 3000;\n\tCallback.attr(\"MIP_OPENSCENARIOS\") = 3007;\n\tCallback.attr(\"MIP_PHASE\") = 3008;\n\tCallback.attr(\"MIP_SOLCNT\") = 3003;\n\tCallback.attr(\"MSG_STRING\") = 6001;\n\tCallback.attr(\"MULTIOBJ\") = 8;\n\tCallback.attr(\"MULTIOBJ_ITRCNT\") = 8004;\n\tCallback.attr(\"MULTIOBJ_MIPGAP\") = 8008;\n\tCallback.attr(\"MULTIOBJ_NODCNT\") = 8009;\n\tCallback.attr(\"MULTIOBJ_NODLFT\") = 8010;\n\tCallback.attr(\"MULTIOBJ_OBJBND\") = 8006;\n\tCallback.attr(\"MULTIOBJ_OBJBST\") = 8005;\n\tCallback.attr(\"MULTIOBJ_OBJCNT\") = 8001;\n\tCallback.attr(\"MULTIOBJ_RUNTIME\") = 8011;\n\tCallback.attr(\"MULTIOBJ_SOL\") = 8003;\n\tCallback.attr(\"MULTIOBJ_SOLCNT\") = 8002;\n\tCallback.attr(\"MULTIOBJ_STATUS\") = 8007;\n\tCallback.attr(\"MULTIOBJ_WORK\") = 8012;\n\tCallback.attr(\"NLBAR\") = 11;\n\tCallback.attr(\"NLBAR_COMPL\") = 11005;\n\tCallback.attr(\"NLBAR_DUALINF\") = 11004;\n\tCallback.attr(\"NLBAR_ITRCNT\") = 11001;\n\tCallback.attr(\"NLBAR_PRIMINF\") = 11003;\n\tCallback.attr(\"NLBAR_PRIMOBJ\") = 11002;\n\tCallback.attr(\"PDHG\") = 10;\n\tCallback.attr(\"PDHG_COMPL\") = 10006;\n\tCallback.attr(\"PDHG_DUALINF\") = 10005;\n\tCallback.attr(\"PDHG_DUALOBJ\") = 10003;\n\tCallback.attr(\"PDHG_ITRCNT\") = 10001;\n\tCallback.attr(\"PDHG_PRIMINF\") = 10004;\n\tCallback.attr(\"PDHG_PRIMOBJ\") = 10002;\n\tCallback.attr(\"POLLING\") = 0;\n\tCallback.attr(\"PRESOLVE\") = 1;\n\tCallback.attr(\"PRE_BNDCHG\") = 1003;\n\tCallback.attr(\"PRE_COECHG\") = 1004;\n\tCallback.attr(\"PRE_COLDEL\") = 1000;\n\tCallback.attr(\"PRE_ROWDEL\") = 1001;\n\tCallback.attr(\"PRE_SENCHG\") = 1002;\n\tCallback.attr(\"RUNTIME\") = 6002;\n\tCallback.attr(\"SIMPLEX\") = 2;\n\tCallback.attr(\"SPX_DUALINF\") = 2003;\n\tCallback.attr(\"SPX_ISPERT\") = 2004;\n\tCallback.attr(\"SPX_ITRCNT\") = 2000;\n\tCallback.attr(\"SPX_OBJVAL\") = 2001;\n\tCallback.attr(\"SPX_PRIMINF\") = 2002;\n\tCallback.attr(\"WORK\") = 6003;\n}\n" }, { "path": "lib/highs_model.cpp", "content": "#include \"pyoptinterface/highs_model.hpp\"\n#include \"fmt/core.h\"\n\nnamespace highs\n{\n#define B DYLIB_DECLARE\nAPILIST\n#undef B\n\nstatic DynamicLibrary lib;\nstatic bool is_loaded = false;\n\nbool is_library_loaded()\n{\n\treturn is_loaded;\n}\n\nbool load_library(const std::string &path)\n{\n\tbool success = lib.try_load(path.c_str());\n\tif (!success)\n\t{\n\t\treturn false;\n\t}\n\n\tDYLIB_LOAD_INIT;\n\n#define B DYLIB_LOAD_FUNCTION\n\tAPILIST\n#undef B\n\n\tif (IS_DYLIB_LOAD_SUCCESS)\n\t{\n#define B DYLIB_SAVE_FUNCTION\n\t\tAPILIST\n#undef B\n\t\tis_loaded = true;\n\t\treturn true;\n\t}\n\telse\n\t{\n\t\treturn false;\n\t}\n}\n} // namespace highs\n\nstatic void check_error(HighsInt error)\n{\n\tif (error == kHighsStatusError)\n\t{\n\t\tstd::string errmsg = fmt::format(\n\t\t \"Encountered an error in HiGHS (Status {}). Check the log for details.\", error);\n\n\t\tthrow std::runtime_error(errmsg);\n\t}\n}\n\nstatic HighsInt highs_vtype(VariableDomain domain)\n{\n\tswitch (domain)\n\t{\n\tcase VariableDomain::Continuous:\n\t\treturn kHighsVarTypeContinuous;\n\tcase VariableDomain::Integer:\n\tcase VariableDomain::Binary:\n\t\treturn kHighsVarTypeInteger;\n\tcase VariableDomain::SemiContinuous:\n\t\treturn kHighsVarTypeSemiContinuous;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown variable domain\");\n\t}\n}\n\nstatic VariableDomain highs_vtype_to_domain(HighsInt vtype)\n{\n\tswitch (vtype)\n\t{\n\tcase kHighsVarTypeContinuous:\n\t\treturn VariableDomain::Continuous;\n\tcase kHighsVarTypeInteger:\n\t\treturn VariableDomain::Integer;\n\tcase kHighsVarTypeSemiContinuous:\n\t\treturn VariableDomain::SemiContinuous;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown variable domain\");\n\t}\n}\n\nstatic HighsInt highs_obj_sense(ObjectiveSense sense)\n{\n\tswitch (sense)\n\t{\n\tcase ObjectiveSense::Minimize:\n\t\treturn kHighsObjSenseMinimize;\n\tcase ObjectiveSense::Maximize:\n\t\treturn kHighsObjSenseMaximize;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown objective sense\");\n\t}\n}\n\nPOIHighsModel::POIHighsModel()\n{\n\tinit();\n}\n\nvoid POIHighsModel::init()\n{\n\tif (!highs::is_library_loaded())\n\t{\n\t\tthrow std::runtime_error(\"HiGHS library is not loaded\");\n\t}\n\tvoid *model = highs::Highs_create();\n\tm_model = std::unique_ptr(model);\n}\n\nvoid POIHighsModel::close()\n{\n\tm_model.reset();\n}\n\nvoid POIHighsModel::write(const std::string &filename, bool pretty)\n{\n\tbool is_solution = false;\n\tif (filename.ends_with(\".sol\"))\n\t{\n\t\tis_solution = true;\n\t}\n\tHighsInt error;\n\tif (is_solution)\n\t{\n\t\tif (pretty)\n\t\t\terror = highs::Highs_writeSolutionPretty(m_model.get(), filename.c_str());\n\t\telse\n\t\t\terror = highs::Highs_writeSolution(m_model.get(), filename.c_str());\n\t}\n\telse\n\t{\n\t\terror = highs::Highs_writeModel(m_model.get(), filename.c_str());\n\t}\n\tcheck_error(error);\n}\n\nVariableIndex POIHighsModel::add_variable(VariableDomain domain, double lb, double ub,\n const char *name)\n{\n\tIndexT index = m_variable_index.add_index();\n\tVariableIndex variable(index);\n\n\tif (domain == VariableDomain::Binary)\n\t{\n\t\tlb = 0.0;\n\t\tub = 1.0;\n\t}\n\tauto error = highs::Highs_addCol(m_model.get(), 0.0, lb, ub, 0, nullptr, nullptr);\n\tcheck_error(error);\n\n\tauto column = m_n_variables;\n\n\tif (domain != VariableDomain::Continuous)\n\t{\n\t\tauto vtype = highs_vtype(domain);\n\t\tif (domain == VariableDomain::Binary)\n\t\t{\n\t\t\tbinary_variables.insert(index);\n\t\t}\n\t\terror = highs::Highs_changeColIntegrality(m_model.get(), column, vtype);\n\t\tcheck_error(error);\n\t}\n\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\tif (name)\n\t{\n\t\terror = highs::Highs_passColName(m_model.get(), column, name);\n\t\tcheck_error(error);\n\t}\n\n\tm_n_variables++;\n\treturn variable;\n}\n\nvoid POIHighsModel::delete_variable(const VariableIndex &variable)\n{\n\tif (!is_variable_active(variable))\n\t{\n\t\tthrow std::runtime_error(\"Variable does not exist\");\n\t}\n\n\tint variable_column = _variable_index(variable);\n\tauto error = highs::Highs_deleteColsBySet(m_model.get(), 1, &variable_column);\n\tcheck_error(error);\n\n\tm_variable_index.delete_index(variable.index);\n\tbinary_variables.erase(variable.index);\n\n\tm_n_variables--;\n}\n\nvoid POIHighsModel::delete_variables(const Vector &variables)\n{\n\tint n_variables = variables.size();\n\tif (n_variables == 0)\n\t\treturn;\n\n\tstd::vector columns;\n\tcolumns.reserve(n_variables);\n\tfor (int i = 0; i < n_variables; i++)\n\t{\n\t\tif (!is_variable_active(variables[i]))\n\t\t{\n\t\t\tcontinue;\n\t\t}\n\t\tauto column = _variable_index(variables[i]);\n\t\tcolumns.push_back(column);\n\t}\n\n\tint error = highs::Highs_deleteColsBySet(m_model.get(), columns.size(), columns.data());\n\tcheck_error(error);\n\n\tfor (int i = 0; i < n_variables; i++)\n\t{\n\t\tm_variable_index.delete_index(variables[i].index);\n\t}\n\tm_n_variables -= columns.size();\n}\n\nbool POIHighsModel::is_variable_active(const VariableIndex &variable)\n{\n\treturn m_variable_index.has_index(variable.index);\n}\n\ndouble POIHighsModel::get_variable_value(const VariableIndex &variable)\n{\n\tauto column = _checked_variable_index(variable);\n\tif (m_solution.primal_solution_status != kHighsSolutionStatusNone)\n\t{\n\t\treturn m_solution.colvalue[column];\n\t}\n\tthrow std::runtime_error(\"No solution available\");\n}\n\nstd::string POIHighsModel::pprint_variable(const VariableIndex &variable)\n{\n\treturn get_variable_name(variable);\n}\n\nvoid POIHighsModel::set_variable_bounds(const VariableIndex &variable, double lb, double ub)\n{\n\tauto column = _checked_variable_index(variable);\n\tauto error = highs::Highs_changeColsBoundsBySet(m_model.get(), 1, &column, &lb, &ub);\n\tcheck_error(error);\n}\n\nConstraintIndex POIHighsModel::add_linear_constraint(const ScalarAffineFunction &function,\n ConstraintSense sense, CoeffT rhs,\n const char *name)\n{\n\tdouble lb = -kHighsInf;\n\tdouble ub = kHighsInf;\n\tswitch (sense)\n\t{\n\tcase ConstraintSense::LessEqual:\n\t\tub = rhs;\n\t\tbreak;\n\tcase ConstraintSense::GreaterEqual:\n\t\tlb = rhs;\n\t\tbreak;\n\tcase ConstraintSense::Equal:\n\t\tlb = rhs;\n\t\tub = rhs;\n\t\tbreak;\n\t}\n\n\tauto con = add_linear_constraint(function, std::make_tuple(lb, ub), name);\n\treturn con;\n}\n\nConstraintIndex POIHighsModel::add_linear_constraint(const ScalarAffineFunction &function,\n const std::tuple &interval,\n const char *name)\n{\n\tIndexT index = m_linear_constraint_index.add_index();\n\tConstraintIndex constraint(ConstraintType::Linear, index);\n\n\tAffineFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\n\tHighsInt numnz = ptr_form.numnz;\n\tHighsInt *cind = ptr_form.index;\n\tdouble *cval = ptr_form.value;\n\n\tdouble lb = std::get<0>(interval);\n\tdouble ub = std::get<1>(interval);\n\tif (function.constant.has_value())\n\t{\n\t\tlb -= function.constant.value();\n\t\tub -= function.constant.value();\n\t}\n\n\tauto error = highs::Highs_addRow(m_model.get(), lb, ub, numnz, cind, cval);\n\tcheck_error(error);\n\n\tHighsInt row = m_n_constraints;\n\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\tif (name)\n\t{\n\t\terror = highs::Highs_passRowName(m_model.get(), row, name);\n\t\tcheck_error(error);\n\t}\n\n\tm_n_constraints++;\n\n\treturn constraint;\n}\n\nConstraintIndex POIHighsModel::add_quadratic_constraint(const ScalarQuadraticFunction &function,\n ConstraintSense sense, CoeffT rhs,\n const char *name)\n{\n\tthrow std::runtime_error(\"HIGHS does not support quadratic constraint!\");\n}\n\nvoid POIHighsModel::delete_constraint(const ConstraintIndex &constraint)\n{\n\tif (!is_constraint_active(constraint))\n\t{\n\t\tthrow std::runtime_error(\"Constraint does not exist\");\n\t}\n\n\tint constraint_row = _constraint_index(constraint);\n\tauto error = highs::Highs_deleteRowsBySet(m_model.get(), 1, &constraint_row);\n\tcheck_error(error);\n\n\tm_linear_constraint_index.delete_index(constraint.index);\n\n\tm_n_constraints--;\n}\n\nbool POIHighsModel::is_constraint_active(const ConstraintIndex &constraint)\n{\n\treturn m_linear_constraint_index.has_index(constraint.index);\n}\n\nvoid POIHighsModel::_set_affine_objective(const ScalarAffineFunction &function,\n ObjectiveSense sense, bool clear_quadratic)\n{\n\tHighsInt error;\n\n\tHighsInt n_variables = m_n_variables;\n\tif (clear_quadratic)\n\t{\n\t\t// First delete all quadratic terms\n\t\tstd::vector colstarts(n_variables, 0);\n\t\terror =\n\t\t highs::Highs_passHessian(m_model.get(), n_variables, 0, kHighsHessianFormatTriangular,\n\t\t colstarts.data(), nullptr, nullptr);\n\n\t\tcheck_error(error);\n\t}\n\n\t// Set Obj attribute of each variable\n\tstd::vector obj_v(n_variables, 0.0);\n\n\tint numnz = function.size();\n\tfor (int i = 0; i < numnz; i++)\n\t{\n\t\tauto column = _variable_index(function.variables[i]);\n\t\tif (column < 0)\n\t\t{\n\t\t\tthrow std::runtime_error(\"Variable does not exist\");\n\t\t}\n\t\tobj_v[column] = function.coefficients[i];\n\t}\n\n\terror = highs::Highs_changeColsCostByRange(m_model.get(), 0, n_variables - 1, obj_v.data());\n\tcheck_error(error);\n\terror = highs::Highs_changeObjectiveOffset(m_model.get(), function.constant.value_or(0.0));\n\tcheck_error(error);\n\n\tHighsInt obj_sense = highs_obj_sense(sense);\n\terror = highs::Highs_changeObjectiveSense(m_model.get(), obj_sense);\n\tcheck_error(error);\n}\n\nvoid POIHighsModel::set_objective(const ScalarAffineFunction &function, ObjectiveSense sense)\n{\n\t_set_affine_objective(function, sense, true);\n}\n\nvoid POIHighsModel::set_objective(const ScalarQuadraticFunction &function, ObjectiveSense sense)\n{\n\tHighsInt error;\n\n\t// Add quadratic term\n\tint numqnz = function.size();\n\tHighsInt n_variables = m_n_variables;\n\tif (numqnz > 0)\n\t{\n\t\tCSCMatrix csc;\n\t\tcsc.make(this, function, n_variables, HessianTriangular::Lower);\n\n\t\t// Highs optimizes 0.5 * x' * Q * x\n\t\t// so the coefficient must be multiplied by 2.0\n\t\tfor (auto &v : csc.values_CSC)\n\t\t{\n\t\t\tv *= 2.0;\n\t\t}\n\n\t\terror = highs::Highs_passHessian(m_model.get(), n_variables, numqnz,\n\t\t kHighsHessianFormatTriangular, csc.colStarts_CSC.data(),\n\t\t csc.rows_CSC.data(), csc.values_CSC.data());\n\t\tcheck_error(error);\n\t}\n\telse\n\t{\n\t\tstd::vector colstarts(n_variables, 0);\n\t\terror =\n\t\t highs::Highs_passHessian(m_model.get(), n_variables, 0, kHighsHessianFormatTriangular,\n\t\t colstarts.data(), nullptr, nullptr);\n\t\tcheck_error(error);\n\t}\n\n\t// Affine part\n\tconst auto &affine_part = function.affine_part;\n\tif (affine_part)\n\t{\n\t\tconst auto &affine_function = affine_part.value();\n\t\t_set_affine_objective(affine_function, sense, false);\n\t}\n\telse\n\t{\n\t\tScalarAffineFunction zero;\n\t\t_set_affine_objective(zero, sense, false);\n\t}\n}\n\nvoid POIHighsModel::set_objective(const ExprBuilder &function, ObjectiveSense sense)\n{\n\tauto deg = function.degree();\n\tif (deg <= 1)\n\t{\n\t\tScalarAffineFunction f(function);\n\t\tset_objective(f, sense);\n\t}\n\telse if (deg == 2)\n\t{\n\t\tScalarQuadraticFunction f(function);\n\t\tset_objective(f, sense);\n\t}\n\telse\n\t{\n\t\tthrow std::runtime_error(\"Objective must be linear or quadratic\");\n\t}\n}\n\nvoid POIHighsModel::optimize()\n{\n\tHighsInt error = highs::Highs_run(m_model.get());\n\n\tPOIHighsSolution &x = m_solution;\n\tx.status = error == kHighsStatusError ? HighsSolutionStatus::OPTIMIZE_ERROR\n\t : HighsSolutionStatus::OPTIMIZE_OK;\n\n\tvoid *model = m_model.get();\n\n\tx.primal_solution_status = kHighsSolutionStatusNone;\n\tx.dual_solution_status = kHighsSolutionStatusNone;\n\tx.has_dual_ray = false;\n\tx.has_primal_ray = false;\n\tauto numCols = m_n_variables;\n\tauto numRows = m_n_constraints;\n\tx.model_status = highs::Highs_getModelStatus(model);\n\n\tHighsInt status;\n\tHighsInt *statusP = &status;\n\tif (x.model_status == kHighsModelStatusInfeasible)\n\t{\n\t\tx.dual_ray.resize(numRows);\n\t\terror = highs::Highs_getDualRay(model, statusP, x.dual_ray.data());\n\t\tx.has_dual_ray = (error == kHighsStatusOk) && (*statusP == 1);\n\t}\n\telse if (x.model_status == kHighsModelStatusUnbounded)\n\t{\n\t\tx.primal_ray.resize(numCols);\n\t\terror = highs::Highs_getPrimalRay(model, statusP, x.primal_ray.data());\n\t\tx.has_primal_ray = (error == kHighsStatusOk) && (*statusP == 1);\n\t}\n\telse\n\t{\n\t\thighs::Highs_getIntInfoValue(model, \"primal_solution_status\", statusP);\n\t\tx.primal_solution_status = *statusP;\n\t\thighs::Highs_getIntInfoValue(model, \"dual_solution_status\", statusP);\n\t\tx.dual_solution_status = *statusP;\n\t\tif (x.primal_solution_status != kHighsSolutionStatusNone)\n\t\t{\n\t\t\tx.colvalue.resize(numCols);\n\t\t\tx.coldual.resize(numCols);\n\t\t\tx.rowvalue.resize(numRows);\n\t\t\tx.rowdual.resize(numRows);\n\t\t\thighs::Highs_getSolution(model, x.colvalue.data(), x.coldual.data(), x.rowvalue.data(),\n\t\t\t x.rowdual.data());\n\n\t\t\t// HighsModel &h_model = ((Highs *)m_model.get())->model_;\n\t\t\t// auto &hessian = h_model.hessian_;\n\t\t\tauto hessian_nz = highs::Highs_getHessianNumNz(model);\n\t\t\tif (hessian_nz == 0)\n\t\t\t{\n\t\t\t\t// No basis is present in a QP.\n\t\t\t\tx.colstatus.resize(numCols);\n\t\t\t\tx.rowstatus.resize(numRows);\n\t\t\t\thighs::Highs_getBasis(model, x.colstatus.data(), x.rowstatus.data());\n\t\t\t}\n\t\t}\n\t}\n}\n\nvoid *POIHighsModel::get_raw_model()\n{\n\treturn m_model.get();\n}\n\nstd::string POIHighsModel::version_string()\n{\n\tauto version = highs::Highs_version();\n\treturn version;\n}\n\ndouble POIHighsModel::getruntime()\n{\n\tdouble runtime = highs::Highs_getRunTime(m_model.get());\n\treturn runtime;\n}\n\nint POIHighsModel::getnumrow()\n{\n\treturn highs::Highs_getNumRow(m_model.get());\n}\n\nint POIHighsModel::getnumcol()\n{\n\treturn highs::Highs_getNumCol(m_model.get());\n}\n\nint POIHighsModel::raw_option_type(const char *param_name)\n{\n\tHighsInt retval;\n\tauto error = highs::Highs_getOptionType(m_model.get(), param_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nvoid POIHighsModel::set_raw_option_bool(const char *param_name, bool value)\n{\n\tauto error = highs::Highs_setBoolOptionValue(m_model.get(), param_name, value);\n\tcheck_error(error);\n}\n\nvoid POIHighsModel::set_raw_option_int(const char *param_name, int value)\n{\n\tauto error = highs::Highs_setIntOptionValue(m_model.get(), param_name, value);\n\tcheck_error(error);\n}\n\nvoid POIHighsModel::set_raw_option_double(const char *param_name, double value)\n{\n\tauto error = highs::Highs_setDoubleOptionValue(m_model.get(), param_name, value);\n\tcheck_error(error);\n}\n\nvoid POIHighsModel::set_raw_option_string(const char *param_name, const char *value)\n{\n\tauto error = highs::Highs_setStringOptionValue(m_model.get(), param_name, value);\n\tcheck_error(error);\n}\n\nbool POIHighsModel::get_raw_option_bool(const char *param_name)\n{\n\tHighsInt retval;\n\tauto error = highs::Highs_getBoolOptionValue(m_model.get(), param_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nint POIHighsModel::get_raw_option_int(const char *param_name)\n{\n\tHighsInt retval;\n\tauto error = highs::Highs_getIntOptionValue(m_model.get(), param_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble POIHighsModel::get_raw_option_double(const char *param_name)\n{\n\tdouble retval;\n\tauto error = highs::Highs_getDoubleOptionValue(m_model.get(), param_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nstd::string POIHighsModel::get_raw_option_string(const char *param_name)\n{\n\tchar retval[kHighsMaximumStringLength];\n\tauto error = highs::Highs_getStringOptionValue(m_model.get(), param_name, retval);\n\tcheck_error(error);\n\treturn std::string(retval);\n}\n\nint POIHighsModel::raw_info_type(const char *info_name)\n{\n\tHighsInt retval;\n\tauto error = highs::Highs_getInfoType(m_model.get(), info_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nint POIHighsModel::get_raw_info_int(const char *info_name)\n{\n\tHighsInt retval;\n\tauto error = highs::Highs_getIntInfoValue(m_model.get(), info_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nstd::int64_t POIHighsModel::get_raw_info_int64(const char *info_name)\n{\n\tint64_t retval;\n\tauto error = highs::Highs_getInt64InfoValue(m_model.get(), info_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble POIHighsModel::get_raw_info_double(const char *info_name)\n{\n\tdouble retval;\n\tauto error = highs::Highs_getDoubleInfoValue(m_model.get(), info_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nstd::string POIHighsModel::get_variable_name(const VariableIndex &variable)\n{\n\tauto column = _checked_variable_index(variable);\n\tchar name[kHighsMaximumStringLength];\n\tauto error = highs::Highs_getColName(m_model.get(), column, name);\n\tcheck_error(error);\n\treturn std::string(name);\n}\n\nvoid POIHighsModel::set_variable_name(const VariableIndex &variable, const char *name)\n{\n\tauto column = _checked_variable_index(variable);\n\tauto error = highs::Highs_passColName(m_model.get(), column, name);\n\tcheck_error(error);\n}\n\nVariableDomain POIHighsModel::get_variable_type(const VariableIndex &variable)\n{\n\tif (binary_variables.contains(variable.index))\n\t{\n\t\treturn VariableDomain::Binary;\n\t}\n\tauto column = _checked_variable_index(variable);\n\tHighsInt vtype;\n\tauto error = highs::Highs_getColIntegrality(m_model.get(), column, &vtype);\n\tcheck_error(error);\n\treturn highs_vtype_to_domain(vtype);\n}\n\nvoid POIHighsModel::set_variable_type(const VariableIndex &variable, VariableDomain domain)\n{\n\tauto vtype = highs_vtype(domain);\n\tauto column = _checked_variable_index(variable);\n\tauto error = highs::Highs_changeColIntegrality(m_model.get(), column, vtype);\n\tcheck_error(error);\n\n\tif (domain == VariableDomain::Binary)\n\t{\n\t\tdouble lb = 0.0;\n\t\tdouble ub = 1.0;\n\t\tbinary_variables.insert(variable.index);\n\t\terror = highs::Highs_changeColsBoundsBySet(m_model.get(), 1, &column, &lb, &ub);\n\t\tcheck_error(error);\n\t}\n\telse\n\t{\n\t\tbinary_variables.erase(variable.index);\n\t}\n}\n\ndouble POIHighsModel::get_variable_lower_bound(const VariableIndex &variable)\n{\n\tauto column = _checked_variable_index(variable);\n\tHighsInt numcol, nz;\n\tdouble c, lb, ub;\n\tauto error = highs::Highs_getColsBySet(m_model.get(), 1, &column, &numcol, &c, &lb, &ub, &nz,\n\t nullptr, nullptr, nullptr);\n\tcheck_error(error);\n\treturn lb;\n}\n\ndouble POIHighsModel::get_variable_upper_bound(const VariableIndex &variable)\n{\n\tauto column = _checked_variable_index(variable);\n\tHighsInt numcol, nz;\n\tdouble c, lb, ub;\n\tauto error = highs::Highs_getColsBySet(m_model.get(), 1, &column, &numcol, &c, &lb, &ub, &nz,\n\t nullptr, nullptr, nullptr);\n\tcheck_error(error);\n\treturn ub;\n}\n\nvoid POIHighsModel::set_variable_lower_bound(const VariableIndex &variable, double lb)\n{\n\tdouble new_lb = lb;\n\tauto column = _checked_variable_index(variable);\n\tHighsInt numcol, nz;\n\tdouble c, ub;\n\tauto error = highs::Highs_getColsBySet(m_model.get(), 1, &column, &numcol, &c, &lb, &ub, &nz,\n\t nullptr, nullptr, nullptr);\n\tcheck_error(error);\n\terror = highs::Highs_changeColsBoundsBySet(m_model.get(), 1, &column, &new_lb, &ub);\n\tcheck_error(error);\n}\n\nvoid POIHighsModel::set_variable_upper_bound(const VariableIndex &variable, double ub)\n{\n\tdouble new_ub = ub;\n\tauto column = _checked_variable_index(variable);\n\tHighsInt numcol, nz;\n\tdouble c, lb;\n\tauto error = highs::Highs_getColsBySet(m_model.get(), 1, &column, &numcol, &c, &lb, &ub, &nz,\n\t nullptr, nullptr, nullptr);\n\tcheck_error(error);\n\terror = highs::Highs_changeColsBoundsBySet(m_model.get(), 1, &column, &lb, &new_ub);\n\tcheck_error(error);\n}\n\nstd::string POIHighsModel::get_constraint_name(const ConstraintIndex &constraint)\n{\n\tauto row = _checked_constraint_index(constraint);\n\tchar name[kHighsMaximumStringLength];\n\tauto error = highs::Highs_getRowName(m_model.get(), row, name);\n\tcheck_error(error);\n\treturn std::string(name);\n}\n\nvoid POIHighsModel::set_constraint_name(const ConstraintIndex &constraint, const char *name)\n{\n\tauto row = _checked_constraint_index(constraint);\n\tauto error = highs::Highs_passRowName(m_model.get(), row, name);\n\tcheck_error(error);\n}\n\ndouble POIHighsModel::get_constraint_primal(const ConstraintIndex &constraint)\n{\n\tauto row = _checked_constraint_index(constraint);\n\tif (m_solution.primal_solution_status != kHighsSolutionStatusNone)\n\t{\n\t\treturn m_solution.rowvalue[row];\n\t}\n\tthrow std::runtime_error(\"No solution available\");\n}\n\ndouble POIHighsModel::get_constraint_dual(const ConstraintIndex &constraint)\n{\n\tauto row = _checked_constraint_index(constraint);\n\tif (m_solution.primal_solution_status != kHighsSolutionStatusNone)\n\t{\n\t\treturn m_solution.rowdual[row];\n\t}\n\tthrow std::runtime_error(\"No solution available\");\n}\n\ndouble POIHighsModel::get_variable_dual(const VariableIndex &variable)\n{\n\tauto col = _checked_variable_index(variable);\n\tif (m_solution.primal_solution_status != kHighsSolutionStatusNone)\n\t{\n\t\treturn m_solution.coldual[col];\n\t}\n\tthrow std::runtime_error(\"No solution available\");\n}\n\nObjectiveSense POIHighsModel::get_obj_sense()\n{\n\tHighsInt obj_sense;\n\tauto error = highs::Highs_getObjectiveSense(m_model.get(), &obj_sense);\n\tcheck_error(error);\n\treturn obj_sense == kHighsObjSenseMinimize ? ObjectiveSense::Minimize\n\t : ObjectiveSense::Maximize;\n}\n\nvoid POIHighsModel::set_obj_sense(ObjectiveSense sense)\n{\n\tauto obj_sense = highs_obj_sense(sense);\n\tauto error = highs::Highs_changeObjectiveSense(m_model.get(), obj_sense);\n\tcheck_error(error);\n}\n\ndouble POIHighsModel::get_obj_value()\n{\n\tdouble obj = highs::Highs_getObjectiveValue(m_model.get());\n\treturn obj;\n}\n\nHighsInt POIHighsModel::_variable_index(const VariableIndex &variable)\n{\n\treturn m_variable_index.get_index(variable.index);\n}\n\nHighsInt POIHighsModel::_checked_variable_index(const VariableIndex &variable)\n{\n\tHighsInt column = _variable_index(variable);\n\tif (column < 0)\n\t{\n\t\tthrow std::runtime_error(\"Variable does not exist\");\n\t}\n\treturn column;\n}\n\nHighsInt POIHighsModel::_constraint_index(const ConstraintIndex &constraint)\n{\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\t\treturn m_linear_constraint_index.get_index(constraint.index);\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n}\n\nHighsInt POIHighsModel::_checked_constraint_index(const ConstraintIndex &constraint)\n{\n\tHighsInt row = _constraint_index(constraint);\n\tif (row < 0)\n\t{\n\t\tthrow std::runtime_error(\"Constraint does not exist\");\n\t}\n\treturn row;\n}\n\nvoid POIHighsModel::set_primal_start(const Vector &variables,\n const Vector &values)\n{\n\tif (variables.size() != values.size())\n\t{\n\t\tthrow std::runtime_error(\"Number of variables and values do not match\");\n\t}\n\tint numnz = variables.size();\n\tif (numnz == 0)\n\t\treturn;\n\n\tauto numcol = m_n_variables;\n\tif (numcol == 0)\n\t\treturn;\n\n\tHighsInt _numcol, nz;\n\tstd::vector c(numcol), lb(numcol), ub(numcol);\n\tauto error = highs::Highs_getColsByRange(m_model.get(), 0, numcol - 1, &_numcol, c.data(),\n\t lb.data(), ub.data(), &nz, nullptr, nullptr, nullptr);\n\tstd::vector vals(numcol);\n\tfor (int i = 0; i < numcol; i++)\n\t{\n\t\tdouble L = lb[i];\n\t\tdouble U = ub[i];\n\t\tbool L_inf = L < -kHighsInf + 1.0;\n\t\tbool U_inf = U > kHighsInf - 1.0;\n\n\t\tdouble initial = L;\n\t\tif (L_inf)\n\t\t{\n\t\t\tif (U_inf)\n\t\t\t{\n\t\t\t\tinitial = 0.0;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tinitial = U;\n\t\t\t}\n\t\t}\n\t\tvals[i] = initial;\n\t}\n\n\tfor (auto i = 0; i < variables.size(); i++)\n\t{\n\t\tauto column = _checked_variable_index(variables[i]);\n\t\tvals[column] = values[i];\n\t}\n\terror = highs::Highs_setSolution(m_model.get(), vals.data(), nullptr, nullptr, nullptr);\n\tcheck_error(error);\n}\n\ndouble POIHighsModel::get_normalized_rhs(const ConstraintIndex &constraint)\n{\n\tauto row = _checked_constraint_index(constraint);\n\tHighsInt numrow, nz;\n\tdouble ub, lb;\n\tauto error = highs::Highs_getRowsBySet(m_model.get(), 1, &row, &numrow, &lb, &ub, &nz, nullptr,\n\t nullptr, nullptr);\n\tcheck_error(error);\n\n\tbool lb_inf = lb < -kHighsInf + 1.0;\n\tbool ub_inf = ub > kHighsInf - 1.0;\n\n\tif (!lb_inf)\n\t\treturn lb;\n\tif (!ub_inf)\n\t\treturn ub;\n\n\tthrow std::runtime_error(\"Constraint has no finite bound\");\n}\n\nvoid POIHighsModel::set_normalized_rhs(const ConstraintIndex &constraint, double value)\n{\n\tauto row = _checked_constraint_index(constraint);\n\tHighsInt numrow, nz;\n\tdouble ub, lb;\n\tauto error = highs::Highs_getRowsBySet(m_model.get(), 1, &row, &numrow, &lb, &ub, &nz, nullptr,\n\t nullptr, nullptr);\n\tcheck_error(error);\n\n\tbool lb_inf = lb < -kHighsInf + 1.0;\n\tbool ub_inf = ub > kHighsInf - 1.0;\n\n\tif (!lb_inf)\n\t\tlb = value;\n\tif (!ub_inf)\n\t\tub = value;\n\tif (lb_inf && ub_inf)\n\t{\n\t\tthrow std::runtime_error(\"Constraint has no finite bound\");\n\t}\n\n\terror = highs::Highs_changeRowsBoundsBySet(m_model.get(), 1, &row, &lb, &ub);\n\tcheck_error(error);\n}\n\ndouble POIHighsModel::get_normalized_coefficient(const ConstraintIndex &constraint,\n const VariableIndex &variable)\n{\n\tauto row = _checked_constraint_index(constraint);\n\tHighsInt numrow, nz;\n\tdouble ub, lb;\n\tauto error = highs::Highs_getRowsBySet(m_model.get(), 1, &row, &numrow, &lb, &ub, &nz, nullptr,\n\t nullptr, nullptr);\n\tcheck_error(error);\n\n\tstd::vector matrix_start(nz);\n\tstd::vector matrix_index(nz);\n\tstd::vector matrix_value(nz);\n\n\terror =\n\t highs::Highs_getRowsBySet(m_model.get(), 1, &row, &numrow, &lb, &ub, &nz,\n\t matrix_start.data(), matrix_index.data(), matrix_value.data());\n\tcheck_error(error);\n\n\tdouble coef = 0.0;\n\tauto col = _checked_variable_index(variable);\n\tfor (auto i = 0; i < nz; i++)\n\t{\n\t\tif (matrix_index[i] == col)\n\t\t{\n\t\t\tcoef = matrix_value[i];\n\t\t\tbreak;\n\t\t}\n\t}\n\treturn coef;\n}\n\nvoid POIHighsModel::set_normalized_coefficient(const ConstraintIndex &constraint,\n const VariableIndex &variable, double value)\n{\n\tauto row = _checked_constraint_index(constraint);\n\tauto col = _checked_variable_index(variable);\n\tauto error = highs::Highs_changeCoeff(m_model.get(), row, col, value);\n\tcheck_error(error);\n}\n\ndouble POIHighsModel::get_objective_coefficient(const VariableIndex &variable)\n{\n\tauto column = _checked_variable_index(variable);\n\tHighsInt numcol, nz;\n\tdouble c, lb, ub;\n\tauto error = highs::Highs_getColsBySet(m_model.get(), 1, &column, &numcol, &c, &lb, &ub, &nz,\n\t nullptr, nullptr, nullptr);\n\tcheck_error(error);\n\treturn c;\n}\n\nvoid POIHighsModel::set_objective_coefficient(const VariableIndex &variable, double value)\n{\n\tauto column = _checked_variable_index(variable);\n\tauto error = highs::Highs_changeColCost(m_model.get(), column, value);\n\tcheck_error(error);\n}\n" }, { "path": "lib/highs_model_ext.cpp", "content": "#include \n#include \n#include \n#include \n\n#include \"pyoptinterface/highs_model.hpp\"\n\nnamespace nb = nanobind;\n\nextern void bind_highs_constants(nb::module_ &m);\n\nNB_MODULE(highs_model_ext, m)\n{\n\tm.import_(\"pyoptinterface._src.core_ext\");\n\n\tm.def(\"is_library_loaded\", &highs::is_library_loaded);\n\tm.def(\"load_library\", &highs::load_library);\n\n\tbind_highs_constants(m);\n\n\tnb::enum_(m, \"HighsSolutionStatus\")\n\t .value(\"OPTIMIZE_NOT_CALLED\", HighsSolutionStatus::OPTIMIZE_NOT_CALLED)\n\t .value(\"OPTIMIZE_OK\", HighsSolutionStatus::OPTIMIZE_OK)\n\t .value(\"OPTIMIZE_ERROR\", HighsSolutionStatus::OPTIMIZE_ERROR);\n\n\tnb::class_(m, \"HighsSolution\")\n\t .def_ro(\"status\", &POIHighsSolution::status)\n\t .def_ro(\"model_status\", &POIHighsSolution::model_status)\n\t .def_ro(\"primal_solution_status\", &POIHighsSolution::primal_solution_status)\n\t .def_ro(\"dual_solution_status\", &POIHighsSolution::dual_solution_status)\n\t .def_ro(\"has_primal_ray\", &POIHighsSolution::has_primal_ray)\n\t .def_ro(\"has_dual_ray\", &POIHighsSolution::has_dual_ray);\n\n\tusing HighsModel = POIHighsModel;\n\n#define BIND_F(f) .def(#f, &HighsModel::f)\n\tnb::class_(m, \"RawModel\")\n\t .def(nb::init<>())\n\t .def_ro(\"m_n_variables\", &HighsModel::m_n_variables)\n\t .def_ro(\"m_n_constraints\", &HighsModel::m_n_constraints)\n\t // clang-format off\n\t BIND_F(init)\n\t BIND_F(close)\n\t // clang-format on\n\t .def(\"write\", &HighsModel::write, nb::arg(\"filename\"), nb::arg(\"pretty\") = false)\n\n\t .def_ro(\"solution\", &HighsModel::m_solution)\n\n\t .def(\"add_variable\", &HighsModel::add_variable,\n\t nb::arg(\"domain\") = VariableDomain::Continuous, nb::arg(\"lb\") = -kHighsInf,\n\t nb::arg(\"ub\") = kHighsInf, nb::arg(\"name\") = \"\")\n\t // clang-format off\n\t BIND_F(delete_variable)\n\t BIND_F(delete_variables)\n\t BIND_F(is_variable_active)\n\t // clang-format on\n\t .def(\"set_variable_bounds\", &HighsModel::set_variable_bounds, nb::arg(\"variable\"),\n\t nb::arg(\"lb\"), nb::arg(\"ub\"))\n\n\t .def(\"get_value\", nb::overload_cast(&HighsModel::get_variable_value))\n\t .def(\"get_value\",\n\t nb::overload_cast(&HighsModel::get_expression_value))\n\t .def(\"get_value\",\n\t nb::overload_cast(&HighsModel::get_expression_value))\n\t .def(\"get_value\", nb::overload_cast(&HighsModel::get_expression_value))\n\n\t .def(\"pprint\", &HighsModel::pprint_variable)\n\t .def(\"pprint\",\n\t nb::overload_cast(&HighsModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\t .def(\n\t \"pprint\",\n\t nb::overload_cast(&HighsModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\t .def(\"pprint\", nb::overload_cast(&HighsModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\n\t .def(\"_add_linear_constraint\",\n\t nb::overload_cast(\n\t &HighsModel::add_linear_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\",\n\t nb::overload_cast &,\n\t const char *>(&HighsModel::add_linear_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &HighsModel::add_linear_constraint_from_var, nb::arg(\"expr\"),\n\t nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &HighsModel::add_linear_interval_constraint_from_var,\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &HighsModel::add_linear_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &HighsModel::add_linear_interval_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\n\t .def(\"delete_constraint\", &HighsModel::delete_constraint)\n\t .def(\"is_constraint_active\", &HighsModel::is_constraint_active)\n\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &HighsModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &HighsModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(&HighsModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &HighsModel::set_objective_as_variable),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(&HighsModel::set_objective_as_constant),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\n\t .def(\"optimize\", &HighsModel::optimize, nb::call_guard())\n\n\t // clang-format off\n\t BIND_F(version_string)\n\t BIND_F(get_raw_model)\n\n\t\tBIND_F(getruntime)\n\t\tBIND_F(getnumrow)\n\t\tBIND_F(getnumcol)\n\n\t BIND_F(raw_option_type)\n\n\t BIND_F(set_raw_option_bool)\n\t BIND_F(set_raw_option_int)\n\t BIND_F(set_raw_option_double)\n\t BIND_F(set_raw_option_string)\n\t BIND_F(get_raw_option_bool)\n\t BIND_F(get_raw_option_int)\n\t BIND_F(get_raw_option_double)\n\t BIND_F(get_raw_option_string)\n\n\t\tBIND_F(raw_info_type)\n\t BIND_F(get_raw_info_int)\n\t BIND_F(get_raw_info_int64)\n\t BIND_F(get_raw_info_double)\n\n\t BIND_F(set_variable_name)\n\t BIND_F(get_variable_name)\n\t BIND_F(set_variable_type)\n\t BIND_F(get_variable_type)\n\t BIND_F(set_variable_lower_bound)\n\t BIND_F(set_variable_upper_bound)\n\t\tBIND_F(get_variable_lower_bound)\n\t BIND_F(get_variable_upper_bound)\n\n\t\tBIND_F(get_variable_dual)\n\n\t BIND_F(get_constraint_primal)\n\t BIND_F(get_constraint_dual)\n\t BIND_F(get_constraint_name)\n\t BIND_F(set_constraint_name)\n\n\t BIND_F(set_obj_sense)\n\t BIND_F(get_obj_sense)\n\t BIND_F(get_obj_value)\n\n\t\tBIND_F(set_primal_start)\n\n\t\tBIND_F(get_normalized_rhs)\n\t\tBIND_F(set_normalized_rhs)\n\t\tBIND_F(get_normalized_coefficient)\n\t\tBIND_F(set_normalized_coefficient)\n\t\tBIND_F(get_objective_coefficient)\n\t\tBIND_F(set_objective_coefficient)\n\t // clang-format on\n\t ;\n}" }, { "path": "lib/highs_model_ext_constants.cpp", "content": "#include \n#include \"interfaces/highs_c_api.h\"\n\nnamespace nb = nanobind;\n\nvoid bind_highs_constants(nb::module_ &m)\n{\n\tnb::module_ Enum = m.def_submodule(\"Enum\");\n\n#define BIND_C(x) Enum.attr(#x) = x\n\n\tBIND_C(kHighsOptionTypeBool);\n\tBIND_C(kHighsOptionTypeInt);\n\tBIND_C(kHighsOptionTypeDouble);\n\tBIND_C(kHighsOptionTypeString);\n\n\tBIND_C(kHighsInfoTypeInt64);\n\tBIND_C(kHighsInfoTypeInt);\n\tBIND_C(kHighsInfoTypeDouble);\n\n\tBIND_C(kHighsSolutionStatusNone);\n\tBIND_C(kHighsSolutionStatusInfeasible);\n\tBIND_C(kHighsSolutionStatusFeasible);\n\n\tBIND_C(kHighsModelStatusNotset);\n\tBIND_C(kHighsModelStatusLoadError);\n\tBIND_C(kHighsModelStatusModelError);\n\tBIND_C(kHighsModelStatusPresolveError);\n\tBIND_C(kHighsModelStatusSolveError);\n\tBIND_C(kHighsModelStatusPostsolveError);\n\tBIND_C(kHighsModelStatusModelEmpty);\n\tBIND_C(kHighsModelStatusOptimal);\n\tBIND_C(kHighsModelStatusInfeasible);\n\tBIND_C(kHighsModelStatusUnboundedOrInfeasible);\n\tBIND_C(kHighsModelStatusUnbounded);\n\tBIND_C(kHighsModelStatusObjectiveBound);\n\tBIND_C(kHighsModelStatusObjectiveTarget);\n\tBIND_C(kHighsModelStatusTimeLimit);\n\tBIND_C(kHighsModelStatusIterationLimit);\n\tBIND_C(kHighsModelStatusUnknown);\n\tBIND_C(kHighsModelStatusSolutionLimit);\n\tBIND_C(kHighsModelStatusInterrupt);\n}" }, { "path": "lib/ipopt_model.cpp", "content": "#include \"pyoptinterface/ipopt_model.hpp\"\n#include \"pyoptinterface/solver_common.hpp\"\n\n#include \"fmt/core.h\"\n#include \"fmt/ranges.h\"\n#include \"pyoptinterface/dylib.hpp\"\n#include \n\nstatic bool is_name_empty(const char *name)\n{\n\treturn name == nullptr || name[0] == '\\0';\n}\n\nnamespace ipopt\n{\n#define B DYLIB_DECLARE\nAPILIST\n#undef B\n\nstatic DynamicLibrary lib;\nstatic bool is_loaded = false;\n\nbool is_library_loaded()\n{\n\treturn is_loaded;\n}\n\nbool load_library(const std::string &path)\n{\n\tbool success = lib.try_load(path.c_str());\n\tif (!success)\n\t{\n\t\treturn false;\n\t}\n\n\tDYLIB_LOAD_INIT;\n\n#define B DYLIB_LOAD_FUNCTION\n\tAPILIST\n#undef B\n\n\tif (IS_DYLIB_LOAD_SUCCESS)\n\t{\n#define B DYLIB_SAVE_FUNCTION\n\t\tAPILIST\n#undef B\n\t\tis_loaded = true;\n\t\treturn true;\n\t}\n\telse\n\t{\n\t\treturn false;\n\t}\n}\n} // namespace ipopt\n\nIpoptModel::IpoptModel()\n{\n\tif (!ipopt::is_library_loaded())\n\t{\n\t\tthrow std::runtime_error(\"IPOPT library is not loaded\");\n\t}\n}\n\nvoid IpoptModel::close()\n{\n\tm_problem.reset();\n}\n\nVariableIndex IpoptModel::add_variable(double lb, double ub, double start, const char *name)\n{\n\tVariableIndex vi(n_variables);\n\tm_var_lb.push_back(lb);\n\tm_var_ub.push_back(ub);\n\tm_var_init.push_back(start);\n\tn_variables += 1;\n\n\tif (!is_name_empty(name))\n\t{\n\t\tm_var_names.emplace(vi.index, name);\n\t}\n\n\tm_is_dirty = true;\n\n\treturn vi;\n}\n\ndouble IpoptModel::get_variable_lb(const VariableIndex &variable)\n{\n\treturn m_var_lb[variable.index];\n}\n\ndouble IpoptModel::get_variable_ub(const VariableIndex &variable)\n{\n\treturn m_var_ub[variable.index];\n}\n\nvoid IpoptModel::set_variable_lb(const VariableIndex &variable, double lb)\n{\n\tm_var_lb[variable.index] = lb;\n}\n\nvoid IpoptModel::set_variable_ub(const VariableIndex &variable, double ub)\n{\n\tm_var_ub[variable.index] = ub;\n}\n\nvoid IpoptModel::set_variable_bounds(const VariableIndex &variable, double lb, double ub)\n{\n\tm_var_lb[variable.index] = lb;\n\tm_var_ub[variable.index] = ub;\n}\n\ndouble IpoptModel::get_variable_start(const VariableIndex &variable)\n{\n\treturn m_var_init[variable.index];\n}\n\nvoid IpoptModel::set_variable_start(const VariableIndex &variable, double start)\n{\n\tm_var_init[variable.index] = start;\n}\n\ndouble IpoptModel::get_variable_value(const VariableIndex &variable)\n{\n\tif (m_is_dirty)\n\t{\n\t\tthrow std::runtime_error(\n\t\t \"Variable value is not available before optimization. Call optimize() first.\");\n\t}\n\treturn m_result.x[variable.index];\n}\n\nstd::string IpoptModel::get_variable_name(const VariableIndex &variable)\n{\n\tauto iter = m_var_names.find(variable.index);\n\tif (iter != m_var_names.end())\n\t{\n\t\treturn iter->second;\n\t}\n\telse\n\t{\n\t\treturn fmt::format(\"x{}\", variable.index);\n\t}\n}\n\nvoid IpoptModel::set_variable_name(const VariableIndex &variable, const std::string &name)\n{\n\tm_var_names[variable.index] = name;\n}\n\nstd::string IpoptModel::pprint_variable(const VariableIndex &variable)\n{\n\treturn get_variable_name(variable);\n}\n\ndouble IpoptModel::get_obj_value()\n{\n\tif (m_is_dirty)\n\t{\n\t\tthrow std::runtime_error(\n\t\t \"Objective value is not available before optimization. Call optimize() first.\");\n\t}\n\treturn m_result.obj_val;\n}\n\nint IpoptModel::_constraint_internal_index(const ConstraintIndex &constraint)\n{\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\t\treturn constraint.index;\n\tcase ConstraintType::Quadratic:\n\t\treturn m_linear_con_evaluator.n_constraints + constraint.index;\n\tcase ConstraintType::NL: {\n\t\tauto base = m_linear_con_evaluator.n_constraints + m_quadratic_con_evaluator.n_constraints;\n\t\tauto internal_nl_index = nl_constraint_map_ext2int[constraint.index];\n\t\treturn base + internal_nl_index;\n\t}\n\tdefault:\n\t\tthrow std::runtime_error(\"Invalid constraint type\");\n\t}\n}\n\ndouble IpoptModel::get_constraint_primal(const ConstraintIndex &constraint)\n{\n\tif (m_is_dirty)\n\t{\n\t\tthrow std::runtime_error(\n\t\t \"Constraint primal value is not available before optimization. Call optimize() first.\");\n\t}\n\tint index = _constraint_internal_index(constraint);\n\treturn m_result.g[index];\n}\n\ndouble IpoptModel::get_constraint_dual(const ConstraintIndex &constraint)\n{\n\tif (m_is_dirty)\n\t{\n\t\tthrow std::runtime_error(\n\t\t \"Constraint dual value is not available before optimization. Call optimize() first.\");\n\t}\n\tint index = _constraint_internal_index(constraint);\n\tauto dual = -m_result.mult_g[index];\n\treturn dual;\n}\n\nConstraintIndex IpoptModel::add_linear_constraint(const ScalarAffineFunction &f,\n ConstraintSense sense, double rhs,\n const char *name)\n{\n\tdouble lb = -INFINITY;\n\tdouble ub = INFINITY;\n\tif (sense == ConstraintSense::LessEqual)\n\t{\n\t\tub = rhs;\n\t}\n\telse if (sense == ConstraintSense::GreaterEqual)\n\t{\n\t\tlb = rhs;\n\t}\n\telse if (sense == ConstraintSense::Equal)\n\t{\n\t\tlb = rhs;\n\t\tub = rhs;\n\t}\n\treturn add_linear_constraint(f, {lb, ub}, name);\n}\n\nConstraintIndex IpoptModel::add_linear_constraint(const ScalarAffineFunction &f,\n const std::tuple &interval,\n const char *name)\n{\n\tConstraintIndex con(ConstraintType::Linear, m_linear_con_evaluator.n_constraints);\n\tm_linear_con_evaluator.add_row(f);\n\n\tauto lb = std::get<0>(interval);\n\tauto ub = std::get<1>(interval);\n\tm_linear_con_lb.push_back(lb);\n\tm_linear_con_ub.push_back(ub);\n\n\tm_is_dirty = true;\n\n\treturn con;\n}\n\nConstraintIndex IpoptModel::add_quadratic_constraint(const ScalarQuadraticFunction &f,\n ConstraintSense sense, double rhs,\n const char *name)\n{\n\tdouble lb = -INFINITY;\n\tdouble ub = INFINITY;\n\tif (sense == ConstraintSense::LessEqual)\n\t{\n\t\tub = rhs;\n\t}\n\telse if (sense == ConstraintSense::GreaterEqual)\n\t{\n\t\tlb = rhs;\n\t}\n\telse if (sense == ConstraintSense::Equal)\n\t{\n\t\tlb = rhs;\n\t\tub = rhs;\n\t}\n\telse\n\t{\n\t\tthrow std::runtime_error(\"'Within' constraint sense must have both LB and UB\");\n\t}\n\treturn add_quadratic_constraint(f, {lb, ub}, name);\n}\n\nConstraintIndex IpoptModel::add_quadratic_constraint(const ScalarQuadraticFunction &f,\n const std::tuple &interval,\n const char *name)\n{\n\tConstraintIndex con(ConstraintType::Quadratic, m_quadratic_con_evaluator.n_constraints);\n\tm_quadratic_con_evaluator.add_row(f);\n\n\tauto lb = std::get<0>(interval);\n\tauto ub = std::get<1>(interval);\n\tm_quadratic_con_lb.push_back(lb);\n\tm_quadratic_con_ub.push_back(ub);\n\n\tm_is_dirty = true;\n\n\treturn con;\n}\n\nvoid IpoptModel::set_objective(const ScalarAffineFunction &expr, ObjectiveSense sense)\n{\n\t_set_linear_objective(expr);\n}\n\nvoid IpoptModel::set_objective(const ScalarQuadraticFunction &expr, ObjectiveSense sense)\n{\n\t_set_quadratic_objective(expr);\n}\n\nvoid IpoptModel::set_objective(const ExprBuilder &expr, ObjectiveSense sense)\n{\n\tauto degree = expr.degree();\n\tif (degree <= 1)\n\t{\n\t\t_set_linear_objective(expr);\n\t}\n\telse if (degree == 2)\n\t{\n\t\t_set_quadratic_objective(expr);\n\t}\n\telse\n\t{\n\t\tthrow std::runtime_error(\"Only linear and quadratic objective is supported\");\n\t}\n\n\tm_is_dirty = true;\n}\n\nvoid IpoptModel::_set_linear_objective(const ScalarAffineFunction &expr)\n{\n\tLinearEvaluator evaluator;\n\tevaluator.add_row(expr);\n\tm_linear_obj_evaluator = evaluator;\n\tm_quadratic_obj_evaluator.reset();\n}\n\nvoid IpoptModel::_set_quadratic_objective(const ScalarQuadraticFunction &expr)\n{\n\tQuadraticEvaluator evaluator;\n\tevaluator.add_row(expr);\n\tm_linear_obj_evaluator.reset();\n\tm_quadratic_obj_evaluator = evaluator;\n}\n\nint IpoptModel::add_graph_index()\n{\n\treturn m_nl_evaluator.add_graph_instance();\n}\n\nvoid IpoptModel::finalize_graph_instance(size_t graph_index, const ExpressionGraph &graph)\n{\n\tm_nl_evaluator.finalize_graph_instance(graph_index, graph);\n}\n\nint IpoptModel::aggregate_nl_constraint_groups()\n{\n\treturn m_nl_evaluator.aggregate_constraint_groups();\n}\n\nint IpoptModel::get_nl_constraint_group_representative(int group_index) const\n{\n\treturn m_nl_evaluator.get_constraint_group_representative(group_index);\n}\n\nint IpoptModel::aggregate_nl_objective_groups()\n{\n\treturn m_nl_evaluator.aggregate_objective_groups();\n}\n\nint IpoptModel::get_nl_objective_group_representative(int group_index) const\n{\n\treturn m_nl_evaluator.get_objective_group_representative(group_index);\n}\n\nvoid IpoptModel::assign_nl_constraint_group_autodiff_structure(\n int group_index, const AutodiffSymbolicStructure &structure)\n{\n\tm_nl_evaluator.assign_constraint_group_autodiff_structure(group_index, structure);\n}\n\nvoid IpoptModel::assign_nl_constraint_group_autodiff_evaluator(\n int group_index, const ConstraintAutodiffEvaluator &evaluator)\n{\n\tm_nl_evaluator.assign_constraint_group_autodiff_evaluator(group_index, evaluator);\n}\n\nvoid IpoptModel::assign_nl_objective_group_autodiff_structure(\n int group_index, const AutodiffSymbolicStructure &structure)\n{\n\tm_nl_evaluator.assign_objective_group_autodiff_structure(group_index, structure);\n}\n\nvoid IpoptModel::assign_nl_objective_group_autodiff_evaluator(\n int group_index, const ObjectiveAutodiffEvaluator &evaluator)\n{\n\tm_nl_evaluator.assign_objective_group_autodiff_evaluator(group_index, evaluator);\n}\n\nConstraintIndex IpoptModel::add_single_nl_constraint(size_t graph_index,\n const ExpressionGraph &graph, double lb,\n double ub)\n{\n\tm_nl_con_lb.push_back(lb);\n\tm_nl_con_ub.push_back(ub);\n\tauto constraint_index = n_nl_constraints;\n\tn_nl_constraints += 1;\n\n\tnl_constraint_graph_memberships.push_back(ConstraintGraphMembership{\n\t .graph = (int)graph_index, .rank = (int)graph.m_constraint_outputs.size() - 1});\n\n\tm_is_dirty = true;\n\n\treturn ConstraintIndex(ConstraintType::NL, constraint_index);\n}\n\nstatic bool eval_f(ipindex n, ipnumber *x, bool new_x, ipnumber *obj_value, UserDataPtr user_data)\n{\n\tIpoptModel &model = *static_cast(user_data);\n\t*obj_value = 0.0;\n\t// fmt::print(\"Before linear and quad objective, obj_value: {}\\n\", *obj_value);\n\tif (model.m_linear_obj_evaluator)\n\t{\n\t\tmodel.m_linear_obj_evaluator->eval_function(x, obj_value);\n\t}\n\telse if (model.m_quadratic_obj_evaluator)\n\t{\n\t\tmodel.m_quadratic_obj_evaluator->eval_function(x, obj_value);\n\t}\n\t// fmt::print(\"After linear and quad objective, obj_value: {}\\n\", *obj_value);\n\n\t// nonlinear part\n\tdouble nl_obj = model.m_nl_evaluator.eval_objective(x);\n\n\t*obj_value += nl_obj;\n\n\treturn true;\n}\n\nstatic bool eval_grad_f(ipindex n, ipnumber *x, bool new_x, ipnumber *grad_f, UserDataPtr user_data)\n{\n\tIpoptModel &model = *static_cast(user_data);\n\tstd::fill(grad_f, grad_f + n, 0.0);\n\n\t// fmt::print(\"Enters eval_grad_f\\n\");\n\n\t// fill sparse_gradient_values\n\tauto &sparse_gradient_values = model.sparse_gradient_values;\n\tstd::fill(sparse_gradient_values.begin(), sparse_gradient_values.end(), 0.0);\n\n\t// analytical part\n\tif (model.m_linear_obj_evaluator)\n\t{\n\t\tmodel.m_linear_obj_evaluator->eval_jacobian(x, sparse_gradient_values.data());\n\t}\n\telse if (model.m_quadratic_obj_evaluator)\n\t{\n\t\tmodel.m_quadratic_obj_evaluator->eval_jacobian(x, sparse_gradient_values.data());\n\t}\n\n\t// nonlinear part\n\tmodel.m_nl_evaluator.eval_objective_gradient(x, sparse_gradient_values.data());\n\n\t// copy to grad_f\n\tfor (size_t i = 0; i < model.sparse_gradient_indices.size(); i++)\n\t{\n\t\tauto index = model.sparse_gradient_indices[i];\n\t\tauto value = sparse_gradient_values[i];\n\t\tgrad_f[index] += value;\n\t}\n\n\t// debug\n\t/*fmt::print(\"Current x: {}\\n\", std::vector(x, x + n));\n\tfmt::print(\"Current gradient: {}\\n\", std::vector(grad_f, grad_f + n));*/\n\n\treturn true;\n}\n\nstatic bool eval_g(ipindex n, ipnumber *x, bool new_x, ipindex m, ipnumber *g,\n UserDataPtr user_data)\n{\n\tIpoptModel &model = *static_cast(user_data);\n\t// std::fill(g, g + m, 0.0);\n\n\t// fmt::print(\"Enters eval_g\\n\");\n\tauto original_g = g;\n\n\t// linear part\n\tmodel.m_linear_con_evaluator.eval_function(x, g);\n\n\t// quadratic part\n\tg += model.m_linear_con_evaluator.n_constraints;\n\tmodel.m_quadratic_con_evaluator.eval_function(x, g);\n\n\t// nonlinear part\n\tg += model.m_quadratic_con_evaluator.n_constraints;\n\tmodel.m_nl_evaluator.eval_constraints(x, g);\n\n\t// debug\n\t/*fmt::print(\"Current x: {}\\n\", std::vector(x, x + n));\n\tfmt::print(\"Current g: {}\\n\", std::vector(original_g, original_g + m));*/\n\n\treturn true;\n}\n\nstatic bool eval_jac_g(ipindex n, ipnumber *x, bool new_x, ipindex m, ipindex nele_jac,\n ipindex *iRow, ipindex *jCol, ipnumber *values, UserDataPtr user_data)\n{\n\tIpoptModel &model = *static_cast(user_data);\n\n\t// fmt::print(\"Enters eval_jac_g\\n\");\n\n\tif (iRow != nullptr)\n\t{\n\t\tauto &rows = model.m_jacobian_rows;\n\t\tauto &cols = model.m_jacobian_cols;\n\t\tstd::copy(rows.begin(), rows.end(), iRow);\n\t\tstd::copy(cols.begin(), cols.end(), jCol);\n\t}\n\telse\n\t{\n\t\t// std::fill(values, values + nele_jac, 0.0);\n\t\tauto original_jacobian = values;\n\n\t\t// fmt::print(\"Initial jacobian: {}\\n\", std::vector(values, values + nele_jac));\n\n\t\t// linear part\n\t\tmodel.m_linear_con_evaluator.eval_jacobian(x, values);\n\n\t\t// quadratic part\n\t\t/*fmt::print(\"jacobian forwards {} for linear part\\n\",\n\t\t model.m_linear_con_evaluator.coefs.size());*/\n\t\tvalues += model.m_linear_con_evaluator.coefs.size();\n\t\tmodel.m_quadratic_con_evaluator.eval_jacobian(x, values);\n\n\t\t// nonlinear part\n\t\t/*fmt::print(\"jacobian forwards {} for quadratic part\\n\",\n\t\t model.m_quadratic_con_evaluator.jacobian_nnz);*/\n\t\tvalues += model.m_quadratic_con_evaluator.jacobian_nnz;\n\t\tmodel.m_nl_evaluator.eval_constraints_jacobian(x, values);\n\n\t\t// debug\n\t\t/*fmt::print(\"Current x: {}\\n\", std::vector(x, x + n));\n\t\tfmt::print(\"Current jacobian: {}\\n\",\n\t\t std::vector(original_jacobian, original_jacobian + nele_jac));*/\n\t}\n\treturn true;\n}\n\nstatic bool eval_h(ipindex n, ipnumber *x, bool new_x, ipnumber obj_factor, ipindex m,\n ipnumber *lambda, bool new_lambda, ipindex nele_hess, ipindex *iRow,\n ipindex *jCol, ipnumber *values, UserDataPtr user_data)\n{\n\tIpoptModel &model = *static_cast(user_data);\n\n\t// fmt::print(\"Enters eval_h\\n\");\n\n\tif (iRow != nullptr)\n\t{\n\t\tauto &rows = model.m_hessian_rows;\n\t\tauto &cols = model.m_hessian_cols;\n\t\tstd::copy(rows.begin(), rows.end(), iRow);\n\t\tstd::copy(cols.begin(), cols.end(), jCol);\n\t}\n\telse\n\t{\n\t\tstd::fill(values, values + nele_hess, 0.0);\n\n\t\t// objective\n\n\t\t// quadratic part\n\t\tif (model.m_quadratic_obj_evaluator)\n\t\t{\n\t\t\tmodel.m_quadratic_obj_evaluator->eval_lagrangian_hessian(&obj_factor, values);\n\t\t}\n\n\t\t// constraint\n\n\t\t// quadratic part\n\t\tlambda += model.m_linear_con_evaluator.n_constraints;\n\t\tmodel.m_quadratic_con_evaluator.eval_lagrangian_hessian(lambda, values);\n\n\t\t// nonlinear part\n\t\tlambda += model.m_quadratic_con_evaluator.n_constraints;\n\t\tmodel.m_nl_evaluator.eval_lagrangian_hessian(x, lambda, obj_factor, values);\n\n\t\t// debug\n\t\t/*fmt::print(\"Current x: {}\\n\", std::vector(x, x + n));\n\t\tfmt::print(\"Current obj_factor: {}\\n\", obj_factor);\n\t\tfmt::print(\"Current lambda: {}\\n\", std::vector(lambda, lambda + m));\n\t\tfmt::print(\"Current hessian: {}\\n\", std::vector(values, values + nele_hess));*/\n\t}\n\treturn true;\n}\n\nvoid IpoptModel::analyze_structure()\n{\n\t// init variables\n\tm_jacobian_nnz = 0;\n\tm_jacobian_rows.clear();\n\tm_jacobian_cols.clear();\n\tm_hessian_nnz = 0;\n\tm_hessian_rows.clear();\n\tm_hessian_cols.clear();\n\tm_hessian_index_map.clear();\n\n\t// constraints\n\n\t// analyze linear part\n\tm_linear_con_evaluator.analyze_jacobian_structure(m_jacobian_nnz, m_jacobian_rows,\n\t m_jacobian_cols);\n\n\t// analyze quadratic part\n\tm_quadratic_con_evaluator.analyze_jacobian_structure(\n\t m_linear_con_evaluator.n_constraints, m_jacobian_nnz, m_jacobian_rows, m_jacobian_cols);\n\tm_quadratic_con_evaluator.analyze_hessian_structure(m_hessian_nnz, m_hessian_rows,\n\t m_hessian_cols, m_hessian_index_map,\n\t HessianSparsityType::Lower);\n\n\t// objective\n\tsparse_gradient_indices.clear();\n\tsparse_gradient_values.clear();\n\tHashmap sparse_gradient_map;\n\n\t// linear and quadratic objective\n\tif (m_linear_obj_evaluator)\n\t{\n\t\tauto &evaluator = m_linear_obj_evaluator.value();\n\t\tsparse_gradient_indices.insert(sparse_gradient_indices.end(), evaluator.indices.begin(),\n\t\t evaluator.indices.end());\n\t}\n\telse if (m_quadratic_obj_evaluator)\n\t{\n\t\tauto &evaluator = m_quadratic_obj_evaluator.value();\n\t\tsparse_gradient_indices.insert(sparse_gradient_indices.end(),\n\t\t evaluator.jacobian_variable_indices.begin(),\n\t\t evaluator.jacobian_variable_indices.end());\n\t\tevaluator.analyze_hessian_structure(m_hessian_nnz, m_hessian_rows, m_hessian_cols,\n\t\t m_hessian_index_map, HessianSparsityType::Lower);\n\t}\n\t// update map\n\tfor (int i = 0; i < sparse_gradient_indices.size(); i++)\n\t{\n\t\tauto index = sparse_gradient_indices[i];\n\t\tsparse_gradient_map.emplace(index, i);\n\t}\n\n\t// analyze nonlinear constraints and objectives\n\t{\n\t\tauto &evaluator = m_nl_evaluator;\n\n\t\tauto constraint_counter =\n\t\t m_linear_con_evaluator.n_constraints + m_quadratic_con_evaluator.n_constraints;\n\t\tevaluator.analyze_constraints_jacobian_structure(constraint_counter, m_jacobian_nnz,\n\t\t m_jacobian_rows, m_jacobian_cols);\n\t\tevaluator.analyze_objective_gradient_structure(sparse_gradient_indices,\n\t\t sparse_gradient_map);\n\t\tevaluator.analyze_constraints_hessian_structure(m_hessian_nnz, m_hessian_rows,\n\t\t m_hessian_cols, m_hessian_index_map,\n\t\t HessianSparsityType::Lower);\n\t\tevaluator.analyze_objective_hessian_structure(m_hessian_nnz, m_hessian_rows, m_hessian_cols,\n\t\t m_hessian_index_map,\n\t\t HessianSparsityType::Lower);\n\t}\n\n\tsparse_gradient_values.resize(sparse_gradient_indices.size());\n\n\t// update the mapping of nl constraint\n\tnl_constraint_map_ext2int.resize(n_nl_constraints);\n\tm_nl_evaluator.calculate_constraint_graph_instances_offset();\n\tfor (int i = 0; i < n_nl_constraints; i++)\n\t{\n\t\tauto i_nl_con = i;\n\t\tauto i_graph_instance = nl_constraint_graph_memberships[i].graph;\n\t\tauto i_graph_rank = nl_constraint_graph_memberships[i].rank;\n\n\t\tauto index_base = m_nl_evaluator.constraint_indices_offsets[i_graph_instance];\n\n\t\tnl_constraint_map_ext2int[i_nl_con] = index_base + i_graph_rank;\n\t}\n\n\t// construct the lower bound and upper bound of the constraints\n\tauto n_constraints = m_linear_con_evaluator.n_constraints +\n\t m_quadratic_con_evaluator.n_constraints + n_nl_constraints;\n\tm_con_lb.resize(n_constraints);\n\tm_con_ub.resize(n_constraints);\n\tstd::copy(m_linear_con_lb.begin(), m_linear_con_lb.end(), m_con_lb.begin());\n\tstd::copy(m_linear_con_ub.begin(), m_linear_con_ub.end(), m_con_ub.begin());\n\tstd::copy(m_quadratic_con_lb.begin(), m_quadratic_con_lb.end(),\n\t m_con_lb.begin() + m_linear_con_evaluator.n_constraints);\n\tstd::copy(m_quadratic_con_ub.begin(), m_quadratic_con_ub.end(),\n\t m_con_ub.begin() + m_linear_con_evaluator.n_constraints);\n\n\t// nonlinear parts need mapping\n\tauto nl_constraint_start =\n\t m_linear_con_evaluator.n_constraints + m_quadratic_con_evaluator.n_constraints;\n\tfor (int i = 0; i < n_nl_constraints; i++)\n\t{\n\t\tauto index = nl_constraint_map_ext2int[i];\n\t\tm_con_lb[nl_constraint_start + index] = m_nl_con_lb[i];\n\t\tm_con_ub[nl_constraint_start + index] = m_nl_con_ub[i];\n\t}\n}\n\nvoid IpoptModel::optimize()\n{\n\tanalyze_structure();\n\n\tauto n_constraints = m_linear_con_evaluator.n_constraints +\n\t m_quadratic_con_evaluator.n_constraints + n_nl_constraints;\n\n\t/*fmt::print(\"Problem has {} variables and {} constraints.\\n\", n_variables, n_constraints);\n\tfmt::print(\"Variable LB: {}\\n\", m_var_lb);\n\tfmt::print(\"Variable UB: {}\\n\", m_var_ub);\n\tfmt::print(\"Constraint LB: {}\\n\", m_con_lb);\n\tfmt::print(\"Constraint UB: {}\\n\", m_con_ub);\n\tfmt::print(\"Jacobian has {} nonzeros\\n\", m_jacobian_nnz);\n\tfmt::print(\"Jacobian rows : {}\\n\", m_jacobian_rows);\n\tfmt::print(\"Jacobian cols : {}\\n\", m_jacobian_cols);\n\tfmt::print(\"Hessian has {} nonzeros\\n\", m_hessian_nnz);\n\tfmt::print(\"Hessian rows : {}\\n\", m_hessian_rows);\n\tfmt::print(\"Hessian cols : {}\\n\", m_hessian_cols);*/\n\n\t/*if (m_quadratic_obj_evaluator)\n\t{\n\t auto &evaluator = m_quadratic_obj_evaluator.value();\n\t fmt::print(\"Diag coefs : {}\\n\", evaluator.diag_coefs);\n\t fmt::print(\"Diag indices : {}\\n\", evaluator.diag_indices);\n\t fmt::print(\"Diag intervals : {}\\n\", evaluator.diag_intervals);\n\t fmt::print(\"OffDiag coefs : {}\\n\", evaluator.offdiag_coefs);\n\t fmt::print(\"OffDiag rows : {}\\n\", evaluator.offdiag_rows);\n\t fmt::print(\"OffDiag cols : {}\\n\", evaluator.offdiag_cols);\n\t fmt::print(\"OffDiag intervals : {}\\n\", evaluator.offdiag_intervals);\n\t fmt::print(\"hessian_diag_indices : {}\\n\", evaluator.hessian_diag_indices);\n\t fmt::print(\"hessian_offdiag_indices : {}\\n\", evaluator.hessian_offdiag_indices);\n\t}\n\n\t{\n\t auto &evaluator = m_quadratic_con_evaluator;\n\t fmt::print(\"Diag coefs : {}\\n\", evaluator.diag_coefs);\n\t fmt::print(\"Diag indices : {}\\n\", evaluator.diag_indices);\n\t fmt::print(\"Diag intervals : {}\\n\", evaluator.diag_intervals);\n\t fmt::print(\"OffDiag coefs : {}\\n\", evaluator.offdiag_coefs);\n\t fmt::print(\"OffDiag rows : {}\\n\", evaluator.offdiag_rows);\n\t fmt::print(\"OffDiag cols : {}\\n\", evaluator.offdiag_cols);\n\t fmt::print(\"OffDiag intervals : {}\\n\", evaluator.offdiag_intervals);\n\t fmt::print(\"hessian_diag_indices : {}\\n\", evaluator.hessian_diag_indices);\n\t fmt::print(\"hessian_offdiag_indices : {}\\n\", evaluator.hessian_offdiag_indices);\n\t}*/\n\n\tauto problem_ptr =\n\t ipopt::CreateIpoptProblem(n_variables, m_var_lb.data(), m_var_ub.data(), n_constraints,\n\t m_con_lb.data(), m_con_ub.data(), m_jacobian_nnz, m_hessian_nnz,\n\t 0, &eval_f, &eval_g, &eval_grad_f, &eval_jac_g, &eval_h);\n\n\tm_problem = std::unique_ptr(problem_ptr);\n\n\t// set options\n\tfor (auto &[key, value] : m_options_int)\n\t{\n\t\tbool ret = ipopt::AddIpoptIntOption(problem_ptr, (char *)key.c_str(), value);\n\t\tif (!ret)\n\t\t{\n\t\t\tfmt::print(\"Failed to set integer option {}\\n\", key);\n\t\t}\n\t}\n\tfor (auto &[key, value] : m_options_num)\n\t{\n\t\tbool ret = ipopt::AddIpoptNumOption(problem_ptr, (char *)key.c_str(), value);\n\t\tif (!ret)\n\t\t{\n\t\t\tfmt::print(\"Failed to set number option {}\\n\", key);\n\t\t}\n\t}\n\tfor (auto &[key, value] : m_options_str)\n\t{\n\t\tbool ret =\n\t\t ipopt::AddIpoptStrOption(problem_ptr, (char *)key.c_str(), (char *)value.c_str());\n\t\tif (!ret)\n\t\t{\n\t\t\tfmt::print(\"Failed to set string option {}\\n\", key);\n\t\t}\n\t}\n\n\t// initialize the solution\n\tm_result.x.resize(n_variables);\n\tstd::copy(m_var_init.begin(), m_var_init.end(), m_result.x.begin());\n\tm_result.mult_x_L.resize(n_variables);\n\tm_result.mult_x_U.resize(n_variables);\n\tm_result.g.resize(n_constraints);\n\tm_result.mult_g.resize(n_constraints);\n\n\tm_status = ipopt::IpoptSolve(problem_ptr, m_result.x.data(), m_result.g.data(),\n\t &m_result.obj_val, m_result.mult_g.data(),\n\t m_result.mult_x_L.data(), m_result.mult_x_U.data(), (void *)this);\n\tm_result.is_valid = true;\n\tm_is_dirty = false;\n}\n\nvoid IpoptModel::load_current_solution()\n{\n\tif (!m_result.is_valid)\n\t{\n\t\tthrow std::runtime_error(\"No valid solution to load\");\n\t}\n\n\tstd::copy(m_result.x.begin(), m_result.x.end(), m_var_init.begin());\n}\n\nvoid IpoptModel::set_raw_option_int(const std::string &name, int value)\n{\n\tm_options_int[name] = value;\n}\n\nvoid IpoptModel::set_raw_option_double(const std::string &name, double value)\n{\n\tm_options_num[name] = value;\n}\n\nvoid IpoptModel::set_raw_option_string(const std::string &name, const std::string &value)\n{\n\tm_options_str[name] = value;\n}\n" }, { "path": "lib/ipopt_model_ext.cpp", "content": "#include \n#include \n#include \n#include \n\nnamespace nb = nanobind;\n\n#include \"pyoptinterface/ipopt_model.hpp\"\n\nNB_MODULE(ipopt_model_ext, m)\n{\n\tm.import_(\"pyoptinterface._src.core_ext\");\n\tm.import_(\"pyoptinterface._src.nleval_ext\");\n\n\tm.def(\"is_library_loaded\", &ipopt::is_library_loaded);\n\tm.def(\"load_library\", &ipopt::load_library);\n\n\tnb::enum_(m, \"ApplicationReturnStatus\")\n\t .value(\"Solve_Succeeded\", ApplicationReturnStatus::Solve_Succeeded)\n\t .value(\"Solved_To_Acceptable_Level\", ApplicationReturnStatus::Solved_To_Acceptable_Level)\n\t .value(\"Infeasible_Problem_Detected\", ApplicationReturnStatus::Infeasible_Problem_Detected)\n\t .value(\"Search_Direction_Becomes_Too_Small\",\n\t ApplicationReturnStatus::Search_Direction_Becomes_Too_Small)\n\t .value(\"Diverging_Iterates\", ApplicationReturnStatus::Diverging_Iterates)\n\t .value(\"User_Requested_Stop\", ApplicationReturnStatus::User_Requested_Stop)\n\t .value(\"Feasible_Point_Found\", ApplicationReturnStatus::Feasible_Point_Found)\n\t .value(\"Maximum_Iterations_Exceeded\", ApplicationReturnStatus::Maximum_Iterations_Exceeded)\n\t .value(\"Restoration_Failed\", ApplicationReturnStatus::Restoration_Failed)\n\t .value(\"Error_In_Step_Computation\", ApplicationReturnStatus::Error_In_Step_Computation)\n\t .value(\"Maximum_CpuTime_Exceeded\", ApplicationReturnStatus::Maximum_CpuTime_Exceeded)\n\t .value(\"Maximum_WallTime_Exceeded\", ApplicationReturnStatus::Maximum_WallTime_Exceeded)\n\t .value(\"Not_Enough_Degrees_Of_Freedom\",\n\t ApplicationReturnStatus::Not_Enough_Degrees_Of_Freedom)\n\t .value(\"Invalid_Problem_Definition\", ApplicationReturnStatus::Invalid_Problem_Definition)\n\t .value(\"Invalid_Option\", ApplicationReturnStatus::Invalid_Option)\n\t .value(\"Invalid_Number_Detected\", ApplicationReturnStatus::Invalid_Number_Detected)\n\t .value(\"Unrecoverable_Exception\", ApplicationReturnStatus::Unrecoverable_Exception)\n\t .value(\"NonIpopt_Exception_Thrown\", ApplicationReturnStatus::NonIpopt_Exception_Thrown)\n\t .value(\"Insufficient_Memory\", ApplicationReturnStatus::Insufficient_Memory)\n\t .value(\"Internal_Error\", ApplicationReturnStatus::Internal_Error);\n\n\tnb::class_(m, \"RawModel\")\n\t .def(nb::init<>())\n\t .def(\"close\", &IpoptModel::close)\n\t .def_ro(\"m_status\", &IpoptModel::m_status)\n\t .def_rw(\"m_is_dirty\", &IpoptModel::m_is_dirty)\n\t .def(\"add_variable\", &IpoptModel::add_variable, nb::arg(\"lb\") = -INFINITY,\n\t nb::arg(\"ub\") = INFINITY, nb::arg(\"start\") = 0.0, nb::arg(\"name\") = \"\")\n\t .def(\"get_variable_lb\", &IpoptModel::get_variable_lb)\n\t .def(\"get_variable_ub\", &IpoptModel::get_variable_ub)\n\t .def(\"set_variable_lb\", &IpoptModel::set_variable_lb)\n\t .def(\"set_variable_ub\", &IpoptModel::set_variable_ub)\n\t .def(\"set_variable_bounds\", &IpoptModel::set_variable_bounds, nb::arg(\"variable\"),\n\t nb::arg(\"lb\"), nb::arg(\"ub\"))\n\n\t .def(\"get_variable_start\", &IpoptModel::get_variable_start)\n\t .def(\"set_variable_start\", &IpoptModel::set_variable_start)\n\n\t .def(\"get_variable_name\", &IpoptModel::get_variable_name)\n\t .def(\"set_variable_name\", &IpoptModel::set_variable_name)\n\n\t .def(\"get_value\", nb::overload_cast(&IpoptModel::get_variable_value))\n\t .def(\"get_value\",\n\t nb::overload_cast(&IpoptModel::get_expression_value))\n\t .def(\"get_value\",\n\t nb::overload_cast(&IpoptModel::get_expression_value))\n\t .def(\"get_value\", nb::overload_cast(&IpoptModel::get_expression_value))\n\n\t .def(\"pprint\", &IpoptModel::pprint_variable)\n\t .def(\"pprint\",\n\t nb::overload_cast(&IpoptModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\t .def(\n\t \"pprint\",\n\t nb::overload_cast(&IpoptModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\t .def(\"pprint\", nb::overload_cast(&IpoptModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\n\t .def(\"get_obj_value\", &IpoptModel::get_obj_value)\n\t .def(\"get_constraint_primal\", &IpoptModel::get_constraint_primal)\n\t .def(\"get_constraint_dual\", &IpoptModel::get_constraint_dual)\n\n\t .def(\"_add_linear_constraint\",\n\t nb::overload_cast(\n\t &IpoptModel::add_linear_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\",\n\t nb::overload_cast &,\n\t const char *>(&IpoptModel::add_linear_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &IpoptModel::add_linear_constraint_from_var, nb::arg(\"expr\"),\n\t nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &IpoptModel::add_linear_interval_constraint_from_var,\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &IpoptModel::add_linear_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &IpoptModel::add_linear_interval_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\n\t .def(\"_add_quadratic_constraint\",\n\t nb::overload_cast(&IpoptModel::add_quadratic_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_quadratic_constraint\",\n\t nb::overload_cast &,\n\t const char *>(&IpoptModel::add_quadratic_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_quadratic_constraint\", &IpoptModel::add_quadratic_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_quadratic_constraint\", &IpoptModel::add_quadratic_interval_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\n\t .def(\"set_objective\", &IpoptModel::set_objective_as_constant, nb::arg(\"expr\"),\n\t nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\", &IpoptModel::set_objective_as_variable, nb::arg(\"expr\"),\n\t nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &IpoptModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &IpoptModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(&IpoptModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\n\t // New API\n\t .def(\"_add_graph_index\", &IpoptModel::add_graph_index)\n\t .def(\"_finalize_graph_instance\", &IpoptModel::finalize_graph_instance)\n\t .def(\"_aggregate_nl_constraint_groups\", &IpoptModel::aggregate_nl_constraint_groups)\n\t .def(\"_get_nl_constraint_group_representative\",\n\t &IpoptModel::get_nl_constraint_group_representative)\n\t .def(\"_aggregate_nl_objective_groups\", &IpoptModel::aggregate_nl_objective_groups)\n\t .def(\"_get_nl_objective_group_representative\",\n\t &IpoptModel::get_nl_objective_group_representative)\n\t .def(\"_assign_nl_constraint_group_autodiff_structure\",\n\t &IpoptModel::assign_nl_constraint_group_autodiff_structure)\n\t .def(\"_assign_nl_constraint_group_autodiff_evaluator\",\n\t &IpoptModel::assign_nl_constraint_group_autodiff_evaluator)\n\t .def(\"_assign_nl_objective_group_autodiff_structure\",\n\t &IpoptModel::assign_nl_objective_group_autodiff_structure)\n\t .def(\"_assign_nl_objective_group_autodiff_evaluator\",\n\t &IpoptModel::assign_nl_objective_group_autodiff_evaluator)\n\n\t .def(\"_add_single_nl_constraint\", &IpoptModel::add_single_nl_constraint)\n\n\t .def(\"_optimize\", &IpoptModel::optimize, nb::call_guard())\n\n\t .def(\"load_current_solution\", &IpoptModel::load_current_solution)\n\n\t .def(\"set_raw_option_int\", &IpoptModel::set_raw_option_int)\n\t .def(\"set_raw_option_double\", &IpoptModel::set_raw_option_double)\n\t .def(\"set_raw_option_string\", &IpoptModel::set_raw_option_string);\n}\n" }, { "path": "lib/knitro_model.cpp", "content": "#include \"pyoptinterface/knitro_model.hpp\"\n#include \"pyoptinterface/solver_common.hpp\"\n\n#include \"fmt/core.h\"\n#include \"fmt/ranges.h\"\n#include \n#include \n#include \n\nnamespace knitro\n{\n#define B DYLIB_DECLARE\nAPILIST\n#undef B\n\nstatic DynamicLibrary lib;\nstatic bool is_loaded = false;\n\nbool is_library_loaded()\n{\n\treturn is_loaded;\n}\n\nbool load_library(const std::string &path)\n{\n\tbool success = lib.try_load(path.c_str());\n\tif (!success)\n\t{\n\t\treturn false;\n\t}\n\n\tDYLIB_LOAD_INIT;\n\n#define B DYLIB_LOAD_FUNCTION\n\tAPILIST\n#undef B\n\n\tif (IS_DYLIB_LOAD_SUCCESS)\n\t{\n#define B DYLIB_SAVE_FUNCTION\n\t\tAPILIST\n#undef B\n\t\tis_loaded = true;\n\t\treturn true;\n\t}\n\telse\n\t{\n\t\treturn false;\n\t}\n}\n\nbool has_valid_license()\n{\n\tif (!is_library_loaded())\n\t{\n\t\tthrow std::runtime_error(\"KNITRO library not loaded\");\n\t}\n\n\tLM_context *lm = nullptr;\n\tint error = KN_checkout_license(&lm);\n\tif (error == 0)\n\t{\n\t\tKN_release_license(&lm);\n\t\treturn true;\n\t}\n\telse\n\t{\n\t\treturn false;\n\t}\n}\n} // namespace knitro\n\nvoid ensure_library_loaded()\n{\n\tif (!knitro::is_library_loaded())\n\t{\n\t\tthrow std::runtime_error(\"KNITRO library not loaded\");\n\t}\n}\n\nKNITROEnv::KNITROEnv(bool empty)\n{\n\tif (!empty)\n\t{\n\t\tstart();\n\t}\n}\n\nvoid KNITROEnv::start()\n{\n\tif (!empty())\n\t{\n\t\treturn;\n\t}\n\tensure_library_loaded();\n\tLM_context *lm = nullptr;\n\tint error = knitro::KN_checkout_license(&lm);\n\t_check_error(error);\n\tm_lm = std::shared_ptr(lm, KNITROFreeLicenseT());\n}\n\nbool KNITROEnv::empty() const\n{\n\treturn m_lm == nullptr;\n}\n\nstd::shared_ptr KNITROEnv::get_lm() const\n{\n\treturn m_lm;\n}\n\nvoid KNITROEnv::close()\n{\n\tm_lm.reset();\n}\n\nvoid KNITROEnv::_check_error(int code) const\n{\n\tknitro_throw(code);\n}\n\nKNITROModel::KNITROModel()\n{\n\tinit();\n}\n\nKNITROModel::KNITROModel(const KNITROEnv &env)\n{\n\tinit(env);\n}\n\nvoid KNITROModel::init()\n{\n\tm_lm.reset();\n\t_init();\n}\n\nvoid KNITROModel::init(const KNITROEnv &env)\n{\n\tif (env.empty())\n\t{\n\t\tthrow std::runtime_error(\"Empty environment provided. Call start()...\");\n\t}\n\tm_lm = env.get_lm();\n\t_init();\n}\n\nvoid KNITROModel::close()\n{\n\t_reset_state();\n\tm_lm.reset();\n}\n\nvoid KNITROModel::_check_error(int code) const\n{\n\tknitro_throw(code);\n}\n\n// Model information\ndouble KNITROModel::get_infinity() const\n{\n\treturn KN_INFINITY;\n}\n\nstd::string KNITROModel::get_solver_name() const\n{\n\treturn std::string(\"KNITRO\");\n}\n\nstd::string KNITROModel::get_release() const\n{\n\tconstexpr int buf_size = 20;\n\tchar release[buf_size];\n\tint error = knitro::KN_get_release(buf_size, release);\n\t_check_error(error);\n\treturn std::string(release);\n}\n\n// Variable functions\nVariableIndex KNITROModel::add_variable(VariableDomain domain, double lb, double ub,\n const char *name)\n{\n\tKNINT indexVar;\n\tint error = knitro::KN_add_var(m_kc.get(), &indexVar);\n\t_check_error(error);\n\n\tVariableIndex variable(indexVar);\n\n\tint var_type = knitro_var_type(domain);\n\t_set_value(knitro::KN_set_var_type, indexVar, var_type);\n\n\tif (var_type == KN_VARTYPE_BINARY)\n\t{\n\t\tlb = (lb < 0.0) ? 0.0 : lb;\n\t\tub = (ub > 1.0) ? 1.0 : ub;\n\t}\n\n\t_set_value(knitro::KN_set_var_lobnd, indexVar, lb);\n\t_set_value(knitro::KN_set_var_upbnd, indexVar, ub);\n\n\tif (!is_name_empty(name))\n\t{\n\t\t_set_value(knitro::KN_set_var_name, indexVar, name);\n\t}\n\n\tm_n_vars++;\n\t_mark_dirty();\n\n\treturn variable;\n}\n\ndouble KNITROModel::get_variable_lb(const VariableIndex &variable) const\n{\n\tKNINT indexVar = _variable_index(variable);\n\treturn _get_value(knitro::KN_get_var_lobnd, indexVar);\n}\n\ndouble KNITROModel::get_variable_ub(const VariableIndex &variable) const\n{\n\tKNINT indexVar = _variable_index(variable);\n\treturn _get_value(knitro::KN_get_var_upbnd, indexVar);\n}\n\nvoid KNITROModel::set_variable_lb(const VariableIndex &variable, double lb)\n{\n\tKNINT indexVar = _variable_index(variable);\n\t_set_value(knitro::KN_set_var_lobnd, indexVar, lb);\n}\n\nvoid KNITROModel::set_variable_ub(const VariableIndex &variable, double ub)\n{\n\tKNINT indexVar = _variable_index(variable);\n\t_set_value(knitro::KN_set_var_upbnd, indexVar, ub);\n}\n\nvoid KNITROModel::set_variable_bounds(const VariableIndex &variable, double lb, double ub)\n{\n\tset_variable_lb(variable, lb);\n\tset_variable_ub(variable, ub);\n}\n\ndouble KNITROModel::get_variable_value(const VariableIndex &variable) const\n{\n\t_check_dirty();\n\tKNINT indexVar = _variable_index(variable);\n\treturn _get_value(knitro::KN_get_var_primal_value, indexVar);\n}\n\nvoid KNITROModel::set_variable_start(const VariableIndex &variable, double start)\n{\n\tKNINT indexVar = _variable_index(variable);\n\t_set_value(knitro::KN_set_var_primal_init_value, indexVar, start);\n}\n\nstd::string KNITROModel::get_variable_name(const VariableIndex &variable) const\n{\n\tKNINT indexVar = _variable_index(variable);\n\treturn _get_name(knitro::KN_get_var_name, indexVar, \"x\");\n}\n\nvoid KNITROModel::set_variable_name(const VariableIndex &variable, const std::string &name)\n{\n\tKNINT indexVar = _variable_index(variable);\n\t_set_value(knitro::KN_set_var_name, indexVar, name.c_str());\n}\n\nvoid KNITROModel::set_variable_domain(const VariableIndex &variable, VariableDomain domain)\n{\n\tKNINT indexVar = _variable_index(variable);\n\tint var_type = knitro_var_type(domain);\n\tdouble lb = -get_infinity();\n\tdouble ub = get_infinity();\n\n\tif (var_type == KN_VARTYPE_BINARY)\n\t{\n\t\tlb = _get_value(knitro::KN_get_var_lobnd, indexVar);\n\t\tub = _get_value(knitro::KN_get_var_upbnd, indexVar);\n\t}\n\n\t_set_value(knitro::KN_set_var_type, indexVar, var_type);\n\n\tif (var_type == KN_VARTYPE_BINARY)\n\t{\n\t\tlb = (lb < 0.0) ? 0.0 : lb;\n\t\tub = (ub > 1.0) ? 1.0 : ub;\n\t\t_set_value(knitro::KN_set_var_lobnd, indexVar, lb);\n\t\t_set_value(knitro::KN_set_var_upbnd, indexVar, ub);\n\t}\n\n\t_mark_dirty();\n}\n\nVariableDomain KNITROModel::get_variable_domain(const VariableIndex &variable) const\n{\n\tKNINT indexVar = _variable_index(variable);\n\tint var_type = _get_value(knitro::KN_get_var_type, indexVar);\n\treturn knitro_variable_domain(var_type);\n}\n\ndouble KNITROModel::get_variable_rc(const VariableIndex &variable) const\n{\n\t_check_dirty();\n\tKNINT indexVar = _variable_index(variable);\n\tdouble dual = _get_value(knitro::KN_get_var_dual_value, indexVar);\n\treturn -dual;\n}\n\nvoid KNITROModel::delete_variable(const VariableIndex &variable)\n{\n\tKNINT indexVar = _variable_index(variable);\n\t_set_value(knitro::KN_set_var_type, indexVar, KN_VARTYPE_CONTINUOUS);\n\t_set_value(knitro::KN_set_var_lobnd, indexVar, -get_infinity());\n\t_set_value(knitro::KN_set_var_upbnd, indexVar, get_infinity());\n\tm_n_vars--;\n\t_mark_dirty();\n}\n\nstd::string KNITROModel::pprint_variable(const VariableIndex &variable) const\n{\n\treturn get_variable_name(variable);\n}\n\n// Constraint functions\nConstraintIndex KNITROModel::add_linear_constraint(const ScalarAffineFunction &function,\n ConstraintSense sense, double rhs,\n const char *name)\n{\n\tauto add = [this](const ScalarAffineFunction &f, const std::tuple &interval,\n\t const char *n) { return add_linear_constraint(f, interval, n); };\n\treturn _add_constraint_with_sense(function, sense, rhs, name, add);\n}\n\nConstraintIndex KNITROModel::add_linear_constraint(const ScalarAffineFunction &function,\n const std::tuple &interval,\n const char *name)\n{\n\tauto setter = [this, &function](const ConstraintIndex &constraint) {\n\t\t_set_linear_constraint(constraint, function);\n\t};\n\treturn _add_constraint_impl(ConstraintType::Linear, interval, name, setter);\n}\n\nConstraintIndex KNITROModel::add_quadratic_constraint(const ScalarQuadraticFunction &function,\n ConstraintSense sense, double rhs,\n const char *name)\n{\n\tauto add = [this](const ScalarQuadraticFunction &f, const std::tuple &interval,\n\t const char *n) { return add_quadratic_constraint(f, interval, n); };\n\treturn _add_constraint_with_sense(function, sense, rhs, name, add);\n}\n\nConstraintIndex KNITROModel::add_quadratic_constraint(const ScalarQuadraticFunction &function,\n const std::tuple &interval,\n const char *name)\n{\n\tauto setter = [this, &function](const ConstraintIndex &constraint) {\n\t\t_set_quadratic_constraint(constraint, function);\n\t};\n\treturn _add_constraint_impl(ConstraintType::Quadratic, interval, name, setter);\n}\n\nConstraintIndex KNITROModel::add_second_order_cone_constraint(\n const Vector &variables, const char *name, bool rotated)\n{\n\n\tif (rotated)\n\t{\n\t\tauto setter = [this, &variables](const ConstraintIndex &constraint) {\n\t\t\t_set_second_order_cone_constraint_rotated(constraint, variables);\n\t\t};\n\t\tstd::pair interval = {0.0, get_infinity()};\n\t\treturn _add_constraint_impl(ConstraintType::SecondOrderCone, interval, name, setter);\n\t}\n\telse\n\t{\n\t\tauto setter = [this, &variables](const ConstraintIndex &constraint) {\n\t\t\t_set_second_order_cone_constraint(constraint, variables);\n\t\t};\n\t\tstd::pair interval = {0.0, get_infinity()};\n\t\treturn _add_constraint_impl(ConstraintType::SecondOrderCone, interval, name, setter);\n\t}\n}\n\nConstraintIndex KNITROModel::add_single_nl_constraint(ExpressionGraph &graph,\n const ExpressionHandle &result,\n const std::tuple &interval,\n const char *name)\n{\n\t_add_graph(graph);\n\tgraph.add_constraint_output(result);\n\tsize_t i = graph.m_constraint_outputs.size() - 1;\n\tm_pending_outputs[&graph].constraint_outputs.push_back(i);\n\tauto setter = [this, &graph](const ConstraintIndex &constraint) {\n\t\tm_pending_outputs[&graph].constraints.push_back(constraint);\n\t\tm_has_pending_callbacks = true;\n\t};\n\treturn _add_constraint_impl(ConstraintType::NL, interval, name, setter);\n}\n\nConstraintIndex KNITROModel::add_single_nl_constraint_sense_rhs(ExpressionGraph &graph,\n const ExpressionHandle &result,\n ConstraintSense sense, double rhs,\n const char *name)\n{\n\tauto add = [this, &graph, &result](void *, const std::tuple &interval,\n\t const char *n) {\n\t\treturn add_single_nl_constraint(graph, result, interval, n);\n\t};\n\treturn _add_constraint_with_sense(nullptr, sense, rhs, name, add);\n}\n\nstd::tuple KNITROModel::_sense_to_interval(ConstraintSense sense, double rhs)\n{\n\tswitch (sense)\n\t{\n\tcase ConstraintSense::LessEqual:\n\t\treturn {-get_infinity(), rhs};\n\tcase ConstraintSense::Equal:\n\t\treturn {rhs, rhs};\n\tcase ConstraintSense::GreaterEqual:\n\t\treturn {rhs, get_infinity()};\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint sense\");\n\t}\n}\n\nvoid KNITROModel::_update_con_sense_flags(const ConstraintIndex &constraint, ConstraintSense sense)\n{\n\tKNINT indexCon = _constraint_index(constraint);\n\tswitch (sense)\n\t{\n\tcase ConstraintSense::Equal:\n\t\tm_con_sense_flags[indexCon] |= CON_LOBND;\n\t\tbreak;\n\tcase ConstraintSense::GreaterEqual:\n\t\tm_con_sense_flags[indexCon] = CON_LOBND;\n\t\tbreak;\n\tdefault:\n\t\tbreak;\n\t}\n}\n\nvoid KNITROModel::_set_second_order_cone_constraint(const ConstraintIndex &constraint,\n const Vector &variables)\n{\n\tKNINT indexCon = _constraint_index(constraint);\n\n\tKNINT indexCon0;\n\tint error = knitro::KN_add_con(m_kc.get(), &indexCon0);\n\t_check_error(error);\n\n\tKNINT indexVar0 = _variable_index(variables[0]);\n\terror = knitro::KN_add_con_linear_term(m_kc.get(), indexCon0, indexVar0, 1.0);\n\t_check_error(error);\n\n\t_set_value(knitro::KN_set_con_lobnd, indexCon0, 0.0);\n\t_set_value(knitro::KN_set_con_upbnd, indexCon0, KN_INFINITY);\n\n\terror = knitro::KN_add_con_quadratic_term(m_kc.get(), indexCon, indexVar0, indexVar0, 1.0);\n\t_check_error(error);\n\tsize_t nnz = variables.size() - 1;\n\tstd::vector indexCons(nnz, indexCon);\n\tstd::vector indexVars(nnz);\n\tfor (size_t i = 0; i < nnz; ++i)\n\t{\n\t\tindexVars[i] = _variable_index(variables[i + 1]);\n\t}\n\tstd::vector coefs(nnz, -1.0);\n\terror = knitro::KN_add_con_quadratic_struct(m_kc.get(), nnz, indexCons.data(), indexVars.data(),\n\t indexVars.data(), coefs.data());\n\t_check_error(error);\n\n\tm_soc_aux_cons[indexCon] = indexCon0;\n}\n\nvoid KNITROModel::_set_second_order_cone_constraint_rotated(const ConstraintIndex &constraint,\n const Vector &variables)\n{\n\tKNINT indexCon = _constraint_index(constraint);\n\n\tKNINT indexCon0, indexCon1;\n\tint error = knitro::KN_add_con(m_kc.get(), &indexCon0);\n\t_check_error(error);\n\terror = knitro::KN_add_con(m_kc.get(), &indexCon1);\n\t_check_error(error);\n\n\tKNINT indexVar0 = _variable_index(variables[0]);\n\tKNINT indexVar1 = _variable_index(variables[1]);\n\terror = knitro::KN_add_con_linear_term(m_kc.get(), indexCon0, indexVar0, 1.0);\n\t_check_error(error);\n\terror = knitro::KN_add_con_linear_term(m_kc.get(), indexCon1, indexVar1, 1.0);\n\t_check_error(error);\n\n\t_set_value(knitro::KN_set_con_lobnd, indexCon0, 0.0);\n\t_set_value(knitro::KN_set_con_upbnd, indexCon0, KN_INFINITY);\n\t_set_value(knitro::KN_set_con_lobnd, indexCon1, 0.0);\n\t_set_value(knitro::KN_set_con_upbnd, indexCon1, KN_INFINITY);\n\n\tsize_t nnz = variables.size() - 2;\n\tstd::vector indexCons(nnz, indexCon);\n\tstd::vector indexVars(nnz);\n\tfor (size_t i = 0; i < nnz; ++i)\n\t{\n\t\tindexVars[i] = _variable_index(variables[i + 2]);\n\t}\n\tstd::vector coefs(nnz, -1.0);\n\terror = knitro::KN_add_con_quadratic_struct(m_kc.get(), nnz, indexCons.data(), indexVars.data(),\n\t indexVars.data(), coefs.data());\n\t_check_error(error);\n\terror = knitro::KN_add_con_quadratic_term(m_kc.get(), indexCon, indexVar0, indexVar1, 2.0);\n\t_check_error(error);\n\n\tm_soc_aux_cons[indexCon] = std::make_pair(indexCon0, indexCon1);\n}\n\nvoid KNITROModel::delete_constraint(const ConstraintIndex &constraint)\n{\n\tKNINT indexCon = _constraint_index(constraint);\n\t_set_value(knitro::KN_set_con_lobnd, indexCon, -get_infinity());\n\t_set_value(knitro::KN_set_con_upbnd, indexCon, get_infinity());\n\n\tm_n_cons_map[constraint.type]--;\n\n\tauto it = m_soc_aux_cons.find(indexCon);\n\tif (it != m_soc_aux_cons.end())\n\t{\n\t\tstd::vector aux_cons;\n\t\tif (std::holds_alternative(it->second))\n\t\t{\n\t\t\taux_cons.push_back(std::get(it->second));\n\t\t}\n\t\telse if (std::holds_alternative>(it->second))\n\t\t{\n\t\t\tauto p = std::get>(it->second);\n\t\t\taux_cons.push_back(p.first);\n\t\t\taux_cons.push_back(p.second);\n\t\t}\n\n\t\tfor (auto const &con : aux_cons)\n\t\t{\n\t\t\t_set_value(knitro::KN_set_con_lobnd, con, -get_infinity());\n\t\t\t_set_value(knitro::KN_set_con_upbnd, con, get_infinity());\n\t\t}\n\n\t\tm_soc_aux_cons.erase(it);\n\t}\n\n\t_mark_dirty();\n}\n\nvoid KNITROModel::set_constraint_name(const ConstraintIndex &constraint, const std::string &name)\n{\n\tKNINT indexCon = _constraint_index(constraint);\n\t_set_value(knitro::KN_set_con_name, indexCon, name.c_str());\n}\n\nstd::string KNITROModel::get_constraint_name(const ConstraintIndex &constraint) const\n{\n\tKNINT indexCon = _constraint_index(constraint);\n\treturn _get_name(knitro::KN_get_con_name, indexCon, \"c\");\n}\n\ndouble KNITROModel::get_constraint_primal(const ConstraintIndex &constraint) const\n{\n\t_check_dirty();\n\tKNINT indexCon = _constraint_index(constraint);\n\treturn _get_value(knitro::KN_get_con_value, indexCon);\n}\n\ndouble KNITROModel::get_constraint_dual(const ConstraintIndex &constraint) const\n{\n\t_check_dirty();\n\tKNINT indexCon = _constraint_index(constraint);\n\tdouble dual = _get_value(knitro::KN_get_con_dual_value, indexCon);\n\treturn -dual;\n}\n\nvoid KNITROModel::set_normalized_rhs(const ConstraintIndex &constraint, double rhs)\n{\n\tKNINT indexCon = _constraint_index(constraint);\n\tauto flag = m_con_sense_flags[indexCon];\n\n\tif (flag & CON_LOBND)\n\t{\n\t\t_set_value(knitro::KN_set_con_lobnd, indexCon, rhs);\n\t}\n\n\tif (flag & CON_UPBND)\n\t{\n\t\t_set_value(knitro::KN_set_con_upbnd, indexCon, rhs);\n\t}\n\n\t_mark_dirty();\n}\n\ndouble KNITROModel::get_normalized_rhs(const ConstraintIndex &constraint) const\n{\n\tKNINT indexCon = _constraint_index(constraint);\n\tauto it = m_con_sense_flags.find(indexCon);\n\tuint8_t flag = (it != m_con_sense_flags.end()) ? it->second : CON_UPBND;\n\tdouble rhs;\n\tif (flag & CON_UPBND)\n\t{\n\t\trhs = _get_value(knitro::KN_get_con_upbnd, indexCon);\n\t}\n\telse\n\t{\n\t\trhs = _get_value(knitro::KN_get_con_lobnd, indexCon);\n\t}\n\treturn rhs;\n}\n\nvoid KNITROModel::set_normalized_coefficient(const ConstraintIndex &constraint,\n const VariableIndex &variable, double coefficient)\n{\n\tKNINT indexCon = _constraint_index(constraint);\n\tKNINT indexVar = _variable_index(variable);\n\n\t// NOTE: To make sure the coefficient is updated correctly,\n\t// we need to call KN_update before changing the linear term\n\t_update();\n\tint error = knitro::KN_chg_con_linear_term(m_kc.get(), indexCon, indexVar, coefficient);\n\t_check_error(error);\n\t_mark_dirty();\n}\n\nvoid KNITROModel::_set_linear_constraint(const ConstraintIndex &constraint,\n const ScalarAffineFunction &function)\n{\n\tKNINT indexCon = _constraint_index(constraint);\n\n\tif (function.constant.has_value())\n\t{\n\t\tdouble constant = function.constant.value();\n\t\tif (constant != 0.0)\n\t\t{\n\t\t\tint error = knitro::KN_add_con_constant(m_kc.get(), indexCon, constant);\n\t\t\t_check_error(error);\n\t\t}\n\t}\n\n\tAffineFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\n\tKNLONG nnz = ptr_form.numnz;\n\tif (nnz > 0)\n\t{\n\t\tstd::vector indexCons(nnz, indexCon);\n\t\tKNINT *indexVars = ptr_form.index;\n\t\tdouble *coefs = ptr_form.value;\n\n\t\tint error =\n\t\t knitro::KN_add_con_linear_struct(m_kc.get(), nnz, indexCons.data(), indexVars, coefs);\n\t\t_check_error(error);\n\t}\n}\n\nvoid KNITROModel::_set_quadratic_constraint(const ConstraintIndex &constraint,\n const ScalarQuadraticFunction &function)\n{\n\tKNINT indexCon = _constraint_index(constraint);\n\n\tif (function.affine_part.has_value())\n\t{\n\t\t_set_linear_constraint(constraint, function.affine_part.value());\n\t}\n\n\tQuadraticFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\tKNLONG nnz = ptr_form.numnz;\n\tif (nnz > 0)\n\t{\n\t\tstd::vector indexCons(nnz, indexCon);\n\t\tKNINT *indexVars1 = ptr_form.row;\n\t\tKNINT *indexVars2 = ptr_form.col;\n\t\tdouble *coefs = ptr_form.value;\n\t\tint error = knitro::KN_add_con_quadratic_struct(m_kc.get(), nnz, indexCons.data(),\n\t\t indexVars1, indexVars2, coefs);\n\t\t_check_error(error);\n\t}\n}\n\n// Objective functions\nvoid KNITROModel::set_objective(const ScalarAffineFunction &function, ObjectiveSense sense)\n{\n\t_set_objective_impl(sense, [this, &function]() { _set_linear_objective(function); });\n}\n\nvoid KNITROModel::set_objective(const ScalarQuadraticFunction &function, ObjectiveSense sense)\n{\n\t_set_objective_impl(sense, [this, &function]() { _set_quadratic_objective(function); });\n}\n\nvoid KNITROModel::set_objective(const ExprBuilder &expr, ObjectiveSense sense)\n{\n\tauto degree = expr.degree();\n\tif (degree <= 1)\n\t{\n\t\tScalarAffineFunction linear(expr);\n\t\tset_objective(linear, sense);\n\t}\n\telse if (degree == 2)\n\t{\n\t\tScalarQuadraticFunction quadratic(expr);\n\t\tset_objective(quadratic, sense);\n\t}\n\telse\n\t{\n\t\tthrow std::runtime_error(\"Objective must be linear or quadratic\");\n\t}\n}\n\nvoid KNITROModel::set_objective_coefficient(const VariableIndex &variable, double coefficient)\n{\n\tKNINT indexVar = _variable_index(variable);\n\t// NOTE: To make sure the coefficient is updated correctly,\n\t// we need to call KN_update before changing the linear term\n\t_update();\n\tint error = knitro::KN_chg_obj_linear_term(m_kc.get(), indexVar, coefficient);\n\t_check_error(error);\n\t_mark_dirty();\n}\n\nvoid KNITROModel::add_single_nl_objective(ExpressionGraph &graph, const ExpressionHandle &result)\n{\n\t_add_graph(graph);\n\tgraph.add_objective_output(result);\n\tsize_t i = graph.m_objective_outputs.size() - 1;\n\tm_pending_outputs[&graph].objective_outputs.push_back(i);\n\tm_has_pending_callbacks = true;\n\tm_obj_flag |= OBJ_NONLINEAR;\n\t_mark_dirty();\n}\n\nvoid KNITROModel::set_obj_sense(ObjectiveSense sense)\n{\n\tint goal = knitro_obj_goal(sense);\n\t_set_value(knitro::KN_set_obj_goal, goal);\n}\n\nObjectiveSense KNITROModel::get_obj_sense() const\n{\n\tint goal = _get_value(knitro::KN_get_obj_goal);\n\treturn knitro_obj_sense(goal);\n}\n\nvoid KNITROModel::_add_graph(ExpressionGraph &graph)\n{\n\tif (m_pending_outputs.find(&graph) == m_pending_outputs.end())\n\t{\n\t\tm_pending_outputs[&graph] = Outputs();\n\t}\n}\n\nvoid KNITROModel::_reset_objective()\n{\n\tif (m_obj_flag & OBJ_CONSTANT)\n\t{\n\t\tint error = knitro::KN_del_obj_constant(m_kc.get());\n\t\t_check_error(error);\n\t}\n\tif (m_obj_flag & OBJ_LINEAR)\n\t{\n\t\tint error = knitro::KN_del_obj_linear_struct_all(m_kc.get());\n\t\t_check_error(error);\n\t}\n\tif (m_obj_flag & OBJ_QUADRATIC)\n\t{\n\t\tint error = knitro::KN_del_obj_quadratic_struct_all(m_kc.get());\n\t\t_check_error(error);\n\t}\n\tif (m_obj_flag & OBJ_NONLINEAR)\n\t{\n\t\tint error = knitro::KN_del_obj_eval_callback_all(m_kc.get());\n\t\t_check_error(error);\n\t\tfor (auto &[graph, outputs] : m_pending_outputs)\n\t\t{\n\t\t\toutputs.objective_outputs.clear();\n\t\t}\n\t}\n\tm_obj_flag = 0;\n\t_update();\n}\n\nvoid KNITROModel::_set_linear_objective(const ScalarAffineFunction &function)\n{\n\tif (function.constant.has_value())\n\t{\n\t\tdouble constant = function.constant.value();\n\t\tif (constant != 0.0)\n\t\t{\n\t\t\tint error = knitro::KN_add_obj_constant(m_kc.get(), constant);\n\t\t\t_check_error(error);\n\t\t\tm_obj_flag |= OBJ_CONSTANT;\n\t\t}\n\t}\n\n\tAffineFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\tKNLONG nnz = ptr_form.numnz;\n\tif (nnz > 0)\n\t{\n\t\tKNINT *indexVars = ptr_form.index;\n\t\tdouble *coefs = ptr_form.value;\n\t\tint error = knitro::KN_add_obj_linear_struct(m_kc.get(), nnz, indexVars, coefs);\n\t\t_check_error(error);\n\t\tm_obj_flag |= OBJ_LINEAR;\n\t}\n}\n\nvoid KNITROModel::_set_quadratic_objective(const ScalarQuadraticFunction &function)\n{\n\tif (function.affine_part.has_value())\n\t{\n\t\t_set_linear_objective(function.affine_part.value());\n\t}\n\n\tQuadraticFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\tKNLONG nnz = ptr_form.numnz;\n\tif (nnz > 0)\n\t{\n\t\tKNINT *indexVars1 = ptr_form.row;\n\t\tKNINT *indexVars2 = ptr_form.col;\n\t\tdouble *coefs = ptr_form.value;\n\t\tint error =\n\t\t knitro::KN_add_obj_quadratic_struct(m_kc.get(), nnz, indexVars1, indexVars2, coefs);\n\t\t_check_error(error);\n\t\tm_obj_flag |= OBJ_QUADRATIC;\n\t}\n}\n\ndouble KNITROModel::get_obj_value() const\n{\n\t_check_dirty();\n\treturn _get_value(knitro::KN_get_obj_value);\n}\n\nvoid KNITROModel::_register_callback(Evaluator *evaluator)\n{\n\tauto f = [](KN_context *, CB_context *cb, KN_eval_request *req, KN_eval_result *res,\n\t void *data) -> int {\n\t\tauto evaluator = static_cast(data);\n\t\tif (evaluator->is_objective())\n\t\t{\n\t\t\tevaluator->eval_fun(req->x, res->obj);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tevaluator->eval_fun(req->x, res->c);\n\t\t}\n\t\treturn 0;\n\t};\n\n\tauto g = [](KN_context *, CB_context *cb, KN_eval_request *req, KN_eval_result *res,\n\t void *data) -> int {\n\t\tauto evaluator = static_cast(data);\n\t\tif (evaluator->is_objective())\n\t\t{\n\t\t\tevaluator->eval_jac(req->x, res->objGrad);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tevaluator->eval_jac(req->x, res->jac);\n\t\t}\n\t\treturn 0;\n\t};\n\n\tauto h = [](KN_context *, CB_context *cb, KN_eval_request *req, KN_eval_result *res,\n\t void *data) -> int {\n\t\tauto evaluator = static_cast(data);\n\t\tif (evaluator->is_objective())\n\t\t{\n\t\t\tevaluator->eval_hess(req->x, req->sigma, res->hess);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tevaluator->eval_hess(req->x, req->lambda, res->hess);\n\t\t}\n\t\treturn 0;\n\t};\n\n\tCB_context *cb = nullptr;\n\tauto p = evaluator->get_callback_pattern();\n\tint error;\n\terror = knitro::KN_add_eval_callback(m_kc.get(), p.indexCons.empty(), p.indexCons.size(),\n\t p.indexCons.data(), f, &cb);\n\t_check_error(error);\n\terror = knitro::KN_set_cb_user_params(m_kc.get(), cb, evaluator);\n\t_check_error(error);\n\terror = knitro::KN_set_cb_grad(m_kc.get(), cb, p.objGradIndexVars.size(),\n\t p.objGradIndexVars.data(), p.jacIndexCons.size(),\n\t p.jacIndexCons.data(), p.jacIndexVars.data(), g);\n\t_check_error(error);\n\terror = knitro::KN_set_cb_hess(m_kc.get(), cb, p.hessIndexVars1.size(), p.hessIndexVars1.data(),\n\t p.hessIndexVars2.data(), h);\n\t_check_error(error);\n}\n\nvoid KNITROModel::_add_callback(const ExpressionGraph &graph, const std::vector &outputs,\n const std::vector &constraints)\n{\n\tauto evaluator_ptr = std::make_unique();\n\tauto *evaluator = evaluator_ptr.get();\n\tevaluator->indexVars.resize(graph.n_variables());\n\tfor (size_t i = 0; i < graph.n_variables(); i++)\n\t{\n\t\tevaluator->indexVars[i] = _variable_index(graph.m_variables[i]);\n\t}\n\tevaluator->indexCons.resize(constraints.size());\n\tfor (size_t i = 0; i < constraints.size(); i++)\n\t{\n\t\tevaluator->indexCons[i] = _constraint_index(constraints[i]);\n\t}\n\tif (evaluator->is_objective())\n\t{\n\t\tevaluator->fun = cppad_trace_graph_objective(graph, outputs, true);\n\t}\n\telse\n\t{\n\t\tevaluator->fun = cppad_trace_graph_constraints(graph, outputs);\n\t}\n\tevaluator->setup();\n\t_register_callback(evaluator);\n\tm_evaluators.push_back(std::move(evaluator_ptr));\n}\n\nvoid KNITROModel::_add_callbacks(const ExpressionGraph &graph, const Outputs &outputs)\n{\n\tif (graph.has_constraint_output() && !outputs.constraint_outputs.empty())\n\t{\n\t\t_add_callback(graph, outputs.constraint_outputs, outputs.constraints);\n\t}\n\n\tif (graph.has_objective_output() && !outputs.objective_outputs.empty())\n\t{\n\t\t_add_callback(graph, outputs.objective_outputs, {});\n\t}\n}\n\nvoid KNITROModel::_add_pending_callbacks()\n{\n\tif (!m_has_pending_callbacks)\n\t{\n\t\treturn;\n\t}\n\n\tfor (const auto &[graph, outputs] : m_pending_outputs)\n\t{\n\t\t_add_callbacks(*graph, outputs);\n\t}\n\n\tm_pending_outputs.clear();\n\tm_has_pending_callbacks = false;\n}\n\n// Solve functions\nvoid KNITROModel::_update()\n{\n\t_add_pending_callbacks();\n\tint error = knitro::KN_update(m_kc.get());\n\t_check_error(error);\n}\n\nvoid KNITROModel::_pre_solve()\n{\n\t_add_pending_callbacks();\n}\n\nvoid KNITROModel::_solve()\n{\n\tm_solve_status = knitro::KN_solve(m_kc.get());\n}\n\nvoid KNITROModel::_post_solve()\n{\n}\n\nvoid KNITROModel::optimize()\n{\n\t_pre_solve();\n\t_solve();\n\t_post_solve();\n\t_unmark_dirty();\n}\n\n// Solve information\nsize_t KNITROModel::get_number_iterations() const\n{\n\t_check_dirty();\n\tint iters = _get_value(knitro::KN_get_number_iters);\n\treturn static_cast(iters);\n}\n\nsize_t KNITROModel::get_mip_node_count() const\n{\n\t_check_dirty();\n\tint nodes = _get_value(knitro::KN_get_mip_number_nodes);\n\treturn static_cast(nodes);\n}\n\ndouble KNITROModel::get_obj_bound() const\n{\n\t_check_dirty();\n\treturn _get_value(knitro::KN_get_mip_relaxation_bnd);\n}\n\ndouble KNITROModel::get_mip_relative_gap() const\n{\n\t_check_dirty();\n\treturn _get_value(knitro::KN_get_mip_rel_gap);\n}\n\ndouble KNITROModel::get_solve_time() const\n{\n\t_check_dirty();\n\treturn _get_value(knitro::KN_get_solve_time_real);\n}\n\n// Dirty state management\nvoid KNITROModel::_mark_dirty()\n{\n\tm_is_dirty = true;\n}\n\nvoid KNITROModel::_unmark_dirty()\n{\n\tm_is_dirty = false;\n}\n\nbool KNITROModel::dirty() const\n{\n\treturn m_is_dirty;\n}\n\n// Model state\nbool KNITROModel::empty() const\n{\n\treturn m_kc == nullptr;\n}\n\nsize_t KNITROModel::get_num_vars() const\n{\n\treturn m_n_vars;\n}\n\nsize_t KNITROModel::get_num_cons(std::optional type) const\n{\n\tif (!type.has_value())\n\t{\n\t\tsize_t total = 0;\n\t\tfor (const auto &[_, count] : m_n_cons_map)\n\t\t{\n\t\t\ttotal += count;\n\t\t}\n\t\treturn total;\n\t}\n\telse\n\t{\n\t\tauto it = m_n_cons_map.find(type.value());\n\t\treturn it != m_n_cons_map.end() ? it->second : 0;\n\t}\n}\n\nint KNITROModel::get_solve_status() const\n{\n\t_check_dirty();\n\treturn m_solve_status;\n}\n\n// Internal helpers\nvoid KNITROModel::_check_dirty() const\n{\n\tif (dirty())\n\t{\n\t\tthrow std::runtime_error(\"Model has been modified since last solve. Call optimize()...\");\n\t}\n}\n\nvoid KNITROModel::_reset_state()\n{\n\tm_kc.reset();\n\tm_n_vars = 0;\n\tm_n_cons_map.clear();\n\tm_soc_aux_cons.clear();\n\tm_con_sense_flags.clear();\n\tm_obj_flag = 0;\n\tm_pending_outputs.clear();\n\tm_evaluators.clear();\n\tm_has_pending_callbacks = false;\n\t_mark_dirty();\n\tm_solve_status = 0;\n}\n\nvoid KNITROModel::_init()\n{\n\tensure_library_loaded();\n\t_reset_state();\n\n\t// Create new KNITRO problem\n\tKN_context *kc = nullptr;\n\tint error = m_lm ? knitro::KN_new_lm(m_lm.get(), &kc) : knitro::KN_new(&kc);\n\tknitro_throw(error);\n\tm_kc = std::unique_ptr(kc);\n}\n\nKNINT KNITROModel::_variable_index(const VariableIndex &variable) const\n{\n\treturn _get_index(variable);\n}\n\nKNINT KNITROModel::_constraint_index(const ConstraintIndex &constraint) const\n{\n\treturn _get_index(constraint);\n}\n" }, { "path": "lib/knitro_model_ext.cpp", "content": "#include \n#include \n#include \n#include \n#include \n\n#include \"pyoptinterface/knitro_model.hpp\"\n\nnamespace nb = nanobind;\n\nextern void bind_knitro_constants(nb::module_ &m);\n\nNB_MODULE(knitro_model_ext, m)\n{\n\tm.import_(\"pyoptinterface._src.core_ext\");\n\n\tm.def(\"is_library_loaded\", &knitro::is_library_loaded);\n\tm.def(\"load_library\", &knitro::load_library);\n\tm.def(\"has_valid_license\", &knitro::has_valid_license);\n\n\tbind_knitro_constants(m);\n\n\tnb::class_(m, \"RawEnv\")\n\t .def(nb::init(), nb::arg(\"empty\") = false)\n\t .def(\"start\", &KNITROEnv::start)\n\t .def(\"empty\", &KNITROEnv::empty)\n\t .def(\"close\", &KNITROEnv::close);\n\n#define BIND_F(f) .def(#f, &KNITROModel::f)\n\tnb::class_(m, \"RawModel\")\n\t .def(nb::init<>())\n\t .def(nb::init())\n\t .def(\"init\", nb::overload_cast<>(&KNITROModel::init))\n\t .def(\"init\", nb::overload_cast(&KNITROModel::init))\n\n\t // clang-format off\n\t\tBIND_F(close)\n\t\tBIND_F(get_infinity)\n\t\tBIND_F(get_number_iterations)\n\t\tBIND_F(get_mip_node_count)\n\t\tBIND_F(get_obj_bound)\n\t\tBIND_F(get_mip_relative_gap)\n\t\tBIND_F(get_solve_time)\n\t\tBIND_F(get_solver_name)\n\t\tBIND_F(get_release)\n\t // clang-format on\n\n\t .def(\"number_of_variables\", &KNITROModel::get_num_vars)\n\t .def(\"number_of_constraints\", &KNITROModel::get_num_cons, nb::arg(\"type\") = nb::none())\n\n\t .def(\"add_variable\", &KNITROModel::add_variable,\n\t nb::arg(\"domain\") = VariableDomain::Continuous, nb::arg(\"lb\") = -KN_INFINITY,\n\t nb::arg(\"ub\") = KN_INFINITY, nb::arg(\"name\") = \"\")\n\n\t // clang-format off\n\t\tBIND_F(get_variable_lb)\n\t\tBIND_F(get_variable_ub)\n\t\tBIND_F(set_variable_lb)\n\t\tBIND_F(set_variable_ub)\n\t\tBIND_F(set_variable_bounds)\n\t\tBIND_F(set_variable_start)\n\t\tBIND_F(get_variable_name)\n\t\tBIND_F(set_variable_name)\n\t\tBIND_F(set_variable_domain)\n\t\tBIND_F(get_variable_domain)\n\t\tBIND_F(get_variable_rc)\n\t\tBIND_F(delete_variable)\n\t // clang-format on\n\n\t .def(\"get_value\", &KNITROModel::get_variable_value)\n\t .def(\"get_value\",\n\t nb::overload_cast(&KNITROModel::get_expression_value))\n\t .def(\"get_value\",\n\t nb::overload_cast(&KNITROModel::get_expression_value))\n\t .def(\"get_value\",\n\t nb::overload_cast(&KNITROModel::get_expression_value))\n\n\t .def(\"pprint\", &KNITROModel::pprint_variable)\n\t .def(\"pprint\",\n\t nb::overload_cast(&KNITROModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\t .def(\"pprint\",\n\t nb::overload_cast(\n\t &KNITROModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\t .def(\"pprint\", nb::overload_cast(&KNITROModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\n\t // clang-format off\n\t\tBIND_F(set_constraint_name)\n\t\tBIND_F(get_constraint_name)\n\t\tBIND_F(get_constraint_primal)\n\t\tBIND_F(get_constraint_dual)\n\t\tBIND_F(set_normalized_rhs)\n\t\tBIND_F(get_normalized_rhs)\n\t\tBIND_F(set_normalized_coefficient)\n\t // clang-format on\n\n\t .def(\"_add_linear_constraint\",\n\t nb::overload_cast(\n\t &KNITROModel::add_linear_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\",\n\t nb::overload_cast &,\n\t const char *>(&KNITROModel::add_linear_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &KNITROModel::add_linear_constraint_from_var,\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &KNITROModel::add_linear_interval_constraint_from_var,\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &KNITROModel::add_linear_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &KNITROModel::add_linear_interval_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\n\t .def(\"_add_quadratic_constraint\",\n\t nb::overload_cast(&KNITROModel::add_quadratic_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_quadratic_constraint\",\n\t nb::overload_cast &,\n\t const char *>(&KNITROModel::add_quadratic_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_quadratic_constraint\", &KNITROModel::add_quadratic_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_quadratic_constraint\", &KNITROModel::add_quadratic_interval_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\n\t .def(\"add_second_order_cone_constraint\", &KNITROModel::add_second_order_cone_constraint,\n\t nb::arg(\"variables\"), nb::arg(\"name\") = \"\", nb::arg(\"rotated\") = false)\n\n\t .def(\"_add_single_nl_constraint\", &KNITROModel::add_single_nl_constraint, nb::arg(\"graph\"),\n\t nb::arg(\"result\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_single_nl_constraint\", &KNITROModel::add_single_nl_constraint_sense_rhs,\n\t nb::arg(\"graph\"), nb::arg(\"result\"), nb::arg(\"sense\"), nb::arg(\"rhs\"),\n\t nb::arg(\"name\") = \"\")\n\t .def(\"_add_single_nl_constraint\", &KNITROModel::add_single_nl_constraint_from_comparison,\n\t nb::arg(\"graph\"), nb::arg(\"expr\"), nb::arg(\"name\") = \"\")\n\n\t // clang-format off\n\t BIND_F(delete_constraint)\n\t // clang-format on\n\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &KNITROModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &KNITROModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(&KNITROModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &KNITROModel::set_objective_as_variable),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(&KNITROModel::set_objective_as_constant),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"_add_single_nl_objective\", &KNITROModel::add_single_nl_objective, nb::arg(\"graph\"),\n\t nb::arg(\"result\"))\n\n\t // clang-format off\n\t\tBIND_F(set_objective_coefficient)\n\t\tBIND_F(get_obj_value)\n\t\tBIND_F(set_obj_sense)\n\t\tBIND_F(get_obj_sense)\n\t // clang-format on\n\n\t .def(\"optimize\", &KNITROModel::optimize, nb::call_guard())\n\n\t .def(\n\t \"set_raw_parameter\",\n\t [](KNITROModel &m, const std::string &name, int value) {\n\t\t m.set_raw_parameter(name, value);\n\t },\n\t nb::arg(\"name\"), nb::arg(\"value\"))\n\t .def(\n\t \"set_raw_parameter\",\n\t [](KNITROModel &m, const std::string &name, double value) {\n\t\t m.set_raw_parameter(name, value);\n\t },\n\t nb::arg(\"name\"), nb::arg(\"value\"))\n\t .def(\n\t \"set_raw_parameter\",\n\t [](KNITROModel &m, const std::string &name, const std::string &value) {\n\t\t m.set_raw_parameter(name, value);\n\t },\n\t nb::arg(\"name\"), nb::arg(\"value\"))\n\t .def(\n\t \"set_raw_parameter\",\n\t [](KNITROModel &m, int param_id, int value) {\n\t\t m.set_raw_parameter(param_id, value);\n\t },\n\t nb::arg(\"param_id\"), nb::arg(\"value\"))\n\t .def(\n\t \"set_raw_parameter\",\n\t [](KNITROModel &m, int param_id, double value) {\n\t\t m.set_raw_parameter(param_id, value);\n\t },\n\t nb::arg(\"param_id\"), nb::arg(\"value\"))\n\t .def(\n\t \"set_raw_parameter\",\n\t [](KNITROModel &m, int param_id, const std::string &value) {\n\t\t m.set_raw_parameter(param_id, value);\n\t },\n\t nb::arg(\"param_id\"), nb::arg(\"value\"))\n\n\t .def(\n\t \"get_raw_parameter\",\n\t [](KNITROModel &m, const std::string &name) -> int {\n\t\t return m.get_raw_parameter(name);\n\t },\n\t nb::arg(\"name\"))\n\t .def(\n\t \"get_raw_parameter\",\n\t [](KNITROModel &m, const std::string &name) -> double {\n\t\t return m.get_raw_parameter(name);\n\t },\n\t nb::arg(\"name\"))\n\t .def(\n\t \"get_raw_parameter\",\n\t [](KNITROModel &m, int param_id) -> int { return m.get_raw_parameter(param_id); },\n\t nb::arg(\"param_id\"))\n\t .def(\n\t \"get_raw_parameter\",\n\t [](KNITROModel &m, int param_id) -> double {\n\t\t return m.get_raw_parameter(param_id);\n\t },\n\t nb::arg(\"param_id\"))\n\n\t // clang-format off\n\t\tBIND_F(dirty)\n\t\tBIND_F(empty)\n\t // clang-format on\n\n\t // clang-format off\n\t\tBIND_F(get_solve_status)\n\t // clang-format on\n\t ;\n\n#undef BIND_F\n}\n" }, { "path": "lib/knitro_model_ext_constants.cpp", "content": "#include \n#include \"pyoptinterface/knitro_model.hpp\"\n\nnamespace nb = nanobind;\n\nvoid bind_knitro_constants(nb::module_ &m)\n{\n\tnb::module_ KN = m.def_submodule(\"KN\");\n\n\t// Objective goal\n\tKN.attr(\"OBJGOAL_MINIMIZE\") = KN_OBJGOAL_MINIMIZE;\n\tKN.attr(\"OBJGOAL_MAXIMIZE\") = KN_OBJGOAL_MAXIMIZE;\n\n\t// Variable types\n\tKN.attr(\"VARTYPE_CONTINUOUS\") = KN_VARTYPE_CONTINUOUS;\n\tKN.attr(\"VARTYPE_INTEGER\") = KN_VARTYPE_INTEGER;\n\tKN.attr(\"VARTYPE_BINARY\") = KN_VARTYPE_BINARY;\n\n\t// Infinity\n\tKN.attr(\"INFINITY\") = KN_INFINITY;\n\n\t// Return codes - Optimal/Satisfactory\n\tKN.attr(\"RC_OPTIMAL_OR_SATISFACTORY\") = KN_RC_OPTIMAL_OR_SATISFACTORY;\n\tKN.attr(\"RC_OPTIMAL\") = KN_RC_OPTIMAL;\n\n\t// Return codes - Feasible\n\tKN.attr(\"RC_NEAR_OPT\") = KN_RC_NEAR_OPT;\n\tKN.attr(\"RC_FEAS_XTOL\") = KN_RC_FEAS_XTOL;\n\tKN.attr(\"RC_FEAS_NO_IMPROVE\") = KN_RC_FEAS_NO_IMPROVE;\n\tKN.attr(\"RC_FEAS_FTOL\") = KN_RC_FEAS_FTOL;\n\tKN.attr(\"RC_FEAS_BEST\") = KN_RC_FEAS_BEST;\n\tKN.attr(\"RC_FEAS_MULTISTART\") = KN_RC_FEAS_MULTISTART;\n\n\t// Return codes - Infeasible\n\tKN.attr(\"RC_INFEASIBLE\") = KN_RC_INFEASIBLE;\n\tKN.attr(\"RC_INFEAS_XTOL\") = KN_RC_INFEAS_XTOL;\n\tKN.attr(\"RC_INFEAS_NO_IMPROVE\") = KN_RC_INFEAS_NO_IMPROVE;\n\tKN.attr(\"RC_INFEAS_MULTISTART\") = KN_RC_INFEAS_MULTISTART;\n\tKN.attr(\"RC_INFEAS_CON_BOUNDS\") = KN_RC_INFEAS_CON_BOUNDS;\n\tKN.attr(\"RC_INFEAS_VAR_BOUNDS\") = KN_RC_INFEAS_VAR_BOUNDS;\n\n\t// Return codes - Unbounded\n\tKN.attr(\"RC_UNBOUNDED\") = KN_RC_UNBOUNDED;\n\tKN.attr(\"RC_UNBOUNDED_OR_INFEAS\") = KN_RC_UNBOUNDED_OR_INFEAS;\n\n\t// Return codes - Limit exceeded (feasible)\n\tKN.attr(\"RC_ITER_LIMIT_FEAS\") = KN_RC_ITER_LIMIT_FEAS;\n\tKN.attr(\"RC_TIME_LIMIT_FEAS\") = KN_RC_TIME_LIMIT_FEAS;\n\tKN.attr(\"RC_FEVAL_LIMIT_FEAS\") = KN_RC_FEVAL_LIMIT_FEAS;\n\tKN.attr(\"RC_MIP_EXH_FEAS\") = KN_RC_MIP_EXH_FEAS;\n\tKN.attr(\"RC_MIP_TERM_FEAS\") = KN_RC_MIP_TERM_FEAS;\n\tKN.attr(\"RC_MIP_SOLVE_LIMIT_FEAS\") = KN_RC_MIP_SOLVE_LIMIT_FEAS;\n\tKN.attr(\"RC_MIP_NODE_LIMIT_FEAS\") = KN_RC_MIP_NODE_LIMIT_FEAS;\n\n\t// Return codes - Limit exceeded (infeasible)\n\tKN.attr(\"RC_ITER_LIMIT_INFEAS\") = KN_RC_ITER_LIMIT_INFEAS;\n\tKN.attr(\"RC_TIME_LIMIT_INFEAS\") = KN_RC_TIME_LIMIT_INFEAS;\n\tKN.attr(\"RC_FEVAL_LIMIT_INFEAS\") = KN_RC_FEVAL_LIMIT_INFEAS;\n\tKN.attr(\"RC_MIP_EXH_INFEAS\") = KN_RC_MIP_EXH_INFEAS;\n\tKN.attr(\"RC_MIP_SOLVE_LIMIT_INFEAS\") = KN_RC_MIP_SOLVE_LIMIT_INFEAS;\n\tKN.attr(\"RC_MIP_NODE_LIMIT_INFEAS\") = KN_RC_MIP_NODE_LIMIT_INFEAS;\n\n\t// Return codes - Other failures\n\tKN.attr(\"RC_CALLBACK_ERR\") = KN_RC_CALLBACK_ERR;\n\tKN.attr(\"RC_LP_SOLVER_ERR\") = KN_RC_LP_SOLVER_ERR;\n\tKN.attr(\"RC_EVAL_ERR\") = KN_RC_EVAL_ERR;\n\tKN.attr(\"RC_OUT_OF_MEMORY\") = KN_RC_OUT_OF_MEMORY;\n\tKN.attr(\"RC_USER_TERMINATION\") = KN_RC_USER_TERMINATION;\n\tKN.attr(\"RC_OPEN_FILE_ERR\") = KN_RC_OPEN_FILE_ERR;\n\n\t// Return codes - Problem definition errors\n\tKN.attr(\"RC_BAD_N_OR_F\") = KN_RC_BAD_N_OR_F;\n\tKN.attr(\"RC_BAD_CONSTRAINT\") = KN_RC_BAD_CONSTRAINT;\n\tKN.attr(\"RC_BAD_JACOBIAN\") = KN_RC_BAD_JACOBIAN;\n\tKN.attr(\"RC_BAD_HESSIAN\") = KN_RC_BAD_HESSIAN;\n\tKN.attr(\"RC_BAD_CON_INDEX\") = KN_RC_BAD_CON_INDEX;\n\tKN.attr(\"RC_BAD_JAC_INDEX\") = KN_RC_BAD_JAC_INDEX;\n\tKN.attr(\"RC_BAD_HESS_INDEX\") = KN_RC_BAD_HESS_INDEX;\n\tKN.attr(\"RC_BAD_CON_BOUNDS\") = KN_RC_BAD_CON_BOUNDS;\n\tKN.attr(\"RC_BAD_VAR_BOUNDS\") = KN_RC_BAD_VAR_BOUNDS;\n\tKN.attr(\"RC_ILLEGAL_CALL\") = KN_RC_ILLEGAL_CALL;\n\tKN.attr(\"RC_BAD_KCPTR\") = KN_RC_BAD_KCPTR;\n\tKN.attr(\"RC_NULL_POINTER\") = KN_RC_NULL_POINTER;\n\tKN.attr(\"RC_BAD_INIT_VALUE\") = KN_RC_BAD_INIT_VALUE;\n\tKN.attr(\"RC_LICENSE_ERROR\") = KN_RC_LICENSE_ERROR;\n\tKN.attr(\"RC_BAD_PARAMINPUT\") = KN_RC_BAD_PARAMINPUT;\n\tKN.attr(\"RC_LINEAR_SOLVER_ERR\") = KN_RC_LINEAR_SOLVER_ERR;\n\tKN.attr(\"RC_DERIV_CHECK_FAILED\") = KN_RC_DERIV_CHECK_FAILED;\n\tKN.attr(\"RC_DERIV_CHECK_TERMINATE\") = KN_RC_DERIV_CHECK_TERMINATE;\n\tKN.attr(\"RC_OVERFLOW_ERR\") = KN_RC_OVERFLOW_ERR;\n\tKN.attr(\"RC_BAD_SIZE\") = KN_RC_BAD_SIZE;\n\tKN.attr(\"RC_BAD_VARIABLE\") = KN_RC_BAD_VARIABLE;\n\tKN.attr(\"RC_BAD_VAR_INDEX\") = KN_RC_BAD_VAR_INDEX;\n\tKN.attr(\"RC_BAD_OBJECTIVE\") = KN_RC_BAD_OBJECTIVE;\n\tKN.attr(\"RC_BAD_OBJ_INDEX\") = KN_RC_BAD_OBJ_INDEX;\n\tKN.attr(\"RC_BAD_RESIDUAL\") = KN_RC_BAD_RESIDUAL;\n\tKN.attr(\"RC_BAD_RSD_INDEX\") = KN_RC_BAD_RSD_INDEX;\n\tKN.attr(\"RC_INTERNAL_ERROR\") = KN_RC_INTERNAL_ERROR;\n\n\t// Callback request codes\n\tKN.attr(\"RC_EVALFC\") = KN_RC_EVALFC;\n\tKN.attr(\"RC_EVALGA\") = KN_RC_EVALGA;\n\tKN.attr(\"RC_EVALH\") = KN_RC_EVALH;\n\tKN.attr(\"RC_EVALHV\") = KN_RC_EVALHV;\n\tKN.attr(\"RC_EVALH_NO_F\") = KN_RC_EVALH_NO_F;\n\tKN.attr(\"RC_EVALHV_NO_F\") = KN_RC_EVALHV_NO_F;\n\tKN.attr(\"RC_EVALR\") = KN_RC_EVALR;\n\tKN.attr(\"RC_EVALRJ\") = KN_RC_EVALRJ;\n\tKN.attr(\"RC_EVALFCGA\") = KN_RC_EVALFCGA;\n\n\t// Parameter types\n\tKN.attr(\"PARAMTYPE_INTEGER\") = KN_PARAMTYPE_INTEGER;\n\tKN.attr(\"PARAMTYPE_FLOAT\") = KN_PARAMTYPE_FLOAT;\n\tKN.attr(\"PARAMTYPE_STRING\") = KN_PARAMTYPE_STRING;\n\n\t// Parameter IDs\n\tKN.attr(\"PARAM_NEWPOINT\") = KN_PARAM_NEWPOINT;\n\tKN.attr(\"PARAM_HONORBNDS\") = KN_PARAM_HONORBNDS;\n\tKN.attr(\"PARAM_ALGORITHM\") = KN_PARAM_ALGORITHM;\n\tKN.attr(\"PARAM_ALG\") = KN_PARAM_ALG;\n\tKN.attr(\"PARAM_NLP_ALGORITHM\") = KN_PARAM_NLP_ALGORITHM;\n\tKN.attr(\"PARAM_BAR_MURULE\") = KN_PARAM_BAR_MURULE;\n\tKN.attr(\"PARAM_BAR_FEASIBLE\") = KN_PARAM_BAR_FEASIBLE;\n\tKN.attr(\"PARAM_GRADOPT\") = KN_PARAM_GRADOPT;\n\tKN.attr(\"PARAM_HESSOPT\") = KN_PARAM_HESSOPT;\n\tKN.attr(\"PARAM_BAR_INITPT\") = KN_PARAM_BAR_INITPT;\n\tKN.attr(\"PARAM_ACT_LPSOLVER\") = KN_PARAM_ACT_LPSOLVER;\n\tKN.attr(\"PARAM_CG_MAXIT\") = KN_PARAM_CG_MAXIT;\n\tKN.attr(\"PARAM_MAXIT\") = KN_PARAM_MAXIT;\n\tKN.attr(\"PARAM_OUTLEV\") = KN_PARAM_OUTLEV;\n\tKN.attr(\"PARAM_OUTMODE\") = KN_PARAM_OUTMODE;\n\tKN.attr(\"PARAM_SCALE\") = KN_PARAM_SCALE;\n\tKN.attr(\"PARAM_SOC\") = KN_PARAM_SOC;\n\tKN.attr(\"PARAM_DELTA\") = KN_PARAM_DELTA;\n\tKN.attr(\"PARAM_BAR_FEASMODETOL\") = KN_PARAM_BAR_FEASMODETOL;\n\tKN.attr(\"PARAM_FEASTOL\") = KN_PARAM_FEASTOL;\n\tKN.attr(\"PARAM_FEASTOLABS\") = KN_PARAM_FEASTOLABS;\n\tKN.attr(\"PARAM_MAXTIMECPU\") = KN_PARAM_MAXTIMECPU;\n\tKN.attr(\"PARAM_BAR_INITMU\") = KN_PARAM_BAR_INITMU;\n\tKN.attr(\"PARAM_OBJRANGE\") = KN_PARAM_OBJRANGE;\n\tKN.attr(\"PARAM_OPTTOL\") = KN_PARAM_OPTTOL;\n\tKN.attr(\"PARAM_OPTTOLABS\") = KN_PARAM_OPTTOLABS;\n\tKN.attr(\"PARAM_LINSOLVER_PIVOTTOL\") = KN_PARAM_LINSOLVER_PIVOTTOL;\n\tKN.attr(\"PARAM_XTOL\") = KN_PARAM_XTOL;\n\tKN.attr(\"PARAM_DEBUG\") = KN_PARAM_DEBUG;\n\tKN.attr(\"PARAM_MULTISTART\") = KN_PARAM_MULTISTART;\n\tKN.attr(\"PARAM_MS_ENABLE\") = KN_PARAM_MS_ENABLE;\n\tKN.attr(\"PARAM_MS_MAXSOLVES\") = KN_PARAM_MS_MAXSOLVES;\n\tKN.attr(\"PARAM_MS_MAXBNDRANGE\") = KN_PARAM_MS_MAXBNDRANGE;\n\tKN.attr(\"PARAM_MS_MAXTIMECPU\") = KN_PARAM_MS_MAXTIMECPU;\n\tKN.attr(\"PARAM_MS_MAXTIMEREAL\") = KN_PARAM_MS_MAXTIMEREAL;\n\tKN.attr(\"PARAM_LMSIZE\") = KN_PARAM_LMSIZE;\n\tKN.attr(\"PARAM_BAR_MAXCROSSIT\") = KN_PARAM_BAR_MAXCROSSIT;\n\tKN.attr(\"PARAM_MAXTIMEREAL\") = KN_PARAM_MAXTIMEREAL;\n\tKN.attr(\"PARAM_CG_PRECOND\") = KN_PARAM_CG_PRECOND;\n\tKN.attr(\"PARAM_BLASOPTION\") = KN_PARAM_BLASOPTION;\n\tKN.attr(\"PARAM_BAR_MAXREFACTOR\") = KN_PARAM_BAR_MAXREFACTOR;\n\tKN.attr(\"PARAM_LINESEARCH_MAXTRIALS\") = KN_PARAM_LINESEARCH_MAXTRIALS;\n\tKN.attr(\"PARAM_BLASOPTIONLIB\") = KN_PARAM_BLASOPTIONLIB;\n\tKN.attr(\"PARAM_OUTAPPEND\") = KN_PARAM_OUTAPPEND;\n\tKN.attr(\"PARAM_OUTDIR\") = KN_PARAM_OUTDIR;\n\tKN.attr(\"PARAM_CPLEXLIB\") = KN_PARAM_CPLEXLIB;\n\tKN.attr(\"PARAM_BAR_PENRULE\") = KN_PARAM_BAR_PENRULE;\n\tKN.attr(\"PARAM_BAR_PENCONS\") = KN_PARAM_BAR_PENCONS;\n\tKN.attr(\"PARAM_MS_NUMTOSAVE\") = KN_PARAM_MS_NUMTOSAVE;\n\tKN.attr(\"PARAM_MS_SAVETOL\") = KN_PARAM_MS_SAVETOL;\n\tKN.attr(\"PARAM_MS_TERMINATE\") = KN_PARAM_MS_TERMINATE;\n\tKN.attr(\"PARAM_MS_STARTPTRANGE\") = KN_PARAM_MS_STARTPTRANGE;\n\tKN.attr(\"PARAM_INFEASTOL\") = KN_PARAM_INFEASTOL;\n\tKN.attr(\"PARAM_LINSOLVER\") = KN_PARAM_LINSOLVER;\n\tKN.attr(\"PARAM_BAR_DIRECTINTERVAL\") = KN_PARAM_BAR_DIRECTINTERVAL;\n\tKN.attr(\"PARAM_PRESOLVE\") = KN_PARAM_PRESOLVE;\n\tKN.attr(\"PARAM_PRESOLVE_TOL\") = KN_PARAM_PRESOLVE_TOL;\n\tKN.attr(\"PARAM_BAR_SWITCHRULE\") = KN_PARAM_BAR_SWITCHRULE;\n\tKN.attr(\"PARAM_HESSIAN_NO_F\") = KN_PARAM_HESSIAN_NO_F;\n\tKN.attr(\"PARAM_MA_TERMINATE\") = KN_PARAM_MA_TERMINATE;\n\tKN.attr(\"PARAM_MA_MAXTIMECPU\") = KN_PARAM_MA_MAXTIMECPU;\n\tKN.attr(\"PARAM_MA_MAXTIMEREAL\") = KN_PARAM_MA_MAXTIMEREAL;\n\tKN.attr(\"PARAM_MS_SEED\") = KN_PARAM_MS_SEED;\n\tKN.attr(\"PARAM_MA_OUTSUB\") = KN_PARAM_MA_OUTSUB;\n\tKN.attr(\"PARAM_MS_OUTSUB\") = KN_PARAM_MS_OUTSUB;\n\tKN.attr(\"PARAM_XPRESSLIB\") = KN_PARAM_XPRESSLIB;\n\tKN.attr(\"PARAM_TUNER\") = KN_PARAM_TUNER;\n\tKN.attr(\"PARAM_TUNER_OPTIONSFILE\") = KN_PARAM_TUNER_OPTIONSFILE;\n\tKN.attr(\"PARAM_TUNER_MAXTIMECPU\") = KN_PARAM_TUNER_MAXTIMECPU;\n\tKN.attr(\"PARAM_TUNER_MAXTIMEREAL\") = KN_PARAM_TUNER_MAXTIMEREAL;\n\tKN.attr(\"PARAM_TUNER_OUTSUB\") = KN_PARAM_TUNER_OUTSUB;\n\tKN.attr(\"PARAM_TUNER_TERMINATE\") = KN_PARAM_TUNER_TERMINATE;\n\tKN.attr(\"PARAM_LINSOLVER_OOC\") = KN_PARAM_LINSOLVER_OOC;\n\tKN.attr(\"PARAM_BAR_RELAXCONS\") = KN_PARAM_BAR_RELAXCONS;\n\tKN.attr(\"PARAM_MS_DETERMINISTIC\") = KN_PARAM_MS_DETERMINISTIC;\n\tKN.attr(\"PARAM_BAR_REFINEMENT\") = KN_PARAM_BAR_REFINEMENT;\n\tKN.attr(\"PARAM_DERIVCHECK\") = KN_PARAM_DERIVCHECK;\n\tKN.attr(\"PARAM_DERIVCHECK_TYPE\") = KN_PARAM_DERIVCHECK_TYPE;\n\tKN.attr(\"PARAM_DERIVCHECK_TOL\") = KN_PARAM_DERIVCHECK_TOL;\n\tKN.attr(\"PARAM_MAXFEVALS\") = KN_PARAM_MAXFEVALS;\n\tKN.attr(\"PARAM_FSTOPVAL\") = KN_PARAM_FSTOPVAL;\n\tKN.attr(\"PARAM_DATACHECK\") = KN_PARAM_DATACHECK;\n\tKN.attr(\"PARAM_DERIVCHECK_TERMINATE\") = KN_PARAM_DERIVCHECK_TERMINATE;\n\tKN.attr(\"PARAM_BAR_WATCHDOG\") = KN_PARAM_BAR_WATCHDOG;\n\tKN.attr(\"PARAM_FTOL\") = KN_PARAM_FTOL;\n\tKN.attr(\"PARAM_FTOL_ITERS\") = KN_PARAM_FTOL_ITERS;\n\tKN.attr(\"PARAM_ACT_QPALG\") = KN_PARAM_ACT_QPALG;\n\tKN.attr(\"PARAM_BAR_INITPI_MPEC\") = KN_PARAM_BAR_INITPI_MPEC;\n\tKN.attr(\"PARAM_XTOL_ITERS\") = KN_PARAM_XTOL_ITERS;\n\tKN.attr(\"PARAM_LINESEARCH\") = KN_PARAM_LINESEARCH;\n\tKN.attr(\"PARAM_OUT_CSVINFO\") = KN_PARAM_OUT_CSVINFO;\n\tKN.attr(\"PARAM_INITPENALTY\") = KN_PARAM_INITPENALTY;\n\tKN.attr(\"PARAM_ACT_LPFEASTOL\") = KN_PARAM_ACT_LPFEASTOL;\n\tKN.attr(\"PARAM_CG_STOPTOL\") = KN_PARAM_CG_STOPTOL;\n\tKN.attr(\"PARAM_RESTARTS\") = KN_PARAM_RESTARTS;\n\tKN.attr(\"PARAM_RESTARTS_MAXIT\") = KN_PARAM_RESTARTS_MAXIT;\n\tKN.attr(\"PARAM_BAR_SLACKBOUNDPUSH\") = KN_PARAM_BAR_SLACKBOUNDPUSH;\n\tKN.attr(\"PARAM_CG_PMEM\") = KN_PARAM_CG_PMEM;\n\tKN.attr(\"PARAM_BAR_SWITCHOBJ\") = KN_PARAM_BAR_SWITCHOBJ;\n\tKN.attr(\"PARAM_OUTNAME\") = KN_PARAM_OUTNAME;\n\tKN.attr(\"PARAM_OUT_CSVNAME\") = KN_PARAM_OUT_CSVNAME;\n\tKN.attr(\"PARAM_ACT_PARAMETRIC\") = KN_PARAM_ACT_PARAMETRIC;\n\tKN.attr(\"PARAM_ACT_LPDUMPMPS\") = KN_PARAM_ACT_LPDUMPMPS;\n\tKN.attr(\"PARAM_ACT_LPALG\") = KN_PARAM_ACT_LPALG;\n\tKN.attr(\"PARAM_ACT_LPPRESOLVE\") = KN_PARAM_ACT_LPPRESOLVE;\n\tKN.attr(\"PARAM_ACT_LPPENALTY\") = KN_PARAM_ACT_LPPENALTY;\n\tKN.attr(\"PARAM_BNDRANGE\") = KN_PARAM_BNDRANGE;\n\tKN.attr(\"PARAM_BAR_CONIC_ENABLE\") = KN_PARAM_BAR_CONIC_ENABLE;\n\tKN.attr(\"PARAM_CONVEX\") = KN_PARAM_CONVEX;\n\tKN.attr(\"PARAM_OUT_HINTS\") = KN_PARAM_OUT_HINTS;\n\tKN.attr(\"PARAM_EVAL_FCGA\") = KN_PARAM_EVAL_FCGA;\n\tKN.attr(\"PARAM_BAR_MAXCORRECTORS\") = KN_PARAM_BAR_MAXCORRECTORS;\n\tKN.attr(\"PARAM_STRAT_WARM_START\") = KN_PARAM_STRAT_WARM_START;\n\tKN.attr(\"PARAM_FINDIFF_TERMINATE\") = KN_PARAM_FINDIFF_TERMINATE;\n\tKN.attr(\"PARAM_CPUPLATFORM\") = KN_PARAM_CPUPLATFORM;\n\tKN.attr(\"PARAM_PRESOLVE_PASSES\") = KN_PARAM_PRESOLVE_PASSES;\n\tKN.attr(\"PARAM_PRESOLVE_LEVEL\") = KN_PARAM_PRESOLVE_LEVEL;\n\tKN.attr(\"PARAM_FINDIFF_RELSTEPSIZE\") = KN_PARAM_FINDIFF_RELSTEPSIZE;\n\tKN.attr(\"PARAM_INFEASTOL_ITERS\") = KN_PARAM_INFEASTOL_ITERS;\n\tKN.attr(\"PARAM_PRESOLVEOP_TIGHTEN\") = KN_PARAM_PRESOLVEOP_TIGHTEN;\n\tKN.attr(\"PARAM_BAR_LINSYS\") = KN_PARAM_BAR_LINSYS;\n\tKN.attr(\"PARAM_PRESOLVE_INITPT\") = KN_PARAM_PRESOLVE_INITPT;\n\tKN.attr(\"PARAM_ACT_QPPENALTY\") = KN_PARAM_ACT_QPPENALTY;\n\tKN.attr(\"PARAM_BAR_LINSYS_STORAGE\") = KN_PARAM_BAR_LINSYS_STORAGE;\n\tKN.attr(\"PARAM_LINSOLVER_MAXITREF\") = KN_PARAM_LINSOLVER_MAXITREF;\n\tKN.attr(\"PARAM_BFGS_SCALING\") = KN_PARAM_BFGS_SCALING;\n\tKN.attr(\"PARAM_BAR_INITSHIFTTOL\") = KN_PARAM_BAR_INITSHIFTTOL;\n\tKN.attr(\"PARAM_NUMTHREADS\") = KN_PARAM_NUMTHREADS;\n\tKN.attr(\"PARAM_CONCURRENT_EVALS\") = KN_PARAM_CONCURRENT_EVALS;\n\tKN.attr(\"PARAM_BLAS_NUMTHREADS\") = KN_PARAM_BLAS_NUMTHREADS;\n\tKN.attr(\"PARAM_LINSOLVER_NUMTHREADS\") = KN_PARAM_LINSOLVER_NUMTHREADS;\n\tKN.attr(\"PARAM_MS_NUMTHREADS\") = KN_PARAM_MS_NUMTHREADS;\n\tKN.attr(\"PARAM_CONIC_NUMTHREADS\") = KN_PARAM_CONIC_NUMTHREADS;\n\tKN.attr(\"PARAM_NCVX_QCQP_INIT\") = KN_PARAM_NCVX_QCQP_INIT;\n\tKN.attr(\"PARAM_FINDIFF_ESTNOISE\") = KN_PARAM_FINDIFF_ESTNOISE;\n\tKN.attr(\"PARAM_FINDIFF_NUMTHREADS\") = KN_PARAM_FINDIFF_NUMTHREADS;\n\tKN.attr(\"PARAM_BAR_MPEC_HEURISTIC\") = KN_PARAM_BAR_MPEC_HEURISTIC;\n\tKN.attr(\"PARAM_PRESOLVEOP_REDUNDANT\") = KN_PARAM_PRESOLVEOP_REDUNDANT;\n\tKN.attr(\"PARAM_LINSOLVER_ORDERING\") = KN_PARAM_LINSOLVER_ORDERING;\n\tKN.attr(\"PARAM_LINSOLVER_NODEAMALG\") = KN_PARAM_LINSOLVER_NODEAMALG;\n\tKN.attr(\"PARAM_PRESOLVEOP_SUBSTITUTION\") = KN_PARAM_PRESOLVEOP_SUBSTITUTION;\n\tKN.attr(\"PARAM_PRESOLVEOP_SUBSTITUTION_TOL\") = KN_PARAM_PRESOLVEOP_SUBSTITUTION_TOL;\n\tKN.attr(\"PARAM_MS_INITPT_CLUSTER\") = KN_PARAM_MS_INITPT_CLUSTER;\n\tKN.attr(\"PARAM_SCALE_VARS\") = KN_PARAM_SCALE_VARS;\n\tKN.attr(\"PARAM_BAR_MAXMU\") = KN_PARAM_BAR_MAXMU;\n\tKN.attr(\"PARAM_BAR_GLOBALIZE\") = KN_PARAM_BAR_GLOBALIZE;\n\tKN.attr(\"PARAM_LINSOLVER_SCALING\") = KN_PARAM_LINSOLVER_SCALING;\n\tKN.attr(\"PARAM_INITPT_STRATEGY\") = KN_PARAM_INITPT_STRATEGY;\n\tKN.attr(\"PARAM_EVAL_COST\") = KN_PARAM_EVAL_COST;\n\tKN.attr(\"PARAM_MS_TERMINATERULE_TOL\") = KN_PARAM_MS_TERMINATERULE_TOL;\n\tKN.attr(\"PARAM_SOLTYPE\") = KN_PARAM_SOLTYPE;\n\tKN.attr(\"PARAM_MAXTIME\") = KN_PARAM_MAXTIME;\n\tKN.attr(\"PARAM_LP_ALGORITHM\") = KN_PARAM_LP_ALGORITHM;\n\tKN.attr(\"PARAM_LP_ALG\") = KN_PARAM_LP_ALG;\n\tKN.attr(\"PARAM_AL_INITPENALTY\") = KN_PARAM_AL_INITPENALTY;\n\tKN.attr(\"PARAM_AL_MAXPENALTY\") = KN_PARAM_AL_MAXPENALTY;\n\tKN.attr(\"PARAM_PRESOLVEOP_PROBING\") = KN_PARAM_PRESOLVEOP_PROBING;\n\n\t// Algorithm values\n\tKN.attr(\"ALG_AUTOMATIC\") = KN_ALG_AUTOMATIC;\n\tKN.attr(\"ALG_AUTO\") = KN_ALG_AUTO;\n\tKN.attr(\"ALG_BAR_DIRECT\") = KN_ALG_BAR_DIRECT;\n\tKN.attr(\"ALG_BAR_CG\") = KN_ALG_BAR_CG;\n\tKN.attr(\"ALG_ACT_CG\") = KN_ALG_ACT_CG;\n\tKN.attr(\"ALG_ACT_SQP\") = KN_ALG_ACT_SQP;\n\tKN.attr(\"ALG_MULTI\") = KN_ALG_MULTI;\n\tKN.attr(\"ALG_AL\") = KN_ALG_AL;\n\n\t// NLP Algorithm values\n\tKN.attr(\"NLP_ALG_AUTOMATIC\") = KN_NLP_ALG_AUTOMATIC;\n\tKN.attr(\"NLP_ALG_AUTO\") = KN_NLP_ALG_AUTO;\n\tKN.attr(\"NLP_ALG_BAR_DIRECT\") = KN_NLP_ALG_BAR_DIRECT;\n\tKN.attr(\"NLP_ALG_BAR_CG\") = KN_NLP_ALG_BAR_CG;\n\tKN.attr(\"NLP_ALG_ACT_CG\") = KN_NLP_ALG_ACT_CG;\n\tKN.attr(\"NLP_ALG_ACT_SQP\") = KN_NLP_ALG_ACT_SQP;\n\tKN.attr(\"NLP_ALG_MULTI\") = KN_NLP_ALG_MULTI;\n\tKN.attr(\"NLP_ALG_AL\") = KN_NLP_ALG_AL;\n\n\t// Bar murule values\n\tKN.attr(\"BAR_MURULE_AUTOMATIC\") = KN_BAR_MURULE_AUTOMATIC;\n\tKN.attr(\"BAR_MURULE_AUTO\") = KN_BAR_MURULE_AUTO;\n\tKN.attr(\"BAR_MURULE_MONOTONE\") = KN_BAR_MURULE_MONOTONE;\n\tKN.attr(\"BAR_MURULE_ADAPTIVE\") = KN_BAR_MURULE_ADAPTIVE;\n\tKN.attr(\"BAR_MURULE_PROBING\") = KN_BAR_MURULE_PROBING;\n\tKN.attr(\"BAR_MURULE_DAMPMPC\") = KN_BAR_MURULE_DAMPMPC;\n\tKN.attr(\"BAR_MURULE_FULLMPC\") = KN_BAR_MURULE_FULLMPC;\n\tKN.attr(\"BAR_MURULE_QUALITY\") = KN_BAR_MURULE_QUALITY;\n\n\t// Gradient options\n\tKN.attr(\"GRADOPT_EXACT\") = KN_GRADOPT_EXACT;\n\tKN.attr(\"GRADOPT_FORWARD\") = KN_GRADOPT_FORWARD;\n\tKN.attr(\"GRADOPT_CENTRAL\") = KN_GRADOPT_CENTRAL;\n\tKN.attr(\"GRADOPT_USER_FORWARD\") = KN_GRADOPT_USER_FORWARD;\n\tKN.attr(\"GRADOPT_USER_CENTRAL\") = KN_GRADOPT_USER_CENTRAL;\n\n\t// Hessian options\n\tKN.attr(\"HESSOPT_AUTO\") = KN_HESSOPT_AUTO;\n\tKN.attr(\"HESSOPT_EXACT\") = KN_HESSOPT_EXACT;\n\tKN.attr(\"HESSOPT_BFGS\") = KN_HESSOPT_BFGS;\n\tKN.attr(\"HESSOPT_SR1\") = KN_HESSOPT_SR1;\n\tKN.attr(\"HESSOPT_PRODUCT_FINDIFF\") = KN_HESSOPT_PRODUCT_FINDIFF;\n\tKN.attr(\"HESSOPT_PRODUCT\") = KN_HESSOPT_PRODUCT;\n\tKN.attr(\"HESSOPT_LBFGS\") = KN_HESSOPT_LBFGS;\n\tKN.attr(\"HESSOPT_GAUSS_NEWTON\") = KN_HESSOPT_GAUSS_NEWTON;\n\n\t// Output level values\n\tKN.attr(\"OUTLEV_NONE\") = KN_OUTLEV_NONE;\n\tKN.attr(\"OUTLEV_SUMMARY\") = KN_OUTLEV_SUMMARY;\n\tKN.attr(\"OUTLEV_ITER_10\") = KN_OUTLEV_ITER_10;\n\tKN.attr(\"OUTLEV_ITER\") = KN_OUTLEV_ITER;\n\tKN.attr(\"OUTLEV_ITER_VERBOSE\") = KN_OUTLEV_ITER_VERBOSE;\n\tKN.attr(\"OUTLEV_ITER_X\") = KN_OUTLEV_ITER_X;\n\tKN.attr(\"OUTLEV_ALL\") = KN_OUTLEV_ALL;\n\n\t// Linear solver values\n\tKN.attr(\"LINSOLVER_AUTO\") = KN_LINSOLVER_AUTO;\n\tKN.attr(\"LINSOLVER_INTERNAL\") = KN_LINSOLVER_INTERNAL;\n\tKN.attr(\"LINSOLVER_HYBRID\") = KN_LINSOLVER_HYBRID;\n\tKN.attr(\"LINSOLVER_DENSEQR\") = KN_LINSOLVER_DENSEQR;\n\tKN.attr(\"LINSOLVER_MA27\") = KN_LINSOLVER_MA27;\n\tKN.attr(\"LINSOLVER_MA57\") = KN_LINSOLVER_MA57;\n\tKN.attr(\"LINSOLVER_MKLPARDISO\") = KN_LINSOLVER_MKLPARDISO;\n\tKN.attr(\"LINSOLVER_MA97\") = KN_LINSOLVER_MA97;\n\tKN.attr(\"LINSOLVER_MA86\") = KN_LINSOLVER_MA86;\n\tKN.attr(\"LINSOLVER_APPLE\") = KN_LINSOLVER_APPLE;\n\n\t// Presolve values\n\tKN.attr(\"PRESOLVE_NO\") = KN_PRESOLVE_NO;\n\tKN.attr(\"PRESOLVE_YES\") = KN_PRESOLVE_YES;\n\n\t// Derivative check values\n\tKN.attr(\"DERIVCHECK_NONE\") = KN_DERIVCHECK_NONE;\n\tKN.attr(\"DERIVCHECK_FIRST\") = KN_DERIVCHECK_FIRST;\n\tKN.attr(\"DERIVCHECK_SECOND\") = KN_DERIVCHECK_SECOND;\n\tKN.attr(\"DERIVCHECK_ALL\") = KN_DERIVCHECK_ALL;\n\n\t// Linesearch values\n\tKN.attr(\"LINESEARCH_AUTO\") = KN_LINESEARCH_AUTO;\n\tKN.attr(\"LINESEARCH_BACKTRACK\") = KN_LINESEARCH_BACKTRACK;\n\tKN.attr(\"LINESEARCH_INTERPOLATE\") = KN_LINESEARCH_INTERPOLATE;\n\tKN.attr(\"LINESEARCH_WEAKWOLFE\") = KN_LINESEARCH_WEAKWOLFE;\n\n\t// LP Algorithm values\n\tKN.attr(\"LP_ALG_AUTO\") = KN_LP_ALG_AUTO;\n\tKN.attr(\"LP_ALG_NLPALGORITHM\") = KN_LP_ALG_NLPALGORITHM;\n\tKN.attr(\"LP_ALG_PRIMALSIMPLEX\") = KN_LP_ALG_PRIMALSIMPLEX;\n\tKN.attr(\"LP_ALG_DUALSIMPLEX\") = KN_LP_ALG_DUALSIMPLEX;\n\tKN.attr(\"LP_ALG_BARRIER\") = KN_LP_ALG_BARRIER;\n\tKN.attr(\"LP_ALG_PDLP\") = KN_LP_ALG_PDLP;\n\n\t// MIP parameter IDs\n\tKN.attr(\"PARAM_MIP_METHOD\") = KN_PARAM_MIP_METHOD;\n\tKN.attr(\"PARAM_MIP_BRANCHRULE\") = KN_PARAM_MIP_BRANCHRULE;\n\tKN.attr(\"PARAM_MIP_SELECTRULE\") = KN_PARAM_MIP_SELECTRULE;\n\tKN.attr(\"PARAM_MIP_OPTGAPABS\") = KN_PARAM_MIP_OPTGAPABS;\n\tKN.attr(\"PARAM_MIP_OPTGAPREL\") = KN_PARAM_MIP_OPTGAPREL;\n\tKN.attr(\"PARAM_MIP_MAXTIMECPU\") = KN_PARAM_MIP_MAXTIMECPU;\n\tKN.attr(\"PARAM_MIP_MAXTIMEREAL\") = KN_PARAM_MIP_MAXTIMEREAL;\n\tKN.attr(\"PARAM_MIP_MAXSOLVES\") = KN_PARAM_MIP_MAXSOLVES;\n\tKN.attr(\"PARAM_MIP_INTEGERTOL\") = KN_PARAM_MIP_INTEGERTOL;\n\tKN.attr(\"PARAM_MIP_OUTLEVEL\") = KN_PARAM_MIP_OUTLEVEL;\n\tKN.attr(\"PARAM_MIP_OUTINTERVAL\") = KN_PARAM_MIP_OUTINTERVAL;\n\tKN.attr(\"PARAM_MIP_OUTSUB\") = KN_PARAM_MIP_OUTSUB;\n\tKN.attr(\"PARAM_MIP_DEBUG\") = KN_PARAM_MIP_DEBUG;\n\tKN.attr(\"PARAM_MIP_IMPLICATIONS\") = KN_PARAM_MIP_IMPLICATIONS;\n\tKN.attr(\"PARAM_MIP_GUB_BRANCH\") = KN_PARAM_MIP_GUB_BRANCH;\n\tKN.attr(\"PARAM_MIP_KNAPSACK\") = KN_PARAM_MIP_KNAPSACK;\n\tKN.attr(\"PARAM_MIP_ROUNDING\") = KN_PARAM_MIP_ROUNDING;\n\tKN.attr(\"PARAM_MIP_ROOT_NLPALG\") = KN_PARAM_MIP_ROOT_NLPALG;\n\tKN.attr(\"PARAM_MIP_TERMINATE\") = KN_PARAM_MIP_TERMINATE;\n\tKN.attr(\"PARAM_MIP_MAXNODES\") = KN_PARAM_MIP_MAXNODES;\n\tKN.attr(\"PARAM_MIP_HEUR_MAXIT\") = KN_PARAM_MIP_HEUR_MAXIT;\n\tKN.attr(\"PARAM_MIP_PSEUDOINIT\") = KN_PARAM_MIP_PSEUDOINIT;\n\tKN.attr(\"PARAM_MIP_STRONG_MAXIT\") = KN_PARAM_MIP_STRONG_MAXIT;\n\tKN.attr(\"PARAM_MIP_STRONG_CANDLIM\") = KN_PARAM_MIP_STRONG_CANDLIM;\n\tKN.attr(\"PARAM_MIP_STRONG_LEVEL\") = KN_PARAM_MIP_STRONG_LEVEL;\n\tKN.attr(\"PARAM_MIP_INTVAR_STRATEGY\") = KN_PARAM_MIP_INTVAR_STRATEGY;\n\tKN.attr(\"PARAM_MIP_RELAXABLE\") = KN_PARAM_MIP_RELAXABLE;\n\tKN.attr(\"PARAM_MIP_NODE_NLPALG\") = KN_PARAM_MIP_NODE_NLPALG;\n\tKN.attr(\"PARAM_MIP_HEUR_TERMINATE\") = KN_PARAM_MIP_HEUR_TERMINATE;\n\tKN.attr(\"PARAM_MIP_SELECTDIR\") = KN_PARAM_MIP_SELECTDIR;\n\tKN.attr(\"PARAM_MIP_CUTFACTOR\") = KN_PARAM_MIP_CUTFACTOR;\n\tKN.attr(\"PARAM_MIP_ZEROHALF\") = KN_PARAM_MIP_ZEROHALF;\n\tKN.attr(\"PARAM_MIP_MIR\") = KN_PARAM_MIP_MIR;\n\tKN.attr(\"PARAM_MIP_CLIQUE\") = KN_PARAM_MIP_CLIQUE;\n\tKN.attr(\"PARAM_MIP_HEUR_STRATEGY\") = KN_PARAM_MIP_HEUR_STRATEGY;\n\tKN.attr(\"PARAM_MIP_HEUR_FEASPUMP\") = KN_PARAM_MIP_HEUR_FEASPUMP;\n\tKN.attr(\"PARAM_MIP_HEUR_MPEC\") = KN_PARAM_MIP_HEUR_MPEC;\n\tKN.attr(\"PARAM_MIP_HEUR_DIVING\") = KN_PARAM_MIP_HEUR_DIVING;\n\tKN.attr(\"PARAM_MIP_CUTTINGPLANE\") = KN_PARAM_MIP_CUTTINGPLANE;\n\tKN.attr(\"PARAM_MIP_CUTOFF\") = KN_PARAM_MIP_CUTOFF;\n\tKN.attr(\"PARAM_MIP_HEUR_LNS\") = KN_PARAM_MIP_HEUR_LNS;\n\tKN.attr(\"PARAM_MIP_MULTISTART\") = KN_PARAM_MIP_MULTISTART;\n\tKN.attr(\"PARAM_MIP_LIFTPROJECT\") = KN_PARAM_MIP_LIFTPROJECT;\n\tKN.attr(\"PARAM_MIP_NUMTHREADS\") = KN_PARAM_MIP_NUMTHREADS;\n\tKN.attr(\"PARAM_MIP_HEUR_MISQP\") = KN_PARAM_MIP_HEUR_MISQP;\n\tKN.attr(\"PARAM_MIP_RESTART\") = KN_PARAM_MIP_RESTART;\n\tKN.attr(\"PARAM_MIP_GOMORY\") = KN_PARAM_MIP_GOMORY;\n\tKN.attr(\"PARAM_MIP_CUT_PROBING\") = KN_PARAM_MIP_CUT_PROBING;\n\tKN.attr(\"PARAM_MIP_CUT_FLOWCOVER\") = KN_PARAM_MIP_CUT_FLOWCOVER;\n\tKN.attr(\"PARAM_MIP_HEUR_LOCALSEARCH\") = KN_PARAM_MIP_HEUR_LOCALSEARCH;\n\tKN.attr(\"PARAM_MIP_ROOT_LPALG\") = KN_PARAM_MIP_ROOT_LPALG;\n\tKN.attr(\"PARAM_MIP_NODE_LPALG\") = KN_PARAM_MIP_NODE_LPALG;\n\n\t// MIP method values\n\tKN.attr(\"MIP_METHOD_AUTO\") = KN_MIP_METHOD_AUTO;\n\tKN.attr(\"MIP_METHOD_BB\") = KN_MIP_METHOD_BB;\n\tKN.attr(\"MIP_METHOD_HQG\") = KN_MIP_METHOD_HQG;\n\tKN.attr(\"MIP_METHOD_MISQP\") = KN_MIP_METHOD_MISQP;\n\n\t// MIP branch rule values\n\tKN.attr(\"MIP_BRANCH_AUTO\") = KN_MIP_BRANCH_AUTO;\n\tKN.attr(\"MIP_BRANCH_MOSTFRAC\") = KN_MIP_BRANCH_MOSTFRAC;\n\tKN.attr(\"MIP_BRANCH_PSEUDOCOST\") = KN_MIP_BRANCH_PSEUDOCOST;\n\tKN.attr(\"MIP_BRANCH_STRONG\") = KN_MIP_BRANCH_STRONG;\n\n\t// MIP select rule values\n\tKN.attr(\"MIP_SEL_AUTO\") = KN_MIP_SEL_AUTO;\n\tKN.attr(\"MIP_SEL_DEPTHFIRST\") = KN_MIP_SEL_DEPTHFIRST;\n\tKN.attr(\"MIP_SEL_BESTBOUND\") = KN_MIP_SEL_BESTBOUND;\n\tKN.attr(\"MIP_SEL_COMBO_1\") = KN_MIP_SEL_COMBO_1;\n\n\t// MIP terminate values\n\tKN.attr(\"MIP_TERMINATE_OPTIMAL\") = KN_MIP_TERMINATE_OPTIMAL;\n\tKN.attr(\"MIP_TERMINATE_FEASIBLE\") = KN_MIP_TERMINATE_FEASIBLE;\n\n\t// MIP output level values\n\tKN.attr(\"MIP_OUTLEVEL_NONE\") = KN_MIP_OUTLEVEL_NONE;\n\tKN.attr(\"MIP_OUTLEVEL_ITERS\") = KN_MIP_OUTLEVEL_ITERS;\n\tKN.attr(\"MIP_OUTLEVEL_ITERSTIME\") = KN_MIP_OUTLEVEL_ITERSTIME;\n\tKN.attr(\"MIP_OUTLEVEL_ROOT\") = KN_MIP_OUTLEVEL_ROOT;\n\n\t// MIP rounding values\n\tKN.attr(\"MIP_ROUND_AUTO\") = KN_MIP_ROUND_AUTO;\n\tKN.attr(\"MIP_ROUND_NONE\") = KN_MIP_ROUND_NONE;\n\tKN.attr(\"MIP_ROUND_HEURISTIC\") = KN_MIP_ROUND_HEURISTIC;\n\tKN.attr(\"MIP_ROUND_NLP_SOME\") = KN_MIP_ROUND_NLP_SOME;\n\tKN.attr(\"MIP_ROUND_NLP_ALWAYS\") = KN_MIP_ROUND_NLP_ALWAYS;\n\n\t// MIP heuristic strategy values\n\tKN.attr(\"MIP_HEUR_STRATEGY_AUTO\") = KN_MIP_HEUR_STRATEGY_AUTO;\n\tKN.attr(\"MIP_HEUR_STRATEGY_NONE\") = KN_MIP_HEUR_STRATEGY_NONE;\n\tKN.attr(\"MIP_HEUR_STRATEGY_BASIC\") = KN_MIP_HEUR_STRATEGY_BASIC;\n\tKN.attr(\"MIP_HEUR_STRATEGY_ADVANCED\") = KN_MIP_HEUR_STRATEGY_ADVANCED;\n\tKN.attr(\"MIP_HEUR_STRATEGY_EXTENSIVE\") = KN_MIP_HEUR_STRATEGY_EXTENSIVE;\n}\n" }, { "path": "lib/main.cpp", "content": "#include \"pyoptinterface/nleval.hpp\"\n#include \"pyoptinterface/cppad_interface.hpp\"\n\nvoid test_linear_eval()\n{\n\tLinearEvaluator evaluator;\n\t{\n\t\tScalarAffineFunction f;\n\t\tf.add_constant(1.0);\n\t\tf.add_term(0, 2.0);\n\n\t\tevaluator.add_row(f);\n\t}\n\n\t{\n\t\tScalarAffineFunction f;\n\t\tf.add_term(1, 3.0);\n\t\tf.add_term(0, 4.0);\n\t\tevaluator.add_row(f);\n\t}\n\n\tstd::vector x = {1.0, 2.0};\n\tstd::vector f(2);\n\tevaluator.eval_function(x.data(), f.data());\n\n\tsize_t global_jabobian_nnz = 0;\n\tstd::vector global_jacobian_rows, global_jacobian_cols;\n\tevaluator.analyze_jacobian_structure(global_jabobian_nnz, global_jacobian_rows,\n\t global_jacobian_cols);\n\n\tstd::vector jacobian(global_jabobian_nnz);\n\tevaluator.eval_jacobian(x.data(), jacobian.data());\n}\n\nvoid test_quadratic_eval()\n{\n\tQuadraticEvaluator evaluator;\n\t{\n\t\tScalarQuadraticFunction f;\n\t\tf.add_constant(1.0);\n\t\tf.add_quadratic_term(0, 1, 4.0);\n\t\tf.add_quadratic_term(0, 0, 1.0);\n\t\tf.add_affine_term(0, 4.0);\n\t\tevaluator.add_row(f);\n\t}\n\tstd::vector x = {1.0, 2.0};\n\tstd::vector f(1);\n\tevaluator.eval_function(x.data(), f.data());\n\tsize_t global_jabobian_nnz = 0;\n\tstd::vector global_jacobian_rows, global_jacobian_cols;\n\tevaluator.analyze_jacobian_structure(0, global_jabobian_nnz, global_jacobian_rows,\n\t global_jacobian_cols);\n\tstd::vector jacobian(global_jabobian_nnz);\n\tevaluator.eval_jacobian(x.data(), jacobian.data());\n\tsize_t global_hessian_nnz = 0;\n\tstd::vector global_hessian_rows, global_hessian_cols;\n\tHashmap, int> global_hessian_index_map;\n\tHessianSparsityType global_hessian_type = HessianSparsityType::Upper;\n\tevaluator.analyze_hessian_structure(global_hessian_nnz, global_hessian_rows,\n\t global_hessian_cols, global_hessian_index_map,\n\t global_hessian_type);\n\tstd::vector hessian(global_hessian_nnz);\n\tstd::vector lambda = {1.0};\n\tevaluator.eval_lagrangian_hessian(lambda.data(), hessian.data());\n}\n\nvoid test_cppad_pow_var_par()\n{\n\tstd::vector> x(2);\n\n\tauto N_parameters = 2;\n\tstd::vector> p(N_parameters);\n\tfor (size_t i = 0; i < N_parameters; i++)\n\t{\n\t\tp[i] = CppAD::AD(i + 1);\n\t}\n\tif (N_parameters > 0)\n\t{\n\t\tCppAD::Independent(x, p);\n\t}\n\telse\n\t{\n\t\tCppAD::Independent(x);\n\t}\n\n\tauto N_outputs = 1;\n\tstd::vector> y(N_outputs);\n\n\t// Trace the outputs\n\tfor (size_t i = 0; i < N_outputs; i++)\n\t{\n\t\ty[i] = CppAD::pow(x[i], p[i]);\n\t}\n\n\tADFunDouble f;\n\tf.Dependent(x, y);\n\n\tCppAD::cpp_graph f_graph;\n\tf.to_graph(f_graph);\n\n\t// Print the graph\n\tf_graph.print(std::cout);\n}\n\nauto main() -> int\n{\n\ttest_cppad_pow_var_par();\n\treturn 0;\n}" }, { "path": "lib/mosek_model.cpp", "content": "#include \"pyoptinterface/mosek_model.hpp\"\n#include \"fmt/core.h\"\n\nnamespace mosek\n{\n#define B DYLIB_DECLARE\nAPILIST\n#undef B\n\nstatic DynamicLibrary lib;\nstatic bool is_loaded = false;\n\nbool is_library_loaded()\n{\n\treturn is_loaded;\n}\n\nbool load_library(const std::string &path)\n{\n\tbool success = lib.try_load(path.c_str());\n\tif (!success)\n\t{\n\t\treturn false;\n\t}\n\n\tDYLIB_LOAD_INIT;\n\n#define B DYLIB_LOAD_FUNCTION\n\tAPILIST\n#undef B\n\n\tif (IS_DYLIB_LOAD_SUCCESS)\n\t{\n#define B DYLIB_SAVE_FUNCTION\n\t\tAPILIST\n#undef B\n\t\tis_loaded = true;\n\t\treturn true;\n\t}\n\telse\n\t{\n\t\treturn false;\n\t}\n}\n} // namespace mosek\n\n// specialize the template for MOSEK\ntemplate <>\ntemplate <>\nvoid QuadraticFunctionPtrForm::make(\n MOSEKModel *model, const ScalarQuadraticFunction &function)\n{\n\tauto f_numnz = function.size();\n\tnumnz = f_numnz;\n\trow_storage.resize(numnz);\n\tcol_storage.resize(numnz);\n\tfor (int i = 0; i < numnz; ++i)\n\t{\n\t\tauto v1 = model->_variable_index(function.variable_1s[i]);\n\t\tauto v2 = v1;\n\t\tif (function.variable_1s[i] != function.variable_2s[i])\n\t\t{\n\t\t\tv2 = model->_variable_index(function.variable_2s[i]);\n\t\t\t// MOSEK only accepts the lower triangle (i >= j)\n\t\t\tif (v1 < v2)\n\t\t\t{\n\t\t\t\tstd::swap(v1, v2);\n\t\t\t}\n\t\t}\n\n\t\trow_storage[i] = v1;\n\t\tcol_storage[i] = v2;\n\t}\n\trow = row_storage.data();\n\tcol = col_storage.data();\n\n\t// MOSEK has 1/2 * x^T @ Q @ x, so we need to multiply the coefficient by 2 for diagonal terms\n\tvalue_storage.resize(numnz);\n\tfor (int i = 0; i < numnz; ++i)\n\t{\n\t\tif (function.variable_1s[i] == function.variable_2s[i])\n\t\t{\n\t\t\tvalue_storage[i] = 2 * function.coefficients[i];\n\t\t}\n\t\telse\n\t\t{\n\t\t\tvalue_storage[i] = function.coefficients[i];\n\t\t}\n\t}\n\tvalue = value_storage.data();\n}\n\nstatic void check_error(MSKrescodee error)\n{\n\tif (error != MSK_RES_OK)\n\t{\n\t\tchar symname[MSK_MAX_STR_LEN];\n\t\tchar desc[MSK_MAX_STR_LEN];\n\t\tmosek::MSK_getcodedesc(error, symname, desc);\n\n\t\tstd::string errmsg = fmt::format(\"Error {} : {}\", symname, desc);\n\n\t\tthrow std::runtime_error(errmsg);\n\t}\n}\n\nstatic MSKboundkeye mosek_con_sense(ConstraintSense sense)\n{\n\tswitch (sense)\n\t{\n\tcase ConstraintSense::LessEqual:\n\t\treturn MSK_BK_UP;\n\tcase ConstraintSense::Equal:\n\t\treturn MSK_BK_FX;\n\tcase ConstraintSense::GreaterEqual:\n\t\treturn MSK_BK_LO;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint sense\");\n\t}\n}\n\nstatic MSKobjsensee mosek_obj_sense(ObjectiveSense sense)\n{\n\tswitch (sense)\n\t{\n\tcase ObjectiveSense::Minimize:\n\t\treturn MSK_OBJECTIVE_SENSE_MINIMIZE;\n\tcase ObjectiveSense::Maximize:\n\t\treturn MSK_OBJECTIVE_SENSE_MAXIMIZE;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown objective sense\");\n\t}\n}\n\nstatic MSKvariabletypee mosek_vtype(VariableDomain domain)\n{\n\tswitch (domain)\n\t{\n\tcase VariableDomain::Continuous:\n\t\treturn MSK_VAR_TYPE_CONT;\n\tcase VariableDomain::Integer:\n\tcase VariableDomain::Binary:\n\t\treturn MSK_VAR_TYPE_INT;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown variable domain\");\n\t}\n}\n\nstatic VariableDomain mosek_vtype_to_domain(MSKvariabletypee vtype)\n{\n\tswitch (vtype)\n\t{\n\tcase MSK_VAR_TYPE_CONT:\n\t\treturn VariableDomain::Continuous;\n\tcase MSK_VAR_TYPE_INT:\n\t\treturn VariableDomain::Integer;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown variable domain\");\n\t}\n}\n\nMOSEKModel::MOSEKModel(const MOSEKEnv &env)\n{\n\tinit(env);\n}\n\nvoid MOSEKModel::init(const MOSEKEnv &env)\n{\n\tif (!mosek::is_library_loaded())\n\t{\n\t\tthrow std::runtime_error(\"Mosek library is not loaded\");\n\t}\n\tMSKtask_t model;\n\tauto error = mosek::MSK_makeemptytask(env.m_env, &model);\n\tcheck_error(error);\n\tm_model = std::unique_ptr(model);\n}\n\nvoid MOSEKModel::close()\n{\n\tm_model.reset();\n}\n\nvoid MOSEKModel::write(const std::string &filename)\n{\n\tbool is_solution = false;\n\tif (filename.ends_with(\".sol\") || filename.ends_with(\".bas\") || filename.ends_with(\".int\") ||\n\t filename.ends_with(\".jsol\"))\n\t{\n\t\tis_solution = true;\n\t}\n\tMSKrescodee error;\n\tif (is_solution)\n\t{\n\t\tif (m_soltype)\n\t\t{\n\t\t\terror = mosek::MSK_writesolution(m_model.get(), m_soltype.value(), filename.c_str());\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthrow std::runtime_error(\n\t\t\t \"Solution type is unavailable. Please optimize before writing solution.\");\n\t\t}\n\t}\n\telse\n\t{\n\t\terror = mosek::MSK_writedata(m_model.get(), filename.c_str());\n\t}\n\tcheck_error(error);\n}\n\nVariableIndex MOSEKModel::add_variable(VariableDomain domain, double lb, double ub,\n const char *name)\n{\n\tm_is_dirty = true;\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\tIndexT index = m_variable_index.add_index();\n\tVariableIndex variable(index);\n\n\tauto error = mosek::MSK_appendvars(m_model.get(), 1);\n\tcheck_error(error);\n\n\tMSKint32t column;\n\terror = mosek::MSK_getnumvar(m_model.get(), &column);\n\tcheck_error(error);\n\t// 0-based indexing\n\tcolumn -= 1;\n\n\tauto vtype = mosek_vtype(domain);\n\terror = mosek::MSK_putvartype(m_model.get(), column, vtype);\n\tcheck_error(error);\n\n\tMSKboundkeye bk;\n\tif (domain == VariableDomain::Binary)\n\t{\n\t\tbk = MSK_BK_RA;\n\t\tlb = 0.0;\n\t\tub = 1.0;\n\t\tbinary_variables.insert(index);\n\t}\n\telse\n\t{\n\t\tbool lb_inf = lb < 1.0 - MSK_INFINITY;\n\t\tbool ub_inf = ub > MSK_INFINITY - 1.0;\n\t\tif (lb_inf && ub_inf)\n\t\t\tbk = MSK_BK_FR;\n\t\telse if (lb_inf)\n\t\t\tbk = MSK_BK_UP;\n\t\telse if (ub_inf)\n\t\t\tbk = MSK_BK_LO;\n\t\telse\n\t\t\tbk = MSK_BK_RA;\n\t}\n\terror = mosek::MSK_putvarbound(m_model.get(), column, bk, lb, ub);\n\tcheck_error(error);\n\n\tif (name)\n\t{\n\t\terror = mosek::MSK_putvarname(m_model.get(), column, name);\n\t\tcheck_error(error);\n\t}\n\n\treturn variable;\n}\n\n// VariableIndex MOSEKModel::add_variables(int N, VariableDomain domain, double lb, double ub)\n//{\n//\tIndexT index = m_variable_index.add_indices(N);\n//\tVariableIndex variable(index);\n//\n//\tauto error = MSK_appendvars(m_model.get(), N);\n//\tcheck_error(error);\n//\n//\tMSKint32t column;\n//\terror = MSK_getnumvar(m_model.get(), &column);\n//\tcheck_error(error);\n//\t// 0-based indexing\n//\tcolumn -= N;\n//\tstd::vector columns(N);\n//\tfor (int i = 0; i < N; i++)\n//\t{\n//\t\tcolumns[i] = column + i;\n//\t}\n//\n//\tMSKvariabletypee vtype = mosek_vtype(domain);\n//\tstd::vector vtypes(N, vtype);\n//\terror = MSK_putvartypelist(m_model.get(), N, columns.data(), vtypes.data());\n//\tcheck_error(error);\n//\n//\tMSKboundkeye bk;\n//\tif (domain == VariableDomain::Binary)\n//\t{\n//\t\tbk = MSK_BK_RA;\n//\t\tlb = 0.0;\n//\t\tub = 1.0;\n//\t\tfor (int i = 0; i < N; i++)\n//\t\t{\n//\t\t\tbinary_variables.insert(index + i);\n//\t\t}\n//\t}\n//\telse\n//\t{\n//\t\tbool lb_inf = lb < 1.0 - MSK_INFINITY;\n//\t\tbool ub_inf = ub > MSK_INFINITY - 1.0;\n//\t\tif (lb_inf && ub_inf)\n//\t\t\tbk = MSK_BK_FR;\n//\t\telse if (lb_inf)\n//\t\t\tbk = MSK_BK_UP;\n//\t\telse if (ub_inf)\n//\t\t\tbk = MSK_BK_LO;\n//\t\telse\n//\t\t\tbk = MSK_BK_RA;\n//\t}\n//\tstd::vector bks(N, bk);\n//\tstd::vector lbs(N, lb);\n//\tstd::vector ubs(N, ub);\n//\terror =\n//\t MSK_putvarboundlist(m_model.get(), N, columns.data(), bks.data(), lbs.data(), ubs.data());\n//\tcheck_error(error);\n//\n//\treturn variable;\n// }\n\nvoid MOSEKModel::delete_variable(const VariableIndex &variable)\n{\n\tm_is_dirty = true;\n\tif (!is_variable_active(variable))\n\t{\n\t\tthrow std::runtime_error(\"Variable does not exist\");\n\t}\n\n\tint variable_column = _variable_index(variable);\n\tauto error = mosek::MSK_removevars(m_model.get(), 1, &variable_column);\n\tcheck_error(error);\n\n\tm_variable_index.delete_index(variable.index);\n\tbinary_variables.erase(variable.index);\n}\n\nvoid MOSEKModel::delete_variables(const Vector &variables)\n{\n\tm_is_dirty = true;\n\tint n_variables = variables.size();\n\tif (n_variables == 0)\n\t\treturn;\n\n\tstd::vector columns;\n\tcolumns.reserve(n_variables);\n\tfor (int i = 0; i < n_variables; i++)\n\t{\n\t\tif (!is_variable_active(variables[i]))\n\t\t{\n\t\t\tcontinue;\n\t\t}\n\t\tauto column = _variable_index(variables[i]);\n\t\tcolumns.push_back(column);\n\t}\n\n\tauto error = mosek::MSK_removevars(m_model.get(), columns.size(), columns.data());\n\tcheck_error(error);\n\n\tfor (int i = 0; i < n_variables; i++)\n\t{\n\t\tm_variable_index.delete_index(variables[i].index);\n\t}\n}\n\nbool MOSEKModel::is_variable_active(const VariableIndex &variable)\n{\n\treturn m_variable_index.has_index(variable.index);\n}\n\ndouble MOSEKModel::get_variable_value(const VariableIndex &variable)\n{\n\tauto column = _checked_variable_index(variable);\n\tMSKrealt retval;\n\tauto soltype = get_current_solution();\n\tauto error = mosek::MSK_getxxslice(m_model.get(), soltype, column, column + 1, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nstd::string MOSEKModel::pprint_variable(const VariableIndex &variable)\n{\n\treturn get_variable_name(variable);\n}\n\nvoid MOSEKModel::set_variable_bounds(const VariableIndex &variable, double lb, double ub)\n{\n\tm_is_dirty = true;\n\tauto column = _checked_variable_index(variable);\n\tMSKboundkeye bk;\n\tif (lb == ub)\n\t{\n\t\tbk = MSK_BK_FX;\n\t}\n\telse\n\t{\n\t\tbk = MSK_BK_RA;\n\t}\n\tauto error = mosek::MSK_putvarbound(m_model.get(), column, bk, lb, ub);\n\tcheck_error(error);\n}\n\nConstraintIndex MOSEKModel::add_linear_constraint(const ScalarAffineFunction &function,\n ConstraintSense sense, CoeffT rhs,\n const char *name)\n{\n\tm_is_dirty = true;\n\tIndexT index = m_linear_quadratic_constraint_index.add_index();\n\tConstraintIndex constraint_index(ConstraintType::Linear, index);\n\n\tauto error = mosek::MSK_appendcons(m_model.get(), 1);\n\tcheck_error(error);\n\n\tMSKint32t row;\n\terror = mosek::MSK_getnumcon(m_model.get(), &row);\n\tcheck_error(error);\n\t// 0-based indexing\n\trow -= 1;\n\n\tAffineFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\n\tMSKint32t numnz = ptr_form.numnz;\n\tMSKint32t *cind = ptr_form.index;\n\tMSKrealt *cval = ptr_form.value;\n\tMSKboundkeye g_sense = mosek_con_sense(sense);\n\tMSKrealt g_rhs = rhs - function.constant.value_or(0.0);\n\n\terror = mosek::MSK_putarow(m_model.get(), row, numnz, cind, cval);\n\tcheck_error(error);\n\terror = mosek::MSK_putconbound(m_model.get(), row, g_sense, g_rhs, g_rhs);\n\tcheck_error(error);\n\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\tif (name)\n\t{\n\t\terror = mosek::MSK_putconname(m_model.get(), row, name);\n\t\tcheck_error(error);\n\t}\n\n\treturn constraint_index;\n}\n\nConstraintIndex MOSEKModel::add_linear_constraint(const ScalarAffineFunction &function,\n const std::tuple &interval,\n const char *name)\n{\n\tm_is_dirty = true;\n\tIndexT index = m_linear_quadratic_constraint_index.add_index();\n\tConstraintIndex constraint_index(ConstraintType::Linear, index);\n\n\tauto error = mosek::MSK_appendcons(m_model.get(), 1);\n\tcheck_error(error);\n\n\tMSKint32t row;\n\terror = mosek::MSK_getnumcon(m_model.get(), &row);\n\tcheck_error(error);\n\t// 0-based indexing\n\trow -= 1;\n\n\tAffineFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\n\tMSKint32t numnz = ptr_form.numnz;\n\tMSKint32t *cind = ptr_form.index;\n\tMSKrealt *cval = ptr_form.value;\n\tdouble lb = std::get<0>(interval);\n\tdouble ub = std::get<1>(interval);\n\tif (function.constant.has_value())\n\t{\n\t\tlb -= function.constant.value();\n\t\tub -= function.constant.value();\n\t}\n\n\terror = mosek::MSK_putarow(m_model.get(), row, numnz, cind, cval);\n\tcheck_error(error);\n\terror = mosek::MSK_putconbound(m_model.get(), row, MSK_BK_RA, lb, ub);\n\tcheck_error(error);\n\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\tif (name)\n\t{\n\t\terror = mosek::MSK_putconname(m_model.get(), row, name);\n\t\tcheck_error(error);\n\t}\n\n\treturn constraint_index;\n}\n\nConstraintIndex MOSEKModel::add_quadratic_constraint(const ScalarQuadraticFunction &function,\n ConstraintSense sense, CoeffT rhs,\n const char *name)\n{\n\tm_is_dirty = true;\n\tIndexT index = m_linear_quadratic_constraint_index.add_index();\n\tConstraintIndex constraint_index(ConstraintType::Quadratic, index);\n\n\tauto error = mosek::MSK_appendcons(m_model.get(), 1);\n\tcheck_error(error);\n\n\tMSKint32t row;\n\terror = mosek::MSK_getnumcon(m_model.get(), &row);\n\tcheck_error(error);\n\t// 0-based indexing\n\trow -= 1;\n\n\tconst auto &affine_part = function.affine_part;\n\n\tMSKint32t numlnz = 0;\n\tMSKint32t *lind = NULL;\n\tMSKrealt *lval = NULL;\n\tAffineFunctionPtrForm affine_ptr_form;\n\tif (affine_part.has_value())\n\t{\n\t\tconst auto &affine_function = affine_part.value();\n\t\taffine_ptr_form.make(this, affine_function);\n\t\tnumlnz = affine_ptr_form.numnz;\n\t\tlind = affine_ptr_form.index;\n\t\tlval = affine_ptr_form.value;\n\t}\n\n\tQuadraticFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\tMSKint32t numqnz = ptr_form.numnz;\n\tMSKint32t *qrow = ptr_form.row;\n\tMSKint32t *qcol = ptr_form.col;\n\tMSKrealt *qval = ptr_form.value;\n\n\tMSKboundkeye g_sense = mosek_con_sense(sense);\n\tMSKrealt g_rhs = rhs;\n\tif (affine_part)\n\t\tg_rhs -= affine_part->constant.value_or(0.0);\n\n\terror = mosek::MSK_putarow(m_model.get(), row, numlnz, lind, lval);\n\tcheck_error(error);\n\terror = mosek::MSK_putqconk(m_model.get(), row, numqnz, qrow, qcol, qval);\n\tcheck_error(error);\n\terror = mosek::MSK_putconbound(m_model.get(), row, g_sense, g_rhs, g_rhs);\n\tcheck_error(error);\n\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\tif (name)\n\t{\n\t\terror = mosek::MSK_putconname(m_model.get(), row, name);\n\t\tcheck_error(error);\n\t}\n\n\treturn constraint_index;\n}\n\nstd::vector MOSEKModel::add_variables_as_afe(const Vector &variables)\n{\n\tm_is_dirty = true;\n\tauto N = variables.size();\n\n\t// afe part\n\tMSKint64t numafe;\n\tauto error = mosek::MSK_getnumafe(m_model.get(), &numafe);\n\tcheck_error(error);\n\n\tstd::vector afe_index(N);\n\tfor (int i = 0; i < N; i++)\n\t{\n\t\tafe_index[i] = numafe + i;\n\t}\n\n\tstd::vector var_index(N);\n\tfor (int i = 0; i < N; i++)\n\t{\n\t\tvar_index[i] = _checked_variable_index(variables[i]);\n\t}\n\n\tstd::vector vals(N, 1.0);\n\n\terror = mosek::MSK_appendafes(m_model.get(), N);\n\tcheck_error(error);\n\n\terror = mosek::MSK_putafefentrylist(m_model.get(), N, afe_index.data(), var_index.data(),\n\t vals.data());\n\tcheck_error(error);\n\n\treturn afe_index;\n}\n\nConstraintIndex MOSEKModel::add_variables_in_cone_constraint(const Vector &variables,\n MSKint64t domain_index,\n ConstraintType type, const char *name)\n{\n\tm_is_dirty = true;\n\tauto N = variables.size();\n\n\tIndexT index = m_acc_index.size();\n\tm_acc_index.push_back(true);\n\tConstraintIndex constraint_index(type, index);\n\n\t// afe part\n\tstd::vector afe_index = add_variables_as_afe(variables);\n\n\t// domain part\n\n\t// add acc\n\tauto error = mosek::MSK_appendacc(m_model.get(), domain_index, N, afe_index.data(), nullptr);\n\tcheck_error(error);\n\n\t// set name\n\tif (name != nullptr && name[0] == '\\0')\n\t{\n\t\tname = nullptr;\n\t}\n\tif (name)\n\t{\n\t\terror = mosek::MSK_putaccname(m_model.get(), index, name);\n\t\tcheck_error(error);\n\t}\n\n\treturn constraint_index;\n}\n\nConstraintIndex MOSEKModel::add_second_order_cone_constraint(const Vector &variables,\n const char *name, bool rotated)\n{\n\tm_is_dirty = true;\n\tauto N = variables.size();\n\n\t// domain part\n\tMSKint64t domain_index;\n\tMSKrescodee error;\n\tif (rotated)\n\t{\n\t\terror = mosek::MSK_appendrquadraticconedomain(m_model.get(), N, &domain_index);\n\t}\n\telse\n\t{\n\t\terror = mosek::MSK_appendquadraticconedomain(m_model.get(), N, &domain_index);\n\t}\n\tcheck_error(error);\n\n\tauto con = add_variables_in_cone_constraint(variables, domain_index,\n\t ConstraintType::SecondOrderCone, name);\n\n\treturn con;\n}\n\nConstraintIndex MOSEKModel::add_exp_cone_constraint(const Vector &variables,\n const char *name, bool dual)\n{\n\tm_is_dirty = true;\n\tauto N = variables.size();\n\tif (N != 3)\n\t{\n\t\tthrow std::runtime_error(\"Exponential cone constraint must have 3 variables\");\n\t}\n\n\t// domain part\n\tMSKint64t domain_index;\n\tMSKrescodee error;\n\tif (dual)\n\t{\n\t\terror = mosek::MSK_appenddualexpconedomain(m_model.get(), &domain_index);\n\t}\n\telse\n\t{\n\t\terror = mosek::MSK_appendprimalexpconedomain(m_model.get(), &domain_index);\n\t}\n\tcheck_error(error);\n\n\tauto con = add_variables_in_cone_constraint(variables, domain_index,\n\t ConstraintType::ExponentialCone, name);\n\n\treturn con;\n}\n\nvoid MOSEKModel::delete_constraint(const ConstraintIndex &constraint)\n{\n\tm_is_dirty = true;\n\tMSKrescodee error;\n\tMSKint32t constraint_row = _constraint_index(constraint);\n\tif (constraint_row < 0)\n\t\treturn;\n\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\tcase ConstraintType::Quadratic:\n\t\tm_linear_quadratic_constraint_index.delete_index(constraint.index);\n\t\terror = mosek::MSK_removecons(m_model.get(), 1, &constraint_row);\n\t\tbreak;\n\tcase ConstraintType::SecondOrderCone:\n\tcase ConstraintType::ExponentialCone: {\n\t\tm_acc_index[constraint.index] = false;\n\t\t// ACC cannot be deleted, we just set its domain to R^n (no constraint)\n\t\t// get the dimension of this ACC\n\t\tMSKint64t N;\n\t\terror = mosek::MSK_getaccn(m_model.get(), constraint_row, &N);\n\t\tcheck_error(error);\n\t\t// get AFE list of ACC\n\t\tstd::vector afeidxlist(N);\n\t\terror = mosek::MSK_getaccafeidxlist(m_model.get(), constraint_row, afeidxlist.data());\n\t\tcheck_error(error);\n\t\t// add a N-dim Rn domain\n\t\tMSKint64t domain_index;\n\t\terror = mosek::MSK_appendrdomain(m_model.get(), N, &domain_index);\n\t\tcheck_error(error);\n\t\t// set the ACC to this domain\n\t\terror = mosek::MSK_putacc(m_model.get(), constraint_row, domain_index, N, afeidxlist.data(),\n\t\t nullptr);\n\t\tcheck_error(error);\n\t}\n\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n\tcheck_error(error);\n}\n\nbool MOSEKModel::is_constraint_active(const ConstraintIndex &constraint)\n{\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\tcase ConstraintType::Quadratic:\n\t\treturn m_linear_quadratic_constraint_index.has_index(constraint.index);\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n}\n\nvoid MOSEKModel::_set_affine_objective(const ScalarAffineFunction &function, ObjectiveSense sense,\n bool clear_quadratic)\n{\n\tMSKrescodee error;\n\tif (clear_quadratic)\n\t{\n\t\t// First delete all quadratic terms\n\t\terror = mosek::MSK_putqobj(m_model.get(), 0, nullptr, nullptr, nullptr);\n\t\tcheck_error(error);\n\t}\n\n\t// Set Obj attribute of each variable\n\tMSKint32t n_variables;\n\terror = mosek::MSK_getnumvar(m_model.get(), &n_variables);\n\tcheck_error(error);\n\tstd::vector obj_v(n_variables, 0.0);\n\n\tint numnz = function.size();\n\tfor (int i = 0; i < numnz; i++)\n\t{\n\t\tauto column = _variable_index(function.variables[i]);\n\t\tif (column < 0)\n\t\t{\n\t\t\tthrow std::runtime_error(\"Variable does not exist\");\n\t\t}\n\t\tobj_v[column] = function.coefficients[i];\n\t}\n\n\terror = mosek::MSK_putcslice(m_model.get(), 0, n_variables, obj_v.data());\n\tcheck_error(error);\n\terror = mosek::MSK_putcfix(m_model.get(), function.constant.value_or(0.0));\n\tcheck_error(error);\n\n\tMSKobjsensee obj_sense = mosek_obj_sense(sense);\n\terror = mosek::MSK_putobjsense(m_model.get(), obj_sense);\n\tcheck_error(error);\n}\n\nvoid MOSEKModel::set_objective(const ScalarAffineFunction &function, ObjectiveSense sense)\n{\n\tm_is_dirty = true;\n\t_set_affine_objective(function, sense, true);\n}\n\nvoid MOSEKModel::set_objective(const ScalarQuadraticFunction &function, ObjectiveSense sense)\n{\n\tm_is_dirty = true;\n\tMSKrescodee error;\n\n\t// Add quadratic term\n\tint numqnz = function.size();\n\tif (numqnz > 0)\n\t{\n\t\tQuadraticFunctionPtrForm ptr_form;\n\t\tptr_form.make(this, function);\n\t\tMSKint32t numqnz = ptr_form.numnz;\n\t\tMSKint32t *qrow = ptr_form.row;\n\t\tMSKint32t *qcol = ptr_form.col;\n\t\tMSKrealt *qval = ptr_form.value;\n\n\t\terror = mosek::MSK_putqobj(m_model.get(), numqnz, qrow, qcol, qval);\n\t\tcheck_error(error);\n\t}\n\telse\n\t{\n\t\t// delete all quadratic terms\n\t\terror = mosek::MSK_putqobj(m_model.get(), 0, nullptr, nullptr, nullptr);\n\t\tcheck_error(error);\n\t}\n\n\t// Affine part\n\tconst auto &affine_part = function.affine_part;\n\tif (affine_part)\n\t{\n\t\tconst auto &affine_function = affine_part.value();\n\t\t_set_affine_objective(affine_function, sense, false);\n\t}\n\telse\n\t{\n\t\tScalarAffineFunction zero;\n\t\t_set_affine_objective(zero, sense, false);\n\t}\n}\n\nvoid MOSEKModel::set_objective(const ExprBuilder &function, ObjectiveSense sense)\n{\n\tm_is_dirty = true;\n\tauto deg = function.degree();\n\tif (deg <= 1)\n\t{\n\t\tScalarAffineFunction f(function);\n\t\tset_objective(f, sense);\n\t}\n\telse if (deg == 2)\n\t{\n\t\tScalarQuadraticFunction f(function);\n\t\tset_objective(f, sense);\n\t}\n\telse\n\t{\n\t\tthrow std::runtime_error(\"Objective must be linear or quadratic\");\n\t}\n}\n\nint MOSEKModel::optimize()\n{\n\tm_is_dirty = false;\n\tauto error = mosek::MSK_optimize(m_model.get());\n\tm_soltype = select_available_solution_after_optimization();\n\treturn error;\n}\n\nint MOSEKModel::raw_parameter_type(const char *name)\n{\n\tMSKparametertypee type;\n\tMSKint32t index;\n\tauto error = mosek::MSK_whichparam(m_model.get(), name, &type, &index);\n\tcheck_error(error);\n\treturn type;\n}\n\nvoid MOSEKModel::set_raw_parameter_int(const char *param_name, int value)\n{\n\tm_is_dirty = true;\n\tauto error = mosek::MSK_putnaintparam(m_model.get(), param_name, value);\n\tcheck_error(error);\n}\n\nvoid MOSEKModel::set_raw_parameter_double(const char *param_name, double value)\n{\n\tm_is_dirty = true;\n\tauto error = mosek::MSK_putnadouparam(m_model.get(), param_name, value);\n\tcheck_error(error);\n}\n\nvoid MOSEKModel::set_raw_parameter_string(const char *param_name, const char *value)\n{\n\tm_is_dirty = true;\n\tauto error = mosek::MSK_putnastrparam(m_model.get(), param_name, value);\n\tcheck_error(error);\n}\n\nint MOSEKModel::get_raw_parameter_int(const char *param_name)\n{\n\tint retval;\n\tauto error = mosek::MSK_getnaintparam(m_model.get(), param_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble MOSEKModel::get_raw_parameter_double(const char *param_name)\n{\n\tdouble retval;\n\tauto error = mosek::MSK_getnadouparam(m_model.get(), param_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nstd::string MOSEKModel::get_raw_parameter_string(const char *param_name)\n{\n\tchar retval[MSK_MAX_STR_LEN];\n\tMSKint32t len;\n\tauto error =\n\t mosek::MSK_getnastrparam(m_model.get(), param_name, strlen(param_name), &len, retval);\n\tcheck_error(error);\n\treturn std::string(retval, len);\n}\n\nint MOSEKModel::get_raw_information_int(const char *attr_name)\n{\n\tint retval;\n\tauto error = mosek::MSK_getnaintinf(m_model.get(), attr_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble MOSEKModel::get_raw_information_double(const char *attr_name)\n{\n\tdouble retval;\n\tauto error = mosek::MSK_getnadouinf(m_model.get(), attr_name, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nMSKint32t MOSEKModel::getnumvar()\n{\n\tMSKint32t retval;\n\tauto error = mosek::MSK_getnumvar(m_model.get(), &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nMSKint32t MOSEKModel::getnumcon()\n{\n\tMSKint32t retval;\n\tauto error = mosek::MSK_getnumcon(m_model.get(), &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nint MOSEKModel::getprosta()\n{\n\tMSKprostae retval;\n\tauto error = mosek::MSK_getprosta(m_model.get(), get_current_solution(), &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nint MOSEKModel::getsolsta()\n{\n\tMSKsolstae retval;\n\tauto error = mosek::MSK_getsolsta(m_model.get(), get_current_solution(), &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble MOSEKModel::getprimalobj()\n{\n\tMSKrealt retval;\n\tauto error = mosek::MSK_getprimalobj(m_model.get(), get_current_solution(), &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble MOSEKModel::getdualobj()\n{\n\tMSKrealt retval;\n\tauto error = mosek::MSK_getdualobj(m_model.get(), get_current_solution(), &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nvoid MOSEKModel::disable_log()\n{\n\tauto error = mosek::MSK_linkfunctotaskstream(m_model.get(), MSK_STREAM_LOG, NULL, NULL);\n\tcheck_error(error);\n}\n\nstd::string MOSEKModel::get_variable_name(const VariableIndex &variable)\n{\n\tauto column = _checked_variable_index(variable);\n\tchar name[MSK_MAX_STR_LEN];\n\tauto error = mosek::MSK_getvarname(m_model.get(), column, MSK_MAX_STR_LEN, name);\n\tcheck_error(error);\n\treturn name;\n}\n\nvoid MOSEKModel::set_variable_name(const VariableIndex &variable, const char *name)\n{\n\tm_is_dirty = true;\n\tauto column = _checked_variable_index(variable);\n\tauto error = mosek::MSK_putvarname(m_model.get(), column, name);\n\tcheck_error(error);\n}\n\nVariableDomain MOSEKModel::get_variable_type(const VariableIndex &variable)\n{\n\tif (binary_variables.contains(variable.index))\n\t{\n\t\treturn VariableDomain::Binary;\n\t}\n\tauto column = _checked_variable_index(variable);\n\tMSKvariabletypee vtype;\n\tauto error = mosek::MSK_getvartype(m_model.get(), column, &vtype);\n\tcheck_error(error);\n\treturn mosek_vtype_to_domain(vtype);\n}\n\nvoid MOSEKModel::set_variable_type(const VariableIndex &variable, VariableDomain domain)\n{\n\tm_is_dirty = true;\n\tMSKvariabletypee vtype = mosek_vtype(domain);\n\tauto column = _checked_variable_index(variable);\n\tauto error = mosek::MSK_putvartype(m_model.get(), column, vtype);\n\tcheck_error(error);\n\n\tif (domain == VariableDomain::Binary)\n\t{\n\t\tMSKrealt lb = 0.0;\n\t\tMSKrealt ub = 1.0;\n\t\tbinary_variables.insert(variable.index);\n\t\terror = mosek::MSK_putvarbound(m_model.get(), column, MSK_BK_RA, lb, ub);\n\t\tcheck_error(error);\n\t}\n\telse\n\t{\n\t\tbinary_variables.erase(variable.index);\n\t}\n}\n\ndouble MOSEKModel::get_variable_lower_bound(const VariableIndex &variable)\n{\n\tMSKboundkeye bound_type;\n\tMSKrealt lb, ub;\n\tauto column = _checked_variable_index(variable);\n\tauto error = mosek::MSK_getvarbound(m_model.get(), column, &bound_type, &lb, &ub);\n\tcheck_error(error);\n\n\tswitch (bound_type)\n\t{\n\tcase MSK_BK_FR:\n\tcase MSK_BK_UP:\n\t\tlb = -MSK_INFINITY;\n\t\tbreak;\n\tcase MSK_BK_LO:\n\tcase MSK_BK_RA:\n\tcase MSK_BK_FX:\n\t\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown bound type\");\n\t}\n\treturn lb;\n}\n\ndouble MOSEKModel::get_variable_upper_bound(const VariableIndex &variable)\n{\n\tMSKboundkeye bound_type;\n\tMSKrealt lb, ub;\n\tauto column = _checked_variable_index(variable);\n\tauto error = mosek::MSK_getvarbound(m_model.get(), column, &bound_type, &lb, &ub);\n\tcheck_error(error);\n\n\tswitch (bound_type)\n\t{\n\tcase MSK_BK_FR:\n\tcase MSK_BK_LO:\n\t\tub = MSK_INFINITY;\n\t\tbreak;\n\tcase MSK_BK_UP:\n\tcase MSK_BK_RA:\n\tcase MSK_BK_FX:\n\t\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown bound type\");\n\t}\n\treturn ub;\n}\n\nvoid MOSEKModel::set_variable_lower_bound(const VariableIndex &variable, double lb)\n{\n\tm_is_dirty = true;\n\tMSKboundkeye bound_type_old, bound_key;\n\tMSKrealt lb_old, ub_old;\n\tauto column = _checked_variable_index(variable);\n\tauto error = mosek::MSK_getvarbound(m_model.get(), column, &bound_type_old, &lb_old, &ub_old);\n\tcheck_error(error);\n\n\tswitch (bound_type_old)\n\t{\n\tcase MSK_BK_FR:\n\t\tbound_key = MSK_BK_LO;\n\t\tbreak;\n\tcase MSK_BK_LO:\n\t\tbound_key = MSK_BK_LO;\n\t\tbreak;\n\tcase MSK_BK_UP:\n\t\tbound_key = MSK_BK_RA;\n\t\tbreak;\n\tcase MSK_BK_RA:\n\t\tbound_key = MSK_BK_RA;\n\t\tbreak;\n\tcase MSK_BK_FX:\n\t\tthrow std::runtime_error(\"Cannot set lower bound for fixed variable\");\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown bound type\");\n\t}\n\n\terror = mosek::MSK_putvarbound(m_model.get(), column, bound_key, lb, ub_old);\n\tcheck_error(error);\n}\n\nvoid MOSEKModel::set_variable_upper_bound(const VariableIndex &variable, double ub)\n{\n\tm_is_dirty = true;\n\tMSKboundkeye bound_type_old, bound_key;\n\tMSKrealt lb_old, ub_old;\n\tauto column = _checked_variable_index(variable);\n\tauto error = mosek::MSK_getvarbound(m_model.get(), column, &bound_type_old, &lb_old, &ub_old);\n\tcheck_error(error);\n\n\tswitch (bound_type_old)\n\t{\n\tcase MSK_BK_FR:\n\t\tbound_key = MSK_BK_UP;\n\t\tbreak;\n\tcase MSK_BK_UP:\n\t\tbound_key = MSK_BK_UP;\n\t\tbreak;\n\tcase MSK_BK_LO:\n\t\tbound_key = MSK_BK_RA;\n\t\tbreak;\n\tcase MSK_BK_RA:\n\t\tbound_key = MSK_BK_RA;\n\t\tbreak;\n\tcase MSK_BK_FX:\n\t\tthrow std::runtime_error(\"Cannot set upper bound for fixed variable\");\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown bound type\");\n\t}\n\n\terror = mosek::MSK_putvarbound(m_model.get(), column, bound_key, lb_old, ub);\n\tcheck_error(error);\n}\n\nvoid MOSEKModel::set_variable_primal(const VariableIndex &variable, double primal)\n{\n\tm_is_dirty = true;\n\tauto column = _checked_variable_index(variable);\n\tMSKrealt val = primal;\n\tauto error = mosek::MSK_putxxslice(m_model.get(), MSK_SOL_ITG, column, column + 1, &val);\n\tcheck_error(error);\n}\n\ndouble MOSEKModel::get_variable_dual(const VariableIndex &variable)\n{\n\tMSKrealt slx, sux;\n\tauto column = _checked_variable_index(variable);\n\tauto error =\n\t mosek::MSK_getslxslice(m_model.get(), get_current_solution(), column, column + 1, &slx);\n\tcheck_error(error);\n\terror = mosek::MSK_getsuxslice(m_model.get(), get_current_solution(), column, column + 1, &sux);\n\tcheck_error(error);\n\n\tdouble retval = slx - sux;\n\treturn retval;\n}\n\ndouble MOSEKModel::get_constraint_primal(const ConstraintIndex &constraint)\n{\n\tint row = _checked_constraint_index(constraint);\n\tauto soltype = get_current_solution();\n\tMSKrealt retval;\n\tint num = 1;\n\tMSKrescodee error;\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\tcase ConstraintType::Quadratic:\n\t\terror = mosek::MSK_getxcslice(m_model.get(), soltype, constraint.index,\n\t\t constraint.index + num, &retval);\n\t\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n\tcheck_error(error);\n\treturn retval;\n}\n\ndouble MOSEKModel::get_constraint_dual(const ConstraintIndex &constraint)\n{\n\tint row = _checked_constraint_index(constraint);\n\tauto soltype = get_current_solution();\n\tMSKrealt retval;\n\tint num = 1;\n\tMSKrescodee error;\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\tcase ConstraintType::Quadratic:\n\t\terror = mosek::MSK_getyslice(m_model.get(), soltype, constraint.index,\n\t\t constraint.index + num, &retval);\n\t\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n\tcheck_error(error);\n\treturn retval;\n}\n\nstd::string MOSEKModel::get_constraint_name(const ConstraintIndex &constraint)\n{\n\tauto row = _checked_constraint_index(constraint);\n\tMSKrescodee error;\n\tMSKint32t reqsize;\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\tcase ConstraintType::Quadratic:\n\t\terror = mosek::MSK_getconnamelen(m_model.get(), row, &reqsize);\n\t\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n\tcheck_error(error);\n\tstd::string retval(reqsize - 1, '\\0');\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\tcase ConstraintType::Quadratic:\n\t\terror = mosek::MSK_getconname(m_model.get(), row, reqsize, retval.data());\n\t\tbreak;\n\t}\n\tcheck_error(error);\n\treturn retval;\n}\n\nvoid MOSEKModel::set_constraint_name(const ConstraintIndex &constraint, const char *name)\n{\n\tm_is_dirty = true;\n\tauto row = _checked_constraint_index(constraint);\n\tMSKrescodee error;\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\tcase ConstraintType::Quadratic:\n\t\terror = mosek::MSK_putconname(m_model.get(), row, name);\n\t\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n\tcheck_error(error);\n}\n\nObjectiveSense MOSEKModel::get_obj_sense()\n{\n\tMSKobjsensee obj_sense;\n\tauto error = mosek::MSK_getobjsense(m_model.get(), &obj_sense);\n\tcheck_error(error);\n\tauto sense = obj_sense == MSK_OBJECTIVE_SENSE_MINIMIZE ? ObjectiveSense::Minimize\n\t : ObjectiveSense::Maximize;\n\treturn sense;\n}\n\nvoid MOSEKModel::set_obj_sense(ObjectiveSense sense)\n{\n\tm_is_dirty = true;\n\tauto obj_sense = mosek_obj_sense(sense);\n\tauto error = mosek::MSK_putobjsense(m_model.get(), obj_sense);\n\tcheck_error(error);\n}\n\ndouble MOSEKModel::get_normalized_rhs(const ConstraintIndex &constraint)\n{\n\tauto row = _checked_constraint_index(constraint);\n\tMSKrescodee error;\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\tcase ConstraintType::Quadratic: {\n\t\tMSKboundkeye bk;\n\t\tMSKrealt lb, ub;\n\t\terror = mosek::MSK_getconbound(m_model.get(), row, &bk, &lb, &ub);\n\t\tcheck_error(error);\n\n\t\tdouble rhs;\n\t\tswitch (bk)\n\t\t{\n\t\tcase MSK_BK_UP:\n\t\t\trhs = ub;\n\t\t\tbreak;\n\t\tcase MSK_BK_LO:\n\t\t\trhs = lb;\n\t\t\tbreak;\n\t\tcase MSK_BK_FX:\n\t\t\trhs = lb;\n\t\t\tbreak;\n\t\tcase MSK_BK_FR:\n\t\t\tthrow std::runtime_error(\"Constraint has no finite bound\");\n\t\t\tbreak;\n\t\tcase MSK_BK_RA:\n\t\t\tthrow std::runtime_error(\"Constraint has two finite bounds\");\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow std::runtime_error(\"Unknown bound type\");\n\t\t}\n\n\t\treturn rhs;\n\t}\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type to get_normalized_rhs\");\n\t}\n}\n\nvoid MOSEKModel::set_normalized_rhs(const ConstraintIndex &constraint, double value)\n{\n\tm_is_dirty = true;\n\tauto row = _checked_constraint_index(constraint);\n\tMSKrescodee error;\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\tcase ConstraintType::Quadratic: {\n\t\tMSKboundkeye bk;\n\t\tMSKrealt lb, ub;\n\t\terror = mosek::MSK_getconbound(m_model.get(), row, &bk, &lb, &ub);\n\t\tcheck_error(error);\n\n\t\tswitch (bk)\n\t\t{\n\t\tcase MSK_BK_UP:\n\t\t\tub = value;\n\t\t\tbreak;\n\t\tcase MSK_BK_LO:\n\t\t\tlb = value;\n\t\t\tbreak;\n\t\tcase MSK_BK_FX:\n\t\t\tub = value;\n\t\t\tlb = value;\n\t\t\tbreak;\n\t\tcase MSK_BK_FR:\n\t\t\tthrow std::runtime_error(\"Constraint has no finite bound\");\n\t\t\tbreak;\n\t\tcase MSK_BK_RA:\n\t\t\tthrow std::runtime_error(\"Constraint has two finite bounds\");\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow std::runtime_error(\"Unknown bound type\");\n\t\t}\n\n\t\terror = mosek::MSK_putconbound(m_model.get(), row, bk, lb, ub);\n\t\tcheck_error(error);\n\t}\n\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type to set_normalized_rhs\");\n\t}\n}\n\ndouble MOSEKModel::get_normalized_coefficient(const ConstraintIndex &constraint,\n const VariableIndex &variable)\n{\n\tif (constraint.type != ConstraintType::Linear && constraint.type != ConstraintType::Quadratic)\n\t{\n\t\tthrow std::runtime_error(\n\t\t \"Only linear and quadratic constraint supports get_normalized_coefficient\");\n\t}\n\tauto row = _checked_constraint_index(constraint);\n\tauto col = _checked_variable_index(variable);\n\tMSKrealt retval;\n\tauto error = mosek::MSK_getaij(m_model.get(), row, col, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nvoid MOSEKModel::set_normalized_coefficient(const ConstraintIndex &constraint,\n const VariableIndex &variable, double value)\n{\n\tm_is_dirty = true;\n\tif (constraint.type != ConstraintType::Linear && constraint.type != ConstraintType::Quadratic)\n\t{\n\t\tthrow std::runtime_error(\n\t\t \"Only linear and quadratic constraint supports set_normalized_coefficient\");\n\t}\n\tauto row = _checked_constraint_index(constraint);\n\tauto col = _checked_variable_index(variable);\n\tauto error = mosek::MSK_putaij(m_model.get(), row, col, value);\n\tcheck_error(error);\n}\n\ndouble MOSEKModel::get_objective_coefficient(const VariableIndex &variable)\n{\n\tauto column = _checked_variable_index(variable);\n\tMSKrealt retval;\n\tauto error = mosek::MSK_getcj(m_model.get(), column, &retval);\n\tcheck_error(error);\n\treturn retval;\n}\n\nvoid MOSEKModel::set_objective_coefficient(const VariableIndex &variable, double value)\n{\n\tm_is_dirty = true;\n\tauto column = _checked_variable_index(variable);\n\tauto error = mosek::MSK_putcj(m_model.get(), column, value);\n\tcheck_error(error);\n}\n\nMSKint32t MOSEKModel::_variable_index(const VariableIndex &variable)\n{\n\treturn m_variable_index.get_index(variable.index);\n}\n\nMSKint32t MOSEKModel::_checked_variable_index(const VariableIndex &variable)\n{\n\tMSKint32t column = _variable_index(variable);\n\tif (column < 0)\n\t{\n\t\tthrow std::runtime_error(\"Variable does not exist\");\n\t}\n\treturn column;\n}\n\nMSKint32t MOSEKModel::_constraint_index(const ConstraintIndex &constraint)\n{\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\tcase ConstraintType::Quadratic:\n\t\treturn m_linear_quadratic_constraint_index.get_index(constraint.index);\n\t\tbreak;\n\tcase ConstraintType::SecondOrderCone:\n\tcase ConstraintType::ExponentialCone:\n\t\treturn m_acc_index[constraint.index] ? constraint.index : -1;\n\t\tbreak;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n}\n\nMSKint32t MOSEKModel::_checked_constraint_index(const ConstraintIndex &constraint)\n{\n\tMSKint32t row = _constraint_index(constraint);\n\tif (row < 0)\n\t{\n\t\tthrow std::runtime_error(\"Constraint does not exist\");\n\t}\n\treturn row;\n}\n\n// Logging callback\nstatic void RealLoggingCallbackFunction(void *handle, const char *msg)\n{\n\tauto real_logdata = static_cast(handle);\n\tauto &callback = real_logdata->callback;\n\tcallback(msg);\n}\n\nvoid MOSEKModel::set_logging(const MOSEKLoggingCallback &callback)\n{\n\tm_is_dirty = true;\n\tm_logging_callback_userdata.callback = callback;\n\tauto error = mosek::MSK_linkfunctotaskstream(\n\t m_model.get(), MSK_STREAM_LOG, &m_logging_callback_userdata, &RealLoggingCallbackFunction);\n\tcheck_error(error);\n}\n\nvoid *MOSEKModel::get_raw_model()\n{\n\treturn m_model.get();\n}\n\nstd::string MOSEKModel::version_string()\n{\n\tMSKint32t major, minor, revision;\n\tauto error = mosek::MSK_getversion(&major, &minor, &revision);\n\tstd::string version = fmt::format(\"v{}.{}.{}\", major, minor, revision);\n\treturn version;\n}\n\nMSKsoltypee MOSEKModel::get_current_solution()\n{\n\tif (m_soltype)\n\t{\n\t\treturn m_soltype.value();\n\t}\n\tthrow std::runtime_error(\"No solution type is available\");\n}\n\nstd::optional MOSEKModel::select_available_solution_after_optimization()\n{\n\tstd::vector soltypes{\n\t MSK_SOL_ITR,\n\t MSK_SOL_ITG,\n\t MSK_SOL_BAS,\n\t};\n\tstd::vector available_soltypes;\n\tstd::vector optimal_soltypes;\n\tfor (auto soltype : soltypes)\n\t{\n\t\tMSKbooleant available;\n\t\tauto error = mosek::MSK_solutiondef(m_model.get(), soltype, &available);\n\t\tcheck_error(error);\n\t\tif (available)\n\t\t{\n\t\t\tavailable_soltypes.push_back(soltype);\n\n\t\t\tMSKsolstae solsta;\n\t\t\tauto error = mosek::MSK_getsolsta(m_model.get(), soltype, &solsta);\n\t\t\tcheck_error(error);\n\n\t\t\tif (solsta == MSK_SOL_STA_OPTIMAL || solsta == MSK_SOL_STA_INTEGER_OPTIMAL)\n\t\t\t{\n\t\t\t\toptimal_soltypes.push_back(soltype);\n\t\t\t}\n\t\t}\n\t}\n\n\tif (!optimal_soltypes.empty())\n\t{\n\t\treturn optimal_soltypes[0];\n\t}\n\tif (!available_soltypes.empty())\n\t{\n\t\treturn available_soltypes[0];\n\t}\n\treturn std::nullopt;\n}\n\nMOSEKEnv::MOSEKEnv()\n{\n\tif (!mosek::is_library_loaded())\n\t{\n\t\tthrow std::runtime_error(\"Mosek library is not loaded\");\n\t}\n\tauto error = mosek::MSK_makeenv(&m_env, NULL);\n\tcheck_error(error);\n}\n\nMOSEKEnv::~MOSEKEnv()\n{\n\tauto error = mosek::MSK_deleteenv(&m_env);\n\tcheck_error(error);\n}\n\nvoid MOSEKEnv::close()\n{\n\tif (m_env != nullptr)\n\t{\n\t\tauto error = mosek::MSK_deleteenv(&m_env);\n\t\tcheck_error(error);\n\t}\n\tm_env = nullptr;\n}\n\nvoid MOSEKEnv::putlicensecode(const std::vector &code)\n{\n\tauto error = mosek::MSK_putlicensecode(m_env, code.data());\n\tcheck_error(error);\n}\n" }, { "path": "lib/mosek_model_ext.cpp", "content": "#include \n#include \n#include \n#include \n#include \n\n#include \"pyoptinterface/mosek_model.hpp\"\n\nnamespace nb = nanobind;\n\nextern void bind_mosek_constants(nb::module_ &m);\n\nNB_MODULE(mosek_model_ext, m)\n{\n\tm.import_(\"pyoptinterface._src.core_ext\");\n\n\tm.def(\"is_library_loaded\", &mosek::is_library_loaded);\n\tm.def(\"load_library\", &mosek::load_library);\n\n\tbind_mosek_constants(m);\n\n\tnb::class_(m, \"Env\")\n\t .def(nb::init<>())\n\t .def(\"close\", &MOSEKEnv::close)\n\t .def(\"putlicensecode\", &MOSEKEnv::putlicensecode);\n\n#define BIND_F(f) .def(#f, &MOSEKModel::f)\n\tnb::class_(m, \"RawModel\")\n\t .def(nb::init<>())\n\t .def(nb::init())\n\t // clang-format off\n\t BIND_F(init)\n\t BIND_F(write)\n\t BIND_F(close)\n\t // clang-format on\n\n\t .def(\"add_variable\", &MOSEKModel::add_variable,\n\t nb::arg(\"domain\") = VariableDomain::Continuous, nb::arg(\"lb\") = -MSK_INFINITY,\n\t nb::arg(\"ub\") = MSK_INFINITY, nb::arg(\"name\") = \"\")\n\t // clang-format off\n\t BIND_F(delete_variable)\n\t BIND_F(delete_variables)\n\t BIND_F(is_variable_active)\n\t // clang-format on\n\t .def(\"set_variable_bounds\", &MOSEKModel::set_variable_bounds, nb::arg(\"variable\"),\n\t nb::arg(\"lb\"), nb::arg(\"ub\"))\n\n\t .def(\"get_value\", nb::overload_cast(&MOSEKModel::get_variable_value))\n\t .def(\"get_value\",\n\t nb::overload_cast(&MOSEKModel::get_expression_value))\n\t .def(\"get_value\",\n\t nb::overload_cast(&MOSEKModel::get_expression_value))\n\t .def(\"get_value\", nb::overload_cast(&MOSEKModel::get_expression_value))\n\n\t .def(\"pprint\", &MOSEKModel::pprint_variable)\n\t .def(\"pprint\",\n\t nb::overload_cast(&MOSEKModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\t .def(\n\t \"pprint\",\n\t nb::overload_cast(&MOSEKModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\t .def(\"pprint\", nb::overload_cast(&MOSEKModel::pprint_expression),\n\t nb::arg(\"expr\"), nb::arg(\"precision\") = 4)\n\n\t .def(\"_add_linear_constraint\",\n\t nb::overload_cast(\n\t &MOSEKModel::add_linear_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\",\n\t nb::overload_cast &,\n\t const char *>(&MOSEKModel::add_linear_constraint),\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &MOSEKModel::add_linear_constraint_from_var, nb::arg(\"expr\"),\n\t nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &MOSEKModel::add_linear_interval_constraint_from_var,\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &MOSEKModel::add_linear_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_linear_constraint\", &MOSEKModel::add_linear_interval_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"interval\"), nb::arg(\"name\") = \"\")\n\n\t .def(\"_add_quadratic_constraint\", &MOSEKModel::add_quadratic_constraint, nb::arg(\"expr\"),\n\t nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\t .def(\"_add_quadratic_constraint\", &MOSEKModel::add_quadratic_constraint_from_expr,\n\t nb::arg(\"expr\"), nb::arg(\"sense\"), nb::arg(\"rhs\"), nb::arg(\"name\") = \"\")\n\n\t .def(\"add_second_order_cone_constraint\", &MOSEKModel::add_second_order_cone_constraint,\n\t nb::arg(\"variables\"), nb::arg(\"name\") = \"\", nb::arg(\"rotated\") = false)\n\t .def(\"add_exp_cone_constraint\", &MOSEKModel::add_exp_cone_constraint, nb::arg(\"variables\"),\n\t nb::arg(\"name\") = \"\", nb::arg(\"dual\") = false)\n\n\t // clang-format off\n\t\tBIND_F(delete_constraint)\n\t\tBIND_F(is_constraint_active)\n\t // clang-format on\n\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &MOSEKModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &MOSEKModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(&MOSEKModel::set_objective),\n\t nb::arg(\"expr\"), nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\", &MOSEKModel::set_objective_as_variable, nb::arg(\"expr\"),\n\t nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\t .def(\"set_objective\", &MOSEKModel::set_objective_as_constant, nb::arg(\"expr\"),\n\t nb::arg(\"sense\") = ObjectiveSense::Minimize)\n\n\t .def(\"optimize\", &MOSEKModel::optimize, nb::call_guard())\n\n\t // clang-format off\n\t BIND_F(version_string)\n\t BIND_F(get_raw_model)\n\n\t BIND_F(raw_parameter_type)\n\n\t BIND_F(set_raw_parameter_int)\n\t BIND_F(set_raw_parameter_double)\n\t BIND_F(set_raw_parameter_string)\n\t BIND_F(get_raw_parameter_int)\n\t BIND_F(get_raw_parameter_double)\n\t BIND_F(get_raw_parameter_string)\n\n\t BIND_F(get_raw_information_int)\n\t BIND_F(get_raw_information_double)\n\n\t BIND_F(getnumvar)\n\t BIND_F(getnumcon)\n\t BIND_F(getprosta)\n\t BIND_F(getsolsta)\n\t\tBIND_F(getprimalobj)\n\t\tBIND_F(getdualobj)\n\n\t\tBIND_F(set_logging)\n\t BIND_F(disable_log)\n\n\t BIND_F(set_variable_name)\n\t BIND_F(get_variable_name)\n\t BIND_F(set_variable_type)\n\t BIND_F(get_variable_type)\n\t BIND_F(set_variable_lower_bound)\n\t BIND_F(set_variable_upper_bound)\n\t\tBIND_F(get_variable_lower_bound)\n\t BIND_F(get_variable_upper_bound)\n\t BIND_F(set_variable_primal)\n\n\t\tBIND_F(get_variable_dual)\n\n\t BIND_F(get_constraint_primal)\n\t BIND_F(get_constraint_dual)\n\t BIND_F(get_constraint_name)\n\t BIND_F(set_constraint_name)\n\n\t BIND_F(set_obj_sense)\n\t BIND_F(get_obj_sense)\n\n\t\tBIND_F(get_normalized_rhs)\n\t\tBIND_F(set_normalized_rhs)\n\t\tBIND_F(get_normalized_coefficient)\n\t\tBIND_F(set_normalized_coefficient)\n\t\tBIND_F(get_objective_coefficient)\n\t\tBIND_F(set_objective_coefficient)\n\t // clang-format on\n\t .def_rw(\"m_is_dirty\", &MOSEKModel::m_is_dirty);\n}" }, { "path": "lib/mosek_model_ext_constants.cpp", "content": "#include \n#ifdef _MSC_VER\n#include \"solvers/mosek/mosek_win.h\"\n#else\n#include \"solvers/mosek/mosek_linux.h\"\n#endif\n\nnamespace nb = nanobind;\n\nvoid bind_mosek_constants(nb::module_ &m)\n{\n\tnb::module_ Enum = m.def_submodule(\"Enum\");\n\n\t// must cast these enums to int, otherwise C++ compilation passes but we get bad cast when\n\t// import it in Python\n#define BIND_C(x) Enum.attr(#x) = static_cast(x)\n\n\tBIND_C(MSK_PRO_STA_UNKNOWN);\n\tBIND_C(MSK_PRO_STA_PRIM_AND_DUAL_FEAS);\n\tBIND_C(MSK_PRO_STA_PRIM_FEAS);\n\tBIND_C(MSK_PRO_STA_DUAL_FEAS);\n\tBIND_C(MSK_PRO_STA_PRIM_INFEAS);\n\tBIND_C(MSK_PRO_STA_DUAL_INFEAS);\n\tBIND_C(MSK_PRO_STA_PRIM_AND_DUAL_INFEAS);\n\tBIND_C(MSK_PRO_STA_ILL_POSED);\n\tBIND_C(MSK_PRO_STA_PRIM_INFEAS_OR_UNBOUNDED);\n\n\tBIND_C(MSK_SOL_STA_UNKNOWN);\n\tBIND_C(MSK_SOL_STA_OPTIMAL);\n\tBIND_C(MSK_SOL_STA_PRIM_FEAS);\n\tBIND_C(MSK_SOL_STA_DUAL_FEAS);\n\tBIND_C(MSK_SOL_STA_PRIM_AND_DUAL_FEAS);\n\tBIND_C(MSK_SOL_STA_PRIM_INFEAS_CER);\n\tBIND_C(MSK_SOL_STA_DUAL_INFEAS_CER);\n\tBIND_C(MSK_SOL_STA_PRIM_ILLPOSED_CER);\n\tBIND_C(MSK_SOL_STA_DUAL_ILLPOSED_CER);\n\tBIND_C(MSK_SOL_STA_INTEGER_OPTIMAL);\n\n\tBIND_C(MSK_RES_OK);\n\tBIND_C(MSK_RES_TRM_MAX_ITERATIONS);\n\tBIND_C(MSK_RES_TRM_MAX_TIME);\n\tBIND_C(MSK_RES_TRM_OBJECTIVE_RANGE);\n\tBIND_C(MSK_RES_TRM_STALL);\n\tBIND_C(MSK_RES_TRM_USER_CALLBACK);\n\tBIND_C(MSK_RES_TRM_MIO_NUM_RELAXS);\n\tBIND_C(MSK_RES_TRM_MIO_NUM_BRANCHES);\n\tBIND_C(MSK_RES_TRM_NUM_MAX_NUM_INT_SOLUTIONS);\n\tBIND_C(MSK_RES_TRM_MAX_NUM_SETBACKS);\n\tBIND_C(MSK_RES_TRM_NUMERICAL_PROBLEM);\n\tBIND_C(MSK_RES_TRM_LOST_RACE);\n\tBIND_C(MSK_RES_TRM_INTERNAL);\n\tBIND_C(MSK_RES_TRM_INTERNAL_STOP);\n}" }, { "path": "lib/nleval.cpp", "content": "#include \"pyoptinterface/nleval.hpp\"\n#include \n#include \n\nConstraintAutodiffEvaluator::ConstraintAutodiffEvaluator(bool has_parameter, uintptr_t fp,\n uintptr_t jp, uintptr_t hp)\n{\n\tif (has_parameter)\n\t{\n\t\tf_eval.p = (f_funcptr)fp;\n\t\tjacobian_eval.p = (jacobian_funcptr)jp;\n\t\thessian_eval.p = (hessian_funcptr)hp;\n\t}\n\telse\n\t{\n\t\tf_eval.nop = (f_funcptr_noparam)fp;\n\t\tjacobian_eval.nop = (jacobian_funcptr_noparam)jp;\n\t\thessian_eval.nop = (hessian_funcptr_noparam)hp;\n\t}\n}\n\nObjectiveAutodiffEvaluator::ObjectiveAutodiffEvaluator(bool has_parameter, uintptr_t fp,\n uintptr_t ajp, uintptr_t hp)\n{\n\tif (has_parameter)\n\t{\n\t\tf_eval.p = (f_funcptr)fp;\n\t\tgrad_eval.p = (additive_grad_funcptr)ajp;\n\t\thessian_eval.p = (hessian_funcptr)hp;\n\t}\n\telse\n\t{\n\t\tf_eval.nop = (f_funcptr_noparam)fp;\n\t\tgrad_eval.nop = (additive_grad_funcptr_noparam)ajp;\n\t\thessian_eval.nop = (hessian_funcptr_noparam)hp;\n\t}\n}\n\nvoid LinearEvaluator::add_row(const ScalarAffineFunction &f)\n{\n\tcoefs.insert(coefs.end(), f.coefficients.begin(), f.coefficients.end());\n\tindices.insert(indices.end(), f.variables.begin(), f.variables.end());\n\tconstraint_intervals.push_back(coefs.size());\n\n\tif (f.constant)\n\t{\n\t\tconstant_values.push_back(f.constant.value());\n\t\tconstant_indices.push_back(n_constraints);\n\t}\n\n\tn_constraints += 1;\n}\n\nvoid LinearEvaluator::eval_function(const double *restrict x, double *restrict f)\n{\n\tfor (size_t i = 0; i < n_constraints; i++)\n\t{\n\t\tauto start = constraint_intervals[i];\n\t\tauto end = constraint_intervals[i + 1];\n\n\t\tdouble sum = 0.0;\n\t\tfor (size_t j = start; j < end; j++)\n\t\t{\n\t\t\tsum += coefs[j] * x[indices[j]];\n\t\t}\n\t\tf[i] = sum;\n\t}\n\tfor (size_t i = 0; i < constant_indices.size(); i++)\n\t{\n\t\tauto index = constant_indices[i];\n\t\tauto value = constant_values[i];\n\t\tf[index] += value;\n\t}\n}\n\nvoid LinearEvaluator::analyze_jacobian_structure(size_t &global_jacobian_nnz,\n std::vector &global_jacobian_rows,\n std::vector &global_jacobian_cols) const\n{\n\tglobal_jacobian_nnz += indices.size();\n\tglobal_jacobian_rows.reserve(global_jacobian_nnz);\n\tfor (size_t i = 0; i < n_constraints; i++)\n\t{\n\t\tauto start = constraint_intervals[i];\n\t\tauto end = constraint_intervals[i + 1];\n\t\tfor (size_t j = start; j < end; j++)\n\t\t{\n\t\t\tglobal_jacobian_rows.push_back(i);\n\t\t}\n\t}\n\tglobal_jacobian_cols.insert(global_jacobian_cols.end(), indices.begin(), indices.end());\n}\n\nvoid LinearEvaluator::eval_jacobian(const double *restrict x, double *restrict jacobian) const\n{\n\tstd::copy(coefs.begin(), coefs.end(), jacobian);\n}\n\nvoid QuadraticEvaluator::add_row(const ScalarQuadraticFunction &f)\n{\n\tfor (int i = 0; i < f.size(); i++)\n\t{\n\t\tauto coef = f.coefficients[i];\n\t\tauto x1 = f.variable_1s[i];\n\t\tauto x2 = f.variable_2s[i];\n\n\t\tif (x1 == x2)\n\t\t{\n\t\t\tdiag_coefs.push_back(coef);\n\t\t\tdiag_indices.push_back(x1);\n\t\t}\n\t\telse\n\t\t{\n\t\t\toffdiag_coefs.push_back(coef);\n\t\t\toffdiag_rows.push_back(x1);\n\t\t\toffdiag_cols.push_back(x2);\n\t\t}\n\t}\n\n\tdiag_intervals.push_back(diag_coefs.size());\n\toffdiag_intervals.push_back(offdiag_coefs.size());\n\n\tif (f.affine_part)\n\t{\n\t\tauto &affine = f.affine_part.value();\n\t\tlinear_coefs.insert(linear_coefs.end(), affine.coefficients.begin(),\n\t\t affine.coefficients.end());\n\t\tlinear_indices.insert(linear_indices.end(), affine.variables.begin(),\n\t\t affine.variables.end());\n\n\t\tif (affine.constant)\n\t\t{\n\t\t\tlinear_constant_values.push_back(affine.constant.value());\n\t\t\tlinear_constant_indices.push_back(n_constraints);\n\t\t}\n\t}\n\tlinear_intervals.push_back(linear_coefs.size());\n\n\tHashmap variable_to_jacobian_nnz;\n\n\tfor (int i = 0; i < f.size(); i++)\n\t{\n\t\tauto coef = f.coefficients[i];\n\t\tauto x1 = f.variable_1s[i];\n\t\tauto x2 = f.variable_2s[i];\n\n\t\tif (x1 == x2)\n\t\t{\n\t\t\tauto [iter, inserted] = variable_to_jacobian_nnz.try_emplace(x1, jacobian_nnz);\n\t\t\tif (inserted)\n\t\t\t{\n\t\t\t\tjacobian_constant.push_back(0.0);\n\t\t\t\tjacobian_variable_indices.push_back(x1);\n\t\t\t\tjacobian_nnz += 1;\n\t\t\t}\n\t\t\tjacobian_diag_indices.push_back(iter->second);\n\t\t}\n\t\telse\n\t\t{\n\t\t\t{\n\t\t\t\tauto [iter, inserted] = variable_to_jacobian_nnz.try_emplace(x1, jacobian_nnz);\n\t\t\t\tif (inserted)\n\t\t\t\t{\n\t\t\t\t\tjacobian_constant.push_back(0.0);\n\t\t\t\t\tjacobian_variable_indices.push_back(x1);\n\t\t\t\t\tjacobian_nnz += 1;\n\t\t\t\t}\n\t\t\t\tjacobian_offdiag_row_indices.push_back(iter->second);\n\t\t\t}\n\t\t\t{\n\t\t\t\tauto [iter, inserted] = variable_to_jacobian_nnz.try_emplace(x2, jacobian_nnz);\n\t\t\t\tif (inserted)\n\t\t\t\t{\n\t\t\t\t\tjacobian_constant.push_back(0.0);\n\t\t\t\t\tjacobian_variable_indices.push_back(x2);\n\t\t\t\t\tjacobian_nnz += 1;\n\t\t\t\t}\n\t\t\t\tjacobian_offdiag_col_indices.push_back(iter->second);\n\t\t\t}\n\t\t}\n\t}\n\n\tif (f.affine_part)\n\t{\n\t\tauto &affine = f.affine_part.value();\n\n\t\tfor (int i = 0; i < affine.size(); i++)\n\t\t{\n\t\t\tauto coef = affine.coefficients[i];\n\t\t\tauto x = affine.variables[i];\n\t\t\tauto [iter, inserted] = variable_to_jacobian_nnz.try_emplace(x, jacobian_nnz);\n\t\t\tif (inserted)\n\t\t\t{\n\t\t\t\tjacobian_constant.push_back(coef);\n\t\t\t\tjacobian_variable_indices.push_back(x);\n\t\t\t\tjacobian_nnz += 1;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tauto jacobian_index = iter->second;\n\t\t\t\tjacobian_constant[jacobian_index] += coef;\n\t\t\t}\n\t\t}\n\t}\n\tjacobian_constraint_intervals.push_back(jacobian_variable_indices.size());\n\n\tn_constraints += 1;\n}\n\nvoid QuadraticEvaluator::eval_function(const double *restrict x, double *restrict f) const\n{\n\tfor (size_t i = 0; i < n_constraints; i++)\n\t{\n\t\tauto start = diag_intervals[i];\n\t\tauto end = diag_intervals[i + 1];\n\t\tdouble sum = 0.0;\n\t\tfor (size_t j = start; j < end; j++)\n\t\t{\n\t\t\tauto c = diag_coefs[j];\n\t\t\tauto v = x[diag_indices[j]];\n\t\t\tsum += c * v * v;\n\t\t}\n\t\tf[i] = sum;\n\t}\n\tfor (size_t i = 0; i < n_constraints; i++)\n\t{\n\t\tauto start = offdiag_intervals[i];\n\t\tauto end = offdiag_intervals[i + 1];\n\t\tdouble sum = 0.0;\n\t\tfor (size_t j = start; j < end; j++)\n\t\t{\n\t\t\tauto c = offdiag_coefs[j];\n\t\t\tauto v1 = x[offdiag_rows[j]];\n\t\t\tauto v2 = x[offdiag_cols[j]];\n\t\t\tsum += c * v1 * v2;\n\t\t}\n\t\tf[i] += sum;\n\t}\n\tfor (size_t i = 0; i < n_constraints; i++)\n\t{\n\t\tauto start = linear_intervals[i];\n\t\tauto end = linear_intervals[i + 1];\n\n\t\tdouble sum = 0.0;\n\t\tfor (size_t j = start; j < end; j++)\n\t\t{\n\t\t\tsum += linear_coefs[j] * x[linear_indices[j]];\n\t\t}\n\t\tf[i] += sum;\n\t}\n\tfor (size_t i = 0; i < linear_constant_indices.size(); i++)\n\t{\n\t\tauto index = linear_constant_indices[i];\n\t\tauto value = linear_constant_values[i];\n\t\tf[index] += value;\n\t}\n}\n\nvoid QuadraticEvaluator::analyze_jacobian_structure(size_t row_base, size_t &global_jacobian_nnz,\n std::vector &global_jacobian_rows,\n std::vector &global_jacobian_cols) const\n{\n\tglobal_jacobian_nnz += jacobian_nnz;\n\tglobal_jacobian_rows.reserve(global_jacobian_nnz);\n\tfor (size_t i = 0; i < n_constraints; i++)\n\t{\n\t\tauto start = jacobian_constraint_intervals[i];\n\t\tauto end = jacobian_constraint_intervals[i + 1];\n\t\tfor (size_t j = start; j < end; j++)\n\t\t{\n\t\t\tglobal_jacobian_rows.push_back(row_base + i);\n\t\t}\n\t}\n\tglobal_jacobian_cols.insert(global_jacobian_cols.end(), jacobian_variable_indices.begin(),\n\t jacobian_variable_indices.end());\n}\n\nvoid QuadraticEvaluator::eval_jacobian(const double *restrict x, double *restrict jacobian) const\n{\n\tstd::copy(jacobian_constant.begin(), jacobian_constant.end(), jacobian);\n\n\tfor (int i = 0; i < diag_coefs.size(); i++)\n\t{\n\t\tauto coef = diag_coefs[i];\n\t\tauto x_index = diag_indices[i];\n\t\tauto jacobian_index = jacobian_diag_indices[i];\n\t\tjacobian[jacobian_index] += 2.0 * coef * x[x_index];\n\t}\n\n\tfor (int i = 0; i < offdiag_coefs.size(); i++)\n\t{\n\t\tauto coef = offdiag_coefs[i];\n\t\tauto x1_index = offdiag_rows[i];\n\t\tauto x2_index = offdiag_cols[i];\n\t\tauto jacobian_index = jacobian_offdiag_row_indices[i];\n\t\tjacobian[jacobian_index] += coef * x[x2_index];\n\t\tjacobian_index = jacobian_offdiag_col_indices[i];\n\t\tjacobian[jacobian_index] += coef * x[x1_index];\n\t}\n}\n\nvoid QuadraticEvaluator::analyze_hessian_structure(\n size_t &global_hessian_nnz, std::vector &global_hessian_rows,\n std::vector &global_hessian_cols, Hashmap, int> &hessian_index_map,\n HessianSparsityType hessian_type)\n{\n\thessian_diag_indices.resize(diag_coefs.size());\n\thessian_offdiag_indices.resize(offdiag_coefs.size());\n\n\tfor (int i = 0; i < diag_coefs.size(); i++)\n\t{\n\t\tauto x = diag_indices[i];\n\n\t\tauto [iter, inserted] = hessian_index_map.try_emplace({x, x}, global_hessian_nnz);\n\t\tif (inserted)\n\t\t{\n\t\t\tglobal_hessian_rows.push_back(x);\n\t\t\tglobal_hessian_cols.push_back(x);\n\t\t\tglobal_hessian_nnz += 1;\n\t\t}\n\t\tauto hessian_index = iter->second;\n\t\thessian_diag_indices[i] = hessian_index;\n\t}\n\n\tfor (int i = 0; i < offdiag_coefs.size(); i++)\n\t{\n\t\tauto x1 = offdiag_rows[i];\n\t\tauto x2 = offdiag_cols[i];\n\t\tif (hessian_type == HessianSparsityType::Upper)\n\t\t{\n\t\t\tif (x1 > x2)\n\t\t\t\tstd::swap(x1, x2);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tif (x1 < x2)\n\t\t\t\tstd::swap(x1, x2);\n\t\t}\n\t\tauto [iter, inserted] = hessian_index_map.try_emplace({x1, x2}, global_hessian_nnz);\n\t\tif (inserted)\n\t\t{\n\t\t\tglobal_hessian_rows.push_back(x1);\n\t\t\tglobal_hessian_cols.push_back(x2);\n\t\t\tglobal_hessian_nnz += 1;\n\t\t}\n\t\tauto hessian_index = iter->second;\n\t\thessian_offdiag_indices[i] = hessian_index;\n\t}\n}\n\nvoid QuadraticEvaluator::eval_lagrangian_hessian(const double *restrict lambda,\n double *restrict hessian) const\n{\n\tfor (size_t i = 0; i < n_constraints; i++)\n\t{\n\t\tauto start = diag_intervals[i];\n\t\tauto end = diag_intervals[i + 1];\n\t\tauto multiplier = lambda[i];\n\t\tfor (size_t j = start; j < end; j++)\n\t\t{\n\t\t\tauto coef = diag_coefs[j];\n\t\t\tauto hessian_index = hessian_diag_indices[j];\n\t\t\thessian[hessian_index] += 2.0 * coef * multiplier;\n\t\t}\n\t}\n\tfor (size_t i = 0; i < n_constraints; i++)\n\t{\n\t\tauto start = offdiag_intervals[i];\n\t\tauto end = offdiag_intervals[i + 1];\n\t\tauto multiplier = lambda[i];\n\t\tfor (size_t j = start; j < end; j++)\n\t\t{\n\t\t\tauto coef = offdiag_coefs[j];\n\t\t\tauto hessian_index = hessian_offdiag_indices[j];\n\t\t\thessian[hessian_index] += coef * multiplier;\n\t\t}\n\t}\n}\n\nint NonlinearEvaluator::add_graph_instance()\n{\n\tauto current_graph_index = n_graph_instances;\n\tn_graph_instances += 1;\n\tgraph_inputs.emplace_back();\n\treturn current_graph_index;\n}\n\nvoid NonlinearEvaluator::finalize_graph_instance(size_t graph_index, const ExpressionGraph &graph)\n{\n\tauto bodyhash = graph.main_structure_hash();\n\n\tgraph_inputs[graph_index].variables = graph.m_variables;\n\tgraph_inputs[graph_index].constants = graph.m_constants;\n\n\tif (graph.has_constraint_output())\n\t{\n\t\tauto hash = graph.constraint_structure_hash(bodyhash);\n\t\tconstraint_graph_hashes.hashes.push_back(\n\t\t GraphHash{.hash = hash, .index = (int)graph_index});\n\t}\n\n\tif (graph.has_objective_output())\n\t{\n\t\tauto hash = graph.objective_structure_hash(bodyhash);\n\t\tobjective_graph_hashes.hashes.push_back(GraphHash{.hash = hash, .index = (int)graph_index});\n\t}\n}\n\nint NonlinearEvaluator::aggregate_constraint_groups()\n{\n\tauto &graph_hashes = constraint_graph_hashes;\n\tauto &group_memberships = constraint_group_memberships;\n\n\t// ensure we have enough space for every graph instance\n\tgroup_memberships.resize(n_graph_instances, GraphGroupMembership{.group = -1, .rank = -1});\n\n\t// graph hashes that has not been aggregated\n\tstd::span hashes_to_analyze(graph_hashes.hashes.begin() +\n\t graph_hashes.n_hashes_since_last_aggregation,\n\t graph_hashes.hashes.end());\n\n\tfor (const auto &graph_hash : hashes_to_analyze)\n\t{\n\t\tauto index = graph_hash.index;\n\t\tauto hash = graph_hash.hash;\n\t\tauto [iter, inserted] =\n\t\t hash_to_constraint_group.try_emplace(hash, constraint_groups.size());\n\t\tauto group_index = iter->second;\n\t\tif (inserted)\n\t\t{\n\t\t\tconstraint_groups.emplace_back();\n\t\t}\n\t\tgroup_memberships[index].group = group_index;\n\t\tgroup_memberships[index].rank = (int)constraint_groups[group_index].instance_indices.size();\n\t\tconstraint_groups[group_index].instance_indices.push_back(index);\n\t}\n\n\tgraph_hashes.n_hashes_since_last_aggregation = graph_hashes.hashes.size();\n\n\treturn constraint_groups.size();\n}\n\nint NonlinearEvaluator::get_constraint_group_representative(int group_index) const\n{\n\tauto index = constraint_groups.at(group_index).instance_indices.at(0);\n\treturn index;\n}\n\nint NonlinearEvaluator::aggregate_objective_groups()\n{\n\tauto &graph_hashes = objective_graph_hashes;\n\tauto &group_memberships = objective_group_memberships;\n\n\t// ensure we have enough space for every graph instance\n\tgroup_memberships.resize(n_graph_instances, GraphGroupMembership{.group = -1, .rank = -1});\n\n\t// graph hashes that has not been aggregated\n\tstd::span hashes_to_analyze(graph_hashes.hashes.begin() +\n\t graph_hashes.n_hashes_since_last_aggregation,\n\t graph_hashes.hashes.end());\n\n\tfor (const auto &graph_hash : hashes_to_analyze)\n\t{\n\t\tauto index = graph_hash.index;\n\t\tauto hash = graph_hash.hash;\n\t\tauto [iter, inserted] = hash_to_objective_group.try_emplace(hash, objective_groups.size());\n\t\tauto group_index = iter->second;\n\t\tif (inserted)\n\t\t{\n\t\t\tobjective_groups.emplace_back();\n\t\t}\n\t\tgroup_memberships[index].group = group_index;\n\t\tgroup_memberships[index].rank = (int)objective_groups[group_index].instance_indices.size();\n\t\tobjective_groups[group_index].instance_indices.push_back(index);\n\t}\n\n\tgraph_hashes.n_hashes_since_last_aggregation = graph_hashes.hashes.size();\n\n\treturn objective_groups.size();\n}\n\nint NonlinearEvaluator::get_objective_group_representative(int group_index) const\n{\n\tauto index = objective_groups.at(group_index).instance_indices.at(0);\n\treturn index;\n}\n\nvoid NonlinearEvaluator::assign_constraint_group_autodiff_structure(\n int group_index, const AutodiffSymbolicStructure &structure)\n{\n\tconstraint_groups[group_index].autodiff_structure = structure;\n}\n\nvoid NonlinearEvaluator::assign_constraint_group_autodiff_evaluator(\n int group_index, const ConstraintAutodiffEvaluator &evaluator)\n{\n\tconstraint_groups[group_index].autodiff_evaluator = evaluator;\n}\n\nvoid NonlinearEvaluator::assign_objective_group_autodiff_structure(\n int group_index, const AutodiffSymbolicStructure &structure)\n{\n\tobjective_groups[group_index].autodiff_structure = structure;\n}\n\nvoid NonlinearEvaluator::assign_objective_group_autodiff_evaluator(\n int group_index, const ObjectiveAutodiffEvaluator &evaluator)\n{\n\tobjective_groups[group_index].autodiff_evaluator = evaluator;\n}\n\nvoid NonlinearEvaluator::calculate_constraint_graph_instances_offset()\n{\n\t// now all graphs are aggregated we need to figure out which index each graph starts\n\tconstraint_indices_offsets.resize(n_graph_instances, -1);\n\tint counter = 0;\n\tfor (const auto &group : constraint_groups)\n\t{\n\t\tconst auto &instance_indices = group.instance_indices;\n\t\tauto ny = group.autodiff_structure.ny;\n\t\tfor (auto instance_index : instance_indices)\n\t\t{\n\t\t\tconstraint_indices_offsets[instance_index] = counter;\n\t\t\tcounter += ny;\n\t\t}\n\t}\n}\n\nvoid NonlinearEvaluator::eval_constraints(const double *restrict x, double *restrict f) const\n{\n\tauto &groups = constraint_groups;\n\tfor (const auto &group : groups)\n\t{\n\t\tauto &instance_indices = group.instance_indices;\n\t\tauto n_instances = instance_indices.size();\n\t\tauto &structure = group.autodiff_structure;\n\t\tauto &evaluator = group.autodiff_evaluator;\n\n\t\tauto ny = structure.ny;\n\n\t\tif (!structure.has_parameter)\n\t\t{\n\t\t\tfor (int j = 0; j < n_instances; j++)\n\t\t\t{\n\t\t\t\tauto instance_index = instance_indices[j];\n\t\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\t\t\t\tevaluator.f_eval.nop(x, f, variables.data());\n\t\t\t\tf += ny;\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\tfor (int j = 0; j < n_instances; j++)\n\t\t\t{\n\t\t\t\tauto instance_index = instance_indices[j];\n\t\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\t\t\t\tauto &constant = graph_inputs[instance_index].constants;\n\t\t\t\tevaluator.f_eval.p(x, constant.data(), f, variables.data());\n\t\t\t\tf += ny;\n\t\t\t}\n\t\t}\n\t}\n}\n\ndouble NonlinearEvaluator::eval_objective(const double *restrict x) const\n{\n\tauto &groups = objective_groups;\n\tdouble obj_value = 0.0;\n\tfor (const auto &group : groups)\n\t{\n\t\tauto &instance_indices = group.instance_indices;\n\t\tauto n_instances = instance_indices.size();\n\t\tauto &structure = group.autodiff_structure;\n\t\tauto &evaluator = group.autodiff_evaluator;\n\n\t\tif (!structure.has_parameter)\n\t\t{\n\t\t\tfor (int j = 0; j < n_instances; j++)\n\t\t\t{\n\t\t\t\tauto instance_index = instance_indices[j];\n\t\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\t\t\t\tevaluator.f_eval.nop(x, &obj_value, variables.data());\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\tfor (int j = 0; j < n_instances; j++)\n\t\t\t{\n\t\t\t\tauto instance_index = instance_indices[j];\n\t\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\t\t\t\tauto &constant = graph_inputs[instance_index].constants;\n\t\t\t\tevaluator.f_eval.p(x, constant.data(), &obj_value, variables.data());\n\t\t\t}\n\t\t}\n\t}\n\treturn obj_value;\n}\n\nvoid NonlinearEvaluator::analyze_constraints_jacobian_structure(\n size_t row_base, size_t &global_jacobian_nnz, std::vector &global_jacobian_rows,\n std::vector &global_jacobian_cols)\n{\n\tauto &groups = constraint_groups;\n\n\tfor (const auto &group : groups)\n\t{\n\t\tauto &instance_indices = group.instance_indices;\n\t\tauto n_instances = instance_indices.size();\n\t\tauto &structure = group.autodiff_structure;\n\n\t\tif (!structure.has_jacobian)\n\t\t{\n\t\t\tcontinue;\n\t\t}\n\n\t\tauto local_jacobian_nnz = structure.m_jacobian_nnz;\n\t\tauto &local_jacobian_rows = structure.m_jacobian_rows;\n\t\tauto &local_jacobian_cols = structure.m_jacobian_cols;\n\n\t\tfor (int j = 0; j < n_instances; j++)\n\t\t{\n\t\t\tauto instance_index = instance_indices[j];\n\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\n\t\t\tfor (int k = 0; k < local_jacobian_nnz; k++)\n\t\t\t{\n\t\t\t\tauto row = local_jacobian_rows[k] + row_base;\n\t\t\t\tauto col = variables[local_jacobian_cols[k]];\n\t\t\t\tglobal_jacobian_rows.push_back(row);\n\t\t\t\tglobal_jacobian_cols.push_back(col);\n\t\t\t}\n\n\t\t\trow_base += structure.ny;\n\t\t}\n\n\t\tglobal_jacobian_nnz += local_jacobian_nnz * n_instances;\n\t}\n}\n\nvoid NonlinearEvaluator::analyze_objective_gradient_structure(\n std::vector &global_gradient_cols, Hashmap &sparse_gradient_map)\n{\n\tauto &groups = objective_groups;\n\n\tfor (auto &group : groups)\n\t{\n\t\tauto &instance_indices = group.instance_indices;\n\t\tauto n_instances = instance_indices.size();\n\t\tauto &structure = group.autodiff_structure;\n\n\t\tif (!structure.has_jacobian)\n\t\t{\n\t\t\tcontinue;\n\t\t}\n\n\t\tauto local_jacobian_nnz = structure.m_jacobian_nnz;\n\t\tauto &local_jacobian_cols = structure.m_jacobian_cols;\n\n\t\tstd::vector jacobian_index_buffer(local_jacobian_nnz);\n\t\tgroup.gradient_indices.resize(n_instances * local_jacobian_nnz);\n\n\t\tfor (int j = 0; j < n_instances; j++)\n\t\t{\n\t\t\tauto instance_index = instance_indices[j];\n\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\n\t\t\tfor (int k = 0; k < local_jacobian_nnz; k++)\n\t\t\t{\n\t\t\t\tauto col = variables[local_jacobian_cols[k]];\n\n\t\t\t\tauto [iter, inserted] =\n\t\t\t\t sparse_gradient_map.try_emplace(col, global_gradient_cols.size());\n\t\t\t\tif (inserted)\n\t\t\t\t{\n\t\t\t\t\tglobal_gradient_cols.push_back(col);\n\t\t\t\t}\n\t\t\t\tjacobian_index_buffer[k] = iter->second;\n\t\t\t}\n\t\t\tstd::copy(jacobian_index_buffer.begin(), jacobian_index_buffer.end(),\n\t\t\t group.gradient_indices.begin() + j * local_jacobian_nnz);\n\t\t}\n\t}\n}\n\nvoid NonlinearEvaluator::eval_constraints_jacobian(const double *restrict x,\n double *restrict jacobian) const\n{\n\tauto &groups = constraint_groups;\n\n\tfor (const auto &group : groups)\n\t{\n\t\tauto &instance_indices = group.instance_indices;\n\t\tauto n_instances = instance_indices.size();\n\t\tauto &structure = group.autodiff_structure;\n\t\tauto &evaluator = group.autodiff_evaluator;\n\t\tif (!structure.has_jacobian)\n\t\t{\n\t\t\tcontinue;\n\t\t}\n\t\tauto local_jacobian_nnz = structure.m_jacobian_nnz;\n\t\tif (!structure.has_parameter)\n\t\t{\n\t\t\tfor (int j = 0; j < n_instances; j++)\n\t\t\t{\n\t\t\t\tauto instance_index = instance_indices[j];\n\t\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\t\t\t\tevaluator.jacobian_eval.nop(x, jacobian, variables.data());\n\t\t\t\tjacobian += local_jacobian_nnz;\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\tfor (int j = 0; j < n_instances; j++)\n\t\t\t{\n\t\t\t\tauto instance_index = instance_indices[j];\n\t\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\t\t\t\tauto &constant = graph_inputs[instance_index].constants;\n\t\t\t\tevaluator.jacobian_eval.p(x, constant.data(), jacobian, variables.data());\n\t\t\t\tjacobian += local_jacobian_nnz;\n\t\t\t}\n\t\t}\n\t}\n}\n\nvoid NonlinearEvaluator::eval_objective_gradient(const double *restrict x,\n double *restrict grad_f) const\n{\n\tauto &groups = objective_groups;\n\n\tfor (const auto &group : groups)\n\t{\n\t\tauto &instance_indices = group.instance_indices;\n\t\tauto n_instances = instance_indices.size();\n\t\tauto &structure = group.autodiff_structure;\n\t\tauto &evaluator = group.autodiff_evaluator;\n\t\tif (!structure.has_jacobian)\n\t\t{\n\t\t\tcontinue;\n\t\t}\n\t\tauto local_jacobian_nnz = structure.m_jacobian_nnz;\n\t\tconst int *grad_index = group.gradient_indices.data();\n\t\tif (!structure.has_parameter)\n\t\t{\n\t\t\tfor (int j = 0; j < n_instances; j++)\n\t\t\t{\n\t\t\t\tauto instance_index = instance_indices[j];\n\t\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\t\t\t\tevaluator.grad_eval.nop(x, grad_f, variables.data(), grad_index);\n\t\t\t\tgrad_index += local_jacobian_nnz;\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\tfor (int j = 0; j < n_instances; j++)\n\t\t\t{\n\t\t\t\tauto instance_index = instance_indices[j];\n\t\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\t\t\t\tauto &constant = graph_inputs[instance_index].constants;\n\t\t\t\tevaluator.grad_eval.p(x, constant.data(), grad_f, variables.data(), grad_index);\n\t\t\t\tgrad_index += local_jacobian_nnz;\n\t\t\t}\n\t\t}\n\t}\n}\n\nvoid NonlinearEvaluator::analyze_constraints_hessian_structure(\n size_t &global_hessian_nnz, std::vector &global_hessian_rows,\n std::vector &global_hessian_cols, Hashmap, int> &hessian_index_map,\n HessianSparsityType hessian_type)\n{\n\tauto &groups = constraint_groups;\n\n\tfor (auto &group : groups)\n\t{\n\t\tauto &instance_indices = group.instance_indices;\n\t\tauto n_instances = instance_indices.size();\n\t\tauto &structure = group.autodiff_structure;\n\n\t\tif (!structure.has_hessian)\n\t\t{\n\t\t\tcontinue;\n\t\t}\n\n\t\tauto local_hessian_nnz = structure.m_hessian_nnz;\n\t\tauto &local_hessian_rows = structure.m_hessian_rows;\n\t\tauto &local_hessian_cols = structure.m_hessian_cols;\n\n\t\tstd::vector hessian_index_buffer(local_hessian_nnz);\n\t\tgroup.hessian_indices.resize(n_instances * local_hessian_nnz);\n\n\t\tfor (int j = 0; j < n_instances; j++)\n\t\t{\n\t\t\tauto instance_index = instance_indices[j];\n\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\n\t\t\tfor (int k = 0; k < local_hessian_nnz; k++)\n\t\t\t{\n\t\t\t\tauto row = variables[local_hessian_rows[k]];\n\t\t\t\tauto col = variables[local_hessian_cols[k]];\n\n\t\t\t\tif (hessian_type == HessianSparsityType::Upper)\n\t\t\t\t{\n\t\t\t\t\tif (row > col)\n\t\t\t\t\t\tstd::swap(row, col);\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tif (row < col)\n\t\t\t\t\t\tstd::swap(row, col);\n\t\t\t\t}\n\n\t\t\t\tauto [iter, inserted] =\n\t\t\t\t hessian_index_map.try_emplace({row, col}, global_hessian_nnz);\n\t\t\t\tif (inserted)\n\t\t\t\t{\n\t\t\t\t\tglobal_hessian_rows.push_back(row);\n\t\t\t\t\tglobal_hessian_cols.push_back(col);\n\t\t\t\t\tglobal_hessian_nnz += 1;\n\t\t\t\t}\n\t\t\t\tauto hessian_index = iter->second;\n\t\t\t\thessian_index_buffer[k] = hessian_index;\n\t\t\t}\n\t\t\tstd::copy(hessian_index_buffer.begin(), hessian_index_buffer.end(),\n\t\t\t group.hessian_indices.begin() + j * local_hessian_nnz);\n\t\t}\n\t}\n}\n\nvoid NonlinearEvaluator::analyze_objective_hessian_structure(\n size_t &global_hessian_nnz, std::vector &global_hessian_rows,\n std::vector &global_hessian_cols, Hashmap, int> &hessian_index_map,\n HessianSparsityType hessian_type)\n{\n\tauto &groups = objective_groups;\n\n\tfor (auto &group : groups)\n\t{\n\t\tauto &instance_indices = group.instance_indices;\n\t\tauto n_instances = instance_indices.size();\n\t\tauto &structure = group.autodiff_structure;\n\n\t\tif (!structure.has_hessian)\n\t\t{\n\t\t\tcontinue;\n\t\t}\n\n\t\tauto local_hessian_nnz = structure.m_hessian_nnz;\n\t\tauto &local_hessian_rows = structure.m_hessian_rows;\n\t\tauto &local_hessian_cols = structure.m_hessian_cols;\n\n\t\tstd::vector hessian_index_buffer(local_hessian_nnz);\n\t\tgroup.hessian_indices.resize(n_instances * local_hessian_nnz);\n\n\t\tfor (int j = 0; j < n_instances; j++)\n\t\t{\n\t\t\tauto instance_index = instance_indices[j];\n\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\n\t\t\tfor (int k = 0; k < local_hessian_nnz; k++)\n\t\t\t{\n\t\t\t\tauto row = variables[local_hessian_rows[k]];\n\t\t\t\tauto col = variables[local_hessian_cols[k]];\n\n\t\t\t\tif (hessian_type == HessianSparsityType::Upper)\n\t\t\t\t{\n\t\t\t\t\tif (row > col)\n\t\t\t\t\t\tstd::swap(row, col);\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tif (row < col)\n\t\t\t\t\t\tstd::swap(row, col);\n\t\t\t\t}\n\n\t\t\t\tauto [iter, inserted] =\n\t\t\t\t hessian_index_map.try_emplace({row, col}, global_hessian_nnz);\n\t\t\t\tif (inserted)\n\t\t\t\t{\n\t\t\t\t\tglobal_hessian_rows.push_back(row);\n\t\t\t\t\tglobal_hessian_cols.push_back(col);\n\t\t\t\t\tglobal_hessian_nnz += 1;\n\t\t\t\t}\n\t\t\t\tauto hessian_index = iter->second;\n\t\t\t\thessian_index_buffer[k] = hessian_index;\n\t\t\t}\n\t\t\tstd::copy(hessian_index_buffer.begin(), hessian_index_buffer.end(),\n\t\t\t group.hessian_indices.begin() + j * local_hessian_nnz);\n\t\t}\n\t}\n}\n\nvoid NonlinearEvaluator::eval_lagrangian_hessian(const double *restrict x,\n const double *restrict lambda,\n const double obj_factor,\n double *restrict hessian) const\n{\n\t// lambda are the multipliers of constraints\n\t// obj_factor is the multiplier of objective function\n\n\t// objective\n\t{\n\t\tauto &groups = objective_groups;\n\t\tfor (const auto &group : groups)\n\t\t{\n\t\t\tauto &instance_indices = group.instance_indices;\n\t\t\tauto n_instances = instance_indices.size();\n\t\t\tauto &structure = group.autodiff_structure;\n\t\t\tauto &evaluator = group.autodiff_evaluator;\n\n\t\t\tif (!structure.has_hessian)\n\t\t\t{\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tauto local_hessian_nnz = structure.m_hessian_nnz;\n\t\t\tconst int *hessian_index = group.hessian_indices.data();\n\n\t\t\tif (!structure.has_parameter)\n\t\t\t{\n\t\t\t\tfor (int j = 0; j < n_instances; j++)\n\t\t\t\t{\n\t\t\t\t\tauto instance_index = instance_indices[j];\n\t\t\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\t\t\t\t\tevaluator.hessian_eval.nop(x, &obj_factor, hessian, variables.data(),\n\t\t\t\t\t hessian_index);\n\t\t\t\t\thessian_index += local_hessian_nnz;\n\t\t\t\t}\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tfor (int j = 0; j < n_instances; j++)\n\t\t\t\t{\n\t\t\t\t\tauto instance_index = instance_indices[j];\n\t\t\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\t\t\t\t\tauto &constant = graph_inputs[instance_index].constants;\n\t\t\t\t\tevaluator.hessian_eval.p(x, constant.data(), &obj_factor, hessian,\n\t\t\t\t\t variables.data(), hessian_index);\n\t\t\t\t\thessian_index += local_hessian_nnz;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// constraints\n\t{\n\t\tauto &groups = constraint_groups;\n\t\tfor (const auto &group : groups)\n\t\t{\n\t\t\tauto &instance_indices = group.instance_indices;\n\t\t\tauto n_instances = instance_indices.size();\n\t\t\tauto &structure = group.autodiff_structure;\n\t\t\tauto &evaluator = group.autodiff_evaluator;\n\t\t\tif (!structure.has_hessian)\n\t\t\t{\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tauto local_hessian_nnz = structure.m_hessian_nnz;\n\t\t\tauto ny = structure.ny;\n\t\t\tconst int *hessian_index = group.hessian_indices.data();\n\t\t\tif (!structure.has_parameter)\n\t\t\t{\n\t\t\t\tfor (int j = 0; j < n_instances; j++)\n\t\t\t\t{\n\t\t\t\t\tauto instance_index = instance_indices[j];\n\t\t\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\t\t\t\t\tevaluator.hessian_eval.nop(x, lambda, hessian, variables.data(), hessian_index);\n\t\t\t\t\thessian_index += local_hessian_nnz;\n\t\t\t\t\tlambda += ny;\n\t\t\t\t}\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tfor (int j = 0; j < n_instances; j++)\n\t\t\t\t{\n\t\t\t\t\tauto instance_index = instance_indices[j];\n\t\t\t\t\tauto &variables = graph_inputs[instance_index].variables;\n\t\t\t\t\tauto &constant = graph_inputs[instance_index].constants;\n\t\t\t\t\tevaluator.hessian_eval.p(x, constant.data(), lambda, hessian, variables.data(),\n\t\t\t\t\t hessian_index);\n\t\t\t\t\thessian_index += local_hessian_nnz;\n\t\t\t\t\tlambda += ny;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": "lib/nleval_ext.cpp", "content": "#include \n#include \n\n#include \"pyoptinterface/nleval.hpp\"\n\nnamespace nb = nanobind;\n\nNB_MODULE(nleval_ext, m)\n{\n\tnb::class_(m, \"AutodiffSymbolicStructure\")\n\t .def(nb::init<>())\n\t .def_ro(\"nx\", &AutodiffSymbolicStructure::nx)\n\t .def_ro(\"np\", &AutodiffSymbolicStructure::np)\n\t .def_ro(\"ny\", &AutodiffSymbolicStructure::ny)\n\t .def_ro(\"m_jacobian_rows\", &AutodiffSymbolicStructure::m_jacobian_rows)\n\t .def_ro(\"m_jacobian_cols\", &AutodiffSymbolicStructure::m_jacobian_cols)\n\t .def_ro(\"m_jacobian_nnz\", &AutodiffSymbolicStructure::m_jacobian_nnz)\n\t .def_ro(\"m_hessian_rows\", &AutodiffSymbolicStructure::m_hessian_rows)\n\t .def_ro(\"m_hessian_cols\", &AutodiffSymbolicStructure::m_hessian_cols)\n\t .def_ro(\"m_hessian_nnz\", &AutodiffSymbolicStructure::m_hessian_nnz)\n\t .def_ro(\"has_parameter\", &AutodiffSymbolicStructure::has_parameter)\n\t .def_ro(\"has_jacobian\", &AutodiffSymbolicStructure::has_jacobian)\n\t .def_ro(\"has_hessian\", &AutodiffSymbolicStructure::has_hessian);\n\n\tnb::class_(m, \"ConstraintAutodiffEvaluator\")\n\t .def(nb::init<>())\n\t .def(nb::init());\n\n\tnb::class_(m, \"ObjectiveAutodiffEvaluator\")\n\t .def(nb::init<>())\n\t .def(nb::init());\n}\n" }, { "path": "lib/nlexpr.cpp", "content": "#include \"pyoptinterface/nlexpr.hpp\"\n\n#include \n#include \n#include \"fmt/core.h\"\n\nbool ExpressionHandle::operator==(const ExpressionHandle &x) const\n{\n\treturn array == x.array && id == x.id;\n}\n\nstd::string ExpressionHandle::to_string() const\n{\n\tswitch (array)\n\t{\n\tcase ArrayType::Constant:\n\t\treturn fmt::format(\"c{}\", id);\n\tcase ArrayType::Variable:\n\t\treturn fmt::format(\"v{}\", id);\n\tcase ArrayType::Parameter:\n\t\treturn fmt::format(\"p{}\", id);\n\tcase ArrayType::Unary:\n\t\treturn fmt::format(\"u{}\", id);\n\tcase ArrayType::Binary:\n\t\treturn fmt::format(\"b{}\", id);\n\tcase ArrayType::Ternary:\n\t\treturn fmt::format(\"t{}\", id);\n\tcase ArrayType::Nary:\n\t\treturn fmt::format(\"n{}\", id);\n\tdefault:\n\t\treturn fmt::format(\"?{}\", id);\n\t}\n}\n\nstd::string ExpressionGraph::to_string() const\n{\n\tfmt::memory_buffer buf;\n\n\tfmt::format_to(fmt::appender(buf), \"Variables: {}\\n\", m_variables.size());\n\tfor (size_t i = 0; i < m_variables.size(); i++)\n\t{\n\t\tfmt::format_to(fmt::appender(buf), \"\\tv{}: {}\\n\", i, m_variables[i]);\n\t}\n\n\tfmt::format_to(fmt::appender(buf), \"Constants: {}\\n\", m_constants.size());\n\tfor (size_t i = 0; i < m_constants.size(); i++)\n\t{\n\t\tfmt::format_to(fmt::appender(buf), \"\\tc{}: {}\\n\", i, m_constants[i]);\n\t}\n\n\tfmt::format_to(fmt::appender(buf), \"Parameters: {}\\n\", m_parameters.size());\n\tfor (size_t i = 0; i < m_parameters.size(); i++)\n\t{\n\t\tfmt::format_to(fmt::appender(buf), \"\\tp{}: {}\\n\", i, m_parameters[i]);\n\t}\n\n\tfmt::format_to(fmt::appender(buf), \"Unary: {}\\n\", m_unaries.size());\n\tfor (size_t i = 0; i < m_unaries.size(); i++)\n\t{\n\t\tfmt::format_to(fmt::appender(buf), \"\\tu{}: {}({})\\n\", i,\n\t\t unary_operator_to_string(m_unaries[i].op), m_unaries[i].operand.to_string());\n\t}\n\n\tfmt::format_to(fmt::appender(buf), \"Binary: {}\\n\", m_binaries.size());\n\tfor (size_t i = 0; i < m_binaries.size(); i++)\n\t{\n\t\tfmt::format_to(fmt::appender(buf), \"\\tb{}: {}({},{})\\n\", i,\n\t\t binary_operator_to_string(m_binaries[i].op), m_binaries[i].left.to_string(),\n\t\t m_binaries[i].right.to_string());\n\t}\n\n\tfmt::format_to(fmt::appender(buf), \"Ternary: {}\\n\", m_ternaries.size());\n\tfor (size_t i = 0; i < m_ternaries.size(); i++)\n\t{\n\t\tfmt::format_to(fmt::appender(buf), \"\\tt{}: {}({},{},{})\\n\", i,\n\t\t ternary_operator_to_string(m_ternaries[i].op),\n\t\t m_ternaries[i].left.to_string(), m_ternaries[i].middle.to_string(),\n\t\t m_ternaries[i].right.to_string());\n\t}\n\n\tfmt::format_to(fmt::appender(buf), \"Nary: {}\\n\", m_naries.size());\n\tfor (size_t i = 0; i < m_naries.size(); i++)\n\t{\n\t\tfmt::format_to(fmt::appender(buf), \"\\tn{}: {}(\", i,\n\t\t nary_operator_to_string(m_naries[i].op));\n\t\tfor (size_t j = 0; j < m_naries[i].operands.size(); j++)\n\t\t{\n\t\t\tfmt::format_to(fmt::appender(buf), \"{}, \", m_naries[i].operands[j].to_string());\n\t\t}\n\t\tfmt::format_to(fmt::appender(buf), \")\\n\");\n\t}\n\n\tfmt::format_to(fmt::appender(buf), \"Constraint outputs: {}\\n\", m_constraint_outputs.size());\n\tfor (size_t i = 0; i < m_constraint_outputs.size(); i++)\n\t{\n\t\tfmt::format_to(fmt::appender(buf), \"\\tcon{}: {}\\n\", i, m_constraint_outputs[i].to_string());\n\t}\n\n\tfmt::format_to(fmt::appender(buf), \"Objective outputs: {}\\n\", m_objective_outputs.size());\n\tfor (size_t i = 0; i < m_objective_outputs.size(); i++)\n\t{\n\t\tfmt::format_to(fmt::appender(buf), \"\\tobj{}: {}\\n\", i, m_objective_outputs[i].to_string());\n\t}\n\n\treturn fmt::to_string(buf);\n}\n\nsize_t ExpressionGraph::n_variables() const\n{\n\treturn m_variables.size();\n}\n\nsize_t ExpressionGraph::n_constants() const\n{\n\treturn m_constants.size();\n}\n\nsize_t ExpressionGraph::n_parameters() const\n{\n\treturn m_parameters.size();\n}\n\nExpressionHandle ExpressionGraph::add_variable(EntityId id)\n{\n\tauto iter = m_variable_index_map.find(id);\n\tif (iter != m_variable_index_map.end())\n\t{\n\t\treturn {ArrayType::Variable, static_cast(iter->second)};\n\t}\n\telse\n\t{\n\t\tauto index = m_variables.size();\n\t\tm_variables.emplace_back(id);\n\t\tm_variable_index_map.emplace(id, index);\n\t\treturn {ArrayType::Variable, static_cast(index)};\n\t}\n}\n\nExpressionHandle ExpressionGraph::add_constant(double value)\n{\n\tm_constants.emplace_back(value);\n\treturn {ArrayType::Constant, static_cast(m_constants.size() - 1)};\n}\n\nExpressionHandle ExpressionGraph::add_parameter(EntityId id)\n{\n\tm_parameters.emplace_back(id);\n\treturn {ArrayType::Parameter, static_cast(m_parameters.size() - 1)};\n}\n\nExpressionHandle ExpressionGraph::add_unary(UnaryOperator op, ExpressionHandle operand)\n{\n\t// Constant folding: if the operand is a constant, compute the result directly\n\tif (operand.array == ArrayType::Constant)\n\t{\n\t\tdouble val = m_constants[operand.id];\n\t\tdouble result;\n\t\tswitch (op)\n\t\t{\n\t\tcase UnaryOperator::Neg:\n\t\t\tresult = -val;\n\t\t\tbreak;\n\t\tcase UnaryOperator::Sin:\n\t\t\tresult = std::sin(val);\n\t\t\tbreak;\n\t\tcase UnaryOperator::Cos:\n\t\t\tresult = std::cos(val);\n\t\t\tbreak;\n\t\tcase UnaryOperator::Tan:\n\t\t\tresult = std::tan(val);\n\t\t\tbreak;\n\t\tcase UnaryOperator::Asin:\n\t\t\tresult = std::asin(val);\n\t\t\tbreak;\n\t\tcase UnaryOperator::Acos:\n\t\t\tresult = std::acos(val);\n\t\t\tbreak;\n\t\tcase UnaryOperator::Atan:\n\t\t\tresult = std::atan(val);\n\t\t\tbreak;\n\t\tcase UnaryOperator::Abs:\n\t\t\tresult = std::abs(val);\n\t\t\tbreak;\n\t\tcase UnaryOperator::Sqrt:\n\t\t\tresult = std::sqrt(val);\n\t\t\tbreak;\n\t\tcase UnaryOperator::Exp:\n\t\t\tresult = std::exp(val);\n\t\t\tbreak;\n\t\tcase UnaryOperator::Log:\n\t\t\tresult = std::log(val);\n\t\t\tbreak;\n\t\tcase UnaryOperator::Log10:\n\t\t\tresult = std::log10(val);\n\t\t\tbreak;\n\t\tdefault:\n\t\t\t// Unknown operator, fall through to create the node\n\t\t\tgoto create_node;\n\t\t}\n\t\treturn add_constant(result);\n\t}\ncreate_node:\n\tm_unaries.emplace_back(op, operand);\n\treturn {ArrayType::Unary, static_cast(m_unaries.size() - 1)};\n}\n\nExpressionHandle ExpressionGraph::add_binary(BinaryOperator op, ExpressionHandle left,\n ExpressionHandle right)\n{\n\t// Constant folding: if both operands are constants, compute the result directly\n\t// Note: comparison operators are not folded as they produce boolean results\n\tif (left.array == ArrayType::Constant && right.array == ArrayType::Constant &&\n\t !is_binary_compare_op(op))\n\t{\n\t\tdouble lval = m_constants[left.id];\n\t\tdouble rval = m_constants[right.id];\n\t\tdouble result;\n\t\tswitch (op)\n\t\t{\n\t\tcase BinaryOperator::Sub:\n\t\t\tresult = lval - rval;\n\t\t\tbreak;\n\t\tcase BinaryOperator::Div:\n\t\t\tresult = lval / rval;\n\t\t\tbreak;\n\t\tcase BinaryOperator::Pow:\n\t\t\tresult = std::pow(lval, rval);\n\t\t\tbreak;\n\t\tcase BinaryOperator::Mul2:\n\t\t\tresult = lval * rval;\n\t\t\tbreak;\n\t\tdefault:\n\t\t\t// Comparison operators or unknown, fall through to create the node\n\t\t\tgoto create_node;\n\t\t}\n\t\treturn add_constant(result);\n\t}\ncreate_node:\n\tm_binaries.emplace_back(op, left, right);\n\treturn {ArrayType::Binary, static_cast(m_binaries.size() - 1)};\n}\n\nExpressionHandle ExpressionGraph::add_ternary(TernaryOperator op, ExpressionHandle left,\n ExpressionHandle middle, ExpressionHandle right)\n{\n\tm_ternaries.emplace_back(op, left, middle, right);\n\treturn {ArrayType::Ternary, static_cast(m_ternaries.size() - 1)};\n}\n\nExpressionHandle ExpressionGraph::add_nary(NaryOperator op,\n const std::vector &operands)\n{\n\t// Constant folding: if all operands are constants, compute the result directly\n\tbool all_constants = true;\n\tfor (const auto &operand : operands)\n\t{\n\t\tif (operand.array != ArrayType::Constant)\n\t\t{\n\t\t\tall_constants = false;\n\t\t\tbreak;\n\t\t}\n\t}\n\n\tif (all_constants && !operands.empty())\n\t{\n\t\tdouble result;\n\t\tswitch (op)\n\t\t{\n\t\tcase NaryOperator::Add:\n\t\t\tresult = 0.0;\n\t\t\tfor (const auto &operand : operands)\n\t\t\t{\n\t\t\t\tresult += m_constants[operand.id];\n\t\t\t}\n\t\t\tbreak;\n\t\tcase NaryOperator::Mul:\n\t\t\tresult = 1.0;\n\t\t\tfor (const auto &operand : operands)\n\t\t\t{\n\t\t\t\tresult *= m_constants[operand.id];\n\t\t\t}\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tgoto create_node;\n\t\t}\n\t\treturn add_constant(result);\n\t}\n\ncreate_node:\n\tm_naries.emplace_back(op, operands);\n\treturn {ArrayType::Nary, static_cast(m_naries.size() - 1)};\n}\n\nExpressionHandle ExpressionGraph::add_repeat_nary(NaryOperator op, ExpressionHandle operand, int N)\n{\n\tstd::vector operands(N, operand);\n\treturn add_nary(op, operands);\n}\n\nvoid ExpressionGraph::append_nary(const ExpressionHandle &expression,\n const ExpressionHandle &operand)\n{\n\tassert(expression.array == ArrayType::Nary);\n\tm_naries[expression.id].operands.push_back(operand);\n}\n\nNaryOperator ExpressionGraph::get_nary_operator(const ExpressionHandle &expression) const\n{\n\tassert(expression.array == ArrayType::Nary);\n\treturn m_naries[expression.id].op;\n}\n\nvoid ExpressionGraph::add_constraint_output(const ExpressionHandle &expression)\n{\n\tm_constraint_outputs.push_back(expression);\n}\n\nvoid ExpressionGraph::add_objective_output(const ExpressionHandle &expression)\n{\n\tm_objective_outputs.push_back(expression);\n}\n\nbool ExpressionGraph::has_constraint_output() const\n{\n\treturn !m_constraint_outputs.empty();\n}\n\nbool ExpressionGraph::has_objective_output() const\n{\n\treturn !m_objective_outputs.empty();\n}\n\nExpressionHandle ExpressionGraph::merge_variableindex(const VariableIndex &v)\n{\n\treturn add_variable(v.index);\n}\n\nExpressionHandle ExpressionGraph::merge_scalaraffinefunction(const ScalarAffineFunction &f)\n{\n\t// Convert it to a n-ary sum of multiplication nodes\n\tauto N = f.size();\n\tstd::vector terms;\n\tterms.reserve(N);\n\tfor (size_t i = 0; i < N; i++)\n\t{\n\t\tauto x = add_variable(f.variables[i]);\n\t\tauto coef = f.coefficients[i];\n\t\tif (coef == 1.0)\n\t\t{\n\t\t\tterms.push_back(x);\n\t\t}\n\t\telse if (coef == -1.0)\n\t\t{\n\t\t\tauto neg = add_unary(UnaryOperator::Neg, x);\n\t\t\tterms.push_back(neg);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tauto c = add_constant(coef);\n\t\t\tterms.push_back(add_nary(NaryOperator::Mul, {c, x}));\n\t\t}\n\t}\n\tif (f.constant)\n\t{\n\t\tterms.push_back(add_constant(f.constant.value()));\n\t}\n\tif (terms.size() == 1)\n\t{\n\t\treturn terms[0];\n\t}\n\telse\n\t{\n\t\treturn add_nary(NaryOperator::Add, terms);\n\t}\n}\n\nExpressionHandle ExpressionGraph::merge_scalarquadraticfunction(const ScalarQuadraticFunction &f)\n{\n\tauto N = f.size();\n\tstd::vector terms;\n\tterms.reserve(N + 1);\n\tfor (size_t i = 0; i < N; i++)\n\t{\n\t\tauto x1 = f.variable_1s[i];\n\t\tauto x2 = f.variable_2s[i];\n\t\tauto coef = f.coefficients[i];\n\n\t\tExpressionHandle x1_var = add_variable(x1);\n\t\tExpressionHandle x2_var;\n\n\t\tif (x1 == x2)\n\t\t{\n\t\t\tx2_var = x1_var;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tx2_var = add_variable(x2);\n\t\t}\n\n\t\tif (coef == 1.0)\n\t\t{\n\t\t\tterms.push_back(add_nary(NaryOperator::Mul, {x1_var, x2_var}));\n\t\t}\n\t\telse if (coef == -1.0)\n\t\t{\n\t\t\tauto neg = add_unary(UnaryOperator::Neg, add_nary(NaryOperator::Mul, {x1_var, x2_var}));\n\t\t\tterms.push_back(neg);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tauto c = add_constant(coef);\n\t\t\tterms.push_back(add_nary(NaryOperator::Mul, {c, x1_var, x2_var}));\n\t\t}\n\t}\n\tif (f.affine_part)\n\t{\n\t\tterms.push_back(merge_scalaraffinefunction(f.affine_part.value()));\n\t}\n\tif (terms.size() == 1)\n\t{\n\t\treturn terms[0];\n\t}\n\telse\n\t{\n\t\treturn add_nary(NaryOperator::Add, terms);\n\t}\n}\n\nExpressionHandle ExpressionGraph::merge_exprbuilder(const ExprBuilder &expr)\n{\n\tstd::vector terms;\n\tterms.reserve(expr.quadratic_terms.size() + expr.affine_terms.size() + 1);\n\tfor (const auto &[varpair, coef] : expr.quadratic_terms)\n\t{\n\t\tauto x1 = varpair.var_1;\n\t\tauto x2 = varpair.var_2;\n\n\t\tExpressionHandle x1_var = add_variable(x1);\n\t\tExpressionHandle x2_var;\n\n\t\tif (x1 == x2)\n\t\t{\n\t\t\tx2_var = x1_var;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tx2_var = add_variable(x2);\n\t\t}\n\n\t\tif (coef == 1.0)\n\t\t{\n\t\t\tterms.push_back(add_nary(NaryOperator::Mul, {x1_var, x2_var}));\n\t\t}\n\t\telse if (coef == -1.0)\n\t\t{\n\t\t\tauto neg = add_unary(UnaryOperator::Neg, add_nary(NaryOperator::Mul, {x1_var, x2_var}));\n\t\t\tterms.push_back(neg);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tauto c = add_constant(coef);\n\t\t\tterms.push_back(add_nary(NaryOperator::Mul, {c, x1_var, x2_var}));\n\t\t}\n\t}\n\tfor (const auto &[var, coef] : expr.affine_terms)\n\t{\n\t\tauto x = add_variable(var);\n\t\tif (coef == 1.0)\n\t\t{\n\t\t\tterms.push_back(x);\n\t\t}\n\t\telse if (coef == -1.0)\n\t\t{\n\t\t\tauto neg = add_unary(UnaryOperator::Neg, x);\n\t\t\tterms.push_back(neg);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tauto c = add_constant(coef);\n\t\t\tterms.push_back(add_nary(NaryOperator::Mul, {c, x}));\n\t\t}\n\t}\n\tif (expr.constant_term)\n\t{\n\t\tterms.push_back(add_constant(expr.constant_term.value()));\n\t}\n\tif (terms.size() == 1)\n\t{\n\t\treturn terms[0];\n\t}\n\telse\n\t{\n\t\treturn add_nary(NaryOperator::Add, terms);\n\t}\n}\n\nbool is_binary_compare_op(BinaryOperator op)\n{\n\treturn (op >= BinaryOperator::LessThan) && (op <= BinaryOperator::GreaterThan);\n}\n\nbool ExpressionGraph::is_compare_expression(const ExpressionHandle &expr) const\n{\n\tif (expr.array != ArrayType::Binary)\n\t{\n\t\treturn false;\n\t}\n\tauto &binary = m_binaries[expr.id];\n\tauto op = binary.op;\n\treturn is_binary_compare_op(op);\n}\n\nstd::string unary_operator_to_string(UnaryOperator op)\n{\n\tswitch (op)\n\t{\n\tcase UnaryOperator::Neg:\n\t\treturn \"Neg\";\n\tcase UnaryOperator::Sin:\n\t\treturn \"Sin\";\n\tcase UnaryOperator::Cos:\n\t\treturn \"Cos\";\n\tcase UnaryOperator::Tan:\n\t\treturn \"Tan\";\n\tcase UnaryOperator::Asin:\n\t\treturn \"Asin\";\n\tcase UnaryOperator::Acos:\n\t\treturn \"Acos\";\n\tcase UnaryOperator::Atan:\n\t\treturn \"Atan\";\n\tcase UnaryOperator::Abs:\n\t\treturn \"Abs\";\n\tcase UnaryOperator::Sqrt:\n\t\treturn \"Sqrt\";\n\tcase UnaryOperator::Exp:\n\t\treturn \"Exp\";\n\tcase UnaryOperator::Log:\n\t\treturn \"Log\";\n\tcase UnaryOperator::Log10:\n\t\treturn \"Log10\";\n\tdefault:\n\t\treturn \"UnknownUnary\";\n\t}\n}\n\nstd::string binary_operator_to_string(BinaryOperator op)\n{\n\tswitch (op)\n\t{\n\tcase BinaryOperator::Sub:\n\t\treturn \"Sub\";\n\tcase BinaryOperator::Div:\n\t\treturn \"Div\";\n\tcase BinaryOperator::Pow:\n\t\treturn \"Pow\";\n\tcase BinaryOperator::LessThan:\n\t\treturn \"LessThan\";\n\tcase BinaryOperator::LessEqual:\n\t\treturn \"LessEqual\";\n\tcase BinaryOperator::Equal:\n\t\treturn \"Equal\";\n\tcase BinaryOperator::NotEqual:\n\t\treturn \"NotEqual\";\n\tcase BinaryOperator::GreaterEqual:\n\t\treturn \"GreaterEqual\";\n\tcase BinaryOperator::GreaterThan:\n\t\treturn \"GreaterThan\";\n\tcase BinaryOperator::Add2:\n\t\treturn \"Add2\";\n\tcase BinaryOperator::Mul2:\n\t\treturn \"Mul2\";\n\tdefault:\n\t\treturn \"UnknownBinary\";\n\t}\n}\n\nstd::string ternary_operator_to_string(TernaryOperator op)\n{\n\tswitch (op)\n\t{\n\tcase TernaryOperator::IfThenElse:\n\t\treturn \"IfThenElse\";\n\tdefault:\n\t\treturn \"UnknownTernary\";\n\t}\n}\n\nstd::string nary_operator_to_string(NaryOperator op)\n{\n\tswitch (op)\n\t{\n\tcase NaryOperator::Add:\n\t\treturn \"Add\";\n\tcase NaryOperator::Mul:\n\t\treturn \"Mul\";\n\tdefault:\n\t\treturn \"UnknownNary\";\n\t}\n}\n\ninline static void hash_combine(uint64_t &hash, const uint64_t subhash)\n{\n\thash ^= subhash + 0x9e3779b9 + (hash << 6) + (hash >> 2);\n}\n\ninline static uint64_t to_i64(const ExpressionHandle &expr)\n{\n\tuint32_t array = static_cast(expr.array);\n\tuint32_t id = static_cast(expr.id);\n\treturn (static_cast(array) << 32) | id;\n}\n\nuint64_t ExpressionGraph::main_structure_hash() const\n{\n\tuint64_t hash = 0;\n\thash_combine(hash, m_variables.size());\n\thash_combine(hash, m_constants.size());\n\thash_combine(hash, m_parameters.size());\n\n\tfor (const auto &unary : m_unaries)\n\t{\n\t\thash_combine(hash, (uint64_t)unary.op);\n\t\thash_combine(hash, to_i64(unary.operand));\n\t}\n\tfor (const auto &binary : m_binaries)\n\t{\n\t\thash_combine(hash, (uint64_t)binary.op);\n\t\thash_combine(hash, to_i64(binary.left));\n\t\thash_combine(hash, to_i64(binary.right));\n\t}\n\tfor (const auto &ternary : m_ternaries)\n\t{\n\t\thash_combine(hash, (uint64_t)ternary.op);\n\t\thash_combine(hash, to_i64(ternary.left));\n\t\thash_combine(hash, to_i64(ternary.middle));\n\t\thash_combine(hash, to_i64(ternary.right));\n\t}\n\tfor (const auto &nary : m_naries)\n\t{\n\t\thash_combine(hash, (uint64_t)nary.op);\n\t\tfor (const auto &operand : nary.operands)\n\t\t{\n\t\t\thash_combine(hash, to_i64(operand));\n\t\t}\n\t}\n\treturn hash;\n}\n\nuint64_t ExpressionGraph::constraint_structure_hash(uint64_t hash) const\n{\n\tfor (const auto &output : m_constraint_outputs)\n\t{\n\t\thash_combine(hash, to_i64(output));\n\t}\n\treturn hash;\n}\n\nuint64_t ExpressionGraph::objective_structure_hash(uint64_t hash) const\n{\n\tfor (const auto &output : m_objective_outputs)\n\t{\n\t\thash_combine(hash, to_i64(output));\n\t}\n\treturn hash;\n}\n\nvoid unpack_comparison_expression(ExpressionGraph &graph, const ExpressionHandle &expr,\n ExpressionHandle &real_expr, double &lb, double &ub)\n{\n\t// Only handles constraint in the form of f <= g or f >= g or f == g\n\t// We need to tell if f or g is constant\n\t// if not, it will be converted into f-g <= 0 or f-g >= 0\n\tauto array_type = expr.array;\n\tauto index = expr.id;\n\n\tif (array_type != ArrayType::Binary)\n\t{\n\t\tthrow std::runtime_error(\"Only binary operator is supported for comparison constraint\");\n\t}\n\n\tauto &binary = graph.m_binaries[index];\n\tauto op = binary.op;\n\tif (op != BinaryOperator::LessEqual && op != BinaryOperator::GreaterEqual &&\n\t op != BinaryOperator::Equal)\n\t{\n\t\tthrow std::runtime_error(\"Only <= or >= or == is supported for comparison constraint\");\n\t}\n\n\tauto f = binary.left;\n\tauto g = binary.right;\n\n\tif (op == BinaryOperator::GreaterEqual)\n\t{\n\t\t// swap f and g\n\t\tauto temp = f;\n\t\tf = g;\n\t\tg = temp;\n\n\t\top = BinaryOperator::LessEqual;\n\t}\n\n\t// Now we only handle f <= g or f == g\n\n\t// test if f or g is constant\n\tbool f_is_constant = f.array == ArrayType::Constant;\n\tbool g_is_constant = g.array == ArrayType::Constant;\n\n\tif (op == BinaryOperator::LessEqual)\n\t{\n\t\tif (f_is_constant)\n\t\t{\n\t\t\tlb = graph.m_constants[f.id];\n\t\t\treal_expr = g;\n\t\t}\n\t\telse if (g_is_constant)\n\t\t{\n\t\t\tub = graph.m_constants[g.id];\n\t\t\treal_expr = f;\n\t\t}\n\t\telse\n\t\t{\n\t\t\t// f - g <= 0\n\t\t\treal_expr = graph.add_binary(BinaryOperator::Sub, f, g);\n\t\t\tub = 0.0;\n\t\t}\n\t}\n\telse\n\t{\n\t\tif (f_is_constant)\n\t\t{\n\t\t\tlb = ub = graph.m_constants[f.id];\n\t\t\treal_expr = g;\n\t\t}\n\t\telse if (g_is_constant)\n\t\t{\n\t\t\tlb = ub = graph.m_constants[g.id];\n\t\t\treal_expr = f;\n\t\t}\n\t\telse\n\t\t{\n\t\t\t// f - g == 0\n\t\t\treal_expr = graph.add_binary(BinaryOperator::Sub, f, g);\n\t\t\tlb = ub = 0.0;\n\t\t}\n\t}\n}\n" }, { "path": "lib/nlexpr_ext.cpp", "content": "#include \n#include \n#include \n#include \n\n#include \"pyoptinterface/nlexpr.hpp\"\n\nnamespace nb = nanobind;\n\nNB_MODULE(nlexpr_ext, m)\n{\n\tm.import_(\"pyoptinterface._src.core_ext\");\n\n\tnb::enum_(m, \"ArrayType\")\n\t .value(\"Constant\", ArrayType::Constant)\n\t .value(\"Variable\", ArrayType::Variable)\n\t .value(\"Parameter\", ArrayType::Parameter)\n\t .value(\"Unary\", ArrayType::Unary)\n\t .value(\"Binary\", ArrayType::Binary)\n\t .value(\"Ternary\", ArrayType::Ternary)\n\t .value(\"Nary\", ArrayType::Nary);\n\n\tnb::enum_(m, \"UnaryOperator\")\n\t .value(\"Neg\", UnaryOperator::Neg)\n\t .value(\"Sin\", UnaryOperator::Sin)\n\t .value(\"Cos\", UnaryOperator::Cos)\n\t .value(\"Tan\", UnaryOperator::Tan)\n\t .value(\"Asin\", UnaryOperator::Asin)\n\t .value(\"Acos\", UnaryOperator::Acos)\n\t .value(\"Atan\", UnaryOperator::Atan)\n\t .value(\"Abs\", UnaryOperator::Abs)\n\t .value(\"Sqrt\", UnaryOperator::Sqrt)\n\t .value(\"Exp\", UnaryOperator::Exp)\n\t .value(\"Log\", UnaryOperator::Log)\n\t .value(\"Log10\", UnaryOperator::Log10);\n\n\tnb::enum_(m, \"BinaryOperator\")\n\t .value(\"Sub\", BinaryOperator::Sub)\n\t .value(\"Div\", BinaryOperator::Div)\n\t .value(\"Pow\", BinaryOperator::Pow)\n\t // compare ops\n\t .value(\"LessThan\", BinaryOperator::LessThan)\n\t .value(\"LessEqual\", BinaryOperator::LessEqual)\n\t .value(\"Equal\", BinaryOperator::Equal)\n\t .value(\"NotEqual\", BinaryOperator::NotEqual)\n\t .value(\"GreaterEqual\", BinaryOperator::GreaterEqual)\n\t .value(\"GreaterThan\", BinaryOperator::GreaterThan);\n\n\tnb::enum_(m, \"TernaryOperator\")\n\t .value(\"IfThenElse\", TernaryOperator::IfThenElse);\n\n\tnb::enum_(m, \"NaryOperator\")\n\t .value(\"Add\", NaryOperator::Add)\n\t .value(\"Mul\", NaryOperator::Mul);\n\n\tnb::class_(m, \"ExpressionHandle\")\n\t .def(nb::init())\n\t .def_ro(\"array\", &ExpressionHandle::array)\n\t .def_ro(\"id\", &ExpressionHandle::id);\n\n\tnb::class_(m, \"UnaryNode\")\n\t .def(nb::init())\n\t .def_ro(\"op\", &UnaryNode::op)\n\t .def_ro(\"operand\", &UnaryNode::operand);\n\n\tnb::class_(m, \"BinaryNode\")\n\t .def(nb::init())\n\t .def_ro(\"op\", &BinaryNode::op)\n\t .def_ro(\"left\", &BinaryNode::left)\n\t .def_ro(\"right\", &BinaryNode::right);\n\n\tnb::class_(m, \"NaryNode\")\n\t .def(nb::init &>())\n\t .def_ro(\"op\", &NaryNode::op)\n\t .def_ro(\"operands\", &NaryNode::operands);\n\n\tnb::class_(m, \"ExpressionGraph\")\n\t .def(nb::init<>())\n\t .def(\"__str__\", &ExpressionGraph::to_string)\n\t .def(\"n_variables\", &ExpressionGraph::n_variables)\n\t .def(\"n_parameters\", &ExpressionGraph::n_parameters)\n\t .def(\"add_variable\", &ExpressionGraph::add_variable, nb::arg(\"id\") = 0)\n\t .def(\"add_constant\", &ExpressionGraph::add_constant, nb::arg(\"value\"))\n\t .def(\"add_parameter\", &ExpressionGraph::add_parameter, nb::arg(\"id\") = 0)\n\t .def(\"add_unary\", &ExpressionGraph::add_unary)\n\t .def(\"add_binary\", &ExpressionGraph::add_binary)\n\t .def(\"add_ternary\", &ExpressionGraph::add_ternary)\n\t .def(\"add_nary\", &ExpressionGraph::add_nary)\n\t .def(\"add_repeat_nary\", &ExpressionGraph::add_repeat_nary)\n\t .def(\"append_nary\", &ExpressionGraph::append_nary)\n\t .def(\"get_nary_operator\", &ExpressionGraph::get_nary_operator)\n\t .def(\"add_constraint_output\", &ExpressionGraph::add_constraint_output)\n\t .def(\"add_objective_output\", &ExpressionGraph::add_objective_output)\n\t .def(\"merge_variableindex\", &ExpressionGraph::merge_variableindex)\n\t .def(\"merge_scalaraffinefunction\", &ExpressionGraph::merge_scalaraffinefunction)\n\t .def(\"merge_scalarquadraticfunction\", &ExpressionGraph::merge_scalarquadraticfunction)\n\t .def(\"merge_exprbuilder\", &ExpressionGraph::merge_exprbuilder)\n\t .def(\"is_compare_expression\", &ExpressionGraph::is_compare_expression);\n\n\tm.def(\"unpack_comparison_expression\",\n\t [](ExpressionGraph &graph, const ExpressionHandle &expr, double INF) {\n\t\t ExpressionHandle real_expr;\n\t\t double lb = -INF, ub = INF;\n\t\t unpack_comparison_expression(graph, expr, real_expr, lb, ub);\n\t\t return std::make_tuple(real_expr, lb, ub);\n\t });\n}\n" }, { "path": "lib/tcc_interface.cpp", "content": "#include \"pyoptinterface/tcc_interface.hpp\"\n#include \n#include \n#include \"fmt/core.h\"\n\nnamespace tcc\n{\n#define B DYLIB_DECLARE\nAPILIST\n#undef B\n\nstatic DynamicLibrary lib;\nstatic bool is_loaded = false;\n\nbool is_library_loaded()\n{\n\treturn is_loaded;\n}\n\nbool load_library(const std::string &path)\n{\n\tbool success = lib.try_load(path.c_str());\n\tif (!success)\n\t{\n\t\treturn false;\n\t}\n\n\tDYLIB_LOAD_INIT;\n\n#define B DYLIB_LOAD_FUNCTION\n\tAPILIST\n#undef B\n\n\tif (IS_DYLIB_LOAD_SUCCESS)\n\t{\n#define B DYLIB_SAVE_FUNCTION\n\t\tAPILIST\n#undef B\n\t\tis_loaded = true;\n\t\treturn true;\n\t}\n\telse\n\t{\n\t\treturn false;\n\t}\n}\n} // namespace tcc\n\nvoid TCCInstance::init()\n{\n\tTCCState *state = tcc::tcc_new();\n\n\tif (state == nullptr)\n\t{\n\t\tthrow std::runtime_error(\"Failed to create TCC state\");\n\t}\n\n\tm_state.reset(state);\n\n\tint ret = tcc::tcc_set_output_type(m_state.get(), TCC_OUTPUT_MEMORY);\n\tif (ret == -1)\n\t{\n\t\tthrow std::runtime_error(\"Failed to set output type\");\n\t}\n}\n\nvoid TCCInstance::add_include_path(const std::string &path)\n{\n\tint ret = tcc::tcc_add_include_path(m_state.get(), path.c_str());\n\tif (ret == -1)\n\t{\n\t\tthrow std::runtime_error(fmt::format(\"Failed to add include path {}\", path));\n\t}\n}\n\nvoid TCCInstance::add_sysinclude_path(const std::string &path)\n{\n\tint ret = tcc::tcc_add_sysinclude_path(m_state.get(), path.c_str());\n\tif (ret == -1)\n\t{\n\t\tthrow std::runtime_error(fmt::format(\"Failed to add sysinclude path {}\", path));\n\t}\n}\n\nvoid TCCInstance::add_library_path(const std::string &path)\n{\n\tint ret = tcc::tcc_add_library_path(m_state.get(), path.c_str());\n\tif (ret == -1)\n\t{\n\t\tthrow std::runtime_error(fmt::format(\"Failed to add library path {}\", path));\n\t}\n}\n\nvoid TCCInstance::add_library(const std::string &name)\n{\n\tint ret = tcc::tcc_add_library(m_state.get(), name.c_str());\n\tif (ret == -1)\n\t{\n\t\tthrow std::runtime_error(fmt::format(\"Failed to add library {}\", name));\n\t}\n}\n\nvoid TCCInstance::import_math_symbols()\n{\n\tint ret;\n\n#define UNARY_MATH_SYMBOL(name) \\\n\t{ \\\n\t\tauto ptr = static_cast(name); \\\n\t\tret = tcc::tcc_add_symbol(m_state.get(), #name, reinterpret_cast(ptr)); \\\n\t\tif (ret == -1) \\\n\t\t{ \\\n\t\t\tthrow std::runtime_error(fmt::format(\"Failed to add symbol {}\", #name)); \\\n\t\t} \\\n\t}\n\n\tUNARY_MATH_SYMBOL(sin);\n\tUNARY_MATH_SYMBOL(cos);\n\tUNARY_MATH_SYMBOL(tan);\n\tUNARY_MATH_SYMBOL(asin);\n\tUNARY_MATH_SYMBOL(acos);\n\tUNARY_MATH_SYMBOL(atan);\n\tUNARY_MATH_SYMBOL(fabs);\n\tUNARY_MATH_SYMBOL(sqrt);\n\tUNARY_MATH_SYMBOL(exp);\n\tUNARY_MATH_SYMBOL(log);\n\tUNARY_MATH_SYMBOL(log10);\n\n#define BINARY_MATH_SYMBOL(name) \\\n\t{ \\\n\t\tauto ptr = static_cast(name); \\\n\t\tret = tcc::tcc_add_symbol(m_state.get(), #name, reinterpret_cast(ptr)); \\\n\t\tif (ret == -1) \\\n\t\t{ \\\n\t\t\tthrow std::runtime_error(fmt::format(\"Failed to add symbol {}\", #name)); \\\n\t\t} \\\n\t}\n\n\tBINARY_MATH_SYMBOL(pow);\n\n#undef UNARY_MATH_SYMBOL\n#undef BINARY_MATH_SYMBOL\n}\n\nvoid TCCInstance::compile_string(const std::string &code)\n{\n\tint ret = tcc::tcc_compile_string(m_state.get(), code.c_str());\n\tif (ret == -1)\n\t{\n\t\tthrow std::runtime_error(\"Failed to compile code\");\n\t}\n\n\tret = tcc::tcc_relocate(m_state.get());\n\tif (ret == -1)\n\t{\n\t\tthrow std::runtime_error(\"Failed to relocate code\");\n\t}\n}\n\nuintptr_t TCCInstance::get_symbol(const std::string &name)\n{\n\tvoid *ptr = tcc::tcc_get_symbol(m_state.get(), name.c_str());\n\tif (ptr == nullptr)\n\t{\n\t\tthrow std::runtime_error(fmt::format(\"Failed to get symbol {}\", name));\n\t}\n\treturn reinterpret_cast(ptr);\n}\n" }, { "path": "lib/tcc_interface_ext.cpp", "content": "#include \n#include \n\n#include \"pyoptinterface/tcc_interface.hpp\"\n\nnamespace nb = nanobind;\n\nNB_MODULE(tcc_interface_ext, m)\n{\n\tm.def(\"is_library_loaded\", &tcc::is_library_loaded);\n\tm.def(\"load_library\", &tcc::load_library);\n\n\tnb::class_(m, \"TCCInstance\")\n\t .def(nb::init<>())\n\t .def(\"init\", &TCCInstance::init)\n\t .def(\"add_include_path\", &TCCInstance::add_include_path)\n\t .def(\"add_sysinclude_path\", &TCCInstance::add_sysinclude_path)\n\t .def(\"add_library_path\", &TCCInstance::add_library_path)\n\t .def(\"add_library\", &TCCInstance::add_library)\n\t .def(\"import_math_symbols\", &TCCInstance::import_math_symbols)\n\t .def(\"compile_string\", &TCCInstance::compile_string)\n\t .def(\"get_symbol\", &TCCInstance::get_symbol);\n}" }, { "path": "lib/xpress_model.cpp", "content": "#include \"pyoptinterface/xpress_model.hpp\"\n#include \"fmt/core.h\"\n#include \"pyoptinterface/core.hpp\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#ifndef _WIN32\n#include \n#endif\n\nnamespace xpress\n{\n\n// Simple helper to have a Go-like defer functionality.\n// Mainly used to move resource release closer to its acquisition.\ntemplate \nstruct Defer : LmdT\n{\n\tDefer(LmdT l) : LmdT(l) {};\n\t~Defer() noexcept\n\t{\n\t\t(*this)();\n\t}\n};\n\n// Mimics what is done to load the other solvers.\n#define B DYLIB_DECLARE\nAPILIST\n#undef B\n\nstatic DynamicLibrary lib;\nstatic bool is_loaded = false;\n\nbool is_library_loaded()\n{\n\treturn is_loaded;\n}\n\nbool load_library(const std::string &path)\n{\n\tbool success = lib.try_load(path.c_str());\n\tif (!success)\n\t{\n\t\treturn false;\n\t}\n\n\tDYLIB_LOAD_INIT;\n\n#define B DYLIB_LOAD_FUNCTION\n\tAPILIST\n#undef B\n\n\tif (IS_DYLIB_LOAD_SUCCESS)\n\t{\n#define B DYLIB_SAVE_FUNCTION\n\t\tAPILIST\n#undef B\n\t\tis_loaded = true;\n\t\tint major = {};\n\t\tint minor = {};\n\t\tint build = {};\n\t\tXPRSgetversionnumbers(&major, &minor, &build);\n\t\t// Use tuple comparison operator\n\t\tif (major < XPRS_VER_MAJOR)\n\t\t{\n\t\t\tfmt::print(\n\t\t\t stderr,\n\t\t\t \"Warning: loaded Xpress version is older than the officially supported one.\\n\");\n\t\t}\n\t}\n\treturn is_loaded;\n}\n\nstatic void check_license(int error)\n{\n\tif (error == 0)\n\t{\n\t\treturn;\n\t}\n\n\tchar buffer[POI_XPRS_MAXMESSAGELENGTH];\n\tif (XPRSgetlicerrmsg(buffer, sizeof buffer) != 0)\n\t{\n\t\tthrow std::runtime_error(\"Error while getting the Xpress license error message\");\n\t}\n\tthrow std::runtime_error(\n\t fmt::format(\"Error while initializing Xpress Environment: {}\", buffer));\n}\n\nEnv::Env(const char *path)\n{\n\tif (!xpress::is_library_loaded())\n\t{\n\t\tthrow std::runtime_error(\"Xpress library is not loaded\");\n\t}\n\n\tauto lg = std::lock_guard(mtx);\n\tassert(init_count >= 0);\n\n\tif (init_count <= 0)\n\t{\n\t\tcheck_license(XPRSinit(path));\n\t}\n\t++init_count;\n\tinitialized = true;\n}\n\nEnv::~Env()\n{\n\ttry\n\t{\n\t\tclose();\n\t}\n\tcatch (std::exception e)\n\t{\n\t\tfmt::print(stderr, \"{}\\n\", e.what());\n\t\tfflush(stderr);\n\t}\n}\n\nvoid Env::close()\n{\n\tif (!initialized)\n\t{\n\t\treturn;\n\t}\n\tinitialized = false;\n\n\tauto lg = std::lock_guard(mtx);\n\t--init_count;\n\tassert(init_count >= 0);\n\n\tif (init_count <= 0 && XPRSfree() != 0)\n\t{\n\t\tthrow std::runtime_error(\"Error while freeing Xpress environment\");\n\t}\n}\n\nstd::pair license(int p_i, const char *p_c)\n{\n\tint i = p_i;\n\tstd::string c(p_c);\n\tcheck_license(XPRSlicense(&i, c.data()));\n\tc.resize(strlen(c.data()));\n\treturn std::make_pair(i, c);\n}\n\nbool beginlicensing()\n{\n\tint notyet = {};\n\tcheck_license(XPRSbeginlicensing(¬yet));\n\treturn notyet != 0;\n}\n\nvoid endlicensing()\n{\n\tcheck_license(XPRSendlicensing());\n}\n\nstatic char poi_to_xprs_cons_sense(ConstraintSense sense)\n{\n\tswitch (sense)\n\t{\n\tcase ConstraintSense::LessEqual:\n\t\treturn 'L';\n\tcase ConstraintSense::Equal:\n\t\treturn 'E';\n\tcase ConstraintSense::GreaterEqual:\n\t\treturn 'G';\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint sense\");\n\t}\n}\n\nstatic ConstraintSense xprs_to_poi_cons_sense(int ctype)\n{\n\tswitch (ctype)\n\t{\n\tcase 'L':\n\t\treturn ConstraintSense::LessEqual;\n\tcase 'E':\n\t\treturn ConstraintSense::Equal;\n\tcase 'G':\n\t\treturn ConstraintSense::GreaterEqual;\n\tcase 'R': // Range constraints\n\tcase 'N': // Free constraints\n\tdefault:\n\t\tthrow std::runtime_error(\"Unsupported constraint sense\");\n\t}\n}\nstatic int poi_to_xprs_obj_sense(ObjectiveSense sense)\n{\n\tswitch (sense)\n\t{\n\tcase ObjectiveSense::Minimize:\n\t\treturn POI_XPRS_OBJ_MINIMIZE;\n\tcase ObjectiveSense::Maximize:\n\t\treturn POI_XPRS_OBJ_MAXIMIZE;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown objective function sense\");\n\t}\n}\n\nstatic char poi_to_xprs_var_type(VariableDomain domain)\n{\n\tswitch (domain)\n\t{\n\tcase VariableDomain::Continuous:\n\t\treturn 'C';\n\tcase VariableDomain::Integer:\n\t\treturn 'I';\n\tcase VariableDomain::Binary:\n\t\treturn 'B';\n\tcase VariableDomain::SemiContinuous:\n\t\treturn 'S';\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown variable domain\");\n\t}\n}\n\nstatic VariableDomain xprs_to_poi_var_type(char vtype)\n{\n\tswitch (vtype)\n\t{\n\tcase 'C':\n\t\treturn VariableDomain::Continuous;\n\tcase 'I':\n\t\treturn VariableDomain::Integer;\n\tcase 'B':\n\t\treturn VariableDomain::Binary;\n\tcase 'S':\n\t\treturn VariableDomain::SemiContinuous;\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown variable domain\");\n\t}\n}\n\nstatic char poi_to_xprs_sos_type(SOSType type)\n{\n\tswitch (type)\n\t{\n\tcase SOSType::SOS1:\n\t\treturn '1';\n\tcase SOSType::SOS2:\n\t\treturn '2';\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown SOS type\");\n\t}\n}\n\n// Check Xpress APIs return value for error and throws in case it is non-zero\nvoid Model::_check(int error)\n{\n\t// We allow users to define custom message callbacks which may throw exceptions. Since\n\t// Xpress APIs can trigger messages at any point, exceptions might be thrown even from\n\t// apparently \"safe\" operations. We always check for captured exceptions before returning.\n\tif (m_mode == XPRESS_MODEL_MODE::MAIN && !m_captured_exceptions.empty())\n\t{\n\t\tDefer exceptions_clear = [&] { m_captured_exceptions.clear(); };\n\n\t\t// Single exception - rethrow directly\n\t\tif (m_captured_exceptions.size() == 1)\n\t\t{\n\t\t\tstd::rethrow_exception(m_captured_exceptions[0]);\n\t\t}\n\n\t\t// Multiple exceptions - aggregate into single message\n\t\tstd::string new_what = \"Multiple exceptions raised:\\n\";\n\t\tfor (int i = 0; const auto &exc : m_captured_exceptions)\n\t\t{\n\t\t\ttry\n\t\t\t{\n\t\t\t\tstd::rethrow_exception(exc);\n\t\t\t}\n\t\t\tcatch (const std::exception &e)\n\t\t\t{\n\t\t\t\tfmt::format_to(std::back_inserter(new_what), \"{}. {}\\n\", ++i, e.what());\n\t\t\t}\n\t\t\tcatch (...)\n\t\t\t{\n\t\t\t\tfmt::format_to(std::back_inserter(new_what), \"{}. Unknown exception\\n\", ++i);\n\t\t\t}\n\t\t}\n\t\tthrow std::runtime_error(new_what);\n\t}\n\n\tif (error == 0)\n\t{\n\t\treturn;\n\t}\n\n\tchar error_buffer[POI_XPRS_MAXMESSAGELENGTH];\n\tif (XPRSgetlasterror(m_model.get(), error_buffer) != 0)\n\t{\n\t\tthrow std::runtime_error(\"Error while getting Xpress message error\");\n\t}\n\tthrow std::runtime_error(error_buffer);\n}\n\n// The default behavior of Xpress C APIs is to don't print anything unless a message CB is\n// registered. Thus, this is the default print callback that redirect to standard streams.\nstatic void default_print(XPRSprob prob, void *, char const *msg, int msgsize, int msgtype)\n{\n\tif (msgtype < 0)\n\t{\n\t\t// Negative values are used to signal output end, and can be use as flush trigger\n\t\t// But we flush at every message, so no problem need to flush again.\n\t\treturn;\n\t}\n\n\tFILE *out = (msgtype == 1 ? stdout : stderr);\n\tfmt::print(out, \"{}\\n\", msgsize > 0 ? msg : \"\");\n\tfflush(out);\n}\n\nModel::Model(const Env &env)\n{\n\tinit(env);\n\n\t// The default behavior expected by POI differ a bit from Xpress default behavior. Here we\n\t// adjust some controls:\n\n\t// Verbose by default, the user can silence if needed\n\tset_raw_control_int_by_id(POI_XPRS_OUTPUTLOG, 1);\n\n\t// Register a message callback (can be overridden)\n\t_check(XPRSaddcbmessage(m_model.get(), &default_print, nullptr, 0));\n\tis_default_message_cb_set = true;\n\n\t// We do not support concurrent CBs invocation since each callback have to acquire Python GIL\n\t_check(XPRSsetintcontrol64(m_model.get(), POI_XPRS_MUTEXCALLBACKS, 1));\n\n\t// Use global solver if the model contains non linear formulas\n\tset_raw_control_int_by_id(POI_XPRS_NLPSOLVER, POI_XPRS_NLPSOLVER_GLOBAL);\n}\n\nvoid Model::init(const Env &env)\n{\n\tif (!xpress::is_library_loaded())\n\t{\n\t\tthrow std::runtime_error(\"Xpress library is not loaded\");\n\t}\n\tif (auto lg = std::lock_guard(Env::mtx); Env::init_count <= 0)\n\t{\n\t\tthrow std::runtime_error(\"Xpress environment is not initialized\");\n\t}\n\tXPRSprob prob = nullptr;\n\t_check(XPRScreateprob(&prob));\n\tm_model.reset(prob);\n\t_clear_caches();\n}\n\nXPRSprob Model::_toggle_model_mode(XPRSprob model)\n{\n\tif (m_mode == XPRESS_MODEL_MODE::MAIN)\n\t{\n\t\tm_mode = XPRESS_MODEL_MODE::CALLBACK_;\n\t}\n\telse\n\t{\n\t\tm_mode = XPRESS_MODEL_MODE::MAIN;\n\t}\n\tXPRSprob old = m_model.release();\n\tm_model.reset(model);\n\treturn old;\n}\n\nModel::~Model()\ntry\n{\n\tclose();\n}\ncatch (std::exception e)\n{\n\tfmt::print(stderr, \"{}\\n\", e.what());\n\tfflush(stderr);\n}\n\nvoid Model::close()\n{\n\t// In CALLBACK mode we cannot destroy the problem, we release the unique_ptr instead\n\tif (m_mode == XPRESS_MODEL_MODE::CALLBACK_)\n\t{\n\t\t[[maybe_unused]] auto _ = m_model.release();\n\t}\n\telse\n\t{\n\t\tm_model.reset();\n\t}\n}\n\nvoid Model::_clear_caches()\n{\n\tm_primal_ray.clear();\n\tm_dual_ray.clear();\n\tm_iis_cols.clear();\n\tm_iss_rows.clear();\n\tm_iis_bound_types.clear();\n}\n\ndouble Model::get_infinity()\n{\n\treturn POI_XPRS_PLUSINFINITY;\n}\n\nvoid Model::write(const std::string &filename)\n{\n\t// Detect if the file should be compressed by looking at the last file\n\t// extension. We exploit short-circuiting and fold expressions to avoid long\n\t// else if branches.\n\tauto find_compress_ext_len = [&](auto &...extensions) {\n\t\tsize_t ext_len = 0;\n\t\t((filename.ends_with(extensions) && (ext_len = sizeof extensions - 1)) || ...);\n\t\treturn ext_len;\n\t};\n\tsize_t compress_ext_len = find_compress_ext_len(\".gz\", \".zip\", \".tar\", \".tgz\", \".bz2\", \".bzip\",\n\t \".7z\", \".xz\", \".lz4\", \".Z\");\n\tstd::string_view fname = filename;\n\tfname.remove_suffix(compress_ext_len);\n\n\t// Based on the second last extension, we deduce what the user wants.\n\tif (fname.ends_with(\".mps\"))\n\t{\n\t\t_check(XPRSwriteprob(m_model.get(), filename.c_str(), \"v\"));\n\t}\n\telse if (fname.ends_with(\".lp\"))\n\t{\n\t\t_check(XPRSwriteprob(m_model.get(), filename.c_str(), \"lv\"));\n\t}\n\telse if (fname.ends_with(\".bss\"))\n\t{\n\t\t_check(XPRSwritebasis(m_model.get(), filename.c_str(), \"v\"));\n\t}\n\telse if (fname.ends_with(\".hdr\") || fname.ends_with(\".asc\"))\n\t{\n\t\t_check(XPRSwritesol(m_model.get(), filename.c_str(), \"v\"));\n\t}\n\telse if (fname.ends_with(\".sol\"))\n\t{\n\t\t_check(XPRSwritebinsol(m_model.get(), filename.c_str(), \"v\"));\n\t}\n\telse if (fname.ends_with(\".prt\"))\n\t{\n\t\t_check(XPRSwriteprtsol(m_model.get(), filename.c_str(), \"v\"));\n\t}\n\telse if (fname.ends_with(\".slx\"))\n\t{\n\t\t_check(XPRSwriteslxsol(m_model.get(), filename.c_str(), \"v\"));\n\t}\n\telse if (fname.ends_with(\".svf\"))\n\t{\n\t\t_check(XPRSsaveas(m_model.get(), filename.c_str()));\n\t}\n\telse\n\t{\n\t\tthrow std::runtime_error(\"Unknow file extension\");\n\t}\n}\n\nstd::string Model::get_problem_name()\n{\n\tint size = get_raw_attribute_int_by_id(POI_XPRS_MAXPROBNAMELENGTH) + 1;\n\tstd::string probname;\n\tprobname.resize(size);\n\t_check(XPRSgetprobname(m_model.get(), probname.data()));\n\t// Align string size with string length\n\tprobname.resize(strlen(probname.c_str()));\n\treturn probname;\n}\n\nvoid Model::set_problem_name(const std::string &probname)\n{\n\t_check(XPRSsetprobname(m_model.get(), probname.c_str()));\n}\n\nVariableIndex Model::add_variable(VariableDomain domain, double lb, double ub, const char *name)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tIndexT index = m_variable_index.add_index();\n\tVariableIndex variable(index);\n\n\tdouble zero[] = {0.0};\n\tint colidx = get_raw_attribute_int_by_id(POI_XPRS_COLS);\n\t_check(XPRSaddcols64(m_model.get(), 1, 0, zero, nullptr, nullptr, nullptr, &lb, &ub));\n\t_set_entity_name(POI_XPRS_NAMES_COLUMN, colidx, name);\n\tchar vtype = poi_to_xprs_var_type(domain);\n\tif (domain != VariableDomain::Continuous)\n\t{\n\t\tchar vtype = poi_to_xprs_var_type(domain);\n\t\tint icol = colidx;\n\t\t_check(XPRSchgcoltype(m_model.get(), 1, &icol, &vtype));\n\t}\n\treturn variable;\n}\n\nvoid Model::delete_variable(VariableIndex variable)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tif (!is_variable_active(variable))\n\t{\n\t\tthrow std::runtime_error(\"Variable does not exist\");\n\t}\n\tint colidx = _variable_index(variable);\n\t_check(XPRSdelcols(m_model.get(), 1, &colidx));\n\tm_variable_index.delete_index(variable.index);\n}\n\nvoid Model::delete_variables(const Vector &variables)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tint n_variables = variables.size();\n\tif (n_variables == 0)\n\t\treturn;\n\n\tstd::vector columns;\n\tcolumns.reserve(n_variables);\n\tfor (int i = {}; i < n_variables; i++)\n\t{\n\t\tif (!is_variable_active(variables[i]))\n\t\t{\n\t\t\tcontinue;\n\t\t}\n\t\tauto column = _variable_index(variables[i]);\n\t\tcolumns.push_back(column);\n\t}\n\t_check(XPRSdelcols(m_model.get(), columns.size(), columns.data()));\n\n\tfor (int i = {}; i < n_variables; i++)\n\t{\n\t\tm_variable_index.delete_index(variables[i].index);\n\t}\n}\n\nbool Model::is_variable_active(VariableIndex variable)\n{\n\treturn m_variable_index.has_index(variable.index);\n}\n\nstd::string Model::pprint_variable(VariableIndex variable)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\treturn get_variable_name(variable);\n}\n\nstd::string Model::_get_entity_name(int etype, int eidx)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tint req_size = {};\n\t_check(XPRSgetnamelist(m_model.get(), etype, nullptr, 0, &req_size, eidx, eidx));\n\tstd::string value = {};\n\tvalue.resize(req_size);\n\t_check(XPRSgetnamelist(m_model.get(), etype, value.data(), req_size, &req_size, eidx, eidx));\n\twhile (value.back() == '\\0')\n\t{\n\t\tvalue.pop_back();\n\t}\n\treturn value;\n}\n\nstd::string Model::get_variable_name(VariableIndex variable)\n{\n\tint colidx = _checked_variable_index(variable);\n\treturn _get_entity_name(POI_XPRS_NAMES_COLUMN, colidx);\n}\n\nstd::string Model::get_constraint_name(ConstraintIndex constraint)\n{\n\tint rowidx = _checked_constraint_index(constraint);\n\treturn _get_entity_name(POI_XPRS_NAMES_ROW, rowidx);\n}\n\nvoid Model::set_variable_bounds(VariableIndex variable, double lb, double ub)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tint column = _checked_variable_index(variable);\n\tint columns[] = {column, column};\n\tchar btypes[] = \"LU\";\n\tdouble bounds[] = {lb, ub};\n\t_check(XPRSchgbounds(m_model.get(), 2, columns, btypes, bounds));\n}\n\nvoid Model::set_variable_lowerbound(VariableIndex variable, double lb)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tint colidx = _checked_variable_index(variable);\n\t_check(XPRSchgbounds(m_model.get(), 1, &colidx, \"L\", &lb));\n}\n\nvoid Model::set_variable_upperbound(VariableIndex variable, double ub)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tint colidx = _checked_variable_index(variable);\n\t_check(XPRSchgbounds(m_model.get(), 1, &colidx, \"U\", &ub));\n}\n\nvoid Model::set_variable_type(VariableIndex variable, VariableDomain vdomain)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tint colidx = _checked_variable_index(variable);\n\tchar vtype = poi_to_xprs_var_type(vdomain);\n\t_check(XPRSchgcoltype(m_model.get(), 1, &colidx, &vtype));\n}\n\nvoid Model::_set_entity_name(int etype, int index, const char *name)\n{\n\tif (name == nullptr || name[0] == '\\0')\n\t{\n\t\treturn;\n\t}\n\t_check(XPRSaddnames(m_model.get(), etype, name, index, index));\n}\n\nvoid Model::add_mip_start(const std::vector &variables,\n const std::vector &values)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\tif (variables.size() != values.size())\n\t{\n\t\tthrow std::runtime_error(\"Number of variables and values do not match\");\n\t}\n\tint numnz = variables.size();\n\tif (numnz == 0)\n\t{\n\t\treturn;\n\t}\n\n\tstd::vector ind_v(numnz);\n\tfor (int i = {}; i < numnz; i++)\n\t{\n\t\tind_v[i] = _checked_variable_index(variables[i].index);\n\t}\n\t_check(XPRSaddmipsol(m_model.get(), numnz, values.data(), ind_v.data(), nullptr));\n}\n\nvoid Model::set_variable_name(VariableIndex variable, const char *name)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tint column = _checked_variable_index(variable);\n\t_set_entity_name(POI_XPRS_NAMES_COLUMN, column, name);\n}\n\nvoid Model::set_constraint_name(ConstraintIndex constraint, const char *name)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tint row = _checked_constraint_index(constraint);\n\t_set_entity_name(POI_XPRS_NAMES_ROW, row, name);\n}\n\nConstraintIndex Model::add_linear_constraint(const ScalarAffineFunction &function,\n const std::tuple &interval,\n const char *name)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tauto [lb, ub] = interval;\n\tdouble constant = static_cast(function.constant.value_or(CoeffT{}));\n\tlb = std::clamp(lb - constant, POI_XPRS_MINUSINFINITY, POI_XPRS_PLUSINFINITY);\n\tub = std::clamp(ub - constant, POI_XPRS_MINUSINFINITY, POI_XPRS_PLUSINFINITY);\n\tif (lb > ub - 1e-10)\n\t{\n\t\tthrow std::runtime_error(\"LB > UB in the provieded interval.\");\n\t}\n\n\t// Handle infinity bounds\n\tbool lb_inf = lb <= POI_XPRS_MINUSINFINITY;\n\tbool ub_inf = ub >= POI_XPRS_PLUSINFINITY;\n\n\t// Determine constraint type and parameters\n\tchar g_sense = {};\n\tdouble g_rhs = {};\n\tdouble range_val = {};\n\tconst double *g_range = {};\n\n\tif (lb_inf && ub_inf)\n\t{\n\t\tg_sense = 'N'; // Free row\n\t\tg_rhs = 0.0;\n\t}\n\telse if (lb_inf)\n\t{\n\t\tg_sense = 'L';\n\t\tg_rhs = ub;\n\t}\n\telse if (ub_inf)\n\t{\n\t\tg_sense = 'G';\n\t\tg_rhs = lb;\n\t}\n\telse if (std::abs(ub - lb) < 1e-10)\n\t{\n\t\tg_sense = 'E';\n\t\tg_rhs = ub;\n\t}\n\telse\n\t{\n\t\tg_sense = 'R';\n\t\tg_rhs = ub;\n\t\trange_val = ub - lb;\n\t\tg_range = &range_val;\n\t}\n\n\tIndexT index = m_constraint_index.add_index();\n\tConstraintIndex constraint_index(ConstraintType::Linear, index);\n\tint rowidx = get_raw_attribute_int_by_id(POI_XPRS_ROWS);\n\n\tAffineFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\tint numnz = ptr_form.numnz;\n\tXPRSint64 beg[] = {0};\n\tconst int *cind = ptr_form.index;\n\tconst double *cval = ptr_form.value;\n\n\t_check(XPRSaddrows64(m_model.get(), 1, numnz, &g_sense, &g_rhs, g_range, beg, cind, cval));\n\t_set_entity_name(POI_XPRS_NAMES_ROW, rowidx, name);\n\n\treturn constraint_index;\n}\n\nConstraintIndex Model::add_linear_constraint(const ScalarAffineFunction &function,\n ConstraintSense sense, CoeffT rhs, const char *name)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tIndexT index = m_constraint_index.add_index();\n\tConstraintIndex constraint_index(ConstraintType::Linear, index);\n\tint rowidx = get_raw_attribute_int_by_id(POI_XPRS_ROWS);\n\n\tAffineFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\tint numnz = ptr_form.numnz;\n\n\tdouble g_rhs = static_cast(rhs - function.constant.value_or(CoeffT{}));\n\tg_rhs = std::clamp(g_rhs, POI_XPRS_MINUSINFINITY, POI_XPRS_PLUSINFINITY);\n\n\t// Map expr >= -inf and expr <= +inf to free rows\n\tchar g_sense = poi_to_xprs_cons_sense(sense);\n\tif ((g_sense == 'G' && g_rhs <= POI_XPRS_MINUSINFINITY) ||\n\t (g_sense == 'L' && g_rhs >= POI_XPRS_PLUSINFINITY))\n\t{\n\t\tg_sense = 'N'; // Free row\n\t\tg_rhs = 0.0;\n\t}\n\n\tXPRSint64 beg[] = {0};\n\tconst int *cind = ptr_form.index;\n\tconst double *cval = ptr_form.value;\n\t_check(XPRSaddrows64(m_model.get(), 1, numnz, &g_sense, &g_rhs, nullptr, beg, cind, cval));\n\t_set_entity_name(POI_XPRS_NAMES_ROW, rowidx, name);\n\n\treturn constraint_index;\n}\n\nstatic QuadraticFunctionPtrForm poi_to_xprs_quad_formula(\n Model &model, const ScalarQuadraticFunction &function, bool is_objective)\n{\n\tQuadraticFunctionPtrForm ptr_form;\n\tptr_form.make(&model, function);\n\tint numqnz = ptr_form.numnz;\n\n\t// Xpress uses different quadratic representations for objectives vs constraints:\n\t//\n\t// OBJECTIVES: Use 0.5*x'Qx form with automatic symmetry.\n\t// - Diagonal terms (i,i): Need 2× multiplication to compensate for the 0.5 factor\n\t// - Off-diagonal terms (i,j): Used as-is; Xpress automatically mirrors to (j,i)\n\t//\n\t// CONSTRAINTS: Use x'Qx form with upper-triangular specification.\n\t// - Diagonal terms (i,i): Used as-is\n\t// - Off-diagonal terms (i,j): Need 0.5× division; Xpress expects coefficients\n\t// for the upper triangular part only, which will be mirrored\n\t//\n\t// PyOptInterface provides coefficients in the standard x'Qx form through\n\t// QuadraticFunctionPtrForm, so we adjust based on whether this is for an objective function or\n\t// a constraint.\n\n\t// Copy coefficients (ptr_form.value may reference function.coefficients directly)\n\tif (ptr_form.value_storage.empty())\n\t{\n\t\tptr_form.value_storage.reserve(numqnz);\n\t\tfor (CoeffT c : function.coefficients)\n\t\t{\n\t\t\tptr_form.value_storage.push_back(static_cast(c));\n\t\t}\n\t}\n\n\t// Apply Xpress-specific coefficient adjustments\n\tfor (int i = 0; i < numqnz; ++i)\n\t{\n\t\tif (is_objective && (ptr_form.row[i] == ptr_form.col[i]))\n\t\t{\n\t\t\t// Objective diagonal terms: multiply by 2 for 0.5*x'Qx convention\n\t\t\tptr_form.value_storage[i] *= 2.0;\n\t\t}\n\t\tif (!is_objective && (ptr_form.row[i] != ptr_form.col[i]))\n\t\t{\n\t\t\t// Constraint off-diagonal terms: divide by 2 for upper-triangular specification\n\t\t\tptr_form.value_storage[i] /= 2.0;\n\t\t}\n\t}\n\n\tptr_form.value = ptr_form.value_storage.data();\n\treturn ptr_form;\n}\n\n// Quadratic constraints are regular rows with a quadratic term.\nConstraintIndex Model::add_quadratic_constraint(const ScalarQuadraticFunction &function,\n ConstraintSense sense, CoeffT rhs, const char *name)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tint rowidx = get_raw_attribute_int_by_id(POI_XPRS_ROWS);\n\n\tconst auto &affine_part = function.affine_part.value_or(ScalarAffineFunction{});\n\tConstraintIndex constraint_index = add_linear_constraint(affine_part, sense, rhs, name);\n\tconstraint_index.type = ConstraintType::Quadratic; // Fix constraint type\n\n\t// Add quadratic term\n\tQuadraticFunctionPtrForm ptr_form =\n\t poi_to_xprs_quad_formula(*this, function, false);\n\tint numqnz = ptr_form.numnz;\n\tconst int *qrow = ptr_form.row;\n\tconst int *qcol = ptr_form.col;\n\tconst double *qval = ptr_form.value;\n\n\t_check(XPRSaddqmatrix64(m_model.get(), rowidx, numqnz, qrow, qcol, qval));\n\t++m_quad_nl_constr_num;\n\treturn constraint_index;\n}\n\nConstraintIndex Model::add_second_order_cone_constraint(const Vector &variables,\n const char *name, bool rotated)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tint rot_offset = rotated ? 1 : 0;\n\tif (variables.size() <= rot_offset)\n\t{\n\t\tthrow std::runtime_error(\"Not enough variables in SOC constraint.\");\n\t}\n\n\t// SOC: 1 x_0 x_0 >= \\sum_{i : [1,N)} x_i^2\n\t// Rotated SOC: 2 x_0 x_1 >= \\sum_{i : [2,N)} x_i^2\n\tScalarQuadraticFunction quadconstr;\n\tquadconstr.add_quadratic_term(variables[0], variables[rot_offset], 1.0 + rot_offset);\n\tfor (int i = 1 + rot_offset; i < variables.size(); ++i)\n\t{\n\t\tquadconstr.add_quadratic_term(variables[i], variables[i], -1.0);\n\t}\n\tConstraintIndex constraint_index =\n\t add_quadratic_constraint(quadconstr, ConstraintSense::GreaterEqual, 0.0, name);\n\tconstraint_index.type = ConstraintType::SecondOrderCone;\n\treturn constraint_index;\n}\n\nnamespace\n{\ntemplate \nstruct NlpArrays\n{\n\tint types[N];\n\tdouble values[N];\n};\n} // namespace\n\nConstraintIndex Model::add_exp_cone_constraint(const Vector &variables,\n const char *name, bool dual)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tif (variables.size() != 3)\n\t{\n\t\tthrow std::runtime_error(\"Exponential cone constraint must have 3 variables\");\n\t}\n\n\t// Add affine part\n\tauto constraint_index =\n\t add_linear_constraint_from_var(variables[0], ConstraintSense::GreaterEqual, 0.0);\n\tconstraint_index.type = ConstraintType::ExponentialCone; // Fix constraint type\n\n\tint nnz = 0;\n\tconst int *types = {};\n\tconst double *values = {};\n\tdouble var1_idx = static_cast(_checked_variable_index(variables[1]));\n\tdouble var2_idx = static_cast(_checked_variable_index(variables[2]));\n\n\tint rowidx = _constraint_index(constraint_index);\n\n\t// Syntactic sugar to make hand written NLP formulas more readable\n\tauto make_type_value_arrays = [](auto... terms) {\n\t\treturn NlpArrays{{terms.type...}, {terms.value...}};\n\t};\n\tif (dual)\n\t{\n\t\t// linear_term + x_2 * exp(x_1 / x_2 - 1) >= 0\n\t\tauto [types, values] = make_type_value_arrays( //\n\t\t Tvp{POI_XPRS_TOK_COL, var2_idx}, // x_2\n\t\t Tvp{POI_XPRS_TOK_RB, {}}, // )\n\t\t Tvp{POI_XPRS_TOK_COL, var1_idx}, // x_1\n\t\t Tvp{POI_XPRS_TOK_COL, var2_idx}, // x_2\n\t\t Tvp{POI_XPRS_TOK_OP, POI_XPRS_OP_DIVIDE}, // /\n\t\t Tvp{POI_XPRS_TOK_CON, 1.0}, // 1.0\n\t\t Tvp{POI_XPRS_TOK_OP, POI_XPRS_OP_MINUS}, // -\n\t\t Tvp{POI_XPRS_TOK_IFUN, POI_XPRS_IFUN_EXP}, // exp(\n\t\t Tvp{POI_XPRS_TOK_OP, POI_XPRS_OP_MULTIPLY}, // *\n\t\t Tvp{POI_XPRS_TOK_EOF, {}}); // EOF\n\n\t\tint begs[] = {0, static_cast(std::ssize(types))};\n\t\t_check(XPRSnlpaddformulas(m_model.get(), 1, &rowidx, begs, 1, types, values));\n\t}\n\telse\n\t{\n\t\t// linear_term - x_1 * exp(x_2 / x_1) >= 0\n\t\tauto [types, values] = make_type_value_arrays( //\n\t\t Tvp{POI_XPRS_TOK_COL, var1_idx}, // x_1\n\t\t Tvp{POI_XPRS_TOK_RB, {}}, // )\n\t\t Tvp{POI_XPRS_TOK_COL, var2_idx}, // x_2\n\t\t Tvp{POI_XPRS_TOK_COL, var1_idx}, // x_1\n\t\t Tvp{POI_XPRS_TOK_OP, POI_XPRS_OP_DIVIDE}, // /\n\t\t Tvp{POI_XPRS_TOK_IFUN, POI_XPRS_IFUN_EXP}, // exp(\n\t\t Tvp{POI_XPRS_TOK_OP, POI_XPRS_OP_MULTIPLY}, // *\n\t\t Tvp{POI_XPRS_TOK_OP, POI_XPRS_OP_UMINUS}, // -\n\t\t Tvp{POI_XPRS_TOK_EOF, {}}); // EOF\n\n\t\tint begs[] = {0, static_cast(std::ssize(types))};\n\t\t_check(XPRSnlpaddformulas(m_model.get(), 1, &rowidx, begs, 1, types, values));\n\t}\n\n\t++m_quad_nl_constr_num;\n\treturn constraint_index;\n}\n\nConstraintIndex Model::_add_sos_constraint(const Vector &variables, SOSType sos_type,\n const Vector &weights)\n{\n\tIndexT index = m_sos_constraint_index.add_index();\n\tConstraintIndex constraint_index(ConstraintType::SOS, index);\n\n\tconst int nnz = variables.size();\n\tconst char type[] = {poi_to_xprs_sos_type(sos_type)};\n\tconst XPRSint64 beg[] = {0};\n\tstd::vector ind_v(nnz);\n\tfor (int i = 0; i < nnz; i++)\n\t{\n\t\tind_v[i] = _checked_variable_index(variables[i]);\n\t}\n\t_check(XPRSaddsets64(m_model.get(), 1, nnz, type, beg, ind_v.data(), weights.data()));\n\treturn constraint_index;\n}\n\nConstraintIndex Model::add_sos_constraint(const Vector &variables, SOSType sos_type)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tVector weights(variables.size());\n\tstd::iota(weights.begin(), weights.end(), 1.0);\n\treturn _add_sos_constraint(variables, sos_type, weights);\n}\n\nConstraintIndex Model::add_sos_constraint(const Vector &variables, SOSType sos_type,\n const Vector &weights)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\t// If CoeffT will ever be not a double, we need to convert weights\n\tif constexpr (std::is_same_v)\n\t{\n\t\tstd::vector double_weights;\n\t\tdouble_weights.reserve(weights.size());\n\t\tfor (CoeffT w : weights)\n\t\t{\n\t\t\tdouble_weights.push_back(static_cast(w));\n\t\t}\n\t\treturn _add_sos_constraint(variables, sos_type, double_weights);\n\t}\n\telse\n\t{\n\t\treturn _add_sos_constraint(variables, sos_type, weights);\n\t}\n}\n\nTvp to_xprs_opcode(UnaryOperator opcode_enum)\n{\n\tswitch (opcode_enum)\n\t{\n\tcase UnaryOperator::Neg:\n\t\treturn {POI_XPRS_TOK_OP, POI_XPRS_OP_UMINUS};\n\tcase UnaryOperator::Sin:\n\t\treturn {POI_XPRS_TOK_IFUN, POI_XPRS_IFUN_SIN};\n\tcase UnaryOperator::Cos:\n\t\treturn {POI_XPRS_TOK_IFUN, POI_XPRS_IFUN_COS};\n\tcase UnaryOperator::Tan:\n\t\treturn {POI_XPRS_TOK_IFUN, POI_XPRS_IFUN_TAN};\n\tcase UnaryOperator::Asin:\n\t\treturn {POI_XPRS_TOK_IFUN, POI_XPRS_IFUN_ARCSIN};\n\tcase UnaryOperator::Acos:\n\t\treturn {POI_XPRS_TOK_IFUN, POI_XPRS_IFUN_ARCCOS};\n\tcase UnaryOperator::Atan:\n\t\treturn {POI_XPRS_TOK_IFUN, POI_XPRS_IFUN_ARCTAN};\n\tcase UnaryOperator::Abs:\n\t\treturn {POI_XPRS_TOK_IFUN, POI_XPRS_IFUN_ABS};\n\tcase UnaryOperator::Sqrt:\n\t\treturn {POI_XPRS_TOK_IFUN, POI_XPRS_IFUN_SQRT};\n\tcase UnaryOperator::Exp:\n\t\treturn {POI_XPRS_TOK_IFUN, POI_XPRS_IFUN_EXP};\n\tcase UnaryOperator::Log:\n\t\treturn {POI_XPRS_TOK_IFUN, POI_XPRS_IFUN_LN};\n\tcase UnaryOperator::Log10:\n\t\treturn {POI_XPRS_TOK_IFUN, POI_XPRS_IFUN_LOG10};\n\tdefault: {\n\t\tauto opname = unary_operator_to_string(opcode_enum);\n\t\tauto msg = fmt::format(\"Unknown unary operator for Xpress: {}\", opname);\n\t\tthrow std::runtime_error(msg);\n\t}\n\t}\n}\n\nTvp to_xprs_opcode(BinaryOperator opcode_enum)\n{\n\tswitch (opcode_enum)\n\t{\n\tcase BinaryOperator::Sub:\n\t\treturn {POI_XPRS_TOK_OP, POI_XPRS_OP_MINUS};\n\tcase BinaryOperator::Div:\n\t\treturn {POI_XPRS_TOK_OP, POI_XPRS_OP_DIVIDE};\n\tcase BinaryOperator::Pow:\n\t\treturn {POI_XPRS_TOK_OP, POI_XPRS_OP_EXPONENT};\n\tcase BinaryOperator::Add2:\n\t\treturn {POI_XPRS_TOK_OP, POI_XPRS_OP_PLUS};\n\tcase BinaryOperator::Mul2:\n\t\treturn {POI_XPRS_TOK_OP, POI_XPRS_OP_MULTIPLY};\n\tdefault:\n\t\tauto opname = binary_operator_to_string(opcode_enum);\n\t\tauto msg = fmt::format(\"Unknown unary operator for Xpress: {}\", opname);\n\t\tthrow std::runtime_error(msg);\n\t}\n}\n\nTvp to_xprs_opcode(TernaryOperator opcode_enum)\n{\n\tauto opname = ternary_operator_to_string(opcode_enum);\n\tauto msg = fmt::format(\"Unknown unary operator for Xpress: {}\", opname);\n\tthrow std::runtime_error(msg);\n}\n\nTvp to_xprs_opcode(NaryOperator opcode_enum)\n{\n\tswitch (opcode_enum)\n\t{\n\tcase NaryOperator::Add:\n\t\treturn {POI_XPRS_TOK_OP, POI_XPRS_OP_PLUS};\n\tcase NaryOperator::Mul:\n\t\treturn {POI_XPRS_TOK_OP, POI_XPRS_OP_MULTIPLY};\n\tdefault:\n\t\tauto opname = nary_operator_to_string(opcode_enum);\n\t\tauto msg = fmt::format(\"Unknown nary operator for Xpress: {}\", opname);\n\t\tthrow std::runtime_error(msg);\n\t}\n}\n\nBinaryOperator nary_to_binary_op(NaryOperator opcode_enum)\n{\n\tswitch (opcode_enum)\n\t{\n\tcase NaryOperator::Add:\n\t\treturn BinaryOperator::Add2;\n\tcase NaryOperator::Mul:\n\t\treturn BinaryOperator::Mul2;\n\tdefault: {\n\t\tauto opname = nary_operator_to_string(opcode_enum);\n\t\tauto msg = fmt::format(\"Unknown nary operator for Xpress: {}\", opname);\n\t\tthrow std::runtime_error(msg);\n\t}\n\t}\n}\n\nTvp Model::_decode_expr(const ExpressionGraph &graph, const ExpressionHandle &expr)\n{\n\tauto array_type = expr.array;\n\tauto index = expr.id;\n\n\tswitch (array_type)\n\t{\n\tcase ArrayType::Constant:\n\t\treturn {POI_XPRS_TOK_CON, static_cast(graph.m_constants[index])};\n\tcase ArrayType::Variable:\n\t\treturn {POI_XPRS_TOK_COL,\n\t\t static_cast(_checked_variable_index(graph.m_variables[index]))};\n\tcase ArrayType::Parameter:\n\t\tbreak;\n\tcase ArrayType::Unary:\n\t\treturn to_xprs_opcode(graph.m_unaries[index].op);\n\tcase ArrayType::Binary:\n\t\treturn to_xprs_opcode(graph.m_binaries[index].op);\n\tcase ArrayType::Ternary:\n\t\treturn to_xprs_opcode(graph.m_ternaries[index].op);\n\tcase ArrayType::Nary:\n\t\treturn to_xprs_opcode(graph.m_naries[index].op);\n\tdefaut:\n\t\tbreak;\n\t}\n\tthrow std::runtime_error(\"Not supported expression.\");\n}\n\nExpressionHandle nary_to_binary(ExpressionGraph &graph, const ExpressionHandle &expr)\n{\n\tauto &nary = graph.m_naries[expr.id];\n\tNaryOperator n_op = nary.op;\n\tBinaryOperator bin_opcode = nary_to_binary_op(n_op);\n\tint n_operands = nary.operands.size();\n\tif (n_operands == 0 || (n_op != NaryOperator::Add && n_op != NaryOperator::Mul))\n\t{\n\t\treturn expr;\n\t}\n\n\tauto new_expr = nary.operands[0];\n\tfor (int i = 1; i < n_operands; ++i)\n\t{\n\t\tnew_expr = graph.add_binary(bin_opcode, new_expr, nary.operands[i]);\n\t}\n\treturn new_expr;\n}\n\nstd::pair, std::vector> Model::_decode_graph_postfix_order(\n ExpressionGraph &graph, const ExpressionHandle &result)\n{\n\tstd::vector types;\n\tstd::vector values;\n\n\t// Xpress uses a reversed Polish notation (post fix). So we need to visit the expression tree\n\t// in post-order depth first. We keep a stack to go depth first and visit each element\n\t// twice. First time process its children, second time decode it.\n\tstd::stack> expr_stack;\n\texpr_stack.emplace(result, true);\n\n\twhile (!expr_stack.empty())\n\t{\n\t\tauto &[expr, visit_children] = expr_stack.top();\n\t\tauto [type, value] = _decode_expr(graph, expr);\n\n\t\t// If its children have already been processed and we can add it to the expression\n\t\tif (!visit_children)\n\t\t{\n\t\t\ttypes.push_back(type);\n\t\t\tvalues.push_back(value);\n\t\t\texpr_stack.pop();\n\t\t\tcontinue;\n\t\t}\n\n\t\t// Xpress requires a parenthesis to start an internal or user function\n\t\tif (type == POI_XPRS_TOK_IFUN || type == POI_XPRS_TOK_FUN)\n\t\t{\n\t\t\ttypes.push_back(POI_XPRS_TOK_RB);\n\t\t\tvalues.push_back({});\n\t\t}\n\n\t\tswitch (expr.array)\n\t\t{\n\t\tcase ArrayType::Constant:\n\t\tcase ArrayType::Variable:\n\t\t\tbreak;\n\t\tcase ArrayType::Unary:\n\t\t\texpr_stack.emplace(graph.m_unaries[expr.id].operand, true);\n\t\t\tbreak;\n\t\tcase ArrayType::Nary:\n\t\t\t// Xpress does not have nary operators out of the box, we have to translate them into a\n\t\t\t// sequence of binary operators\n\t\t\texpr = nary_to_binary(graph, expr);\n\t\t\t[[fallthrough]];\n\t\tcase ArrayType::Binary:\n\t\t\texpr_stack.emplace(graph.m_binaries[expr.id].right, true);\n\t\t\texpr_stack.emplace(graph.m_binaries[expr.id].left, true);\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow std::runtime_error(\"Unrecognized token.\");\n\t\t}\n\n\t\t// Children has been processed and added to the stack, next time we'll add it to the\n\t\t// expression.\n\t\tvisit_children = false;\n\t}\n\n\ttypes.push_back(POI_XPRS_TOK_EOF);\n\tvalues.push_back({});\n\treturn {std::move(types), std::move(values)};\n}\n\nConstraintIndex Model::add_single_nl_constraint(ExpressionGraph &graph,\n const ExpressionHandle &result,\n const std::tuple &interval,\n const char *name)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tint rowidx = get_raw_attribute_int_by_id(POI_XPRS_ROWS);\n\tConstraintIndex constraint = add_linear_constraint(ScalarAffineFunction{}, interval, name);\n\tconstraint.type = ConstraintType::NL;\n\n\tauto [types, values] = _decode_graph_postfix_order(graph, result);\n\n\tint nnz = values.size();\n\tint begs[] = {0, nnz};\n\t_check(XPRSnlpaddformulas(m_model.get(), 1, &rowidx, begs, 1, types.data(), values.data()));\n\t++m_quad_nl_constr_num;\n\treturn constraint;\n}\n\nvoid Model::delete_constraint(ConstraintIndex constraint)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tif (!is_constraint_active(constraint))\n\t{\n\t\tthrow std::runtime_error(\"Constraint does not exist\");\n\t}\n\n\tint constraint_row = _checked_constraint_index(constraint);\n\tif (constraint_row >= 0)\n\t{\n\t\tswitch (constraint.type)\n\t\t{\n\t\tcase ConstraintType::Quadratic:\n\t\tcase ConstraintType::SecondOrderCone:\n\t\tcase ConstraintType::ExponentialCone:\n\t\tcase ConstraintType::NL:\n\t\t\t--m_quad_nl_constr_num;\n\t\t\t[[fallthrough]];\n\t\tcase ConstraintType::Linear:\n\t\t\tm_constraint_index.delete_index(constraint.index);\n\t\t\t_check(XPRSdelrows(m_model.get(), 1, &constraint_row));\n\t\t\tbreak;\n\t\tcase ConstraintType::SOS:\n\t\t\tm_sos_constraint_index.delete_index(constraint.index);\n\t\t\t_check(XPRSdelsets(m_model.get(), 1, &constraint_row));\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t\t}\n\t}\n}\n\nbool Model::is_constraint_active(ConstraintIndex constraint)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\tcase ConstraintType::Quadratic:\n\tcase ConstraintType::SecondOrderCone:\n\tcase ConstraintType::ExponentialCone:\n\tcase ConstraintType::NL:\n\t\treturn m_constraint_index.has_index(constraint.index);\n\tcase ConstraintType::SOS:\n\t\treturn m_sos_constraint_index.has_index(constraint.index);\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n\treturn false;\n}\n\nvoid Model::set_objective(const ScalarAffineFunction &function, ObjectiveSense sense)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\t// Delete linear and quadratic term of the objective function\n\t_check(XPRSdelobj(m_model.get(), 0));\n\t_check(XPRSdelqmatrix(m_model.get(), -1));\n\thas_quad_objective = false;\n\tif (has_nlp_objective)\n\t{\n\t\tdelete_constraint(m_nlp_obj_constraint);\n\t\tdelete_variable(m_nlp_obj_variable);\n\t\thas_nlp_objective = false;\n\t}\n\n\tif (function.size() > 0)\n\t{\n\t\tAffineFunctionPtrForm ptr_form;\n\t\tptr_form.make(this, function);\n\t\tint numnz = ptr_form.numnz;\n\t\tconst int *cind = ptr_form.index;\n\t\tconst double *cval = ptr_form.value;\n\t\t_check(XPRSchgobj(m_model.get(), numnz, cind, cval));\n\t}\n\tif (function.constant.has_value())\n\t{\n\t\tint obj_constant_magic_index = -1;\n\t\tdouble obj_constant = -static_cast(function.constant.value());\n\t\t_check(XPRSchgobj(m_model.get(), 1, &obj_constant_magic_index, &obj_constant));\n\t}\n\tint stype = poi_to_xprs_obj_sense(sense);\n\t_check(XPRSchgobjsense(m_model.get(), stype));\n}\n\n// Set quadratic objective function, replacing any previous objective.\n// Handles Xpress's symmetric matrix convention where off-diagonal terms are doubled.\nvoid Model::set_objective(const ScalarQuadraticFunction &function, ObjectiveSense sense)\n{\n\t// Set affine part (also clears any previous quadratic terms)\n\tconst auto &affine_part = function.affine_part.value_or(ScalarAffineFunction{});\n\tset_objective(affine_part, sense);\n\n\t// Add quadratic terms if present\n\tif (function.size() > 0)\n\t{\n\t\tQuadraticFunctionPtrForm ptr_form =\n\t\t poi_to_xprs_quad_formula(*this, function, true);\n\t\tint numqnz = ptr_form.numnz;\n\t\tconst int *qrow = ptr_form.row;\n\t\tconst int *qcol = ptr_form.col;\n\t\tconst double *qval = ptr_form.value;\n\t\t_check(XPRSchgmqobj64(m_model.get(), numqnz, qrow, qcol, qval));\n\t\thas_quad_objective = true;\n\t}\n}\n\nvoid Model::set_objective(const ExprBuilder &function, ObjectiveSense sense)\n{\n\tauto deg = function.degree();\n\tif (deg <= 1)\n\t{\n\t\tScalarAffineFunction f(function);\n\t\tset_objective(f, sense);\n\t}\n\telse if (deg == 2)\n\t{\n\t\tScalarQuadraticFunction f(function);\n\t\tset_objective(f, sense);\n\t}\n\telse\n\t{\n\t\tthrow std::runtime_error(\"Objective must be linear or quadratic\");\n\t}\n}\n\nvoid Model::add_single_nl_objective(ExpressionGraph &graph, const ExpressionHandle &result)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tif (!has_nlp_objective)\n\t{\n\t\thas_nlp_objective = true;\n\t\tm_nlp_obj_variable = add_variable();\n\t\tm_nlp_obj_constraint = add_linear_constraint(ScalarAffineFunction(m_nlp_obj_variable, -1.0),\n\t\t ConstraintSense::Equal, 0.0, NULL);\n\t\tset_objective_coefficient(m_nlp_obj_variable, 1.0);\n\t}\n\n\tauto [types, values] = _decode_graph_postfix_order(graph, result);\n\tint nnz = values.size();\n\tint begs[] = {0, nnz};\n\tint rowidx = _constraint_index(m_nlp_obj_constraint);\n\t_check(XPRSnlpaddformulas(m_model.get(), 1, &rowidx, begs, 1, types.data(), values.data()));\n}\n\ndouble Model::get_normalized_rhs(ConstraintIndex constraint)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tdouble rhs = {};\n\tint rowidx = _checked_constraint_index(constraint);\n\t_check(XPRSgetrhs(m_model.get(), &rhs, rowidx, rowidx));\n\treturn rhs;\n}\n\nvoid Model::set_normalized_rhs(ConstraintIndex constraint, double value)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tint rowidx = _checked_constraint_index(constraint);\n\t_check(XPRSchgrhs(m_model.get(), 1, &rowidx, &value));\n}\n\ndouble Model::get_normalized_coefficient(ConstraintIndex constraint, VariableIndex variable)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tint rowidx = _checked_constraint_index(constraint);\n\tint colidx = _checked_variable_index(variable);\n\tdouble coeff = {};\n\t_check(XPRSgetcoef(m_model.get(), rowidx, colidx, &coeff));\n\treturn coeff;\n}\nvoid Model::set_normalized_coefficient(ConstraintIndex constraint, VariableIndex variable,\n double value)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tint rowidx = _checked_constraint_index(constraint);\n\tint colidx = _checked_variable_index(variable);\n\t_check(XPRSchgcoef(m_model.get(), rowidx, colidx, value));\n}\n\ndouble Model::get_objective_coefficient(VariableIndex variable)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tint colidx = _checked_variable_index(variable);\n\tdouble coeff = {};\n\t_check(XPRSgetobj(m_model.get(), &coeff, colidx, colidx));\n\treturn coeff;\n}\nvoid Model::set_objective_coefficient(VariableIndex variable, double value)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\t_clear_caches();\n\n\tint colidx = _checked_variable_index(variable);\n\t_check(XPRSchgobj(m_model.get(), 1, &colidx, &value));\n}\n\nint Model::_constraint_index(ConstraintIndex constraint)\n{\n\tswitch (constraint.type)\n\t{\n\tcase ConstraintType::Linear:\n\tcase ConstraintType::Quadratic:\n\tcase ConstraintType::SecondOrderCone:\n\tcase ConstraintType::ExponentialCone:\n\tcase ConstraintType::NL:\n\t\treturn m_constraint_index.get_index(constraint.index);\n\tcase ConstraintType::SOS:\n\t\treturn m_sos_constraint_index.get_index(constraint.index);\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown constraint type\");\n\t}\n}\n\nint Model::_variable_index(VariableIndex variable)\n{\n\treturn m_variable_index.get_index(variable.index);\n}\n\nint Model::_checked_constraint_index(ConstraintIndex constraint)\n{\n\tint rowidx = _constraint_index(constraint);\n\tif (rowidx < 0)\n\t{\n\t\tthrow std::runtime_error(\"Constraint does not exists\");\n\t}\n\treturn rowidx;\n}\n\nint Model::_checked_variable_index(VariableIndex variable)\n{\n\tint colidx = _variable_index(variable);\n\tif (colidx < 0)\n\t{\n\t\tthrow std::runtime_error(\"Variable does not exists\");\n\t}\n\treturn colidx;\n}\n\nbool Model::_is_mip()\n{\n\treturn get_raw_attribute_int_by_id(POI_XPRS_MIPENTS) > 0 ||\n\t get_raw_attribute_int_by_id(POI_XPRS_SETS) > 0;\n}\n\nvoid Model::optimize()\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_clear_caches();\n\n\tint stop_status = 0;\n\t_check(XPRSoptimize(m_model.get(), \"\", &stop_status, nullptr));\n\tm_need_postsolve = (stop_status == POI_XPRS_SOLVESTATUS_STOPPED);\n}\n\ndouble Model::get_variable_value(VariableIndex variable)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\tint colidx = _checked_variable_index(variable);\n\tint status = POI_XPRS_SOLAVAILABLE_NOTFOUND;\n\tdouble value = {};\n\t_check(XPRSgetsolution(m_model.get(), &status, &value, colidx, colidx));\n\tif (status == POI_XPRS_SOLAVAILABLE_NOTFOUND)\n\t{\n\t\tthrow std::runtime_error(\"No solution found\");\n\t}\n\treturn value;\n}\n\ndouble Model::get_variable_rc(VariableIndex variable)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\tint colidx = _checked_variable_index(variable);\n\tint status = POI_XPRS_SOLAVAILABLE_NOTFOUND;\n\tdouble value = {};\n\t_check(XPRSgetredcosts(m_model.get(), &status, &value, colidx, colidx));\n\tif (status == POI_XPRS_SOLAVAILABLE_NOTFOUND)\n\t{\n\t\tthrow std::runtime_error(\"No solution found\");\n\t}\n\treturn value;\n}\n\ndouble Model::get_variable_primal_ray(VariableIndex variable)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tif (m_primal_ray.empty())\n\t{\n\t\tint has_ray = 0;\n\t\t_check(XPRSgetprimalray(m_model.get(), nullptr, &has_ray));\n\t\tif (has_ray == 0)\n\t\t{\n\t\t\tthrow std::runtime_error(\"Primal ray not available\");\n\t\t}\n\t\tm_primal_ray.resize(get_raw_attribute_int_by_id(POI_XPRS_COLS));\n\t\t_check(XPRSgetprimalray(m_model.get(), m_primal_ray.data(), &has_ray));\n\t\tassert(has_ray != 0);\n\t}\n\n\tint colidx = _checked_variable_index(variable);\n\treturn m_primal_ray[colidx];\n}\n\nint Model::_get_basis_stat(int entity_idx, bool is_row)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tint entity_stat = {};\n\tif (is_row)\n\t{\n\t\t_check(XPRSgetbasisval(m_model.get(), entity_idx, 0, &entity_stat, nullptr));\n\t}\n\telse\n\t{\n\t\t_check(XPRSgetbasisval(m_model.get(), 0, entity_idx, nullptr, &entity_stat));\n\t}\n\treturn entity_stat;\n}\n\nbool Model::is_variable_basic(VariableIndex variable)\n{\n\treturn _get_basis_stat(_checked_variable_index(variable), false) == POI_XPRS_BASISSTATUS_BASIC;\n}\n\nbool Model::is_variable_nonbasic_lb(VariableIndex variable)\n{\n\treturn _get_basis_stat(_checked_variable_index(variable), false) ==\n\t POI_XPRS_BASISSTATUS_NONBASIC_LOWER;\n}\n\nbool Model::is_variable_nonbasic_ub(VariableIndex variable)\n{\n\treturn _get_basis_stat(_checked_variable_index(variable), false) ==\n\t POI_XPRS_BASISSTATUS_NONBASIC_UPPER;\n}\nbool Model::is_variable_superbasic(VariableIndex variable)\n{\n\treturn _get_basis_stat(_checked_variable_index(variable), false) ==\n\t POI_XPRS_BASISSTATUS_SUPERBASIC;\n}\n\ndouble Model::get_variable_lowerbound(VariableIndex variable)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tdouble lb = {};\n\tint colidx = _checked_variable_index(variable);\n\t_check(XPRSgetlb(m_model.get(), &lb, colidx, colidx));\n\treturn lb;\n}\n\ndouble Model::get_variable_upperbound(VariableIndex variable)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tdouble ub = {};\n\tint colidx = _checked_variable_index(variable);\n\t_check(XPRSgetub(m_model.get(), &ub, colidx, colidx));\n\treturn ub;\n}\n\nVariableDomain Model::get_variable_type(VariableIndex variable)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tint colidex = _checked_variable_index(variable);\n\tchar vtype = {};\n\t_check(XPRSgetcoltype(m_model.get(), &vtype, colidex, colidex));\n\treturn xprs_to_poi_var_type(vtype);\n}\n\nchar Model::_get_variable_bound_IIS(VariableIndex variable)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tif (m_iis_cols.empty() || m_iis_bound_types.empty())\n\t{\n\t\tint m_nrows = {};\n\t\tint m_ncols = {};\n\t\t_check(XPRSgetiisdata(m_model.get(), 1, &m_nrows, &m_ncols, nullptr, nullptr, nullptr,\n\t\t nullptr, nullptr, nullptr, nullptr, nullptr));\n\n\t\tm_iis_cols.resize(m_ncols);\n\t\tm_iis_bound_types.resize(m_ncols);\n\t\t_check(XPRSgetiisdata(m_model.get(), 1, &m_nrows, &m_ncols, nullptr, m_iis_cols.data(),\n\t\t nullptr, m_iis_bound_types.data(), nullptr, nullptr, nullptr,\n\t\t nullptr));\n\t}\n\n\tint colidx = _checked_variable_index(variable);\n\tfor (int j = 0; j < m_iis_cols.size(); ++j)\n\t{\n\t\tif (m_iis_cols[j] == colidx)\n\t\t{\n\t\t\treturn m_iis_bound_types[j];\n\t\t}\n\t}\n\treturn '\\0';\n}\n\nbool Model::is_variable_lowerbound_IIS(VariableIndex variable)\n{\n\treturn _get_variable_bound_IIS(variable) == 'L';\n}\n\nbool Model::is_variable_upperbound_IIS(VariableIndex variable)\n{\n\treturn _get_variable_bound_IIS(variable) == 'U';\n}\n\nvoid Model::set_constraint_sense(ConstraintIndex constraint, ConstraintSense sense)\n{\n\tconst int rowidx = _checked_constraint_index(constraint);\n\tconst char rowtype = poi_to_xprs_cons_sense(sense);\n\t_check(XPRSchgrowtype(m_model.get(), 1, &rowidx, &rowtype));\n}\n\nConstraintSense Model::get_constraint_sense(ConstraintIndex constraint)\n{\n\tconst int rowidx = _checked_constraint_index(constraint);\n\tchar rowtype = {};\n\t_check(XPRSgetrowtype(m_model.get(), &rowtype, rowidx, rowidx));\n\treturn xprs_to_poi_cons_sense(rowtype);\n}\n\nvoid Model::set_constraint_rhs(ConstraintIndex constraint, CoeffT rhs)\n{\n\tconst int rowidx = _checked_constraint_index(constraint);\n\tconst double g_rhs[] = {static_cast(rhs)};\n\t_check(XPRSchgrhs(m_model.get(), 1, &rowidx, g_rhs));\n}\n\nCoeffT Model::get_constraint_rhs(ConstraintIndex constraint)\n{\n\tconst int rowidx = _checked_constraint_index(constraint);\n\tdouble rhs = {};\n\t_check(XPRSgetrhs(m_model.get(), &rhs, rowidx, rowidx));\n\treturn static_cast(rhs);\n}\n\ndouble Model::get_constraint_slack(ConstraintIndex constraint)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tint rowidx = _checked_constraint_index(constraint);\n\tint status = POI_XPRS_SOLAVAILABLE_NOTFOUND;\n\tdouble value = {};\n\t_check(XPRSgetslacks(m_model.get(), &status, &value, rowidx, rowidx));\n\tif (status == POI_XPRS_SOLAVAILABLE_NOTFOUND)\n\t{\n\t\tthrow std::runtime_error(\"No solution found\");\n\t}\n\treturn value;\n}\n\ndouble Model::get_constraint_dual(ConstraintIndex constraint)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tint rowidx = _checked_constraint_index(constraint);\n\tint status = POI_XPRS_SOLAVAILABLE_NOTFOUND;\n\tdouble value = {};\n\t_check(XPRSgetduals(m_model.get(), &status, &value, rowidx, rowidx));\n\tif (status == POI_XPRS_SOLAVAILABLE_NOTFOUND)\n\t{\n\t\tthrow std::runtime_error(\"No solution found\");\n\t}\n\treturn value;\n}\n\ndouble Model::get_constraint_dual_ray(ConstraintIndex constraint)\n{\n\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tif (m_dual_ray.empty())\n\t{\n\t\tint has_ray = 0;\n\t\t_check(XPRSgetdualray(m_model.get(), nullptr, &has_ray));\n\t\tif (has_ray == 0)\n\t\t{\n\t\t\tthrow std::runtime_error(\"Dual ray not available\");\n\t\t}\n\t\tm_dual_ray.resize(get_raw_attribute_int_by_id(POI_XPRS_ROWS));\n\t\t_check(XPRSgetdualray(m_model.get(), m_dual_ray.data(), &has_ray));\n\t\tassert(has_ray != 0);\n\t}\n\n\tint rowidx = _checked_constraint_index(constraint);\n\treturn m_dual_ray[rowidx];\n}\n\nbool Model::is_constraint_basic(ConstraintIndex constraint)\n{\n\treturn _get_basis_stat(_checked_constraint_index(constraint), true) ==\n\t POI_XPRS_BASISSTATUS_BASIC;\n}\n\nbool Model::is_constraint_nonbasic_lb(ConstraintIndex constraint)\n{\n\treturn _get_basis_stat(_checked_constraint_index(constraint), true) ==\n\t POI_XPRS_BASISSTATUS_NONBASIC_LOWER;\n}\n\nbool Model::is_constraint_nonbasic_ub(ConstraintIndex constraint)\n{\n\treturn _get_basis_stat(_checked_constraint_index(constraint), true) ==\n\t POI_XPRS_BASISSTATUS_NONBASIC_UPPER;\n}\n\nbool Model::is_constraint_superbasic(ConstraintIndex constraint)\n{\n\treturn _get_basis_stat(_checked_constraint_index(constraint), true) ==\n\t POI_XPRS_BASISSTATUS_SUPERBASIC;\n}\n\nbool Model::is_constraint_in_IIS(ConstraintIndex constraint)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\t_ensure_postsolved();\n\n\tif (m_iss_rows.empty())\n\t{\n\t\tint nrow = {};\n\t\tint ncol = {};\n\t\t_check(XPRSgetiisdata(m_model.get(), 1, &nrow, &ncol, nullptr, nullptr, nullptr, nullptr,\n\t\t nullptr, nullptr, nullptr, nullptr));\n\n\t\tm_iss_rows.resize(nrow);\n\t\t_check(XPRSgetiisdata(m_model.get(), 1, &nrow, &ncol, m_iss_rows.data(), nullptr, nullptr,\n\t\t nullptr, nullptr, nullptr, nullptr, nullptr));\n\t}\n\n\tint rowidx = _constraint_index(constraint);\n\tfor (int ridx : m_iss_rows)\n\t{\n\t\tif (ridx == rowidx)\n\t\t{\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n\nvoid *Model::get_raw_model()\n{\n\treturn m_model.get();\n}\n\nstd::string Model::version_string()\n{\n\tchar buffer[32];\n\tXPRSgetversion(buffer);\n\treturn buffer;\n}\n\nvoid Model::computeIIS()\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\tint status = 0;\n\n\t// passing 1 emphasizes simplicity of the IIS\n\t// passing 2 emphasizes a quick result\n\t_check(XPRSiisfirst(m_model.get(), 2, &status));\n\tswitch (status)\n\t{\n\tcase 0:\n\t\treturn;\n\tcase 1:\n\t\tthrow std::runtime_error(\"IIS: problem is feasible\");\n\tcase 2:\n\t\tthrow std::runtime_error(\"IIS: generic error\");\n\tcase 3:\n\t\tthrow std::runtime_error(\"IIS: timeout or interruption\");\n\tdefault:\n\t\tthrow std::runtime_error(fmt::format(\"IIS: unknown exit status {}\", status));\n\t}\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// ATTRIBUTES AND CONTROLS ACCESS //\n////////////////////////////////////////////////////////////////////////////////\n\nstatic const char *xpress_type_to_string(CATypes type)\n{\n\tswitch (type)\n\t{\n\tcase CATypes::INT:\n\t\treturn \"int\";\n\tcase CATypes::INT64:\n\t\treturn \"int64\";\n\tcase CATypes::DOUBLE:\n\t\treturn \"double\";\n\tcase CATypes::STRING:\n\t\treturn \"string\";\n\tdefault:\n\t\treturn \"unknown\";\n\t}\n}\n\nstd::pair Model::_get_control_info(const char *control)\n{\n\tint control_id = {};\n\tint control_type = {};\n\t_check(XPRSgetcontrolinfo(m_model.get(), control, &control_id, &control_type));\n\treturn std::make_pair(control_id, static_cast(control_type));\n}\n\nstd::pair Model::_get_attribute_info(const char *attrib)\n{\n\tint attrib_id = {};\n\tint attrib_type = {};\n\t_check(XPRSgetattribinfo(m_model.get(), attrib, &attrib_id, &attrib_type));\n\treturn std::make_pair(attrib_id, static_cast(attrib_type));\n}\n\nint Model::_get_checked_control_id(const char *control, CATypes expected, CATypes backup)\n{\n\tauto [id, type] = _get_control_info(control);\n\tif (type == CATypes::NOTDEFINED)\n\t{\n\t\tthrow std::runtime_error(\"Error, unknown control type.\");\n\t}\n\tif (type != expected && type != backup)\n\t{\n\t\tauto error_msg = fmt::format(\n\t\t \"Error retriving control '{}'. Control type is '{}', but '{}' was expected.\", control,\n\t\t xpress_type_to_string(type), xpress_type_to_string(expected));\n\t\tthrow std::runtime_error(error_msg);\n\t}\n\treturn id;\n}\n\nint Model::_get_checked_attribute_id(const char *attrib, CATypes expected, CATypes backup)\n{\n\tauto [id, type] = _get_attribute_info(attrib);\n\tif (type == CATypes::NOTDEFINED)\n\t{\n\t\tthrow std::runtime_error(\"Error, unknown attribute type.\");\n\t}\n\tif (type != expected)\n\t{\n\t\tauto error_msg = fmt::format(\n\t\t \"Error retriving attribute '{}'. Attribute type is '{}', but '{}' was expected.\",\n\t\t attrib, xpress_type_to_string(type), xpress_type_to_string(expected));\n\t\tthrow std::runtime_error(error_msg);\n\t}\n\treturn id;\n}\n\n// Generic access to attributes and controls\nModel::xprs_type_variant_t Model::get_raw_attribute(const char *attrib)\n{\n\tauto [id, type] = _get_attribute_info(attrib);\n\tswitch (type)\n\t{\n\tcase CATypes::INT:\n\tcase CATypes::INT64:\n\t\treturn get_raw_attribute_int_by_id(id);\n\tcase CATypes::DOUBLE:\n\t\treturn get_raw_attribute_dbl_by_id(id);\n\tcase CATypes::STRING:\n\t\treturn get_raw_attribute_str_by_id(id);\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown attribute type\");\n\t}\n}\n\nModel::xprs_type_variant_t Model::get_raw_control(const char *control)\n{\n\tauto [id, type] = _get_control_info(control);\n\tswitch (type)\n\t{\n\tcase CATypes::INT:\n\tcase CATypes::INT64:\n\t\treturn get_raw_control_int_by_id(id);\n\tcase CATypes::DOUBLE:\n\t\treturn get_raw_control_dbl_by_id(id);\n\tcase CATypes::STRING:\n\t\treturn get_raw_control_str_by_id(id);\n\tdefault:\n\t\tthrow std::runtime_error(\"Unknown attribute type\");\n\t}\n}\n\n// Helper struct to achieve a sort of pattern matching with the visitor pattern.\n// It basically exploit the overload resolution to get the equivalent of a series of\n// if constexpr(std::is_same_v)\ntemplate \nstruct OverloadSet : public Ts...\n{\n\tusing Ts::operator()...;\n};\n\n// Deduction guide for OverloadSet\ntemplate \nOverloadSet(Ts...) -> OverloadSet;\n\nvoid Model::set_raw_control(const char *control, Model::xprs_type_variant_t &value)\n{\n\tstd::visit(OverloadSet{[&](double d) { set_raw_control_dbl(control, d); },\n\t [&](std::integral auto i) { set_raw_control_int(control, i); },\n\t [&](const std::string &s) { set_raw_control_str(control, s.c_str()); }},\n\t value);\n}\n\nvoid Model::set_raw_control_int(const char *control, XPRSint64 value)\n{\n\tint id = _get_checked_control_id(control, CATypes::INT64, CATypes::INT);\n\treturn set_raw_control_int_by_id(id, value);\n}\n\nvoid Model::set_raw_control_dbl(const char *control, double value)\n{\n\tint id = _get_checked_control_id(control, CATypes::DOUBLE);\n\treturn set_raw_control_dbl_by_id(id, value);\n}\n\nvoid Model::set_raw_control_str(const char *control, const char *value)\n{\n\tint id = _get_checked_control_id(control, CATypes::STRING);\n\treturn set_raw_control_str_by_id(id, value);\n}\n\nXPRSint64 Model::get_raw_control_int(const char *control)\n{\n\tint id = _get_checked_control_id(control, CATypes::INT64, CATypes::INT);\n\treturn get_raw_control_int_by_id(id);\n}\n\ndouble Model::get_raw_control_dbl(const char *control)\n{\n\tint id = _get_checked_control_id(control, CATypes::DOUBLE);\n\treturn get_raw_control_dbl_by_id(id);\n}\n\nstd::string Model::get_raw_control_str(const char *control)\n{\n\tint id = _get_checked_control_id(control, CATypes::STRING);\n\treturn get_raw_control_str_by_id(id);\n}\n\nXPRSint64 Model::get_raw_attribute_int(const char *attrib)\n{\n\tint id = _get_checked_attribute_id(attrib, CATypes::INT64, CATypes::INT);\n\treturn get_raw_attribute_int_by_id(id);\n}\n\ndouble Model::get_raw_attribute_dbl(const char *attrib)\n{\n\tint id = _get_checked_attribute_id(attrib, CATypes::DOUBLE);\n\treturn get_raw_attribute_dbl_by_id(id);\n}\n\nstd::string Model::get_raw_attribute_str(const char *attrib)\n{\n\tint id = _get_checked_attribute_id(attrib, CATypes::STRING);\n\treturn get_raw_attribute_str_by_id(id);\n}\n\nvoid Model::set_raw_control_int_by_id(int control, XPRSint64 value)\n{\n\t// Disabling Xpress internal callback mutex is forbidden since this could easily create race\n\t// condition and deadlocks since it's used in conjunction with Python GIL.\n\tif (control == POI_XPRS_MUTEXCALLBACKS)\n\t{\n\t\tthrow std::runtime_error(\n\t\t \"Changing Xpress callback mutex setting is currently not supported.\");\n\t}\n\t_check(XPRSsetintcontrol64(m_model.get(), control, value));\n}\n\nvoid Model::set_raw_control_dbl_by_id(int control, double value)\n{\n\t_check(XPRSsetdblcontrol(m_model.get(), control, value));\n}\n\nvoid Model::set_raw_control_str_by_id(int control, const char *value)\n{\n\t_check(XPRSsetstrcontrol(m_model.get(), control, value));\n}\n\nXPRSint64 Model::get_raw_control_int_by_id(int control)\n{\n\tXPRSint64 value = {};\n\t_check(XPRSgetintcontrol64(m_model.get(), control, &value));\n\treturn value;\n}\n\ndouble Model::get_raw_control_dbl_by_id(int control)\n{\n\tdouble value = {};\n\t_check(XPRSgetdblcontrol(m_model.get(), control, &value));\n\treturn value;\n}\n\nstd::string Model::get_raw_control_str_by_id(int control)\n{\n\tint req_size = {};\n\t_check(XPRSgetstringcontrol(m_model.get(), control, nullptr, 0, &req_size));\n\tstd::string value = {};\n\tvalue.resize(req_size);\n\t_check(XPRSgetstringcontrol(m_model.get(), control, value.data(), req_size, &req_size));\n\tif (value.size() != req_size)\n\t{\n\t\tthrow std::runtime_error(\"Error while getting control string\");\n\t}\n\t// Align string size with string length\n\tvalue.resize(strlen(value.c_str()));\n\treturn value;\n}\n\nXPRSint64 Model::get_raw_attribute_int_by_id(int attrib)\n{\n\tXPRSint64 value = {};\n\t_check(XPRSgetintattrib64(m_model.get(), attrib, &value));\n\treturn value;\n}\n\ndouble Model::get_raw_attribute_dbl_by_id(int attrib)\n{\n\tdouble value = {};\n\t_check(XPRSgetdblattrib(m_model.get(), attrib, &value));\n\treturn value;\n}\n\nstd::string Model::get_raw_attribute_str_by_id(int attrib)\n{\n\tint req_size = {};\n\t_check(XPRSgetstringattrib(m_model.get(), attrib, nullptr, 0, &req_size));\n\tstd::string value = {};\n\tvalue.resize(req_size);\n\t_check(XPRSgetstringattrib(m_model.get(), attrib, value.data(), req_size, &req_size));\n\tif (value.size() != req_size)\n\t{\n\t\tthrow std::runtime_error(\"Error while getting control string\");\n\t}\n\treturn value;\n}\n\nLPSTATUS Model::get_lp_status()\n{\n\treturn static_cast(get_raw_attribute_int_by_id(POI_XPRS_LPSTATUS));\n}\n\nMIPSTATUS Model::get_mip_status()\n{\n\treturn static_cast(get_raw_attribute_int_by_id(POI_XPRS_MIPSTATUS));\n}\n\nNLPSTATUS Model::get_nlp_status()\n{\n\treturn static_cast(get_raw_attribute_int_by_id(POI_XPRS_NLPSTATUS));\n}\n\nSOLVESTATUS Model::get_solve_status()\n{\n\treturn static_cast(get_raw_attribute_int_by_id(POI_XPRS_SOLVESTATUS));\n}\n\nSOLSTATUS Model::get_sol_status()\n{\n\treturn static_cast(get_raw_attribute_int_by_id(POI_XPRS_SOLSTATUS));\n}\n\nIISSOLSTATUS Model::get_iis_sol_status()\n{\n\treturn static_cast(get_raw_attribute_int_by_id(POI_XPRS_IISSOLSTATUS));\n}\n\nOPTIMIZETYPE Model::get_optimize_type()\n{\n\treturn static_cast(get_raw_attribute_int_by_id(POI_XPRS_OPTIMIZETYPEUSED));\n}\n\nvoid Model::_ensure_postsolved()\n{\n\tif (m_need_postsolve)\n\t{\n\t\t_check(XPRSpostsolve(m_model.get()));\n\n\t\t// Non-convex quadratic constraint might be solved with the non linear solver, so we have to\n\t\t// make sure that the problem is nl-postsolved, even if it is not always strictly necessary\n\t\t// and could introduce minor overhead.\n\t\tif (m_quad_nl_constr_num >= 0 || has_quad_objective || has_nlp_objective)\n\t\t{\n\t\t\t_check(XPRSnlppostsolve(m_model.get()));\n\t\t}\n\t\tm_need_postsolve = false;\n\t}\n}\n\nvoid Model::_check_expected_mode(XPRESS_MODEL_MODE mode)\n{\n\tif (mode == XPRESS_MODEL_MODE::MAIN && m_mode == XPRESS_MODEL_MODE::CALLBACK_)\n\t{\n\t\tthrow std::runtime_error(\"Cannot call this function from within a callback. \"\n\t\t \"This operation is only available on the main model.\");\n\t}\n\tif (mode == XPRESS_MODEL_MODE::CALLBACK_ && m_mode == XPRESS_MODEL_MODE::MAIN)\n\t{\n\t\tthrow std::runtime_error(\"This function can only be called from within a callback. \"\n\t\t \"It is not available on the main model.\");\n\t}\n}\n\nxpress_cbs_data Model::cb_get_arguments()\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::CALLBACK_);\n\treturn cb_args;\n}\n\n// NOTE: XPRSgetcallbacksolution return a context dependent solution\ndouble Model::_cb_get_context_solution(VariableIndex variable)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::CALLBACK_);\n\t// Xpress already caches solutions internally\n\tint p_available = 0;\n\tint colidx = _checked_variable_index(variable);\n\tdouble value[] = {0.0};\n\t_check(XPRSgetcallbacksolution(m_model.get(), &p_available, value, colidx, colidx));\n\tif (p_available == 0)\n\t{\n\t\tthrow std::runtime_error(\"No solution available\");\n\t}\n\treturn value[0];\n}\n\n// Get MIP solution value for a variable in callback context.\n// Returns the callback's candidate integer solution if available (intsol, preintsol contexts),\n// otherwise falls back to the current incumbent solution.\ndouble Model::cb_get_solution(VariableIndex variable)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::CALLBACK_);\n\tif (cb_where == CB_CONTEXT::intsol || cb_where == CB_CONTEXT::preintsol)\n\t{\n\t\t// Context provides a candidate integer solution - return it directly\n\t\treturn _cb_get_context_solution(variable);\n\t}\n\n\t// No integer solution in current context - return best known incumbent instead\n\treturn cb_get_incumbent(variable);\n}\n\n// Get LP relaxation solution value for a variable in callback context. Returns the callback's LP\n// relaxation solution when available in contexts that solve LPs (bariteration, cutround,\n// chgbranchobject, nodelpsolved, optnode). It throws in other contexts.\ndouble Model::cb_get_relaxation(VariableIndex variable)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::CALLBACK_);\n\tif (cb_where != CB_CONTEXT::bariteration && cb_where != CB_CONTEXT::cutround &&\n\t cb_where != CB_CONTEXT::chgbranchobject && cb_where != CB_CONTEXT::nodelpsolved &&\n\t cb_where != CB_CONTEXT::optnode)\n\t{\n\t\tthrow std::runtime_error(\"LP relaxation solution not available.\");\n\t}\n\treturn _cb_get_context_solution(variable);\n}\n\ndouble Model::cb_get_incumbent(VariableIndex variable)\n{\n\treturn get_variable_value(variable);\n}\n\nvoid Model::cb_set_solution(VariableIndex variable, double value)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::CALLBACK_);\n\tcb_sol_cache.emplace_back(_checked_variable_index(variable), value);\n}\n\nvoid Model::cb_submit_solution()\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::CALLBACK_);\n\n\tauto &sol = cb_sol_cache;\n\tif (sol.empty())\n\t{\n\t\treturn;\n\t}\n\n\t// Merge together coefficient of duplicated indices\n\tstd::ranges::sort(sol);\n\tstd::vector indices;\n\tstd::vector values;\n\tint curr_idx = std::numeric_limits::lowest();\n\tfor (auto [idx, val] : sol)\n\t{\n\t\tif (curr_idx != idx)\n\t\t{\n\t\t\tcurr_idx = idx;\n\t\t\tindices.push_back(idx);\n\t\t\tvalues.emplace_back();\n\t\t}\n\t\tvalues.back() += val;\n\t}\n\n\tint ncol = static_cast(indices.size());\n\t_check(XPRSaddmipsol(m_model.get(), ncol, values.data(), indices.data(), nullptr));\n}\n\nvoid Model::cb_exit()\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::CALLBACK_);\n\t_check(XPRSinterrupt(m_model.get(), POI_XPRS_STOP_USER));\n}\n\nvoid Model::_cb_add_cut(const ScalarAffineFunction &function, ConstraintSense sense, CoeffT rhs)\n{\n\tAffineFunctionPtrForm ptr_form;\n\tptr_form.make(this, function);\n\tint numnz = ptr_form.numnz;\n\tchar g_sense = poi_to_xprs_cons_sense(sense);\n\tdouble g_rhs = static_cast(rhs - function.constant.value_or(CoeffT{}));\n\tconst int *cind = ptr_form.index;\n\tconst double *cval = ptr_form.value;\n\n\t// Before adding the cut, we must translate it to the presolved model. If this translation fails\n\t// then we cannot continue. The translation can only fail if we have presolve operations enabled\n\t// that should be disabled in case of dynamically separated constraints.\n\tint ncols = get_raw_attribute_int_by_id(POI_XPRS_COLS);\n\tint ps_numnz = 0;\n\tstd::vector ps_cind(ncols);\n\tstd::vector ps_cval(ncols);\n\tdouble ps_rhs = 0.0;\n\tint ps_status = 0;\n\t_check(XPRSpresolverow(m_model.get(), g_sense, numnz, cind, cval, g_rhs, ncols, &ps_numnz,\n\t ps_cind.data(), ps_cval.data(), &ps_rhs, &ps_status));\n\tif (ps_status != 0)\n\t{\n\t\tthrow std::runtime_error(\"Failed to presolve new cut.\");\n\t}\n\n\tXPRSint64 start[] = {0, ps_numnz};\n\tint ctype = 1;\n\tif (cb_where == CB_CONTEXT::cutround)\n\t{\n\t\t// NOTE: we assume cuts to be global since other solvers only support those\n\t\t_check(XPRSaddmanagedcuts64(m_model.get(), 1, 1, &g_sense, &ps_rhs, start, ps_cind.data(),\n\t\t ps_cval.data()));\n\t}\n\telse\n\t{\n\t\t_check(XPRSaddcuts64(m_model.get(), 1, &ctype, &g_sense, &ps_rhs, start, ps_cind.data(),\n\t\t ps_cval.data()));\n\t}\n}\n\n// Tries to add a lazy constraints. If the context is right, but we are not in a node of the tree,\n// it fallbacks to simply rejecting the solution, since no cut can be added at that moment.\nvoid Model::cb_add_lazy_constraint(const ScalarAffineFunction &function, ConstraintSense sense,\n CoeffT rhs)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::CALLBACK_);\n\tif (cb_where != CB_CONTEXT::nodelpsolved && cb_where != CB_CONTEXT::optnode &&\n\t cb_where != CB_CONTEXT::preintsol && cb_where != CB_CONTEXT::prenode)\n\t{\n\t\tthrow std::runtime_error(\"New constraints can be added only in NODELPSOLVED, OPTNODE, \"\n\t\t \"PREINTSOL, and PRENODE callbacks.\");\n\t}\n\n\tif (cb_where != CB_CONTEXT::preintsol)\n\t{\n\t\t_cb_add_cut(function, sense, rhs);\n\t\treturn;\n\t}\n\n\tauto *args = std::get(cb_args);\n\tif (args->soltype == 0)\n\t{\n\t\t_cb_add_cut(function, sense, rhs);\n\t\treturn;\n\t}\n\n\t// If the solution didn't originated from a node of the tree, we can't reject it with a cut.\n\t// However, if the user cut makes the solution infeasible, we have to reject it.\n\tdouble pos_activity = 0.0;\n\tdouble neg_anctivity = 0.0;\n\tconst int nnz = function.size();\n\tfor (int i = 0; i < nnz; ++i)\n\t{\n\t\tdouble col_val = _cb_get_context_solution(function.variables[i]);\n\t\tdouble term_val = col_val * function.coefficients[i];\n\t\t(term_val > 0.0 ? pos_activity : neg_anctivity) += term_val;\n\t}\n\tconst double activity = pos_activity + neg_anctivity;\n\tconst double real_rhs = static_cast(rhs - function.constant.value_or(0.0));\n\tdouble infeas = 0.0; // > 0 if solution violates constraint\n\tif (sense == ConstraintSense::Equal || sense == ConstraintSense::LessEqual)\n\t{\n\t\tinfeas = std::max(infeas, activity - real_rhs);\n\t}\n\tif (sense == ConstraintSense::Equal || sense == ConstraintSense::GreaterEqual)\n\t{\n\t\tinfeas = std::max(infeas, real_rhs - activity);\n\t}\n\tconst double feastol = get_raw_control_dbl_by_id(POI_XPRS_FEASTOL);\n\tif (infeas > feastol)\n\t{\n\t\t// The user added a cut, but we are not in a context where it can be added. So, the only\n\t\t// thing we can reasonably do is to reject the solution iff it is made infeasible by the\n\t\t// user provided cut.\n\t\t*args->p_reject = 1;\n\t}\n}\n\nvoid Model::cb_add_lazy_constraint(const ExprBuilder &function, ConstraintSense sense, CoeffT rhs)\n{\n\tScalarAffineFunction f(function);\n\tcb_add_lazy_constraint(f, sense, rhs);\n}\n\nvoid Model::cb_add_user_cut(const ScalarAffineFunction &function, ConstraintSense sense, CoeffT rhs)\n{\n\t_cb_add_cut(function, sense, rhs);\n}\n\nvoid Model::cb_add_user_cut(const ExprBuilder &function, ConstraintSense sense, CoeffT rhs)\n{\n\tScalarAffineFunction f(function);\n\tcb_add_user_cut(f, sense, rhs);\n}\n\n// Helper struct that defines a static function when instantiated.\n// The defined static function is the actual Xpress CB that will be registered to the context\n// selected by the Where argument.\n// It collects the due-diligence common to all CBs, to minimize code duplication.\ntemplate \nstruct Model::CbWrap\n{\n\tstatic RetT cb(XPRSprob cb_prob, void *user_data, ArgsT... args) noexcept\n\t{\n\t\tauto *model = reinterpret_cast(user_data);\n\t\tassert(model->m_mode == XPRESS_MODEL_MODE::MAIN);\n\n\t\tauto cb_args = CbStruct{{/*ret_code*/}, args...}; // Store additional arguments\n\n\t\t// Temporarily swap the XpressModel's problem pointer with the callback's thread-local\n\t\t// clone. This allows reusing the model's indexers and helper data without copying.\n\t\t//\n\t\t// Current design assumes serialized callback invocation (enforced by Python GIL). The swap\n\t\t// is safe because only one callback executes at a time.\n\t\t//\n\t\t// NOTE: Free-threading compatibility will require redesign. The approach would be to split\n\t\t// Model state into:\n\t\t// - Immutable shared state (indexers, problem structure) shared through a common pointer,\n\t\t// read-only when in callbacks\n\t\t// - Thread-local state (callback context, temporary buffers)\n\t\t//\n\t\t// Instead of swapping problem pointers, create lightweight callback problem objects that\n\t\t// reference the shared state. This is conceptually simple but requires refactoring all\n\t\t// Model methods to access shared state through indirection.\n\t\tXPRSprob main_prob = model->_toggle_model_mode(cb_prob);\n\t\t// Ensure restoration on all exit paths\n\t\tDefer main_prob_restore = [&] { model->_toggle_model_mode(main_prob); };\n\n\t\ttry\n\t\t{\n\t\t\tmodel->_check_expected_mode(XPRESS_MODEL_MODE::CALLBACK_);\n\t\t\tmodel->cb_sol_cache.clear();\n\t\t\tmodel->cb_where = static_cast(Where);\n\t\t\tmodel->cb_args = &cb_args;\n\t\t\tmodel->m_callback(model, static_cast(Where));\n\t\t\tmodel->cb_submit_solution();\n\t\t}\n\t\tcatch (...)\n\t\t{\n\t\t\t// We cannot let any exception slip through a callback, we have to catch it,\n\t\t\t// terminate Xpress gracefully and then we can throw it again.\n\t\t\tif (XPRSinterrupt(cb_prob, POI_XPRS_STOP_USER) != 0)\n\t\t\t{\n\t\t\t\tstd::rethrow_exception(std::current_exception()); // We have to terminate somehow\n\t\t\t}\n\t\t\tmodel->m_captured_exceptions.push_back(std::current_exception());\n\t\t}\n\n\t\treturn cb_args.get_return_value();\n\t}\n};\n\nstatic constexpr unsigned long long as_flag(int ID)\n{\n\tassert(\"ID must be in the [0, 63] range\" && ID >= 0 && ID < 63);\n\treturn (1ULL << ID);\n}\n\nstatic constexpr bool test_ctx(CB_CONTEXT dest_ctx, unsigned long long curr_ctx)\n{\n\tauto ctx = static_cast(dest_ctx);\n\treturn (curr_ctx & ctx) != 0; // The context matches the ID\n}\n\nvoid Model::set_callback(const Callback &cb, unsigned long long new_contexts)\n{\n\t_check_expected_mode(XPRESS_MODEL_MODE::MAIN);\n\n\t// Default message callback management - we always register a default message handler\n\t// unless the user explicitly registers their own. When the user callback is removed,\n\t// restore the default handler.\n\tif (is_default_message_cb_set && test_ctx(CB_CONTEXT::message, new_contexts))\n\t{\n\t\t_check(XPRSremovecbmessage(m_model.get(), &default_print, nullptr));\n\t\tis_default_message_cb_set = false;\n\t}\n\tif (!is_default_message_cb_set && !test_ctx(CB_CONTEXT::message, new_contexts))\n\t{\n\t\t_check(XPRSaddcbmessage(m_model.get(), &default_print, nullptr, 0));\n\t\tis_default_message_cb_set = true;\n\t}\n\n\t// Register/unregister Xpress callbacks based on context changes. For each callback type,\n\t// compare the old context set (m_curr_contexts) with the new one. If a context needs to be\n\t// added or removed, register/unregister the corresponding low-level wrapper function.\n\t//\n\t// Note: The wrapper functions are stateless - they just forward to the user callback pointer.\n\t// Updating the callback for an already-registered context only requires updating m_callback;\n\t// the wrapper stays registered.\n\n#define XPRSCB_SET_CTX(ID, NAME, RET, ...) \\\n\t{ \\\n\t\tbool has_cb = test_ctx(CB_CONTEXT::NAME, m_curr_contexts); \\\n\t\tbool needs_cb = test_ctx(CB_CONTEXT::NAME, new_contexts); \\\n\t\tif (has_cb != needs_cb) \\\n\t\t{ \\\n\t\t\tauto *cb = &CbWrap::cb; \\\n\t\t\tif (has_cb) \\\n\t\t\t{ \\\n\t\t\t\t_check(XPRSremovecb##NAME(m_model.get(), cb, this)); \\\n\t\t\t} \\\n\t\t\telse /* needs_cb */ \\\n\t\t\t{ \\\n\t\t\t\t_check(XPRSaddcb##NAME(m_model.get(), cb, this, 0)); \\\n\t\t\t} \\\n\t\t} \\\n\t}\n\tXPRSCB_LIST(XPRSCB_SET_CTX, XPRSCB_ARG_TYPE)\n#undef XPRSCB_SET_CTX\n\n\tm_curr_contexts = new_contexts;\n\tm_callback = cb;\n}\n} // namespace xpress\n" }, { "path": "lib/xpress_model_ext.cpp", "content": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"pyoptinterface/core.hpp\"\n#include \"pyoptinterface/xpress_model.hpp\"\n\nnamespace nb = nanobind;\n\nusing namespace nb::literals;\nusing namespace xpress;\n\nextern void bind_xpress_constants(nb::module_ &m);\n\nNB_MODULE(xpress_model_ext, m)\n{\n\tm.import_(\"pyoptinterface._src.core_ext\");\n\n\tm.def(\"is_library_loaded\", &xpress::is_library_loaded);\n\tm.def(\"load_library\", &xpress::load_library);\n\tm.def(\"license\", &xpress::license, \"i\"_a, \"c\"_a);\n\tm.def(\"beginlicensing\", &xpress::beginlicensing);\n\tm.def(\"endlicensing\", &xpress::endlicensing);\n\n\tbind_xpress_constants(m);\n\n\tnb::class_(m, \"Env\")\n\t .def(nb::init<>())\n\t .def(nb::init(), \"path\"_a = nullptr)\n\t .def(\"close\", &Env::close);\n\n\tnb::class_(m, \"RawModel\")\n\t .def(nb::init<>())\n\t .def(nb::init(), nb::keep_alive<1, 2>())\n\n\t // Model management\n\t .def(\"init\", &Model::init, \"env\"_a)\n\t .def(\"close\", &Model::close)\n\t .def(\"optimize\", &Model::optimize, nb::call_guard())\n\t .def(\"computeIIS\", &Model::computeIIS, nb::call_guard())\n\t .def(\"write\", &Model::write, \"filename\"_a, nb::call_guard())\n\t .def(\"_is_mip\", &Model::_is_mip)\n\t .def_static(\"get_infinity\", &Model::get_infinity)\n\t .def(\"get_problem_name\", &Model::get_problem_name)\n\t .def(\"set_problem_name\", &Model::set_problem_name, \"probname\"_a)\n\t .def(\"add_mip_start\", &Model::add_mip_start, \"variables\"_a, \"values\"_a)\n\t .def(\"get_raw_model\", &Model::get_raw_model)\n\t .def(\"version_string\", &Model::version_string)\n\n\t // Index mappings\n\t .def(\"_constraint_index\", &Model::_constraint_index, \"constraint\"_a)\n\t .def(\"_variable_index\", &Model::_variable_index, \"variable\"_a)\n\t .def(\"_checked_constraint_index\", &Model::_checked_constraint_index, \"constraint\"_a)\n\t .def(\"_checked_variable_index\", &Model::_checked_variable_index, \"variable\"_a)\n\n\t // Variables\n\t .def(\"add_variable\", &Model::add_variable, \"domain\"_a = VariableDomain::Continuous,\n\t \"lb\"_a = POI_XPRS_MINUSINFINITY, \"ub\"_a = POI_XPRS_PLUSINFINITY, \"name\"_a = \"\")\n\t .def(\"delete_variable\", &Model::delete_variable, \"variable\"_a)\n\t .def(\"delete_variables\", &Model::delete_variables, \"variables\"_a)\n\t .def(\"set_objective_coefficient\", &Model::set_objective_coefficient, \"variable\"_a,\n\t \"value\"_a)\n\t .def(\"set_variable_bounds\", &Model::set_variable_bounds, \"variable\"_a, \"lb\"_a, \"ub\"_a)\n\t .def(\"set_variable_lowerbound\", &Model::set_variable_lowerbound, \"variable\"_a, \"lb\"_a)\n\t .def(\"set_variable_name\", &Model::set_variable_name, \"variable\"_a, \"name\"_a)\n\t .def(\"set_variable_type\", &Model::set_variable_type, \"variable\"_a, \"vtype\"_a)\n\t .def(\"set_variable_upperbound\", &Model::set_variable_upperbound, \"variable\"_a, \"ub\"_a)\n\t .def(\"is_variable_active\", &Model::is_variable_active, \"variable\"_a)\n\t .def(\"is_variable_basic\", &Model::is_variable_basic, \"variable\"_a)\n\t .def(\"get_variable_lowerbound_IIS\", &Model::is_variable_lowerbound_IIS, \"variable\"_a)\n\t .def(\"is_variable_nonbasic_lb\", &Model::is_variable_nonbasic_lb, \"variable\"_a)\n\t .def(\"is_variable_nonbasic_ub\", &Model::is_variable_nonbasic_ub, \"variable\"_a)\n\t .def(\"is_variable_superbasic\", &Model::is_variable_superbasic, \"variable\"_a)\n\t .def(\"get_variable_upperbound_IIS\", &Model::is_variable_upperbound_IIS, \"variable\"_a)\n\t .def(\"get_objective_coefficient\", &Model::get_objective_coefficient, \"variable\"_a)\n\t .def(\"get_variable_lowerbound\", &Model::get_variable_lowerbound, \"variable\"_a)\n\t .def(\"get_variable_primal_ray\", &Model::get_variable_primal_ray, \"variable\"_a)\n\t .def(\"get_variable_rc\", &Model::get_variable_rc, \"variable\"_a)\n\t .def(\"get_variable_upperbound\", &Model::get_variable_upperbound, \"variable\"_a)\n\t .def(\"get_variable_value\", &Model::get_variable_value, \"variable\"_a)\n\t .def(\"get_variable_name\", &Model::get_variable_name, \"variable\"_a)\n\t .def(\"pprint\", &Model::pprint_variable, \"variable\"_a)\n\t .def(\"get_variable_type\", &Model::get_variable_type, \"variable\"_a)\n\n\t // Constraints\n\t .def(\"add_exp_cone_constraint\", &Model::add_exp_cone_constraint, \"variables\"_a,\n\t \"name\"_a = \"\", \"dual\"_a = false)\n\t .def(\"_add_linear_constraint\",\n\t nb::overload_cast &,\n\t const char *>(&Model::add_linear_constraint),\n\t \"function\"_a, \"interval\"_a, \"name\"_a = \"\")\n\t .def(\"_add_linear_constraint\",\n\t nb::overload_cast(\n\t &Model::add_linear_constraint),\n\t \"function\"_a, \"sense\"_a, \"rhs\"_a, \"name\"_a = \"\")\n\t .def(\"add_quadratic_constraint\", &Model::add_quadratic_constraint, \"function\"_a, \"sense\"_a,\n\t \"rhs\"_a, \"name\"_a = \"\")\n\t .def(\"_add_quadratic_constraint\", &Model::add_quadratic_constraint, \"function\"_a, \"sense\"_a,\n\t \"rhs\"_a, \"name\"_a = \"\")\n\t .def(\"add_second_order_cone_constraint\", &Model::add_second_order_cone_constraint,\n\t \"variables\"_a, \"name\"_a = \"\", \"rotated\"_a = false)\n\t .def(\"_add_single_nl_constraint\", &Model::add_single_nl_constraint, \"graph\"_a, \"result\"_a,\n\n\t \"interval\"_a, \"name\"_a = \"\")\n\t .def(\"add_sos_constraint\",\n\t nb::overload_cast &, SOSType, const Vector &>(\n\t &Model::add_sos_constraint),\n\t \"variables\"_a, \"sos_type\"_a, \"weights\"_a)\n\t .def(\"add_sos_constraint\",\n\t nb::overload_cast &, SOSType>(&Model::add_sos_constraint),\n\t \"variables\"_a, \"sos_type\"_a)\n\t .def(\"delete_constraint\", &Model::delete_constraint, \"constraint\"_a)\n\t .def(\"set_constraint_name\", &Model::set_constraint_name, \"constraint\"_a, \"name\"_a)\n\t .def(\"set_constraint_rhs\", &Model::set_constraint_rhs, \"constraint\"_a, \"rhs\"_a)\n\t .def(\"set_constraint_sense\", &Model::set_constraint_sense, \"constraint\"_a, \"sense\"_a)\n\t .def(\"set_normalized_coefficient\", &Model::set_normalized_coefficient, \"constraint\"_a,\n\t \"variable\"_a, \"value\"_a)\n\t .def(\"set_normalized_rhs\", &Model::set_normalized_rhs, \"constraint\"_a, \"value\"_a)\n\t .def(\"is_constraint_active\", &Model::is_constraint_active, \"constraint\"_a)\n\t .def(\"is_constraint_basic\", &Model::is_constraint_basic, \"constraint\"_a)\n\t .def(\"is_constraint_in_IIS\", &Model::is_constraint_in_IIS, \"constraint\"_a)\n\t .def(\"is_constraint_nonbasic_lb\", &Model::is_constraint_nonbasic_lb, \"constraint\"_a)\n\t .def(\"is_constraint_nonbasic_ub\", &Model::is_constraint_nonbasic_ub, \"constraint\"_a)\n\t .def(\"is_constraint_superbasic\", &Model::is_constraint_superbasic, \"constraint\"_a)\n\t .def(\"get_constraint_dual_ray\", &Model::get_constraint_dual_ray, \"constraint\"_a)\n\t .def(\"get_constraint_dual\", &Model::get_constraint_dual, \"constraint\"_a)\n\t .def(\"get_constraint_slack\", &Model::get_constraint_slack, \"constraint\"_a)\n\t .def(\"get_normalized_coefficient\", &Model::get_normalized_coefficient, \"constraint\"_a,\n\t \"variable\"_a)\n\t .def(\"get_normalized_rhs\", &Model::get_normalized_rhs, \"constraint\"_a)\n\t .def(\"get_constraint_rhs\", &Model::get_constraint_rhs, \"constraint\"_a)\n\t .def(\"get_constraint_name\", &Model::get_constraint_name, \"constraint\"_a)\n\t .def(\"get_constraint_sense\", &Model::get_constraint_sense, \"constraint\"_a)\n\n\t // Objective function\n\t .def(\"set_objective\",\n\t nb::overload_cast(&Model::set_objective),\n\t \"function\"_a, \"sense\"_a = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(\n\t &Model::set_objective),\n\t \"function\"_a, \"sense\"_a = ObjectiveSense::Minimize)\n\t .def(\"set_objective\",\n\t nb::overload_cast(&Model::set_objective),\n\t \"function\"_a, \"sense\"_a = ObjectiveSense::Minimize)\n\t .def(\"_add_single_nl_objective\", &Model::add_single_nl_objective, \"graph\"_a, \"result\"_a)\n\n\t // Status queries\n\t .def(\"get_lp_status\", &Model::get_lp_status)\n\t .def(\"get_mip_status\", &Model::get_mip_status)\n\t .def(\"get_nlp_status\", &Model::get_nlp_status)\n\t .def(\"get_sol_status\", &Model::get_sol_status)\n\t .def(\"get_solve_status\", &Model::get_solve_status)\n\t .def(\"get_optimize_type\", &Model::get_optimize_type)\n\t .def(\"get_iis_sol_status\", &Model::get_iis_sol_status)\n\n\t // Raw control/attribute access by ID\n\t .def(\"set_raw_control_dbl_by_id\", &Model::set_raw_control_dbl_by_id, \"control\"_a, \"value\"_a)\n\t .def(\"set_raw_control_int_by_id\", &Model::set_raw_control_int_by_id, \"control\"_a, \"value\"_a)\n\t .def(\"set_raw_control_str_by_id\", &Model::set_raw_control_str_by_id, \"control\"_a, \"value\"_a)\n\t .def(\"get_raw_control_int_by_id\", &Model::get_raw_control_int_by_id, \"control\"_a)\n\t .def(\"get_raw_control_dbl_by_id\", &Model::get_raw_control_dbl_by_id, \"control\"_a)\n\t .def(\"get_raw_control_str_by_id\", &Model::get_raw_control_str_by_id, \"control\"_a)\n\t .def(\"get_raw_attribute_int_by_id\", &Model::get_raw_attribute_int_by_id, \"attrib\"_a)\n\t .def(\"get_raw_attribute_dbl_by_id\", &Model::get_raw_attribute_dbl_by_id, \"attrib\"_a)\n\t .def(\"get_raw_attribute_str_by_id\", &Model::get_raw_attribute_str_by_id, \"attrib\"_a)\n\n\t // Raw control/attribute access by string\n\t .def(\"set_raw_control_int\", &Model::set_raw_control_int, \"control\"_a, \"value\"_a)\n\t .def(\"set_raw_control_dbl\", &Model::set_raw_control_dbl, \"control\"_a, \"value\"_a)\n\t .def(\"set_raw_control_str\", &Model::set_raw_control_str, \"control\"_a, \"value\"_a)\n\t .def(\"get_raw_control_int\", &Model::get_raw_control_int, \"control\"_a)\n\t .def(\"get_raw_control_dbl\", &Model::get_raw_control_dbl, \"control\"_a)\n\t .def(\"get_raw_control_str\", &Model::get_raw_control_str, \"control\"_a)\n\t .def(\"get_raw_attribute_int\", &Model::get_raw_attribute_int, \"attrib\"_a)\n\t .def(\"get_raw_attribute_dbl\", &Model::get_raw_attribute_dbl, \"attrib\"_a)\n\t .def(\"get_raw_attribute_str\", &Model::get_raw_attribute_str, \"attrib\"_a)\n\n\t // Generic variant access\n\t .def(\"set_raw_control\", &Model::set_raw_control, \"control\"_a, \"value\"_a)\n\t .def(\"get_raw_attribute\", &Model::get_raw_attribute, \"attrib\"_a)\n\t .def(\"get_raw_control\", &Model::get_raw_control, \"control\"_a)\n\n\t // Callback methods\n\t .def(\"set_callback\", &Model::set_callback, \"callback\"_a, \"cbctx\"_a)\n\t .def(\"cb_get_arguments\", &Model::cb_get_arguments, nb::rv_policy::reference)\n\t .def(\"cb_get_solution\", &Model::cb_get_solution, \"variable\"_a)\n\t .def(\"cb_get_relaxation\", &Model::cb_get_relaxation, \"variable\"_a)\n\t .def(\"cb_get_incumbent\", &Model::cb_get_incumbent, \"variable\"_a)\n\t .def(\"cb_set_solution\", &Model::cb_set_solution, \"variable\"_a, \"value\"_a)\n\t .def(\"cb_submit_solution\", &Model::cb_submit_solution)\n\t .def(\"cb_exit\", &Model::cb_exit)\n\t .def(\"cb_add_lazy_constraint\",\n\t nb::overload_cast(\n\t &Model::cb_add_lazy_constraint),\n\t \"function\"_a, \"sense\"_a, \"rhs\"_a)\n\t .def(\"cb_add_lazy_constraint\",\n\t nb::overload_cast(\n\t &Model::cb_add_lazy_constraint),\n\t \"function\"_a, \"sense\"_a, \"rhs\"_a)\n\t .def(\"cb_add_user_cut\",\n\t nb::overload_cast(\n\t &Model::cb_add_user_cut),\n\t \"function\"_a, \"sense\"_a, \"rhs\"_a)\n\t .def(\"cb_add_user_cut\",\n\t nb::overload_cast(\n\t &Model::cb_add_user_cut),\n\t \"function\"_a, \"sense\"_a, \"rhs\"_a)\n\n\t // Functions defined in CRTP Mixins\n\t .def(\"pprint\",\n\t nb::overload_cast(&Model::pprint_expression),\n\t \"expr\"_a, \"precision\"_a = 4)\n\t .def(\"pprint\",\n\t nb::overload_cast(&Model::pprint_expression),\n\t \"expr\"_a, \"precision\"_a = 4)\n\t .def(\"pprint\", nb::overload_cast(&Model::pprint_expression),\n\t \"expr\"_a, \"precision\"_a = 4)\n\n\t .def(\"get_value\", nb::overload_cast(&Model::get_variable_value))\n\t .def(\"get_value\",\n\t nb::overload_cast(&Model::get_expression_value))\n\t .def(\"get_value\",\n\t nb::overload_cast(&Model::get_expression_value))\n\t .def(\"get_value\", nb::overload_cast(&Model::get_expression_value))\n\n\t .def(\"_add_linear_constraint\", &Model::add_linear_constraint_from_var, \"expr\"_a, \"sense\"_a,\n\t \"rhs\"_a, \"name\"_a = \"\")\n\t .def(\"_add_linear_constraint\", &Model::add_linear_interval_constraint_from_var, \"expr\"_a,\n\t \"interval\"_a, \"name\"_a = \"\")\n\t .def(\"_add_linear_constraint\", &Model::add_linear_constraint_from_expr, \"expr\"_a, \"sense\"_a,\n\t \"rhs\"_a, \"name\"_a = \"\")\n\t .def(\"_add_linear_constraint\", &Model::add_linear_interval_constraint_from_expr, \"expr\"_a,\n\t \"interval\"_a, \"name\"_a = \"\")\n\t .def(\"_add_linear_constraint\", &Model::add_linear_constraint_from_var, \"expr\"_a, \"sense\"_a,\n\t \"rhs\"_a, \"name\"_a = \"\")\n\t .def(\"_add_linear_constraint\", &Model::add_linear_interval_constraint_from_var, \"expr\"_a,\n\t \"interval\"_a, \"name\"_a = \"\")\n\t .def(\"_add_linear_constraint\", &Model::add_linear_constraint_from_expr, \"expr\"_a, \"sense\"_a,\n\t \"rhs\"_a, \"name\"_a = \"\")\n\t .def(\"_add_linear_constraint\", &Model::add_linear_interval_constraint_from_expr, \"expr\"_a,\n\t \"interval\"_a, \"name\"_a = \"\")\n\n\t .def(\"_add_single_nl_constraint\", &Model::add_single_nl_constraint_sense_rhs, \"graph\"_a,\n\t \"result\"_a, \"sense\"_a, \"rhs\"_a, \"name\"_a = \"\")\n\t .def(\"_add_single_nl_constraint\", &Model::add_single_nl_constraint_from_comparison,\n\t \"graph\"_a, \"expr\"_a, \"name\"_a = \"\")\n\n\t .def(\"set_objective\", &Model::set_objective_as_variable, \"expr\"_a,\n\t \"sense\"_a = ObjectiveSense::Minimize)\n\t .def(\"set_objective\", &Model::set_objective_as_constant, \"expr\"_a,\n\t \"sense\"_a = ObjectiveSense::Minimize);\n\n\t// Bind the return value only it the CB has one\n\tauto bind_ret_code = [](nb::class_ s) {\n\t\t// \"if constexpr + templates\" conditionally instantiates only the true branch.\n\t\tif constexpr (requires { &S::ret_code; })\n\t\t\ts.def_rw(\"ret_code\", &S::ret_code);\n\t};\n\n// When callbacks provide pointer arguments, those are usually meant as output arguments.\n// An exception is with pointer to structs, which usually are just opaque objects passed around\n// between API calls.\n// We define pointer arguments as read-write, while all the other arguments stays read-only\n#define XPRSCB_ARG_NB_FIELD(TYPE, NAME) \\\n\tif constexpr (std::is_pointer_v) \\\n\t\ts.def_rw(#NAME, &struct_t::NAME); \\\n\telse \\\n\t\ts.def_ro(#NAME, &struct_t::NAME);\n\n// Define the binding for the argument struct of each CB. In this way, Nanobind will be able to\n// translate our std::variant of CB-struct pointers into the proper Python union object\n#define XPRSCB_NB_STRUCTS(ID, NAME, RET, ...) \\\n\t{ \\\n\t\tusing struct_t = NAME##_struct; \\\n\t\tauto s = nb::class_(m, #NAME \"_struct\"); \\\n\t\t__VA_ARGS__ \\\n\t\tbind_ret_code(s); \\\n\t}\n\tXPRSCB_LIST(XPRSCB_NB_STRUCTS, XPRSCB_ARG_NB_FIELD)\n#undef XPRSCB_NB_STRUCTS\n}\n" }, { "path": "lib/xpress_model_ext_constants.cpp", "content": "#include \n\n#include \"pyoptinterface/xpress_model.hpp\"\n\nnamespace nb = nanobind;\nusing namespace xpress;\n\nvoid bind_xpress_constants(nb::module_ &m)\n{\n\tnb::module_ XPRS = m.def_submodule(\"XPRS\");\n\t/* useful constants */\n\tXPRS.attr(\"PLUSINFINITY\") = POI_XPRS_PLUSINFINITY;\n\tXPRS.attr(\"MINUSINFINITY\") = POI_XPRS_MINUSINFINITY;\n\tXPRS.attr(\"MAXINT\") = POI_XPRS_MAXINT;\n\tXPRS.attr(\"MAXBANNERLENGTH\") = POI_XPRS_MAXBANNERLENGTH;\n\tXPRS.attr(\"VERSION\") = POI_XPVERSION;\n\tXPRS.attr(\"VERSION_MAJOR\") = POI_XPVERSION_FULL;\n\tXPRS.attr(\"VERSION_MINOR\") = POI_XPVERSION_BUILD;\n\tXPRS.attr(\"VERSION_BUILD\") = POI_XPVERSION_MINOR;\n\tXPRS.attr(\"VERSION_FULL\") = POI_XPVERSION_MAJOR;\n\tXPRS.attr(\"MAXMESSAGELENGTH\") = POI_XPRS_MAXMESSAGELENGTH;\n\n\t/* control parameters for XPRSprob */\n\t/* String control parameters */\n\tXPRS.attr(\"MPSRHSNAME\") = POI_XPRS_MPSRHSNAME;\n\tXPRS.attr(\"MPSOBJNAME\") = POI_XPRS_MPSOBJNAME;\n\tXPRS.attr(\"MPSRANGENAME\") = POI_XPRS_MPSRANGENAME;\n\tXPRS.attr(\"MPSBOUNDNAME\") = POI_XPRS_MPSBOUNDNAME;\n\tXPRS.attr(\"OUTPUTMASK\") = POI_XPRS_OUTPUTMASK;\n\tXPRS.attr(\"TUNERMETHODFILE\") = POI_XPRS_TUNERMETHODFILE;\n\tXPRS.attr(\"TUNEROUTPUTPATH\") = POI_XPRS_TUNEROUTPUTPATH;\n\tXPRS.attr(\"TUNERSESSIONNAME\") = POI_XPRS_TUNERSESSIONNAME;\n\tXPRS.attr(\"COMPUTEEXECSERVICE\") = POI_XPRS_COMPUTEEXECSERVICE;\n\t/* Double control parameters */\n\tXPRS.attr(\"MAXCUTTIME\") = POI_XPRS_MAXCUTTIME;\n\tXPRS.attr(\"MAXSTALLTIME\") = POI_XPRS_MAXSTALLTIME;\n\tXPRS.attr(\"TUNERMAXTIME\") = POI_XPRS_TUNERMAXTIME;\n\tXPRS.attr(\"MATRIXTOL\") = POI_XPRS_MATRIXTOL;\n\tXPRS.attr(\"PIVOTTOL\") = POI_XPRS_PIVOTTOL;\n\tXPRS.attr(\"FEASTOL\") = POI_XPRS_FEASTOL;\n\tXPRS.attr(\"OUTPUTTOL\") = POI_XPRS_OUTPUTTOL;\n\tXPRS.attr(\"SOSREFTOL\") = POI_XPRS_SOSREFTOL;\n\tXPRS.attr(\"OPTIMALITYTOL\") = POI_XPRS_OPTIMALITYTOL;\n\tXPRS.attr(\"ETATOL\") = POI_XPRS_ETATOL;\n\tXPRS.attr(\"RELPIVOTTOL\") = POI_XPRS_RELPIVOTTOL;\n\tXPRS.attr(\"MIPTOL\") = POI_XPRS_MIPTOL;\n\tXPRS.attr(\"MIPTOLTARGET\") = POI_XPRS_MIPTOLTARGET;\n\tXPRS.attr(\"BARPERTURB\") = POI_XPRS_BARPERTURB;\n\tXPRS.attr(\"MIPADDCUTOFF\") = POI_XPRS_MIPADDCUTOFF;\n\tXPRS.attr(\"MIPABSCUTOFF\") = POI_XPRS_MIPABSCUTOFF;\n\tXPRS.attr(\"MIPRELCUTOFF\") = POI_XPRS_MIPRELCUTOFF;\n\tXPRS.attr(\"PSEUDOCOST\") = POI_XPRS_PSEUDOCOST;\n\tXPRS.attr(\"PENALTY\") = POI_XPRS_PENALTY;\n\tXPRS.attr(\"BIGM\") = POI_XPRS_BIGM;\n\tXPRS.attr(\"MIPABSSTOP\") = POI_XPRS_MIPABSSTOP;\n\tXPRS.attr(\"MIPRELSTOP\") = POI_XPRS_MIPRELSTOP;\n\tXPRS.attr(\"CROSSOVERACCURACYTOL\") = POI_XPRS_CROSSOVERACCURACYTOL;\n\tXPRS.attr(\"PRIMALPERTURB\") = POI_XPRS_PRIMALPERTURB;\n\tXPRS.attr(\"DUALPERTURB\") = POI_XPRS_DUALPERTURB;\n\tXPRS.attr(\"BAROBJSCALE\") = POI_XPRS_BAROBJSCALE;\n\tXPRS.attr(\"BARRHSSCALE\") = POI_XPRS_BARRHSSCALE;\n\tXPRS.attr(\"CHOLESKYTOL\") = POI_XPRS_CHOLESKYTOL;\n\tXPRS.attr(\"BARGAPSTOP\") = POI_XPRS_BARGAPSTOP;\n\tXPRS.attr(\"BARDUALSTOP\") = POI_XPRS_BARDUALSTOP;\n\tXPRS.attr(\"BARPRIMALSTOP\") = POI_XPRS_BARPRIMALSTOP;\n\tXPRS.attr(\"BARSTEPSTOP\") = POI_XPRS_BARSTEPSTOP;\n\tXPRS.attr(\"ELIMTOL\") = POI_XPRS_ELIMTOL;\n\tXPRS.attr(\"MARKOWITZTOL\") = POI_XPRS_MARKOWITZTOL;\n\tXPRS.attr(\"MIPABSGAPNOTIFY\") = POI_XPRS_MIPABSGAPNOTIFY;\n\tXPRS.attr(\"MIPRELGAPNOTIFY\") = POI_XPRS_MIPRELGAPNOTIFY;\n\tXPRS.attr(\"BARLARGEBOUND\") = POI_XPRS_BARLARGEBOUND;\n\tXPRS.attr(\"PPFACTOR\") = POI_XPRS_PPFACTOR;\n\tXPRS.attr(\"REPAIRINDEFINITEQMAX\") = POI_XPRS_REPAIRINDEFINITEQMAX;\n\tXPRS.attr(\"BARGAPTARGET\") = POI_XPRS_BARGAPTARGET;\n\tXPRS.attr(\"DUMMYCONTROL\") = POI_XPRS_DUMMYCONTROL;\n\tXPRS.attr(\"BARSTARTWEIGHT\") = POI_XPRS_BARSTARTWEIGHT;\n\tXPRS.attr(\"BARFREESCALE\") = POI_XPRS_BARFREESCALE;\n\tXPRS.attr(\"SBEFFORT\") = POI_XPRS_SBEFFORT;\n\tXPRS.attr(\"HEURDIVERANDOMIZE\") = POI_XPRS_HEURDIVERANDOMIZE;\n\tXPRS.attr(\"HEURSEARCHEFFORT\") = POI_XPRS_HEURSEARCHEFFORT;\n\tXPRS.attr(\"CUTFACTOR\") = POI_XPRS_CUTFACTOR;\n\tXPRS.attr(\"EIGENVALUETOL\") = POI_XPRS_EIGENVALUETOL;\n\tXPRS.attr(\"INDLINBIGM\") = POI_XPRS_INDLINBIGM;\n\tXPRS.attr(\"TREEMEMORYSAVINGTARGET\") = POI_XPRS_TREEMEMORYSAVINGTARGET;\n\tXPRS.attr(\"INDPRELINBIGM\") = POI_XPRS_INDPRELINBIGM;\n\tXPRS.attr(\"RELAXTREEMEMORYLIMIT\") = POI_XPRS_RELAXTREEMEMORYLIMIT;\n\tXPRS.attr(\"MIPABSGAPNOTIFYOBJ\") = POI_XPRS_MIPABSGAPNOTIFYOBJ;\n\tXPRS.attr(\"MIPABSGAPNOTIFYBOUND\") = POI_XPRS_MIPABSGAPNOTIFYBOUND;\n\tXPRS.attr(\"PRESOLVEMAXGROW\") = POI_XPRS_PRESOLVEMAXGROW;\n\tXPRS.attr(\"HEURSEARCHTARGETSIZE\") = POI_XPRS_HEURSEARCHTARGETSIZE;\n\tXPRS.attr(\"CROSSOVERRELPIVOTTOL\") = POI_XPRS_CROSSOVERRELPIVOTTOL;\n\tXPRS.attr(\"CROSSOVERRELPIVOTTOLSAFE\") = POI_XPRS_CROSSOVERRELPIVOTTOLSAFE;\n\tXPRS.attr(\"DETLOGFREQ\") = POI_XPRS_DETLOGFREQ;\n\tXPRS.attr(\"MAXIMPLIEDBOUND\") = POI_XPRS_MAXIMPLIEDBOUND;\n\tXPRS.attr(\"FEASTOLTARGET\") = POI_XPRS_FEASTOLTARGET;\n\tXPRS.attr(\"OPTIMALITYTOLTARGET\") = POI_XPRS_OPTIMALITYTOLTARGET;\n\tXPRS.attr(\"PRECOMPONENTSEFFORT\") = POI_XPRS_PRECOMPONENTSEFFORT;\n\tXPRS.attr(\"LPLOGDELAY\") = POI_XPRS_LPLOGDELAY;\n\tXPRS.attr(\"HEURDIVEITERLIMIT\") = POI_XPRS_HEURDIVEITERLIMIT;\n\tXPRS.attr(\"BARKERNEL\") = POI_XPRS_BARKERNEL;\n\tXPRS.attr(\"FEASTOLPERTURB\") = POI_XPRS_FEASTOLPERTURB;\n\tXPRS.attr(\"CROSSOVERFEASWEIGHT\") = POI_XPRS_CROSSOVERFEASWEIGHT;\n\tXPRS.attr(\"LUPIVOTTOL\") = POI_XPRS_LUPIVOTTOL;\n\tXPRS.attr(\"MIPRESTARTGAPTHRESHOLD\") = POI_XPRS_MIPRESTARTGAPTHRESHOLD;\n\tXPRS.attr(\"NODEPROBINGEFFORT\") = POI_XPRS_NODEPROBINGEFFORT;\n\tXPRS.attr(\"INPUTTOL\") = POI_XPRS_INPUTTOL;\n\tXPRS.attr(\"MIPRESTARTFACTOR\") = POI_XPRS_MIPRESTARTFACTOR;\n\tXPRS.attr(\"BAROBJPERTURB\") = POI_XPRS_BAROBJPERTURB;\n\tXPRS.attr(\"CPIALPHA\") = POI_XPRS_CPIALPHA;\n\tXPRS.attr(\"GLOBALSPATIALBRANCHPROPAGATIONEFFORT\") =\n\t POI_XPRS_GLOBALSPATIALBRANCHPROPAGATIONEFFORT;\n\tXPRS.attr(\"GLOBALSPATIALBRANCHCUTTINGEFFORT\") = POI_XPRS_GLOBALSPATIALBRANCHCUTTINGEFFORT;\n\tXPRS.attr(\"GLOBALBOUNDINGBOX\") = POI_XPRS_GLOBALBOUNDINGBOX;\n\tXPRS.attr(\"TIMELIMIT\") = POI_XPRS_TIMELIMIT;\n\tXPRS.attr(\"SOLTIMELIMIT\") = POI_XPRS_SOLTIMELIMIT;\n\tXPRS.attr(\"REPAIRINFEASTIMELIMIT\") = POI_XPRS_REPAIRINFEASTIMELIMIT;\n\tXPRS.attr(\"BARHGEXTRAPOLATE\") = POI_XPRS_BARHGEXTRAPOLATE;\n\tXPRS.attr(\"WORKLIMIT\") = POI_XPRS_WORKLIMIT;\n\tXPRS.attr(\"CALLBACKCHECKTIMEWORKDELAY\") = POI_XPRS_CALLBACKCHECKTIMEWORKDELAY;\n\tXPRS.attr(\"PREROOTWORKLIMIT\") = POI_XPRS_PREROOTWORKLIMIT;\n\tXPRS.attr(\"PREROOTEFFORT\") = POI_XPRS_PREROOTEFFORT;\n\t/* Integer control parameters */\n\tXPRS.attr(\"EXTRAROWS\") = POI_XPRS_EXTRAROWS;\n\tXPRS.attr(\"EXTRACOLS\") = POI_XPRS_EXTRACOLS;\n\tXPRS.attr(\"LPITERLIMIT\") = POI_XPRS_LPITERLIMIT;\n\tXPRS.attr(\"LPLOG\") = POI_XPRS_LPLOG;\n\tXPRS.attr(\"SCALING\") = POI_XPRS_SCALING;\n\tXPRS.attr(\"PRESOLVE\") = POI_XPRS_PRESOLVE;\n\tXPRS.attr(\"CRASH\") = POI_XPRS_CRASH;\n\tXPRS.attr(\"PRICINGALG\") = POI_XPRS_PRICINGALG;\n\tXPRS.attr(\"INVERTFREQ\") = POI_XPRS_INVERTFREQ;\n\tXPRS.attr(\"INVERTMIN\") = POI_XPRS_INVERTMIN;\n\tXPRS.attr(\"MAXNODE\") = POI_XPRS_MAXNODE;\n\tXPRS.attr(\"MAXMIPSOL\") = POI_XPRS_MAXMIPSOL;\n\tXPRS.attr(\"SIFTPASSES\") = POI_XPRS_SIFTPASSES;\n\tXPRS.attr(\"DEFAULTALG\") = POI_XPRS_DEFAULTALG;\n\tXPRS.attr(\"VARSELECTION\") = POI_XPRS_VARSELECTION;\n\tXPRS.attr(\"NODESELECTION\") = POI_XPRS_NODESELECTION;\n\tXPRS.attr(\"BACKTRACK\") = POI_XPRS_BACKTRACK;\n\tXPRS.attr(\"MIPLOG\") = POI_XPRS_MIPLOG;\n\tXPRS.attr(\"KEEPNROWS\") = POI_XPRS_KEEPNROWS;\n\tXPRS.attr(\"MPSECHO\") = POI_XPRS_MPSECHO;\n\tXPRS.attr(\"MAXPAGELINES\") = POI_XPRS_MAXPAGELINES;\n\tXPRS.attr(\"OUTPUTLOG\") = POI_XPRS_OUTPUTLOG;\n\tXPRS.attr(\"BARSOLUTION\") = POI_XPRS_BARSOLUTION;\n\tXPRS.attr(\"CROSSOVER\") = POI_XPRS_CROSSOVER;\n\tXPRS.attr(\"BARITERLIMIT\") = POI_XPRS_BARITERLIMIT;\n\tXPRS.attr(\"CHOLESKYALG\") = POI_XPRS_CHOLESKYALG;\n\tXPRS.attr(\"BAROUTPUT\") = POI_XPRS_BAROUTPUT;\n\tXPRS.attr(\"EXTRAMIPENTS\") = POI_XPRS_EXTRAMIPENTS;\n\tXPRS.attr(\"REFACTOR\") = POI_XPRS_REFACTOR;\n\tXPRS.attr(\"BARTHREADS\") = POI_XPRS_BARTHREADS;\n\tXPRS.attr(\"KEEPBASIS\") = POI_XPRS_KEEPBASIS;\n\tXPRS.attr(\"CROSSOVEROPS\") = POI_XPRS_CROSSOVEROPS;\n\tXPRS.attr(\"VERSION\") = POI_XPRS_VERSION;\n\tXPRS.attr(\"CROSSOVERTHREADS\") = POI_XPRS_CROSSOVERTHREADS;\n\tXPRS.attr(\"BIGMMETHOD\") = POI_XPRS_BIGMMETHOD;\n\tXPRS.attr(\"MPSNAMELENGTH\") = POI_XPRS_MPSNAMELENGTH;\n\tXPRS.attr(\"ELIMFILLIN\") = POI_XPRS_ELIMFILLIN;\n\tXPRS.attr(\"PRESOLVEOPS\") = POI_XPRS_PRESOLVEOPS;\n\tXPRS.attr(\"MIPPRESOLVE\") = POI_XPRS_MIPPRESOLVE;\n\tXPRS.attr(\"MIPTHREADS\") = POI_XPRS_MIPTHREADS;\n\tXPRS.attr(\"BARORDER\") = POI_XPRS_BARORDER;\n\tXPRS.attr(\"BREADTHFIRST\") = POI_XPRS_BREADTHFIRST;\n\tXPRS.attr(\"AUTOPERTURB\") = POI_XPRS_AUTOPERTURB;\n\tXPRS.attr(\"DENSECOLLIMIT\") = POI_XPRS_DENSECOLLIMIT;\n\tXPRS.attr(\"CALLBACKFROMMAINTHREAD\") = POI_XPRS_CALLBACKFROMMAINTHREAD;\n\tXPRS.attr(\"MAXMCOEFFBUFFERELEMS\") = POI_XPRS_MAXMCOEFFBUFFERELEMS;\n\tXPRS.attr(\"REFINEOPS\") = POI_XPRS_REFINEOPS;\n\tXPRS.attr(\"LPREFINEITERLIMIT\") = POI_XPRS_LPREFINEITERLIMIT;\n\tXPRS.attr(\"MIPREFINEITERLIMIT\") = POI_XPRS_MIPREFINEITERLIMIT;\n\tXPRS.attr(\"DUALIZEOPS\") = POI_XPRS_DUALIZEOPS;\n\tXPRS.attr(\"CROSSOVERITERLIMIT\") = POI_XPRS_CROSSOVERITERLIMIT;\n\tXPRS.attr(\"PREBASISRED\") = POI_XPRS_PREBASISRED;\n\tXPRS.attr(\"PRESORT\") = POI_XPRS_PRESORT;\n\tXPRS.attr(\"PREPERMUTE\") = POI_XPRS_PREPERMUTE;\n\tXPRS.attr(\"PREPERMUTESEED\") = POI_XPRS_PREPERMUTESEED;\n\tXPRS.attr(\"MAXMEMORYSOFT\") = POI_XPRS_MAXMEMORYSOFT;\n\tXPRS.attr(\"CUTFREQ\") = POI_XPRS_CUTFREQ;\n\tXPRS.attr(\"SYMSELECT\") = POI_XPRS_SYMSELECT;\n\tXPRS.attr(\"SYMMETRY\") = POI_XPRS_SYMMETRY;\n\tXPRS.attr(\"MAXMEMORYHARD\") = POI_XPRS_MAXMEMORYHARD;\n\tXPRS.attr(\"MIQCPALG\") = POI_XPRS_MIQCPALG;\n\tXPRS.attr(\"QCCUTS\") = POI_XPRS_QCCUTS;\n\tXPRS.attr(\"QCROOTALG\") = POI_XPRS_QCROOTALG;\n\tXPRS.attr(\"PRECONVERTSEPARABLE\") = POI_XPRS_PRECONVERTSEPARABLE;\n\tXPRS.attr(\"ALGAFTERNETWORK\") = POI_XPRS_ALGAFTERNETWORK;\n\tXPRS.attr(\"TRACE\") = POI_XPRS_TRACE;\n\tXPRS.attr(\"MAXIIS\") = POI_XPRS_MAXIIS;\n\tXPRS.attr(\"CPUTIME\") = POI_XPRS_CPUTIME;\n\tXPRS.attr(\"COVERCUTS\") = POI_XPRS_COVERCUTS;\n\tXPRS.attr(\"GOMCUTS\") = POI_XPRS_GOMCUTS;\n\tXPRS.attr(\"LPFOLDING\") = POI_XPRS_LPFOLDING;\n\tXPRS.attr(\"MPSFORMAT\") = POI_XPRS_MPSFORMAT;\n\tXPRS.attr(\"CUTSTRATEGY\") = POI_XPRS_CUTSTRATEGY;\n\tXPRS.attr(\"CUTDEPTH\") = POI_XPRS_CUTDEPTH;\n\tXPRS.attr(\"TREECOVERCUTS\") = POI_XPRS_TREECOVERCUTS;\n\tXPRS.attr(\"TREEGOMCUTS\") = POI_XPRS_TREEGOMCUTS;\n\tXPRS.attr(\"CUTSELECT\") = POI_XPRS_CUTSELECT;\n\tXPRS.attr(\"TREECUTSELECT\") = POI_XPRS_TREECUTSELECT;\n\tXPRS.attr(\"DUALIZE\") = POI_XPRS_DUALIZE;\n\tXPRS.attr(\"DUALGRADIENT\") = POI_XPRS_DUALGRADIENT;\n\tXPRS.attr(\"SBITERLIMIT\") = POI_XPRS_SBITERLIMIT;\n\tXPRS.attr(\"SBBEST\") = POI_XPRS_SBBEST;\n\tXPRS.attr(\"BARINDEFLIMIT\") = POI_XPRS_BARINDEFLIMIT;\n\tXPRS.attr(\"HEURFREQ\") = POI_XPRS_HEURFREQ;\n\tXPRS.attr(\"HEURDEPTH\") = POI_XPRS_HEURDEPTH;\n\tXPRS.attr(\"HEURMAXSOL\") = POI_XPRS_HEURMAXSOL;\n\tXPRS.attr(\"HEURNODES\") = POI_XPRS_HEURNODES;\n\tXPRS.attr(\"LNPBEST\") = POI_XPRS_LNPBEST;\n\tXPRS.attr(\"LNPITERLIMIT\") = POI_XPRS_LNPITERLIMIT;\n\tXPRS.attr(\"BRANCHCHOICE\") = POI_XPRS_BRANCHCHOICE;\n\tXPRS.attr(\"BARREGULARIZE\") = POI_XPRS_BARREGULARIZE;\n\tXPRS.attr(\"SBSELECT\") = POI_XPRS_SBSELECT;\n\tXPRS.attr(\"IISLOG\") = POI_XPRS_IISLOG;\n\tXPRS.attr(\"LOCALCHOICE\") = POI_XPRS_LOCALCHOICE;\n\tXPRS.attr(\"LOCALBACKTRACK\") = POI_XPRS_LOCALBACKTRACK;\n\tXPRS.attr(\"DUALSTRATEGY\") = POI_XPRS_DUALSTRATEGY;\n\tXPRS.attr(\"HEURDIVESTRATEGY\") = POI_XPRS_HEURDIVESTRATEGY;\n\tXPRS.attr(\"HEURSELECT\") = POI_XPRS_HEURSELECT;\n\tXPRS.attr(\"BARSTART\") = POI_XPRS_BARSTART;\n\tXPRS.attr(\"PRESOLVEPASSES\") = POI_XPRS_PRESOLVEPASSES;\n\tXPRS.attr(\"BARORDERTHREADS\") = POI_XPRS_BARORDERTHREADS;\n\tXPRS.attr(\"EXTRASETS\") = POI_XPRS_EXTRASETS;\n\tXPRS.attr(\"FEASIBILITYPUMP\") = POI_XPRS_FEASIBILITYPUMP;\n\tXPRS.attr(\"PRECOEFELIM\") = POI_XPRS_PRECOEFELIM;\n\tXPRS.attr(\"PREDOMCOL\") = POI_XPRS_PREDOMCOL;\n\tXPRS.attr(\"HEURSEARCHFREQ\") = POI_XPRS_HEURSEARCHFREQ;\n\tXPRS.attr(\"HEURDIVESPEEDUP\") = POI_XPRS_HEURDIVESPEEDUP;\n\tXPRS.attr(\"SBESTIMATE\") = POI_XPRS_SBESTIMATE;\n\tXPRS.attr(\"BARCORES\") = POI_XPRS_BARCORES;\n\tXPRS.attr(\"MAXCHECKSONMAXTIME\") = POI_XPRS_MAXCHECKSONMAXTIME;\n\tXPRS.attr(\"MAXCHECKSONMAXCUTTIME\") = POI_XPRS_MAXCHECKSONMAXCUTTIME;\n\tXPRS.attr(\"HISTORYCOSTS\") = POI_XPRS_HISTORYCOSTS;\n\tXPRS.attr(\"ALGAFTERCROSSOVER\") = POI_XPRS_ALGAFTERCROSSOVER;\n\tXPRS.attr(\"MUTEXCALLBACKS\") = POI_XPRS_MUTEXCALLBACKS;\n\tXPRS.attr(\"BARCRASH\") = POI_XPRS_BARCRASH;\n\tXPRS.attr(\"HEURDIVESOFTROUNDING\") = POI_XPRS_HEURDIVESOFTROUNDING;\n\tXPRS.attr(\"HEURSEARCHROOTSELECT\") = POI_XPRS_HEURSEARCHROOTSELECT;\n\tXPRS.attr(\"HEURSEARCHTREESELECT\") = POI_XPRS_HEURSEARCHTREESELECT;\n\tXPRS.attr(\"MPS18COMPATIBLE\") = POI_XPRS_MPS18COMPATIBLE;\n\tXPRS.attr(\"ROOTPRESOLVE\") = POI_XPRS_ROOTPRESOLVE;\n\tXPRS.attr(\"CROSSOVERDRP\") = POI_XPRS_CROSSOVERDRP;\n\tXPRS.attr(\"FORCEOUTPUT\") = POI_XPRS_FORCEOUTPUT;\n\tXPRS.attr(\"PRIMALOPS\") = POI_XPRS_PRIMALOPS;\n\tXPRS.attr(\"DETERMINISTIC\") = POI_XPRS_DETERMINISTIC;\n\tXPRS.attr(\"PREPROBING\") = POI_XPRS_PREPROBING;\n\tXPRS.attr(\"TREEMEMORYLIMIT\") = POI_XPRS_TREEMEMORYLIMIT;\n\tXPRS.attr(\"TREECOMPRESSION\") = POI_XPRS_TREECOMPRESSION;\n\tXPRS.attr(\"TREEDIAGNOSTICS\") = POI_XPRS_TREEDIAGNOSTICS;\n\tXPRS.attr(\"MAXTREEFILESIZE\") = POI_XPRS_MAXTREEFILESIZE;\n\tXPRS.attr(\"PRECLIQUESTRATEGY\") = POI_XPRS_PRECLIQUESTRATEGY;\n\tXPRS.attr(\"IFCHECKCONVEXITY\") = POI_XPRS_IFCHECKCONVEXITY;\n\tXPRS.attr(\"PRIMALUNSHIFT\") = POI_XPRS_PRIMALUNSHIFT;\n\tXPRS.attr(\"REPAIRINDEFINITEQ\") = POI_XPRS_REPAIRINDEFINITEQ;\n\tXPRS.attr(\"MIPRAMPUP\") = POI_XPRS_MIPRAMPUP;\n\tXPRS.attr(\"MAXLOCALBACKTRACK\") = POI_XPRS_MAXLOCALBACKTRACK;\n\tXPRS.attr(\"USERSOLHEURISTIC\") = POI_XPRS_USERSOLHEURISTIC;\n\tXPRS.attr(\"PRECONVERTOBJTOCONS\") = POI_XPRS_PRECONVERTOBJTOCONS;\n\tXPRS.attr(\"FORCEPARALLELDUAL\") = POI_XPRS_FORCEPARALLELDUAL;\n\tXPRS.attr(\"BACKTRACKTIE\") = POI_XPRS_BACKTRACKTIE;\n\tXPRS.attr(\"BRANCHDISJ\") = POI_XPRS_BRANCHDISJ;\n\tXPRS.attr(\"MIPFRACREDUCE\") = POI_XPRS_MIPFRACREDUCE;\n\tXPRS.attr(\"CONCURRENTTHREADS\") = POI_XPRS_CONCURRENTTHREADS;\n\tXPRS.attr(\"MAXSCALEFACTOR\") = POI_XPRS_MAXSCALEFACTOR;\n\tXPRS.attr(\"HEURTHREADS\") = POI_XPRS_HEURTHREADS;\n\tXPRS.attr(\"THREADS\") = POI_XPRS_THREADS;\n\tXPRS.attr(\"HEURBEFORELP\") = POI_XPRS_HEURBEFORELP;\n\tXPRS.attr(\"PREDOMROW\") = POI_XPRS_PREDOMROW;\n\tXPRS.attr(\"BRANCHSTRUCTURAL\") = POI_XPRS_BRANCHSTRUCTURAL;\n\tXPRS.attr(\"QUADRATICUNSHIFT\") = POI_XPRS_QUADRATICUNSHIFT;\n\tXPRS.attr(\"BARPRESOLVEOPS\") = POI_XPRS_BARPRESOLVEOPS;\n\tXPRS.attr(\"QSIMPLEXOPS\") = POI_XPRS_QSIMPLEXOPS;\n\tXPRS.attr(\"MIPRESTART\") = POI_XPRS_MIPRESTART;\n\tXPRS.attr(\"CONFLICTCUTS\") = POI_XPRS_CONFLICTCUTS;\n\tXPRS.attr(\"PREPROTECTDUAL\") = POI_XPRS_PREPROTECTDUAL;\n\tXPRS.attr(\"CORESPERCPU\") = POI_XPRS_CORESPERCPU;\n\tXPRS.attr(\"RESOURCESTRATEGY\") = POI_XPRS_RESOURCESTRATEGY;\n\tXPRS.attr(\"CLAMPING\") = POI_XPRS_CLAMPING;\n\tXPRS.attr(\"PREDUPROW\") = POI_XPRS_PREDUPROW;\n\tXPRS.attr(\"CPUPLATFORM\") = POI_XPRS_CPUPLATFORM;\n\tXPRS.attr(\"BARALG\") = POI_XPRS_BARALG;\n\tXPRS.attr(\"SIFTING\") = POI_XPRS_SIFTING;\n\tXPRS.attr(\"BARKEEPLASTSOL\") = POI_XPRS_BARKEEPLASTSOL;\n\tXPRS.attr(\"LPLOGSTYLE\") = POI_XPRS_LPLOGSTYLE;\n\tXPRS.attr(\"RANDOMSEED\") = POI_XPRS_RANDOMSEED;\n\tXPRS.attr(\"TREEQCCUTS\") = POI_XPRS_TREEQCCUTS;\n\tXPRS.attr(\"PRELINDEP\") = POI_XPRS_PRELINDEP;\n\tXPRS.attr(\"DUALTHREADS\") = POI_XPRS_DUALTHREADS;\n\tXPRS.attr(\"PREOBJCUTDETECT\") = POI_XPRS_PREOBJCUTDETECT;\n\tXPRS.attr(\"PREBNDREDQUAD\") = POI_XPRS_PREBNDREDQUAD;\n\tXPRS.attr(\"PREBNDREDCONE\") = POI_XPRS_PREBNDREDCONE;\n\tXPRS.attr(\"PRECOMPONENTS\") = POI_XPRS_PRECOMPONENTS;\n\tXPRS.attr(\"MAXMIPTASKS\") = POI_XPRS_MAXMIPTASKS;\n\tXPRS.attr(\"MIPTERMINATIONMETHOD\") = POI_XPRS_MIPTERMINATIONMETHOD;\n\tXPRS.attr(\"PRECONEDECOMP\") = POI_XPRS_PRECONEDECOMP;\n\tXPRS.attr(\"HEURFORCESPECIALOBJ\") = POI_XPRS_HEURFORCESPECIALOBJ;\n\tXPRS.attr(\"HEURSEARCHROOTCUTFREQ\") = POI_XPRS_HEURSEARCHROOTCUTFREQ;\n\tXPRS.attr(\"PREELIMQUAD\") = POI_XPRS_PREELIMQUAD;\n\tXPRS.attr(\"PREIMPLICATIONS\") = POI_XPRS_PREIMPLICATIONS;\n\tXPRS.attr(\"TUNERMODE\") = POI_XPRS_TUNERMODE;\n\tXPRS.attr(\"TUNERMETHOD\") = POI_XPRS_TUNERMETHOD;\n\tXPRS.attr(\"TUNERTARGET\") = POI_XPRS_TUNERTARGET;\n\tXPRS.attr(\"TUNERTHREADS\") = POI_XPRS_TUNERTHREADS;\n\tXPRS.attr(\"TUNERHISTORY\") = POI_XPRS_TUNERHISTORY;\n\tXPRS.attr(\"TUNERPERMUTE\") = POI_XPRS_TUNERPERMUTE;\n\tXPRS.attr(\"TUNERVERBOSE\") = POI_XPRS_TUNERVERBOSE;\n\tXPRS.attr(\"TUNEROUTPUT\") = POI_XPRS_TUNEROUTPUT;\n\tXPRS.attr(\"PREANALYTICCENTER\") = POI_XPRS_PREANALYTICCENTER;\n\tXPRS.attr(\"LPFLAGS\") = POI_XPRS_LPFLAGS;\n\tXPRS.attr(\"MIPKAPPAFREQ\") = POI_XPRS_MIPKAPPAFREQ;\n\tXPRS.attr(\"OBJSCALEFACTOR\") = POI_XPRS_OBJSCALEFACTOR;\n\tXPRS.attr(\"TREEFILELOGINTERVAL\") = POI_XPRS_TREEFILELOGINTERVAL;\n\tXPRS.attr(\"IGNORECONTAINERCPULIMIT\") = POI_XPRS_IGNORECONTAINERCPULIMIT;\n\tXPRS.attr(\"IGNORECONTAINERMEMORYLIMIT\") = POI_XPRS_IGNORECONTAINERMEMORYLIMIT;\n\tXPRS.attr(\"MIPDUALREDUCTIONS\") = POI_XPRS_MIPDUALREDUCTIONS;\n\tXPRS.attr(\"GENCONSDUALREDUCTIONS\") = POI_XPRS_GENCONSDUALREDUCTIONS;\n\tXPRS.attr(\"PWLDUALREDUCTIONS\") = POI_XPRS_PWLDUALREDUCTIONS;\n\tXPRS.attr(\"BARFAILITERLIMIT\") = POI_XPRS_BARFAILITERLIMIT;\n\tXPRS.attr(\"AUTOSCALING\") = POI_XPRS_AUTOSCALING;\n\tXPRS.attr(\"GENCONSABSTRANSFORMATION\") = POI_XPRS_GENCONSABSTRANSFORMATION;\n\tXPRS.attr(\"COMPUTEJOBPRIORITY\") = POI_XPRS_COMPUTEJOBPRIORITY;\n\tXPRS.attr(\"PREFOLDING\") = POI_XPRS_PREFOLDING;\n\tXPRS.attr(\"COMPUTE\") = POI_XPRS_COMPUTE;\n\tXPRS.attr(\"NETSTALLLIMIT\") = POI_XPRS_NETSTALLLIMIT;\n\tXPRS.attr(\"SERIALIZEPREINTSOL\") = POI_XPRS_SERIALIZEPREINTSOL;\n\tXPRS.attr(\"NUMERICALEMPHASIS\") = POI_XPRS_NUMERICALEMPHASIS;\n\tXPRS.attr(\"PWLNONCONVEXTRANSFORMATION\") = POI_XPRS_PWLNONCONVEXTRANSFORMATION;\n\tXPRS.attr(\"MIPCOMPONENTS\") = POI_XPRS_MIPCOMPONENTS;\n\tXPRS.attr(\"MIPCONCURRENTNODES\") = POI_XPRS_MIPCONCURRENTNODES;\n\tXPRS.attr(\"MIPCONCURRENTSOLVES\") = POI_XPRS_MIPCONCURRENTSOLVES;\n\tXPRS.attr(\"OUTPUTCONTROLS\") = POI_XPRS_OUTPUTCONTROLS;\n\tXPRS.attr(\"SIFTSWITCH\") = POI_XPRS_SIFTSWITCH;\n\tXPRS.attr(\"HEUREMPHASIS\") = POI_XPRS_HEUREMPHASIS;\n\tXPRS.attr(\"BARREFITER\") = POI_XPRS_BARREFITER;\n\tXPRS.attr(\"COMPUTELOG\") = POI_XPRS_COMPUTELOG;\n\tXPRS.attr(\"SIFTPRESOLVEOPS\") = POI_XPRS_SIFTPRESOLVEOPS;\n\tXPRS.attr(\"CHECKINPUTDATA\") = POI_XPRS_CHECKINPUTDATA;\n\tXPRS.attr(\"ESCAPENAMES\") = POI_XPRS_ESCAPENAMES;\n\tXPRS.attr(\"IOTIMEOUT\") = POI_XPRS_IOTIMEOUT;\n\tXPRS.attr(\"AUTOCUTTING\") = POI_XPRS_AUTOCUTTING;\n\tXPRS.attr(\"GLOBALNUMINITNLPCUTS\") = POI_XPRS_GLOBALNUMINITNLPCUTS;\n\tXPRS.attr(\"CALLBACKCHECKTIMEDELAY\") = POI_XPRS_CALLBACKCHECKTIMEDELAY;\n\tXPRS.attr(\"MULTIOBJOPS\") = POI_XPRS_MULTIOBJOPS;\n\tXPRS.attr(\"MULTIOBJLOG\") = POI_XPRS_MULTIOBJLOG;\n\tXPRS.attr(\"BACKGROUNDMAXTHREADS\") = POI_XPRS_BACKGROUNDMAXTHREADS;\n\tXPRS.attr(\"GLOBALLSHEURSTRATEGY\") = POI_XPRS_GLOBALLSHEURSTRATEGY;\n\tXPRS.attr(\"GLOBALSPATIALBRANCHIFPREFERORIG\") = POI_XPRS_GLOBALSPATIALBRANCHIFPREFERORIG;\n\tXPRS.attr(\"PRECONFIGURATION\") = POI_XPRS_PRECONFIGURATION;\n\tXPRS.attr(\"FEASIBILITYJUMP\") = POI_XPRS_FEASIBILITYJUMP;\n\tXPRS.attr(\"IISOPS\") = POI_XPRS_IISOPS;\n\tXPRS.attr(\"RLTCUTS\") = POI_XPRS_RLTCUTS;\n\tXPRS.attr(\"ALTERNATIVEREDCOSTS\") = POI_XPRS_ALTERNATIVEREDCOSTS;\n\tXPRS.attr(\"HEURSHIFTPROP\") = POI_XPRS_HEURSHIFTPROP;\n\tXPRS.attr(\"HEURSEARCHCOPYCONTROLS\") = POI_XPRS_HEURSEARCHCOPYCONTROLS;\n\tXPRS.attr(\"GLOBALNLPCUTS\") = POI_XPRS_GLOBALNLPCUTS;\n\tXPRS.attr(\"GLOBALTREENLPCUTS\") = POI_XPRS_GLOBALTREENLPCUTS;\n\tXPRS.attr(\"BARHGOPS\") = POI_XPRS_BARHGOPS;\n\tXPRS.attr(\"BARHGMAXRESTARTS\") = POI_XPRS_BARHGMAXRESTARTS;\n\tXPRS.attr(\"MCFCUTSTRATEGY\") = POI_XPRS_MCFCUTSTRATEGY;\n\tXPRS.attr(\"PREROOTTHREADS\") = POI_XPRS_PREROOTTHREADS;\n\tXPRS.attr(\"BARITERATIVE\") = POI_XPRS_BARITERATIVE;\n\t/* Integer control parameters that support 64-bit values */\n\tXPRS.attr(\"EXTRAELEMS\") = POI_XPRS_EXTRAELEMS;\n\tXPRS.attr(\"EXTRASETELEMS\") = POI_XPRS_EXTRASETELEMS;\n\tXPRS.attr(\"BACKGROUNDSELECT\") = POI_XPRS_BACKGROUNDSELECT;\n\tXPRS.attr(\"HEURSEARCHBACKGROUNDSELECT\") = POI_XPRS_HEURSEARCHBACKGROUNDSELECT;\n\n\t/* attributes for XPRSprob */\n\t/* String attributes */\n\tXPRS.attr(\"MATRIXNAME\") = POI_XPRS_MATRIXNAME;\n\tXPRS.attr(\"BOUNDNAME\") = POI_XPRS_BOUNDNAME;\n\tXPRS.attr(\"RHSNAME\") = POI_XPRS_RHSNAME;\n\tXPRS.attr(\"RANGENAME\") = POI_XPRS_RANGENAME;\n\tXPRS.attr(\"XPRESSVERSION\") = POI_XPRS_XPRESSVERSION;\n\tXPRS.attr(\"UUID\") = POI_XPRS_UUID;\n\t/* Double attributes */\n\tXPRS.attr(\"MIPSOLTIME\") = POI_XPRS_MIPSOLTIME;\n\tXPRS.attr(\"TIME\") = POI_XPRS_TIME;\n\tXPRS.attr(\"LPOBJVAL\") = POI_XPRS_LPOBJVAL;\n\tXPRS.attr(\"SUMPRIMALINF\") = POI_XPRS_SUMPRIMALINF;\n\tXPRS.attr(\"MIPOBJVAL\") = POI_XPRS_MIPOBJVAL;\n\tXPRS.attr(\"BESTBOUND\") = POI_XPRS_BESTBOUND;\n\tXPRS.attr(\"OBJRHS\") = POI_XPRS_OBJRHS;\n\tXPRS.attr(\"MIPBESTOBJVAL\") = POI_XPRS_MIPBESTOBJVAL;\n\tXPRS.attr(\"OBJSENSE\") = POI_XPRS_OBJSENSE;\n\tXPRS.attr(\"BRANCHVALUE\") = POI_XPRS_BRANCHVALUE;\n\tXPRS.attr(\"PENALTYVALUE\") = POI_XPRS_PENALTYVALUE;\n\tXPRS.attr(\"CURRMIPCUTOFF\") = POI_XPRS_CURRMIPCUTOFF;\n\tXPRS.attr(\"BARCONDA\") = POI_XPRS_BARCONDA;\n\tXPRS.attr(\"BARCONDD\") = POI_XPRS_BARCONDD;\n\tXPRS.attr(\"MAXABSPRIMALINFEAS\") = POI_XPRS_MAXABSPRIMALINFEAS;\n\tXPRS.attr(\"MAXRELPRIMALINFEAS\") = POI_XPRS_MAXRELPRIMALINFEAS;\n\tXPRS.attr(\"MAXABSDUALINFEAS\") = POI_XPRS_MAXABSDUALINFEAS;\n\tXPRS.attr(\"MAXRELDUALINFEAS\") = POI_XPRS_MAXRELDUALINFEAS;\n\tXPRS.attr(\"PRIMALDUALINTEGRAL\") = POI_XPRS_PRIMALDUALINTEGRAL;\n\tXPRS.attr(\"MAXMIPINFEAS\") = POI_XPRS_MAXMIPINFEAS;\n\tXPRS.attr(\"ATTENTIONLEVEL\") = POI_XPRS_ATTENTIONLEVEL;\n\tXPRS.attr(\"MAXKAPPA\") = POI_XPRS_MAXKAPPA;\n\tXPRS.attr(\"TREECOMPLETION\") = POI_XPRS_TREECOMPLETION;\n\tXPRS.attr(\"PREDICTEDATTLEVEL\") = POI_XPRS_PREDICTEDATTLEVEL;\n\tXPRS.attr(\"OBSERVEDPRIMALINTEGRAL\") = POI_XPRS_OBSERVEDPRIMALINTEGRAL;\n\tXPRS.attr(\"CPISCALEFACTOR\") = POI_XPRS_CPISCALEFACTOR;\n\tXPRS.attr(\"OBJVAL\") = POI_XPRS_OBJVAL;\n\tXPRS.attr(\"WORK\") = POI_XPRS_WORK;\n\tXPRS.attr(\"BARPRIMALOBJ\") = POI_XPRS_BARPRIMALOBJ;\n\tXPRS.attr(\"BARDUALOBJ\") = POI_XPRS_BARDUALOBJ;\n\tXPRS.attr(\"BARPRIMALINF\") = POI_XPRS_BARPRIMALINF;\n\tXPRS.attr(\"BARDUALINF\") = POI_XPRS_BARDUALINF;\n\tXPRS.attr(\"BARCGAP\") = POI_XPRS_BARCGAP;\n\t/* Integer attributes */\n\tXPRS.attr(\"ROWS\") = POI_XPRS_ROWS;\n\tXPRS.attr(\"SETS\") = POI_XPRS_SETS;\n\tXPRS.attr(\"PRIMALINFEAS\") = POI_XPRS_PRIMALINFEAS;\n\tXPRS.attr(\"DUALINFEAS\") = POI_XPRS_DUALINFEAS;\n\tXPRS.attr(\"SIMPLEXITER\") = POI_XPRS_SIMPLEXITER;\n\tXPRS.attr(\"LPSTATUS\") = POI_XPRS_LPSTATUS;\n\tXPRS.attr(\"MIPSTATUS\") = POI_XPRS_MIPSTATUS;\n\tXPRS.attr(\"CUTS\") = POI_XPRS_CUTS;\n\tXPRS.attr(\"NODES\") = POI_XPRS_NODES;\n\tXPRS.attr(\"NODEDEPTH\") = POI_XPRS_NODEDEPTH;\n\tXPRS.attr(\"ACTIVENODES\") = POI_XPRS_ACTIVENODES;\n\tXPRS.attr(\"MIPSOLNODE\") = POI_XPRS_MIPSOLNODE;\n\tXPRS.attr(\"MIPSOLS\") = POI_XPRS_MIPSOLS;\n\tXPRS.attr(\"COLS\") = POI_XPRS_COLS;\n\tXPRS.attr(\"SPAREROWS\") = POI_XPRS_SPAREROWS;\n\tXPRS.attr(\"SPARECOLS\") = POI_XPRS_SPARECOLS;\n\tXPRS.attr(\"SPAREMIPENTS\") = POI_XPRS_SPAREMIPENTS;\n\tXPRS.attr(\"ERRORCODE\") = POI_XPRS_ERRORCODE;\n\tXPRS.attr(\"MIPINFEAS\") = POI_XPRS_MIPINFEAS;\n\tXPRS.attr(\"PRESOLVESTATE\") = POI_XPRS_PRESOLVESTATE;\n\tXPRS.attr(\"PARENTNODE\") = POI_XPRS_PARENTNODE;\n\tXPRS.attr(\"NAMELENGTH\") = POI_XPRS_NAMELENGTH;\n\tXPRS.attr(\"QELEMS\") = POI_XPRS_QELEMS;\n\tXPRS.attr(\"NUMIIS\") = POI_XPRS_NUMIIS;\n\tXPRS.attr(\"MIPENTS\") = POI_XPRS_MIPENTS;\n\tXPRS.attr(\"BRANCHVAR\") = POI_XPRS_BRANCHVAR;\n\tXPRS.attr(\"MIPTHREADID\") = POI_XPRS_MIPTHREADID;\n\tXPRS.attr(\"ALGORITHM\") = POI_XPRS_ALGORITHM;\n\tXPRS.attr(\"CROSSOVERITER\") = POI_XPRS_CROSSOVERITER;\n\tXPRS.attr(\"SOLSTATUS\") = POI_XPRS_SOLSTATUS;\n\tXPRS.attr(\"CUTROUNDS\") = POI_XPRS_CUTROUNDS;\n\tXPRS.attr(\"ORIGINALROWS\") = POI_XPRS_ORIGINALROWS;\n\tXPRS.attr(\"CALLBACKCOUNT_OPTNODE\") = POI_XPRS_CALLBACKCOUNT_OPTNODE;\n\tXPRS.attr(\"ORIGINALQELEMS\") = POI_XPRS_ORIGINALQELEMS;\n\tXPRS.attr(\"MAXPROBNAMELENGTH\") = POI_XPRS_MAXPROBNAMELENGTH;\n\tXPRS.attr(\"STOPSTATUS\") = POI_XPRS_STOPSTATUS;\n\tXPRS.attr(\"ORIGINALMIPENTS\") = POI_XPRS_ORIGINALMIPENTS;\n\tXPRS.attr(\"ORIGINALSETS\") = POI_XPRS_ORIGINALSETS;\n\tXPRS.attr(\"SPARESETS\") = POI_XPRS_SPARESETS;\n\tXPRS.attr(\"CHECKSONMAXTIME\") = POI_XPRS_CHECKSONMAXTIME;\n\tXPRS.attr(\"CHECKSONMAXCUTTIME\") = POI_XPRS_CHECKSONMAXCUTTIME;\n\tXPRS.attr(\"ORIGINALCOLS\") = POI_XPRS_ORIGINALCOLS;\n\tXPRS.attr(\"QCELEMS\") = POI_XPRS_QCELEMS;\n\tXPRS.attr(\"QCONSTRAINTS\") = POI_XPRS_QCONSTRAINTS;\n\tXPRS.attr(\"ORIGINALQCELEMS\") = POI_XPRS_ORIGINALQCELEMS;\n\tXPRS.attr(\"ORIGINALQCONSTRAINTS\") = POI_XPRS_ORIGINALQCONSTRAINTS;\n\tXPRS.attr(\"PEAKTOTALTREEMEMORYUSAGE\") = POI_XPRS_PEAKTOTALTREEMEMORYUSAGE;\n\tXPRS.attr(\"CURRENTNODE\") = POI_XPRS_CURRENTNODE;\n\tXPRS.attr(\"TREEMEMORYUSAGE\") = POI_XPRS_TREEMEMORYUSAGE;\n\tXPRS.attr(\"TREEFILESIZE\") = POI_XPRS_TREEFILESIZE;\n\tXPRS.attr(\"TREEFILEUSAGE\") = POI_XPRS_TREEFILEUSAGE;\n\tXPRS.attr(\"INDICATORS\") = POI_XPRS_INDICATORS;\n\tXPRS.attr(\"ORIGINALINDICATORS\") = POI_XPRS_ORIGINALINDICATORS;\n\tXPRS.attr(\"CORESPERCPUDETECTED\") = POI_XPRS_CORESPERCPUDETECTED;\n\tXPRS.attr(\"CPUSDETECTED\") = POI_XPRS_CPUSDETECTED;\n\tXPRS.attr(\"CORESDETECTED\") = POI_XPRS_CORESDETECTED;\n\tXPRS.attr(\"PHYSICALCORESDETECTED\") = POI_XPRS_PHYSICALCORESDETECTED;\n\tXPRS.attr(\"PHYSICALCORESPERCPUDETECTED\") = POI_XPRS_PHYSICALCORESPERCPUDETECTED;\n\tXPRS.attr(\"OPTIMIZETYPEUSED\") = POI_XPRS_OPTIMIZETYPEUSED;\n\tXPRS.attr(\"BARSING\") = POI_XPRS_BARSING;\n\tXPRS.attr(\"BARSINGR\") = POI_XPRS_BARSINGR;\n\tXPRS.attr(\"PRESOLVEINDEX\") = POI_XPRS_PRESOLVEINDEX;\n\tXPRS.attr(\"CONES\") = POI_XPRS_CONES;\n\tXPRS.attr(\"CONEELEMS\") = POI_XPRS_CONEELEMS;\n\tXPRS.attr(\"PWLCONS\") = POI_XPRS_PWLCONS;\n\tXPRS.attr(\"GENCONS\") = POI_XPRS_GENCONS;\n\tXPRS.attr(\"TREERESTARTS\") = POI_XPRS_TREERESTARTS;\n\tXPRS.attr(\"ORIGINALPWLS\") = POI_XPRS_ORIGINALPWLS;\n\tXPRS.attr(\"ORIGINALGENCONS\") = POI_XPRS_ORIGINALGENCONS;\n\tXPRS.attr(\"COMPUTEEXECUTIONS\") = POI_XPRS_COMPUTEEXECUTIONS;\n\tXPRS.attr(\"RESTARTS\") = POI_XPRS_RESTARTS;\n\tXPRS.attr(\"SOLVESTATUS\") = POI_XPRS_SOLVESTATUS;\n\tXPRS.attr(\"GLOBALBOUNDINGBOXAPPLIED\") = POI_XPRS_GLOBALBOUNDINGBOXAPPLIED;\n\tXPRS.attr(\"OBJECTIVES\") = POI_XPRS_OBJECTIVES;\n\tXPRS.attr(\"SOLVEDOBJS\") = POI_XPRS_SOLVEDOBJS;\n\tXPRS.attr(\"OBJSTOSOLVE\") = POI_XPRS_OBJSTOSOLVE;\n\tXPRS.attr(\"GLOBALNLPINFEAS\") = POI_XPRS_GLOBALNLPINFEAS;\n\tXPRS.attr(\"IISSOLSTATUS\") = POI_XPRS_IISSOLSTATUS;\n\tXPRS.attr(\"INPUTROWS\") = POI_XPRS_INPUTROWS;\n\tXPRS.attr(\"INPUTCOLS\") = POI_XPRS_INPUTCOLS;\n\tXPRS.attr(\"BARITER\") = POI_XPRS_BARITER;\n\tXPRS.attr(\"BARDENSECOL\") = POI_XPRS_BARDENSECOL;\n\tXPRS.attr(\"BARCROSSOVER\") = POI_XPRS_BARCROSSOVER;\n\t/* Integer attributes that support 64-bit values */\n\tXPRS.attr(\"SETMEMBERS\") = POI_XPRS_SETMEMBERS;\n\tXPRS.attr(\"ELEMS\") = POI_XPRS_ELEMS;\n\tXPRS.attr(\"SPAREELEMS\") = POI_XPRS_SPAREELEMS;\n\tXPRS.attr(\"SYSTEMMEMORY\") = POI_XPRS_SYSTEMMEMORY;\n\tXPRS.attr(\"ORIGINALSETMEMBERS\") = POI_XPRS_ORIGINALSETMEMBERS;\n\tXPRS.attr(\"SPARESETELEMS\") = POI_XPRS_SPARESETELEMS;\n\tXPRS.attr(\"CURRENTMEMORY\") = POI_XPRS_CURRENTMEMORY;\n\tXPRS.attr(\"PEAKMEMORY\") = POI_XPRS_PEAKMEMORY;\n\tXPRS.attr(\"TOTALMEMORY\") = POI_XPRS_TOTALMEMORY;\n\tXPRS.attr(\"AVAILABLEMEMORY\") = POI_XPRS_AVAILABLEMEMORY;\n\tXPRS.attr(\"PWLPOINTS\") = POI_XPRS_PWLPOINTS;\n\tXPRS.attr(\"GENCONCOLS\") = POI_XPRS_GENCONCOLS;\n\tXPRS.attr(\"GENCONVALS\") = POI_XPRS_GENCONVALS;\n\tXPRS.attr(\"ORIGINALPWLPOINTS\") = POI_XPRS_ORIGINALPWLPOINTS;\n\tXPRS.attr(\"ORIGINALGENCONCOLS\") = POI_XPRS_ORIGINALGENCONCOLS;\n\tXPRS.attr(\"ORIGINALGENCONVALS\") = POI_XPRS_ORIGINALGENCONVALS;\n\tXPRS.attr(\"MEMORYLIMITDETECTED\") = POI_XPRS_MEMORYLIMITDETECTED;\n\tXPRS.attr(\"BARAASIZE\") = POI_XPRS_BARAASIZE;\n\tXPRS.attr(\"BARLSIZE\") = POI_XPRS_BARLSIZE;\n\n\t// Nonlinear solver related controls and attributes\n\tXPRS.attr(\"NLPFUNCEVAL\") = POI_XPRS_NLPFUNCEVAL;\n\tXPRS.attr(\"NLPLOG\") = POI_XPRS_NLPLOG;\n\tXPRS.attr(\"NLPKEEPEQUALSCOLUMN\") = POI_XPRS_NLPKEEPEQUALSCOLUMN;\n\tXPRS.attr(\"NLPEVALUATE\") = POI_XPRS_NLPEVALUATE;\n\tXPRS.attr(\"NLPPRESOLVE\") = POI_XPRS_NLPPRESOLVE;\n\tXPRS.attr(\"SLPLOG\") = POI_XPRS_SLPLOG;\n\tXPRS.attr(\"LOCALSOLVER\") = POI_XPRS_LOCALSOLVER;\n\tXPRS.attr(\"NLPSTOPOUTOFRANGE\") = POI_XPRS_NLPSTOPOUTOFRANGE;\n\tXPRS.attr(\"NLPTHREADSAFEUSERFUNC\") = POI_XPRS_NLPTHREADSAFEUSERFUNC;\n\tXPRS.attr(\"NLPJACOBIAN\") = POI_XPRS_NLPJACOBIAN;\n\tXPRS.attr(\"NLPHESSIAN\") = POI_XPRS_NLPHESSIAN;\n\tXPRS.attr(\"MULTISTART\") = POI_XPRS_MULTISTART;\n\tXPRS.attr(\"MULTISTART_THREADS\") = POI_XPRS_MULTISTART_THREADS;\n\tXPRS.attr(\"MULTISTART_MAXSOLVES\") = POI_XPRS_MULTISTART_MAXSOLVES;\n\tXPRS.attr(\"MULTISTART_MAXTIME\") = POI_XPRS_MULTISTART_MAXTIME;\n\tXPRS.attr(\"NLPMAXTIME\") = POI_XPRS_NLPMAXTIME;\n\tXPRS.attr(\"NLPDERIVATIVES\") = POI_XPRS_NLPDERIVATIVES;\n\tXPRS.attr(\"NLPREFORMULATE\") = POI_XPRS_NLPREFORMULATE;\n\tXPRS.attr(\"NLPPRESOLVEOPS\") = POI_XPRS_NLPPRESOLVEOPS;\n\tXPRS.attr(\"MULTISTART_LOG\") = POI_XPRS_MULTISTART_LOG;\n\tXPRS.attr(\"MULTISTART_SEED\") = POI_XPRS_MULTISTART_SEED;\n\tXPRS.attr(\"MULTISTART_POOLSIZE\") = POI_XPRS_MULTISTART_POOLSIZE;\n\tXPRS.attr(\"NLPPOSTSOLVE\") = POI_XPRS_NLPPOSTSOLVE;\n\tXPRS.attr(\"NLPDETERMINISTIC\") = POI_XPRS_NLPDETERMINISTIC;\n\tXPRS.attr(\"NLPPRESOLVELEVEL\") = POI_XPRS_NLPPRESOLVELEVEL;\n\tXPRS.attr(\"NLPPROBING\") = POI_XPRS_NLPPROBING;\n\tXPRS.attr(\"NLPCALCTHREADS\") = POI_XPRS_NLPCALCTHREADS;\n\tXPRS.attr(\"NLPTHREADS\") = POI_XPRS_NLPTHREADS;\n\tXPRS.attr(\"NLPFINDIV\") = POI_XPRS_NLPFINDIV;\n\tXPRS.attr(\"NLPLINQUADBR\") = POI_XPRS_NLPLINQUADBR;\n\tXPRS.attr(\"NLPSOLVER\") = POI_XPRS_NLPSOLVER;\n\t// SLP related integer controls\n\tXPRS.attr(\"SLPALGORITHM\") = POI_XPRS_SLPALGORITHM;\n\tXPRS.attr(\"SLPAUGMENTATION\") = POI_XPRS_SLPAUGMENTATION;\n\tXPRS.attr(\"SLPBARLIMIT\") = POI_XPRS_SLPBARLIMIT;\n\tXPRS.attr(\"SLPCASCADE\") = POI_XPRS_SLPCASCADE;\n\tXPRS.attr(\"SLPCASCADENLIMIT\") = POI_XPRS_SLPCASCADENLIMIT;\n\tXPRS.attr(\"SLPDAMPSTART\") = POI_XPRS_SLPDAMPSTART;\n\tXPRS.attr(\"SLPCUTSTRATEGY\") = POI_XPRS_SLPCUTSTRATEGY;\n\tXPRS.attr(\"SLPDELTAZLIMIT\") = POI_XPRS_SLPDELTAZLIMIT;\n\tXPRS.attr(\"SLPINFEASLIMIT\") = POI_XPRS_SLPINFEASLIMIT;\n\tXPRS.attr(\"SLPITERLIMIT\") = POI_XPRS_SLPITERLIMIT;\n\tXPRS.attr(\"SLPSAMECOUNT\") = POI_XPRS_SLPSAMECOUNT;\n\tXPRS.attr(\"SLPSAMEDAMP\") = POI_XPRS_SLPSAMEDAMP;\n\tXPRS.attr(\"SLPSBSTART\") = POI_XPRS_SLPSBSTART;\n\tXPRS.attr(\"SLPXCOUNT\") = POI_XPRS_SLPXCOUNT;\n\tXPRS.attr(\"SLPXLIMIT\") = POI_XPRS_SLPXLIMIT;\n\tXPRS.attr(\"SLPDELAYUPDATEROWS\") = POI_XPRS_SLPDELAYUPDATEROWS;\n\tXPRS.attr(\"SLPAUTOSAVE\") = POI_XPRS_SLPAUTOSAVE;\n\tXPRS.attr(\"SLPANALYZE\") = POI_XPRS_SLPANALYZE;\n\tXPRS.attr(\"SLPOCOUNT\") = POI_XPRS_SLPOCOUNT;\n\tXPRS.attr(\"SLPMIPALGORITHM\") = POI_XPRS_SLPMIPALGORITHM;\n\tXPRS.attr(\"SLPMIPRELAXSTEPBOUNDS\") = POI_XPRS_SLPMIPRELAXSTEPBOUNDS;\n\tXPRS.attr(\"SLPMIPFIXSTEPBOUNDS\") = POI_XPRS_SLPMIPFIXSTEPBOUNDS;\n\tXPRS.attr(\"SLPMIPITERLIMIT\") = POI_XPRS_SLPMIPITERLIMIT;\n\tXPRS.attr(\"SLPMIPCUTOFFLIMIT\") = POI_XPRS_SLPMIPCUTOFFLIMIT;\n\tXPRS.attr(\"SLPMIPOCOUNT\") = POI_XPRS_SLPMIPOCOUNT;\n\tXPRS.attr(\"SLPMIPDEFAULTALGORITHM\") = POI_XPRS_SLPMIPDEFAULTALGORITHM;\n\tXPRS.attr(\"SLPMIPLOG\") = POI_XPRS_SLPMIPLOG;\n\tXPRS.attr(\"SLPDELTAOFFSET\") = POI_XPRS_SLPDELTAOFFSET;\n\tXPRS.attr(\"SLPUPDATEOFFSET\") = POI_XPRS_SLPUPDATEOFFSET;\n\tXPRS.attr(\"SLPERROROFFSET\") = POI_XPRS_SLPERROROFFSET;\n\tXPRS.attr(\"SLPSBROWOFFSET\") = POI_XPRS_SLPSBROWOFFSET;\n\tXPRS.attr(\"SLPVCOUNT\") = POI_XPRS_SLPVCOUNT;\n\tXPRS.attr(\"SLPVLIMIT\") = POI_XPRS_SLPVLIMIT;\n\tXPRS.attr(\"SLPSCALE\") = POI_XPRS_SLPSCALE;\n\tXPRS.attr(\"SLPSCALECOUNT\") = POI_XPRS_SLPSCALECOUNT;\n\tXPRS.attr(\"SLPECFCHECK\") = POI_XPRS_SLPECFCHECK;\n\tXPRS.attr(\"SLPMIPCUTOFFCOUNT\") = POI_XPRS_SLPMIPCUTOFFCOUNT;\n\tXPRS.attr(\"SLPWCOUNT\") = POI_XPRS_SLPWCOUNT;\n\tXPRS.attr(\"SLPUNFINISHEDLIMIT\") = POI_XPRS_SLPUNFINISHEDLIMIT;\n\tXPRS.attr(\"SLPCONVERGENCEOPS\") = POI_XPRS_SLPCONVERGENCEOPS;\n\tXPRS.attr(\"SLPZEROCRITERION\") = POI_XPRS_SLPZEROCRITERION;\n\tXPRS.attr(\"SLPZEROCRITERIONSTART\") = POI_XPRS_SLPZEROCRITERIONSTART;\n\tXPRS.attr(\"SLPZEROCRITERIONCOUNT\") = POI_XPRS_SLPZEROCRITERIONCOUNT;\n\tXPRS.attr(\"SLPLSPATTERNLIMIT\") = POI_XPRS_SLPLSPATTERNLIMIT;\n\tXPRS.attr(\"SLPLSITERLIMIT\") = POI_XPRS_SLPLSITERLIMIT;\n\tXPRS.attr(\"SLPLSSTART\") = POI_XPRS_SLPLSSTART;\n\tXPRS.attr(\"SLPPENALTYINFOSTART\") = POI_XPRS_SLPPENALTYINFOSTART;\n\tXPRS.attr(\"SLPFILTER\") = POI_XPRS_SLPFILTER;\n\tXPRS.attr(\"SLPTRACEMASKOPS\") = POI_XPRS_SLPTRACEMASKOPS;\n\tXPRS.attr(\"SLPLSZEROLIMIT\") = POI_XPRS_SLPLSZEROLIMIT;\n\tXPRS.attr(\"SLPHEURSTRATEGY\") = POI_XPRS_SLPHEURSTRATEGY;\n\tXPRS.attr(\"SLPBARCROSSOVERSTART\") = POI_XPRS_SLPBARCROSSOVERSTART;\n\tXPRS.attr(\"SLPBARSTALLINGLIMIT\") = POI_XPRS_SLPBARSTALLINGLIMIT;\n\tXPRS.attr(\"SLPBARSTALLINGOBJLIMIT\") = POI_XPRS_SLPBARSTALLINGOBJLIMIT;\n\tXPRS.attr(\"SLPBARSTARTOPS\") = POI_XPRS_SLPBARSTARTOPS;\n\tXPRS.attr(\"SLPGRIDHEURSELECT\") = POI_XPRS_SLPGRIDHEURSELECT;\n\t// Nonlinear related double controls\n\tXPRS.attr(\"NLPINFINITY\") = POI_XPRS_NLPINFINITY;\n\tXPRS.attr(\"NLPZERO\") = POI_XPRS_NLPZERO;\n\tXPRS.attr(\"NLPDEFAULTIV\") = POI_XPRS_NLPDEFAULTIV;\n\tXPRS.attr(\"NLPOPTTIME\") = POI_XPRS_NLPOPTTIME;\n\tXPRS.attr(\"NLPVALIDATIONTOL_A\") = POI_XPRS_NLPVALIDATIONTOL_A;\n\tXPRS.attr(\"NLPVALIDATIONTOL_R\") = POI_XPRS_NLPVALIDATIONTOL_R;\n\tXPRS.attr(\"NLPVALIDATIONINDEX_A\") = POI_XPRS_NLPVALIDATIONINDEX_A;\n\tXPRS.attr(\"NLPVALIDATIONINDEX_R\") = POI_XPRS_NLPVALIDATIONINDEX_R;\n\tXPRS.attr(\"NLPPRIMALINTEGRALREF\") = POI_XPRS_NLPPRIMALINTEGRALREF;\n\tXPRS.attr(\"NLPPRIMALINTEGRALALPHA\") = POI_XPRS_NLPPRIMALINTEGRALALPHA;\n\tXPRS.attr(\"NLPOBJVAL\") = POI_XPRS_NLPOBJVAL;\n\tXPRS.attr(\"NLPPRESOLVEZERO\") = POI_XPRS_NLPPRESOLVEZERO;\n\tXPRS.attr(\"NLPMERITLAMBDA\") = POI_XPRS_NLPMERITLAMBDA;\n\tXPRS.attr(\"MSMAXBOUNDRANGE\") = POI_XPRS_MSMAXBOUNDRANGE;\n\tXPRS.attr(\"NLPVALIDATIONTOL_K\") = POI_XPRS_NLPVALIDATIONTOL_K;\n\tXPRS.attr(\"NLPPRESOLVE_ELIMTOL\") = POI_XPRS_NLPPRESOLVE_ELIMTOL;\n\tXPRS.attr(\"NLPVALIDATIONTARGET_R\") = POI_XPRS_NLPVALIDATIONTARGET_R;\n\tXPRS.attr(\"NLPVALIDATIONTARGET_K\") = POI_XPRS_NLPVALIDATIONTARGET_K;\n\tXPRS.attr(\"NLPVALIDATIONFACTOR\") = POI_XPRS_NLPVALIDATIONFACTOR;\n\tXPRS.attr(\"NLPRELTOLBOUNDTHRESHOLD\") = POI_XPRS_NLPRELTOLBOUNDTHRESHOLD;\n\t// SLP related double controls\n\tXPRS.attr(\"SLPDAMP\") = POI_XPRS_SLPDAMP;\n\tXPRS.attr(\"SLPDAMPEXPAND\") = POI_XPRS_SLPDAMPEXPAND;\n\tXPRS.attr(\"SLPDAMPSHRINK\") = POI_XPRS_SLPDAMPSHRINK;\n\tXPRS.attr(\"SLPDELTA_A\") = POI_XPRS_SLPDELTA_A;\n\tXPRS.attr(\"SLPDELTA_R\") = POI_XPRS_SLPDELTA_R;\n\tXPRS.attr(\"SLPDELTA_Z\") = POI_XPRS_SLPDELTA_Z;\n\tXPRS.attr(\"SLPDELTACOST\") = POI_XPRS_SLPDELTACOST;\n\tXPRS.attr(\"SLPDELTAMAXCOST\") = POI_XPRS_SLPDELTAMAXCOST;\n\tXPRS.attr(\"SLPDJTOL\") = POI_XPRS_SLPDJTOL;\n\tXPRS.attr(\"SLPERRORCOST\") = POI_XPRS_SLPERRORCOST;\n\tXPRS.attr(\"SLPERRORMAXCOST\") = POI_XPRS_SLPERRORMAXCOST;\n\tXPRS.attr(\"SLPERRORTOL_A\") = POI_XPRS_SLPERRORTOL_A;\n\tXPRS.attr(\"SLPEXPAND\") = POI_XPRS_SLPEXPAND;\n\tXPRS.attr(\"SLPMAXWEIGHT\") = POI_XPRS_SLPMAXWEIGHT;\n\tXPRS.attr(\"SLPMINWEIGHT\") = POI_XPRS_SLPMINWEIGHT;\n\tXPRS.attr(\"SLPSHRINK\") = POI_XPRS_SLPSHRINK;\n\tXPRS.attr(\"SLPCTOL\") = POI_XPRS_SLPCTOL;\n\tXPRS.attr(\"SLPATOL_A\") = POI_XPRS_SLPATOL_A;\n\tXPRS.attr(\"SLPATOL_R\") = POI_XPRS_SLPATOL_R;\n\tXPRS.attr(\"SLPMTOL_A\") = POI_XPRS_SLPMTOL_A;\n\tXPRS.attr(\"SLPMTOL_R\") = POI_XPRS_SLPMTOL_R;\n\tXPRS.attr(\"SLPITOL_A\") = POI_XPRS_SLPITOL_A;\n\tXPRS.attr(\"SLPITOL_R\") = POI_XPRS_SLPITOL_R;\n\tXPRS.attr(\"SLPSTOL_A\") = POI_XPRS_SLPSTOL_A;\n\tXPRS.attr(\"SLPSTOL_R\") = POI_XPRS_SLPSTOL_R;\n\tXPRS.attr(\"SLPMVTOL\") = POI_XPRS_SLPMVTOL;\n\tXPRS.attr(\"SLPXTOL_A\") = POI_XPRS_SLPXTOL_A;\n\tXPRS.attr(\"SLPXTOL_R\") = POI_XPRS_SLPXTOL_R;\n\tXPRS.attr(\"SLPDEFAULTSTEPBOUND\") = POI_XPRS_SLPDEFAULTSTEPBOUND;\n\tXPRS.attr(\"SLPDAMPMAX\") = POI_XPRS_SLPDAMPMAX;\n\tXPRS.attr(\"SLPDAMPMIN\") = POI_XPRS_SLPDAMPMIN;\n\tXPRS.attr(\"SLPDELTACOSTFACTOR\") = POI_XPRS_SLPDELTACOSTFACTOR;\n\tXPRS.attr(\"SLPERRORCOSTFACTOR\") = POI_XPRS_SLPERRORCOSTFACTOR;\n\tXPRS.attr(\"SLPERRORTOL_P\") = POI_XPRS_SLPERRORTOL_P;\n\tXPRS.attr(\"SLPCASCADETOL_PA\") = POI_XPRS_SLPCASCADETOL_PA;\n\tXPRS.attr(\"SLPCASCADETOL_PR\") = POI_XPRS_SLPCASCADETOL_PR;\n\tXPRS.attr(\"SLPCASCADETOL_Z\") = POI_XPRS_SLPCASCADETOL_Z;\n\tXPRS.attr(\"SLPOTOL_A\") = POI_XPRS_SLPOTOL_A;\n\tXPRS.attr(\"SLPOTOL_R\") = POI_XPRS_SLPOTOL_R;\n\tXPRS.attr(\"SLPDELTA_X\") = POI_XPRS_SLPDELTA_X;\n\tXPRS.attr(\"SLPERRORCOSTS\") = POI_XPRS_SLPERRORCOSTS;\n\tXPRS.attr(\"SLPGRANULARITY\") = POI_XPRS_SLPGRANULARITY;\n\tXPRS.attr(\"SLPMIPCUTOFF_A\") = POI_XPRS_SLPMIPCUTOFF_A;\n\tXPRS.attr(\"SLPMIPCUTOFF_R\") = POI_XPRS_SLPMIPCUTOFF_R;\n\tXPRS.attr(\"SLPMIPOTOL_A\") = POI_XPRS_SLPMIPOTOL_A;\n\tXPRS.attr(\"SLPMIPOTOL_R\") = POI_XPRS_SLPMIPOTOL_R;\n\tXPRS.attr(\"SLPESCALATION\") = POI_XPRS_SLPESCALATION;\n\tXPRS.attr(\"SLPOBJTOPENALTYCOST\") = POI_XPRS_SLPOBJTOPENALTYCOST;\n\tXPRS.attr(\"SLPSHRINKBIAS\") = POI_XPRS_SLPSHRINKBIAS;\n\tXPRS.attr(\"SLPFEASTOLTARGET\") = POI_XPRS_SLPFEASTOLTARGET;\n\tXPRS.attr(\"SLPOPTIMALITYTOLTARGET\") = POI_XPRS_SLPOPTIMALITYTOLTARGET;\n\tXPRS.attr(\"SLPDELTA_INFINITY\") = POI_XPRS_SLPDELTA_INFINITY;\n\tXPRS.attr(\"SLPVTOL_A\") = POI_XPRS_SLPVTOL_A;\n\tXPRS.attr(\"SLPVTOL_R\") = POI_XPRS_SLPVTOL_R;\n\tXPRS.attr(\"SLPETOL_A\") = POI_XPRS_SLPETOL_A;\n\tXPRS.attr(\"SLPETOL_R\") = POI_XPRS_SLPETOL_R;\n\tXPRS.attr(\"SLPEVTOL_A\") = POI_XPRS_SLPEVTOL_A;\n\tXPRS.attr(\"SLPEVTOL_R\") = POI_XPRS_SLPEVTOL_R;\n\tXPRS.attr(\"SLPDELTA_ZERO\") = POI_XPRS_SLPDELTA_ZERO;\n\tXPRS.attr(\"SLPMINSBFACTOR\") = POI_XPRS_SLPMINSBFACTOR;\n\tXPRS.attr(\"SLPCLAMPVALIDATIONTOL_A\") = POI_XPRS_SLPCLAMPVALIDATIONTOL_A;\n\tXPRS.attr(\"SLPCLAMPVALIDATIONTOL_R\") = POI_XPRS_SLPCLAMPVALIDATIONTOL_R;\n\tXPRS.attr(\"SLPCLAMPSHRINK\") = POI_XPRS_SLPCLAMPSHRINK;\n\tXPRS.attr(\"SLPECFTOL_A\") = POI_XPRS_SLPECFTOL_A;\n\tXPRS.attr(\"SLPECFTOL_R\") = POI_XPRS_SLPECFTOL_R;\n\tXPRS.attr(\"SLPWTOL_A\") = POI_XPRS_SLPWTOL_A;\n\tXPRS.attr(\"SLPWTOL_R\") = POI_XPRS_SLPWTOL_R;\n\tXPRS.attr(\"SLPMATRIXTOL\") = POI_XPRS_SLPMATRIXTOL;\n\tXPRS.attr(\"SLPDRFIXRANGE\") = POI_XPRS_SLPDRFIXRANGE;\n\tXPRS.attr(\"SLPDRCOLTOL\") = POI_XPRS_SLPDRCOLTOL;\n\tXPRS.attr(\"SLPMIPERRORTOL_A\") = POI_XPRS_SLPMIPERRORTOL_A;\n\tXPRS.attr(\"SLPMIPERRORTOL_R\") = POI_XPRS_SLPMIPERRORTOL_R;\n\tXPRS.attr(\"SLPCDTOL_A\") = POI_XPRS_SLPCDTOL_A;\n\tXPRS.attr(\"SLPCDTOL_R\") = POI_XPRS_SLPCDTOL_R;\n\tXPRS.attr(\"SLPENFORCEMAXCOST\") = POI_XPRS_SLPENFORCEMAXCOST;\n\tXPRS.attr(\"SLPENFORCECOSTSHRINK\") = POI_XPRS_SLPENFORCECOSTSHRINK;\n\tXPRS.attr(\"SLPDRCOLDJTOL\") = POI_XPRS_SLPDRCOLDJTOL;\n\tXPRS.attr(\"SLPBARSTALLINGTOL\") = POI_XPRS_SLPBARSTALLINGTOL;\n\tXPRS.attr(\"SLPOBJTHRESHOLD\") = POI_XPRS_SLPOBJTHRESHOLD;\n\tXPRS.attr(\"SLPBOUNDTHRESHOLD\") = POI_XPRS_SLPBOUNDTHRESHOLD;\n\t// Nonlinear related string controls\n\tXPRS.attr(\"NLPIVNAME\") = POI_XPRS_NLPIVNAME;\n\t// SLP related string controls\n\tXPRS.attr(\"SLPDELTAFORMAT\") = POI_XPRS_SLPDELTAFORMAT;\n\tXPRS.attr(\"SLPMINUSDELTAFORMAT\") = POI_XPRS_SLPMINUSDELTAFORMAT;\n\tXPRS.attr(\"SLPMINUSERRORFORMAT\") = POI_XPRS_SLPMINUSERRORFORMAT;\n\tXPRS.attr(\"SLPPLUSDELTAFORMAT\") = POI_XPRS_SLPPLUSDELTAFORMAT;\n\tXPRS.attr(\"SLPPLUSERRORFORMAT\") = POI_XPRS_SLPPLUSERRORFORMAT;\n\tXPRS.attr(\"SLPSBNAME\") = POI_XPRS_SLPSBNAME;\n\tXPRS.attr(\"SLPTOLNAME\") = POI_XPRS_SLPTOLNAME;\n\tXPRS.attr(\"SLPUPDATEFORMAT\") = POI_XPRS_SLPUPDATEFORMAT;\n\tXPRS.attr(\"SLPPENALTYROWFORMAT\") = POI_XPRS_SLPPENALTYROWFORMAT;\n\tXPRS.attr(\"SLPPENALTYCOLFORMAT\") = POI_XPRS_SLPPENALTYCOLFORMAT;\n\tXPRS.attr(\"SLPSBLOROWFORMAT\") = POI_XPRS_SLPSBLOROWFORMAT;\n\tXPRS.attr(\"SLPSBUPROWFORMAT\") = POI_XPRS_SLPSBUPROWFORMAT;\n\tXPRS.attr(\"SLPTRACEMASK\") = POI_XPRS_SLPTRACEMASK;\n\tXPRS.attr(\"SLPITERFALLBACKOPS\") = POI_XPRS_SLPITERFALLBACKOPS;\n\t// Nonlinear related integer attributes\n\tXPRS.attr(\"NLPVALIDATIONSTATUS\") = POI_XPRS_NLPVALIDATIONSTATUS;\n\tXPRS.attr(\"NLPSOLSTATUS\") = POI_XPRS_NLPSOLSTATUS;\n\tXPRS.attr(\"NLPORIGINALROWS\") = POI_XPRS_NLPORIGINALROWS;\n\tXPRS.attr(\"NLPORIGINALCOLS\") = POI_XPRS_NLPORIGINALCOLS;\n\tXPRS.attr(\"NLPUFS\") = POI_XPRS_NLPUFS;\n\tXPRS.attr(\"NLPIFS\") = POI_XPRS_NLPIFS;\n\tXPRS.attr(\"NLPEQUALSCOLUMN\") = POI_XPRS_NLPEQUALSCOLUMN;\n\tXPRS.attr(\"NLPVARIABLES\") = POI_XPRS_NLPVARIABLES;\n\tXPRS.attr(\"NLPIMPLICITVARIABLES\") = POI_XPRS_NLPIMPLICITVARIABLES;\n\tXPRS.attr(\"NONLINEARCONSTRAINTS\") = POI_XPRS_NONLINEARCONSTRAINTS;\n\tXPRS.attr(\"NLPUSERFUNCCALLS\") = POI_XPRS_NLPUSERFUNCCALLS;\n\tXPRS.attr(\"NLPUSEDERIVATIVES\") = POI_XPRS_NLPUSEDERIVATIVES;\n\tXPRS.attr(\"NLPKEEPBESTITER\") = POI_XPRS_NLPKEEPBESTITER;\n\tXPRS.attr(\"NLPSTATUS\") = POI_XPRS_NLPSTATUS;\n\tXPRS.attr(\"LOCALSOLVERSELECTED\") = POI_XPRS_LOCALSOLVERSELECTED;\n\tXPRS.attr(\"NLPMODELROWS\") = POI_XPRS_NLPMODELROWS;\n\tXPRS.attr(\"NLPMODELCOLS\") = POI_XPRS_NLPMODELCOLS;\n\tXPRS.attr(\"NLPJOBID\") = POI_XPRS_NLPJOBID;\n\tXPRS.attr(\"MSJOBS\") = POI_XPRS_MSJOBS;\n\tXPRS.attr(\"NLPSTOPSTATUS\") = POI_XPRS_NLPSTOPSTATUS;\n\tXPRS.attr(\"NLPPRESOLVEELIMINATIONS\") = POI_XPRS_NLPPRESOLVEELIMINATIONS;\n\tXPRS.attr(\"NLPTOTALEVALUATIONERRORS\") = POI_XPRS_NLPTOTALEVALUATIONERRORS;\n\t// SLP related integer attributes\n\tXPRS.attr(\"SLPEXPLOREDELTAS\") = POI_XPRS_SLPEXPLOREDELTAS;\n\tXPRS.attr(\"SLPSEMICONTDELTAS\") = POI_XPRS_SLPSEMICONTDELTAS;\n\tXPRS.attr(\"SLPINTEGERDELTAS\") = POI_XPRS_SLPINTEGERDELTAS;\n\tXPRS.attr(\"SLPITER\") = POI_XPRS_SLPITER;\n\tXPRS.attr(\"SLPSTATUS\") = POI_XPRS_SLPSTATUS;\n\tXPRS.attr(\"SLPUNCONVERGED\") = POI_XPRS_SLPUNCONVERGED;\n\tXPRS.attr(\"SLPSBXCONVERGED\") = POI_XPRS_SLPSBXCONVERGED;\n\tXPRS.attr(\"SLPPENALTYDELTAROW\") = POI_XPRS_SLPPENALTYDELTAROW;\n\tXPRS.attr(\"SLPPENALTYDELTACOLUMN\") = POI_XPRS_SLPPENALTYDELTACOLUMN;\n\tXPRS.attr(\"SLPPENALTYERRORROW\") = POI_XPRS_SLPPENALTYERRORROW;\n\tXPRS.attr(\"SLPPENALTYERRORCOLUMN\") = POI_XPRS_SLPPENALTYERRORCOLUMN;\n\tXPRS.attr(\"SLPCOEFFICIENTS\") = POI_XPRS_SLPCOEFFICIENTS;\n\tXPRS.attr(\"SLPPENALTYDELTAS\") = POI_XPRS_SLPPENALTYDELTAS;\n\tXPRS.attr(\"SLPPENALTYERRORS\") = POI_XPRS_SLPPENALTYERRORS;\n\tXPRS.attr(\"SLPPLUSPENALTYERRORS\") = POI_XPRS_SLPPLUSPENALTYERRORS;\n\tXPRS.attr(\"SLPMINUSPENALTYERRORS\") = POI_XPRS_SLPMINUSPENALTYERRORS;\n\tXPRS.attr(\"SLPUCCONSTRAINEDCOUNT\") = POI_XPRS_SLPUCCONSTRAINEDCOUNT;\n\tXPRS.attr(\"SLPMIPNODES\") = POI_XPRS_SLPMIPNODES;\n\tXPRS.attr(\"SLPMIPITER\") = POI_XPRS_SLPMIPITER;\n\tXPRS.attr(\"SLPTOLSETS\") = POI_XPRS_SLPTOLSETS;\n\tXPRS.attr(\"SLPECFCOUNT\") = POI_XPRS_SLPECFCOUNT;\n\tXPRS.attr(\"SLPDELTAS\") = POI_XPRS_SLPDELTAS;\n\tXPRS.attr(\"SLPZEROESRESET\") = POI_XPRS_SLPZEROESRESET;\n\tXPRS.attr(\"SLPZEROESTOTAL\") = POI_XPRS_SLPZEROESTOTAL;\n\tXPRS.attr(\"SLPZEROESRETAINED\") = POI_XPRS_SLPZEROESRETAINED;\n\tXPRS.attr(\"SLPNONCONSTANTCOEFFS\") = POI_XPRS_SLPNONCONSTANTCOEFFS;\n\tXPRS.attr(\"SLPMIPSOLS\") = POI_XPRS_SLPMIPSOLS;\n\t// Nonlinear related double attributes\n\tXPRS.attr(\"NLPVALIDATIONINDEX_K\") = POI_XPRS_NLPVALIDATIONINDEX_K;\n\tXPRS.attr(\"NLPVALIDATIONNETOBJ\") = POI_XPRS_NLPVALIDATIONNETOBJ;\n\tXPRS.attr(\"NLPPRIMALINTEGRAL\") = POI_XPRS_NLPPRIMALINTEGRAL;\n\t// SLP related double attributes\n\tXPRS.attr(\"SLPCURRENTDELTACOST\") = POI_XPRS_SLPCURRENTDELTACOST;\n\tXPRS.attr(\"SLPCURRENTERRORCOST\") = POI_XPRS_SLPCURRENTERRORCOST;\n\tXPRS.attr(\"SLPPENALTYERRORTOTAL\") = POI_XPRS_SLPPENALTYERRORTOTAL;\n\tXPRS.attr(\"SLPPENALTYERRORVALUE\") = POI_XPRS_SLPPENALTYERRORVALUE;\n\tXPRS.attr(\"SLPPENALTYDELTATOTAL\") = POI_XPRS_SLPPENALTYDELTATOTAL;\n\tXPRS.attr(\"SLPPENALTYDELTAVALUE\") = POI_XPRS_SLPPENALTYDELTAVALUE;\n\t// Nonlinear related string attributes\n\t// SLP related string attributes\n\t// Knitro's parameters\n\tXPRS.attr(\"KNITRO_PARAM_NEWPOINT\") = POI_XPRS_KNITRO_PARAM_NEWPOINT;\n\tXPRS.attr(\"KNITRO_PARAM_HONORBNDS\") = POI_XPRS_KNITRO_PARAM_HONORBNDS;\n\tXPRS.attr(\"KNITRO_PARAM_ALGORITHM\") = POI_XPRS_KNITRO_PARAM_ALGORITHM;\n\tXPRS.attr(\"KNITRO_PARAM_BAR_MURULE\") = POI_XPRS_KNITRO_PARAM_BAR_MURULE;\n\tXPRS.attr(\"KNITRO_PARAM_BAR_FEASIBLE\") = POI_XPRS_KNITRO_PARAM_BAR_FEASIBLE;\n\tXPRS.attr(\"KNITRO_PARAM_GRADOPT\") = POI_XPRS_KNITRO_PARAM_GRADOPT;\n\tXPRS.attr(\"KNITRO_PARAM_HESSOPT\") = POI_XPRS_KNITRO_PARAM_HESSOPT;\n\tXPRS.attr(\"KNITRO_PARAM_BAR_INITPT\") = POI_XPRS_KNITRO_PARAM_BAR_INITPT;\n\tXPRS.attr(\"KNITRO_PARAM_MAXCGIT\") = POI_XPRS_KNITRO_PARAM_MAXCGIT;\n\tXPRS.attr(\"KNITRO_PARAM_MAXIT\") = POI_XPRS_KNITRO_PARAM_MAXIT;\n\tXPRS.attr(\"KNITRO_PARAM_OUTLEV\") = POI_XPRS_KNITRO_PARAM_OUTLEV;\n\tXPRS.attr(\"KNITRO_PARAM_SCALE\") = POI_XPRS_KNITRO_PARAM_SCALE;\n\tXPRS.attr(\"KNITRO_PARAM_SOC\") = POI_XPRS_KNITRO_PARAM_SOC;\n\tXPRS.attr(\"KNITRO_PARAM_DELTA\") = POI_XPRS_KNITRO_PARAM_DELTA;\n\tXPRS.attr(\"KNITRO_PARAM_BAR_FEASMODETOL\") = POI_XPRS_KNITRO_PARAM_BAR_FEASMODETOL;\n\tXPRS.attr(\"KNITRO_PARAM_FEASTOL\") = POI_XPRS_KNITRO_PARAM_FEASTOL;\n\tXPRS.attr(\"KNITRO_PARAM_FEASTOLABS\") = POI_XPRS_KNITRO_PARAM_FEASTOLABS;\n\tXPRS.attr(\"KNITRO_PARAM_BAR_INITMU\") = POI_XPRS_KNITRO_PARAM_BAR_INITMU;\n\tXPRS.attr(\"KNITRO_PARAM_OBJRANGE\") = POI_XPRS_KNITRO_PARAM_OBJRANGE;\n\tXPRS.attr(\"KNITRO_PARAM_OPTTOL\") = POI_XPRS_KNITRO_PARAM_OPTTOL;\n\tXPRS.attr(\"KNITRO_PARAM_OPTTOLABS\") = POI_XPRS_KNITRO_PARAM_OPTTOLABS;\n\tXPRS.attr(\"KNITRO_PARAM_PIVOT\") = POI_XPRS_KNITRO_PARAM_PIVOT;\n\tXPRS.attr(\"KNITRO_PARAM_XTOL\") = POI_XPRS_KNITRO_PARAM_XTOL;\n\tXPRS.attr(\"KNITRO_PARAM_DEBUG\") = POI_XPRS_KNITRO_PARAM_DEBUG;\n\tXPRS.attr(\"KNITRO_PARAM_MULTISTART\") = POI_XPRS_KNITRO_PARAM_MULTISTART;\n\tXPRS.attr(\"KNITRO_PARAM_MSMAXSOLVES\") = POI_XPRS_KNITRO_PARAM_MSMAXSOLVES;\n\tXPRS.attr(\"KNITRO_PARAM_MSMAXBNDRANGE\") = POI_XPRS_KNITRO_PARAM_MSMAXBNDRANGE;\n\tXPRS.attr(\"KNITRO_PARAM_LMSIZE\") = POI_XPRS_KNITRO_PARAM_LMSIZE;\n\tXPRS.attr(\"KNITRO_PARAM_BAR_MAXCROSSIT\") = POI_XPRS_KNITRO_PARAM_BAR_MAXCROSSIT;\n\tXPRS.attr(\"KNITRO_PARAM_BLASOPTION\") = POI_XPRS_KNITRO_PARAM_BLASOPTION;\n\tXPRS.attr(\"KNITRO_PARAM_BAR_MAXREFACTOR\") = POI_XPRS_KNITRO_PARAM_BAR_MAXREFACTOR;\n\tXPRS.attr(\"KNITRO_PARAM_BAR_MAXBACKTRACK\") = POI_XPRS_KNITRO_PARAM_BAR_MAXBACKTRACK;\n\tXPRS.attr(\"KNITRO_PARAM_BAR_PENRULE\") = POI_XPRS_KNITRO_PARAM_BAR_PENRULE;\n\tXPRS.attr(\"KNITRO_PARAM_BAR_PENCONS\") = POI_XPRS_KNITRO_PARAM_BAR_PENCONS;\n\tXPRS.attr(\"KNITRO_PARAM_MSNUMTOSAVE\") = POI_XPRS_KNITRO_PARAM_MSNUMTOSAVE;\n\tXPRS.attr(\"KNITRO_PARAM_MSSAVETOL\") = POI_XPRS_KNITRO_PARAM_MSSAVETOL;\n\tXPRS.attr(\"KNITRO_PARAM_MSTERMINATE\") = POI_XPRS_KNITRO_PARAM_MSTERMINATE;\n\tXPRS.attr(\"KNITRO_PARAM_MSSTARTPTRANGE\") = POI_XPRS_KNITRO_PARAM_MSSTARTPTRANGE;\n\tXPRS.attr(\"KNITRO_PARAM_INFEASTOL\") = POI_XPRS_KNITRO_PARAM_INFEASTOL;\n\tXPRS.attr(\"KNITRO_PARAM_LINSOLVER\") = POI_XPRS_KNITRO_PARAM_LINSOLVER;\n\tXPRS.attr(\"KNITRO_PARAM_BAR_DIRECTINTERVAL\") = POI_XPRS_KNITRO_PARAM_BAR_DIRECTINTERVAL;\n\tXPRS.attr(\"KNITRO_PARAM_PRESOLVE\") = POI_XPRS_KNITRO_PARAM_PRESOLVE;\n\tXPRS.attr(\"KNITRO_PARAM_PRESOLVE_TOL\") = POI_XPRS_KNITRO_PARAM_PRESOLVE_TOL;\n\tXPRS.attr(\"KNITRO_PARAM_BAR_SWITCHRULE\") = POI_XPRS_KNITRO_PARAM_BAR_SWITCHRULE;\n\tXPRS.attr(\"KNITRO_PARAM_MA_TERMINATE\") = POI_XPRS_KNITRO_PARAM_MA_TERMINATE;\n\tXPRS.attr(\"KNITRO_PARAM_MSSEED\") = POI_XPRS_KNITRO_PARAM_MSSEED;\n\tXPRS.attr(\"KNITRO_PARAM_BAR_RELAXCONS\") = POI_XPRS_KNITRO_PARAM_BAR_RELAXCONS;\n\tXPRS.attr(\"KNITRO_PARAM_SOLTYPE\") = POI_XPRS_KNITRO_PARAM_SOLTYPE;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_METHOD\") = POI_XPRS_KNITRO_PARAM_MIP_METHOD;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_BRANCHRULE\") = POI_XPRS_KNITRO_PARAM_MIP_BRANCHRULE;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_SELECTRULE\") = POI_XPRS_KNITRO_PARAM_MIP_SELECTRULE;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_INTGAPABS\") = POI_XPRS_KNITRO_PARAM_MIP_INTGAPABS;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_INTGAPREL\") = POI_XPRS_KNITRO_PARAM_MIP_INTGAPREL;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_OUTLEVEL\") = POI_XPRS_KNITRO_PARAM_MIP_OUTLEVEL;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_OUTINTERVAL\") = POI_XPRS_KNITRO_PARAM_MIP_OUTINTERVAL;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_DEBUG\") = POI_XPRS_KNITRO_PARAM_MIP_DEBUG;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_IMPLICATNS\") = POI_XPRS_KNITRO_PARAM_MIP_IMPLICATNS;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_GUB_BRANCH\") = POI_XPRS_KNITRO_PARAM_MIP_GUB_BRANCH;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_KNAPSACK\") = POI_XPRS_KNITRO_PARAM_MIP_KNAPSACK;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_ROUNDING\") = POI_XPRS_KNITRO_PARAM_MIP_ROUNDING;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_ROOTALG\") = POI_XPRS_KNITRO_PARAM_MIP_ROOTALG;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_LPALG\") = POI_XPRS_KNITRO_PARAM_MIP_LPALG;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_MAXNODES\") = POI_XPRS_KNITRO_PARAM_MIP_MAXNODES;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_HEURISTIC\") = POI_XPRS_KNITRO_PARAM_MIP_HEURISTIC;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_HEUR_MAXIT\") = POI_XPRS_KNITRO_PARAM_MIP_HEUR_MAXIT;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_PSEUDOINIT\") = POI_XPRS_KNITRO_PARAM_MIP_PSEUDOINIT;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_STRONG_MAXIT\") = POI_XPRS_KNITRO_PARAM_MIP_STRONG_MAXIT;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_STRONG_CANDLIM\") = POI_XPRS_KNITRO_PARAM_MIP_STRONG_CANDLIM;\n\tXPRS.attr(\"KNITRO_PARAM_MIP_STRONG_LEVEL\") = POI_XPRS_KNITRO_PARAM_MIP_STRONG_LEVEL;\n\tXPRS.attr(\"KNITRO_PARAM_PAR_NUMTHREADS\") = POI_XPRS_KNITRO_PARAM_PAR_NUMTHREADS;\n\n\tnb::enum_(XPRS, \"SOLSTATUS\")\n\t .value(\"NOTFOUND\", SOLSTATUS::NOTFOUND)\n\t .value(\"OPTIMAL\", SOLSTATUS::OPTIMAL)\n\t .value(\"FEASIBLE\", SOLSTATUS::FEASIBLE)\n\t .value(\"INFEASIBLE\", SOLSTATUS::INFEASIBLE)\n\t .value(\"UNBOUNDED\", SOLSTATUS::UNBOUNDED);\n\n\tnb::enum_(XPRS, \"SOLVESTATUS\")\n\t .value(\"UNSTARTED\", SOLVESTATUS::UNSTARTED)\n\t .value(\"STOPPED\", SOLVESTATUS::STOPPED)\n\t .value(\"FAILED\", SOLVESTATUS::FAILED)\n\t .value(\"COMPLETED\", SOLVESTATUS::COMPLETED);\n\n\tnb::enum_(XPRS, \"LPSTATUS\")\n\t .value(\"UNSTARTED\", LPSTATUS::UNSTARTED)\n\t .value(\"OPTIMAL\", LPSTATUS::OPTIMAL)\n\t .value(\"INFEAS\", LPSTATUS::INFEAS)\n\t .value(\"CUTOFF\", LPSTATUS::CUTOFF)\n\t .value(\"UNFINISHED\", LPSTATUS::UNFINISHED)\n\t .value(\"UNBOUNDED\", LPSTATUS::UNBOUNDED)\n\t .value(\"CUTOFF_IN_DUAL\", LPSTATUS::CUTOFF_IN_DUAL)\n\t .value(\"UNSOLVED\", LPSTATUS::UNSOLVED)\n\t .value(\"NONCONVEX\", LPSTATUS::NONCONVEX);\n\n\tnb::enum_(XPRS, \"MIPSTATUS\")\n\t .value(\"NOT_LOADED\", MIPSTATUS::NOT_LOADED)\n\t .value(\"LP_NOT_OPTIMAL\", MIPSTATUS::LP_NOT_OPTIMAL)\n\t .value(\"LP_OPTIMAL\", MIPSTATUS::LP_OPTIMAL)\n\t .value(\"NO_SOL_FOUND\", MIPSTATUS::NO_SOL_FOUND)\n\t .value(\"SOLUTION\", MIPSTATUS::SOLUTION)\n\t .value(\"INFEAS\", MIPSTATUS::INFEAS)\n\t .value(\"OPTIMAL\", MIPSTATUS::OPTIMAL)\n\t .value(\"UNBOUNDED\", MIPSTATUS::UNBOUNDED);\n\n\tnb::enum_(XPRS, \"NLPSTATUS\")\n\t .value(\"UNSTARTED\", NLPSTATUS::UNSTARTED)\n\t .value(\"SOLUTION\", NLPSTATUS::SOLUTION)\n\t .value(\"LOCALLY_OPTIMAL\", NLPSTATUS::LOCALLY_OPTIMAL)\n\t .value(\"OPTIMAL\", NLPSTATUS::OPTIMAL)\n\t .value(\"NOSOLUTION\", NLPSTATUS::NOSOLUTION)\n\t .value(\"LOCALLY_INFEASIBLE\", NLPSTATUS::LOCALLY_INFEASIBLE)\n\t .value(\"INFEASIBLE\", NLPSTATUS::INFEASIBLE)\n\t .value(\"UNBOUNDED\", NLPSTATUS::UNBOUNDED)\n\t .value(\"UNFINISHED\", NLPSTATUS::UNFINISHED)\n\t .value(\"UNSOLVED\", NLPSTATUS::UNSOLVED);\n\n\tnb::enum_(XPRS, \"IISSOLSTATUS\")\n\t .value(\"UNSTARTED\", IISSOLSTATUS::UNSTARTED)\n\t .value(\"FEASIBLE\", IISSOLSTATUS::FEASIBLE)\n\t .value(\"COMPLETED\", IISSOLSTATUS::COMPLETED)\n\t .value(\"UNFINISHED\", IISSOLSTATUS::UNFINISHED);\n\n\tnb::enum_(XPRS, \"SOLAVAILABLE\")\n\t .value(\"NOTFOUND\", SOLAVAILABLE::NOTFOUND)\n\t .value(\"OPTIMAL\", SOLAVAILABLE::OPTIMAL)\n\t .value(\"FEASIBLE\", SOLAVAILABLE::FEASIBLE);\n\n\tnb::enum_(XPRS, \"OPTIMIZETYPE\")\n\t .value(\"NONE\", OPTIMIZETYPE::NONE)\n\t .value(\"LP\", OPTIMIZETYPE::LP)\n\t .value(\"MIP\", OPTIMIZETYPE::MIP)\n\t .value(\"LOCAL\", OPTIMIZETYPE::LOCAL)\n\t .value(\"GLOBAL\", OPTIMIZETYPE::GLOBAL);\n\n\t// Define Callbacks context enum\n\tauto to_upper = [](char const *name) {\n\t\tstd::string res(name);\n\t\tfor (char &c : res)\n\t\t\tc = std::toupper(c);\n\t\treturn res;\n\t};\n\tnb::enum_(XPRS, \"CB_CONTEXT\", nb::is_arithmetic())\n\t// Use the callback list to define a value for each callback\n#define XPRSCB_NB_ENUM(ID, NAME, ...) .value(to_upper(#NAME).c_str(), CB_CONTEXT::NAME)\n\t XPRSCB_LIST(XPRSCB_NB_ENUM, XPRSCB_ARG_IGNORE);\n#undef XPRSCB_NB_ENUM\n}\n" }, { "path": "optimizer_version.toml", "content": "Gurobi = \"13.0.0\"\nCOPT = \"8.0.2\"\nMOSEK = \"10.2.0\"\nHiGHS = \"1.12.0\"\nIPOPT = \"3.13.2\"\nXpress = \"9.8\"\nKNITRO = \"15.1.0\"\n" }, { "path": "pyproject.toml", "content": "[build-system]\nrequires = [\"scikit-build-core\", \"nanobind\", \"typing_extensions\"]\nbuild-backend = \"scikit_build_core.build\"\n\n[project]\nname = \"pyoptinterface\"\nversion = \"0.6.1\"\ndescription = \"Python interface to multiple optimization solvers\"\nreadme = \"README.md\"\nrequires-python = \">=3.9\"\nauthors = [{ name = \"Yue Yang\", email = \"metab0t@outlook.com\" }]\nclassifiers = [\n 'Development Status :: 5 - Production/Stable',\n 'Intended Audience :: Science/Research',\n 'Topic :: Scientific/Engineering',\n 'License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)',\n]\n\n[project.urls]\nHomepage = \"https://github.com/metab0t/pyoptinterface\"\n\n[project.optional-dependencies]\nmatrix = [\"numpy\", \"scipy\"]\nhighs = [\"highsbox\"]\nnlp = [\"llvmlite\", \"tccbox\"]\ntest = [\"pytest\", \"numpy\", \"scipy>=1.11.0\", \"highsbox\", \"llvmlite\", \"tccbox\"]\n\n[tool.scikit-build]\neditable.rebuild = true\nbuild-dir = \"build/{wheel_tag}\"\ncmake.build-type = \"Release\"\n# Build stable ABI wheels for CPython 3.12+\nwheel.py-api = \"cp312\"\n\n[tool.scikit-build.cmake.define]\nPYTHON_VERSION = { env = \"PYTHON_VERSION\", default = \"3.9\" }\nCMAKE_FIND_DEBUG_MODE = \"OFF\"\nENABLE_TEST_MAIN = \"OFF\"\n" }, { "path": "scripts/generate_attribute_table.py", "content": "from typing import IO\nfrom pathlib import Path\n\n\nimport pyoptinterface as poi\nfrom pyoptinterface import gurobi, copt, mosek, highs, ipopt\n\n\ndef attribute_support_table(f, attribute_enum):\n results = []\n for attribute in attribute_enum:\n support_get = f(attribute)\n support_set = f(attribute, settable=True)\n results.append((attribute, support_get, support_set))\n return results\n\n\nemoji_map = {True: \"✅\", False: \"❌\"}\n\n\ndef print_table(io: IO[str], results):\n io.write(\"\"\":::{list-table}\n:header-rows: 1\n\n* - Attribute\n - Get\n - Set\n\"\"\")\n\n for attribute, support_get, support_set in results:\n io.write(f\"* - {attribute.name}\\n\")\n io.write(f\" - {emoji_map[support_get]}\\n\")\n io.write(f\" - {emoji_map[support_set]}\\n\")\n\n io.write(\":::\\n\\n\")\n\n\nio_pairs = [\n (gurobi.Model, \"gurobi\"),\n (copt.Model, \"copt\"),\n (mosek.Model, \"mosek\"),\n (highs.Model, \"highs\"),\n (ipopt.Model, \"ipopt\"),\n]\n\nrootdir = Path(__file__).parent.parent\ndocsource_dir = rootdir / \"docs\" / \"source\" / \"attribute\"\n\nfor model, name in io_pairs:\n path = docsource_dir / f\"{name}.md\"\n with open(path, \"w\", encoding=\"utf-8\") as io:\n io.write(f\"### Supported [model attribute](#pyoptinterface.ModelAttribute)\\n\\n\")\n print_table(\n io,\n attribute_support_table(model.supports_model_attribute, poi.ModelAttribute),\n )\n io.write(\n f\"### Supported [variable attribute](#pyoptinterface.VariableAttribute)\\n\\n\"\n )\n print_table(\n io,\n attribute_support_table(\n model.supports_variable_attribute, poi.VariableAttribute\n ),\n )\n io.write(\n f\"### Supported [constraint attribute](#pyoptinterface.ConstraintAttribute)\\n\\n\"\n )\n print_table(\n io,\n attribute_support_table(\n model.supports_constraint_attribute, poi.ConstraintAttribute\n ),\n )\n" }, { "path": "scripts/generate_solver_constants.py", "content": "from typing import IO\nfrom pathlib import Path\n\nimport gurobipy as gp\n\nGRB = gp.GRB\n\nimport coptpy as cp\n\nCOPT = cp.COPT\n\n\ndef value_to_str(value):\n if isinstance(value, str):\n return f'\"{value}\"'\n return str(value)\n\n\ndef extract_gurobi_constants():\n # we want to extract all variables with all UPPERCASE names in dir(GRB)\n GRB_constants = []\n for name in dir(GRB):\n if name.isupper():\n GRB_constants.append(name)\n\n # extract all variables with first letter in UPPERCASE in dir(GRB.Attr) and dir(GRB.Param) and dir(GRB.Callback)\n GRB_Attr_constants = []\n for name in dir(GRB.Attr):\n if name[0].isupper():\n GRB_Attr_constants.append(name)\n\n GRB_Param_constants = []\n for name in dir(GRB.Param):\n if name[0].isupper():\n GRB_Param_constants.append(name)\n\n GRB_Callback_constants = []\n for name in dir(GRB.Callback):\n if name[0].isupper():\n GRB_Callback_constants.append(name)\n\n return {\n \"GRB\": GRB_constants,\n \"GRB.Attr\": GRB_Attr_constants,\n \"GRB.Param\": GRB_Param_constants,\n \"GRB.Callback\": GRB_Callback_constants,\n }\n\n\ndef export_gurobi_constants(io: IO[str], gurobi_constants):\n io.write('nb::module_ GRB = m.def_submodule(\"GRB\");\\n')\n for name in gurobi_constants[\"GRB\"]:\n value = getattr(GRB, name)\n value = value_to_str(value)\n io.write(f'GRB.attr(\"{name}\") = {value};\\n')\n io.write(\"\\n\")\n\n io.write('nb::module_ Attr = GRB.def_submodule(\"Attr\");\\n')\n Attr = GRB.Attr\n for name in gurobi_constants[\"GRB.Attr\"]:\n value = getattr(Attr, name)\n value = value_to_str(value)\n io.write(f'Attr.attr(\"{name}\") = {value};\\n')\n io.write(\"\\n\")\n\n io.write('nb::module_ Param = GRB.def_submodule(\"Param\");\\n')\n Param = GRB.Param\n for name in gurobi_constants[\"GRB.Param\"]:\n value = getattr(Param, name)\n value = value_to_str(value)\n io.write(f'Param.attr(\"{name}\") = {value};\\n')\n io.write(\"\\n\")\n\n io.write('nb::module_ Callback = GRB.def_submodule(\"Callback\");\\n')\n Callback = GRB.Callback\n for name in gurobi_constants[\"GRB.Callback\"]:\n value = getattr(Callback, name)\n value = value_to_str(value)\n io.write(f'Callback.attr(\"{name}\") = {value};\\n')\n\n\ndef extract_copt_constants():\n # dir(COPT)\n COPT_constants = []\n for name in dir(COPT):\n if name.isupper():\n COPT_constants.append(name)\n\n # dir(COPT.Attr)\n COPT_Attr_constants = []\n for name in dir(COPT.Attr):\n if name[0].isupper():\n COPT_Attr_constants.append(name)\n\n # dir(COPT.Param)\n COPT_Param_constants = []\n for name in dir(COPT.Param):\n if name[0].isupper():\n COPT_Param_constants.append(name)\n\n # dir(COPT.Info)\n COPT_Info_constants = []\n for name in dir(COPT.Info):\n if name[0].isupper():\n COPT_Info_constants.append(name)\n\n # dir(COPT.CbInfo)\n COPT_CbInfo_constants = []\n for name in dir(COPT.CbInfo):\n if name[0].isupper():\n COPT_CbInfo_constants.append(name)\n\n return {\n \"COPT\": COPT_constants,\n \"COPT.Attr\": COPT_Attr_constants,\n \"COPT.Param\": COPT_Param_constants,\n \"COPT.Info\": COPT_Info_constants,\n \"COPT.CbInfo\": COPT_CbInfo_constants,\n }\n\n\ndef export_copt_constants(io: IO[str], copt_constants):\n io.write('nb::module_ COPT = m.def_submodule(\"COPT\");\\n')\n for name in copt_constants[\"COPT\"]:\n value = getattr(COPT, name)\n value = value_to_str(value)\n io.write(f'COPT.attr(\"{name}\") = {value};\\n')\n io.write(\"\\n\")\n\n io.write('nb::module_ Attr = COPT.def_submodule(\"Attr\");\\n')\n Attr = COPT.Attr\n for name in copt_constants[\"COPT.Attr\"]:\n value = getattr(Attr, name)\n value = value_to_str(value)\n io.write(f'Attr.attr(\"{name}\") = {value};\\n')\n io.write(\"\\n\")\n\n io.write('nb::module_ Param = COPT.def_submodule(\"Param\");\\n')\n Param = COPT.Param\n for name in copt_constants[\"COPT.Param\"]:\n value = getattr(Param, name)\n value = value_to_str(value)\n io.write(f'Param.attr(\"{name}\") = {value};\\n')\n io.write(\"\\n\")\n\n io.write('nb::module_ Info = COPT.def_submodule(\"Info\");\\n')\n Info = COPT.Info\n for name in copt_constants[\"COPT.Info\"]:\n value = getattr(Info, name)\n value = value_to_str(value)\n io.write(f'Info.attr(\"{name}\") = {value};\\n')\n io.write(\"\\n\")\n\n io.write('nb::module_ CbInfo = COPT.def_submodule(\"CbInfo\");\\n')\n CbInfo = COPT.CbInfo\n for name in copt_constants[\"COPT.CbInfo\"]:\n value = getattr(CbInfo, name)\n value = value_to_str(value)\n io.write(f'CbInfo.attr(\"{name}\") = {value};\\n')\n\n\nif __name__ == \"__main__\":\n current_dir = Path(__file__).parent.resolve()\n\n with open(current_dir / \"gurobi_constants.txt\", \"w\") as io:\n gurobi_constants = extract_gurobi_constants()\n export_gurobi_constants(io, gurobi_constants)\n print(\"Done!\")\n\n with open(current_dir / \"copt_constants.txt\", \"w\") as io:\n copt_constants = extract_copt_constants()\n export_copt_constants(io, copt_constants)\n print(\"Done!\")\n" }, { "path": "skills/pyoptinterface-expert/SKILL.md", "content": "---\nname: pyoptinterface-expert\ndescription: Specialized guidance for modeling mathematical optimization problems using the pyoptinterface_native library. Use when building optimization models (LP, QP, MIP, NLP), interfacing with solvers (Gurobi, HiGHS, Ipopt, etc.), and performing matrix-based or nonlinear modeling in Python.\n---\n\n# PyOptInterface Expert Skill\n\nThis skill provides expert guidance for using `pyoptinterface` (POI), a high-performance Python modeling interface for mathematical optimization solvers.\n\n## Core Concepts\n\nPOI follows a common modeling pattern:\n1. Create a solver-specific model (e.g., `poi.highs.Model()`).\n2. Add variables using `model.add_variable()` or `model.add_m_variables()`.\n3. Set the objective using `model.set_objective()`.\n4. Add constraints using `model.add_linear_constraint()`, `model.add_quadratic_constraint()`, or `model.add_nl_constraint()`.\n5. Call `model.optimize()` and retrieve results.\n\n## Key Workflows\n\n### 1. Basic Modeling\n```python\nimport pyoptinterface as poi\nfrom pyoptinterface import highs\n\nmodel = highs.Model()\nx = model.add_variable(lb=0, name=\"x\")\ny = model.add_variable(lb=0, name=\"y\")\n\nmodel.set_objective(x + 2 * y, poi.ObjectiveSense.Minimize)\nmodel.add_linear_constraint(x + y >= 10, name=\"c1\")\n\nmodel.optimize()\nstatus = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\nif status == poi.TerminationStatusCode.OPTIMAL:\n print(f\"x: {model.get_variable_attribute(x, poi.VariableAttribute.Value)}\")\n```\n\n### 2. Matrix-based Modeling\nUse `add_m_variables` and `add_m_linear_constraints` for performance with NumPy/SciPy.\n```python\nimport numpy as np\nx = model.add_m_variables((10,), lb=0)\nA = np.random.rand(5, 10)\nb = np.ones(5)\nmodel.add_m_linear_constraints(A, x, poi.Leq, b)\n```\n\n### 3. Nonlinear Modeling\nNonlinear expressions must be wrapped in `nl.graph()` context.\n```python\nfrom pyoptinterface import nl\nwith nl.graph():\n model.add_nl_objective(x * x + nl.sin(y))\n model.add_nl_constraint(x * y >= 5)\n```\n\n## Reference Documentation\n- API Reference: [references/api.md](references/api.md)\n- Modeling Examples: [references/examples.md](references/examples.md)\n\n## Best Practices\n- Use `poi.quicksum()` for large summations.\n- Check `TerminationStatus` before accessing variable values.\n- For large-scale models, prefer the Matrix API (`add_m_...`).\n" }, { "path": "skills/pyoptinterface-expert/references/api.md", "content": "# API Reference\n\n## Model Classes\nImported from solver submodules:\n- `pyoptinterface.highs.Model`\n- `pyoptinterface.gurobi.Model`\n- `pyoptinterface.copt.Model`\n- `pyoptinterface.ipopt.Model`\n- `pyoptinterface.knitro.Model`\n- `pyoptinterface.mosek.Model`\n- `pyoptinterface.xpress.Model`\n\n## Core Methods\n### Model\n- `add_variable(lb, ub, domain, name, start)`: Add a single variable.\n- `add_m_variables(shape, lb, ub, domain, name, start)`: Add a NumPy array of variables.\n- `add_linear_constraint(expr, sense, rhs, name)`: Add a linear constraint.\n- `add_quadratic_constraint(expr, sense, rhs, name)`: Add a quadratic constraint.\n- `add_m_linear_constraints(A, x, sense, rhs)`: Add constraints in matrix form $Ax \\sim b$.\n- `add_nl_constraint(expr)`: Add a nonlinear constraint (within `nl.graph()`).\n- `set_objective(expr, sense)`: Set objective function.\n- `set_nl_objective(expr, sense)`: Set nonlinear objective.\n- `optimize()`: Solve the model.\n- `get_model_attribute(attr)`: Get model information (Status, ObjVal, etc.).\n- `get_variable_attribute(v, attr)`: Get variable information (Value, ReducedCost, etc.).\n- `set_variable_attribute(v, attr, value)`: Set variable bounds, starts, etc.\n- `get_value(expr)`: Evaluate expression at the current solution.\n\n## Enums\n### `poi.VariableDomain`\n- `Continuous`\n- `Integer`\n- `Binary`\n\n### `poi.ConstraintSense`\n- `Equal` (or `poi.Eq`)\n- `LessEqual` (or `poi.Leq`)\n- `GreaterEqual` (or `poi.Geq`)\n\n### `poi.ObjectiveSense`\n- `Minimize`\n- `Maximize`\n- `Feasibility`\n\n### `poi.TerminationStatusCode`\n- `OPTIMAL`\n- `INFEASIBLE`\n- `UNBOUNDED`\n- `TIME_LIMIT`\n- `ITERATION_LIMIT`\n\n### `poi.ModelAttribute`\n- `TerminationStatus`\n- `ObjectiveValue`\n- `SolveTimeSec`\n- `RelativeGap`\n- `Silent`\n\n### `poi.VariableAttribute`\n- `Value`\n- `Name`\n- `LowerBound`\n- `UpperBound`\n- `Domain`\n- `PrimalStart`\n" }, { "path": "skills/pyoptinterface-expert/references/examples.md", "content": "# Modeling Examples\n\n## 1. Knapsack Problem (MIP)\nMaximize total value given a weight limit.\n```python\nimport pyoptinterface as poi\nfrom pyoptinterface import highs\n\nvalues = [10, 15, 20, 8]\nweights = [2, 3, 5, 2]\nlimit = 8\n\nmodel = highs.Model()\nx = model.add_m_variables(len(values), domain=poi.VariableDomain.Binary)\n\nmodel.set_objective(poi.quicksum(values[i] * x[i] for i in range(len(values))), poi.ObjectiveSense.Maximize)\nmodel.add_linear_constraint(poi.quicksum(weights[i] * x[i] for i in range(len(weights))) <= limit)\n\nmodel.optimize()\nif model.get_model_attribute(poi.ModelAttribute.TerminationStatus) == poi.TerminationStatusCode.OPTIMAL:\n print(\"Selected items:\", [i for i in range(len(values)) if model.get_variable_attribute(x[i], poi.VariableAttribute.Value) > 0.5])\n```\n\n## 2. Sparse Matrix Model (LP)\nSolve $Ax \\le b$ using the matrix API.\n```python\nimport numpy as np\nfrom scipy import sparse\nimport pyoptinterface as poi\nfrom pyoptinterface import highs\n\nm, n = 100, 500\nA = sparse.random(m, n, density=0.1)\nb = np.random.rand(m)\nc = np.random.rand(n)\n\nmodel = highs.Model()\nx = model.add_m_variables(n, lb=0)\n\nmodel.set_objective(poi.quicksum(c[i] * x[i] for i in range(n)))\nmodel.add_m_linear_constraints(A, x, poi.Leq, b)\n\nmodel.optimize()\n```\n\n## 3. Nonlinear Rosenbrock Function (NLP)\nMinimize $f(x, y) = (1-x)^2 + 100(y-x^2)^2$.\n```python\nimport pyoptinterface as poi\nfrom pyoptinterface import ipopt, nl\n\nmodel = ipopt.Model()\nx = model.add_variable(lb=-5, ub=5)\ny = model.add_variable(lb=-5, ub=5)\n\nwith nl.graph():\n model.add_nl_objective((1 - x)**2 + 100 * (y - x**2)**2, poi.ObjectiveSense.Minimize)\n\nmodel.optimize()\nprint(f\"Optimal x: {model.get_value(x)}, y: {model.get_value(y)}\")\n```\n" }, { "path": "src/pyoptinterface/__init__.py", "content": "from pyoptinterface._src.core_ext import (\n VariableIndex,\n ConstraintIndex,\n ExprBuilder,\n VariableDomain,\n ConstraintSense,\n ConstraintType,\n SOSType,\n ObjectiveSense,\n ScalarAffineFunction,\n ScalarQuadraticFunction,\n)\n\nfrom pyoptinterface._src.attributes import (\n VariableAttribute,\n ModelAttribute,\n TerminationStatusCode,\n ResultStatusCode,\n ConstraintAttribute,\n)\n\nfrom pyoptinterface._src.tupledict import (\n tupledict,\n make_tupledict,\n)\n\nfrom pyoptinterface._src.aml import quicksum, quicksum_\n\n# Alias of ConstraintSense\nEq = ConstraintSense.Equal\n\"\"\"Alias of `ConstraintSense.Equal` for equality constraints.\n\"\"\"\nLeq = ConstraintSense.LessEqual\n\"\"\"Alias of `ConstraintSense.LessEqual` for less-than-or-equal-to constraints.\n\"\"\"\nGeq = ConstraintSense.GreaterEqual\n\"\"\"Alias of `ConstraintSense.GreaterEqual` for greater-than-or-equal-to constraints.\n\"\"\"\n\nfrom pyoptinterface._src.monkeypatch import _monkeypatch_all\n\n_monkeypatch_all()\n\n__all__ = [\n \"VariableIndex\",\n \"ConstraintIndex\",\n \"ExprBuilder\",\n \"VariableDomain\",\n \"ConstraintSense\",\n \"ConstraintType\",\n \"SOSType\",\n \"ObjectiveSense\",\n \"ScalarAffineFunction\",\n \"ScalarQuadraticFunction\",\n \"VariableAttribute\",\n \"ModelAttribute\",\n \"TerminationStatusCode\",\n \"ResultStatusCode\",\n \"ConstraintAttribute\",\n \"tupledict\",\n \"make_tupledict\",\n \"quicksum\",\n \"quicksum_\",\n \"Eq\",\n \"Leq\",\n \"Geq\",\n]\n" }, { "path": "src/pyoptinterface/_src/__init__.py", "content": "" }, { "path": "src/pyoptinterface/_src/aml.py", "content": "from .core_ext import ExprBuilder, VariableDomain\nfrom .tupledict import make_tupledict\n\nfrom collections.abc import Collection\nfrom typing import Tuple, Union, Optional\n\n\ndef make_variable_ndarray(\n model,\n shape: Union[Tuple[int, ...], int],\n domain: Optional[VariableDomain] = None,\n lb: Optional[float] = None,\n ub: Optional[float] = None,\n name: Optional[str] = None,\n start: Optional[float] = None,\n):\n import numpy as np\n\n if isinstance(shape, int):\n shape = (shape,)\n\n variables = np.empty(shape, dtype=object)\n\n kw_args = dict()\n if domain is not None:\n kw_args[\"domain\"] = domain\n if lb is not None:\n kw_args[\"lb\"] = lb\n if ub is not None:\n kw_args[\"ub\"] = ub\n if start is not None:\n kw_args[\"start\"] = start\n\n for index in np.ndindex(shape):\n if name is not None:\n suffix = str(index)\n kw_args[\"name\"] = f\"{name}{suffix}\"\n variables[index] = model.add_variable(**kw_args)\n\n return variables\n\n\ndef make_variable_tupledict(\n model,\n *coords: Collection,\n domain: Optional[VariableDomain] = None,\n lb: Optional[float] = None,\n ub: Optional[float] = None,\n name: Optional[str] = None,\n start: Optional[float] = None,\n):\n kw_args = dict()\n if domain is not None:\n kw_args[\"domain\"] = domain\n if lb is not None:\n kw_args[\"lb\"] = lb\n if ub is not None:\n kw_args[\"ub\"] = ub\n if start is not None:\n kw_args[\"start\"] = start\n\n def f(*args):\n if name is not None:\n suffix = str(args)\n kw_args[\"name\"] = f\"{name}{suffix}\"\n return model.add_variable(**kw_args)\n\n td = make_tupledict(*coords, rule=f)\n return td\n\n\n# def make_nd_variable_batch(\n# model,\n# *coords: Collection,\n# domain=None,\n# lb=None,\n# ub=None,\n# name=None,\n# ):\n# assert model.supports_batch_add_variables()\n#\n# kw_args = dict()\n# if domain is not None:\n# kw_args[\"domain\"] = domain\n# if lb is not None:\n# kw_args[\"lb\"] = lb\n# if ub is not None:\n# kw_args[\"ub\"] = ub\n#\n# N = math.prod(len(c) for c in coords)\n#\n# start_vi = model.add_variables(N, **kw_args)\n# start_index = start_vi.index\n#\n# kvs = []\n# assert len(coords) > 0\n# for i, coord in enumerate(product(*coords)):\n# coord = tuple(flatten_tuple(coord))\n# value = VariableIndex(start_index + i)\n# if len(coord) == 1:\n# coord = coord[0]\n# if value is not None:\n# kvs.append((coord, value))\n#\n# suffix = str(coord)\n# if name is not None:\n# model.set_variable_name(value, f\"{name}{suffix}\")\n# return tupledict(kvs)\n\n\ndef quicksum_(expr: ExprBuilder, terms, f=None):\n import numpy as np\n\n if isinstance(terms, dict):\n iter = terms.values()\n elif isinstance(terms, np.ndarray):\n iter = terms.flat\n else:\n iter = terms\n if f:\n iter = map(f, iter)\n for v in iter:\n expr += v\n\n\ndef quicksum(terms, f=None):\n expr = ExprBuilder()\n quicksum_(expr, terms, f)\n return expr\n" }, { "path": "src/pyoptinterface/_src/attributes.py", "content": "from enum import Enum, auto\nfrom .core_ext import VariableDomain, ObjectiveSense\n\n\nclass VariableAttribute(Enum):\n Value = auto()\n LowerBound = auto()\n UpperBound = auto()\n Domain = auto()\n PrimalStart = auto()\n Name = auto()\n IISLowerBound = auto()\n IISUpperBound = auto()\n ReducedCost = auto()\n\n\nvar_attr_type_map = {\n VariableAttribute.Value: float,\n VariableAttribute.LowerBound: float,\n VariableAttribute.UpperBound: float,\n VariableAttribute.PrimalStart: float,\n VariableAttribute.Domain: VariableDomain,\n VariableAttribute.Name: str,\n VariableAttribute.IISLowerBound: bool,\n VariableAttribute.IISUpperBound: bool,\n VariableAttribute.ReducedCost: float,\n}\n\n\nclass ModelAttribute(Enum):\n # ModelLike API\n # NumberOfConstraints = auto()\n # NumberOfVariables = auto()\n Name = auto()\n ObjectiveSense = auto()\n\n # AbstractOptimizer API\n DualStatus = auto()\n PrimalStatus = auto()\n RawStatusString = auto()\n TerminationStatus = auto()\n BarrierIterations = auto()\n DualObjectiveValue = auto()\n NodeCount = auto()\n NumberOfThreads = auto()\n ObjectiveBound = auto()\n ObjectiveValue = auto()\n RelativeGap = auto()\n Silent = auto()\n SimplexIterations = auto()\n SolverName = auto()\n SolverVersion = auto()\n SolveTimeSec = auto()\n TimeLimitSec = auto()\n # ObjectiveLimit = auto()\n\n\nclass ResultStatusCode(Enum):\n NO_SOLUTION = auto()\n FEASIBLE_POINT = auto()\n NEARLY_FEASIBLE_POINT = auto()\n INFEASIBLE_POINT = auto()\n INFEASIBILITY_CERTIFICATE = auto()\n NEARLY_INFEASIBILITY_CERTIFICATE = auto()\n REDUCTION_CERTIFICATE = auto()\n NEARLY_REDUCTION_CERTIFICATE = auto()\n UNKNOWN_RESULT_STATUS = auto()\n OTHER_RESULT_STATUS = auto()\n\n\nclass TerminationStatusCode(Enum):\n OPTIMIZE_NOT_CALLED = auto()\n OPTIMAL = auto()\n INFEASIBLE = auto()\n DUAL_INFEASIBLE = auto()\n LOCALLY_SOLVED = auto()\n LOCALLY_INFEASIBLE = auto()\n INFEASIBLE_OR_UNBOUNDED = auto()\n ALMOST_OPTIMAL = auto()\n ALMOST_INFEASIBLE = auto()\n ALMOST_DUAL_INFEASIBLE = auto()\n ALMOST_LOCALLY_SOLVED = auto()\n ITERATION_LIMIT = auto()\n TIME_LIMIT = auto()\n NODE_LIMIT = auto()\n SOLUTION_LIMIT = auto()\n MEMORY_LIMIT = auto()\n OBJECTIVE_LIMIT = auto()\n NORM_LIMIT = auto()\n OTHER_LIMIT = auto()\n SLOW_PROGRESS = auto()\n NUMERICAL_ERROR = auto()\n INVALID_MODEL = auto()\n INVALID_OPTION = auto()\n INTERRUPTED = auto()\n OTHER_ERROR = auto()\n\n\nmodel_attr_type_map = {\n ModelAttribute.Name: str,\n ModelAttribute.ObjectiveSense: ObjectiveSense,\n ModelAttribute.DualStatus: ResultStatusCode,\n ModelAttribute.PrimalStatus: ResultStatusCode,\n ModelAttribute.RawStatusString: str,\n ModelAttribute.TerminationStatus: TerminationStatusCode,\n ModelAttribute.BarrierIterations: int,\n ModelAttribute.DualObjectiveValue: float,\n ModelAttribute.NodeCount: int,\n ModelAttribute.NumberOfThreads: int,\n ModelAttribute.ObjectiveBound: float,\n ModelAttribute.ObjectiveValue: float,\n ModelAttribute.RelativeGap: float,\n ModelAttribute.Silent: bool,\n ModelAttribute.SimplexIterations: int,\n ModelAttribute.SolverName: str,\n ModelAttribute.SolverVersion: str,\n ModelAttribute.SolveTimeSec: float,\n ModelAttribute.TimeLimitSec: float,\n}\n\n\nclass ConstraintAttribute(Enum):\n Name = auto()\n # PrimalStart = auto()\n # DualStart = auto()\n Primal = auto()\n Dual = auto()\n # BasisStatus = auto()\n IIS = auto()\n\n\nconstraint_attr_type_map = {\n ConstraintAttribute.Name: str,\n ConstraintAttribute.Primal: float,\n ConstraintAttribute.Dual: float,\n ConstraintAttribute.IIS: bool,\n}\n" }, { "path": "src/pyoptinterface/_src/codegen_c.py", "content": "from .cppad_interface_ext import (\n graph_op,\n)\nfrom .cpp_graph_iter import cpp_graph_iterator\n\nfrom typing import IO\n\nop2name = {\n graph_op.abs: \"fabs\",\n graph_op.acos: \"acos\",\n graph_op.asin: \"asin\",\n graph_op.atan: \"atan\",\n graph_op.cos: \"cos\",\n graph_op.exp: \"exp\",\n graph_op.log: \"log\",\n graph_op.pow: \"pow\",\n graph_op.sign: \"sign\",\n graph_op.sin: \"sin\",\n graph_op.sqrt: \"sqrt\",\n graph_op.tan: \"tan\",\n graph_op.add: \"+\",\n graph_op.sub: \"-\",\n graph_op.mul: \"*\",\n graph_op.div: \"/\",\n graph_op.azmul: \"*\",\n graph_op.neg: \"-\",\n}\n\ncompare_ops = set([graph_op.cexp_eq, graph_op.cexp_le, graph_op.cexp_lt])\n\ncompare_ops_string = {\n graph_op.cexp_eq: \"==\",\n graph_op.cexp_le: \"<=\",\n graph_op.cexp_lt: \"<\",\n}\n\n\ndef generate_csrc_prelude(io: IO[str]):\n io.write(\"\"\"// includes\n#include \n\n// typedefs\ntypedef double float_point_t;\n\n// declare mathematical functions\n#define UNARY(f) extern float_point_t f(float_point_t x)\n#define BINARY(f) extern float_point_t f(float_point_t x, float_point_t y)\n\n// unary functions\nUNARY(fabs);\nUNARY(acos);\nUNARY(asin);\nUNARY(atan);\nUNARY(cos);\nUNARY(exp);\nUNARY(log);\nUNARY(sin);\nUNARY(sqrt);\nUNARY(tan);\n\n// binary functions\nBINARY(pow);\n\n// externals\n// azmul\nfloat_point_t azmul(float_point_t x, float_point_t y)\n{\n if( x == 0.0 ) return 0.0;\n return x * y;\n}\n\n// sign\nfloat_point_t sign(float_point_t x)\n{\t\n if( x > 0.0 ) return 1.0;\n if( x == 0.0 ) return 0.0;\n return -1.0;\n}\n\"\"\")\n\n\ndef generate_csrc_from_graph(\n io: IO[str],\n graph_obj,\n name: str,\n np: int = 0,\n hessian_lagrange: bool = False,\n nw: int = 0,\n indirect_x: bool = False,\n indirect_p: bool = False,\n indirect_w: bool = False,\n indirect_y: bool = False,\n add_y: bool = False,\n):\n n_dynamic_ind = graph_obj.n_dynamic_ind\n n_variable_ind = graph_obj.n_variable_ind\n n_constant = graph_obj.n_constant\n n_dependent = graph_obj.n_dependent\n\n # Simple case\n # 0 -> dummy\n # [1, 1 + np) -> *p\n # [1 + np, 1 + n_dynamic_ind + n_variable_ind) -> *x\n # [1 + n_dynamic_ind + n_variable_ind, 1 + n_dynamic_ind + n_variable_ind + n_constant) -> c[...]\n # [1 + n_dynamic_ind + n_variable_ind + n_constant, ...) -> v[...]\n\n # Hessian lagragian case\n # 0 -> dummy\n # [1, 1 + np) -> *p\n # [1 + np, 1 + np + nw) -> *w\n # [1 + np + nw, 1 + n_dynamic_ind + n_variable_ind) -> *x\n # [1 + n_dynamic_ind + n_variable_ind, 1 + n_dynamic_ind + n_variable_ind + n_constant) -> c[...]\n # [1 + n_dynamic_ind + n_variable_ind + n_constant, ...) -> v[...]\n\n n_node = 0\n for graph_iter in cpp_graph_iterator(graph_obj):\n n_node += graph_iter.n_result\n\n has_parameter = np > 0\n\n function_args_signature = [\"const float_point_t* x\"]\n if has_parameter:\n function_args_signature.append(\"const float_point_t* p\")\n if hessian_lagrange:\n function_args_signature.append(\"const float_point_t* w\")\n function_args_signature.append(\"float_point_t* y\")\n if indirect_x:\n function_args_signature.append(\"const int* xi\")\n if has_parameter and indirect_p:\n function_args_signature.append(\"const int* pi\")\n if hessian_lagrange and indirect_w:\n function_args_signature.append(\"const int* wi\")\n if indirect_y:\n function_args_signature.append(\"const int* yi\")\n\n function_args = \", \".join(function_args_signature)\n\n function_prototype = f\"\"\"\nvoid {name}(\n {function_args}\n)\n\"\"\"\n io.write(function_prototype)\n\n if not hessian_lagrange:\n nx = n_dynamic_ind + n_variable_ind - np\n else:\n nx = n_dynamic_ind + n_variable_ind - np - nw\n ny = n_dependent\n io.write(f\"\"\"{{\n // begin function body\n\n // size checks\n // const size_t nx = {nx};\n // const size_t np = {np};\n // const size_t ny = {ny};\n\"\"\")\n if hessian_lagrange:\n io.write(f\" // const size_t nw = {nw};\\n\")\n\n io.write(f\"\"\"\n // declare variables\n float_point_t v[{n_node}];\n \"\"\")\n\n nc = n_constant\n if nc > 0:\n cs = (graph_obj.constant_vec_get(i) for i in range(nc))\n cs_str = \", \".join(f\"{c}\" for c in cs)\n io.write(f\"\"\"\n // constants\n // set c[i] for i = 0, ..., nc-1\n // nc = {nc}\n static const float_point_t c[{nc}] = {{\n {cs_str}\n }};\n\"\"\")\n\n n_result_node = n_node\n io.write(f\"\"\"\n // result nodes\n // set v[i] for i = 0, ..., n_result_node-1\n // n_result_node = {n_result_node}\n\"\"\")\n\n def get_node_name(node: int) -> str:\n if node < 1:\n raise ValueError(f\"Invalid node: {node}\")\n if node < 1 + np:\n index = node - 1\n if indirect_p:\n return f\"p[pi[{index}]]\"\n else:\n return f\"p[{index}]\"\n elif node < 1 + n_dynamic_ind + n_variable_ind:\n if hessian_lagrange:\n if node < 1 + np + nw:\n index = node - 1 - np\n if indirect_w:\n return f\"w[wi[{index}]]\"\n else:\n return f\"w[{index}]\"\n else:\n index = node - 1 - np - nw\n if indirect_x:\n return f\"x[xi[{index}]]\"\n else:\n return f\"x[{index}]\"\n else:\n index = node - 1 - np\n if indirect_x:\n return f\"x[xi[{index}]]\"\n else:\n return f\"x[{index}]\"\n elif node < 1 + n_dynamic_ind + n_variable_ind + n_constant:\n index = node - 1 - n_dynamic_ind - n_variable_ind\n return f\"c[{index}]\"\n else:\n node = node - 1 - n_dynamic_ind - n_variable_ind - n_constant\n assert node < n_node\n return f\"v[{node}]\"\n\n result_node = 0\n\n infix_operators = set([\"+\", \"-\", \"*\", \"/\"])\n\n for iter in cpp_graph_iterator(graph_obj):\n op = iter.op\n n_result = iter.n_result\n args = iter.args\n\n assert n_result == 1\n\n n_arg = len(args)\n\n op_name = op2name.get(op, None)\n if op_name is not None:\n if n_arg == 1:\n arg1 = get_node_name(args[0])\n io.write(f\" v[{result_node}] = {op_name}({arg1});\\n\")\n elif n_arg == 2:\n arg1 = get_node_name(args[0])\n arg2 = get_node_name(args[1])\n if op_name in infix_operators:\n io.write(f\" v[{result_node}] = {arg1} {op_name} {arg2};\\n\")\n else:\n io.write(f\" v[{result_node}] = {op_name}({arg1}, {arg2});\\n\")\n else:\n message = f\"Unknown n_arg: {n_arg} for op_enum: {op}\\n\"\n raise ValueError(message)\n elif op in compare_ops:\n cmp_op = compare_ops_string[op]\n assert n_arg == 4\n predicate = get_node_name(args[0])\n target = get_node_name(args[1])\n then_value = get_node_name(args[2])\n else_value = get_node_name(args[3])\n io.write(\n f\" v[{result_node}] = {predicate} {cmp_op} {target} ? {then_value} : {else_value};\\n\"\n )\n else:\n message = f\"Unknown name for op_enum: {op}\\n\"\n debug_context = f\"name: {name}\\nfull graph:\\n{str(graph_obj)}\"\n raise ValueError(message + debug_context)\n\n result_node += n_result\n\n io.write(\"\"\"\n // dependent variables\n // set y[i] for i = 0, ny-1\n\"\"\")\n\n op = \"=\"\n if add_y:\n op = \"+=\"\n for i in range(ny):\n node = graph_obj.dependent_vec_get(i)\n node_name = get_node_name(node)\n if indirect_y:\n assignment = f\" y[yi[{i}]] {op} {node_name};\\n\"\n else:\n assignment = f\" y[{i}] {op} {node_name};\\n\"\n io.write(assignment)\n\n io.write(\"\"\"\n // end function body\n}\n\"\"\")\n" }, { "path": "src/pyoptinterface/_src/codegen_llvm.py", "content": "from .cppad_interface_ext import (\n graph_op,\n)\nfrom .cpp_graph_iter import cpp_graph_iterator\nfrom llvmlite import ir\n\nD = ir.DoubleType()\nD_PTR = ir.PointerType(D)\nI = ir.IntType(32)\nI_PTR = ir.PointerType(I)\n\n\ndef create_azmul(module: ir.Module):\n # Define and create the azmul function\n azmul_func_type = ir.FunctionType(D, [D, D])\n azmul_func = ir.Function(module, azmul_func_type, name=\"azmul\")\n azmul_func.attributes.add(\"alwaysinline\")\n x, y = azmul_func.args\n x.name = \"x\"\n y.name = \"y\"\n\n block = azmul_func.append_basic_block(name=\"entry\")\n builder = ir.IRBuilder(block)\n\n # Implement the azmul logic\n with builder.if_else(builder.fcmp_unordered(\"==\", x, D(0.0))) as (\n then,\n otherwise,\n ):\n with then:\n builder.ret(D(0.0))\n with otherwise:\n result = builder.fmul(x, y)\n builder.ret(result)\n builder.unreachable()\n\n\ndef create_sign(module: ir.Module):\n # Define and create the sign function\n sign_func_type = ir.FunctionType(D, [D])\n sign_func = ir.Function(module, sign_func_type, name=\"sign\")\n sign_func.attributes.add(\"alwaysinline\")\n x = sign_func.args[0]\n x.name = \"x\"\n\n block = sign_func.append_basic_block(name=\"entry\")\n builder = ir.IRBuilder(block)\n\n # Implement the sign logic\n with builder.if_else(builder.fcmp_ordered(\">\", x, D(0.0))) as (\n then_positive,\n otherwise,\n ):\n with then_positive:\n builder.ret(D(1.0))\n with otherwise:\n with builder.if_else(builder.fcmp_ordered(\"==\", x, D(0.0))) as (\n then_zero,\n otherwise_negative,\n ):\n with then_zero:\n builder.ret(D(0.0))\n with otherwise_negative:\n builder.ret(D(-1.0))\n builder.unreachable()\n\n\ndef create_direct_load_store(module: ir.Module):\n # Define and create the load_direct function\n # D load_directly(D_PTR, I)\n # returns ptr[idx_ptr[idx]]\n load_direct_func_type = ir.FunctionType(D, [D_PTR, I])\n load_direct_func = ir.Function(module, load_direct_func_type, name=\"load_direct\")\n load_direct_func.attributes.add(\"alwaysinline\")\n ptr, idx = load_direct_func.args\n ptr.name = \"ptr\"\n idx.name = \"idx\"\n\n block = load_direct_func.append_basic_block(name=\"entry\")\n builder = ir.IRBuilder(block)\n\n # Implement the load_direct logic\n ptr = builder.gep(ptr, [idx], name=\"gep_ptr\")\n val = builder.load(ptr, name=\"val\")\n builder.ret(val)\n\n # Define and create the store_direct function\n # void store_directly(D_PTR, I, D)\n # ptr[idx] = val\n store_direct_func_type = ir.FunctionType(ir.VoidType(), [D_PTR, I, D])\n store_direct_func = ir.Function(module, store_direct_func_type, name=\"store_direct\")\n store_direct_func.attributes.add(\"alwaysinline\")\n ptr, idx, val = store_direct_func.args\n ptr.name = \"ptr\"\n idx.name = \"idx\"\n val.name = \"val\"\n\n block = store_direct_func.append_basic_block(name=\"entry\")\n builder = ir.IRBuilder(block)\n\n # Implement the store_direct logic\n ptr = builder.gep(ptr, [idx], name=\"gep_ptr\")\n builder.store(val, ptr)\n builder.ret_void()\n\n # Define and create the add_store_direct function\n # void add_store_directly(D_PTR, I, D)\n # ptr[idx] += val\n add_store_direct_func_type = ir.FunctionType(ir.VoidType(), [D_PTR, I, D])\n add_store_direct_func = ir.Function(\n module, add_store_direct_func_type, name=\"add_store_direct\"\n )\n add_store_direct_func.attributes.add(\"alwaysinline\")\n ptr, idx, val = add_store_direct_func.args\n ptr.name = \"ptr\"\n idx.name = \"idx\"\n val.name = \"val\"\n\n block = add_store_direct_func.append_basic_block(name=\"entry\")\n builder = ir.IRBuilder(block)\n\n # Implement the add_store_direct logic\n ptr = builder.gep(ptr, [idx], name=\"gep_ptr\")\n old_val = builder.load(ptr, name=\"old_val\")\n new_val = builder.fadd(old_val, val, name=\"new_val\")\n builder.store(new_val, ptr)\n builder.ret_void()\n\n\ndef create_indirect_load_store(module: ir.Module):\n # Define and create the load_indirect function\n # D load_indirectly(D_PTR, I_PTR, I)\n # returns ptr[idx_ptr[idx]]\n load_indirect_func_type = ir.FunctionType(D, [D_PTR, I_PTR, I])\n load_indirect_func = ir.Function(\n module, load_indirect_func_type, name=\"load_indirect\"\n )\n load_indirect_func.attributes.add(\"alwaysinline\")\n ptr, idx_ptr, idx = load_indirect_func.args\n ptr.name = \"ptr\"\n idx_ptr.name = \"idx_ptr\"\n idx.name = \"idx\"\n\n block = load_indirect_func.append_basic_block(name=\"entry\")\n builder = ir.IRBuilder(block)\n\n # Implement the load_indirect logic\n idx = builder.gep(idx_ptr, [idx], name=\"gep_idx\")\n idx = builder.load(idx, name=\"real_idx\")\n ptr = builder.gep(ptr, [idx], name=\"gep_ptr\")\n val = builder.load(ptr, name=\"val\")\n builder.ret(val)\n\n # Define and create the store_indirect function\n # void store_indirectly(D_PTR, I_PTR, I, D)\n # ptr[idx_ptr[idx]] = val\n store_indirect_func_type = ir.FunctionType(ir.VoidType(), [D_PTR, I_PTR, I, D])\n store_indirect_func = ir.Function(\n module, store_indirect_func_type, name=\"store_indirect\"\n )\n store_indirect_func.attributes.add(\"alwaysinline\")\n ptr, idx_ptr, idx, val = store_indirect_func.args\n ptr.name = \"ptr\"\n idx_ptr.name = \"idx_ptr\"\n idx.name = \"idx\"\n val.name = \"val\"\n\n block = store_indirect_func.append_basic_block(name=\"entry\")\n builder = ir.IRBuilder(block)\n\n # Implement the store_indirect logic\n idx = builder.gep(idx_ptr, [idx], name=\"gep_idx\")\n idx = builder.load(idx, name=\"real_idx\")\n ptr = builder.gep(ptr, [idx], name=\"gep_ptr\")\n builder.store(val, ptr)\n builder.ret_void()\n\n # Define and create the add_store_indirect function\n # void add_store_indirectly(D_PTR, I_PTR, I, D)\n # ptr[idx_ptr[idx]] += val\n add_store_indirect_func_type = ir.FunctionType(ir.VoidType(), [D_PTR, I_PTR, I, D])\n add_store_indirect_func = ir.Function(\n module, add_store_indirect_func_type, name=\"add_store_indirect\"\n )\n add_store_indirect_func.attributes.add(\"alwaysinline\")\n ptr, idx_ptr, idx, val = add_store_indirect_func.args\n ptr.name = \"ptr\"\n idx_ptr.name = \"idx_ptr\"\n idx.name = \"idx\"\n val.name = \"val\"\n\n block = add_store_indirect_func.append_basic_block(name=\"entry\")\n builder = ir.IRBuilder(block)\n\n # Implement the add_store_indirect logic\n idx = builder.gep(idx_ptr, [idx], name=\"gep_idx\")\n idx = builder.load(idx, name=\"real_idx\")\n ptr = builder.gep(ptr, [idx], name=\"gep_ptr\")\n old_val = builder.load(ptr, name=\"old_val\")\n new_val = builder.fadd(old_val, val, name=\"new_val\")\n builder.store(new_val, ptr)\n builder.ret_void()\n\n\nop2name = {\n graph_op.abs: \"fabs\",\n graph_op.acos: \"acos\",\n graph_op.asin: \"asin\",\n graph_op.atan: \"atan\",\n graph_op.cos: \"cos\",\n graph_op.exp: \"exp\",\n graph_op.log: \"log\",\n graph_op.pow: \"pow\",\n graph_op.sin: \"sin\",\n graph_op.sqrt: \"sqrt\",\n graph_op.tan: \"tan\",\n}\n\nmath_ops = set(op2name.keys())\n\nbinary_ops = set([graph_op.pow])\n\ncompare_ops = set([graph_op.cexp_eq, graph_op.cexp_le, graph_op.cexp_lt])\n\ncompare_ops_string = {\n graph_op.cexp_eq: \"==\",\n graph_op.cexp_le: \"<=\",\n graph_op.cexp_lt: \"<\",\n}\n\n\ndef create_llvmir_basic_functions(module: ir.Module):\n create_azmul(module)\n create_sign(module)\n create_direct_load_store(module)\n create_indirect_load_store(module)\n\n for op, op_name in op2name.items():\n if op in binary_ops:\n func_type = ir.FunctionType(D, [D, D])\n else:\n func_type = ir.FunctionType(D, [D])\n ir.Function(module, func_type, name=op_name)\n\n # sin = module.declare_intrinsic('llvm.sin', [D])\n # cos = module.declare_intrinsic('llvm.cos', [D])\n\n\n# Define graph to LLVM IR translation function\ndef generate_llvmir_from_graph(\n module: ir.Module,\n graph_obj,\n name: str,\n np: int = 0,\n hessian_lagrange: bool = False,\n nw: int = 0,\n indirect_x: bool = False,\n indirect_p: bool = False,\n indirect_w: bool = False,\n indirect_y: bool = False,\n add_y: bool = False,\n):\n n_dynamic_ind = graph_obj.n_dynamic_ind\n n_variable_ind = graph_obj.n_variable_ind\n n_constant = graph_obj.n_constant\n n_dependent = graph_obj.n_dependent\n\n n_node = 0\n for graph_iter in cpp_graph_iterator(graph_obj):\n n_node += graph_iter.n_result\n\n has_parameter = np > 0\n\n # Define function signature\n func_args = [D_PTR]\n arg_names = [\"x\"]\n if has_parameter:\n func_args.append(D_PTR)\n arg_names.append(\"p\")\n if hessian_lagrange:\n func_args.append(D_PTR)\n arg_names.append(\"w\")\n func_args.append(D_PTR)\n arg_names.append(\"y\")\n if indirect_x:\n func_args.append(I_PTR)\n arg_names.append(\"xi\")\n if has_parameter and indirect_p:\n func_args.append(I_PTR)\n arg_names.append(\"pi\")\n if hessian_lagrange and indirect_w:\n func_args.append(I_PTR)\n arg_names.append(\"wi\")\n if indirect_y:\n func_args.append(I_PTR)\n arg_names.append(\"yi\")\n\n func_type = ir.FunctionType(ir.VoidType(), func_args)\n func = ir.Function(module, func_type, name=name)\n\n # set argument names\n args_dict = {}\n args = func.args\n for i, arg in enumerate(args):\n arg.name = arg_names[i]\n args_dict[arg.name] = arg\n # Destructure the args\n x = args_dict.get(\"x\", None)\n p = args_dict.get(\"p\", None)\n w = args_dict.get(\"w\", None)\n y = args_dict.get(\"y\", None)\n xi = args_dict.get(\"xi\", None)\n pi = args_dict.get(\"pi\", None)\n wi = args_dict.get(\"wi\", None)\n yi = args_dict.get(\"yi\", None)\n # add noalias attribute\n for arg in [x, p, w, y, xi, pi, wi, yi]:\n if arg is not None:\n arg.add_attribute(\"noalias\")\n\n # Define entry block\n block = func.append_basic_block(name=\"entry\")\n builder = ir.IRBuilder(block)\n\n comment = \"\"\n if not hessian_lagrange:\n nx = n_dynamic_ind + n_variable_ind - np\n comment += f\"nx = {nx}, np = {np}, \"\n else:\n nx = n_dynamic_ind + n_variable_ind - np - nw\n comment += f\"nx = {nx}, np = {np}, nw = {nw}, \"\n ny = n_dependent\n comment += f\"ny = {ny}\"\n builder.comment(comment)\n\n # Constants and initial setup (if any)\n nc = n_constant\n constants = [graph_obj.constant_vec_get(i) for i in range(nc)]\n c_array = ir.Constant(ir.ArrayType(D, len(constants)), constants)\n c_global = ir.GlobalVariable(module, c_array.type, name=f\"{name}_constants\")\n c_global.linkage = \"internal\"\n c_global.initializer = c_array\n c_global_ptr = builder.bitcast(c_global, D_PTR)\n\n # sin = module.get_global(\"llvm.sin.f64\")\n # cos = module.get_global(\"llvm.cos.f64\")\n math_functions = dict()\n for op_name in op2name.values():\n op_function = module.get_global(op_name)\n if op_function is None:\n raise ValueError(f\"Math function {op_name} not found in module\")\n math_functions[op_name] = op_function\n\n azmul = module.get_global(\"azmul\")\n sign = module.get_global(\"sign\")\n load_direct = module.get_global(\"load_direct\")\n store_direct = module.get_global(\"store_direct\")\n add_store_direct = module.get_global(\"add_store_direct\")\n load_indirect = module.get_global(\"load_indirect\")\n store_indirect = module.get_global(\"store_indirect\")\n add_store_indirect = module.get_global(\"add_store_indirect\")\n\n result_node = 0\n\n p_dict = {}\n w_dict = {}\n x_dict = {}\n c_dict = {}\n v_dict = {}\n\n def get_node_value(node: int):\n if node < 1:\n raise ValueError(f\"Invalid node: {node}\")\n if node < 1 + np:\n p_index = node - 1\n val = p_dict.get(p_index, None)\n if val is None:\n if indirect_p:\n val = builder.call(load_indirect, [p, pi, I(p_index)])\n else:\n val = builder.call(load_direct, [p, I(p_index)])\n val.name = f\"p[{p_index}]\"\n p_dict[p_index] = val\n elif node < 1 + n_dynamic_ind + n_variable_ind:\n if hessian_lagrange:\n if node < 1 + np + nw:\n w_index = node - 1 - np\n val = w_dict.get(w_index, None)\n if val is None:\n if indirect_w:\n val = builder.call(load_indirect, [w, wi, I(w_index)])\n else:\n val = builder.call(load_direct, [w, I(w_index)])\n val.name = f\"w[{w_index}]\"\n w_dict[w_index] = val\n else:\n x_index = node - 1 - np - nw\n val = x_dict.get(x_index, None)\n if val is None:\n if indirect_x:\n val = builder.call(load_indirect, [x, xi, I(x_index)])\n else:\n val = builder.call(load_direct, [x, I(x_index)])\n val.name = f\"x[{x_index}]\"\n x_dict[x_index] = val\n else:\n x_index = node - 1 - np\n val = x_dict.get(x_index, None)\n if val is None:\n if indirect_x:\n val = builder.call(load_indirect, [x, xi, I(x_index)])\n else:\n val = builder.call(load_direct, [x, I(x_index)])\n val.name = f\"x[{x_index}]\"\n x_dict[x_index] = val\n elif node < 1 + n_dynamic_ind + n_variable_ind + n_constant:\n c_index = node - 1 - n_dynamic_ind - n_variable_ind\n val = c_dict.get(c_index, None)\n if val is None:\n val = builder.call(load_direct, [c_global_ptr, I(c_index)])\n val.name = f\"c[{c_index}]\"\n c_dict[c_index] = val\n else:\n v_index = node - 1 - n_dynamic_ind - n_variable_ind - n_constant\n assert v_index < n_node\n v_val = v_dict.get(v_index, None)\n if v_val is None:\n raise ValueError(f\"Node value not found: {v_index}\")\n val = v_val\n return val\n\n arithmetic_flags = (\"fast\",)\n\n for iter in cpp_graph_iterator(graph_obj):\n op = iter.op\n n_result = iter.n_result\n args = iter.args\n\n assert n_result == 1\n\n arg1 = get_node_value(args[0])\n if len(args) >= 2:\n arg2 = get_node_value(args[1])\n\n if op == graph_op.add:\n ret_val = builder.fadd(arg1, arg2, flags=arithmetic_flags)\n elif op == graph_op.sub:\n ret_val = builder.fsub(arg1, arg2, flags=arithmetic_flags)\n elif op == graph_op.mul:\n ret_val = builder.fmul(arg1, arg2, flags=arithmetic_flags)\n elif op == graph_op.div:\n ret_val = builder.fdiv(arg1, arg2, flags=arithmetic_flags)\n elif op == graph_op.azmul:\n ret_val = builder.fmul(arg1, arg2, flags=arithmetic_flags)\n # ret_val = builder.call(azmul, [arg1, arg2])\n elif op == graph_op.neg:\n ret_val = builder.fneg(arg1, flags=arithmetic_flags)\n elif op == graph_op.sign:\n ret_val = builder.call(sign, [arg1])\n elif op in math_ops:\n op_name = op2name[op]\n op_function = math_functions[op_name]\n if op in binary_ops:\n ret_val = builder.call(op_function, [arg1, arg2])\n else:\n ret_val = builder.call(op_function, [arg1])\n elif op in compare_ops:\n assert len(args) == 4\n predicate = arg1\n target = arg2\n then_value = get_node_value(args[2])\n else_value = get_node_value(args[3])\n\n cmp_string = compare_ops_string[op]\n cond = builder.fcmp_ordered(cmp_string, predicate, target)\n\n ret_val = builder.select(cond, then_value, else_value)\n else:\n raise ValueError(f\"Unknown CppAD graph op_enum: {op}\")\n\n ret_val.name = f\"v[{result_node}]\"\n v_dict[result_node] = ret_val\n\n result_node += n_result\n\n store_f_dict = {\n (True, True): add_store_indirect,\n (True, False): store_indirect,\n (False, True): add_store_direct,\n (False, False): store_direct,\n }\n store_f = store_f_dict[(indirect_y, add_y)]\n for i in range(ny):\n node = graph_obj.dependent_vec_get(i)\n val = get_node_value(node)\n builder.comment(f\"write y[{i}]\")\n if indirect_y:\n builder.call(store_f, [y, yi, I(i), val])\n else:\n builder.call(store_f, [y, I(i), val])\n\n # Return from the function\n builder.ret_void()\n" }, { "path": "src/pyoptinterface/_src/comparison_constraint.py", "content": "from dataclasses import dataclass\nfrom typing import Any\n\nfrom .core_ext import ConstraintSense\n\n\n@dataclass\nclass ComparisonConstraint:\n sense: ConstraintSense\n lhs: Any\n rhs: Any\n" }, { "path": "src/pyoptinterface/_src/constraint_bridge.py", "content": "from .core_ext import ScalarQuadraticFunction, ConstraintSense\n\n\ndef bridge_soc_quadratic_constraint(model, cone_variables, name=\"\", rotated=False):\n \"\"\"\n Convert a second order cone constraint to a quadratic constraint.\n x[0] >= sqrt(x[1]^2 + ... + x[n]^2)\n to\n x[0]^2 - x[1]^2 - ... - x[n]^2 >= 0\n or\n convert a rotated second order cone constraint to a quadratic constraint.\n 2 * x[0] * x[1] >= x[2]^2 + ... + x[n]^2\n to\n 2 * x[0] * x[1] - x[2]^2 - ... - x[n]^2 >= 0\n \"\"\"\n N = len(cone_variables)\n if N < 2:\n raise ValueError(\n \"Second order cone constraint must have at least two variables\"\n )\n\n expr = ScalarQuadraticFunction()\n expr.reserve_quadratic(N)\n\n if not rotated:\n x0 = cone_variables[0]\n expr.add_quadratic_term(x0, x0, 1.0)\n\n for i in range(1, N):\n xi = cone_variables[i]\n expr.add_quadratic_term(xi, xi, -1.0)\n\n con = model.add_quadratic_constraint(\n expr, ConstraintSense.GreaterEqual, 0.0, name\n )\n else:\n x0 = cone_variables[0]\n x1 = cone_variables[1]\n expr.add_quadratic_term(x0, x1, 2.0)\n\n for i in range(2, N):\n xi = cone_variables[i]\n expr.add_quadratic_term(xi, xi, -1.0)\n\n con = model.add_quadratic_constraint(\n expr, ConstraintSense.GreaterEqual, 0.0, name\n )\n\n return con\n" }, { "path": "src/pyoptinterface/_src/copt.py", "content": "import os\nimport platform\nfrom pathlib import Path\nimport logging\nfrom typing import Dict, Tuple, Union, overload\n\nfrom .copt_model_ext import RawModel, Env, COPT, load_library\nfrom .attributes import (\n VariableAttribute,\n ConstraintAttribute,\n ModelAttribute,\n ResultStatusCode,\n TerminationStatusCode,\n)\nfrom .core_ext import (\n VariableIndex,\n ScalarAffineFunction,\n ScalarQuadraticFunction,\n ExprBuilder,\n ConstraintType,\n ConstraintSense,\n ObjectiveSense,\n)\nfrom .nlexpr_ext import ExpressionHandle\nfrom .nlfunc import ExpressionGraphContext, convert_to_expressionhandle\nfrom .comparison_constraint import ComparisonConstraint\nfrom .solver_common import (\n _direct_get_model_attribute,\n _direct_set_model_attribute,\n _direct_get_entity_attribute,\n _direct_set_entity_attribute,\n)\nfrom .aml import make_variable_tupledict, make_variable_ndarray\nfrom .matrix import add_matrix_constraints\n\n\ndef detected_libraries():\n libs = []\n\n subdir = {\n \"Linux\": \"lib\",\n \"Darwin\": \"lib\",\n \"Windows\": \"bin\",\n }[platform.system()]\n libname = {\n \"Linux\": \"libcopt.so\",\n \"Darwin\": \"libcopt.dylib\",\n \"Windows\": \"copt.dll\",\n }[platform.system()]\n\n # Environment\n home = os.environ.get(\"COPT_HOME\", None)\n if home and os.path.exists(home):\n lib = Path(home) / subdir / libname\n if lib.exists():\n libs.append(str(lib))\n\n # default names\n default_libname = libname\n libs.append(default_libname)\n\n return libs\n\n\ndef autoload_library():\n libs = detected_libraries()\n for lib in libs:\n ret = load_library(lib)\n if ret:\n logging.info(f\"Loaded COPT library: {lib}\")\n return True\n return False\n\n\nautoload_library()\n\nDEFAULT_ENV = None\n\n\ndef init_default_env():\n global DEFAULT_ENV\n if DEFAULT_ENV is None:\n DEFAULT_ENV = Env()\n\n\nvariable_attribute_get_func_map = {\n VariableAttribute.Value: lambda model, v: model.get_variable_info(v, \"Value\"),\n VariableAttribute.LowerBound: lambda model, v: model.get_variable_info(v, \"LB\"),\n VariableAttribute.UpperBound: lambda model, v: model.get_variable_info(v, \"UB\"),\n VariableAttribute.PrimalStart: lambda model, v: model.variable_start_values.get(\n v, None\n ),\n VariableAttribute.Domain: lambda model, v: model.get_variable_type(v),\n VariableAttribute.Name: lambda model, v: model.get_variable_name(v),\n VariableAttribute.IISLowerBound: lambda model, v: model._get_variable_lowerbound_IIS(\n v\n )\n > 0,\n VariableAttribute.IISUpperBound: lambda model, v: model._get_variable_upperbound_IIS(\n v\n )\n > 0,\n VariableAttribute.ReducedCost: lambda model, v: model.get_variable_info(\n v, \"RedCost\"\n ),\n}\n\n\ndef set_variable_start(model, v, val):\n model.variable_start_values[v] = val\n\n\nvariable_attribute_set_func_map = {\n VariableAttribute.LowerBound: lambda model, v, val: model.set_variable_lower_bound(\n v, val\n ),\n VariableAttribute.UpperBound: lambda model, v, val: model.set_variable_upper_bound(\n v, val\n ),\n VariableAttribute.PrimalStart: set_variable_start,\n VariableAttribute.Domain: lambda model, v, val: model.set_variable_type(v, val),\n VariableAttribute.Name: lambda model, v, val: model.set_variable_name(v, val),\n}\n\nconstraint_type_attribute_name_map = {\n ConstraintType.Linear: \"Rows\",\n ConstraintType.Quadratic: \"QConstrs\",\n}\n\ncopt_parameter_raw_type_map = {\n 0: float,\n 1: int,\n}\n\ncopt_attribute_raw_type_map = {\n 2: float,\n 3: int,\n}\n\n\ndef get_objsense(model):\n raw_sense = model.get_raw_attribute_int(\"ObjSense\")\n if raw_sense == COPT.MINIMIZE:\n return ObjectiveSense.Minimize\n elif raw_sense == COPT.MAXIMIZE:\n return ObjectiveSense.Maximize\n else:\n raise ValueError(f\"Unknown objective sense: {raw_sense}\")\n\n\ndef get_objval(model):\n if model._is_mip():\n attr_name = \"BestObj\"\n else:\n attr_name = \"LpObjval\"\n obj = model.get_raw_attribute_double(attr_name)\n return obj\n\n\ndef get_primalstatus(model):\n if model._is_mip():\n attr_name = \"HasMipSol\"\n else:\n attr_name = \"HasLpSol\"\n has_sol = model.get_raw_attribute_int(attr_name)\n if has_sol != 0:\n return ResultStatusCode.FEASIBLE_POINT\n else:\n return ResultStatusCode.NO_SOLUTION\n\n\ndef get_dualstatus(model):\n if not model._is_mip():\n has_sol = model.get_raw_attribute_int(\"HasLpSol\")\n if has_sol != 0:\n return ResultStatusCode.FEASIBLE_POINT\n return ResultStatusCode.NO_SOLUTION\n\n\n# LP status codes. Descriptions taken from COPT user guide.\n# Code : (TerminationStatus, RawStatusString)\n_RAW_LPSTATUS_STRINGS = {\n COPT.UNSTARTED: (\n TerminationStatusCode.OPTIMIZE_NOT_CALLED,\n \"The LP optimization is not started yet.\",\n ),\n COPT.OPTIMAL: (\n TerminationStatusCode.OPTIMAL,\n \"The LP problem is solved to optimality.\",\n ),\n COPT.INFEASIBLE: (\n TerminationStatusCode.INFEASIBLE,\n \"The LP problem is infeasible.\",\n ),\n COPT.UNBOUNDED: (\n TerminationStatusCode.DUAL_INFEASIBLE,\n \"The LP problem is unbounded.\",\n ),\n COPT.NUMERICAL: (\n TerminationStatusCode.NUMERICAL_ERROR,\n \"Numerical trouble encountered.\",\n ),\n COPT.IMPRECISE: (\n TerminationStatusCode.ALMOST_OPTIMAL,\n \"The LP problem is solved to optimality with relaxed tolerances.\",\n ),\n COPT.TIMEOUT: (\n TerminationStatusCode.TIME_LIMIT,\n \"The LP optimization is stopped because of time limit.\",\n ),\n COPT.UNFINISHED: (\n TerminationStatusCode.NUMERICAL_ERROR,\n \"The LP optimization is stopped but the solver cannot provide a solution because of numerical difficulties.\",\n ),\n COPT.INTERRUPTED: (\n TerminationStatusCode.INTERRUPTED,\n \"The LP optimization is stopped by user interrupt.\",\n ),\n}\n\n# MIP status codes. Descriptions taken from COPT user guide.\n# Code : (TerminationStatus, RawStatusString)\n_RAW_MIPSTATUS_STRINGS = {\n COPT.UNSTARTED: (\n TerminationStatusCode.OPTIMIZE_NOT_CALLED,\n \"The MIP optimization is not started yet.\",\n ),\n COPT.OPTIMAL: (\n TerminationStatusCode.OPTIMAL,\n \"The MIP problem is solved to optimality.\",\n ),\n COPT.INFEASIBLE: (\n TerminationStatusCode.INFEASIBLE,\n \"The MIP problem is infeasible.\",\n ),\n COPT.UNBOUNDED: (\n TerminationStatusCode.DUAL_INFEASIBLE,\n \"The MIP problem is unbounded.\",\n ),\n COPT.INF_OR_UNB: (\n TerminationStatusCode.INFEASIBLE_OR_UNBOUNDED,\n \"The MIP problem is infeasible or unbounded.\",\n ),\n COPT.NODELIMIT: (\n TerminationStatusCode.NODE_LIMIT,\n \"The MIP optimization is stopped because of node limit.\",\n ),\n COPT.TIMEOUT: (\n TerminationStatusCode.TIME_LIMIT,\n \"The MIP optimization is stopped because of time limit.\",\n ),\n COPT.UNFINISHED: (\n TerminationStatusCode.NUMERICAL_ERROR,\n \"The MIP optimization is stopped but the solver cannot provide a solution because of numerical difficulties.\",\n ),\n COPT.INTERRUPTED: (\n TerminationStatusCode.INTERRUPTED,\n \"The MIP optimization is stopped by user interrupt.\",\n ),\n}\n\n\ndef get_terminationstatus(model):\n if model._is_mip():\n raw_status = model.get_raw_attribute_int(\"MipStatus\")\n status_string_pair = _RAW_MIPSTATUS_STRINGS.get(raw_status, None)\n else:\n raw_status = model.get_raw_attribute_int(\"LpStatus\")\n status_string_pair = _RAW_LPSTATUS_STRINGS.get(raw_status, None)\n if not status_string_pair:\n raise ValueError(f\"Unknown termination status: {raw_status}\")\n return status_string_pair[0]\n\n\ndef get_rawstatusstring(model):\n if model._is_mip():\n raw_status = model.get_raw_attribute_int(\"MipStatus\")\n status_string_pair = _RAW_MIPSTATUS_STRINGS.get(raw_status, None)\n else:\n raw_status = model.get_raw_attribute_int(\"LpStatus\")\n status_string_pair = _RAW_LPSTATUS_STRINGS.get(raw_status, None)\n if not status_string_pair:\n raise ValueError(f\"Unknown termination status: {raw_status}\")\n return status_string_pair[1]\n\n\ndef get_silent(model):\n return model.get_raw_parameter_int(\"LogToConsole\") == 0\n\n\nmodel_attribute_get_func_map = {\n ModelAttribute.ObjectiveSense: get_objsense,\n ModelAttribute.BarrierIterations: lambda model: model.get_model_raw_attribute_int(\n \"BarrierIter\"\n ),\n ModelAttribute.DualObjectiveValue: get_objval,\n ModelAttribute.NodeCount: lambda model: model.get_model_raw_attribute_int(\n \"NodeCnt\"\n ),\n ModelAttribute.ObjectiveBound: get_objval,\n ModelAttribute.ObjectiveValue: get_objval,\n ModelAttribute.SimplexIterations: lambda model: model.get_model_raw_attribute_int(\n \"SimplexIter\"\n ),\n ModelAttribute.SolveTimeSec: lambda model: model.get_raw_attribute_double(\n \"SolvingTime\"\n ),\n ModelAttribute.NumberOfThreads: lambda model: model.get_raw_parameter_int(\n \"Threads\"\n ),\n ModelAttribute.RelativeGap: lambda model: model.get_raw_parameter_double(\"RelGap\"),\n ModelAttribute.TimeLimitSec: lambda model: model.get_raw_parameter_double(\n \"TimeLimit\"\n ),\n ModelAttribute.DualStatus: get_dualstatus,\n ModelAttribute.PrimalStatus: get_primalstatus,\n ModelAttribute.RawStatusString: get_rawstatusstring,\n ModelAttribute.TerminationStatus: get_terminationstatus,\n ModelAttribute.Silent: get_silent,\n ModelAttribute.SolverName: lambda _: \"COPT\",\n ModelAttribute.SolverVersion: lambda model: model.version_string(),\n}\n\n\ndef set_silent(model, value: bool):\n if value:\n model.set_raw_parameter_int(\"LogToConsole\", 0)\n else:\n model.set_raw_parameter_int(\"LogToConsole\", 1)\n\n\nmodel_attribute_set_func_map = {\n ModelAttribute.ObjectiveSense: lambda model, v: model.set_obj_sense(v),\n ModelAttribute.NumberOfThreads: lambda model, v: model.set_raw_parameter_int(\n \"Threads\", v\n ),\n ModelAttribute.RelativeGap: lambda model, v: model.set_raw_parameter_double(\n \"RelGap\", v\n ),\n ModelAttribute.TimeLimitSec: lambda model, v: model.set_raw_parameter_double(\n \"TimeLimit\", v\n ),\n ModelAttribute.Silent: set_silent,\n}\n\nconstraint_attribute_get_func_map = {\n ConstraintAttribute.Name: lambda model, constraint: model.get_constraint_name(\n constraint\n ),\n ConstraintAttribute.Primal: lambda model, constraint: model.get_constraint_info(\n constraint, \"Slack\"\n ),\n ConstraintAttribute.Dual: lambda model, constraint: model.get_constraint_info(\n constraint, \"Dual\"\n ),\n ConstraintAttribute.IIS: lambda model, constraint: model._get_constraint_IIS(\n constraint\n )\n > 0,\n}\n\nconstraint_attribute_set_func_map = {\n ConstraintAttribute.Name: lambda model, constraint, value: model.set_constraint_name(\n constraint, value\n ),\n}\n\ncallback_info_typemap = {\n \"BestObj\": float,\n \"BestBnd\": float,\n \"HasIncumbent\": int,\n \"MipCandObj\": float,\n \"RelaxSolObj\": float,\n \"NodeStatus\": int,\n}\n\n\nclass Model(RawModel):\n def __init__(self, env=None):\n if env is None:\n init_default_env()\n env = DEFAULT_ENV\n super().__init__(env)\n\n # We must keep a reference to the environment to prevent it from being garbage collected\n self._env = env\n self.variable_start_values: Dict[VariableIndex, float] = dict()\n self.nl_start_values: Dict[VariableIndex, float] = dict()\n\n # override logging\n self.set_raw_parameter(\"LogToConsole\", 0)\n self.set_logging(print)\n\n def add_variables(self, *args, **kwargs):\n return make_variable_tupledict(self, *args, **kwargs)\n\n @staticmethod\n def supports_variable_attribute(attribute: VariableAttribute, settable=False):\n if settable:\n return attribute in variable_attribute_set_func_map\n else:\n return attribute in variable_attribute_get_func_map\n\n @staticmethod\n def supports_model_attribute(attribute: ModelAttribute, settable=False):\n if settable:\n return attribute in model_attribute_set_func_map\n else:\n return attribute in model_attribute_get_func_map\n\n @staticmethod\n def supports_constraint_attribute(attribute: ConstraintAttribute, settable=False):\n if settable:\n return attribute in constraint_attribute_set_func_map\n else:\n return attribute in constraint_attribute_get_func_map\n\n def get_variable_attribute(self, variable, attribute: VariableAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown variable attribute to get: {attribute}\")\n\n value = _direct_get_entity_attribute(\n self,\n variable,\n attribute,\n variable_attribute_get_func_map,\n e,\n )\n return value\n\n def set_variable_attribute(self, variable, attribute: VariableAttribute, value):\n def e(attribute):\n raise ValueError(f\"Unknown variable attribute to set: {attribute}\")\n\n _direct_set_entity_attribute(\n self,\n variable,\n attribute,\n value,\n variable_attribute_set_func_map,\n e,\n )\n\n def number_of_constraints(self, type: ConstraintType):\n attr_name = constraint_type_attribute_name_map.get(type, None)\n if not attr_name:\n raise ValueError(f\"Unknown constraint type: {type}\")\n return self.get_raw_attribute_int(attr_name)\n\n def number_of_variables(self):\n return self.get_raw_attribute_int(\"Cols\")\n\n def _is_mip(self):\n ismip = self.get_raw_attribute_int(\"IsMIP\")\n return ismip > 0\n\n def _has_nl(self):\n nlconstrs = self.get_raw_attribute_int(\"NLConstrs\")\n hasnlobj = self.get_raw_attribute_int(\"HasNLObj\")\n return nlconstrs > 0 or hasnlobj > 0\n\n def get_model_attribute(self, attribute: ModelAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown model attribute to get: {attribute}\")\n\n value = _direct_get_model_attribute(\n self,\n attribute,\n model_attribute_get_func_map,\n e,\n )\n return value\n\n def set_model_attribute(self, attribute: ModelAttribute, value):\n def e(attribute):\n raise ValueError(f\"Unknown model attribute to set: {attribute}\")\n\n _direct_set_model_attribute(\n self,\n attribute,\n value,\n model_attribute_set_func_map,\n e,\n )\n\n def get_constraint_attribute(self, constraint, attribute: ConstraintAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown constraint attribute to get: {attribute}\")\n\n value = _direct_get_entity_attribute(\n self,\n constraint,\n attribute,\n constraint_attribute_get_func_map,\n e,\n )\n return value\n\n def set_constraint_attribute(\n self, constraint, attribute: ConstraintAttribute, value\n ):\n def e(attribute):\n raise ValueError(f\"Unknown constraint attribute to set: {attribute}\")\n\n _direct_set_entity_attribute(\n self,\n constraint,\n attribute,\n value,\n constraint_attribute_set_func_map,\n e,\n )\n\n def get_raw_parameter(self, param_name: str):\n param_type = copt_parameter_raw_type_map[\n self.raw_parameter_attribute_type(param_name)\n ]\n get_function_map = {\n int: self.get_raw_parameter_int,\n float: self.get_raw_parameter_double,\n }\n get_function = get_function_map[param_type]\n return get_function(param_name)\n\n def set_raw_parameter(self, param_name: str, value):\n param_type = copt_parameter_raw_type_map[\n self.raw_parameter_attribute_type(param_name)\n ]\n set_function_map = {\n int: self.set_raw_parameter_int,\n float: self.set_raw_parameter_double,\n }\n set_function = set_function_map[param_type]\n set_function(param_name, value)\n\n def get_raw_attribute(self, param_name: str):\n param_type = copt_attribute_raw_type_map[\n self.raw_parameter_attribute_type(param_name)\n ]\n get_function_map = {\n int: self.get_raw_attribute_int,\n float: self.get_raw_attribute_double,\n }\n get_function = get_function_map[param_type]\n return get_function(param_name)\n\n def optimize(self):\n is_mip = self._is_mip()\n is_nl = self._has_nl()\n\n if is_mip or is_nl:\n variable_start_values = self.variable_start_values\n if len(variable_start_values) != 0:\n variables = list(variable_start_values.keys())\n values = list(variable_start_values.values())\n variable_start_values.clear()\n\n if is_mip:\n self.add_mip_start(variables, values)\n if is_nl:\n self.add_nl_start(variables, values)\n\n super().optimize()\n\n def cb_get_info(self, what):\n cb_info_type = callback_info_typemap.get(what, None)\n if cb_info_type is None:\n raise ValueError(f\"Unknown callback info type: {what}\")\n if cb_info_type is int:\n return self.cb_get_info_int(what)\n elif cb_info_type is float:\n return self.cb_get_info_double(what)\n else:\n raise ValueError(f\"Unknown callback info type: {what}\")\n\n @overload\n def add_linear_constraint(\n self,\n expr: Union[VariableIndex, ScalarAffineFunction, ExprBuilder],\n sense: ConstraintSense,\n rhs: float,\n name: str = \"\",\n ): ...\n\n @overload\n def add_linear_constraint(\n self,\n expr: Union[VariableIndex, ScalarAffineFunction, ExprBuilder],\n interval: Tuple[float, float],\n name: str = \"\",\n ): ...\n\n @overload\n def add_linear_constraint(\n self,\n con: ComparisonConstraint,\n name: str = \"\",\n ): ...\n\n def add_linear_constraint(self, arg, *args, **kwargs):\n if isinstance(arg, ComparisonConstraint):\n return self._add_linear_constraint(\n arg.lhs, arg.sense, arg.rhs, *args, **kwargs\n )\n else:\n return self._add_linear_constraint(arg, *args, **kwargs)\n\n @overload\n def add_quadratic_constraint(\n self,\n expr: Union[ScalarQuadraticFunction, ExprBuilder],\n sense: ConstraintSense,\n rhs: float,\n name: str = \"\",\n ): ...\n\n @overload\n def add_quadratic_constraint(\n self,\n con: ComparisonConstraint,\n name: str = \"\",\n ): ...\n\n def add_quadratic_constraint(self, arg, *args, **kwargs):\n if isinstance(arg, ComparisonConstraint):\n return self._add_quadratic_constraint(\n arg.lhs, arg.sense, arg.rhs, *args, **kwargs\n )\n else:\n return self._add_quadratic_constraint(arg, *args, **kwargs)\n\n @overload\n def add_nl_constraint(\n self,\n expr,\n sense: ConstraintSense,\n rhs: float,\n /,\n name: str = \"\",\n ): ...\n\n @overload\n def add_nl_constraint(\n self,\n expr,\n interval: Tuple[float, float],\n /,\n name: str = \"\",\n ): ...\n\n @overload\n def add_nl_constraint(\n self,\n con,\n /,\n name: str = \"\",\n ): ...\n\n def add_nl_constraint(self, expr, *args, **kwargs):\n graph = ExpressionGraphContext.current_graph()\n expr = convert_to_expressionhandle(graph, expr)\n if not isinstance(expr, ExpressionHandle):\n raise ValueError(\n \"Expression should be able to be converted to ExpressionHandle\"\n )\n\n con = self._add_single_nl_constraint(graph, expr, *args, **kwargs)\n\n return con\n\n def add_nl_objective(self, expr):\n graph = ExpressionGraphContext.current_graph()\n expr = convert_to_expressionhandle(graph, expr)\n if not isinstance(expr, ExpressionHandle):\n raise ValueError(\n \"Expression should be able to be converted to ExpressionHandle\"\n )\n self._add_single_nl_objective(graph, expr)\n\n add_variables = make_variable_tupledict\n add_m_variables = make_variable_ndarray\n add_m_linear_constraints = add_matrix_constraints\n" }, { "path": "src/pyoptinterface/_src/cpp_graph_iter.py", "content": "from collections import namedtuple\nfrom .cppad_interface_ext import cpp_graph_cursor\n\ncpp_graph_instruction = namedtuple(\"cpp_graph_instruction\", [\"op\", \"args\", \"n_result\"])\n\n\nclass cpp_graph_iterator:\n def __init__(self, graph):\n self.graph = graph\n self.init = False\n self.cursor = None\n self.N = graph.n_operator\n\n def __iter__(self):\n return self\n\n def __next__(self):\n if self.N == 0:\n raise StopIteration\n\n graph = self.graph\n if not self.init:\n self.init = True\n self.cursor = cpp_graph_cursor()\n else:\n if self.cursor.op_index >= self.N:\n raise StopIteration\n\n cursor = self.cursor\n\n op = graph.get_cursor_op(cursor)\n args = graph.get_cursor_args(cursor)\n n_result = 1\n\n instruction = cpp_graph_instruction(op, args, n_result)\n\n graph.next_cursor(self.cursor)\n\n return instruction\n" }, { "path": "src/pyoptinterface/_src/dylib.py", "content": "import platform\n\n\ndef dylib_suffix():\n system = platform.system()\n if system == \"Linux\":\n return \"so\"\n elif system == \"Darwin\":\n return \"dylib\"\n elif system == \"Windows\":\n return \"dll\"\n else:\n raise RuntimeError(\"Unknown platform: %s\" % system)\n" }, { "path": "src/pyoptinterface/_src/gurobi.py", "content": "import os\nimport platform\nfrom pathlib import Path\nimport re\nimport sys\nimport logging\nfrom typing import Tuple, Union, overload\n\nfrom .gurobi_model_ext import RawModel, RawEnv, GRB, load_library\nfrom .attributes import (\n VariableAttribute,\n ConstraintAttribute,\n ModelAttribute,\n ResultStatusCode,\n TerminationStatusCode,\n)\nfrom .core_ext import (\n VariableIndex,\n ScalarAffineFunction,\n ScalarQuadraticFunction,\n ExprBuilder,\n VariableDomain,\n ConstraintType,\n ConstraintSense,\n ObjectiveSense,\n)\nfrom .nlexpr_ext import ExpressionHandle\nfrom .nlfunc import ExpressionGraphContext, convert_to_expressionhandle\nfrom .comparison_constraint import ComparisonConstraint\nfrom .solver_common import (\n _get_model_attribute,\n _set_model_attribute,\n _get_entity_attribute,\n _direct_get_entity_attribute,\n _set_entity_attribute,\n _direct_set_entity_attribute,\n)\nfrom .constraint_bridge import bridge_soc_quadratic_constraint\nfrom .aml import make_variable_tupledict, make_variable_ndarray\nfrom .matrix import add_matrix_constraints\n\n\ndef detected_libraries():\n libs = []\n\n subdir = {\n \"Linux\": \"lib\",\n \"Darwin\": \"lib\",\n \"Windows\": \"bin\",\n }[platform.system()]\n libname_pattern = {\n \"Linux\": r\"libgurobi(\\d+)\\.so\",\n \"Darwin\": r\"libgurobi(\\d+)\\.dylib\",\n \"Windows\": r\"gurobi(\\d+)\\.dll\",\n }[platform.system()]\n suffix_pattern = {\n \"Linux\": \"*.so\",\n \"Darwin\": \"*.dylib\",\n \"Windows\": \"*.dll\",\n }[platform.system()]\n\n # Environment\n home = os.environ.get(\"GUROBI_HOME\", None)\n if home and os.path.exists(home):\n dir = Path(home) / subdir\n for path in dir.glob(suffix_pattern):\n match = re.match(libname_pattern, path.name)\n if match:\n libs.append(str(path))\n\n # gurobipy installation\n try:\n import gurobipy\n\n dir = Path(gurobipy.__path__[0])\n if platform.system() != \"Windows\":\n dir = dir / \".libs\"\n for path in dir.glob(suffix_pattern):\n match = re.match(libname_pattern, path.name)\n if match:\n libs.append(str(path))\n except Exception:\n pass\n\n # conda/pixi environment\n prefix = Path(sys.prefix)\n dir = prefix / subdir\n for path in dir.glob(suffix_pattern):\n match = re.match(libname_pattern, path.name)\n if match:\n libs.append(str(path))\n\n # default names\n gurobi_names = [\n \"gurobi130\",\n \"gurobi120\",\n \"gurobi110\",\n ]\n default_libname = {\n \"Linux\": [\"lib\" + name + \".so\" for name in gurobi_names],\n \"Darwin\": [\"lib\" + name + \".dylib\" for name in gurobi_names],\n \"Windows\": [name + \".dll\" for name in gurobi_names],\n }[platform.system()]\n libs.extend(default_libname)\n\n return libs\n\n\ndef autoload_library():\n libs = detected_libraries()\n for lib in libs:\n ret = load_library(lib)\n if ret:\n logging.info(f\"Loaded Gurobi library: {lib}\")\n return True\n return False\n\n\nautoload_library()\n\nDEFAULT_ENV = None\n\n\ndef init_default_env():\n global DEFAULT_ENV\n if DEFAULT_ENV is None:\n DEFAULT_ENV = RawEnv()\n\n\n# Variable Attribute\nvariable_attribute_get_func_map = {\n VariableAttribute.Value: lambda model, v: model.get_variable_raw_attribute_double(\n v, \"X\"\n ),\n VariableAttribute.LowerBound: lambda model, v: model.get_variable_raw_attribute_double(\n v, \"LB\"\n ),\n VariableAttribute.UpperBound: lambda model, v: model.get_variable_raw_attribute_double(\n v, \"UB\"\n ),\n VariableAttribute.PrimalStart: lambda model, v: model.get_variable_raw_attribute_double(\n v, \"Start\"\n ),\n VariableAttribute.Domain: lambda model, v: model.get_variable_raw_attribute_char(\n v, \"VType\"\n ),\n VariableAttribute.Name: lambda model, v: model.get_variable_raw_attribute_string(\n v, \"VarName\"\n ),\n VariableAttribute.IISLowerBound: lambda model, v: model.get_variable_raw_attribute_int(\n v, \"IISLB\"\n )\n > 0,\n VariableAttribute.IISUpperBound: lambda model, v: model.get_variable_raw_attribute_int(\n v, \"IISUB\"\n )\n > 0,\n VariableAttribute.ReducedCost: lambda model, v: model.get_variable_raw_attribute_double(\n v, \"RC\"\n ),\n}\n\nvariable_attribute_get_translate_func_map = {\n VariableAttribute.Domain: lambda v: {\n GRB.BINARY: VariableDomain.Binary,\n GRB.INTEGER: VariableDomain.Integer,\n GRB.CONTINUOUS: VariableDomain.Continuous,\n GRB.SEMICONT: VariableDomain.SemiContinuous,\n }[v],\n}\n\nvariable_attribute_set_translate_func_map = {\n VariableAttribute.Domain: lambda v: {\n VariableDomain.Binary: GRB.BINARY,\n VariableDomain.Integer: GRB.INTEGER,\n VariableDomain.Continuous: GRB.CONTINUOUS,\n VariableDomain.SemiContinuous: GRB.SEMICONT,\n }[v],\n}\n\nvariable_attribute_set_func_map = {\n VariableAttribute.LowerBound: lambda model, v, x: model.set_variable_raw_attribute_double(\n v, \"LB\", x\n ),\n VariableAttribute.UpperBound: lambda model, v, x: model.set_variable_raw_attribute_double(\n v, \"UB\", x\n ),\n VariableAttribute.PrimalStart: lambda model, v, x: model.set_variable_raw_attribute_double(\n v, \"Start\", x\n ),\n VariableAttribute.Domain: lambda model, v, x: model.set_variable_raw_attribute_char(\n v, \"VType\", x\n ),\n VariableAttribute.Name: lambda model, v, x: model.set_variable_raw_attribute_string(\n v, \"VarName\", x\n ),\n}\n\n# Model Attribute\n\nconstraint_type_attribute_name_map = {\n ConstraintType.Linear: \"NumConstrs\",\n ConstraintType.Quadratic: \"NumQConstrs\",\n}\n\n_RAW_STATUS_STRINGS = [ # TerminationStatus, RawStatusString\n (\n TerminationStatusCode.OPTIMIZE_NOT_CALLED,\n \"Model is loaded, but no solution information is available.\",\n ),\n (\n TerminationStatusCode.OPTIMAL,\n \"Model was solved to optimality (subject to tolerances), and an optimal solution is available.\",\n ),\n (TerminationStatusCode.INFEASIBLE, \"Model was proven to be infeasible.\"),\n (\n TerminationStatusCode.INFEASIBLE_OR_UNBOUNDED,\n \"Model was proven to be either infeasible or unbounded. To obtain a more definitive conclusion, set the DualReductions parameter to 0 and reoptimize.\",\n ),\n (\n TerminationStatusCode.DUAL_INFEASIBLE,\n \"Model was proven to be unbounded. Important note: an unbounded status indicates the presence of an unbounded ray that allows the objective to improve without limit. It says nothing about whether the model has a feasible solution. If you require information on feasibility, you should set the objective to zero and reoptimize.\",\n ),\n (\n TerminationStatusCode.OBJECTIVE_LIMIT,\n \"Optimal objective for model was proven to be worse than the value specified in the Cutoff parameter. No solution information is available.\",\n ),\n (\n TerminationStatusCode.ITERATION_LIMIT,\n \"Optimization terminated because the total number of simplex iterations performed exceeded the value specified in the IterationLimit parameter, or because the total number of barrier iterations exceeded the value specified in the BarIterLimit parameter.\",\n ),\n (\n TerminationStatusCode.NODE_LIMIT,\n \"Optimization terminated because the total number of branch-and-cut nodes explored exceeded the value specified in the NodeLimit parameter.\",\n ),\n (\n TerminationStatusCode.TIME_LIMIT,\n \"Optimization terminated because the time expended exceeded the value specified in the TimeLimit parameter.\",\n ),\n (\n TerminationStatusCode.SOLUTION_LIMIT,\n \"Optimization terminated because the number of solutions found reached the value specified in the SolutionLimit parameter.\",\n ),\n (TerminationStatusCode.INTERRUPTED, \"Optimization was terminated by the user.\"),\n (\n TerminationStatusCode.NUMERICAL_ERROR,\n \"Optimization was terminated due to unrecoverable numerical difficulties.\",\n ),\n (\n TerminationStatusCode.LOCALLY_SOLVED,\n \"Unable to satisfy optimality tolerances; a sub-optimal solution is available.\",\n ),\n (\n TerminationStatusCode.OTHER_ERROR,\n \"An asynchronous optimization call was made, but the associated optimization run is not yet complete.\",\n ),\n (\n TerminationStatusCode.OBJECTIVE_LIMIT,\n \"User specified an objective limit (a bound on either the best objective or the best bound), and that limit has been reached.\",\n ),\n (\n TerminationStatusCode.OTHER_LIMIT,\n \"Optimization terminated because the work expended exceeded the value specified in the WorkLimit parameter.\",\n ),\n (\n TerminationStatusCode.MEMORY_LIMIT,\n \"Optimization terminated because the total amount of allocated memory exceeded the value specified in the SoftMemLimit parameter.\",\n ),\n (\n TerminationStatusCode.LOCALLY_SOLVED,\n \"Model solved to local optimality. A solution satisfying the first-order optimality conditions (subject to tolerances) was found and is available.\",\n ),\n (\n TerminationStatusCode.LOCALLY_INFEASIBLE,\n \"Model appears to be locally infeasible. A first-order minimizer of a measure for the constraint violations was found.\",\n ),\n]\n\ngurobi_raw_type_map = {\n 0: \"char\",\n 1: int,\n 2: float,\n 3: str,\n}\n\n\ndef get_terminationstatus(model):\n status = model.get_model_raw_attribute_int(\"Status\")\n assert status >= 1 and status <= 19, f\"Unknown status code: {status}\"\n return _RAW_STATUS_STRINGS[status - 1][0]\n\n\ndef get_primalstatus(model):\n termination_status = get_terminationstatus(model)\n if termination_status in (\n TerminationStatusCode.DUAL_INFEASIBLE,\n TerminationStatusCode.INFEASIBLE_OR_UNBOUNDED,\n ):\n try:\n model.get_model_raw_attribute_list_double(\"UnbdRay\", [0])\n return ResultStatusCode.INFEASIBILITY_CERTIFICATE\n except:\n return ResultStatusCode.NO_SOLUTION\n solcount = model.get_model_raw_attribute_int(\"SolCount\")\n if solcount == 0:\n return ResultStatusCode.NO_SOLUTION\n else:\n return ResultStatusCode.FEASIBLE_POINT\n\n\ndef get_dualstatus(model):\n if model.get_model_raw_attribute_int(\"IsMIP\") != 0:\n return ResultStatusCode.NO_SOLUTION\n elif (\n model.get_model_raw_attribute_int(\"IsQCP\") != 0\n and model.get_model_raw_attribute(\"QCPDual\") != 1\n ):\n return ResultStatusCode.NO_SOLUTION\n termination_status = get_terminationstatus(model)\n if termination_status in (\n TerminationStatusCode.DUAL_INFEASIBLE,\n TerminationStatusCode.INFEASIBLE_OR_UNBOUNDED,\n ):\n try:\n model.get_model_raw_attribute_list_double(\"FarkasDual\", [0])\n return ResultStatusCode.INFEASIBILITY_CERTIFICATE\n except:\n return ResultStatusCode.NO_SOLUTION\n solcount = model.get_model_raw_attribute_int(\"SolCount\")\n if solcount == 0:\n return ResultStatusCode.NO_SOLUTION\n try:\n model.get_model_raw_attribute_list_double(\"RC\", [0])\n return ResultStatusCode.FEASIBLE_POINT\n except:\n return ResultStatusCode.NO_SOLUTION\n\n\ndef get_rawstatusstring(model):\n status = model.get_model_raw_attribute_int(\"Status\")\n assert status >= 1 and status <= 15, f\"Unknown status code: {status}\"\n return _RAW_STATUS_STRINGS[status - 1][1]\n\n\ndef get_silent(model):\n return model.get_model_raw_parameter_int(\"OutputFlag\") == 0\n\n\nmodel_attribute_get_func_map = {\n ModelAttribute.Name: lambda model: model.get_model_raw_attribute_string(\n \"ModelName\"\n ),\n ModelAttribute.ObjectiveSense: lambda model: model.get_model_raw_attribute_int(\n \"ModelSense\"\n ),\n ModelAttribute.BarrierIterations: lambda model: model.get_model_raw_attribute_int(\n \"BarIterCount\"\n ),\n ModelAttribute.DualObjectiveValue: lambda model: model.get_model_raw_attribute_double(\n \"ObjBound\"\n ),\n ModelAttribute.NodeCount: lambda model: model.get_model_raw_attribute_int(\n \"NodeCount\"\n ),\n ModelAttribute.ObjectiveBound: lambda model: model.get_model_raw_attribute_double(\n \"ObjBound\"\n ),\n ModelAttribute.ObjectiveValue: lambda model: model.get_model_raw_attribute_double(\n \"ObjVal\"\n ),\n ModelAttribute.SimplexIterations: lambda model: model.get_model_raw_attribute_int(\n \"IterCount\"\n ),\n ModelAttribute.SolveTimeSec: lambda model: model.get_model_raw_attribute_double(\n \"RunTime\"\n ),\n ModelAttribute.NumberOfThreads: lambda model: model.get_raw_parameter_int(\n \"Threads\"\n ),\n ModelAttribute.RelativeGap: lambda model: model.get_raw_parameter_double(\"MIPGap\"),\n ModelAttribute.TimeLimitSec: lambda model: model.get_raw_parameter_double(\n \"TimeLimit\"\n ),\n ModelAttribute.DualStatus: get_dualstatus,\n ModelAttribute.PrimalStatus: get_primalstatus,\n ModelAttribute.RawStatusString: get_rawstatusstring,\n ModelAttribute.TerminationStatus: get_terminationstatus,\n ModelAttribute.Silent: get_silent,\n ModelAttribute.SolverName: lambda _: \"Gurobi\",\n ModelAttribute.SolverVersion: lambda model: model.version_string(),\n}\n\nmodel_attribute_get_translate_func_map = {\n ModelAttribute.ObjectiveSense: lambda v: {\n GRB.MINIMIZE: ObjectiveSense.Minimize,\n GRB.MAXIMIZE: ObjectiveSense.Maximize,\n }[v],\n}\n\nmodel_attribute_set_translate_func_map = {\n ModelAttribute.ObjectiveSense: lambda v: {\n ObjectiveSense.Minimize: GRB.MINIMIZE,\n ObjectiveSense.Maximize: GRB.MAXIMIZE,\n }[v],\n}\n\n\ndef set_silent(model, value: bool):\n if value:\n model.set_raw_parameter_int(\"OutputFlag\", 0)\n else:\n model.set_raw_parameter_int(\"OutputFlag\", 1)\n\n\nmodel_attribute_set_func_map = {\n ModelAttribute.Name: lambda model, v: model.set_model_raw_attribute_string(\n \"ModelName\", v\n ),\n ModelAttribute.ObjectiveSense: lambda model, v: model.set_model_raw_attribute_int(\n \"ModelSense\", v\n ),\n ModelAttribute.NumberOfThreads: lambda model, v: model.set_raw_parameter_int(\n \"Threads\", v\n ),\n ModelAttribute.RelativeGap: lambda model, v: model.set_raw_parameter_double(\n \"MIPGap\", v\n ),\n ModelAttribute.TimeLimitSec: lambda model, v: model.set_raw_parameter_double(\n \"TimeLimit\", v\n ),\n ModelAttribute.Silent: set_silent,\n}\n\n# Constraint Attribute\n\n\ndef get_constraint_name(model, constraint):\n type = constraint.type\n attr_name_dict = {\n ConstraintType.Linear: \"ConstrName\",\n ConstraintType.Quadratic: \"QConstrName\",\n }\n attr_name = attr_name_dict.get(type, None)\n if not attr_name:\n raise ValueError(f\"Unknown constraint type: {type}\")\n return model.get_constraint_raw_attribute_string(constraint, attr_name)\n\n\ndef get_constraint_primal(model, constraint):\n # Linear : RHS - Slack\n # Quadratic : QCRHS - QCSlack\n type = constraint.type\n attr_name_dict = {\n ConstraintType.Linear: (\"RHS\", \"Slack\"),\n ConstraintType.Quadratic: (\"QCRHS\", \"QCSlack\"),\n }\n attr_name = attr_name_dict.get(type, None)\n if not attr_name:\n raise ValueError(f\"Unknown constraint type: {type}\")\n rhs = model.get_constraint_raw_attribute_double(constraint, attr_name[0])\n slack = model.get_constraint_raw_attribute_double(constraint, attr_name[1])\n return rhs - slack\n\n\ndef get_constraint_dual(model, constraint):\n type = constraint.type\n attr_name_dict = {\n ConstraintType.Linear: \"Pi\",\n ConstraintType.Quadratic: \"QCPi\",\n }\n attr_name = attr_name_dict.get(type, None)\n if not attr_name:\n raise ValueError(f\"Unknown constraint type: {type}\")\n return model.get_constraint_raw_attribute_double(constraint, attr_name)\n\n\ndef get_constraint_IIS(model, constraint):\n type = constraint.type\n attr_name_dict = {\n ConstraintType.Linear: \"IISConstr\",\n ConstraintType.SOS: \"IISSOS\",\n ConstraintType.Quadratic: \"IISQConstr\",\n }\n attr_name = attr_name_dict.get(type, None)\n if not attr_name:\n raise ValueError(f\"Unknown constraint type: {type}\")\n return model.get_constraint_raw_attribute_int(constraint, attr_name) > 0\n\n\nconstraint_attribute_get_func_map = {\n ConstraintAttribute.Name: get_constraint_name,\n ConstraintAttribute.Primal: get_constraint_primal,\n ConstraintAttribute.Dual: get_constraint_dual,\n ConstraintAttribute.IIS: get_constraint_IIS,\n}\n\nconstraint_attribute_set_func_map = {\n ConstraintAttribute.Name: lambda model, constraint, value: model.set_constraint_name(\n constraint, value\n ),\n}\n\ncallback_info_typemap = {\n GRB.Callback.RUNTIME: float,\n GRB.Callback.WORK: float,\n GRB.Callback.PRE_COLDEL: int,\n GRB.Callback.PRE_ROWDEL: int,\n GRB.Callback.PRE_SENCHG: int,\n GRB.Callback.PRE_BNDCHG: int,\n GRB.Callback.PRE_COECHG: int,\n GRB.Callback.SPX_ITRCNT: float,\n GRB.Callback.SPX_OBJVAL: float,\n GRB.Callback.SPX_PRIMINF: float,\n GRB.Callback.SPX_DUALINF: float,\n GRB.Callback.SPX_ISPERT: int,\n GRB.Callback.MIP_OBJBST: float,\n GRB.Callback.MIP_OBJBND: float,\n GRB.Callback.MIP_NODCNT: float,\n GRB.Callback.MIP_SOLCNT: int,\n GRB.Callback.MIP_CUTCNT: int,\n GRB.Callback.MIP_NODLFT: float,\n GRB.Callback.MIP_ITRCNT: float,\n GRB.Callback.MIP_OPENSCENARIOS: int,\n GRB.Callback.MIP_PHASE: int,\n GRB.Callback.MIPSOL_OBJ: float,\n GRB.Callback.MIPSOL_OBJBST: float,\n GRB.Callback.MIPSOL_OBJBND: float,\n GRB.Callback.MIPSOL_NODCNT: float,\n GRB.Callback.MIPSOL_SOLCNT: int,\n GRB.Callback.MIPSOL_OPENSCENARIOS: int,\n GRB.Callback.MIPSOL_PHASE: int,\n GRB.Callback.MIPNODE_STATUS: int,\n GRB.Callback.MIPNODE_OBJBST: float,\n GRB.Callback.MIPNODE_OBJBND: float,\n GRB.Callback.MIPNODE_NODCNT: float,\n GRB.Callback.MIPNODE_SOLCNT: int,\n GRB.Callback.MIPNODE_OPENSCENARIOS: int,\n GRB.Callback.MIPNODE_PHASE: int,\n GRB.Callback.MIPNODE_REL: float,\n GRB.Callback.BARRIER_ITRCNT: int,\n GRB.Callback.BARRIER_PRIMOBJ: float,\n GRB.Callback.BARRIER_DUALOBJ: float,\n GRB.Callback.BARRIER_PRIMINF: float,\n GRB.Callback.BARRIER_DUALINF: float,\n GRB.Callback.BARRIER_COMPL: float,\n}\n\n\nclass Env(RawEnv):\n def set_raw_parameter(self, param_name: str, value):\n param_type = gurobi_raw_type_map[self.raw_parameter_type(param_name)]\n set_function_map = {\n int: self.set_raw_parameter_int,\n float: self.set_raw_parameter_double,\n str: self.set_raw_parameter_string,\n }\n set_function = set_function_map[param_type]\n set_function(param_name, value)\n\n\nclass Model(RawModel):\n def __init__(self, env=None):\n if env is None:\n init_default_env()\n env = DEFAULT_ENV\n super().__init__(env)\n\n # We must keep a reference to the environment to prevent it from being garbage collected\n self._env = env\n\n # Replace default logging behavior to use Python print\n # otherwise it prints directly to stdout/stderr bypassing Python and causing issues in Jupyter notebooks\n self.set_raw_parameter(\"LogToConsole\", 0)\n self.set_logging(lambda msg: print(msg, end=\"\"))\n\n @staticmethod\n def supports_variable_attribute(attribute: VariableAttribute, settable=False):\n if settable:\n return attribute in variable_attribute_set_func_map\n else:\n return attribute in variable_attribute_get_func_map\n\n @staticmethod\n def supports_model_attribute(attribute: ModelAttribute, settable=False):\n if settable:\n return attribute in model_attribute_set_func_map\n else:\n return attribute in model_attribute_get_func_map\n\n @staticmethod\n def supports_constraint_attribute(attribute: ConstraintAttribute, settable=False):\n if settable:\n return attribute in constraint_attribute_set_func_map\n else:\n return attribute in constraint_attribute_get_func_map\n\n def get_variable_attribute(self, variable, attribute: VariableAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown variable attribute to get: {attribute}\")\n\n value = _get_entity_attribute(\n self,\n variable,\n attribute,\n variable_attribute_get_func_map,\n variable_attribute_get_translate_func_map,\n e,\n )\n return value\n\n def set_variable_attribute(self, variable, attribute: VariableAttribute, value):\n def e(attribute):\n raise ValueError(f\"Unknown variable attribute to set: {attribute}\")\n\n _set_entity_attribute(\n self,\n variable,\n attribute,\n value,\n variable_attribute_set_func_map,\n variable_attribute_set_translate_func_map,\n e,\n )\n\n def number_of_constraints(self, type: ConstraintType):\n attr_name = constraint_type_attribute_name_map.get(type, None)\n if not attr_name:\n raise ValueError(f\"Unknown constraint type: {type}\")\n return self.get_model_raw_attribute_int(attr_name)\n\n def number_of_variables(self):\n return self.get_model_raw_attribute_int(\"NumVars\")\n\n def get_model_attribute(self, attribute: ModelAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown model attribute to get: {attribute}\")\n\n value = _get_model_attribute(\n self,\n attribute,\n model_attribute_get_func_map,\n model_attribute_get_translate_func_map,\n e,\n )\n return value\n\n def set_model_attribute(self, attribute: ModelAttribute, value):\n def e(attribute):\n raise ValueError(f\"Unknown model attribute to set: {attribute}\")\n\n _set_model_attribute(\n self,\n attribute,\n value,\n model_attribute_set_func_map,\n model_attribute_set_translate_func_map,\n e,\n )\n\n def get_constraint_attribute(self, constraint, attribute: ConstraintAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown constraint attribute to get: {attribute}\")\n\n value = _direct_get_entity_attribute(\n self,\n constraint,\n attribute,\n constraint_attribute_get_func_map,\n e,\n )\n return value\n\n def set_constraint_attribute(\n self, constraint, attribute: ConstraintAttribute, value\n ):\n def e(attribute):\n raise ValueError(f\"Unknown constraint attribute to set: {attribute}\")\n\n _direct_set_entity_attribute(\n self,\n constraint,\n attribute,\n value,\n constraint_attribute_set_func_map,\n e,\n )\n\n def get_raw_parameter(self, param_name: str):\n param_type = gurobi_raw_type_map[self.raw_parameter_type(param_name)]\n get_function_map = {\n int: self.get_raw_parameter_int,\n float: self.get_raw_parameter_double,\n str: self.get_raw_parameter_string,\n }\n get_function = get_function_map[param_type]\n return get_function(param_name)\n\n def set_raw_parameter(self, param_name: str, value):\n param_type = gurobi_raw_type_map[self.raw_parameter_type(param_name)]\n set_function_map = {\n int: self.set_raw_parameter_int,\n float: self.set_raw_parameter_double,\n str: self.set_raw_parameter_string,\n }\n set_function = set_function_map[param_type]\n set_function(param_name, value)\n\n def get_model_raw_attribute(self, name: str):\n param_type = gurobi_raw_type_map[self.raw_attribute_type(name)]\n get_function_map = {\n int: self.get_model_raw_attribute_int,\n float: self.get_model_raw_attribute_double,\n str: self.get_model_raw_attribute_string,\n }\n get_function = get_function_map[param_type]\n return get_function(name)\n\n def set_model_raw_attribute(self, name: str, value):\n param_type = gurobi_raw_type_map[self.raw_attribute_type(name)]\n set_function_map = {\n int: self.set_model_raw_attribute_int,\n float: self.set_model_raw_attribute_double,\n str: self.set_model_raw_attribute_string,\n }\n set_function = set_function_map[param_type]\n set_function(name, value)\n\n def get_variable_raw_attribute(self, variable, name: str):\n param_type = gurobi_raw_type_map[self.raw_attribute_type(name)]\n get_function_map = {\n \"char\": self.get_variable_raw_attribute_char,\n int: self.get_variable_raw_attribute_int,\n float: self.get_variable_raw_attribute_double,\n str: self.get_variable_raw_attribute_string,\n }\n get_function = get_function_map[param_type]\n return get_function(variable, name)\n\n def set_variable_raw_attribute(self, variable, name: str, value):\n param_type = gurobi_raw_type_map[self.raw_attribute_type(name)]\n set_function_map = {\n \"char\": self.set_variable_raw_attribute_char,\n int: self.set_variable_raw_attribute_int,\n float: self.set_variable_raw_attribute_double,\n str: self.set_variable_raw_attribute_string,\n }\n set_function = set_function_map[param_type]\n set_function(variable, name, value)\n\n def get_constraint_raw_attribute(self, constraint, name: str):\n param_type = gurobi_raw_type_map[self.raw_attribute_type(name)]\n get_function_map = {\n \"char\": self.get_constraint_raw_attribute_char,\n int: self.get_constraint_raw_attribute_int,\n float: self.get_constraint_raw_attribute_double,\n str: self.get_constraint_raw_attribute_string,\n }\n get_function = get_function_map[param_type]\n return get_function(constraint, name)\n\n def set_constraint_raw_attribute(self, constraint, name: str, value):\n param_type = gurobi_raw_type_map[self.raw_attribute_type(name)]\n set_function_map = {\n \"char\": self.set_constraint_raw_attribute_char,\n int: self.set_constraint_raw_attribute_int,\n float: self.set_constraint_raw_attribute_double,\n str: self.set_constraint_raw_attribute_string,\n }\n set_function = set_function_map[param_type]\n set_function(constraint, name, value)\n\n def cb_get_info(self, what):\n cb_info_type = callback_info_typemap.get(what, None)\n if cb_info_type is None:\n raise ValueError(f\"Unknown callback info type: {what}\")\n if cb_info_type is int:\n return self.cb_get_info_int(what)\n elif cb_info_type is float:\n return self.cb_get_info_double(what)\n else:\n raise ValueError(f\"Unknown callback info type: {what}\")\n\n @overload\n def add_linear_constraint(\n self,\n expr: Union[VariableIndex, ScalarAffineFunction, ExprBuilder],\n sense: ConstraintSense,\n rhs: float,\n name: str = \"\",\n ): ...\n\n @overload\n def add_linear_constraint(\n self,\n con: ComparisonConstraint,\n name: str = \"\",\n ): ...\n\n def add_linear_constraint(self, arg, *args, **kwargs):\n if isinstance(arg, ComparisonConstraint):\n return self._add_linear_constraint(\n arg.lhs, arg.sense, arg.rhs, *args, **kwargs\n )\n else:\n return self._add_linear_constraint(arg, *args, **kwargs)\n\n @overload\n def add_quadratic_constraint(\n self,\n expr: Union[ScalarQuadraticFunction, ExprBuilder],\n sense: ConstraintSense,\n rhs: float,\n name: str = \"\",\n ): ...\n\n @overload\n def add_quadratic_constraint(\n self,\n con: ComparisonConstraint,\n name: str = \"\",\n ): ...\n\n def add_quadratic_constraint(self, arg, *args, **kwargs):\n if isinstance(arg, ComparisonConstraint):\n return self._add_quadratic_constraint(\n arg.lhs, arg.sense, arg.rhs, *args, **kwargs\n )\n else:\n return self._add_quadratic_constraint(arg, *args, **kwargs)\n\n @overload\n def add_nl_constraint(\n self,\n expr,\n sense: ConstraintSense,\n rhs: float,\n /,\n name: str = \"\",\n ): ...\n\n @overload\n def add_nl_constraint(\n self,\n expr,\n interval: Tuple[float, float],\n /,\n name: str = \"\",\n ): ...\n\n @overload\n def add_nl_constraint(\n self,\n con,\n /,\n name: str = \"\",\n ): ...\n\n def add_nl_constraint(self, expr, *args, **kwargs):\n graph = ExpressionGraphContext.current_graph()\n expr = convert_to_expressionhandle(graph, expr)\n if not isinstance(expr, ExpressionHandle):\n raise ValueError(\n \"Expression should be able to be converted to ExpressionHandle\"\n )\n\n con = self._add_single_nl_constraint(graph, expr, *args, **kwargs)\n\n return con\n\n def add_nl_objective(self, expr):\n graph = ExpressionGraphContext.current_graph()\n expr = convert_to_expressionhandle(graph, expr)\n if not isinstance(expr, ExpressionHandle):\n raise ValueError(\n \"Expression should be able to be converted to ExpressionHandle\"\n )\n self._add_single_nl_objective(graph, expr)\n\n add_variables = make_variable_tupledict\n add_m_variables = make_variable_ndarray\n add_m_linear_constraints = add_matrix_constraints\n add_second_order_cone_constraint = bridge_soc_quadratic_constraint\n" }, { "path": "src/pyoptinterface/_src/highs.py", "content": "import logging\nimport os\nimport platform\nfrom pathlib import Path\nfrom typing import Dict, Union, overload\n\nfrom .highs_model_ext import (\n RawModel,\n HighsSolutionStatus,\n Enum,\n load_library,\n)\nfrom .attributes import (\n VariableAttribute,\n ConstraintAttribute,\n ModelAttribute,\n ResultStatusCode,\n TerminationStatusCode,\n)\nfrom .core_ext import (\n VariableIndex,\n ScalarAffineFunction,\n ExprBuilder,\n ConstraintType,\n ConstraintSense,\n)\nfrom .comparison_constraint import ComparisonConstraint\nfrom .solver_common import (\n _direct_get_model_attribute,\n _direct_set_model_attribute,\n _direct_get_entity_attribute,\n _direct_set_entity_attribute,\n)\nfrom .aml import make_variable_tupledict, make_variable_ndarray\nfrom .matrix import add_matrix_constraints\n\n\ndef detected_libraries():\n libs = []\n\n subdir = {\n \"Linux\": \"lib\",\n \"Darwin\": \"lib\",\n \"Windows\": \"bin\",\n }[platform.system()]\n libname = {\n \"Linux\": \"libhighs.so\",\n \"Darwin\": \"libhighs.dylib\",\n \"Windows\": \"highs.dll\",\n }[platform.system()]\n\n # Environment\n home = os.environ.get(\"HiGHS_HOME\", None)\n if home and os.path.exists(home):\n lib = Path(home) / subdir / libname\n if lib.exists():\n libs.append(str(lib))\n\n # HiGHS pypi installation\n try:\n import highsbox\n\n home = highsbox.highs_dist_dir()\n\n if os.path.exists(home):\n lib = Path(home) / subdir / libname\n if lib.exists():\n libs.append(str(lib))\n except Exception:\n pass\n\n # default names\n default_libname = libname\n libs.append(default_libname)\n\n return libs\n\n\ndef autoload_library():\n libs = detected_libraries()\n for lib in libs:\n ret = load_library(lib)\n if ret:\n logging.info(f\"Loaded HiGHS library: {lib}\")\n return True\n return False\n\n\nautoload_library()\n\n\nvariable_attribute_get_func_map = {\n VariableAttribute.Value: lambda model, v: model.get_value(v),\n VariableAttribute.LowerBound: lambda model, v: model.get_variable_lower_bound(v),\n VariableAttribute.UpperBound: lambda model, v: model.get_variable_upper_bound(v),\n VariableAttribute.PrimalStart: lambda model, v: model.mip_start_values.get(v, None),\n VariableAttribute.Domain: lambda model, v: model.get_variable_type(v),\n VariableAttribute.Name: lambda model, v: model.get_variable_name(v),\n VariableAttribute.ReducedCost: lambda model, v: model.get_variable_dual(v),\n}\n\nvariable_attribute_set_func_map = {\n VariableAttribute.LowerBound: lambda model, v, val: model.set_variable_lower_bound(\n v, val\n ),\n VariableAttribute.UpperBound: lambda model, v, val: model.set_variable_upper_bound(\n v, val\n ),\n VariableAttribute.PrimalStart: lambda model, v, val: model.mip_start_values.__setitem__(\n v, val\n ),\n VariableAttribute.Domain: lambda model, v, val: model.set_variable_type(v, val),\n VariableAttribute.Name: lambda model, v, val: model.set_variable_name(v, val),\n}\n\n\ndef get_dualstatus(model):\n sol = model.solution\n if sol.dual_solution_status == Enum.kHighsSolutionStatusFeasible:\n return ResultStatusCode.FEASIBLE_POINT\n elif sol.dual_solution_status == Enum.kHighsSolutionStatusInfeasible:\n return ResultStatusCode.INFEASIBLE_POINT\n elif model.solution.has_dual_ray:\n return ResultStatusCode.INFEASIBILITY_CERTIFICATE\n else:\n return ResultStatusCode.NO_SOLUTION\n\n\ndef get_primalstatus(model):\n sol = model.solution\n if sol.primal_solution_status == Enum.kHighsSolutionStatusFeasible:\n return ResultStatusCode.FEASIBLE_POINT\n elif sol.primal_solution_status == Enum.kHighsSolutionStatusInfeasible:\n return ResultStatusCode.INFEASIBLE_POINT\n elif sol.has_primal_ray:\n return ResultStatusCode.INFEASIBILITY_CERTIFICATE\n return ResultStatusCode.NO_SOLUTION\n\n\ndef get_rawstatusstring(model):\n status = model.solution.status\n model_status = model.solution.model_status\n if status == HighsSolutionStatus.OPTIMIZE_NOT_CALLED:\n return \"OPTIMIZE_NOT_CALLED\"\n elif status == HighsSolutionStatus.OPTIMIZE_ERROR:\n return \"There was an error calling optimize!\"\n elif model_status == Enum.kHighsModelStatusNotset:\n return \"kHighsModelStatusNotset\"\n elif model_status == Enum.kHighsModelStatusLoadError:\n return \"kHighsModelStatusLoadError\"\n elif model_status == Enum.kHighsModelStatusModelError:\n return \"kHighsModelStatusModelError\"\n elif model_status == Enum.kHighsModelStatusPresolveError:\n return \"kHighsModelStatusPresolveError\"\n elif model_status == Enum.kHighsModelStatusSolveError:\n return \"kHighsModelStatusSolveError\"\n elif model_status == Enum.kHighsModelStatusPostsolveError:\n return \"kHighsModelStatusPostsolveError\"\n elif model_status == Enum.kHighsModelStatusModelEmpty:\n return \"kHighsModelStatusModelEmpty\"\n elif model_status == Enum.kHighsModelStatusOptimal:\n return \"kHighsModelStatusOptimal\"\n elif model_status == Enum.kHighsModelStatusInfeasible:\n return \"kHighsModelStatusInfeasible\"\n elif model_status == Enum.kHighsModelStatusUnboundedOrInfeasible:\n return \"kHighsModelStatusUnboundedOrInfeasible\"\n elif model_status == Enum.kHighsModelStatusUnbounded:\n return \"kHighsModelStatusUnbounded\"\n elif model_status == Enum.kHighsModelStatusObjectiveBound:\n return \"kHighsModelStatusObjectiveBound\"\n elif model_status == Enum.kHighsModelStatusObjectiveTarget:\n return \"kHighsModelStatusObjectiveTarget\"\n elif model_status == Enum.kHighsModelStatusTimeLimit:\n return \"kHighsModelStatusTimeLimit\"\n elif model_status == Enum.kHighsModelStatusIterationLimit:\n return \"kHighsModelStatusIterationLimit\"\n else:\n assert model_status == Enum.kHighsModelStatusUnknown\n return \"kHighsModelStatusUnknown\"\n\n\ndef get_terminationstatus(model):\n status = model.solution.status\n model_status = model.solution.model_status\n if status == HighsSolutionStatus.OPTIMIZE_NOT_CALLED:\n return TerminationStatusCode.OPTIMIZE_NOT_CALLED\n elif status == HighsSolutionStatus.OPTIMIZE_ERROR:\n return TerminationStatusCode.OTHER_ERROR\n elif model_status == Enum.kHighsModelStatusNotset:\n return TerminationStatusCode.OTHER_ERROR\n elif model_status == Enum.kHighsModelStatusLoadError:\n return TerminationStatusCode.OTHER_ERROR\n elif model_status == Enum.kHighsModelStatusModelError:\n return TerminationStatusCode.INVALID_MODEL\n elif model_status == Enum.kHighsModelStatusPresolveError:\n return TerminationStatusCode.OTHER_ERROR\n elif model_status == Enum.kHighsModelStatusSolveError:\n return TerminationStatusCode.OTHER_ERROR\n elif model_status == Enum.kHighsModelStatusPostsolveError:\n return TerminationStatusCode.OTHER_ERROR\n elif model_status == Enum.kHighsModelStatusModelEmpty:\n return TerminationStatusCode.INVALID_MODEL\n elif model_status == Enum.kHighsModelStatusOptimal:\n return TerminationStatusCode.OPTIMAL\n elif model_status == Enum.kHighsModelStatusInfeasible:\n return TerminationStatusCode.INFEASIBLE\n elif model_status == Enum.kHighsModelStatusUnboundedOrInfeasible:\n return TerminationStatusCode.INFEASIBLE_OR_UNBOUNDED\n elif model_status == Enum.kHighsModelStatusUnbounded:\n return TerminationStatusCode.DUAL_INFEASIBLE\n elif model_status == Enum.kHighsModelStatusObjectiveBound:\n return TerminationStatusCode.OBJECTIVE_LIMIT\n elif model_status == Enum.kHighsModelStatusObjectiveTarget:\n return TerminationStatusCode.OBJECTIVE_LIMIT\n elif model_status == Enum.kHighsModelStatusTimeLimit:\n return TerminationStatusCode.TIME_LIMIT\n elif model_status == Enum.kHighsModelStatusIterationLimit:\n return TerminationStatusCode.ITERATION_LIMIT\n elif model_status == Enum.kHighsModelStatusUnknown:\n return TerminationStatusCode.OTHER_ERROR\n else:\n assert model_status == Enum.kHighsModelStatusSolutionLimit\n return TerminationStatusCode.SOLUTION_LIMIT\n\n\nmodel_attribute_get_func_map = {\n ModelAttribute.ObjectiveSense: lambda model: model.get_obj_sense(),\n # ModelAttribute.DualObjectiveValue: lambda model: model.getdualobj(),\n ModelAttribute.ObjectiveValue: lambda model: model.get_obj_value(),\n ModelAttribute.SolveTimeSec: lambda model: model.getruntime(),\n ModelAttribute.NumberOfThreads: lambda model: model.get_raw_option_int(\"threads\"),\n ModelAttribute.RelativeGap: lambda model: model.get_raw_option_double(\n \"mip_rel_gap\"\n ),\n ModelAttribute.TimeLimitSec: lambda model: model.get_raw_option_double(\n \"time_limit\"\n ),\n ModelAttribute.DualStatus: get_dualstatus,\n ModelAttribute.PrimalStatus: get_primalstatus,\n ModelAttribute.RawStatusString: get_rawstatusstring,\n ModelAttribute.TerminationStatus: get_terminationstatus,\n ModelAttribute.Silent: lambda model: not model.get_raw_option_bool(\"output_flag\"),\n ModelAttribute.SolverName: lambda _: \"HiGHS\",\n ModelAttribute.SolverVersion: lambda model: model.version_string(),\n}\n\nmodel_attribute_set_func_map = {\n ModelAttribute.ObjectiveSense: lambda model, v: model.set_obj_sense(v),\n ModelAttribute.NumberOfThreads: lambda model, v: model.set_raw_option_int(\n \"threads\", v\n ),\n ModelAttribute.RelativeGap: lambda model, v: model.set_raw_option_double(\n \"mip_rel_gap\", v\n ),\n ModelAttribute.TimeLimitSec: lambda model, v: model.set_raw_option_double(\n \"time_limit\", v\n ),\n ModelAttribute.Silent: lambda model, v: model.set_raw_option_bool(\n \"output_flag\", not v\n ),\n}\n\nconstraint_attribute_get_func_map = {\n ConstraintAttribute.Name: lambda model, constraint: model.get_constraint_name(\n constraint\n ),\n ConstraintAttribute.Primal: lambda model, constraint: model.get_constraint_primal(\n constraint\n ),\n ConstraintAttribute.Dual: lambda model, constraint: model.get_constraint_dual(\n constraint\n ),\n}\n\nconstraint_attribute_set_func_map = {\n ConstraintAttribute.Name: lambda model, constraint, value: model.set_constraint_name(\n constraint, value\n ),\n}\n\nhighs_option_raw_type_map = {\n Enum.kHighsOptionTypeBool: bool,\n Enum.kHighsOptionTypeInt: int,\n Enum.kHighsOptionTypeDouble: float,\n Enum.kHighsOptionTypeString: str,\n}\n\nhighs_info_raw_type_map = {\n Enum.kHighsInfoTypeInt: int,\n Enum.kHighsInfoTypeInt64: \"int64\",\n Enum.kHighsInfoTypeDouble: float,\n}\n\n\nclass Model(RawModel):\n def __init__(self):\n super().__init__()\n\n self.mip_start_values: Dict[VariableIndex, float] = dict()\n\n @staticmethod\n def supports_variable_attribute(attribute: VariableAttribute, settable=False):\n if settable:\n return attribute in variable_attribute_set_func_map\n else:\n return attribute in variable_attribute_get_func_map\n\n @staticmethod\n def supports_model_attribute(attribute: ModelAttribute, settable=False):\n if settable:\n return attribute in model_attribute_set_func_map\n else:\n return attribute in model_attribute_get_func_map\n\n @staticmethod\n def supports_constraint_attribute(attribute: ConstraintAttribute, settable=False):\n if settable:\n return attribute in constraint_attribute_set_func_map\n else:\n return attribute in constraint_attribute_get_func_map\n\n def get_variable_attribute(self, variable, attribute: VariableAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown variable attribute to get: {attribute}\")\n\n value = _direct_get_entity_attribute(\n self,\n variable,\n attribute,\n variable_attribute_get_func_map,\n e,\n )\n return value\n\n def set_variable_attribute(self, variable, attribute: VariableAttribute, value):\n def e(attribute):\n raise ValueError(f\"Unknown variable attribute to set: {attribute}\")\n\n _direct_set_entity_attribute(\n self,\n variable,\n attribute,\n value,\n variable_attribute_set_func_map,\n e,\n )\n\n def number_of_constraints(self, type: ConstraintType):\n if type not in {ConstraintType.Linear}:\n raise ValueError(f\"Unknown constraint type: {type}\")\n return self.m_n_constraints\n\n def number_of_variables(self):\n return self.m_n_variables\n\n def get_model_attribute(self, attribute: ModelAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown model attribute to get: {attribute}\")\n\n value = _direct_get_model_attribute(\n self,\n attribute,\n model_attribute_get_func_map,\n e,\n )\n return value\n\n def set_model_attribute(self, attribute: ModelAttribute, value):\n def e(attribute):\n raise ValueError(f\"Unknown model attribute to set: {attribute}\")\n\n _direct_set_model_attribute(\n self,\n attribute,\n value,\n model_attribute_set_func_map,\n e,\n )\n\n def get_constraint_attribute(self, constraint, attribute: ConstraintAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown constraint attribute to get: {attribute}\")\n\n value = _direct_get_entity_attribute(\n self,\n constraint,\n attribute,\n constraint_attribute_get_func_map,\n e,\n )\n return value\n\n def set_constraint_attribute(\n self, constraint, attribute: ConstraintAttribute, value\n ):\n def e(attribute):\n raise ValueError(f\"Unknown constraint attribute to set: {attribute}\")\n\n _direct_set_entity_attribute(\n self,\n constraint,\n attribute,\n value,\n constraint_attribute_set_func_map,\n e,\n )\n\n def get_raw_parameter(self, param_name: str):\n param_type = highs_option_raw_type_map[self.raw_option_type(param_name)]\n get_function_map = {\n bool: self.get_raw_option_bool,\n int: self.get_raw_option_int,\n float: self.get_raw_option_double,\n str: self.get_raw_option_string,\n }\n get_function = get_function_map[param_type]\n return get_function(param_name)\n\n def set_raw_parameter(self, param_name: str, value):\n param_type = highs_option_raw_type_map[self.raw_option_type(param_name)]\n set_function_map = {\n bool: self.set_raw_option_bool,\n int: self.set_raw_option_int,\n float: self.set_raw_option_double,\n str: self.set_raw_option_string,\n }\n set_function = set_function_map[param_type]\n set_function(param_name, value)\n\n def get_raw_information(self, param_name: str):\n param_type = highs_info_raw_type_map[self.raw_info_type(param_name)]\n get_function_map = {\n int: self.get_raw_attribute_int,\n \"int64\": self.get_raw_attribute_int64,\n float: self.get_raw_attribute_double,\n }\n get_function = get_function_map[param_type]\n return get_function(param_name)\n\n def optimize(self):\n mip_start = self.mip_start_values\n if len(mip_start) != 0:\n variables = list(mip_start.keys())\n values = list(mip_start.values())\n self.set_primal_start(variables, values)\n mip_start.clear()\n super().optimize()\n\n @overload\n def add_linear_constraint(\n self,\n expr: Union[VariableIndex, ScalarAffineFunction, ExprBuilder],\n sense: ConstraintSense,\n rhs: float,\n name: str = \"\",\n ): ...\n\n @overload\n def add_linear_constraint(\n self,\n con: ComparisonConstraint,\n name: str = \"\",\n ): ...\n\n def add_linear_constraint(self, arg, *args, **kwargs):\n if isinstance(arg, ComparisonConstraint):\n return self._add_linear_constraint(\n arg.lhs, arg.sense, arg.rhs, *args, **kwargs\n )\n else:\n return self._add_linear_constraint(arg, *args, **kwargs)\n\n add_variables = make_variable_tupledict\n add_m_variables = make_variable_ndarray\n add_m_linear_constraints = add_matrix_constraints\n" }, { "path": "src/pyoptinterface/_src/ipopt.py", "content": "from io import StringIO\nimport logging\nimport platform\nfrom typing import Optional, List, Dict, Set, Union, Tuple, overload\n\nfrom llvmlite import ir\n\nfrom .ipopt_model_ext import RawModel, ApplicationReturnStatus, load_library\nfrom .codegen_c import generate_csrc_prelude, generate_csrc_from_graph\nfrom .jit_c import TCCJITCompiler\nfrom .codegen_llvm import create_llvmir_basic_functions, generate_llvmir_from_graph\nfrom .jit_llvm import LLJITCompiler\nfrom .nlexpr_ext import ExpressionHandle, ExpressionGraph, unpack_comparison_expression\nfrom .nlfunc import (\n ExpressionGraphContext,\n convert_to_expressionhandle,\n)\n\nfrom .core_ext import (\n VariableIndex,\n ScalarAffineFunction,\n ScalarQuadraticFunction,\n ExprBuilder,\n ConstraintSense,\n)\nfrom .comparison_constraint import ComparisonConstraint\nfrom .nleval_ext import (\n AutodiffSymbolicStructure,\n ConstraintAutodiffEvaluator,\n ObjectiveAutodiffEvaluator,\n)\nfrom .cppad_interface_ext import (\n CppADAutodiffGraph,\n cppad_trace_graph_constraints,\n cppad_trace_graph_objective,\n cppad_autodiff,\n)\n\nfrom .attributes import (\n VariableAttribute,\n ConstraintAttribute,\n ModelAttribute,\n ResultStatusCode,\n TerminationStatusCode,\n)\nfrom .solver_common import (\n _direct_get_model_attribute,\n _direct_set_model_attribute,\n _direct_get_entity_attribute,\n _direct_set_entity_attribute,\n)\nfrom .constraint_bridge import bridge_soc_quadratic_constraint\nfrom .aml import make_variable_tupledict, make_variable_ndarray\nfrom .matrix import add_matrix_constraints\n\n\ndef detected_libraries():\n libs = []\n\n # default names\n default_libnames = {\n \"Linux\": [\"libipopt.so\"],\n \"Darwin\": [\"libipopt.dylib\"],\n \"Windows\": [\"ipopt-3.dll\", \"ipopt.dll\", \"libipopt-3.dll\", \"libipopt.dll\"],\n }[platform.system()]\n libs.extend(default_libnames)\n\n return libs\n\n\ndef autoload_library():\n libs = detected_libraries()\n for lib in libs:\n ret = load_library(lib)\n if ret:\n logging.info(f\"Loaded IPOPT library: {lib}\")\n return True\n return False\n\n\nautoload_library()\n\nvariable_attribute_get_func_map = {\n VariableAttribute.Value: lambda model, v: model.get_value(v),\n VariableAttribute.LowerBound: lambda model, v: model.get_variable_lb(v),\n VariableAttribute.UpperBound: lambda model, v: model.get_variable_ub(v),\n VariableAttribute.PrimalStart: lambda model, v: model.get_variable_start(v),\n VariableAttribute.Name: lambda model, v: model.get_variable_name(v),\n}\n\nvariable_attribute_set_func_map = {\n VariableAttribute.LowerBound: lambda model, v, val: model.set_variable_lb(v, val),\n VariableAttribute.UpperBound: lambda model, v, val: model.set_variable_ub(v, val),\n VariableAttribute.PrimalStart: lambda model, v, val: model.set_variable_start(\n v, val\n ),\n VariableAttribute.Name: lambda model, v, val: model.set_variable_name(v, val),\n}\n\n\ndef get_dualstatus(model):\n status = model.m_status\n if status == ApplicationReturnStatus.Solve_Succeeded:\n return ResultStatusCode.FEASIBLE_POINT\n elif status == ApplicationReturnStatus.Feasible_Point_Found:\n return ResultStatusCode.FEASIBLE_POINT\n elif status == ApplicationReturnStatus.Solved_To_Acceptable_Level:\n return ResultStatusCode.NEARLY_FEASIBLE_POINT\n else:\n return ResultStatusCode.UNKNOWN_RESULT_STATUS\n\n\ndef get_primalstatus(model):\n status = model.m_status\n if status == ApplicationReturnStatus.Solve_Succeeded:\n return ResultStatusCode.FEASIBLE_POINT\n elif status == ApplicationReturnStatus.Feasible_Point_Found:\n return ResultStatusCode.FEASIBLE_POINT\n elif status == ApplicationReturnStatus.Solved_To_Acceptable_Level:\n return ResultStatusCode.NEARLY_FEASIBLE_POINT\n elif status == ApplicationReturnStatus.Infeasible_Problem_Detected:\n return ResultStatusCode.INFEASIBLE_POINT\n else:\n return ResultStatusCode.UNKNOWN_RESULT_STATUS\n\n\ndef get_rawstatusstring(model):\n status = model.m_status\n return status.name\n\n\ndef get_terminationstatus(model):\n is_dirty = model.m_is_dirty\n if is_dirty:\n return TerminationStatusCode.OPTIMIZE_NOT_CALLED\n status = model.m_status\n if (\n status == ApplicationReturnStatus.Solve_Succeeded\n or status == ApplicationReturnStatus.Feasible_Point_Found\n ):\n return TerminationStatusCode.LOCALLY_SOLVED\n elif status == ApplicationReturnStatus.Infeasible_Problem_Detected:\n return TerminationStatusCode.LOCALLY_INFEASIBLE\n elif status == ApplicationReturnStatus.Solved_To_Acceptable_Level:\n return TerminationStatusCode.ALMOST_LOCALLY_SOLVED\n elif status == ApplicationReturnStatus.Search_Direction_Becomes_Too_Small:\n return TerminationStatusCode.NUMERICAL_ERROR\n elif status == ApplicationReturnStatus.Diverging_Iterates:\n return TerminationStatusCode.NORM_LIMIT\n elif status == ApplicationReturnStatus.User_Requested_Stop:\n return TerminationStatusCode.INTERRUPTED\n elif status == ApplicationReturnStatus.Maximum_Iterations_Exceeded:\n return TerminationStatusCode.ITERATION_LIMIT\n elif status == ApplicationReturnStatus.Maximum_CpuTime_Exceeded:\n return TerminationStatusCode.TIME_LIMIT\n elif status == ApplicationReturnStatus.Maximum_WallTime_Exceeded:\n return TerminationStatusCode.TIME_LIMIT\n elif status == ApplicationReturnStatus.Restoration_Failed:\n return TerminationStatusCode.NUMERICAL_ERROR\n elif status == ApplicationReturnStatus.Error_In_Step_Computation:\n return TerminationStatusCode.NUMERICAL_ERROR\n elif status == ApplicationReturnStatus.Invalid_Option:\n return TerminationStatusCode.INVALID_OPTION\n elif status == ApplicationReturnStatus.Not_Enough_Degrees_Of_Freedom:\n return TerminationStatusCode.INVALID_MODEL\n elif status == ApplicationReturnStatus.Invalid_Problem_Definition:\n return TerminationStatusCode.INVALID_MODEL\n elif status == ApplicationReturnStatus.Invalid_Number_Detected:\n return TerminationStatusCode.INVALID_MODEL\n elif status == ApplicationReturnStatus.Unrecoverable_Exception:\n return TerminationStatusCode.OTHER_ERROR\n elif status == ApplicationReturnStatus.NonIpopt_Exception_Thrown:\n return TerminationStatusCode.OTHER_ERROR\n else:\n assert status == ApplicationReturnStatus.Insufficient_Memory\n return TerminationStatusCode.MEMORY_LIMIT\n\n\nmodel_attribute_get_func_map = {\n ModelAttribute.ObjectiveValue: lambda model: model.get_obj_value(),\n ModelAttribute.DualStatus: get_dualstatus,\n ModelAttribute.PrimalStatus: get_primalstatus,\n ModelAttribute.RawStatusString: get_rawstatusstring,\n ModelAttribute.TerminationStatus: get_terminationstatus,\n ModelAttribute.SolverName: lambda _: \"IPOPT\",\n}\n\nmodel_attribute_set_func_map = {\n ModelAttribute.TimeLimitSec: lambda model, v: model.set_raw_parameter(\n \"max_wall_time\", v\n ),\n ModelAttribute.Silent: lambda model, v: model.set_raw_parameter(\n \"print_level\", 0 if v else 5\n ),\n}\n\n\ndef get_constraint_primal(model, constraint):\n return model.get_constraint_primal(constraint)\n\n\ndef get_constraint_dual(model, constraint):\n return model.get_constraint_dual(constraint)\n\n\nconstraint_attribute_get_func_map = {\n ConstraintAttribute.Primal: get_constraint_primal,\n ConstraintAttribute.Dual: get_constraint_dual,\n}\n\nconstraint_attribute_set_func_map = {}\n\n\nclass Model(RawModel):\n def __init__(self, jit: str = \"LLVM\"):\n super().__init__()\n\n if jit == \"C\":\n self.jit_compiler = TCCJITCompiler()\n elif jit == \"LLVM\":\n self.jit_compiler = LLJITCompiler()\n else:\n raise ValueError(f\"JIT engine can only be 'C' or 'LLVM', got {jit}\")\n self.jit = jit\n\n # store graph_instance to graph_index\n self.graph_instance_to_index: Dict[ExpressionGraph, int] = {}\n self.graph_instances: List[ExpressionGraph] = []\n\n self.nl_constraint_group_num = 0\n self.nl_constraint_group_representatives: List[int] = []\n self.nl_constraint_cppad_autodiff_graphs: List[CppADAutodiffGraph] = []\n self.nl_constraint_autodiff_structures: List[AutodiffSymbolicStructure] = []\n self.nl_constraint_evaluators: List[ConstraintAutodiffEvaluator] = []\n\n self.nl_objective_group_num = 0\n self.nl_objective_group_representatives: List[int] = []\n self.nl_objective_cppad_autodiff_graphs: List[CppADAutodiffGraph] = []\n self.nl_objective_autodiff_structures: List[AutodiffSymbolicStructure] = []\n self.nl_objective_evaluators: List[ObjectiveAutodiffEvaluator] = []\n\n # record the analyzed part of the problem\n self.n_graph_instances_since_last_optimize = 0\n self.nl_constraint_group_num_since_last_optimize = 0\n self.nl_objective_group_num_since_last_optimize = 0\n\n @staticmethod\n def supports_variable_attribute(attribute: VariableAttribute, settable=False):\n if settable:\n return attribute in variable_attribute_set_func_map\n else:\n return attribute in variable_attribute_get_func_map\n\n @staticmethod\n def supports_model_attribute(attribute: ModelAttribute, settable=False):\n if settable:\n return attribute in model_attribute_set_func_map\n else:\n return attribute in model_attribute_get_func_map\n\n @staticmethod\n def supports_constraint_attribute(attribute: ConstraintAttribute, settable=False):\n if settable:\n return attribute in constraint_attribute_set_func_map\n else:\n return attribute in constraint_attribute_get_func_map\n\n def get_variable_attribute(self, variable, attribute: VariableAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown variable attribute to get: {attribute}\")\n\n value = _direct_get_entity_attribute(\n self,\n variable,\n attribute,\n variable_attribute_get_func_map,\n e,\n )\n return value\n\n def set_variable_attribute(self, variable, attribute: VariableAttribute, value):\n def e(attribute):\n raise ValueError(f\"Unknown variable attribute to set: {attribute}\")\n\n _direct_set_entity_attribute(\n self,\n variable,\n attribute,\n value,\n variable_attribute_set_func_map,\n e,\n )\n\n def get_model_attribute(self, attribute: ModelAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown model attribute to get: {attribute}\")\n\n value = _direct_get_model_attribute(\n self,\n attribute,\n model_attribute_get_func_map,\n e,\n )\n return value\n\n def set_model_attribute(self, attribute: ModelAttribute, value):\n def e(attribute):\n raise ValueError(f\"Unknown model attribute to set: {attribute}\")\n\n _direct_set_model_attribute(\n self,\n attribute,\n value,\n model_attribute_set_func_map,\n e,\n )\n\n def get_constraint_attribute(self, constraint, attribute: ConstraintAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown constraint attribute to get: {attribute}\")\n\n value = _direct_get_entity_attribute(\n self,\n constraint,\n attribute,\n constraint_attribute_get_func_map,\n e,\n )\n return value\n\n def set_constraint_attribute(\n self, constraint, attribute: ConstraintAttribute, value\n ):\n def e(attribute):\n raise ValueError(f\"Unknown constraint attribute to set: {attribute}\")\n\n _direct_set_entity_attribute(\n self,\n constraint,\n attribute,\n value,\n constraint_attribute_set_func_map,\n e,\n )\n\n def set_raw_parameter(self, param_name: str, value):\n ty = type(value)\n if ty is int:\n self.set_raw_option_int(param_name, value)\n elif ty is float:\n self.set_raw_option_double(param_name, value)\n elif ty is str:\n self.set_raw_option_string(param_name, value)\n else:\n raise ValueError(f\"Unsupported parameter type: {ty}\")\n\n @overload\n def add_linear_constraint(\n self,\n expr: Union[VariableIndex, ScalarAffineFunction, ExprBuilder],\n sense: ConstraintSense,\n rhs: float,\n name: str = \"\",\n ): ...\n\n @overload\n def add_linear_constraint(\n self,\n expr: Union[VariableIndex, ScalarAffineFunction, ExprBuilder],\n interval: Tuple[float, float],\n name: str = \"\",\n ): ...\n\n @overload\n def add_linear_constraint(\n self,\n con: ComparisonConstraint,\n name: str = \"\",\n ): ...\n\n def add_linear_constraint(self, arg, *args, **kwargs):\n if isinstance(arg, ComparisonConstraint):\n return self._add_linear_constraint(\n arg.lhs, arg.sense, arg.rhs, *args, **kwargs\n )\n else:\n return self._add_linear_constraint(arg, *args, **kwargs)\n\n @overload\n def add_quadratic_constraint(\n self,\n expr: Union[ScalarQuadraticFunction, ExprBuilder],\n sense: ConstraintSense,\n rhs: float,\n name: str = \"\",\n ): ...\n\n @overload\n def add_quadratic_constraint(\n self,\n expr: Union[ScalarQuadraticFunction, ExprBuilder],\n interval: Tuple[float, float],\n name: str = \"\",\n ): ...\n\n @overload\n def add_quadratic_constraint(\n self,\n con: ComparisonConstraint,\n name: str = \"\",\n ): ...\n\n def add_quadratic_constraint(self, arg, *args, **kwargs):\n if isinstance(arg, ComparisonConstraint):\n return self._add_quadratic_constraint(\n arg.lhs, arg.sense, arg.rhs, *args, **kwargs\n )\n else:\n return self._add_quadratic_constraint(arg, *args, **kwargs)\n\n @overload\n def add_nl_constraint(\n self,\n expr,\n sense: ConstraintSense,\n rhs: float,\n /,\n name: str = \"\",\n ): ...\n\n @overload\n def add_nl_constraint(\n self,\n expr,\n interval: Tuple[float, float],\n /,\n name: str = \"\",\n ): ...\n\n @overload\n def add_nl_constraint(\n self,\n con,\n /,\n name: str = \"\",\n ): ...\n\n def add_nl_constraint(self, expr, *args, **kwargs):\n graph = ExpressionGraphContext.current_graph()\n expr = convert_to_expressionhandle(graph, expr)\n if not isinstance(expr, ExpressionHandle):\n raise ValueError(\n \"Expression should be able to be converted to ExpressionHandle\"\n )\n\n n_args = len(args)\n\n if n_args == 0:\n is_comparison = graph.is_compare_expression(expr)\n if is_comparison:\n expr, lb, ub = unpack_comparison_expression(graph, expr, float(\"inf\"))\n else:\n raise ValueError(\"Must specify either equality or inequality bounds\")\n elif n_args == 1:\n arg = args[0]\n if isinstance(arg, tuple):\n lb, ub = arg\n else:\n raise ValueError(\"Must specify either equality or inequality bounds\")\n elif n_args == 2:\n sense = args[0]\n rhs = args[1]\n if isinstance(sense, ConstraintSense) and isinstance(rhs, float):\n if sense == ConstraintSense.Equal:\n lb = ub = rhs\n elif sense == ConstraintSense.LessEqual:\n lb = -float(\"inf\")\n ub = rhs\n elif sense == ConstraintSense.GreaterEqual:\n lb = rhs\n ub = float(\"inf\")\n else:\n raise ValueError(f\"Unknown constraint sense: {sense}\")\n else:\n raise ValueError(\"Must specify either equality or inequality bounds\")\n else:\n raise ValueError(\"Must specify either equality or inequality bounds\")\n\n graph.add_constraint_output(expr)\n\n graph_index = self.graph_instance_to_index.get(graph, None)\n if graph_index is None:\n graph_index = self._add_graph_index()\n self.graph_instance_to_index[graph] = graph_index\n self.graph_instances.append(graph)\n\n con = self._add_single_nl_constraint(graph_index, graph, lb, ub)\n\n return con\n\n def add_nl_objective(self, expr):\n graph = ExpressionGraphContext.current_graph()\n expr = convert_to_expressionhandle(graph, expr)\n if not isinstance(expr, ExpressionHandle):\n raise ValueError(\n \"Expression should be able to be converted to ExpressionHandle\"\n )\n\n graph.add_objective_output(expr)\n\n graph_index = self.graph_instance_to_index.get(graph, None)\n if graph_index is None:\n graph_index = self._add_graph_index()\n self.graph_instance_to_index[graph] = graph_index\n self.graph_instances.append(graph)\n\n self.m_is_dirty = True\n\n def optimize(self):\n self._find_similar_graphs()\n self._compile_evaluators()\n # print(\"Compiling evaluators successfully\")\n # print(self.jit_compiler.source_codes[0])\n\n self.n_graph_instances_since_last_optimize = len(self.graph_instances)\n self.nl_constraint_group_num_since_last_optimize = self.nl_constraint_group_num\n self.nl_objective_group_num_since_last_optimize = self.nl_objective_group_num\n\n super()._optimize()\n\n def _find_similar_graphs(self):\n for i in range(\n self.n_graph_instances_since_last_optimize, len(self.graph_instances)\n ):\n graph = self.graph_instances[i]\n self._finalize_graph_instance(i, graph)\n\n # constraint part\n\n n_groups = self._aggregate_nl_constraint_groups()\n # print(f\"Found {n_groups} nonlinear constraint groups of similar graphs\")\n self.nl_constraint_group_num = n_groups\n\n rep_instances = self.nl_constraint_group_representatives\n\n for i in range(self.nl_constraint_group_num_since_last_optimize, n_groups):\n graph_index = self._get_nl_constraint_group_representative(i)\n rep_instances.append(graph_index)\n\n # objective part\n n_groups = self._aggregate_nl_objective_groups()\n # print(f\"Found {n_groups} nonlinear objective groups of similar graphs\")\n self.nl_objective_group_num = n_groups\n\n rep_instances = self.nl_objective_group_representatives\n\n for i in range(self.nl_objective_group_num_since_last_optimize, n_groups):\n graph_index = self._get_nl_objective_group_representative(i)\n rep_instances.append(graph_index)\n\n def _compile_evaluators(self):\n # for each group of nonlinear constraint and objective, we construct a cppad_autodiff graph\n # and then compile them to get the function pointers\n\n # constraint\n # self.nl_constraint_cppad_autodiff_graphs.clear()\n # self.nl_constraint_autodiff_structures.clear()\n for i in range(\n self.nl_constraint_group_num_since_last_optimize,\n self.nl_constraint_group_num,\n ):\n graph_index = self.nl_constraint_group_representatives[i]\n graph = self.graph_instances[graph_index]\n\n # print(graph)\n\n cppad_function = cppad_trace_graph_constraints(graph)\n\n nx = cppad_function.nx\n var_values = [(i + 1) / (nx + 1) for i in range(nx)]\n np = cppad_function.np\n param_values = [(i + 1) / (np + 1) for i in range(np)]\n\n # print(f\"nx = {nx}, np = {np}\")\n # print(f\"var_values = {var_values}\")\n # print(f\"param_values = {param_values}\")\n\n autodiff_structure = AutodiffSymbolicStructure()\n cppad_graph = CppADAutodiffGraph()\n\n cppad_autodiff(\n cppad_function,\n autodiff_structure,\n cppad_graph,\n var_values,\n param_values,\n )\n\n # print(cppad_graph.f)\n\n self._assign_nl_constraint_group_autodiff_structure(i, autodiff_structure)\n\n self.nl_constraint_cppad_autodiff_graphs.append(cppad_graph)\n self.nl_constraint_autodiff_structures.append(autodiff_structure)\n\n # objective\n # self.nl_objective_cppad_autodiff_graphs.clear()\n # self.nl_objective_autodiff_structures.clear()\n for i in range(\n self.nl_objective_group_num_since_last_optimize, self.nl_objective_group_num\n ):\n graph_index = self.nl_objective_group_representatives[i]\n graph = self.graph_instances[graph_index]\n\n cppad_function = cppad_trace_graph_objective(graph)\n\n nx = cppad_function.nx\n var_values = [(i + 1) / (nx + 1) for i in range(nx)]\n np = cppad_function.np\n param_values = [(i + 1) / (np + 1) for i in range(np)]\n\n autodiff_structure = AutodiffSymbolicStructure()\n cppad_graph = CppADAutodiffGraph()\n\n cppad_autodiff(\n cppad_function,\n autodiff_structure,\n cppad_graph,\n var_values,\n param_values,\n )\n\n self._assign_nl_objective_group_autodiff_structure(i, autodiff_structure)\n\n self.nl_objective_cppad_autodiff_graphs.append(cppad_graph)\n self.nl_objective_autodiff_structures.append(autodiff_structure)\n\n # compile the evaluators\n jit_compiler = self.jit_compiler\n if isinstance(jit_compiler, TCCJITCompiler):\n self._codegen_c()\n elif isinstance(jit_compiler, LLJITCompiler):\n self._codegen_llvm()\n\n def _codegen_c(self):\n jit_compiler: TCCJITCompiler = self.jit_compiler\n io = StringIO()\n\n generate_csrc_prelude(io)\n\n for group_index in range(\n self.nl_constraint_group_num_since_last_optimize,\n self.nl_constraint_group_num,\n ):\n cppad_autodiff_graph = self.nl_constraint_cppad_autodiff_graphs[group_index]\n autodiff_structure = self.nl_constraint_autodiff_structures[group_index]\n\n np = autodiff_structure.np\n ny = autodiff_structure.ny\n\n name = f\"nlconstraint_{group_index}\"\n\n f_name = name\n generate_csrc_from_graph(\n io,\n cppad_autodiff_graph.f,\n f_name,\n np=np,\n indirect_x=True,\n )\n if autodiff_structure.has_jacobian:\n jacobian_name = name + \"_jacobian\"\n generate_csrc_from_graph(\n io,\n cppad_autodiff_graph.jacobian,\n jacobian_name,\n np=np,\n indirect_x=True,\n )\n if autodiff_structure.has_hessian:\n hessian_name = name + \"_hessian\"\n generate_csrc_from_graph(\n io,\n cppad_autodiff_graph.hessian,\n hessian_name,\n np=np,\n hessian_lagrange=True,\n nw=ny,\n indirect_x=True,\n indirect_y=True,\n add_y=True,\n )\n\n for group_index in range(\n self.nl_objective_group_num_since_last_optimize, self.nl_objective_group_num\n ):\n cppad_autodiff_graph = self.nl_objective_cppad_autodiff_graphs[group_index]\n autodiff_structure = self.nl_objective_autodiff_structures[group_index]\n\n np = autodiff_structure.np\n ny = autodiff_structure.ny\n\n name = f\"nlobjective_{group_index}\"\n\n f_name = name\n generate_csrc_from_graph(\n io, cppad_autodiff_graph.f, f_name, np=np, indirect_x=True, add_y=True\n )\n if autodiff_structure.has_jacobian:\n jacobian_name = name + \"_jacobian\"\n generate_csrc_from_graph(\n io,\n cppad_autodiff_graph.jacobian,\n jacobian_name,\n np=np,\n indirect_x=True,\n indirect_y=True,\n add_y=True,\n )\n if autodiff_structure.has_hessian:\n hessian_name = name + \"_hessian\"\n generate_csrc_from_graph(\n io,\n cppad_autodiff_graph.hessian,\n hessian_name,\n np=np,\n hessian_lagrange=True,\n nw=ny,\n indirect_x=True,\n indirect_y=True,\n add_y=True,\n )\n\n csrc = io.getvalue()\n\n inst = jit_compiler.create_instance()\n jit_compiler.compile_string(inst, csrc)\n\n for group_index in range(\n self.nl_constraint_group_num_since_last_optimize,\n self.nl_constraint_group_num,\n ):\n name = f\"nlconstraint_{group_index}\"\n autodiff_structure = self.nl_constraint_autodiff_structures[group_index]\n has_parameter = autodiff_structure.has_parameter\n\n f_name = name\n jacobian_name = name + \"_jacobian\"\n hessian_name = name + \"_hessian\"\n\n f_ptr = inst.get_symbol(f_name)\n jacobian_ptr = hessian_ptr = 0\n if autodiff_structure.has_jacobian:\n jacobian_ptr = inst.get_symbol(jacobian_name)\n if autodiff_structure.has_hessian:\n hessian_ptr = inst.get_symbol(hessian_name)\n\n evaluator = ConstraintAutodiffEvaluator(\n has_parameter, f_ptr, jacobian_ptr, hessian_ptr\n )\n self._assign_nl_constraint_group_autodiff_evaluator(group_index, evaluator)\n\n for group_index in range(\n self.nl_objective_group_num_since_last_optimize, self.nl_objective_group_num\n ):\n name = f\"nlobjective_{group_index}\"\n autodiff_structure = self.nl_objective_autodiff_structures[group_index]\n has_parameter = autodiff_structure.has_parameter\n\n f_name = name\n jacobian_name = name + \"_jacobian\"\n hessian_name = name + \"_hessian\"\n\n f_ptr = inst.get_symbol(f_name)\n jacobian_ptr = hessian_ptr = 0\n if autodiff_structure.has_jacobian:\n jacobian_ptr = inst.get_symbol(jacobian_name)\n if autodiff_structure.has_hessian:\n hessian_ptr = inst.get_symbol(hessian_name)\n\n evaluator = ObjectiveAutodiffEvaluator(\n has_parameter, f_ptr, jacobian_ptr, hessian_ptr\n )\n self._assign_nl_objective_group_autodiff_evaluator(group_index, evaluator)\n\n def _codegen_llvm(self):\n jit_compiler: LLJITCompiler = self.jit_compiler\n module = ir.Module(name=\"my_module\")\n create_llvmir_basic_functions(module)\n\n export_functions = []\n\n for group_index in range(\n self.nl_constraint_group_num_since_last_optimize,\n self.nl_constraint_group_num,\n ):\n cppad_autodiff_graph = self.nl_constraint_cppad_autodiff_graphs[group_index]\n autodiff_structure = self.nl_constraint_autodiff_structures[group_index]\n\n np = autodiff_structure.np\n ny = autodiff_structure.ny\n\n name = f\"nlconstraint_{group_index}\"\n\n f_name = name\n generate_llvmir_from_graph(\n module,\n cppad_autodiff_graph.f,\n f_name,\n np=np,\n indirect_x=True,\n )\n export_functions.append(f_name)\n if autodiff_structure.has_jacobian:\n jacobian_name = name + \"_jacobian\"\n generate_llvmir_from_graph(\n module,\n cppad_autodiff_graph.jacobian,\n jacobian_name,\n np=np,\n indirect_x=True,\n )\n export_functions.append(jacobian_name)\n if autodiff_structure.has_hessian:\n hessian_name = name + \"_hessian\"\n generate_llvmir_from_graph(\n module,\n cppad_autodiff_graph.hessian,\n hessian_name,\n np=np,\n hessian_lagrange=True,\n nw=ny,\n indirect_x=True,\n indirect_y=True,\n add_y=True,\n )\n export_functions.append(hessian_name)\n\n for group_index in range(\n self.nl_objective_group_num_since_last_optimize, self.nl_objective_group_num\n ):\n cppad_autodiff_graph = self.nl_objective_cppad_autodiff_graphs[group_index]\n autodiff_structure = self.nl_objective_autodiff_structures[group_index]\n\n np = autodiff_structure.np\n ny = autodiff_structure.ny\n\n name = f\"nlobjective_{group_index}\"\n\n f_name = name\n generate_llvmir_from_graph(\n module,\n cppad_autodiff_graph.f,\n f_name,\n np=np,\n indirect_x=True,\n add_y=True,\n )\n export_functions.append(f_name)\n if autodiff_structure.has_jacobian:\n jacobian_name = name + \"_jacobian\"\n generate_llvmir_from_graph(\n module,\n cppad_autodiff_graph.jacobian,\n jacobian_name,\n np=np,\n indirect_x=True,\n indirect_y=True,\n add_y=True,\n )\n export_functions.append(jacobian_name)\n if autodiff_structure.has_hessian:\n hessian_name = name + \"_hessian\"\n generate_llvmir_from_graph(\n module,\n cppad_autodiff_graph.hessian,\n hessian_name,\n np=np,\n hessian_lagrange=True,\n nw=ny,\n indirect_x=True,\n indirect_y=True,\n add_y=True,\n )\n export_functions.append(hessian_name)\n\n rt = jit_compiler.compile_module(module, export_functions)\n\n for group_index in range(\n self.nl_constraint_group_num_since_last_optimize,\n self.nl_constraint_group_num,\n ):\n name = f\"nlconstraint_{group_index}\"\n autodiff_structure = self.nl_constraint_autodiff_structures[group_index]\n has_parameter = autodiff_structure.has_parameter\n\n f_name = name\n jacobian_name = name + \"_jacobian\"\n hessian_name = name + \"_hessian\"\n\n f_ptr = rt[f_name]\n jacobian_ptr = hessian_ptr = 0\n if autodiff_structure.has_jacobian:\n jacobian_ptr = rt[jacobian_name]\n if autodiff_structure.has_hessian:\n hessian_ptr = rt[hessian_name]\n\n evaluator = ConstraintAutodiffEvaluator(\n has_parameter, f_ptr, jacobian_ptr, hessian_ptr\n )\n self._assign_nl_constraint_group_autodiff_evaluator(group_index, evaluator)\n\n for group_index in range(\n self.nl_objective_group_num_since_last_optimize, self.nl_objective_group_num\n ):\n name = f\"nlobjective_{group_index}\"\n autodiff_structure = self.nl_objective_autodiff_structures[group_index]\n has_parameter = autodiff_structure.has_parameter\n\n f_name = name\n jacobian_name = name + \"_jacobian\"\n hessian_name = name + \"_hessian\"\n\n f_ptr = rt[f_name]\n jacobian_ptr = hessian_ptr = 0\n if autodiff_structure.has_jacobian:\n jacobian_ptr = rt[jacobian_name]\n if autodiff_structure.has_hessian:\n hessian_ptr = rt[hessian_name]\n\n evaluator = ObjectiveAutodiffEvaluator(\n has_parameter, f_ptr, jacobian_ptr, hessian_ptr\n )\n self._assign_nl_objective_group_autodiff_evaluator(group_index, evaluator)\n\n add_variables = make_variable_tupledict\n add_m_variables = make_variable_ndarray\n add_m_linear_constraints = add_matrix_constraints\n add_second_order_cone_constraint = bridge_soc_quadratic_constraint\n" }, { "path": "src/pyoptinterface/_src/jit_c.py", "content": "import platform\nimport os\n\nimport tccbox\n\nfrom .tcc_interface_ext import load_library, TCCInstance\n\nsystem = platform.system()\n\nlibtcc_dir = tccbox.tcc_lib_dir()\n# windows: libtcc.dll\n# linux: libtcc.so\n# macos: libtcc.dylib\nsharedlib_suffix = {\n \"Windows\": \"dll\",\n \"Linux\": \"so\",\n \"Darwin\": \"dylib\",\n}[system]\nlibtcc_path = os.path.join(libtcc_dir, f\"libtcc.{sharedlib_suffix}\")\n\nret = load_library(libtcc_path)\nif not ret:\n raise Exception(\"Failed to load libtcc from tccbox\")\n\n# On Linux/Mac, tcc has lib/tcc/include/ and lib/tcc/libtcc1.a which must be included in compilation\nlibtcc_extra_include_paths = []\nlibtcc_extra_lib_paths = []\nlibtcc_extra_lib_names = []\nif system in [\"Linux\", \"Darwin\"]:\n libtcc_extra_include_paths.append(os.path.join(libtcc_dir, \"tcc\", \"include\"))\n libtcc_extra_lib_paths.append(os.path.join(libtcc_dir, \"tcc\"))\n libtcc_extra_lib_names.append(\"m\")\nif system == \"Linux\":\n libtcc_extra_include_paths.extend(\n [\n \"/usr/include\",\n \"/usr/local/include\",\n \"/usr/include/x86_64-linux-gnu\",\n # arm\n \"/usr/include/aarch64-linux-gnu\",\n ]\n )\n libtcc_extra_lib_paths.extend(\n [\n \"/usr/lib\",\n \"/usr/local/lib\",\n \"/usr/lib/x86_64-linux-gnu\",\n # arm\n \"/usr/lib/aarch64-linux-gnu\",\n ]\n )\n\n\nclass TCCJITCompiler:\n def __init__(self):\n self.instances = []\n self.source_codes = []\n\n def create_instance(self):\n inst = TCCInstance()\n inst.init()\n\n # Add extra include path and library path\n for path in libtcc_extra_include_paths:\n inst.add_include_path(path)\n inst.add_sysinclude_path(path)\n for path in libtcc_extra_lib_paths:\n inst.add_library_path(path)\n for name in libtcc_extra_lib_names:\n inst.add_library(name)\n\n self.instances.append(inst)\n\n return inst\n\n def compile_string(self, inst, c_code: str):\n inst.compile_string(c_code)\n\n self.source_codes.append(c_code)\n" }, { "path": "src/pyoptinterface/_src/jit_llvm.py", "content": "from llvmlite import ir, binding\n\nfrom typing import List\n\n# Initialize LLVM\ntry:\n # llvmlite older than 0.45.0 still requires this\n binding.initialize()\nexcept Exception:\n pass\n\nbinding.initialize_native_target()\nbinding.initialize_native_asmprinter()\n\n\nclass LLJITCompiler:\n def __init__(self):\n target = binding.Target.from_default_triple()\n target_machine = target.create_target_machine(jit=True, opt=3)\n self.lljit = binding.create_lljit_compiler(target_machine)\n\n self.rts = []\n self.source_codes = []\n\n def compile_module(self, module: ir.Module, export_functions: List[str] = []):\n ir_str = str(module)\n self.source_codes.append(ir_str)\n builder = binding.JITLibraryBuilder().add_ir(ir_str).add_current_process()\n for f in export_functions:\n builder.export_symbol(f)\n n = len(self.rts)\n libname = f\"lib{n}\"\n rt = builder.link(self.lljit, libname)\n self.rts.append(rt)\n\n return rt\n" }, { "path": "src/pyoptinterface/_src/knitro.py", "content": "import logging\nimport os\nimport platform\nimport re\nfrom pathlib import Path\nfrom typing import Tuple, Union, overload\n\nfrom .aml import make_variable_ndarray, make_variable_tupledict\nfrom .attributes import (\n ConstraintAttribute,\n ModelAttribute,\n ResultStatusCode,\n TerminationStatusCode,\n VariableAttribute,\n)\nfrom .comparison_constraint import ComparisonConstraint\nfrom .core_ext import (\n ConstraintIndex,\n ConstraintSense,\n ExprBuilder,\n ScalarAffineFunction,\n ScalarQuadraticFunction,\n VariableIndex,\n)\nfrom .knitro_model_ext import KN, RawEnv, RawModel, load_library\nfrom .matrix import add_matrix_constraints\nfrom .nlexpr_ext import ExpressionGraph, ExpressionHandle\nfrom .nlfunc import ExpressionGraphContext, convert_to_expressionhandle\nfrom .solver_common import (\n _get_entity_attribute,\n _get_model_attribute,\n _set_entity_attribute,\n _set_model_attribute,\n)\n\n\ndef detected_libraries():\n libs = []\n\n subdir = {\n \"Linux\": \"lib\",\n \"Darwin\": \"lib\",\n \"Windows\": \"bin\",\n }[platform.system()]\n libname_pattern = {\n \"Linux\": r\"libknitro\\.so.*\",\n \"Darwin\": r\"libknitro\\.dylib.*\",\n \"Windows\": r\"knitro\\d*\\.dll\",\n }[platform.system()]\n suffix_pattern = {\n \"Linux\": \"*.so*\",\n \"Darwin\": \"*.dylib*\",\n \"Windows\": \"*.dll\",\n }[platform.system()]\n\n # Environment variable\n knitro_dir = os.environ.get(\"KNITRODIR\", None)\n if knitro_dir and os.path.exists(knitro_dir):\n dir = Path(knitro_dir) / subdir\n if dir.exists():\n for path in dir.glob(suffix_pattern):\n match = re.match(libname_pattern, path.name)\n if match:\n libs.append(str(path))\n\n try:\n import knitro\n\n dir = Path(knitro.__path__[0])\n dir = dir / \"lib\"\n for path in dir.glob(suffix_pattern):\n match = re.match(libname_pattern, path.name)\n if match:\n libs.append(str(path))\n except ImportError:\n pass\n\n # Default library names\n default_libname = {\n \"Linux\": [\"libknitro.so\"],\n \"Darwin\": [\"libknitro.dylib\"],\n \"Windows\": [\"knitro.dll\"],\n }[platform.system()]\n libs.extend(default_libname)\n\n return libs\n\n\ndef autoload_library():\n libs = detected_libraries()\n for lib in libs:\n ret = load_library(lib)\n if ret:\n logging.info(f\"Loaded KNITRO library: {lib}\")\n return True\n return False\n\n\nautoload_library()\n\n\n# Variable Attribute\nvariable_attribute_get_func_map = {\n VariableAttribute.Value: lambda model, v: model.get_value(v),\n VariableAttribute.LowerBound: lambda model, v: model.get_variable_lb(v),\n VariableAttribute.UpperBound: lambda model, v: model.get_variable_ub(v),\n VariableAttribute.Name: lambda model, v: model.get_variable_name(v),\n VariableAttribute.Domain: lambda model, v: model.get_variable_domain(v),\n VariableAttribute.ReducedCost: lambda model, v: model.get_variable_rc(v),\n}\n\nvariable_attribute_set_func_map = {\n VariableAttribute.LowerBound: lambda model, v, x: model.set_variable_lb(v, x),\n VariableAttribute.UpperBound: lambda model, v, x: model.set_variable_ub(v, x),\n VariableAttribute.PrimalStart: lambda model, v, x: model.set_variable_start(v, x),\n VariableAttribute.Name: lambda model, v, x: model.set_variable_name(v, x),\n VariableAttribute.Domain: lambda model, v, x: model.set_variable_domain(v, x),\n}\n\n# Constraint Attribute\nconstraint_attribute_get_func_map = {\n ConstraintAttribute.Primal: lambda model, c: model.get_constraint_primal(c),\n ConstraintAttribute.Dual: lambda model, c: model.get_constraint_dual(c),\n ConstraintAttribute.Name: lambda model, c: model.get_constraint_name(c),\n}\n\nconstraint_attribute_set_func_map = {\n ConstraintAttribute.Name: lambda model, c, x: model.set_constraint_name(c, x),\n}\n\n_RAW_STATUS_STRINGS = [\n (TerminationStatusCode.OPTIMAL, KN.RC_OPTIMAL),\n (TerminationStatusCode.OPTIMAL, KN.RC_OPTIMAL_OR_SATISFACTORY),\n (TerminationStatusCode.ALMOST_OPTIMAL, KN.RC_NEAR_OPT),\n (TerminationStatusCode.ALMOST_OPTIMAL, KN.RC_FEAS_XTOL),\n (TerminationStatusCode.ALMOST_OPTIMAL, KN.RC_FEAS_NO_IMPROVE),\n (TerminationStatusCode.ALMOST_OPTIMAL, KN.RC_FEAS_FTOL),\n (TerminationStatusCode.LOCALLY_SOLVED, KN.RC_FEAS_BEST),\n (TerminationStatusCode.LOCALLY_SOLVED, KN.RC_FEAS_MULTISTART),\n (TerminationStatusCode.INFEASIBLE, KN.RC_INFEASIBLE),\n (TerminationStatusCode.LOCALLY_INFEASIBLE, KN.RC_INFEAS_XTOL),\n (TerminationStatusCode.LOCALLY_INFEASIBLE, KN.RC_INFEAS_NO_IMPROVE),\n (TerminationStatusCode.LOCALLY_INFEASIBLE, KN.RC_INFEAS_MULTISTART),\n (TerminationStatusCode.INFEASIBLE, KN.RC_INFEAS_CON_BOUNDS),\n (TerminationStatusCode.INFEASIBLE, KN.RC_INFEAS_VAR_BOUNDS),\n (TerminationStatusCode.DUAL_INFEASIBLE, KN.RC_UNBOUNDED),\n (TerminationStatusCode.INFEASIBLE_OR_UNBOUNDED, KN.RC_UNBOUNDED_OR_INFEAS),\n (TerminationStatusCode.ITERATION_LIMIT, KN.RC_ITER_LIMIT_FEAS),\n (TerminationStatusCode.ITERATION_LIMIT, KN.RC_ITER_LIMIT_INFEAS),\n (TerminationStatusCode.TIME_LIMIT, KN.RC_TIME_LIMIT_FEAS),\n (TerminationStatusCode.TIME_LIMIT, KN.RC_TIME_LIMIT_INFEAS),\n (TerminationStatusCode.OTHER_LIMIT, KN.RC_FEVAL_LIMIT_FEAS),\n (TerminationStatusCode.OTHER_LIMIT, KN.RC_FEVAL_LIMIT_INFEAS),\n (TerminationStatusCode.OTHER_LIMIT, KN.RC_MIP_EXH_FEAS),\n (TerminationStatusCode.OTHER_LIMIT, KN.RC_MIP_EXH_INFEAS),\n (TerminationStatusCode.NODE_LIMIT, KN.RC_MIP_NODE_LIMIT_FEAS),\n (TerminationStatusCode.NODE_LIMIT, KN.RC_MIP_NODE_LIMIT_INFEAS),\n (TerminationStatusCode.INTERRUPTED, KN.RC_USER_TERMINATION),\n (TerminationStatusCode.NUMERICAL_ERROR, KN.RC_EVAL_ERR),\n (TerminationStatusCode.MEMORY_LIMIT, KN.RC_OUT_OF_MEMORY),\n (TerminationStatusCode.OTHER_ERROR, KN.RC_CALLBACK_ERR),\n (TerminationStatusCode.OTHER_ERROR, KN.RC_LP_SOLVER_ERR),\n (TerminationStatusCode.OTHER_ERROR, KN.RC_LINEAR_SOLVER_ERR),\n (TerminationStatusCode.OTHER_ERROR, KN.RC_INTERNAL_ERROR),\n]\n\n\ndef _termination_status_knitro(model: \"Model\"):\n if model.is_dirty:\n return TerminationStatusCode.OPTIMIZE_NOT_CALLED\n\n code = model.solve_status\n for ts, rs in _RAW_STATUS_STRINGS:\n if code == rs:\n return ts\n return TerminationStatusCode.OTHER_ERROR\n\n\ndef _result_status_knitro(model: \"Model\"):\n if model.is_dirty:\n return ResultStatusCode.NO_SOLUTION\n\n code = model.solve_status\n\n feasible = {\n KN.RC_OPTIMAL,\n KN.RC_OPTIMAL_OR_SATISFACTORY,\n KN.RC_NEAR_OPT,\n KN.RC_FEAS_XTOL,\n KN.RC_FEAS_NO_IMPROVE,\n KN.RC_FEAS_FTOL,\n KN.RC_FEAS_BEST,\n KN.RC_FEAS_MULTISTART,\n KN.RC_ITER_LIMIT_FEAS,\n KN.RC_TIME_LIMIT_FEAS,\n KN.RC_FEVAL_LIMIT_FEAS,\n KN.RC_MIP_EXH_FEAS,\n KN.RC_MIP_TERM_FEAS,\n KN.RC_MIP_SOLVE_LIMIT_FEAS,\n KN.RC_MIP_NODE_LIMIT_FEAS,\n }\n\n infeasible = {\n KN.RC_INFEASIBLE,\n KN.RC_INFEAS_XTOL,\n KN.RC_INFEAS_NO_IMPROVE,\n KN.RC_INFEAS_MULTISTART,\n KN.RC_INFEAS_CON_BOUNDS,\n KN.RC_INFEAS_VAR_BOUNDS,\n KN.RC_ITER_LIMIT_INFEAS,\n KN.RC_TIME_LIMIT_INFEAS,\n KN.RC_FEVAL_LIMIT_INFEAS,\n KN.RC_MIP_EXH_INFEAS,\n KN.RC_MIP_SOLVE_LIMIT_INFEAS,\n KN.RC_MIP_NODE_LIMIT_INFEAS,\n }\n\n if code in feasible:\n return ResultStatusCode.FEASIBLE_POINT\n if code in infeasible:\n return ResultStatusCode.INFEASIBLE_POINT\n return ResultStatusCode.NO_SOLUTION\n\n\n# Model Attribute\nmodel_attribute_get_func_map = {\n ModelAttribute.ObjectiveValue: lambda model: model.get_obj_value(),\n ModelAttribute.ObjectiveSense: lambda model: model.get_obj_sense(),\n ModelAttribute.TerminationStatus: _termination_status_knitro,\n ModelAttribute.RawStatusString: lambda model: (\n f\"KNITRO status code: {model.solve_status}\"\n ),\n ModelAttribute.PrimalStatus: _result_status_knitro,\n ModelAttribute.NumberOfThreads: lambda model: model.get_raw_parameter(\n KN.PARAM_NUMTHREADS\n ),\n ModelAttribute.TimeLimitSec: lambda model: model.get_raw_parameter(\n KN.PARAM_MAXTIME\n ),\n ModelAttribute.BarrierIterations: lambda model: model.get_number_iterations(),\n ModelAttribute.NodeCount: lambda model: model.get_mip_node_count(),\n ModelAttribute.ObjectiveBound: lambda model: model.get_obj_bound(),\n ModelAttribute.RelativeGap: lambda model: model.get_mip_relative_gap(),\n ModelAttribute.SolverName: lambda model: model.get_solver_name(),\n ModelAttribute.SolverVersion: lambda model: model.get_release(),\n ModelAttribute.SolveTimeSec: lambda model: model.get_solve_time(),\n}\n\nmodel_attribute_set_func_map = {\n ModelAttribute.ObjectiveSense: lambda model, x: model.set_obj_sense(x),\n ModelAttribute.NumberOfThreads: lambda model, x: model.set_raw_parameter(\n KN.PARAM_NUMTHREADS, x\n ),\n ModelAttribute.Silent: lambda model, x: model.set_raw_parameter(\n KN.PARAM_OUTLEV, KN.OUTLEV_NONE if x else KN.OUTLEV_ITER_10\n ),\n ModelAttribute.TimeLimitSec: lambda model, x: model.set_raw_parameter(\n KN.PARAM_MAXTIME, x\n ),\n}\n\n\nclass Env(RawEnv):\n \"\"\"\n KNITRO license manager environment.\n \"\"\"\n\n @property\n def is_empty(self):\n return self.empty()\n\n\nclass Model(RawModel):\n \"\"\"\n KNITRO model class for PyOptInterface.\n \"\"\"\n\n def __init__(self, env: Env = None) -> None:\n if env is not None:\n super().__init__(env)\n else:\n super().__init__()\n self.graph_map: dict[ExpressionGraph, int] = {}\n\n def _reset_graph_map(self) -> None:\n self.graph_map.clear()\n\n def _add_graph_expr(\n self, expr: ExpressionHandle\n ) -> tuple[ExpressionGraph, ExpressionHandle]:\n graph = ExpressionGraphContext.current_graph()\n expr = convert_to_expressionhandle(graph, expr)\n if not isinstance(expr, ExpressionHandle):\n raise ValueError(\"Expression should be convertible to ExpressionHandle\")\n if graph not in self.graph_map:\n self.graph_map[graph] = len(self.graph_map)\n return graph, expr\n\n def init(self, env: Env = None) -> None:\n if env is not None:\n super().init(env)\n else:\n super().init()\n self._reset_graph_map()\n\n def close(self) -> None:\n super().close()\n self._reset_graph_map()\n\n @staticmethod\n def supports_variable_attribute(\n attribute: VariableAttribute, setable: bool = False\n ) -> bool:\n if setable:\n return attribute in variable_attribute_set_func_map\n else:\n return attribute in variable_attribute_get_func_map\n\n @staticmethod\n def supports_constraint_attribute(\n attribute: ConstraintAttribute, setable: bool = False\n ) -> bool:\n if setable:\n return attribute in constraint_attribute_set_func_map\n else:\n return attribute in constraint_attribute_get_func_map\n\n @staticmethod\n def supports_model_attribute(\n attribute: ModelAttribute, setable: bool = False\n ) -> bool:\n if setable:\n return attribute in model_attribute_set_func_map\n else:\n return attribute in model_attribute_get_func_map\n\n @overload\n def add_linear_constraint(\n self,\n expr: Union[VariableIndex, ScalarAffineFunction, ExprBuilder],\n sense: ConstraintSense,\n rhs: float,\n name: str = \"\",\n ): ...\n\n @overload\n def add_linear_constraint(\n self,\n expr: Union[VariableIndex, ScalarAffineFunction, ExprBuilder],\n interval: Tuple[float, float],\n name: str = \"\",\n ) -> ConstraintIndex: ...\n\n @overload\n def add_linear_constraint(\n self,\n con: ComparisonConstraint,\n name: str = \"\",\n ) -> ConstraintIndex: ...\n\n def add_linear_constraint(self, arg, *args, **kwargs) -> ConstraintIndex:\n if isinstance(arg, ComparisonConstraint):\n return self._add_linear_constraint(\n arg.lhs, arg.sense, arg.rhs, *args, **kwargs\n )\n else:\n return self._add_linear_constraint(arg, *args, **kwargs)\n\n @overload\n def add_quadratic_constraint(\n self,\n expr: Union[ScalarQuadraticFunction, ExprBuilder],\n sense: ConstraintSense,\n rhs: float,\n name: str = \"\",\n ) -> ConstraintIndex: ...\n\n @overload\n def add_quadratic_constraint(\n self,\n con: ComparisonConstraint,\n name: str = \"\",\n ) -> ConstraintIndex: ...\n\n def add_quadratic_constraint(self, arg, *args, **kwargs) -> ConstraintIndex:\n if isinstance(arg, ComparisonConstraint):\n return self._add_quadratic_constraint(\n arg.lhs, arg.sense, arg.rhs, *args, **kwargs\n )\n else:\n return self._add_quadratic_constraint(arg, *args, **kwargs)\n\n @overload\n def add_nl_constraint(\n self,\n expr,\n sense: ConstraintSense,\n rhs: float,\n /,\n name: str = \"\",\n ) -> ConstraintIndex: ...\n\n @overload\n def add_nl_constraint(\n self,\n expr,\n interval: Tuple[float, float],\n /,\n name: str = \"\",\n ) -> ConstraintIndex: ...\n\n @overload\n def add_nl_constraint(\n self,\n con,\n /,\n name: str = \"\",\n ) -> ConstraintIndex: ...\n\n def add_nl_constraint(self, expr, *args, **kwargs) -> ConstraintIndex:\n graph, expr = self._add_graph_expr(expr)\n return self._add_single_nl_constraint(graph, expr, *args, **kwargs)\n\n def add_nl_objective(self, expr) -> None:\n graph, expr = self._add_graph_expr(expr)\n self._add_single_nl_objective(graph, expr)\n\n def get_model_attribute(self, attr: ModelAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown model attribute to get: {attribute}\")\n\n return _get_model_attribute(self, attr, model_attribute_get_func_map, {}, e)\n\n def set_model_attribute(self, attr: ModelAttribute, value):\n def e(attribute):\n raise ValueError(f\"Unknown model attribute to set: {attribute}\")\n\n _set_model_attribute(self, attr, value, model_attribute_set_func_map, {}, e)\n\n def get_variable_attribute(self, variable: VariableIndex, attr: VariableAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown variable attribute to get: {attribute}\")\n\n return _get_entity_attribute(\n self,\n variable,\n attr,\n variable_attribute_get_func_map,\n {},\n e,\n )\n\n def set_variable_attribute(\n self, variable: VariableIndex, attr: VariableAttribute, value\n ):\n def e(attribute):\n raise ValueError(f\"Unknown variable attribute to set: {attribute}\")\n\n _set_entity_attribute(\n self,\n variable,\n attr,\n value,\n variable_attribute_set_func_map,\n {},\n e,\n )\n\n def get_constraint_attribute(\n self, constraint: ConstraintIndex, attr: ConstraintAttribute\n ):\n def e(attribute):\n raise ValueError(f\"Unknown constraint attribute to get: {attribute}\")\n\n return _get_entity_attribute(\n self,\n constraint,\n attr,\n constraint_attribute_get_func_map,\n {},\n e,\n )\n\n def set_constraint_attribute(\n self, constraint: ConstraintIndex, attr: ConstraintAttribute, value\n ):\n def e(attribute):\n raise ValueError(f\"Unknown constraint attribute to set: {attribute}\")\n\n _set_entity_attribute(\n self,\n constraint,\n attr,\n value,\n constraint_attribute_set_func_map,\n {},\n e,\n )\n\n @property\n def is_dirty(self) -> bool:\n return self.dirty()\n\n @property\n def is_empty(self) -> bool:\n return self.empty() and not self.graph_map\n\n @property\n def solve_status(self) -> int:\n return self.get_solve_status()\n\n\nModel.add_variables = make_variable_tupledict\nModel.add_m_variables = make_variable_ndarray\nModel.add_m_linear_constraints = add_matrix_constraints\n" }, { "path": "src/pyoptinterface/_src/matrix.py", "content": "from .tupledict import tupledict\nfrom .core_ext import ScalarAffineFunction\n\n\ndef iterate_sparse_matrix_rows(A):\n \"\"\"\n Iterate over rows of a sparse matrix and get non-zero elements for each row.\n\n A is a 2-dimensional scipy sparse matrix\n isinstance(A, scipy.sparse.sparray) = True and A.ndim = 2\n \"\"\"\n from scipy.sparse import csr_array\n\n if not isinstance(A, csr_array):\n A = csr_array(A) # Convert to CSR format if not already\n\n for i in range(A.shape[0]):\n row_start = A.indptr[i]\n row_end = A.indptr[i + 1]\n row_indices = A.indices[row_start:row_end]\n row_data = A.data[row_start:row_end]\n yield row_indices, row_data\n\n\ndef add_matrix_constraints(model, A, x, sense, b):\n \"\"\"\n add constraints Ax <= / = / >= b\n\n A is a 2-dimensional numpy array or scipy sparse matrix\n x is an iterable of variables\n sense is one of (poi.Leq, poi.Eq, poi.Geq)\n b is an iterable of values or a single scalar\n \"\"\"\n import numpy as np\n from scipy.sparse import sparray\n\n is_ndarray = isinstance(A, np.ndarray)\n is_sparse = isinstance(A, sparray)\n\n if not is_ndarray and not is_sparse:\n raise ValueError(\"A must be a numpy array or scipy.sparse array\")\n\n ndim = A.ndim\n if ndim != 2:\n raise ValueError(\"A must be a 2-dimensional array\")\n\n M, N = A.shape\n\n # turn x into a list if x is an iterable\n if isinstance(x, np.ndarray):\n xdim = x.ndim\n if xdim != 1:\n raise ValueError(\"x must be a 1-dimensional array\")\n elif isinstance(x, tupledict):\n x = list(x.values())\n else:\n x = list(x)\n\n if len(x) != N:\n raise ValueError(\"x must have length equal to the number of columns of A\")\n\n # check b\n if np.isscalar(b):\n b = np.full(M, b)\n elif len(b) != M:\n raise ValueError(\"b must have length equal to the number of rows of A\")\n\n constraints = np.empty(M, dtype=object)\n\n if is_ndarray:\n for i in range(M):\n expr = ScalarAffineFunction()\n row = A[i]\n for coef, var in zip(row, x):\n expr.add_term(var, coef)\n con = model.add_linear_constraint(expr, sense, b[i])\n constraints[i] = con\n elif is_sparse:\n for i, (row_indices, row_data), rhs in zip(\n range(M), iterate_sparse_matrix_rows(A), b\n ):\n expr = ScalarAffineFunction()\n for j, coef in zip(row_indices, row_data):\n expr.add_term(x[j], coef)\n con = model.add_linear_constraint(expr, sense, rhs)\n constraints[i] = con\n\n return constraints\n" }, { "path": "src/pyoptinterface/_src/monkeypatch.py", "content": "from .core_ext import (\n VariableIndex,\n ScalarAffineFunction,\n ScalarQuadraticFunction,\n ExprBuilder,\n ConstraintSense,\n)\nfrom .comparison_constraint import ComparisonConstraint\nfrom .nlexpr_ext import (\n ExpressionHandle,\n BinaryOperator,\n NaryOperator,\n UnaryOperator,\n ArrayType,\n)\nfrom .nlfunc import ExpressionGraphContext, convert_to_expressionhandle\n\n\ndef patch_core_compararison_operator(cls):\n def _compare(self, other, op: ConstraintSense):\n if isinstance(\n other,\n (VariableIndex, ScalarAffineFunction, ScalarQuadraticFunction, ExprBuilder),\n ):\n lhs = self - other\n rhs = 0.0\n elif isinstance(other, (int, float)):\n lhs = self\n rhs = other\n else:\n return NotImplemented\n\n constraint = ComparisonConstraint(op, lhs, rhs)\n return constraint\n\n def __eq__(self, other):\n return _compare(self, other, ConstraintSense.Equal)\n\n def __le__(self, other):\n return _compare(self, other, ConstraintSense.LessEqual)\n\n def __ge__(self, other):\n return _compare(self, other, ConstraintSense.GreaterEqual)\n\n cls.__eq__ = __eq__\n cls.__le__ = __le__\n cls.__ge__ = __ge__\n\n\ndef patch_more_compararison_operator(cls):\n def _compare(self, other, op: BinaryOperator):\n graph = ExpressionGraphContext.current_graph_no_exception()\n if graph is None:\n return NotImplemented\n\n converted_other = convert_to_expressionhandle(graph, other)\n if isinstance(converted_other, ExpressionHandle):\n converted_self = convert_to_expressionhandle(graph, self)\n fallback_result = graph.add_binary(op, converted_self, converted_other)\n return fallback_result\n else:\n return NotImplemented\n\n def __lt__(self, other):\n return _compare(self, other, BinaryOperator.LessThan)\n\n def __gt__(self, other):\n return _compare(self, other, BinaryOperator.GreaterThan)\n\n def __ne__(self, other):\n return _compare(self, other, BinaryOperator.NotEqual)\n\n cls.__lt__ = __lt__\n cls.__gt__ = __gt__\n cls.__ne__ = __ne__\n\n\ndef patch_quadratic_mul(cls):\n old_mul = getattr(cls, \"__mul__\", None)\n old_rmul = getattr(cls, \"__rmul__\", None)\n\n assert old_mul is not None, f\"{cls} does not have __mul__ method\"\n assert old_rmul is not None, f\"{cls} does not have __rmul__ method\"\n\n def __mul__(self, other):\n original_result = NotImplemented\n\n try:\n original_result = old_mul(self, other)\n except TypeError:\n original_result = NotImplemented\n\n if original_result is not NotImplemented:\n return original_result\n\n graph = ExpressionGraphContext.current_graph_no_exception()\n if graph is None:\n return NotImplemented\n\n converted_other = convert_to_expressionhandle(graph, other)\n if isinstance(converted_other, ExpressionHandle):\n fallback_result = converted_other * self\n return fallback_result\n else:\n return NotImplemented\n\n def __rmul__(self, other):\n original_result = NotImplemented\n\n try:\n original_result = old_rmul(self, other)\n except TypeError:\n original_result = NotImplemented\n\n if original_result is not NotImplemented:\n return original_result\n\n graph = ExpressionGraphContext.current_graph_no_exception()\n if graph is None:\n return NotImplemented\n\n converted_other = convert_to_expressionhandle(graph, other)\n if isinstance(converted_other, ExpressionHandle):\n fallback_result = converted_other * self\n return fallback_result\n else:\n return NotImplemented\n\n cls.__mul__ = __mul__\n cls.__rmul__ = __rmul__\n\n\ndef patch_div(cls):\n old_truediv = getattr(cls, \"__truediv__\", None)\n\n assert old_truediv is not None, f\"{cls} does not have __truediv__ method\"\n\n def __truediv__(self, other):\n original_result = NotImplemented\n\n try:\n original_result = old_truediv(self, other)\n except TypeError:\n original_result = NotImplemented\n\n if original_result is not NotImplemented:\n return original_result\n\n graph = ExpressionGraphContext.current_graph_no_exception()\n if graph is None:\n return NotImplemented\n\n converted_other = convert_to_expressionhandle(graph, other)\n if isinstance(converted_other, ExpressionHandle):\n converted_self = convert_to_expressionhandle(graph, self)\n fallback_result = graph.add_binary(\n BinaryOperator.Div, converted_self, converted_other\n )\n return fallback_result\n else:\n return NotImplemented\n\n def __rtruediv__(self, other):\n graph = ExpressionGraphContext.current_graph_no_exception()\n if graph is None:\n return NotImplemented\n\n converted_other = convert_to_expressionhandle(graph, other)\n if isinstance(converted_other, ExpressionHandle):\n converted_self = convert_to_expressionhandle(graph, self)\n fallback_result = graph.add_binary(\n BinaryOperator.Div, converted_other, converted_self\n )\n return fallback_result\n else:\n return NotImplemented\n\n cls.__truediv__ = __truediv__\n cls.__rtruediv__ = __rtruediv__\n\n\ndef pow_int(graph, expr, N):\n if N == 0:\n return 1\n if N < 0:\n return graph.add_binary(BinaryOperator.Div, 1, pow_int(graph, expr, -N))\n if N == 1:\n return expr\n\n M, r = divmod(N, 2)\n\n pow_2 = graph.add_nary(NaryOperator.Mul, [expr, expr])\n pow_2M = pow_int(graph, pow_2, M)\n\n if r == 0:\n return pow_2M\n else:\n return graph.add_nary(NaryOperator.Mul, [pow_2M, expr])\n\n\ndef patch_expressionhandle(cls):\n def _binary_operator(self, other, op: BinaryOperator, swap=False):\n graph = ExpressionGraphContext.current_graph()\n other = convert_to_expressionhandle(graph, other)\n if not isinstance(other, ExpressionHandle):\n return NotImplemented\n\n if swap:\n new_expression = graph.add_binary(op, other, self)\n else:\n new_expression = graph.add_binary(op, self, other)\n return new_expression\n\n def _nary_operator(self, other, op: NaryOperator):\n graph = ExpressionGraphContext.current_graph()\n other = convert_to_expressionhandle(graph, other)\n if not isinstance(other, ExpressionHandle):\n return NotImplemented\n\n if self.array == ArrayType.Nary and graph.get_nary_operator(self) == op:\n graph.append_nary(self, other)\n return self\n else:\n new_expression = graph.add_nary(op, [self, other])\n return new_expression\n\n def __add__(self, other):\n return self._nary_operator(other, NaryOperator.Add)\n\n def __radd__(self, other):\n return self._nary_operator(other, NaryOperator.Add)\n\n def __sub__(self, other):\n return self._binary_operator(other, BinaryOperator.Sub)\n\n def __rsub__(self, other):\n return self._binary_operator(other, BinaryOperator.Sub, swap=True)\n\n def __mul__(self, other):\n return self._nary_operator(other, NaryOperator.Mul)\n\n def __rmul__(self, other):\n return self._nary_operator(other, NaryOperator.Mul)\n\n def __truediv__(self, other):\n return self._binary_operator(other, BinaryOperator.Div)\n\n def __rtruediv__(self, other):\n return self._binary_operator(other, BinaryOperator.Div, swap=True)\n\n def __neg__(self):\n graph = ExpressionGraphContext.current_graph()\n new_expression = graph.add_unary(UnaryOperator.Neg, self)\n return new_expression\n\n def __pow__(self, other):\n # special case for integer powers, which can be implemented as a repeated multiplication\n if isinstance(other, int):\n graph = ExpressionGraphContext.current_graph()\n new_expression = pow_int(graph, self, other)\n return new_expression\n else:\n return self._binary_operator(other, BinaryOperator.Pow)\n\n def __rpow__(self, other):\n return self._binary_operator(other, BinaryOperator.Pow, swap=True)\n\n # compare operators\n def __eq__(self, other):\n return self._binary_operator(other, BinaryOperator.Equal)\n\n def __ne__(self, other):\n return self._binary_operator(other, BinaryOperator.NotEqual)\n\n def __lt__(self, other):\n return self._binary_operator(other, BinaryOperator.LessThan)\n\n def __le__(self, other):\n return self._binary_operator(other, BinaryOperator.LessEqual)\n\n def __gt__(self, other):\n return self._binary_operator(other, BinaryOperator.GreaterThan)\n\n def __ge__(self, other):\n return self._binary_operator(other, BinaryOperator.GreaterEqual)\n\n cls._binary_operator = _binary_operator\n cls._nary_operator = _nary_operator\n cls.__add__ = __add__\n cls.__radd__ = __radd__\n cls.__sub__ = __sub__\n cls.__rsub__ = __rsub__\n cls.__mul__ = __mul__\n cls.__rmul__ = __rmul__\n cls.__truediv__ = __truediv__\n cls.__rtruediv__ = __rtruediv__\n cls.__neg__ = __neg__\n cls.__pow__ = __pow__\n cls.__rpow__ = __rpow__\n cls.__eq__ = __eq__\n cls.__ne__ = __ne__\n cls.__lt__ = __lt__\n cls.__le__ = __le__\n cls.__gt__ = __gt__\n cls.__ge__ = __ge__\n\n\ndef patch_pow(cls):\n def __pow__(self, other):\n if other == 0:\n return 1\n elif other == 1:\n return self\n elif other == 2:\n return self * self\n\n graph = ExpressionGraphContext.current_graph_no_exception()\n if graph is None:\n return NotImplemented\n\n self = convert_to_expressionhandle(graph, self)\n\n if isinstance(other, int):\n new_expression = pow_int(graph, self, other)\n return new_expression\n\n other = convert_to_expressionhandle(graph, other)\n if isinstance(other, ExpressionHandle):\n result = graph.add_binary(BinaryOperator.Pow, self, other)\n return result\n else:\n return NotImplemented\n\n def __rpow__(self, other):\n if other == 0:\n return 0\n elif other == 1:\n return 1\n\n graph = ExpressionGraphContext.current_graph_no_exception()\n if graph is None:\n return NotImplemented\n\n self = convert_to_expressionhandle(graph, self)\n other = convert_to_expressionhandle(graph, other)\n if isinstance(other, ExpressionHandle):\n result = graph.add_binary(BinaryOperator.Pow, other, self)\n return result\n else:\n return NotImplemented\n\n cls.__pow__ = __pow__\n cls.__rpow__ = __rpow__\n\n\ndef _monkeypatch_all():\n patch_core_compararison_operator(VariableIndex)\n patch_core_compararison_operator(ScalarAffineFunction)\n patch_core_compararison_operator(ScalarQuadraticFunction)\n patch_core_compararison_operator(ExprBuilder)\n\n patch_more_compararison_operator(VariableIndex)\n patch_more_compararison_operator(ScalarAffineFunction)\n patch_more_compararison_operator(ScalarQuadraticFunction)\n patch_more_compararison_operator(ExprBuilder)\n\n patch_quadratic_mul(ScalarQuadraticFunction)\n patch_quadratic_mul(ExprBuilder)\n\n patch_div(VariableIndex)\n patch_div(ScalarAffineFunction)\n patch_div(ScalarQuadraticFunction)\n patch_div(ExprBuilder)\n\n patch_pow(VariableIndex)\n patch_pow(ScalarAffineFunction)\n patch_pow(ScalarQuadraticFunction)\n patch_pow(ExprBuilder)\n\n patch_expressionhandle(ExpressionHandle)\n" }, { "path": "src/pyoptinterface/_src/mosek.py", "content": "import os\nimport platform\nfrom pathlib import Path\nimport re\nimport logging\nfrom typing import Optional, Union, overload\n\nfrom .mosek_model_ext import RawModel, Env, Enum, load_library\nfrom .attributes import (\n VariableAttribute,\n ConstraintAttribute,\n ModelAttribute,\n ResultStatusCode,\n TerminationStatusCode,\n)\nfrom .core_ext import (\n VariableIndex,\n ScalarAffineFunction,\n ScalarQuadraticFunction,\n ExprBuilder,\n ConstraintType,\n ConstraintSense,\n)\nfrom .comparison_constraint import ComparisonConstraint\nfrom .solver_common import (\n _direct_get_model_attribute,\n _direct_set_model_attribute,\n _direct_get_entity_attribute,\n _direct_set_entity_attribute,\n)\nfrom .aml import make_variable_tupledict, make_variable_ndarray\nfrom .matrix import add_matrix_constraints\n\n\ndef detected_libraries():\n libs = []\n\n libname_pattern = {\n \"Linux\": r\"libmosek64\\.so\",\n \"Darwin\": r\"libmosek64\\.dylib\",\n \"Windows\": r\"mosek64_(\\d+)_(\\d+)\\.dll\",\n }[platform.system()]\n suffix_pattern = {\n \"Linux\": \"*.so\",\n \"Darwin\": \"*.dylib\",\n \"Windows\": \"*.dll\",\n }[platform.system()]\n\n # Environment\n possible_envs = [\n \"MOSEK_11_1_BINDIR\",\n \"MOSEK_11_0_BINDIR\",\n \"MOSEK_10_2_BINDIR\",\n \"MOSEK_10_1_BINDIR\",\n ]\n for env in possible_envs:\n home = os.environ.get(env, None)\n if home and os.path.exists(home):\n dir = Path(home)\n for path in dir.glob(suffix_pattern):\n match = re.match(libname_pattern, path.name)\n if match:\n libs.append(str(path))\n break\n\n # mosekpy installation\n try:\n import mosek\n\n dir = Path(mosek.__path__[0])\n\n libname_pattern = {\n \"Linux\": r\"libmosek64\\.so\\.*\",\n \"Darwin\": r\"libmosek64\\.*\\.dylib\",\n \"Windows\": r\"mosek64_(\\d+)_(\\d+)\\.dll\",\n }[platform.system()]\n suffix_pattern = {\n \"Linux\": \"*.so.*\",\n \"Darwin\": \"*.dylib\",\n \"Windows\": \"*.dll\",\n }[platform.system()]\n\n for path in dir.glob(suffix_pattern):\n match = re.match(libname_pattern, path.name)\n if match:\n libs.append(str(path))\n except Exception:\n pass\n\n # default names\n default_libname = {\n \"Linux\": [\"libmosek64.so\"],\n \"Darwin\": [\"libmosek64.dylib\"],\n \"Windows\": [\n \"mosek64_11_1.dll\",\n \"mosek64_11_0.dll\",\n \"mosek64_10_2.dll\",\n \"mosek64_10_1.dll\",\n ],\n }[platform.system()]\n libs.extend(default_libname)\n\n return libs\n\n\ndef autoload_library():\n libs = detected_libraries()\n for lib in libs:\n ret = load_library(lib)\n if ret:\n logging.info(f\"Loaded Mosek library: {lib}\")\n return True\n return False\n\n\nautoload_library()\n\nDEFAULT_ENV = None\n\n\ndef init_default_env():\n global DEFAULT_ENV\n if DEFAULT_ENV is None:\n DEFAULT_ENV = Env()\n\n\nvariable_attribute_get_func_map = {\n VariableAttribute.Value: lambda model, v: model.get_value(v),\n VariableAttribute.LowerBound: lambda model, v: model.get_variable_lower_bound(v),\n VariableAttribute.UpperBound: lambda model, v: model.get_variable_upper_bound(v),\n # VariableAttribute.PrimalStart: lambda model, v: model.mip_start_values.get(v, None),\n VariableAttribute.Domain: lambda model, v: model.get_variable_type(v),\n VariableAttribute.Name: lambda model, v: model.get_variable_name(v),\n VariableAttribute.ReducedCost: lambda model, v: model.get_variable_dual(v),\n}\n\nvariable_attribute_set_func_map = {\n VariableAttribute.LowerBound: lambda model, v, val: model.set_variable_lower_bound(\n v, val\n ),\n VariableAttribute.UpperBound: lambda model, v, val: model.set_variable_upper_bound(\n v, val\n ),\n VariableAttribute.PrimalStart: lambda model, v, val: model.set_variable_primal(\n v, val\n ),\n VariableAttribute.Domain: lambda model, v, val: model.set_variable_type(v, val),\n VariableAttribute.Name: lambda model, v, val: model.set_variable_name(v, val),\n}\n\n\ndef get_primalstatus(model):\n if model.m_is_dirty:\n return ResultStatusCode.NO_SOLUTION\n solsta = model.getsolsta()\n if solsta == Enum.MSK_SOL_STA_UNKNOWN:\n return ResultStatusCode.UNKNOWN_RESULT_STATUS\n elif solsta == Enum.MSK_SOL_STA_OPTIMAL:\n return ResultStatusCode.FEASIBLE_POINT\n elif solsta == Enum.MSK_SOL_STA_PRIM_FEAS:\n return ResultStatusCode.FEASIBLE_POINT\n elif solsta == Enum.MSK_SOL_STA_DUAL_FEAS:\n return ResultStatusCode.UNKNOWN_RESULT_STATUS\n elif solsta == Enum.MSK_SOL_STA_PRIM_AND_DUAL_FEAS:\n return ResultStatusCode.FEASIBLE_POINT\n elif solsta == Enum.MSK_SOL_STA_PRIM_INFEAS_CER:\n return ResultStatusCode.NO_SOLUTION\n elif solsta == Enum.MSK_SOL_STA_DUAL_INFEAS_CER:\n return ResultStatusCode.INFEASIBILITY_CERTIFICATE\n elif solsta == Enum.MSK_SOL_STA_PRIM_ILLPOSED_CER:\n return ResultStatusCode.NO_SOLUTION\n elif solsta == Enum.MSK_SOL_STA_DUAL_ILLPOSED_CER:\n return ResultStatusCode.REDUCTION_CERTIFICATE\n elif solsta == Enum.MSK_SOL_STA_INTEGER_OPTIMAL:\n return ResultStatusCode.FEASIBLE_POINT\n else:\n return ResultStatusCode.UNKNOWN_RESULT_STATUS\n\n\ndef get_dualstatus(model):\n if model.m_is_dirty:\n return ResultStatusCode.NO_SOLUTION\n solsta = model.getsolsta()\n if solsta == Enum.MSK_SOL_STA_UNKNOWN:\n return ResultStatusCode.UNKNOWN_RESULT_STATUS\n elif solsta == Enum.MSK_SOL_STA_OPTIMAL:\n return ResultStatusCode.FEASIBLE_POINT\n elif solsta == Enum.MSK_SOL_STA_PRIM_FEAS:\n return ResultStatusCode.UNKNOWN_RESULT_STATUS\n elif solsta == Enum.MSK_SOL_STA_DUAL_FEAS:\n return ResultStatusCode.FEASIBLE_POINT\n elif solsta == Enum.MSK_SOL_STA_PRIM_AND_DUAL_FEAS:\n return ResultStatusCode.FEASIBLE_POINT\n elif solsta == Enum.MSK_SOL_STA_PRIM_INFEAS_CER:\n return ResultStatusCode.INFEASIBILITY_CERTIFICATE\n elif solsta == Enum.MSK_SOL_STA_DUAL_INFEAS_CER:\n return ResultStatusCode.NO_SOLUTION\n elif solsta == Enum.MSK_SOL_STA_PRIM_ILLPOSED_CER:\n return ResultStatusCode.REDUCTION_CERTIFICATE\n elif solsta == Enum.MSK_SOL_STA_DUAL_ILLPOSED_CER:\n return ResultStatusCode.NO_SOLUTION\n elif solsta == Enum.MSK_SOL_STA_INTEGER_OPTIMAL:\n return ResultStatusCode.NO_SOLUTION\n else:\n return ResultStatusCode.UNKNOWN_RESULT_STATUS\n\n\nsolsta_names = {\n Enum.MSK_SOL_STA_UNKNOWN: \"MSK_SOL_STA_UNKNOWN\",\n Enum.MSK_SOL_STA_OPTIMAL: \"MSK_SOL_STA_OPTIMAL\",\n Enum.MSK_SOL_STA_PRIM_FEAS: \"MSK_SOL_STA_PRIM_FEAS\",\n Enum.MSK_SOL_STA_DUAL_FEAS: \"MSK_SOL_STA_DUAL_FEAS\",\n Enum.MSK_SOL_STA_PRIM_AND_DUAL_FEAS: \"MSK_SOL_STA_PRIM_AND_DUAL_FEAS\",\n Enum.MSK_SOL_STA_PRIM_INFEAS_CER: \"MSK_SOL_STA_PRIM_INFEAS_CER\",\n Enum.MSK_SOL_STA_DUAL_INFEAS_CER: \"MSK_SOL_STA_DUAL_INFEAS_CER\",\n Enum.MSK_SOL_STA_PRIM_ILLPOSED_CER: \"MSK_SOL_STA_PRIM_ILLPOSED_CER\",\n Enum.MSK_SOL_STA_DUAL_ILLPOSED_CER: \"MSK_SOL_STA_DUAL_ILLPOSED_CER\",\n Enum.MSK_SOL_STA_INTEGER_OPTIMAL: \"MSK_SOL_STA_INTEGER_OPTIMAL\",\n}\n\ntermination_names = {\n Enum.MSK_RES_OK: \"MSK_RES_OK\",\n Enum.MSK_RES_TRM_MAX_ITERATIONS: \"MSK_RES_TRM_MAX_ITERATIONS\",\n Enum.MSK_RES_TRM_MAX_TIME: \"MSK_RES_TRM_MAX_TIME\",\n Enum.MSK_RES_TRM_OBJECTIVE_RANGE: \"MSK_RES_TRM_OBJECTIVE_RANGE\",\n Enum.MSK_RES_TRM_STALL: \"MSK_RES_TRM_STALL\",\n Enum.MSK_RES_TRM_USER_CALLBACK: \"MSK_RES_TRM_USER_CALLBACK\",\n Enum.MSK_RES_TRM_MIO_NUM_RELAXS: \"MSK_RES_TRM_MIO_NUM_RELAXS\",\n Enum.MSK_RES_TRM_MIO_NUM_BRANCHES: \"MSK_RES_TRM_MIO_NUM_BRANCHES\",\n Enum.MSK_RES_TRM_NUM_MAX_NUM_INT_SOLUTIONS: \"MSK_RES_TRM_NUM_MAX_NUM_INT_SOLUTIONS\",\n Enum.MSK_RES_TRM_MAX_NUM_SETBACKS: \"MSK_RES_TRM_MAX_NUM_SETBACKS\",\n Enum.MSK_RES_TRM_NUMERICAL_PROBLEM: \"MSK_RES_TRM_NUMERICAL_PROBLEM\",\n Enum.MSK_RES_TRM_LOST_RACE: \"MSK_RES_TRM_LOST_RACE\",\n Enum.MSK_RES_TRM_INTERNAL: \"MSK_RES_TRM_INTERNAL\",\n Enum.MSK_RES_TRM_INTERNAL_STOP: \"MSK_RES_TRM_INTERNAL_STOP\",\n}\n\n\ndef get_rawstatusstring(model):\n if model.m_is_dirty:\n return \"OPTIMIZE_NOT_CALLED\"\n trm = model.last_solve_return_code\n if trm is None:\n return \"OPTIMIZE_NOT_CALLED\"\n elif trm == Enum.MSK_RES_OK:\n solsta = model.getsolsta()\n return solsta_names[solsta]\n else:\n return termination_names[trm]\n\n\ndef get_terminationstatus(model):\n if model.m_is_dirty:\n return TerminationStatusCode.OPTIMIZE_NOT_CALLED\n trm = model.last_solve_return_code\n prosta = model.getprosta()\n solsta = model.getsolsta()\n if trm is None:\n return TerminationStatusCode.OPTIMIZE_NOT_CALLED\n elif trm == Enum.MSK_RES_OK:\n if prosta in (Enum.MSK_PRO_STA_PRIM_INFEAS, Enum.MSK_PRO_STA_ILL_POSED):\n return TerminationStatusCode.INFEASIBLE\n elif prosta == Enum.MSK_PRO_STA_DUAL_INFEAS:\n return TerminationStatusCode.DUAL_INFEASIBLE\n elif prosta == Enum.MSK_PRO_STA_PRIM_INFEAS_OR_UNBOUNDED:\n return TerminationStatusCode.INFEASIBLE_OR_UNBOUNDED\n elif solsta in (Enum.MSK_SOL_STA_OPTIMAL, Enum.MSK_SOL_STA_INTEGER_OPTIMAL):\n return TerminationStatusCode.OPTIMAL\n else:\n return TerminationStatusCode.OTHER_ERROR # ??\n elif trm == Enum.MSK_RES_TRM_MAX_ITERATIONS:\n return TerminationStatusCode.ITERATION_LIMIT\n elif trm == Enum.MSK_RES_TRM_MAX_TIME:\n return TerminationStatusCode.TIME_LIMIT\n elif trm == Enum.MSK_RES_TRM_OBJECTIVE_RANGE:\n return TerminationStatusCode.OBJECTIVE_LIMIT\n elif trm == Enum.MSK_RES_TRM_MIO_NUM_RELAXS:\n return TerminationStatusCode.OTHER_LIMIT\n elif trm == Enum.MSK_RES_TRM_MIO_NUM_BRANCHES:\n return TerminationStatusCode.NODE_LIMIT\n elif trm == Enum.MSK_RES_TRM_NUM_MAX_NUM_INT_SOLUTIONS:\n return TerminationStatusCode.SOLUTION_LIMIT\n elif trm == Enum.MSK_RES_TRM_STALL:\n return TerminationStatusCode.SLOW_PROGRESS\n elif trm == Enum.MSK_RES_TRM_USER_CALLBACK:\n return TerminationStatusCode.INTERRUPTED\n elif trm == Enum.MSK_RES_TRM_MAX_NUM_SETBACKS:\n return TerminationStatusCode.OTHER_LIMIT\n elif trm == Enum.MSK_RES_TRM_NUMERICAL_PROBLEM:\n return TerminationStatusCode.SLOW_PROGRESS\n elif trm == Enum.MSK_RES_TRM_INTERNAL:\n return TerminationStatusCode.OTHER_ERROR\n elif trm == Enum.MSK_RES_TRM_INTERNAL_STOP:\n return TerminationStatusCode.OTHER_ERROR\n else:\n TerminationStatusCode.OTHER_ERROR\n\n\nmodel_attribute_get_func_map = {\n ModelAttribute.ObjectiveSense: lambda model: model.get_obj_sense(),\n ModelAttribute.DualObjectiveValue: lambda model: model.getdualobj(),\n ModelAttribute.ObjectiveValue: lambda model: model.getprimalobj(),\n ModelAttribute.SolveTimeSec: lambda model: model.get_raw_information_double(\n \"MSK_DINF_OPTIMIZER_TIME\"\n ),\n ModelAttribute.NumberOfThreads: lambda model: model.get_raw_parameter_int(\n \"MSK_IPAR_NUM_THREADS\"\n ),\n ModelAttribute.RelativeGap: lambda model: model.get_raw_parameter_double(\n \"MSK_DPAR_MIO_REL_GAP_CONST\"\n ),\n ModelAttribute.TimeLimitSec: lambda model: model.get_raw_parameter_double(\n \"MSK_DPAR_OPTIMIZER_MAX_TIME\"\n ),\n ModelAttribute.DualStatus: get_dualstatus,\n ModelAttribute.PrimalStatus: get_primalstatus,\n ModelAttribute.RawStatusString: get_rawstatusstring,\n ModelAttribute.TerminationStatus: get_terminationstatus,\n ModelAttribute.Silent: lambda model: model.silent,\n ModelAttribute.SolverName: lambda _: \"MOSEK\",\n ModelAttribute.SolverVersion: lambda model: model.version_string(),\n}\n\n\ndef set_silent(model, value: bool):\n model.silent = value\n if value:\n model.disable_log()\n else:\n model.set_logging(lambda msg: print(msg, end=\"\"))\n\n\nmodel_attribute_set_func_map = {\n ModelAttribute.ObjectiveSense: lambda model, v: model.set_obj_sense(v),\n ModelAttribute.NumberOfThreads: lambda model, v: model.set_raw_parameter_int(\n \"MSK_IPAR_NUM_THREADS\", v\n ),\n ModelAttribute.RelativeGap: lambda model, v: model.set_raw_parameter_double(\n \"MSK_DPAR_MIO_REL_GAP_CONST\", v\n ),\n ModelAttribute.TimeLimitSec: lambda model, v: model.set_raw_parameter_double(\n \"MSK_DPAR_OPTIMIZER_MAX_TIME\", v\n ),\n ModelAttribute.Silent: set_silent,\n}\n\nconstraint_attribute_get_func_map = {\n ConstraintAttribute.Name: lambda model, constraint: model.get_constraint_name(\n constraint\n ),\n ConstraintAttribute.Primal: lambda model, constraint: model.get_constraint_primal(\n constraint\n ),\n ConstraintAttribute.Dual: lambda model, constraint: model.get_constraint_dual(\n constraint\n ),\n}\n\nconstraint_attribute_set_func_map = {\n ConstraintAttribute.Name: lambda model, constraint, value: model.set_constraint_name(\n constraint, value\n ),\n}\n\n\ndef tell_enum_type(name: str):\n if name.startswith(\"MSK_D\"):\n return float\n elif name.startswith(\"MSK_I\"):\n return int\n elif name.startswith(\"MSK_S\"):\n return str\n else:\n raise ValueError(f\"Unknown parameter name: {name}\")\n\n\nclass Model(RawModel):\n def __init__(self, env=None):\n if env is None:\n init_default_env()\n env = DEFAULT_ENV\n super().__init__(env)\n # We must keep a reference to the environment to prevent it from being garbage collected\n self._env = env\n self.last_solve_return_code: Optional[int] = None\n self.silent = False\n self.set_logging(lambda msg: print(msg, end=\"\"))\n\n @staticmethod\n def supports_variable_attribute(attribute: VariableAttribute, settable=False):\n if settable:\n return attribute in variable_attribute_set_func_map\n else:\n return attribute in variable_attribute_get_func_map\n\n @staticmethod\n def supports_model_attribute(attribute: ModelAttribute, settable=False):\n if settable:\n return attribute in model_attribute_set_func_map\n else:\n return attribute in model_attribute_get_func_map\n\n @staticmethod\n def supports_constraint_attribute(attribute: ConstraintAttribute, settable=False):\n if settable:\n return attribute in constraint_attribute_set_func_map\n else:\n return attribute in constraint_attribute_get_func_map\n\n def get_variable_attribute(self, variable, attribute: VariableAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown variable attribute to get: {attribute}\")\n\n value = _direct_get_entity_attribute(\n self,\n variable,\n attribute,\n variable_attribute_get_func_map,\n e,\n )\n return value\n\n def set_variable_attribute(self, variable, attribute: VariableAttribute, value):\n def e(attribute):\n raise ValueError(f\"Unknown variable attribute to set: {attribute}\")\n\n _direct_set_entity_attribute(\n self,\n variable,\n attribute,\n value,\n variable_attribute_set_func_map,\n e,\n )\n\n def number_of_constraints(self, type: ConstraintType):\n if type not in {ConstraintType.Linear, ConstraintType.Quadratic}:\n raise ValueError(f\"Unknown constraint type: {type}\")\n return self.getnumcon()\n\n def number_of_variables(self):\n return self.getnumvar()\n\n def get_model_attribute(self, attribute: ModelAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown model attribute to get: {attribute}\")\n\n value = _direct_get_model_attribute(\n self,\n attribute,\n model_attribute_get_func_map,\n e,\n )\n return value\n\n def set_model_attribute(self, attribute: ModelAttribute, value):\n def e(attribute):\n raise ValueError(f\"Unknown model attribute to set: {attribute}\")\n\n _direct_set_model_attribute(\n self,\n attribute,\n value,\n model_attribute_set_func_map,\n e,\n )\n\n def get_constraint_attribute(self, constraint, attribute: ConstraintAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown constraint attribute to get: {attribute}\")\n\n value = _direct_get_entity_attribute(\n self,\n constraint,\n attribute,\n constraint_attribute_get_func_map,\n e,\n )\n return value\n\n def set_constraint_attribute(\n self, constraint, attribute: ConstraintAttribute, value\n ):\n def e(attribute):\n raise ValueError(f\"Unknown constraint attribute to set: {attribute}\")\n\n _direct_set_entity_attribute(\n self,\n constraint,\n attribute,\n value,\n constraint_attribute_set_func_map,\n e,\n )\n\n def get_raw_parameter(self, param_name: str):\n param_type = tell_enum_type(param_name)\n get_function_map = {\n int: self.get_raw_parameter_int,\n float: self.get_raw_parameter_double,\n str: self.get_raw_parameter_string,\n }\n get_function = get_function_map[param_type]\n return get_function(param_name)\n\n def set_raw_parameter(self, param_name: str, value):\n param_type = tell_enum_type(param_name)\n set_function_map = {\n int: self.set_raw_parameter_int,\n float: self.set_raw_parameter_double,\n str: self.set_raw_parameter_string,\n }\n set_function = set_function_map[param_type]\n set_function(param_name, value)\n\n def get_raw_information(self, param_name: str):\n param_type = tell_enum_type(param_name)\n get_function_map = {\n int: self.get_raw_information_int,\n float: self.get_raw_information_double,\n }\n get_function = get_function_map[param_type]\n return get_function(param_name)\n\n def optimize(self):\n ret = super().optimize()\n self.last_solve_return_code = ret\n\n @overload\n def add_linear_constraint(\n self,\n expr: Union[VariableIndex, ScalarAffineFunction, ExprBuilder],\n sense: ConstraintSense,\n rhs: float,\n name: str = \"\",\n ): ...\n\n @overload\n def add_linear_constraint(\n self,\n con: ComparisonConstraint,\n name: str = \"\",\n ): ...\n\n def add_linear_constraint(self, arg, *args, **kwargs):\n if isinstance(arg, ComparisonConstraint):\n return self._add_linear_constraint(\n arg.lhs, arg.sense, arg.rhs, *args, **kwargs\n )\n else:\n return self._add_linear_constraint(arg, *args, **kwargs)\n\n @overload\n def add_quadratic_constraint(\n self,\n expr: Union[ScalarQuadraticFunction, ExprBuilder],\n sense: ConstraintSense,\n rhs: float,\n name: str = \"\",\n ): ...\n\n @overload\n def add_quadratic_constraint(\n self,\n con: ComparisonConstraint,\n name: str = \"\",\n ): ...\n\n def add_quadratic_constraint(self, arg, *args, **kwargs):\n if isinstance(arg, ComparisonConstraint):\n return self._add_quadratic_constraint(\n arg.lhs, arg.sense, arg.rhs, *args, **kwargs\n )\n else:\n return self._add_quadratic_constraint(arg, *args, **kwargs)\n\n add_variables = make_variable_tupledict\n add_m_variables = make_variable_ndarray\n add_m_linear_constraints = add_matrix_constraints\n" }, { "path": "src/pyoptinterface/_src/nlfunc.py", "content": "from .nlexpr_ext import (\n ExpressionGraph,\n ExpressionHandle,\n UnaryOperator,\n BinaryOperator,\n TernaryOperator,\n)\nfrom .core_ext import (\n VariableIndex,\n ScalarAffineFunction,\n ScalarQuadraticFunction,\n ExprBuilder,\n ConstraintSense,\n)\nfrom .comparison_constraint import ComparisonConstraint\nimport functools\nimport math\nimport threading\n\n\nclass ExpressionGraphContext:\n _thread_local = threading.local()\n\n def __enter__(self):\n _thread_local = self._thread_local\n graph = ExpressionGraph()\n if not hasattr(_thread_local, \"_graph_stack\"):\n _thread_local._graph_stack = [graph]\n else:\n _thread_local._graph_stack.append(graph)\n return graph\n\n def __exit__(self, exc_type, exc_val, exc_tb):\n self._thread_local._graph_stack.pop()\n\n @classmethod\n def current_graph_no_exception(cls):\n _thread_local = cls._thread_local\n if not hasattr(_thread_local, \"_graph_stack\"):\n return None\n stack = _thread_local._graph_stack\n if not stack:\n return None\n return stack[-1]\n\n @classmethod\n def current_graph(cls):\n _thread_local = cls._thread_local\n if not hasattr(_thread_local, \"_graph_stack\"):\n raise RuntimeError(\"No active expression graph context\")\n stack = _thread_local._graph_stack\n if not stack:\n raise RuntimeError(\"No active expression graph context\")\n return stack[-1]\n\n\ncompare_op_map = {\n ConstraintSense.LessEqual: BinaryOperator.LessEqual,\n ConstraintSense.GreaterEqual: BinaryOperator.GreaterEqual,\n ConstraintSense.Equal: BinaryOperator.Equal,\n}\n\n\ndef convert_to_expressionhandle(graph, expr):\n if isinstance(expr, ExpressionHandle):\n return expr\n elif isinstance(expr, (int, float)):\n return graph.add_constant(expr)\n elif isinstance(expr, VariableIndex):\n return graph.merge_variableindex(expr)\n elif isinstance(expr, ScalarAffineFunction):\n return graph.merge_scalaraffinefunction(expr)\n elif isinstance(expr, ScalarQuadraticFunction):\n return graph.merge_scalarquadraticfunction(expr)\n elif isinstance(expr, ExprBuilder):\n return graph.merge_exprbuilder(expr)\n elif isinstance(expr, ComparisonConstraint):\n lhs = convert_to_expressionhandle(graph, expr.lhs)\n rhs = convert_to_expressionhandle(graph, expr.rhs)\n if isinstance(lhs, ExpressionHandle) and isinstance(rhs, ExpressionHandle):\n compare_op = compare_op_map[expr.sense]\n expr = graph.add_binary(compare_op, lhs, rhs)\n return expr\n else:\n raise TypeError(f\"Unsupported expression type in comparison constraint\")\n else:\n return expr\n\n\ndef to_nlexpr(expr):\n if isinstance(expr, ExpressionHandle):\n return expr\n graph = ExpressionGraphContext.current_graph()\n if isinstance(expr, (int, float)):\n return graph.add_constant(expr)\n elif isinstance(expr, VariableIndex):\n return graph.merge_variableindex(expr)\n elif isinstance(expr, ScalarAffineFunction):\n return graph.merge_scalaraffinefunction(expr)\n elif isinstance(expr, ScalarQuadraticFunction):\n return graph.merge_scalarquadraticfunction(expr)\n elif isinstance(expr, ExprBuilder):\n return graph.merge_exprbuilder(expr)\n else:\n raise TypeError(f\"Unsupported expression type: {type(expr)}\")\n\n\n# Implement unary mathematical functions\ndef unary_mathematical_function(math_function, op: UnaryOperator):\n @functools.wraps(math_function)\n def f(expr):\n if isinstance(expr, (int, float)):\n return math_function(expr)\n graph = ExpressionGraphContext.current_graph()\n expr = convert_to_expressionhandle(graph, expr)\n if isinstance(expr, ExpressionHandle):\n new_expression = graph.add_unary(op, expr)\n return new_expression\n else:\n return NotImplemented\n\n return f\n\n\nsin = unary_mathematical_function(math.sin, UnaryOperator.Sin)\ncos = unary_mathematical_function(math.cos, UnaryOperator.Cos)\ntan = unary_mathematical_function(math.tan, UnaryOperator.Tan)\nasin = unary_mathematical_function(math.asin, UnaryOperator.Asin)\nacos = unary_mathematical_function(math.acos, UnaryOperator.Acos)\natan = unary_mathematical_function(math.atan, UnaryOperator.Atan)\nabs = unary_mathematical_function(math.fabs, UnaryOperator.Abs)\nsqrt = unary_mathematical_function(math.sqrt, UnaryOperator.Sqrt)\nexp = unary_mathematical_function(math.exp, UnaryOperator.Exp)\nlog = unary_mathematical_function(math.log, UnaryOperator.Log)\nlog10 = unary_mathematical_function(math.log10, UnaryOperator.Log10)\n\n\n# Implement binary mathematical functions\ndef binary_mathematical_function(math_function, op: BinaryOperator):\n @functools.wraps(math_function)\n def f(expr1, expr2):\n is_number1 = isinstance(expr1, (int, float))\n is_number2 = isinstance(expr2, (int, float))\n if is_number1 and is_number2:\n return math_function(expr1, expr2)\n\n graph = ExpressionGraphContext.current_graph()\n\n expr1 = convert_to_expressionhandle(graph, expr1)\n expr2 = convert_to_expressionhandle(graph, expr2)\n\n if isinstance(expr1, ExpressionHandle) and isinstance(expr2, ExpressionHandle):\n new_expression = graph.add_binary(op, expr1, expr2)\n return new_expression\n else:\n return NotImplemented\n\n return f\n\n\npow = binary_mathematical_function(math.pow, BinaryOperator.Pow)\n\n\ndef ifelse(condition, true_expr, false_expr):\n graph = ExpressionGraphContext.current_graph()\n if isinstance(condition, bool):\n if condition:\n return true_expr\n else:\n return false_expr\n\n condition = convert_to_expressionhandle(graph, condition)\n true_expr = convert_to_expressionhandle(graph, true_expr)\n false_expr = convert_to_expressionhandle(graph, false_expr)\n\n new_expression = graph.add_ternary(\n TernaryOperator.IfThenElse, condition, true_expr, false_expr\n )\n return new_expression\n" }, { "path": "src/pyoptinterface/_src/solver_common.py", "content": "# include some common methods for solver intergaces\n\n\ndef _get_model_attribute(\n model, attribute, get_func_map, value_translate_map, error_callback\n):\n get_function = get_func_map.get(attribute, None)\n if not get_function:\n raise error_callback(attribute)\n value = get_function(model)\n translate_function = value_translate_map.get(attribute, None)\n if translate_function:\n value = translate_function(value)\n return value\n\n\ndef _direct_get_model_attribute(model, attribute, get_func_map, error_callback):\n get_function = get_func_map.get(attribute, None)\n if not get_function:\n raise error_callback(attribute)\n value = get_function(model)\n return value\n\n\ndef _set_model_attribute(\n model,\n attribute,\n value,\n set_func_map,\n value_translate_map,\n error_callback,\n):\n translate_function = value_translate_map.get(attribute, None)\n if translate_function:\n value = translate_function(value)\n set_function = set_func_map.get(attribute, None)\n if not set_function:\n raise error_callback(attribute)\n set_function(model, value)\n\n\ndef _direct_set_model_attribute(\n model,\n attribute,\n value,\n set_func_map,\n error_callback,\n):\n set_function = set_func_map.get(attribute, None)\n if not set_function:\n raise error_callback(attribute)\n set_function(model, value)\n\n\ndef _get_entity_attribute(\n model, entity, attribute, get_func_map, value_translate_map, error_callback\n):\n get_function = get_func_map.get(attribute, None)\n if not get_function:\n raise error_callback(attribute)\n value = get_function(model, entity)\n translate_function = value_translate_map.get(attribute, None)\n if translate_function:\n value = translate_function(value)\n return value\n\n\ndef _direct_get_entity_attribute(\n model, entity, attribute, get_func_map, error_callback\n):\n get_function = get_func_map.get(attribute, None)\n if not get_function:\n raise error_callback(attribute)\n value = get_function(model, entity)\n return value\n\n\ndef _set_entity_attribute(\n model,\n entity,\n attribute,\n value,\n set_func_map,\n value_translate_map,\n error_callback,\n):\n translate_function = value_translate_map.get(attribute, None)\n if translate_function:\n value = translate_function(value)\n set_function = set_func_map.get(attribute, None)\n if not set_function:\n raise error_callback(attribute)\n set_function(model, entity, value)\n\n\ndef _direct_set_entity_attribute(\n model,\n entity,\n attribute,\n value,\n set_func_map,\n error_callback,\n):\n set_function = set_func_map.get(attribute, None)\n if not set_function:\n raise error_callback(attribute)\n set_function(model, entity, value)\n" }, { "path": "src/pyoptinterface/_src/tupledict.py", "content": "from typing import Iterable\nfrom itertools import product\n\nWILDCARD = \"*\"\n\n\nclass tupledict(dict):\n def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.__select_cache = None\n self.__scalar = False\n\n def __setitem__(self, key, value):\n super().__setitem__(key, value)\n self.__select_cache = None\n\n def __delitem__(self, key):\n super().__delitem__(key)\n self.__select_cache = None\n\n def __check_key_length(self):\n if len(self) == 0:\n return\n first_key = next(iter(self.keys()))\n if isinstance(first_key, tuple):\n key_len = len(first_key)\n for k in self.keys():\n if len(k) != key_len:\n raise ValueError(\n \"The length of keys in tupledict is not consistent\"\n )\n self.__key_len = key_len\n self.__scalar = False\n else:\n key_len = 1\n self.__key_len = key_len\n self.__scalar = True\n\n def select(self, *keys, with_key=False):\n if len(keys) == 0:\n yield from ()\n return\n if self.__scalar:\n if len(keys) != 1:\n raise ValueError(\n \"The length of keys is not consistent with the scalar tupledict\"\n )\n key = keys[0]\n if key == WILDCARD:\n if with_key:\n yield from self.items()\n else:\n yield from self.values()\n else:\n if key in self:\n if with_key:\n yield key, self[key]\n else:\n yield self[key]\n else:\n yield from ()\n else:\n if self.__select_cache is None:\n self.__check_key_length()\n self.__select_cache = dict()\n key_len = self.__key_len\n if len(keys) > key_len:\n raise ValueError(\n f\"Too many keys for tupledict with {key_len}-tuple keys\"\n )\n no_wildcard_indices = tuple(\n i for i, key in enumerate(keys) if key != WILDCARD\n )\n if len(no_wildcard_indices) == 0:\n if with_key:\n yield from self.items()\n else:\n yield from self.values()\n return\n no_wildcard_keys = tuple(keys[i] for i in no_wildcard_indices)\n select_cache = self.__select_cache\n indices_cache = select_cache.get(no_wildcard_indices, None)\n if indices_cache is None:\n indices_cache = dict()\n for k, v in self.items():\n indices = tuple(k[i] for i in no_wildcard_indices)\n kv_cache = indices_cache.get(indices, None)\n if kv_cache is None:\n indices_cache[indices] = [(k, v)]\n else:\n kv_cache.append((k, v))\n select_cache[no_wildcard_indices] = indices_cache\n kv_cache = indices_cache.get(no_wildcard_keys, None)\n if kv_cache is None:\n yield from ()\n else:\n if with_key:\n yield from kv_cache\n else:\n for k, v in kv_cache:\n yield v\n\n def clean(self):\n self.__select_cache = None\n\n def map(self, func):\n return tupledict((k, func(v)) for k, v in self.items())\n\n\ndef flatten_tuple(t):\n # (1, (2, 3), (4, 5)) -> (1, 2, 3, 4, 5)\n for it in t:\n if isinstance(it, tuple) or isinstance(it, list):\n for element in it:\n yield element\n else:\n yield it\n\n\ndef make_tupledict(*coords: Iterable, rule):\n d = {}\n assert len(coords) > 0\n for coord in product(*coords):\n # (1, (2, 3), (4, 5)) -> (1, 2, 3, 4, 5)\n coord = tuple(flatten_tuple(coord))\n value = rule(*coord)\n if len(coord) == 1:\n coord = coord[0]\n if value is not None:\n d[coord] = value\n return tupledict(d)\n" }, { "path": "src/pyoptinterface/_src/xpress.py", "content": "import os\nimport platform\nfrom pathlib import Path\nimport logging\nfrom typing import Dict, Tuple, Union, overload\n\nfrom .xpress_model_ext import RawModel, Env, load_library, XPRS\nfrom .attributes import (\n VariableAttribute,\n ConstraintAttribute,\n ModelAttribute,\n ResultStatusCode,\n TerminationStatusCode,\n)\nfrom .core_ext import (\n VariableIndex,\n ScalarAffineFunction,\n ScalarQuadraticFunction,\n ExprBuilder,\n VariableDomain,\n ConstraintType,\n ConstraintSense,\n ObjectiveSense,\n)\nfrom .nlexpr_ext import ExpressionHandle\nfrom .nlfunc import ExpressionGraphContext, convert_to_expressionhandle\nfrom .comparison_constraint import ComparisonConstraint\nfrom .solver_common import (\n _get_model_attribute,\n _set_model_attribute,\n _get_entity_attribute,\n _direct_get_entity_attribute,\n _set_entity_attribute,\n _direct_set_entity_attribute,\n)\n\nfrom .aml import make_variable_tupledict, make_variable_ndarray\nfrom .matrix import add_matrix_constraints\n\n\ndef detected_libraries():\n libs = []\n\n subdir = {\n \"Linux\": \"lib\",\n \"Darwin\": \"lib\",\n \"Windows\": \"bin\",\n }[platform.system()]\n libname = {\n \"Linux\": \"libxprs.so\",\n \"Darwin\": \"libxprs.dylib\",\n \"Windows\": \"xprs.dll\",\n }[platform.system()]\n\n # Environment\n home = os.environ.get(\"XPRESSDIR\", None)\n if home and os.path.exists(home):\n lib = Path(home) / subdir / libname\n if lib.exists():\n libs.append(str(lib))\n\n # default names\n default_libname = libname\n libs.append(default_libname)\n\n return libs\n\n\ndef autoload_library():\n libs = detected_libraries()\n for lib in libs:\n ret = load_library(lib)\n if ret:\n logging.info(f\"Loaded Xpress library: {lib}\")\n return True\n return False\n\n\nautoload_library()\n\n\n# LP status codes (TerminationStatus, RawStatusString)\n_RAW_LPSTATUS_STRINGS = {\n XPRS.LPSTATUS.UNSTARTED: (\n TerminationStatusCode.OPTIMIZE_NOT_CALLED,\n \"LP problem optimization not started\",\n ),\n XPRS.LPSTATUS.OPTIMAL: (\n TerminationStatusCode.OPTIMAL,\n \"Optimal LP solution found\",\n ),\n XPRS.LPSTATUS.INFEAS: (\n TerminationStatusCode.INFEASIBLE,\n \"Infeasible LP problem\",\n ),\n XPRS.LPSTATUS.CUTOFF: (\n TerminationStatusCode.OBJECTIVE_LIMIT,\n \"LP problem objective worse than cutoff value\",\n ),\n XPRS.LPSTATUS.UNFINISHED: (\n TerminationStatusCode.ITERATION_LIMIT,\n \"LP problem optimization unfinished\",\n ),\n XPRS.LPSTATUS.UNBOUNDED: (\n TerminationStatusCode.DUAL_INFEASIBLE,\n \"LP problem is unbounded\",\n ),\n XPRS.LPSTATUS.CUTOFF_IN_DUAL: (\n TerminationStatusCode.OBJECTIVE_LIMIT,\n \"LP dual bound is worse than dual cutoff value\",\n ),\n XPRS.LPSTATUS.UNSOLVED: (\n TerminationStatusCode.NUMERICAL_ERROR,\n \"LP problem could not be solved due to numerical issues\",\n ),\n XPRS.LPSTATUS.NONCONVEX: (\n TerminationStatusCode.INVALID_MODEL,\n \"LP problem contains quadratic data which is not convex, consider using FICO Xpress Global\",\n ),\n}\n\n# MIP status codes (TerminationStatus, RawStatusString)\n_RAW_MIPSTATUS_STRINGS = {\n XPRS.MIPSTATUS.NOT_LOADED: (\n TerminationStatusCode.OPTIMIZE_NOT_CALLED,\n \"MIP problem has not been loaded\",\n ),\n XPRS.MIPSTATUS.LP_NOT_OPTIMAL: (\n TerminationStatusCode.ITERATION_LIMIT,\n \"MIP search incomplete, the initial continuous relaxation has not been solved and no integer solution has been found\",\n ),\n XPRS.MIPSTATUS.LP_OPTIMAL: (\n TerminationStatusCode.ITERATION_LIMIT,\n \"MIP search incomplete, the initial continuous relaxation has been solved and no integer solution has been found\",\n ),\n XPRS.MIPSTATUS.NO_SOL_FOUND: (\n TerminationStatusCode.ITERATION_LIMIT,\n \"MIP search incomplete, no integer solution found\",\n ),\n XPRS.MIPSTATUS.SOLUTION: (\n TerminationStatusCode.ITERATION_LIMIT,\n \"MIP search incomplete, an integer solution has been found\",\n ),\n XPRS.MIPSTATUS.INFEAS: (\n TerminationStatusCode.INFEASIBLE,\n \"MIP search complete, MIP is infeasible, no integer solution found\",\n ),\n XPRS.MIPSTATUS.OPTIMAL: (\n TerminationStatusCode.OPTIMAL,\n \"MIP search complete, optimal integer solution found\",\n ),\n XPRS.MIPSTATUS.UNBOUNDED: (\n TerminationStatusCode.DUAL_INFEASIBLE,\n \"MIP search incomplete, the initial continuous relaxation was found to be unbounded. A solution may have been found\",\n ),\n}\n\n# NLP status codes (TerminationStatus, RawStatusString)\n_RAW_NLPSTATUS_STRINGS = {\n XPRS.NLPSTATUS.UNSTARTED: (\n TerminationStatusCode.OPTIMIZE_NOT_CALLED,\n \"Optimization unstarted\",\n ),\n XPRS.NLPSTATUS.SOLUTION: (\n TerminationStatusCode.LOCALLY_SOLVED,\n \"Solution found\",\n ),\n XPRS.NLPSTATUS.OPTIMAL: (\n TerminationStatusCode.OPTIMAL,\n \"Globally optimal\",\n ),\n XPRS.NLPSTATUS.NOSOLUTION: (\n TerminationStatusCode.ITERATION_LIMIT,\n \"No solution found\",\n ),\n XPRS.NLPSTATUS.INFEASIBLE: (\n TerminationStatusCode.INFEASIBLE,\n \"Proven infeasible\",\n ),\n XPRS.NLPSTATUS.UNBOUNDED: (\n TerminationStatusCode.DUAL_INFEASIBLE,\n \"Locally unbounded\",\n ),\n XPRS.NLPSTATUS.UNFINISHED: (\n TerminationStatusCode.ITERATION_LIMIT,\n \"Not yet solved to completion\",\n ),\n XPRS.NLPSTATUS.UNSOLVED: (\n TerminationStatusCode.NUMERICAL_ERROR,\n \"Could not be solved due to numerical issues\",\n ),\n}\n\n\ndef get_terminationstatus(model):\n opt_type = model.get_optimize_type()\n\n if opt_type == XPRS.OPTIMIZETYPE.LP:\n raw_status = model.get_lp_status()\n status_string_pair = _RAW_LPSTATUS_STRINGS.get(raw_status, None)\n elif opt_type == XPRS.OPTIMIZETYPE.MIP:\n raw_status = model.get_mip_status()\n status_string_pair = _RAW_MIPSTATUS_STRINGS.get(raw_status, None)\n else: # NLP or LOCAL\n raw_status = model.get_nlp_status()\n status_string_pair = _RAW_NLPSTATUS_STRINGS.get(raw_status, None)\n\n if not status_string_pair:\n raise ValueError(f\"Unknown termination status: {raw_status}\")\n return status_string_pair[0]\n\n\ndef get_primalstatus(model):\n opt_type = model.get_optimize_type()\n\n if opt_type == XPRS.OPTIMIZETYPE.LP:\n status = model.get_lp_status()\n if status == XPRS.LPSTATUS.OPTIMAL:\n return ResultStatusCode.FEASIBLE_POINT\n return ResultStatusCode.NO_SOLUTION\n\n elif opt_type == XPRS.OPTIMIZETYPE.MIP:\n status = model.get_mip_status()\n if model.get_raw_attribute_int_by_id(XPRS.MIPSOLS) > 0:\n return ResultStatusCode.FEASIBLE_POINT\n return ResultStatusCode.NO_SOLUTION\n\n else: # NLP or LOCAL\n status = model.get_nlp_status()\n if status in (\n XPRS.NLPSTATUS.OPTIMAL,\n XPRS.NLPSTATUS.SOLUTION,\n XPRS.NLPSTATUS.UNBOUNDED,\n ):\n return ResultStatusCode.FEASIBLE_POINT\n return ResultStatusCode.NO_SOLUTION\n\n\ndef get_dualstatus(model):\n opt_type = model.get_optimize_type()\n if opt_type != XPRS.OPTIMIZETYPE.LP:\n return ResultStatusCode.NO_SOLUTION\n\n status = model.get_lp_status()\n if status == XPRS.LPSTATUS.OPTIMAL:\n return ResultStatusCode.FEASIBLE_POINT\n return ResultStatusCode.NO_SOLUTION\n\n\ndef get_rawstatusstring(model):\n opt_type = model.get_optimize_type()\n\n if opt_type == XPRS.OPTIMIZETYPE.LP:\n raw_status = model.get_lp_status()\n status_string_pair = _RAW_LPSTATUS_STRINGS.get(raw_status, None)\n elif opt_type == XPRS.OPTIMIZETYPE.MIP:\n raw_status = model.get_mip_status()\n status_string_pair = _RAW_MIPSTATUS_STRINGS.get(raw_status, None)\n else: # NLP or LOCAL\n raw_status = model.get_nlp_status()\n status_string_pair = _RAW_NLPSTATUS_STRINGS.get(raw_status, None)\n\n if not status_string_pair:\n raise ValueError(f\"Unknown termination status: {raw_status}\")\n return status_string_pair[1]\n\n\n# Variable maps\nvariable_attribute_get_func_map = { # UB, LB, Name, etc\n VariableAttribute.Value: lambda model, v: model.get_variable_value(v),\n VariableAttribute.LowerBound: lambda model, v: model.get_variable_lowerbound(v),\n VariableAttribute.UpperBound: lambda model, v: model.get_variable_upperbound(v),\n VariableAttribute.PrimalStart: lambda model, v: model.get_variable_mip_start(v),\n VariableAttribute.Domain: lambda model, v: model.get_variable_type(v),\n VariableAttribute.Name: lambda model, v: model.get_variable_name(v),\n VariableAttribute.IISLowerBound: lambda model, v: model.get_variable_lowerbound_IIS(\n v\n ),\n VariableAttribute.IISUpperBound: lambda model, v: model.get_variable_upperbound_IIS(\n v\n ),\n VariableAttribute.ReducedCost: lambda model, v: model.get_variable_rc(v),\n}\n\nvariable_attribute_set_func_map = (\n { # Subset of the previous one about stuff that can be set\n VariableAttribute.LowerBound: lambda model, v, x: model.set_variable_lowerbound(\n v, x\n ),\n VariableAttribute.UpperBound: lambda model, v, x: model.set_variable_upperbound(\n v, x\n ),\n VariableAttribute.PrimalStart: lambda model, v, x: model.set_variable_mip_start(\n v, x\n ),\n VariableAttribute.Domain: lambda model, v, x: model.set_variable_type(v, x),\n VariableAttribute.Name: lambda model, v, x: model.set_variable_name(v, x),\n }\n)\n\nconstraint_attribute_get_func_map = {\n ConstraintAttribute.Name: lambda model, c: model.get_constraint_name(c),\n ConstraintAttribute.Primal: lambda model, c: model.get_normalized_rhs(c)\n - model.get_constraint_slack(c),\n ConstraintAttribute.Dual: lambda model, c: model.get_constraint_dual(c),\n ConstraintAttribute.IIS: lambda model, c: model.is_constraint_in_IIS(c),\n}\n\nconstraint_attribute_set_func_map = {\n ConstraintAttribute.Name: lambda model, constraint, value: model.set_constraint_name(\n constraint, value\n ),\n}\n\nmodel_attribute_get_func_map = {\n ModelAttribute.Name: lambda model: model.get_problem_name(),\n ModelAttribute.ObjectiveSense: lambda model: model.get_raw_attribute_dbl_by_id(\n XPRS.OBJSENSE\n ),\n ModelAttribute.BarrierIterations: lambda model: model.get_raw_attribute_int_by_id(\n XPRS.BARITER\n ),\n ModelAttribute.DualObjectiveValue: lambda model: model.get_raw_attribute_dbl_by_id(\n XPRS.LPOBJVAL\n ),\n ModelAttribute.NodeCount: lambda model: model.get_raw_attribute_int_by_id(\n XPRS.NODES\n ),\n ModelAttribute.ObjectiveBound: lambda model: model.get_raw_attribute_dbl_by_id(\n XPRS.LPOBJVAL\n ),\n ModelAttribute.ObjectiveValue: lambda model: model.get_raw_attribute_dbl_by_id(\n XPRS.OBJVAL\n ),\n ModelAttribute.SimplexIterations: lambda model: model.get_raw_attribute_int_by_id(\n XPRS.SIMPLEXITER\n ),\n ModelAttribute.SolveTimeSec: lambda model: model.get_raw_attribute_dbl_by_id(\n XPRS.TIME\n ),\n ModelAttribute.NumberOfThreads: lambda model: model.get_raw_control_int(\n XPRS.THREADS\n ),\n ModelAttribute.RelativeGap: lambda model: model.get_raw_control_dbl_by_id(\n XPRS.MIPRELSTOP\n ),\n ModelAttribute.TimeLimitSec: lambda model: model.get_raw_contorl_dbl_by_id(\n XPRS.TIMELIMIT\n ),\n ModelAttribute.DualStatus: get_dualstatus,\n ModelAttribute.PrimalStatus: get_primalstatus,\n ModelAttribute.RawStatusString: get_rawstatusstring,\n ModelAttribute.TerminationStatus: get_terminationstatus,\n ModelAttribute.Silent: lambda model: model.get_raw_control_int_by_id(XPRS.OUTPUTLOG)\n == 0,\n ModelAttribute.SolverName: lambda _: \"FICO Xpress\",\n ModelAttribute.SolverVersion: lambda model: model.version_string(),\n}\n\nmodel_control_set_func_map = {\n ModelAttribute.Name: lambda model, value: model.set_problem_name(value),\n ModelAttribute.ObjectiveSense: lambda model, value: model.set_raw_control_dbl_by_id(\n XPRS.OBJSENSE, value\n ),\n ModelAttribute.NumberOfThreads: lambda model, value: model.set_raw_control_int_by_id(\n XPRS.THREADS, value\n ),\n ModelAttribute.TimeLimitSec: lambda model, value: model.set_raw_control_dbl_by_id(\n XPRS.TIMELIMIT, value\n ),\n ModelAttribute.Silent: lambda model, value: model.set_raw_control_int_by_id(\n XPRS.OUTPUTLOG, 0 if value else 1\n ),\n}\n\nmodel_attribute_get_translate_func_map = {\n ModelAttribute.ObjectiveSense: lambda v: {\n XPRS.OBJ_MINIMIZE: ObjectiveSense.Minimize,\n XPRS.OBJ_MAXIMIZE: ObjectiveSense.Maximize,\n }[v],\n}\n\nmodel_attribute_set_translate_func_map = {\n ModelAttribute.ObjectiveSense: lambda v: {\n ObjectiveSense.Minimize: XPRS.OBJ_MINIMIZE,\n ObjectiveSense.Maximize: XPRS.OBJ_MAXIMIZE,\n }[v],\n}\n\nDEFAULT_ENV = None\n\n\ndef init_default_env():\n global DEFAULT_ENV\n if DEFAULT_ENV is None:\n DEFAULT_ENV = Env()\n\n\nclass Model(RawModel):\n def __init__(self, env=None):\n # Initializing with raw model object\n if isinstance(env, RawModel):\n super().__init__(env)\n return\n\n if env is None:\n init_default_env()\n env = DEFAULT_ENV\n super().__init__(env)\n self.mip_start_values: Dict[VariableIndex, float] = dict()\n\n def optimize(self):\n if self._is_mip():\n mip_start = self.mip_start_values\n if len(mip_start) != 0:\n variables = list(mip_start.keys())\n values = list(mip_start.values())\n self.add_mip_start(variables, values)\n mip_start.clear()\n super().optimize()\n\n @staticmethod\n def supports_variable_attribute(attribute: VariableAttribute, settable=False):\n if settable:\n return attribute in variable_attribute_set_func_map\n else:\n return attribute in variable_attribute_get_func_map\n\n @staticmethod\n def supports_model_attribute(attribute: ModelAttribute, settable=False):\n if settable:\n return attribute in model_control_set_func_map\n else:\n return attribute in model_attribute_get_func_map\n\n @staticmethod\n def supports_constraint_attribute(attribute: ConstraintAttribute, settable=False):\n if settable:\n return attribute in constraint_attribute_set_func_map\n else:\n return attribute in constraint_attribute_get_func_map\n\n def get_variable_attribute(self, variable, attribute: VariableAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown variable attribute to get: {attribute}\")\n\n value = _direct_get_entity_attribute(\n self,\n variable,\n attribute,\n variable_attribute_get_func_map,\n e,\n )\n return value\n\n def set_variable_attribute(self, variable, attribute: VariableAttribute, value):\n def e(attribute):\n raise ValueError(f\"Unknown variable attribute to set: {attribute}\")\n\n _direct_set_entity_attribute(\n self,\n variable,\n attribute,\n value,\n variable_attribute_set_func_map,\n e,\n )\n\n def number_of_constraints(self, type: ConstraintType):\n if type in {ConstraintType.Linear, ConstraintType.Quadratic}:\n return self.get_raw_attribute_int_by_id(XPRS.ROWS)\n if type == ConstraintType.SOS:\n return self.get_raw_attribute_int_by_id(XPRS.SETS)\n raise ValueError(f\"Unknown constraint type: {type}\")\n\n def number_of_variables(self):\n return self.get_raw_attribute_int_by_id(XPRS.INPUTCOLS)\n\n def get_model_attribute(self, attribute: ModelAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown model attribute to get: {attribute}\")\n\n value = _get_model_attribute(\n self,\n attribute,\n model_attribute_get_func_map,\n model_attribute_get_translate_func_map,\n e,\n )\n return value\n\n def set_model_attribute(self, attribute: ModelAttribute, value):\n def e(attribute):\n raise ValueError(f\"Unknown model attribute to set: {attribute}\")\n\n _set_model_attribute(\n self,\n attribute,\n value,\n model_control_set_func_map,\n model_attribute_set_translate_func_map,\n e,\n )\n\n def get_constraint_attribute(self, constraint, attribute: ConstraintAttribute):\n def e(attribute):\n raise ValueError(f\"Unknown constraint attribute to get: {attribute}\")\n\n value = _direct_get_entity_attribute(\n self,\n constraint,\n attribute,\n constraint_attribute_get_func_map,\n e,\n )\n return value\n\n def set_constraint_attribute(\n self, constraint, attribute: ConstraintAttribute, value\n ):\n def e(attribute):\n raise ValueError(f\"Unknown constraint attribute to set: {attribute}\")\n\n _direct_set_entity_attribute(\n self,\n constraint,\n attribute,\n value,\n constraint_attribute_set_func_map,\n e,\n )\n\n @overload\n def add_linear_constraint(\n self,\n expr: Union[VariableIndex, ScalarAffineFunction, ExprBuilder],\n sense: ConstraintSense,\n rhs: float,\n name: str = \"\",\n ): ...\n\n @overload\n def add_linear_constraint(\n self,\n expr: Union[VariableIndex, ScalarAffineFunction, ExprBuilder],\n interval: Tuple[float, float],\n name: str = \"\",\n ): ...\n\n @overload\n def add_linear_constraint(\n self,\n con: ComparisonConstraint,\n name: str = \"\",\n ): ...\n\n def add_linear_constraint(self, arg, *args, **kwargs):\n if isinstance(arg, ComparisonConstraint):\n return self._add_linear_constraint(\n arg.lhs, arg.sense, arg.rhs, *args, **kwargs\n )\n else:\n return self._add_linear_constraint(arg, *args, **kwargs)\n\n @overload\n def add_quadratic_constraint(\n self,\n expr: Union[ScalarQuadraticFunction, ExprBuilder],\n sense: ConstraintSense,\n rhs: float,\n name: str = \"\",\n ): ...\n\n @overload\n def add_quadratic_constraint(\n self,\n con: ComparisonConstraint,\n name: str = \"\",\n ): ...\n\n def add_quadratic_constraint(self, arg, *args, **kwargs):\n if isinstance(arg, ComparisonConstraint):\n return self._add_quadratic_constraint(\n arg.lhs, arg.sense, arg.rhs, *args, **kwargs\n )\n else:\n return self._add_quadratic_constraint(arg, *args, **kwargs)\n\n @overload\n def add_nl_constraint(\n self,\n expr,\n sense: ConstraintSense,\n rhs: float,\n /,\n name: str = \"\",\n ): ...\n\n @overload\n def add_nl_constraint(\n self,\n expr,\n interval: Tuple[float, float],\n /,\n name: str = \"\",\n ): ...\n\n @overload\n def add_nl_constraint(\n self,\n con,\n /,\n name: str = \"\",\n ): ...\n\n def add_nl_constraint(self, expr, *args, **kwargs):\n graph = ExpressionGraphContext.current_graph()\n expr = convert_to_expressionhandle(graph, expr)\n if not isinstance(expr, ExpressionHandle):\n raise ValueError(\"Expression should be convertible to ExpressionHandle\")\n\n con = self._add_single_nl_constraint(graph, expr, *args, **kwargs)\n return con\n\n def add_nl_objective(self, expr):\n graph = ExpressionGraphContext.current_graph()\n expr = convert_to_expressionhandle(graph, expr)\n if not isinstance(expr, ExpressionHandle):\n raise ValueError(\"Expression should be convertible to ExpressionHandle\")\n self._add_single_nl_objective(graph, expr)\n\n def set_callback(self, cb, where):\n def cb_wrapper(raw_model, ctx):\n # Warning: This is super hacky. We need to provide a complete Model\n # object to the callback (a RawModel is not enough). Xpress invokes\n # callbacks with thread-local problem pointers, so we reuse the\n # original object by swapping the pointers temporarily. This is\n # okay because we've serialized access to the model anyway (GIL\n # limitation). But all of this happens at the C++ level, here we\n # only need to provide the user callback with the original complete\n # Model object. So it looks like we're giving the original model to\n # the callbacks, but in reality we pull a switcheroo behind the\n # curtains.\n cb(self, ctx)\n\n super().set_callback(cb_wrapper, where)\n\n add_variables = make_variable_tupledict\n add_m_variables = make_variable_ndarray\n add_m_linear_constraints = add_matrix_constraints\n" }, { "path": "src/pyoptinterface/copt.py", "content": "from pyoptinterface._src.copt import Model, autoload_library\nfrom pyoptinterface._src.copt_model_ext import (\n EnvConfig,\n Env,\n COPT,\n load_library,\n is_library_loaded,\n)\n\n__all__ = [\n \"Model\",\n \"EnvConfig\",\n \"Env\",\n \"COPT\",\n \"autoload_library\",\n \"load_library\",\n \"is_library_loaded\",\n]\n" }, { "path": "src/pyoptinterface/gurobi.py", "content": "from pyoptinterface._src.gurobi import Model, Env, autoload_library\nfrom pyoptinterface._src.gurobi_model_ext import (\n GRB,\n load_library,\n is_library_loaded,\n)\n\n__all__ = [\n \"Model\",\n \"Env\",\n \"GRB\",\n \"autoload_library\",\n \"load_library\",\n \"is_library_loaded\",\n]\n" }, { "path": "src/pyoptinterface/highs.py", "content": "from pyoptinterface._src.highs import Model, autoload_library\nfrom pyoptinterface._src.highs_model_ext import Enum, load_library, is_library_loaded\n\n__all__ = [\"Model\", \"Enum\", \"autoload_library\", \"load_library\", \"is_library_loaded\"]\n" }, { "path": "src/pyoptinterface/ipopt.py", "content": "from pyoptinterface._src.ipopt import Model\nfrom pyoptinterface._src.ipopt_model_ext import (\n ApplicationReturnStatus,\n load_library,\n is_library_loaded,\n)\n\n__all__ = [\"Model\", \"ApplicationReturnStatus\", \"load_library\", \"is_library_loaded\"]\n" }, { "path": "src/pyoptinterface/knitro.py", "content": "from pyoptinterface._src.knitro import Env, Model, autoload_library\nfrom pyoptinterface._src.knitro_model_ext import (\n KN,\n load_library,\n is_library_loaded,\n has_valid_license,\n)\n\n__all__ = [\n \"Env\",\n \"Model\",\n \"KN\",\n \"autoload_library\",\n \"load_library\",\n \"is_library_loaded\",\n \"has_valid_license\",\n]\n" }, { "path": "src/pyoptinterface/mosek.py", "content": "from pyoptinterface._src.mosek import Model, autoload_library\nfrom pyoptinterface._src.mosek_model_ext import (\n Env,\n Enum,\n load_library,\n is_library_loaded,\n)\n\n__all__ = [\n \"Model\",\n \"Env\",\n \"Enum\",\n \"autoload_library\",\n \"load_library\",\n \"is_library_loaded\",\n]\n" }, { "path": "src/pyoptinterface/nl.py", "content": "from pyoptinterface._src.nlfunc import (\n ExpressionGraphContext as graph,\n to_nlexpr,\n sin,\n cos,\n tan,\n asin,\n acos,\n atan,\n abs,\n sqrt,\n exp,\n log,\n log10,\n pow,\n ifelse,\n)\n" }, { "path": "src/pyoptinterface/xpress.py", "content": "from pyoptinterface._src.xpress import Model, autoload_library\nfrom pyoptinterface._src.xpress_model_ext import (\n Env,\n XPRS,\n load_library,\n is_library_loaded,\n license,\n beginlicensing,\n endlicensing,\n)\n\n__all__ = [\n \"Model\",\n \"Env\",\n \"XPRS\",\n \"autoload_library\",\n \"load_library\",\n \"is_library_loaded\",\n \"license\",\n \"beginlicensing\",\n \"endlicensing\",\n]\n" }, { "path": "tests/conftest.py", "content": "import pytest\nimport platform\n\nfrom pyoptinterface import gurobi, xpress, copt, mosek, highs, ipopt, knitro\n\nnlp_model_dict = {}\n\nif ipopt.is_library_loaded():\n\n def llvm():\n return ipopt.Model(jit=\"LLVM\")\n\n def c():\n return ipopt.Model(jit=\"C\")\n\n nlp_model_dict[\"ipopt_llvm\"] = llvm\n system = platform.system()\n if system != \"Darwin\":\n # On macOS, loading dynamic library of Gurobi/Xpress/COPT/Mosek before loading libtcc will cause memory error\n # The reason is still unclear\n nlp_model_dict[\"ipopt_c\"] = c\n\nif copt.is_library_loaded():\n nlp_model_dict[\"copt\"] = copt.Model\n\nif knitro.is_library_loaded() and knitro.has_valid_license():\n nlp_model_dict[\"knitro\"] = knitro.Model\n\n\n@pytest.fixture(params=nlp_model_dict.keys())\ndef nlp_model_ctor(request):\n name = request.param\n ctor = nlp_model_dict[name]\n return ctor\n\n\nmodel_interface_dict_full = {}\n\nif gurobi.is_library_loaded():\n model_interface_dict_full[\"gurobi\"] = gurobi.Model\nif xpress.is_library_loaded():\n model_interface_dict_full[\"xpress\"] = xpress.Model\nif copt.is_library_loaded():\n model_interface_dict_full[\"copt\"] = copt.Model\nif mosek.is_library_loaded():\n model_interface_dict_full[\"mosek\"] = mosek.Model\nif highs.is_library_loaded():\n model_interface_dict_full[\"highs\"] = highs.Model\nif knitro.is_library_loaded() and knitro.has_valid_license():\n model_interface_dict_full[\"knitro\"] = knitro.Model\n\n\n@pytest.fixture(params=model_interface_dict_full.keys())\ndef model_interface(request):\n name = request.param\n model_interface_class = model_interface_dict_full[name]\n return model_interface_class()\n\n\nmodel_interface_dict_oneshot = model_interface_dict_full.copy()\nif ipopt.is_library_loaded():\n model_interface_dict_oneshot[\"ipopt\"] = ipopt.Model\n\n\n@pytest.fixture(params=model_interface_dict_oneshot.keys())\ndef model_interface_oneshot(request):\n name = request.param\n model_interface_class = model_interface_dict_oneshot[name]\n return model_interface_class()\n" }, { "path": "tests/simple_cb.py", "content": "import pyoptinterface as poi\nfrom pyoptinterface import gurobi, xpress\n\nGRB = gurobi.GRB\nXPRS = xpress.XPRS\n\n\ndef simple_cb(f):\n model = f()\n\n x = model.add_variable(lb=0.0, ub=20.0)\n y = model.add_variable(lb=8.0, ub=20.0)\n\n model.set_variable_attribute(x, poi.VariableAttribute.Name, \"x\")\n model.set_variable_attribute(y, poi.VariableAttribute.Name, \"y\")\n\n obj = x * x + y * y\n model.set_objective(obj, poi.ObjectiveSense.Minimize)\n\n conexpr = x + y\n model.add_linear_constraint(\n conexpr, poi.ConstraintSense.GreaterEqual, 10.0, name=\"con1\"\n )\n\n def cb(model, where):\n runtime = 0.0\n coldel = 0\n rowdel = 0\n if isinstance(model, gurobi.Model) and where == GRB.Callback.PRESOLVE:\n runtime = model.cb_get_info(GRB.Callback.RUNTIME)\n coldel = model.cb_get_info(GRB.Callback.PRE_COLDEL)\n rowdel = model.cb_get_info(GRB.Callback.PRE_ROWDEL)\n print(f\"Runtime: {runtime}, Coldel: {coldel}, Rowdel: {rowdel}\")\n if isinstance(model, xpress.Model) and where == XPRS.CB_CONTEXT.PRESOLVE:\n runtime = model.get_raw_attribute_dbl_by_id(XPRS.TIME)\n coldel = model.get_raw_attribute_int_by_id(\n XPRS.ORIGINALCOLS\n ) - model.get_raw_attribute_int_by_id(XPRS.COLS)\n rowdel = model.get_raw_attribute_int_by_id(\n XPRS.ORIGINALROWS\n ) - model.get_raw_attribute_int_by_id(XPRS.ROWS)\n print(\n f\"CB[AFTER-PRESOLVE] >> Runtime: {runtime}, Coldel: {coldel}, Rowdel: {rowdel}\"\n )\n if isinstance(model, xpress.Model) and where == XPRS.CB_CONTEXT.MESSAGE:\n args = model.cb_get_arguments()\n print(f\"CB[MESSAGE-{args.msgtype}] >> {args.msg}\")\n\n if isinstance(model, gurobi.Model):\n model.set_callback(cb)\n elif isinstance(model, xpress.Model):\n model.set_callback(cb, XPRS.CB_CONTEXT.PRESOLVE | XPRS.CB_CONTEXT.MESSAGE)\n\n model.set_model_attribute(poi.ModelAttribute.Silent, False)\n model.optimize()\n\n\nif xpress.is_library_loaded():\n simple_cb(xpress.Model)\nif gurobi.is_library_loaded():\n simple_cb(gurobi.Model)\n" }, { "path": "tests/test_basic.py", "content": "import pyoptinterface as poi\nimport numpy as np\nfrom pytest import approx\n\nfrom pyoptinterface._src.core_ext import IntMonotoneIndexer\n\n\ndef test_basic():\n vars = [poi.VariableIndex(i) for i in range(10)]\n v = vars[0]\n assert v.index == 0\n\n t = poi.ExprBuilder()\n t += v\n t += v * v\n assert t.degree() == 2\n assert t.empty() == False\n\n t = poi.ExprBuilder(v)\n t.add_affine_term(vars[1], 2.0)\n t += 3.0 * vars[2]\n t -= 4.0 * vars[3]\n assert t.degree() == 1\n assert t.empty() == False\n\n saf = poi.ScalarAffineFunction(t)\n saf.canonicalize()\n assert list(saf.variables) == [0, 1, 2, 3]\n assert np.allclose(saf.coefficients, [1.0, 2.0, 3.0, -4.0])\n\n saf = 2.0 - 1.0 * saf * -4.0 / 2.0 + 1.0\n saf.canonicalize()\n assert list(saf.variables) == [0, 1, 2, 3]\n assert np.allclose(saf.coefficients, [2.0, 4.0, 6.0, -8.0])\n assert saf.constant == approx(3.0)\n\n sqf = v * v + 2.0 * v + 1.0\n sqf = 2.0 - 1.0 * sqf * -4.0 / 2.0 + 1.0\n sqf.canonicalize()\n assert list(sqf.variable_1s) == [0]\n assert list(sqf.variable_2s) == [0]\n assert np.allclose(sqf.coefficients, [2.0])\n assert list(sqf.affine_part.variables) == [0]\n assert np.allclose(sqf.affine_part.coefficients, [4.0])\n assert sqf.affine_part.constant == approx(5.0)\n\n t = poi.ExprBuilder(v)\n t *= 2.0\n assert t.degree() == 1\n\n t *= vars[0]\n assert t.degree() == 2\n\n t /= 0.5\n assert t.degree() == 2\n\n t = poi.ExprBuilder(v * v + 2.0 * v + 1.0)\n t += 2.0\n t -= v\n t *= 4.0\n t /= 2.0\n sqf = poi.ScalarQuadraticFunction(t)\n sqf.canonicalize()\n assert list(sqf.variable_1s) == [0]\n assert list(sqf.variable_2s) == [0]\n assert np.allclose(sqf.coefficients, [2.0])\n assert list(sqf.affine_part.variables) == [0]\n assert np.allclose(sqf.affine_part.coefficients, [2.0])\n assert sqf.affine_part.constant == approx(6.0)\n\n\ndef test_affineexpr_from_numpy():\n N = 25\n coefs = np.arange(N, dtype=np.float64)\n vars = np.arange(N, dtype=np.int_) * 2\n coefs.flags.writeable = False\n vars.flags.writeable = False\n\n expr = poi.ScalarAffineFunction.from_numpy(coefs, vars)\n\n assert list(expr.variables) == list(vars)\n assert np.allclose(expr.coefficients, coefs)\n\n constant = 3.0\n expr = poi.ScalarAffineFunction.from_numpy(coefs, vars, constant)\n\n assert list(expr.variables) == list(vars)\n assert np.allclose(expr.coefficients, coefs)\n assert expr.constant == approx(constant)\n\n\ndef test_monotoneindexer():\n indexer = IntMonotoneIndexer()\n\n N = 200\n for i in range(N):\n index = indexer.add_index()\n assert index == i\n\n for i in range(N - 1):\n indexer.delete_index(i)\n x = indexer.get_index(i + 1)\n assert x == 0\n x = indexer.get_index(N - 1)\n assert x == N - 1 - (i + 1)\n x = indexer.get_index(0)\n assert x == -1\n" }, { "path": "tests/test_close.py", "content": "from pyoptinterface import gurobi, xpress, copt, mosek\n\nenvs = []\nmodels = []\nif gurobi.is_library_loaded():\n envs.append(gurobi.Env)\n models.append(gurobi.Model)\nif xpress.is_library_loaded():\n envs.append(xpress.Env)\n models.append(xpress.Model)\nif copt.is_library_loaded():\n envs.append(copt.Env)\n models.append(copt.Model)\nif mosek.is_library_loaded():\n envs.append(mosek.Env)\n models.append(mosek.Model)\n\n\ndef test_close():\n for env, model in zip(envs, models):\n env_instance = env()\n model_instance = model(env_instance)\n\n model_instance.close()\n env_instance.close()\n" }, { "path": "tests/test_compare_constraint.py", "content": "import pyoptinterface as poi\n\nimport pytest\n\n\ndef test_compare_constraint(model_interface):\n model = model_interface\n\n x = model.add_variable(lb=0.0)\n y = model.add_variable(lb=0.0)\n\n def t_expr(expr):\n con = model.add_linear_constraint(expr >= 1.0)\n model.set_objective(expr)\n model.optimize()\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(1.0, abs=1e-6)\n model.delete_constraint(con)\n\n con = model.add_linear_constraint(expr <= 2.0)\n model.set_objective(expr, poi.ObjectiveSense.Maximize)\n model.optimize()\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(2.0, abs=1e-6)\n model.delete_constraint(con)\n\n con = model.add_linear_constraint(expr == 3.0)\n model.set_objective(expr, poi.ObjectiveSense.Maximize)\n model.optimize()\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(3.0, abs=1e-6)\n model.delete_constraint(con)\n\n con = model.add_linear_constraint(1.0 <= expr)\n model.set_objective(expr)\n model.optimize()\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(1.0, abs=1e-6)\n model.delete_constraint(con)\n\n con = model.add_linear_constraint(2.0 >= expr)\n model.set_objective(expr, poi.ObjectiveSense.Maximize)\n model.optimize()\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(2.0, abs=1e-6)\n model.delete_constraint(con)\n\n con = model.add_linear_constraint(3.0 == expr)\n model.set_objective(expr, poi.ObjectiveSense.Maximize)\n model.optimize()\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(3.0, abs=1e-6)\n model.delete_constraint(con)\n\n def t_binary_expr(lhs, rhs):\n expr = lhs - rhs\n\n con = model.add_linear_constraint(lhs >= rhs + 1.0)\n model.set_objective(expr)\n model.optimize()\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(1.0, abs=1e-6)\n model.delete_constraint(con)\n\n con = model.add_linear_constraint(lhs <= rhs + 2.0)\n model.set_objective(expr, poi.ObjectiveSense.Maximize)\n model.optimize()\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(2.0, abs=1e-6)\n model.delete_constraint(con)\n\n con = model.add_linear_constraint(lhs == rhs + 3.0)\n model.set_objective(expr, poi.ObjectiveSense.Maximize)\n model.optimize()\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(3.0, abs=1e-6)\n model.delete_constraint(con)\n\n con = model.add_linear_constraint(1.0 + rhs <= lhs)\n model.set_objective(expr)\n model.optimize()\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(1.0, abs=1e-6)\n model.delete_constraint(con)\n\n con = model.add_linear_constraint(2.0 + rhs >= lhs)\n model.set_objective(expr, poi.ObjectiveSense.Maximize)\n model.optimize()\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(2.0, abs=1e-6)\n model.delete_constraint(con)\n\n con = model.add_linear_constraint(3.0 + rhs == lhs)\n model.set_objective(expr, poi.ObjectiveSense.Maximize)\n model.optimize()\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(3.0, abs=1e-6)\n model.delete_constraint(con)\n\n expr = x + y\n t_expr(expr)\n\n expr = poi.ExprBuilder(x + y)\n t_expr(expr)\n\n for lhs in [x, poi.ScalarAffineFunction(x), poi.ExprBuilder(x)]:\n for rhs in [y, poi.ScalarAffineFunction(y), poi.ExprBuilder(y)]:\n t_binary_expr(lhs, rhs)\n\n if hasattr(model, \"add_quadratic_constraint\"):\n con_expr = x * x + y * y\n expr = x + y\n\n con = model.add_quadratic_constraint(con_expr <= 18.0)\n model.set_objective(expr, poi.ObjectiveSense.Maximize)\n model.optimize()\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(6.0, abs=1e-5)\n model.delete_constraint(con)\n\n con = model.add_quadratic_constraint(32.0 >= con_expr)\n model.set_objective(expr, poi.ObjectiveSense.Maximize)\n model.optimize()\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(8.0, abs=1e-5)\n model.delete_constraint(con)\n" }, { "path": "tests/test_exp_cone.py", "content": "import pyoptinterface as poi\nfrom pytest import approx\nimport pytest\nimport math\n\n\ndef test_exp_cone(model_interface):\n model = model_interface\n\n if not hasattr(model, \"add_exp_cone_constraint\"):\n pytest.skip(\"Model interface does not support exponential cone constraints\")\n\n N = 4\n x = model.add_variables(range(N), lb=1.0)\n t = model.add_variables(range(N), lb=0.0)\n one = model.add_variable(lb=1.0, ub=1.0, name=\"one\")\n\n obj = poi.quicksum(t)\n model.set_objective(obj, poi.ObjectiveSense.Minimize)\n\n con = poi.make_tupledict(\n range(N), rule=lambda i: model.add_exp_cone_constraint([t[i], one, x[i]])\n )\n\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n\n x_val = x.map(model.get_value)\n t_val = t.map(model.get_value)\n for i in range(N):\n assert x_val[i] == approx(1.0)\n assert t_val[i] == approx(math.e)\n\n obj_val = model.get_value(obj)\n assert obj_val == approx(N * math.e)\n\n model.delete_constraint(con[0])\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n\n x_val = x.map(model.get_value)\n t_val = t.map(model.get_value)\n for i in range(1, N):\n assert x_val[i] == approx(1.0)\n assert t_val[i] == approx(math.e)\n\n obj_val = model.get_value(obj)\n assert obj_val == approx((N - 1) * math.e)\n" }, { "path": "tests/test_iis.py", "content": "import pyoptinterface as poi\nimport pytest\n\n\ndef test_constraint_iis(model_interface):\n model = model_interface\n\n if not hasattr(model, \"computeIIS\"):\n pytest.skip(\"Model interface does not support IIS computation\")\n\n x = model.add_variable(lb=0.0, name=\"x\")\n y = model.add_variable(lb=0.0, name=\"y\")\n\n con1 = model.add_linear_constraint(x + y, poi.Geq, 5.0)\n con2 = model.add_linear_constraint(x + 2 * y, poi.Leq, 1.0)\n\n model.set_objective(x)\n\n model.computeIIS()\n\n con1_iis = model.get_constraint_attribute(con1, poi.ConstraintAttribute.IIS)\n con2_iis = model.get_constraint_attribute(con2, poi.ConstraintAttribute.IIS)\n\n assert con1_iis\n assert con2_iis\n\n\ndef test_variable_iis(model_interface):\n model = model_interface\n\n if not hasattr(model, \"computeIIS\"):\n pytest.skip(\"Model interface does not support IIS computation\")\n\n x = model.add_variable(lb=0.0, ub=2.0, name=\"x\")\n y = model.add_variable(lb=0.0, ub=3.0, name=\"y\")\n\n con1 = model.add_linear_constraint(x + y, poi.Geq, 6.0)\n\n model.set_objective(x)\n\n model.computeIIS()\n\n con1_iis = model.get_constraint_attribute(con1, poi.ConstraintAttribute.IIS)\n x_lb_iis = model.get_variable_attribute(x, poi.VariableAttribute.IISLowerBound)\n x_ub_iis = model.get_variable_attribute(x, poi.VariableAttribute.IISUpperBound)\n y_lb_iis = model.get_variable_attribute(y, poi.VariableAttribute.IISLowerBound)\n y_ub_iis = model.get_variable_attribute(y, poi.VariableAttribute.IISUpperBound)\n\n assert con1_iis\n assert not x_lb_iis\n assert x_ub_iis\n assert not y_lb_iis\n assert y_ub_iis\n" }, { "path": "tests/test_in_constraint.py", "content": "import pyoptinterface as poi\nfrom pyoptinterface import nl, gurobi\n\nimport pytest\n\n\ndef test_linear_in_constraint(model_interface_oneshot):\n model = model_interface_oneshot\n\n if isinstance(model, gurobi.Model):\n pytest.skip(\"Gurobi does not support range linear constraints\")\n\n x = model.add_variable(lb=0.0)\n y = model.add_variable(lb=0.0)\n\n expr = x + y\n model.add_linear_constraint(expr, (0, 1.0))\n model.set_objective(expr)\n model.optimize()\n\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(0.0, abs=1e-6)\n\n model.set_objective(-expr)\n model.optimize()\n\n expr_value = model.get_value(expr)\n assert expr_value == pytest.approx(1.0, rel=1e-6)\n\n\ndef test_nl_in_constraint(nlp_model_ctor):\n model = nlp_model_ctor()\n\n x = model.add_variable(lb=0.0)\n y = model.add_variable(lb=0.0)\n\n with nl.graph():\n expr = nl.exp(x) + nl.exp(y)\n model.add_nl_constraint(expr, (5.0, 10.0))\n model.add_nl_objective(expr)\n\n model.optimize()\n objective_value = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n assert objective_value == pytest.approx(5.0, abs=1e-6)\n" }, { "path": "tests/test_ipopt.py", "content": "import pytest\nimport pyoptinterface as poi\nfrom pyoptinterface import ipopt, nl\n\npytestmark = pytest.mark.skipif(\n not ipopt.is_library_loaded(), reason=\"IPOPT library not available\"\n)\n\nOPTIMIZE_RE = r\"optimize\\(\\)\"\n\n\ndef _build_simple_model():\n \"\"\"Build a simple model: min x^2 s.t. x >= 0.5\"\"\"\n model = ipopt.Model()\n x = model.add_variable(lb=0.0, ub=10.0)\n model.set_objective(x**2)\n con = model.add_linear_constraint(x, poi.Geq, 0.5)\n return model, x, con\n\n\nclass TestUnoptimizedModelRaises:\n \"\"\"Accessing variable/constraint/objective values before calling optimize() should raise.\"\"\"\n\n def test_get_variable_value_before_optimize(self):\n model, x, _con = _build_simple_model()\n with pytest.raises(RuntimeError, match=OPTIMIZE_RE):\n model.get_value(x)\n\n def test_get_objective_value_before_optimize(self):\n model, _x, _con = _build_simple_model()\n with pytest.raises(RuntimeError, match=OPTIMIZE_RE):\n model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n\n def test_get_constraint_primal_before_optimize(self):\n model, _x, con = _build_simple_model()\n with pytest.raises(RuntimeError, match=OPTIMIZE_RE):\n model.get_constraint_attribute(con, poi.ConstraintAttribute.Primal)\n\n def test_get_constraint_dual_before_optimize(self):\n model, _x, con = _build_simple_model()\n with pytest.raises(RuntimeError, match=OPTIMIZE_RE):\n model.get_constraint_attribute(con, poi.ConstraintAttribute.Dual)\n\n\nclass TestDirtyAfterModificationRaises:\n \"\"\"After a successful optimize(), modifying the model (adding variables/constraints)\n should make it dirty and re-querying values should raise.\"\"\"\n\n def test_dirty_after_add_variable(self):\n model, x, con = _build_simple_model()\n model.optimize()\n # Values should be accessible now\n model.get_value(x)\n model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n\n # Add a new variable to make the model dirty\n model.add_variable(lb=0.0, ub=10.0)\n\n with pytest.raises(RuntimeError, match=OPTIMIZE_RE):\n model.get_value(x)\n with pytest.raises(RuntimeError, match=OPTIMIZE_RE):\n model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n with pytest.raises(RuntimeError, match=OPTIMIZE_RE):\n model.get_constraint_attribute(con, poi.ConstraintAttribute.Primal)\n with pytest.raises(RuntimeError, match=OPTIMIZE_RE):\n model.get_constraint_attribute(con, poi.ConstraintAttribute.Dual)\n\n def test_dirty_after_add_linear_constraint(self):\n model, x, _con = _build_simple_model()\n model.optimize()\n model.get_value(x)\n\n # Add a linear constraint to make the model dirty\n model.add_linear_constraint(x, poi.Leq, 5.0)\n\n with pytest.raises(RuntimeError, match=OPTIMIZE_RE):\n model.get_value(x)\n with pytest.raises(RuntimeError, match=OPTIMIZE_RE):\n model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n\n def test_dirty_after_add_quadratic_constraint(self):\n model, x, _con = _build_simple_model()\n model.optimize()\n model.get_value(x)\n\n # Add a quadratic constraint to make the model dirty\n model.add_quadratic_constraint(x**2, poi.Leq, 25.0)\n\n with pytest.raises(RuntimeError, match=OPTIMIZE_RE):\n model.get_value(x)\n with pytest.raises(RuntimeError, match=OPTIMIZE_RE):\n model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n\n def test_dirty_after_add_nl_constraint(self):\n model, x, _con = _build_simple_model()\n model.optimize()\n model.get_value(x)\n\n # Add a nonlinear constraint to make the model dirty\n with nl.graph():\n model.add_nl_constraint(nl.exp(x), poi.Leq, 100.0)\n\n with pytest.raises(RuntimeError, match=OPTIMIZE_RE):\n model.get_value(x)\n with pytest.raises(RuntimeError, match=OPTIMIZE_RE):\n model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n\n def test_reoptimize_clears_dirty(self):\n \"\"\"After re-optimizing, values should be accessible again.\"\"\"\n model, x, con = _build_simple_model()\n model.optimize()\n\n # Modify model\n model.add_linear_constraint(x, poi.Leq, 5.0)\n\n # Dirty – raises\n with pytest.raises(RuntimeError, match=OPTIMIZE_RE):\n model.get_value(x)\n\n # Re-optimize – should clear the dirty flag\n model.optimize()\n\n val = model.get_value(x)\n assert val == pytest.approx(0.5, abs=1e-6)\n obj = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n assert obj == pytest.approx(0.25, abs=1e-6)\n primal = model.get_constraint_attribute(con, poi.ConstraintAttribute.Primal)\n assert primal == pytest.approx(0.5, abs=1e-6)\n" }, { "path": "tests/test_knitro.py", "content": "import pytest\nfrom pytest import approx\n\nfrom pyoptinterface import knitro\nimport pyoptinterface as poi\n\npytestmark = pytest.mark.skipif(\n not knitro.is_library_loaded() or not knitro.has_valid_license(),\n reason=\"KNITRO library is not loaded or license is not valid\",\n)\n\n\ndef test_new_model_without_env():\n \"\"\"Test creating a model without an environment (default behavior).\"\"\"\n model = knitro.Model()\n\n x = model.add_variable(lb=0.0, ub=10.0)\n y = model.add_variable(lb=0.0, ub=10.0)\n\n model.set_objective(x + y, poi.ObjectiveSense.Minimize)\n model.add_linear_constraint(x + y, poi.ConstraintSense.GreaterEqual, 5.0)\n\n model.optimize()\n\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n\n x_val = model.get_value(x)\n y_val = model.get_value(y)\n assert x_val + y_val == approx(5.0)\n\n\ndef test_new_model_with_env():\n \"\"\"Test creating a model with an environment.\"\"\"\n env = knitro.Env()\n model = knitro.Model(env=env)\n\n x = model.add_variable(lb=0.0, ub=10.0)\n y = model.add_variable(lb=0.0, ub=10.0)\n\n model.set_objective(x + y, poi.ObjectiveSense.Minimize)\n model.add_linear_constraint(x + y, poi.ConstraintSense.GreaterEqual, 5.0)\n\n model.optimize()\n\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n\n x_val = model.get_value(x)\n y_val = model.get_value(y)\n assert x_val + y_val == approx(5.0)\n\n\ndef test_multiple_models_single_env():\n \"\"\"Test creating multiple models sharing the same environment.\"\"\"\n env = knitro.Env()\n\n model1 = knitro.Model(env=env)\n model2 = knitro.Model(env=env)\n\n x1 = model1.add_variable(lb=0.0, ub=10.0)\n model1.set_objective(x1, poi.ObjectiveSense.Minimize)\n model1.add_linear_constraint(x1, poi.ConstraintSense.GreaterEqual, 3.0)\n model1.optimize()\n\n x2 = model2.add_variable(lb=0.0, ub=10.0)\n model2.set_objective(x2, poi.ObjectiveSense.Minimize)\n model2.add_linear_constraint(x2, poi.ConstraintSense.GreaterEqual, 5.0)\n model2.optimize()\n\n assert model1.get_value(x1) == approx(3.0)\n assert model2.get_value(x2) == approx(5.0)\n\n\ndef test_multiple_models_multiple_envs():\n \"\"\"Test creating multiple models each with its own environment.\"\"\"\n env1 = knitro.Env()\n env2 = knitro.Env()\n\n model1 = knitro.Model(env=env1)\n model2 = knitro.Model(env=env2)\n\n x1 = model1.add_variable(lb=0.0, ub=10.0)\n model1.set_objective(x1, poi.ObjectiveSense.Minimize)\n model1.add_linear_constraint(x1, poi.ConstraintSense.GreaterEqual, 4.0)\n model1.optimize()\n\n x2 = model2.add_variable(lb=0.0, ub=10.0)\n model2.set_objective(x2, poi.ObjectiveSense.Minimize)\n model2.add_linear_constraint(x2, poi.ConstraintSense.GreaterEqual, 6.0)\n model2.optimize()\n\n assert model1.get_value(x1) == approx(4.0)\n assert model2.get_value(x2) == approx(6.0)\n\n\ndef test_env_lifetime():\n \"\"\"Test that environment properly manages its lifetime.\"\"\"\n env = knitro.Env()\n model = knitro.Model(env=env)\n\n x = model.add_variable(lb=0.0, ub=10.0)\n model.set_objective(x, poi.ObjectiveSense.Minimize)\n model.add_linear_constraint(x, poi.ConstraintSense.GreaterEqual, 2.0)\n model.optimize()\n\n assert model.get_value(x) == approx(2.0)\n\n model.close()\n\n try:\n del env\n except Exception as e:\n pytest.fail(f\"Deleting environment raised an error: {e}\")\n\n\ndef test_env_close():\n \"\"\"Test that env.close() properly releases the license.\"\"\"\n env = knitro.Env()\n\n model = knitro.Model(env=env)\n x = model.add_variable(lb=0.0, ub=10.0)\n model.set_objective(x, poi.ObjectiveSense.Minimize)\n model.add_linear_constraint(x, poi.ConstraintSense.GreaterEqual, 1.0)\n model.optimize()\n assert model.get_value(x) == approx(1.0)\n model.close()\n\n try:\n env.close()\n except Exception as e:\n pytest.fail(f\"env.close() raised an error: {e}\")\n\n\ndef test_init_with_env():\n \"\"\"Test using init method with an environment.\"\"\"\n env = knitro.Env()\n model = knitro.Model()\n model.init(env)\n x = model.add_variable(lb=0.0, ub=10.0)\n model.set_objective(x, poi.ObjectiveSense.Minimize)\n model.add_linear_constraint(x, poi.ConstraintSense.GreaterEqual, 1.0)\n model.optimize()\n\n assert model.get_value(x) == approx(1.0)\n\n model.close()\n del model\n del env\n\n\ndef test_model_with_empty_env():\n \"\"\"Test that creating a model with an empty environment raises an error.\"\"\"\n env = knitro.Env(empty=True)\n assert env.is_empty\n\n with pytest.raises(RuntimeError, match=\"Empty environment\"):\n knitro.Model(env=env)\n\n\ndef test_model_init_with_empty_env_after_start():\n \"\"\"Test that initializing a model with an empty environment after starting raises an error.\"\"\"\n env = knitro.Env(empty=True)\n assert env.is_empty\n\n env.start()\n assert knitro.Model(env=env) is not None\n\n\ndef test_model_dirty():\n \"\"\"Test the dirty method.\"\"\"\n model = knitro.Model()\n\n assert model.dirty() is True\n\n x = model.add_variable(lb=0.0, ub=10.0)\n assert model.dirty() is True\n\n model.set_objective(x, poi.ObjectiveSense.Minimize)\n model.add_linear_constraint(x, poi.ConstraintSense.GreaterEqual, 1.0)\n model.optimize()\n\n assert model.dirty() is False\n\n model.add_variable(lb=0.0, ub=5.0)\n assert model.dirty() is True\n\n\ndef test_model_is_dirty():\n \"\"\"Test the is_dirty property.\"\"\"\n model = knitro.Model()\n\n assert model.is_dirty is True\n\n x = model.add_variable(lb=0.0, ub=10.0)\n assert model.is_dirty is True\n\n model.set_objective(x, poi.ObjectiveSense.Minimize)\n model.add_linear_constraint(x, poi.ConstraintSense.GreaterEqual, 1.0)\n model.optimize()\n\n assert model.is_dirty is False\n\n model.add_variable(lb=0.0, ub=5.0)\n assert model.is_dirty is True\n\n\ndef test_model_empty():\n \"\"\"Test the empty() method.\"\"\"\n model = knitro.Model()\n assert model.empty() is False\n model.close()\n assert model.empty() is True\n\n\ndef test_model_is_empty_property():\n \"\"\"Test the is_empty property.\"\"\"\n model = knitro.Model()\n assert model.is_empty is False\n model.close()\n assert model.is_empty is True\n\n\ndef test_number_of_variables():\n \"\"\"Test number_of_variables() method.\"\"\"\n model = knitro.Model()\n\n assert model.number_of_variables() == 0\n\n model.add_variable()\n assert model.number_of_variables() == 1\n\n model.add_variable()\n model.add_variable()\n assert model.number_of_variables() == 3\n\n\ndef test_number_of_constraints():\n \"\"\"Test number_of_constraints() method.\"\"\"\n model = knitro.Model()\n x = model.add_variable(lb=-10.0, ub=10.0)\n y = model.add_variable(lb=-10.0, ub=10.0)\n\n assert model.number_of_constraints() == 0\n assert model.number_of_constraints(poi.ConstraintType.Linear) == 0\n assert model.number_of_constraints(poi.ConstraintType.Quadratic) == 0\n\n model.add_linear_constraint(x + y, poi.ConstraintSense.LessEqual, 5.0)\n assert model.number_of_constraints() == 1\n assert model.number_of_constraints(poi.ConstraintType.Linear) == 1\n\n model.add_quadratic_constraint(x * x + y, poi.ConstraintSense.LessEqual, 10.0)\n assert model.number_of_constraints() == 2\n assert model.number_of_constraints(poi.ConstraintType.Quadratic) == 1\n\n\ndef test_supports_attribute_methods():\n \"\"\"Test supports_*_attribute() static methods.\"\"\"\n assert knitro.Model.supports_variable_attribute(poi.VariableAttribute.Value) is True\n assert (\n knitro.Model.supports_variable_attribute(poi.VariableAttribute.LowerBound)\n is True\n )\n assert (\n knitro.Model.supports_variable_attribute(\n poi.VariableAttribute.LowerBound, setable=True\n )\n is True\n )\n assert (\n knitro.Model.supports_variable_attribute(\n poi.VariableAttribute.Value, setable=True\n )\n is False\n )\n\n assert (\n knitro.Model.supports_constraint_attribute(poi.ConstraintAttribute.Primal)\n is True\n )\n assert (\n knitro.Model.supports_constraint_attribute(poi.ConstraintAttribute.Name) is True\n )\n assert (\n knitro.Model.supports_constraint_attribute(\n poi.ConstraintAttribute.Name, setable=True\n )\n is True\n )\n\n assert (\n knitro.Model.supports_model_attribute(poi.ModelAttribute.ObjectiveValue) is True\n )\n assert knitro.Model.supports_model_attribute(poi.ModelAttribute.SolverName) is True\n assert (\n knitro.Model.supports_model_attribute(poi.ModelAttribute.Silent, setable=True)\n is True\n )\n assert (\n knitro.Model.supports_model_attribute(\n poi.ModelAttribute.ObjectiveValue, setable=True\n )\n is False\n )\n assert (\n knitro.Model.supports_model_attribute(\n poi.ModelAttribute.NumberOfThreads, setable=True\n )\n is True\n )\n assert (\n knitro.Model.supports_model_attribute(\n poi.ModelAttribute.TimeLimitSec, setable=True\n )\n is True\n )\n\n\ndef test_model_attribute_solver_info():\n \"\"\"Test getting solver info model attributes.\"\"\"\n model = knitro.Model()\n\n solver_name = model.get_model_attribute(poi.ModelAttribute.SolverName)\n assert solver_name == \"KNITRO\"\n\n solver_version = model.get_model_attribute(poi.ModelAttribute.SolverVersion)\n assert isinstance(solver_version, str)\n assert len(solver_version) > 0\n\n\ndef test_model_attribute_after_solve():\n \"\"\"Test model attributes after solving.\"\"\"\n model = knitro.Model()\n x = model.add_variable(lb=0.0, ub=10.0)\n y = model.add_variable(lb=0.0, ub=10.0)\n\n model.set_objective(x + 2 * y, poi.ObjectiveSense.Minimize)\n model.add_linear_constraint(x + y, poi.ConstraintSense.GreaterEqual, 5.0)\n model.optimize()\n\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n\n primal_status = model.get_model_attribute(poi.ModelAttribute.PrimalStatus)\n assert primal_status == poi.ResultStatusCode.FEASIBLE_POINT\n\n raw_status = model.get_model_attribute(poi.ModelAttribute.RawStatusString)\n assert isinstance(raw_status, str)\n assert \"KNITRO\" in raw_status\n\n obj_value = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n assert obj_value == approx(5.0)\n\n obj_sense = model.get_model_attribute(poi.ModelAttribute.ObjectiveSense)\n assert obj_sense == poi.ObjectiveSense.Minimize\n\n solve_time = model.get_model_attribute(poi.ModelAttribute.SolveTimeSec)\n assert isinstance(solve_time, float)\n assert solve_time >= 0.0\n\n iterations = model.get_model_attribute(poi.ModelAttribute.BarrierIterations)\n assert isinstance(iterations, int)\n assert iterations >= 0\n\n\ndef test_set_model_attribute_objective_sense():\n \"\"\"Test setting objective sense.\"\"\"\n model = knitro.Model()\n model.add_variable(lb=0.0, ub=10.0)\n\n model.set_model_attribute(\n poi.ModelAttribute.ObjectiveSense, poi.ObjectiveSense.Maximize\n )\n assert (\n model.get_model_attribute(poi.ModelAttribute.ObjectiveSense)\n == poi.ObjectiveSense.Maximize\n )\n\n model.set_model_attribute(\n poi.ModelAttribute.ObjectiveSense, poi.ObjectiveSense.Minimize\n )\n assert (\n model.get_model_attribute(poi.ModelAttribute.ObjectiveSense)\n == poi.ObjectiveSense.Minimize\n )\n\n\ndef test_set_model_attribute_silent():\n \"\"\"Test setting silent mode (should not raise error).\"\"\"\n model = knitro.Model()\n x = model.add_variable(lb=0.0, ub=10.0)\n model.set_objective(x, poi.ObjectiveSense.Minimize)\n model.add_linear_constraint(x, poi.ConstraintSense.GreaterEqual, 1.0)\n\n model.set_model_attribute(poi.ModelAttribute.Silent, True)\n model.optimize()\n\n assert model.get_value(x) == approx(1.0)\n\n\ndef test_set_model_attribute_threads():\n \"\"\"Test setting number of threads.\"\"\"\n model = knitro.Model()\n\n model.set_model_attribute(poi.ModelAttribute.NumberOfThreads, 2)\n threads = model.get_model_attribute(poi.ModelAttribute.NumberOfThreads)\n assert threads == 2\n\n\ndef test_set_model_attribute_time_limit():\n \"\"\"Test setting time limit (set only, get may not work due to param type mismatch).\"\"\"\n model = knitro.Model()\n\n model.set_model_attribute(poi.ModelAttribute.TimeLimitSec, 100.0)\n\n\ndef test_variable_attribute_bounds():\n \"\"\"Test getting and setting variable bounds.\"\"\"\n model = knitro.Model()\n x = model.add_variable(lb=0.0, ub=10.0)\n\n lb = model.get_variable_attribute(x, poi.VariableAttribute.LowerBound)\n ub = model.get_variable_attribute(x, poi.VariableAttribute.UpperBound)\n assert lb == approx(0.0)\n assert ub == approx(10.0)\n\n model.set_variable_attribute(x, poi.VariableAttribute.LowerBound, 1.0)\n model.set_variable_attribute(x, poi.VariableAttribute.UpperBound, 5.0)\n\n lb = model.get_variable_attribute(x, poi.VariableAttribute.LowerBound)\n ub = model.get_variable_attribute(x, poi.VariableAttribute.UpperBound)\n assert lb == approx(1.0)\n assert ub == approx(5.0)\n\n\ndef test_variable_attribute_name():\n \"\"\"Test getting and setting variable name.\"\"\"\n model = knitro.Model()\n x = model.add_variable(name=\"my_var\")\n\n name = model.get_variable_attribute(x, poi.VariableAttribute.Name)\n assert name == \"my_var\"\n\n model.set_variable_attribute(x, poi.VariableAttribute.Name, \"new_name\")\n name = model.get_variable_attribute(x, poi.VariableAttribute.Name)\n assert name == \"new_name\"\n\n\ndef test_variable_attribute_value():\n \"\"\"Test getting variable value after solve.\"\"\"\n model = knitro.Model()\n x = model.add_variable(lb=0.0, ub=10.0)\n\n model.set_objective(x, poi.ObjectiveSense.Minimize)\n model.add_linear_constraint(x, poi.ConstraintSense.GreaterEqual, 3.0)\n model.optimize()\n\n value = model.get_variable_attribute(x, poi.VariableAttribute.Value)\n assert value == approx(3.0)\n\n\ndef test_variable_attribute_primal_start():\n \"\"\"Test setting primal start value.\"\"\"\n model = knitro.Model()\n x = model.add_variable(lb=0.0, ub=10.0)\n\n model.set_variable_attribute(x, poi.VariableAttribute.PrimalStart, 5.0)\n\n model.set_objective(x, poi.ObjectiveSense.Minimize)\n model.add_linear_constraint(x, poi.ConstraintSense.GreaterEqual, 2.0)\n model.optimize()\n\n assert model.get_value(x) == approx(2.0)\n\n\ndef test_variable_attribute_domain():\n \"\"\"Test getting and setting variable domain.\"\"\"\n model = knitro.Model()\n x = model.add_variable(lb=0.0, ub=10.0)\n\n # Default domain should be Continuous\n domain = model.get_variable_attribute(x, poi.VariableAttribute.Domain)\n assert domain == poi.VariableDomain.Continuous\n\n # Set to Integer and verify\n model.set_variable_attribute(\n x, poi.VariableAttribute.Domain, poi.VariableDomain.Integer\n )\n domain = model.get_variable_attribute(x, poi.VariableAttribute.Domain)\n assert domain == poi.VariableDomain.Integer\n\n model.set_objective(x, poi.ObjectiveSense.Minimize)\n model.add_linear_constraint(x, poi.ConstraintSense.GreaterEqual, 2.5)\n model.optimize()\n\n assert model.get_value(x) == approx(3.0)\n\n # Test Binary domain\n y = model.add_variable(domain=poi.VariableDomain.Binary)\n domain = model.get_variable_attribute(y, poi.VariableAttribute.Domain)\n assert domain == poi.VariableDomain.Binary\n\n\ndef test_constraint_attribute_name():\n \"\"\"Test getting and setting constraint name.\"\"\"\n model = knitro.Model()\n x = model.add_variable(lb=0.0, ub=10.0)\n\n con = model.add_linear_constraint(\n x, poi.ConstraintSense.LessEqual, 5.0, name=\"my_con\"\n )\n\n name = model.get_constraint_attribute(con, poi.ConstraintAttribute.Name)\n assert name == \"my_con\"\n\n model.set_constraint_attribute(con, poi.ConstraintAttribute.Name, \"new_con\")\n name = model.get_constraint_attribute(con, poi.ConstraintAttribute.Name)\n assert name == \"new_con\"\n\n\ndef test_constraint_attribute_primal_dual():\n \"\"\"Test getting constraint primal and dual values after solve.\"\"\"\n model = knitro.Model()\n x = model.add_variable(lb=0.0, ub=10.0)\n y = model.add_variable(lb=0.0, ub=10.0)\n\n model.set_objective(x + y, poi.ObjectiveSense.Minimize)\n con = model.add_linear_constraint(x + y, poi.ConstraintSense.GreaterEqual, 5.0)\n model.optimize()\n\n primal = model.get_constraint_attribute(con, poi.ConstraintAttribute.Primal)\n assert primal == approx(5.0)\n\n dual = model.get_constraint_attribute(con, poi.ConstraintAttribute.Dual)\n assert isinstance(dual, float)\n" }, { "path": "tests/test_lukvle10.py", "content": "import pytest\n\nimport pyoptinterface as poi\nfrom pyoptinterface import ipopt, nl, copt\n\n\ndef test_nlp_lukvle10(nlp_model_ctor):\n # LUKSAN-VLCEK Problem 10\n #\n # min sum[i=1..n] (x[2i]^2)^(x[2i+1]^2 + 1) + (x[2i+1]^2)^(x[2i]^2 + 1)\n # s.t. (3 - 2*x[i+1])*x[i+1] + 1 - x[i] - 2*x[i+2] = 0, i = 1,...,2n-2\n #\n # Starting point: x[2i] = -1, x[2i+1] = 1\n model = nlp_model_ctor()\n if isinstance(model, ipopt.Model):\n # LUKVLE10 is too large and IPOPT raises a bad_alloc error.\n pytest.skip(\"lukvle10 is too large to be supported with IPOPT\")\n if isinstance(model, copt.Model):\n # LUKVLE10 is too large the current license of COpt supports up\n # to 2000 variables.\n pytest.skip(\"lukvle10 is too large to be supported with COpt\")\n\n n = 1250\n x = model.add_m_variables(2 * n, name=\"x\")\n\n for i in range(2 * n - 2):\n model.add_quadratic_constraint(\n (3 - 2 * x[i + 1]) * x[i + 1] + 1 - x[i] - 2 * x[i + 2],\n poi.ConstraintSense.Equal,\n 0.0,\n name=f\"c{i}\",\n )\n\n with nl.graph():\n for i in range(n):\n model.add_nl_objective(\n nl.pow(x[2 * i] ** 2, (x[2 * i + 1] ** 2) + 1)\n + nl.pow(x[2 * i + 1] ** 2, (x[2 * i] ** 2) + 1)\n )\n\n for i in range(n):\n model.set_variable_attribute(x[2 * i], poi.VariableAttribute.PrimalStart, -1.0)\n model.set_variable_attribute(\n x[2 * i + 1], poi.VariableAttribute.PrimalStart, 1.0\n )\n\n model.optimize()\n model.set_model_attribute(poi.ModelAttribute.Silent, False)\n\n termination_status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert termination_status == poi.TerminationStatusCode.OPTIMAL\n" }, { "path": "tests/test_matrix_api.py", "content": "import pyoptinterface as poi\nimport numpy as np\nfrom scipy.sparse import coo_array\nfrom pytest import approx\n\n\ndef test_matrix_api(model_interface_oneshot):\n model = model_interface_oneshot\n\n N = 10\n x = model.add_m_variables(N, lb=0.0)\n A = np.eye(N)\n ub = 3.0\n lb = 1.0\n A_sparse = coo_array(np.eye(N))\n model.add_m_linear_constraints(A, x, poi.Leq, ub)\n model.add_m_linear_constraints(A_sparse, x, poi.Geq, lb)\n\n obj = poi.quicksum(x)\n\n model.set_objective(obj)\n model.optimize()\n obj_value = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n assert obj_value == approx(N * lb)\n\n model.set_objective(-obj)\n model.optimize()\n obj_value = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n assert obj_value == approx(-N * ub)\n\n\ndef test_quicksum_ndarray(model_interface_oneshot):\n model = model_interface_oneshot\n\n N = 10\n x = model.add_m_variables((N, 2 * N), lb=1.0, ub=3.0)\n obj = poi.quicksum(x)\n model.set_objective(obj)\n model.optimize()\n obj_value = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n assert obj_value == approx(2 * N**2)\n" }, { "path": "tests/test_nlp.py", "content": "import math\nimport pytest\n\nimport pyoptinterface as poi\nfrom pyoptinterface import ipopt, nl\n\n\ndef test_easy_nlp(nlp_model_ctor):\n model = nlp_model_ctor()\n\n x = model.add_variable(lb=0.1, ub=10.0)\n y = model.add_variable(lb=0.1, ub=10.0)\n\n model.add_linear_constraint(x + y, poi.Eq, 1.0)\n\n with nl.graph():\n model.add_nl_objective(nl.exp(x) + nl.exp(y))\n\n with nl.graph():\n z = x * x\n s = y * y\n model.add_nl_constraint(z, (0.36, 4.0))\n model.add_nl_constraint(s, (0.04, 4.0))\n\n nl_funcs = [\n nl.abs,\n nl.acos,\n nl.asin,\n nl.atan,\n nl.cos,\n nl.exp,\n nl.log,\n nl.log10,\n nl.pow,\n nl.sin,\n nl.sqrt,\n nl.tan,\n ]\n\n B = 1e10\n all_nlfuncs_con = []\n with nl.graph():\n for f in nl_funcs:\n if f == nl.pow:\n v = f(x, 2)\n else:\n v = f(x)\n con = model.add_nl_constraint(v, (-B, B))\n all_nlfuncs_con.append(con)\n\n model.optimize()\n\n termination_status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert (\n termination_status == poi.TerminationStatusCode.LOCALLY_SOLVED\n or termination_status == poi.TerminationStatusCode.OPTIMAL\n )\n\n x_value = model.get_value(x)\n y_value = model.get_value(y)\n assert x_value == pytest.approx(0.6)\n assert y_value == pytest.approx(0.4)\n\n obj_value = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n assert obj_value == pytest.approx(math.exp(x_value) + math.exp(y_value))\n\n con_values = [\n model.get_constraint_attribute(con, poi.ConstraintAttribute.Primal)\n for con in all_nlfuncs_con\n ]\n\n correct_con_values = []\n for f in nl_funcs:\n if f == nl.pow:\n correct_con_values.append(f(x_value, 2))\n else:\n correct_con_values.append(f(x_value))\n\n assert con_values == pytest.approx(correct_con_values)\n\n\ndef test_nlfunc_ifelse(nlp_model_ctor):\n model = nlp_model_ctor()\n if not isinstance(model, ipopt.Model):\n pytest.skip(\"ifelse is only supported in IPOPT\")\n\n for x_, fx in zip([0.2, 0.5, 1.0, 2.0, 3.0], [0.2, 0.5, 1.0, 4.0, 9.0]):\n model = nlp_model_ctor()\n\n x = model.add_variable(lb=0.0, ub=10.0)\n\n with nl.graph():\n y = nl.ifelse(x > 1.0, x**2, x)\n model.add_nl_constraint(y, poi.Geq, fx)\n\n model.set_objective(x)\n\n model.optimize()\n\n x_value = model.get_value(x)\n assert x_value == pytest.approx(x_)\n\n\n@pytest.mark.skipif(not ipopt.is_library_loaded(), reason=\"IPOPT library not available\")\ndef test_ipopt_optimizer_not_called():\n model = ipopt.Model()\n\n x = model.add_variable(lb=0.0, ub=10.0)\n termination_status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert termination_status == poi.TerminationStatusCode.OPTIMIZE_NOT_CALLED\n\n model.set_objective(x**2)\n model.optimize()\n termination_status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert termination_status == poi.TerminationStatusCode.LOCALLY_SOLVED\n\n model.add_linear_constraint(x >= 0.5)\n termination_status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert termination_status == poi.TerminationStatusCode.OPTIMIZE_NOT_CALLED\n\n model.optimize()\n termination_status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert termination_status == poi.TerminationStatusCode.LOCALLY_SOLVED\n\n model.add_quadratic_constraint(x**2 >= 0.36)\n termination_status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert termination_status == poi.TerminationStatusCode.OPTIMIZE_NOT_CALLED\n\n model.optimize()\n termination_status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert termination_status == poi.TerminationStatusCode.LOCALLY_SOLVED\n\n with nl.graph():\n model.add_nl_constraint(nl.exp(x) <= 100.0)\n termination_status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert termination_status == poi.TerminationStatusCode.OPTIMIZE_NOT_CALLED\n\n model.optimize()\n termination_status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert termination_status == poi.TerminationStatusCode.LOCALLY_SOLVED\n\n with nl.graph():\n model.add_nl_objective(nl.log(x))\n termination_status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert termination_status == poi.TerminationStatusCode.OPTIMIZE_NOT_CALLED\n\n model.optimize()\n termination_status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert termination_status == poi.TerminationStatusCode.LOCALLY_SOLVED\n\n\nif __name__ == \"__main__\":\n\n def c():\n return ipopt.Model(jit=\"C\")\n\n test_easy_nlp(c)\n test_nlfunc_ifelse(c)\n\n def llvm():\n return ipopt.Model(jit=\"LLVM\")\n\n test_easy_nlp(llvm)\n test_nlfunc_ifelse(llvm)\n" }, { "path": "tests/test_nlp_bilinear.py", "content": "import pyoptinterface as poi\n\nimport pytest\n\n\ndef test_bilinear(nlp_model_ctor):\n model = nlp_model_ctor()\n\n x = model.add_m_variables(3, lb=0.0)\n\n obj = -(x[0] + x[1]) * (x[0] + x[2])\n\n expr = (x[0] + x[1]) * (x[0] + x[1]) + (x[0] + x[2]) * (x[0] + x[2])\n model.add_quadratic_constraint(expr == 4.0)\n\n model.set_objective(obj)\n model.optimize()\n\n objective_value = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n assert objective_value == pytest.approx(-2.0, abs=1e-8)\n" }, { "path": "tests/test_nlp_clnlbeam.py", "content": "import pyoptinterface as poi\nfrom pyoptinterface import nl\n\nimport pytest\n\nimport numpy as np\n\n\ndef test_clnlbeam(nlp_model_ctor):\n model = nlp_model_ctor()\n\n N = 100\n h = 1 / N\n alpha = 350\n\n t = model.add_m_variables(N + 1, lb=-1.0, ub=1.0)\n x = model.add_m_variables(N + 1, lb=-0.05, ub=0.05)\n u = model.add_m_variables(N + 1)\n\n for i in range(N):\n with nl.graph():\n model.add_nl_objective(\n 0.5 * h * (u[i] * u[i] + u[i + 1] * u[i + 1])\n + 0.5 * alpha * h * (nl.cos(t[i]) + nl.cos(t[i + 1]))\n )\n model.add_nl_constraint(\n x[i + 1] - x[i] - 0.5 * h * (nl.sin(t[i]) + nl.sin(t[i + 1])) == 0.0\n )\n model.add_linear_constraint(\n t[i + 1] - t[i] - 0.5 * h * u[i + 1] - 0.5 * h * u[i] == 0.0\n )\n\n model.optimize()\n\n tv = np.zeros(N + 1)\n xv = np.zeros(N + 1)\n uv = np.zeros(N + 1)\n for i in range(N + 1):\n tv[i] = model.get_value(t[i])\n xv[i] = model.get_value(x[i])\n uv[i] = model.get_value(u[i])\n\n con_expr_val = np.zeros(N)\n for i in range(N):\n con_expr_val[i] = (\n xv[i + 1] - xv[i] - 0.5 * h * (np.sin(tv[i]) + np.sin(tv[i + 1]))\n )\n\n assert np.allclose(con_expr_val, 0.0, atol=1e-8)\n\n lin_con_expr_val = np.zeros(N)\n for i in range(N):\n lin_con_expr_val[i] = tv[i + 1] - tv[i] - 0.5 * h * uv[i + 1] - 0.5 * h * uv[i]\n\n assert np.allclose(lin_con_expr_val, 0.0, atol=1e-8)\n\n obj_expr_val = 0.0\n for i in range(N):\n obj_expr_val += 0.5 * h * (uv[i] * uv[i] + uv[i + 1] * uv[i + 1])\n obj_expr_val += 0.5 * alpha * h * (np.cos(tv[i]) + np.cos(tv[i + 1]))\n\n objective_value = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n\n assert np.isclose(obj_expr_val, objective_value, atol=1e-8)\n assert objective_value == pytest.approx(\n 328.0967, abs=1e-4\n ) or objective_value == pytest.approx(350.0, abs=1e-8)\n" }, { "path": "tests/test_nlp_expression.py", "content": "import pyoptinterface as poi\nfrom pyoptinterface import nl\nimport math\nimport pytest\nfrom pytest import approx\n\n\ndef test_nlp_expressiontree(model_interface):\n model = model_interface\n\n if not hasattr(model, \"add_nl_constraint\"):\n pytest.skip(\"Model interface does not support nonlinear constraint\")\n\n x = model.add_variable(lb=0.0, ub=2.0)\n y = model.add_variable(lb=0.0, ub=2.0)\n\n with nl.graph():\n z = nl.exp(x) + nl.exp(2 * y)\n model.add_nl_constraint(z <= 2 * math.exp(1.0))\n\n z = x * x * x\n model.add_nl_constraint(z >= 0.8**3)\n\n model.set_objective(x + 2 * y, poi.ObjectiveSense.Maximize)\n model.optimize()\n\n x_value = model.get_value(x)\n y_value = model.get_value(y)\n\n # Note: with a feasibility tolerance defaulted to 1e-6 + the\n # effect of the internal solver scaling, x and y can assume\n # values relatively far away from the expected ones.\n # E.g.: x = 1.0005, y = 0.49975\n assert x_value == approx(1.0, rel=1e-2)\n assert y_value == approx(0.5, rel=1e-2)\n\n\ndef test_nlp_expressiontree_obj(model_interface):\n model = model_interface\n\n if not hasattr(model, \"add_nl_constraint\"):\n pytest.skip(\"Model interface does not support nonlinear constraint\")\n if not hasattr(model, \"add_nl_objective\"):\n pytest.skip(\"Model interface does not support nonlinear objective\")\n\n x = model.add_variable(lb=-2.0, ub=2.0)\n y = model.add_variable(lb=-2.0, ub=2.0)\n\n with nl.graph():\n z = x**2 + y**2\n model.add_nl_constraint(z, (-1.0, 1.0))\n\n with nl.graph():\n z = nl.exp(x**2) + nl.exp(y**2)\n model.add_nl_objective(z)\n\n model.optimize()\n\n x_value = model.get_value(x)\n y_value = model.get_value(y)\n\n assert x_value == approx(0.0, abs=1e-4)\n assert y_value == approx(0.0, abs=1e-4)\n" }, { "path": "tests/test_nlp_hs071.py", "content": "import pyoptinterface as poi\nfrom pyoptinterface import nl\nimport pytest\n\n\ndef test_hs071(nlp_model_ctor):\n model = nlp_model_ctor()\n\n x = model.add_m_variables(4, lb=1.0, ub=5.0, name=\"x\")\n\n model.set_variable_attribute(x[0], poi.VariableAttribute.PrimalStart, 1.0)\n model.set_variable_attribute(x[1], poi.VariableAttribute.PrimalStart, 5.0)\n model.set_variable_attribute(x[2], poi.VariableAttribute.PrimalStart, 5.0)\n model.set_variable_attribute(x[3], poi.VariableAttribute.PrimalStart, 1.0)\n\n with nl.graph():\n model.add_nl_objective(x[0] * x[3] * (x[0] + x[1] + x[2]) + x[2])\n\n with nl.graph():\n model.add_nl_constraint(x[0] * x[1] * x[2] * x[3] >= 25.0)\n model.add_quadratic_constraint(\n x[0] ** 2 + x[1] ** 2 + x[2] ** 2 + x[3] ** 2 == 40.0\n )\n\n model.optimize()\n\n x1_val = model.get_value(x[0])\n x2_val = model.get_value(x[1])\n x3_val = model.get_value(x[2])\n x4_val = model.get_value(x[3])\n\n sum_sq = x1_val**2 + x2_val**2 + x3_val**2 + x4_val**2\n product = x1_val * x2_val * x3_val * x4_val\n assert sum_sq == pytest.approx(40.0, rel=1e-6)\n assert 25.0 - 1e-6 <= product <= 100.0 + 1e-6\n\n objective_value = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n assert objective_value == pytest.approx(17.014, rel=1e-3)\n" }, { "path": "tests/test_nlp_multiple_run.py", "content": "from pyoptinterface import copt, ipopt, knitro, nl\nimport pytest\nimport math\n\n\ndef test_nlp_reopt(nlp_model_ctor):\n model = nlp_model_ctor()\n\n x = model.add_variable(lb=0.1)\n y = model.add_variable(lb=0.1)\n\n with nl.graph():\n model.add_nl_objective(x**2 + y**2)\n\n with nl.graph():\n model.add_nl_constraint(x**2 <= 1.0)\n model.add_nl_constraint(y**2 <= 1.0)\n\n model.optimize()\n\n assert model.get_value(x) == pytest.approx(0.1, rel=1e-5)\n assert model.get_value(y) == pytest.approx(0.1, rel=1e-5)\n\n z = model.add_variable(lb=0.2)\n with nl.graph():\n model.add_nl_objective(z**4)\n\n model.optimize()\n\n assert model.get_value(z) == pytest.approx(0.2)\n\n with nl.graph():\n model.add_nl_constraint(nl.log(z) >= math.log(4.0))\n\n model.optimize()\n\n print(model.get_value(z))\n\n assert model.get_value(z) == pytest.approx(4.0, rel=1e-5)\n\n\nif __name__ == \"__main__\":\n\n def c():\n return ipopt.Model(jit=\"C\")\n\n test_nlp_reopt(c)\n\n def llvm():\n return ipopt.Model(jit=\"LLVM\")\n\n test_nlp_reopt(llvm)\n\n test_nlp_reopt(copt.Model)\n test_nlp_reopt(knitro.Model)\n" }, { "path": "tests/test_nlp_opf.py", "content": "import math\nimport pyoptinterface as poi\nfrom pyoptinterface import nl\n\nimport pytest\n\n\ndef test_acopf(nlp_model_ctor):\n model = nlp_model_ctor()\n\n branches = [\n # (from, to, R, X, B, angmin, angmax, Smax)\n (0, 1, 0.00281, 0.0281, 0.00712, -30.0, 30.0, 4.00),\n (0, 3, 0.00304, 0.0304, 0.00658, -30.0, 30.0, 4.26),\n (0, 4, 0.00064, 0.0064, 0.03126, -30.0, 30.0, 4.26),\n (1, 2, 0.00108, 0.0108, 0.01852, -30.0, 30.0, 4.26),\n (2, 3, 0.00297, 0.0297, 0.00674, -30.0, 30.0, 4.26),\n (3, 4, 0.00297, 0.0297, 0.00674, -30.0, 30.0, 2.40),\n ]\n\n buses = [\n # (Pd, Qd, Gs, Bs, Vmin, Vmax)\n (0.0, 0.0000, 0.0, 0.0, 0.9, 1.1),\n (3.0, 0.9861, 0.0, 0.0, 0.9, 1.1),\n (3.0, 0.9861, 0.0, 0.0, 0.9, 1.1),\n (4.0, 1.3147, 0.0, 0.0, 0.9, 1.1),\n (0.0, 0.0000, 0.0, 0.0, 0.9, 1.1),\n ]\n\n generators = [\n # (bus, Pmin, Pmax, Qmin, Qmax, a, b, c)\n (0, 0.0, 0.4, -0.300, 0.300, 0.0, 1400, 0.0),\n (0, 0.0, 1.7, -1.275, 1.275, 0.0, 1500, 0.0),\n (2, 0.0, 5.2, -3.900, 3.900, 0.0, 3000, 0.0),\n (3, 0.0, 2.0, -1.500, 1.500, 0.0, 4000, 0.0),\n (4, 0.0, 6.0, -4.500, 4.500, 0.0, 1000, 0.0),\n ]\n\n slack_bus = 3\n\n N_branch = len(branches)\n N_bus = len(buses)\n N_gen = len(generators)\n\n Pbr_from = model.add_m_variables(N_branch)\n Qbr_from = model.add_m_variables(N_branch)\n Pbr_to = model.add_m_variables(N_branch)\n Qbr_to = model.add_m_variables(N_branch)\n\n V = model.add_m_variables(N_bus, name=\"V\")\n theta = model.add_m_variables(N_bus, name=\"theta\")\n\n for i in range(N_bus):\n Vmin, Vmax = buses[i][4], buses[i][5]\n model.set_variable_bounds(V[i], Vmin, Vmax)\n\n model.set_variable_bounds(theta[slack_bus], 0.0, 0.0)\n\n P = model.add_variables(range(N_gen), name=\"P\")\n Q = model.add_variables(range(N_gen), name=\"Q\")\n\n for i in range(N_gen):\n model.set_variable_bounds(P[i], generators[i][1], generators[i][2])\n model.set_variable_bounds(Q[i], generators[i][3], generators[i][4])\n\n # nonlinear constraints\n for k in range(N_branch):\n with nl.graph():\n branch = branches[k]\n R, X, Bc2 = branch[2], branch[3], branch[4]\n\n G = R / (R**2 + X**2)\n B = -X / (R**2 + X**2)\n Bc = Bc2 / 2\n\n i = branch[0]\n j = branch[1]\n\n Vi = V[i]\n Vj = V[j]\n theta_i = theta[i]\n theta_j = theta[j]\n\n Pij = Pbr_from[k]\n Qij = Qbr_from[k]\n Pji = Pbr_to[k]\n Qji = Qbr_to[k]\n\n sin_ij = nl.sin(theta_i - theta_j)\n cos_ij = nl.cos(theta_i - theta_j)\n\n Pij_eq = G * Vi**2 - Vi * Vj * (G * cos_ij + B * sin_ij) - Pij\n Qij_eq = -(B + Bc) * Vi**2 - Vi * Vj * (G * sin_ij - B * cos_ij) - Qij\n Pji_eq = G * Vj**2 - Vi * Vj * (G * cos_ij - B * sin_ij) - Pji\n Qji_eq = -(B + Bc) * Vj**2 - Vi * Vj * (-G * sin_ij - B * cos_ij) - Qji\n\n model.add_nl_constraint(\n Pij_eq == 0.0,\n )\n model.add_nl_constraint(\n Qij_eq == 0.0,\n )\n model.add_nl_constraint(\n Pji_eq == 0.0,\n )\n model.add_nl_constraint(\n Qji_eq == 0.0,\n )\n\n # power balance constraints\n P_balance_eq = [poi.ExprBuilder() for i in range(N_bus)]\n Q_balance_eq = [poi.ExprBuilder() for i in range(N_bus)]\n\n for b in range(N_bus):\n Pd, Qd = buses[b][0], buses[b][1]\n Gs, Bs = buses[b][2], buses[b][3]\n Vb = V[b]\n\n P_balance_eq[b] -= poi.quicksum(\n Pbr_from[k] for k in range(N_branch) if branches[k][0] == b\n )\n P_balance_eq[b] -= poi.quicksum(\n Pbr_to[k] for k in range(N_branch) if branches[k][1] == b\n )\n P_balance_eq[b] += poi.quicksum(\n P[i] for i in range(N_gen) if generators[i][0] == b\n )\n P_balance_eq[b] -= Pd\n P_balance_eq[b] -= Gs * Vb * Vb\n\n Q_balance_eq[b] -= poi.quicksum(\n Qbr_from[k] for k in range(N_branch) if branches[k][0] == b\n )\n Q_balance_eq[b] -= poi.quicksum(\n Qbr_to[k] for k in range(N_branch) if branches[k][1] == b\n )\n Q_balance_eq[b] += poi.quicksum(\n Q[i] for i in range(N_gen) if generators[i][0] == b\n )\n Q_balance_eq[b] -= Qd\n Q_balance_eq[b] += Bs * Vb * Vb\n\n model.add_quadratic_constraint(P_balance_eq[b], poi.Eq, 0.0)\n model.add_quadratic_constraint(Q_balance_eq[b], poi.Eq, 0.0)\n\n for k in range(N_branch):\n branch = branches[k]\n\n i = branch[0]\n j = branch[1]\n\n theta_i = theta[i]\n theta_j = theta[j]\n\n angmin = branch[5] / 180 * math.pi\n angmax = branch[6] / 180 * math.pi\n\n model.add_linear_constraint(theta_i - theta_j, (angmin, angmax))\n\n Smax = branch[7]\n Pij = Pbr_from[k]\n Qij = Qbr_from[k]\n Pji = Pbr_to[k]\n Qji = Qbr_to[k]\n model.add_quadratic_constraint(Pij * Pij + Qij * Qij, poi.Leq, Smax * Smax)\n model.add_quadratic_constraint(Pji * Pji + Qji * Qji, poi.Leq, Smax * Smax)\n\n cost = poi.ExprBuilder()\n for i in range(N_gen):\n a, b, c = generators[i][5], generators[i][6], generators[i][7]\n cost += a * P[i] * P[i] + b * P[i] + c\n model.set_objective(cost)\n\n model.optimize()\n\n terminattion_status = model.get_model_attribute(\n poi.ModelAttribute.TerminationStatus\n )\n assert (terminattion_status == poi.TerminationStatusCode.LOCALLY_SOLVED) or (\n terminattion_status == poi.TerminationStatusCode.OPTIMAL\n )\n\n P_value = P.map(model.get_value)\n P_value_sum = sum(P_value.values())\n\n total_load_p = sum(b[0] for b in buses)\n\n assert P_value_sum > total_load_p\n\n objective_value = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n assert objective_value == pytest.approx(1.7552e4, rel=1e-3)\n\n\nif __name__ == \"__main__\":\n from pyoptinterface import ipopt, copt, knitro\n\n test_acopf(ipopt.Model)\n test_acopf(copt.Model)\n test_acopf(knitro.Model)\n" }, { "path": "tests/test_nlp_rocket.py", "content": "from pyoptinterface import nl\n\nimport math\nimport pytest\n\n\ndef rocket_model(model, nh: int):\n h_0 = 1.0\n v_0 = 0.0\n m_0 = 1.0\n g_0 = 1.0\n T_c = 3.5\n h_c = 500.0\n v_c = 620.0\n m_c = 0.6\n\n c = 0.5 * math.sqrt(g_0 * h_0)\n m_f = m_c * m_0\n D_c = 0.5 * v_c * (m_0 / g_0)\n T_max = T_c * m_0 * g_0\n\n h = model.add_m_variables(nh, lb=1.0)\n v = model.add_m_variables(nh, lb=0.0)\n m = model.add_m_variables(nh, lb=m_f, ub=m_0)\n T = model.add_m_variables(nh, lb=0.0, ub=T_max)\n step = model.add_variable(lb=0.0)\n\n model.set_objective(-1.0 * h[-1])\n\n for i in range(nh - 1):\n with nl.graph():\n h1 = h[i]\n h2 = h[i + 1]\n v1 = v[i]\n v2 = v[i + 1]\n m1 = m[i]\n m2 = m[i + 1]\n T1 = T[i]\n T2 = T[i + 1]\n\n model.add_nl_constraint(h2 - h1 - 0.5 * step * (v1 + v2) == 0)\n\n D1 = D_c * v1 * v1 * nl.exp(-h_c * (h1 - h_0)) / h_0\n D2 = D_c * v2 * v2 * nl.exp(-h_c * (h2 - h_0)) / h_0\n g1 = g_0 * h_0 * h_0 / (h1 * h1)\n g2 = g_0 * h_0 * h_0 / (h2 * h2)\n dv1 = (T1 - D1) / m1 - g1\n dv2 = (T2 - D2) / m2 - g2\n\n model.add_nl_constraint(v2 - v1 - 0.5 * step * (dv1 + dv2) == 0)\n model.add_nl_constraint(m2 - m1 + 0.5 * step * (T1 + T2) / c == 0)\n\n # Boundary conditions\n model.set_variable_bounds(h[0], h_0, h_0)\n model.set_variable_bounds(v[0], v_0, v_0)\n model.set_variable_bounds(m[0], m_0, m_0)\n model.set_variable_bounds(m[-1], m_f, m_f)\n\n model.h = h\n\n\ndef test_rocket(nlp_model_ctor):\n nh = 400\n model = nlp_model_ctor()\n rocket_model(model, nh)\n model.optimize()\n\n obj = model.get_value(model.h[-1])\n\n assert obj == pytest.approx(1.01283, rel=1e-4)\n\n\nif __name__ == \"__main__\":\n from pyoptinterface import copt, ipopt, knitro\n\n def c():\n return ipopt.Model(jit=\"C\")\n\n test_rocket(c)\n\n def llvm():\n return ipopt.Model(jit=\"LLVM\")\n\n test_rocket(llvm)\n\n test_rocket(copt.Model)\n\n test_rocket(knitro.Model)\n" }, { "path": "tests/test_operator.py", "content": "from operator import add, sub, mul, truediv\n\nfrom pyoptinterface import (\n VariableIndex,\n ExprBuilder,\n ScalarAffineFunction,\n ScalarQuadraticFunction,\n quicksum,\n quicksum_,\n)\nfrom pytest import approx\n\n\ndef evaluate(expr, var_value_map=None):\n if isinstance(expr, VariableIndex):\n return var_value_map[expr.index]\n elif isinstance(expr, ScalarAffineFunction):\n s = 0.0\n if expr.constant is not None:\n s = expr.constant\n for index, coef in zip(expr.variables, expr.coefficients):\n val = var_value_map[index]\n s += coef * val\n return s\n elif isinstance(expr, ScalarQuadraticFunction):\n s = 0.0\n if expr.affine_part is not None:\n s = evaluate(expr.affine_part, var_value_map)\n for index1, index2, coef in zip(\n expr.variable_1s, expr.variable_2s, expr.coefficients\n ):\n val1 = var_value_map[index1]\n val2 = var_value_map[index2]\n s += coef * val1 * val2\n return s\n elif isinstance(expr, ExprBuilder):\n degree = expr.degree()\n if degree < 2:\n return evaluate(ScalarAffineFunction(expr), var_value_map)\n elif degree == 2:\n return evaluate(ScalarQuadraticFunction(expr), var_value_map)\n else:\n raise ValueError(\"Unsupported degree\")\n elif isinstance(expr, (int, float)):\n return expr\n else:\n raise ValueError(\"Unsupported type\")\n\n\ndef degree(expr):\n if isinstance(expr, VariableIndex):\n return 1\n elif isinstance(expr, ScalarAffineFunction):\n return 1\n elif isinstance(expr, ScalarQuadraticFunction):\n return 2\n elif isinstance(expr, ExprBuilder):\n return expr.degree()\n elif isinstance(expr, (int, float)):\n return 0\n else:\n raise ValueError(\"Unsupported type\")\n\n\ndef test_evaluate():\n assert evaluate(1.0) == approx(1.0)\n assert evaluate(2) == 2\n\n N = 6\n vars = [VariableIndex(i) for i in range(N)]\n var_value_map = {v.index: float(v.index) for v in vars}\n\n for i in range(N):\n assert evaluate(vars[i], var_value_map) == approx(i)\n\n expr = vars[0] + 1 * vars[1] + 2 * vars[2]\n assert evaluate(expr, var_value_map) == approx(5.0)\n\n expr = ExprBuilder(expr)\n assert evaluate(expr, var_value_map) == approx(5.0)\n\n expr = vars[0] + 2 * vars[1] + 5 * vars[3] * vars[2] + 6 * vars[4] * vars[4]\n answer = 2 + 5 * 3 * 2 + 6 * 4 * 4\n assert evaluate(expr, var_value_map) == approx(answer)\n\n expr = ExprBuilder(expr)\n assert evaluate(expr, var_value_map) == approx(answer)\n\n\ndef test_operator():\n N = 6\n vars = [VariableIndex(i) for i in range(N)]\n\n exprs = [\n 1,\n 2.0,\n vars[4],\n 3 * vars[2],\n 2 * vars[1] + vars[3],\n 2 * vars[2] + vars[3] + 5.0,\n 13 * vars[4] * vars[4],\n 17 * vars[3] * vars[3] + 1.0,\n 17 * vars[3] * vars[5] + 3 * vars[1],\n 11 * vars[5] * vars[5] + 7 * vars[1] + 3.0,\n ]\n exprs += [ExprBuilder(e) for e in exprs]\n\n # For two quadratic polynomials, if their values equal on more than 3 points, then thir coefficients are the same.\n for i in (1, 2, 3, 4):\n var_value_map = {v.index: i * float(v.index) for v in vars}\n\n expr_values = [evaluate(e, var_value_map) for e in exprs]\n\n for op in [add, sub]:\n for i, ei in enumerate(exprs):\n for j, ej in enumerate(exprs):\n expr = op(ei, ej)\n value = evaluate(expr, var_value_map)\n assert value == approx(op(expr_values[i], expr_values[j]))\n\n op = mul\n for i, ei in enumerate(exprs):\n for j, ej in enumerate(exprs):\n total_degree = degree(ei) + degree(ej)\n if total_degree > 2:\n continue\n expr = op(ei, ej)\n value = evaluate(expr, var_value_map)\n # flag = value == approx(op(expr_values[i], expr_values[j]))\n # if not flag:\n # k = 1\n assert value == approx(op(expr_values[i], expr_values[j]))\n\n op = truediv\n for i, ei in enumerate(exprs):\n for j, ej in enumerate(exprs):\n if not isinstance(ej, (int, float)):\n continue\n expr = op(ei, ej)\n value = evaluate(expr, var_value_map)\n assert value == approx(op(expr_values[i], expr_values[j]))\n\n\ndef test_quicksum():\n N = 6\n vars = [VariableIndex(i) for i in range(N)]\n var_value_map = {v.index: float(v.index) for v in vars}\n vars_dict = {i: v for i, v in enumerate(vars)}\n\n expr = ExprBuilder()\n for v in vars:\n expr += v\n expr_sum = quicksum(vars_dict)\n assert evaluate(expr_sum, var_value_map) == approx(evaluate(expr, var_value_map))\n\n f = lambda x: x * x\n expr = ExprBuilder()\n for v in vars:\n expr += f(v)\n expr_sum = quicksum(vars, f)\n assert evaluate(expr_sum, var_value_map) == approx(evaluate(expr, var_value_map))\n\n c = 3.0\n expr = ExprBuilder(c)\n for v in vars:\n expr += v\n expr_sum = ExprBuilder(c)\n quicksum_(expr_sum, vars)\n assert evaluate(expr_sum, var_value_map) == approx(evaluate(expr, var_value_map))\n\n f = lambda x: x * x\n expr = ExprBuilder(c)\n for v in vars:\n expr += f(v)\n expr_sum = ExprBuilder(c)\n quicksum_(expr_sum, vars_dict, f)\n assert evaluate(expr_sum, var_value_map) == approx(evaluate(expr, var_value_map))\n" }, { "path": "tests/test_preopt.py", "content": "import pyoptinterface as poi\n\n\ndef test_model_attribute_termination_before_solve(model_interface_oneshot):\n \"\"\"Test termination status before solving.\"\"\"\n model = model_interface_oneshot\n x = model.add_variable(lb=0.0, ub=10.0)\n model.set_objective(x, poi.ObjectiveSense.Minimize)\n\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMIZE_NOT_CALLED\n" }, { "path": "tests/test_qp.py", "content": "import pyoptinterface as poi\nfrom pytest import approx\n\nimport numpy as np\n\n\ndef test_simple_qp(model_interface_oneshot):\n model = model_interface_oneshot\n\n N = 6\n\n x = model.add_variables(range(N), lb=0.0)\n\n model.add_linear_constraint(poi.quicksum(x), poi.Geq, N)\n\n s = poi.quicksum(x)\n s *= s\n model.set_objective(s, poi.ObjectiveSense.Minimize)\n\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert (\n status == poi.TerminationStatusCode.OPTIMAL\n or status == poi.TerminationStatusCode.LOCALLY_SOLVED\n )\n\n obj_val = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n assert obj_val == approx(N**2, rel=1e-5)\n\n\n# reported by https://github.com/metab0t/PyOptInterface/issues/59\ndef test_shuffle_qp_objective(model_interface_oneshot):\n model = model_interface_oneshot\n\n N = 3\n weights = model.add_m_variables(N, lb=0)\n\n expected_returns = [0.05, 0.07, 0.12]\n min_return = 0.06\n cov = [\n (0, 0, 0.1),\n (0, 1, 0.1),\n (0, 2, 0.04),\n (1, 1, 0.4),\n (1, 2, 0.2),\n (2, 2, 0.9),\n ]\n cov_objs = [weights[i] * weights[j] * v for i, j, v in cov]\n\n model.add_linear_constraint(poi.quicksum(weights) == 1)\n model.add_linear_constraint(\n poi.quicksum(expected_returns[i] * weights[i] for i in range(N)) >= min_return\n )\n\n trial = 120\n obj_values = []\n for _ in range(trial):\n import random\n\n random.shuffle(cov_objs)\n obj = poi.quicksum(cov_objs)\n model.set_objective(obj, poi.ObjectiveSense.Minimize)\n\n model.optimize()\n\n obj_value = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n obj_values.append(obj_value)\n\n obj_values = np.array(obj_values)\n # test all values are the same\n assert np.all(np.abs(obj_values - obj_values[0]) < 1e-8)\n\n\ndef test_duplicated_quadratic_terms(model_interface_oneshot):\n model = model_interface_oneshot\n\n x = model.add_m_variables(2, lb=1.0)\n\n obj = (\n x[0] * x[0]\n + x[0] * x[0]\n + x[1] * x[1]\n + 2 * x[1] * x[1]\n + 0.5 * x[0] * x[1]\n + 0.1 * x[1] * x[0]\n )\n\n model.set_objective(obj)\n\n model.optimize()\n obj_value = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n assert obj_value == approx(5.6)\n" }, { "path": "tests/test_reducedcost.py", "content": "import pyoptinterface as poi\nimport pytest\nfrom pytest import approx\n\n\ndef test_simple_redcost(model_interface):\n model = model_interface\n\n if not model.supports_variable_attribute(poi.VariableAttribute.ReducedCost):\n pytest.skip(\"Model interface does not support ReducedCost attribute\")\n\n x = model.add_variable(lb=0.0, ub=2.0)\n y = model.add_variable(lb=0.0, ub=2.5)\n model.add_linear_constraint(x + 2 * y >= 6.0)\n\n model.set_objective(x + y)\n\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n\n x_redcost = model.get_variable_attribute(x, poi.VariableAttribute.ReducedCost)\n y_redcost = model.get_variable_attribute(y, poi.VariableAttribute.ReducedCost)\n\n assert x_redcost == approx(0.0, abs=1e-5)\n assert y_redcost == approx(-1.0, abs=1e-5)\n" }, { "path": "tests/test_simple_opt.py", "content": "import pyoptinterface as poi\nfrom pytest import approx\nimport pytest\n\n\ndef test_simple_opt(model_interface):\n model = model_interface\n\n x = model.add_variable(lb=0.0, ub=20.0)\n y = model.add_variable()\n model.set_variable_bounds(y, 8.0, 20.0)\n\n model.set_variable_attribute(x, poi.VariableAttribute.Name, \"x\")\n model.set_variable_attribute(y, poi.VariableAttribute.Name, \"y\")\n\n obj = x * x + y * y\n model.set_objective(obj, poi.ObjectiveSense.Minimize)\n\n conexpr = x + y\n con1 = model.add_linear_constraint(\n conexpr - 10.0, poi.ConstraintSense.GreaterEqual, 0.0, name=\"con1\"\n )\n\n assert model.number_of_variables() == 2\n assert model.number_of_constraints(poi.ConstraintType.Linear) == 1\n\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n x_val = model.get_variable_attribute(x, poi.VariableAttribute.Value)\n y_val = model.get_variable_attribute(y, poi.VariableAttribute.Value)\n assert x_val == approx(2.0)\n assert y_val == approx(8.0)\n obj_val = model.get_value(obj)\n assert obj_val == approx(68.0)\n obj_val_attr = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n assert obj_val_attr == approx(obj_val)\n conexpr_val = model.get_value(conexpr)\n assert conexpr_val == approx(10.0)\n\n assert model.pprint(x) == \"x\"\n assert model.pprint(y) == \"y\"\n assert model.pprint(obj) == \"1*x*x+1*y*y\"\n assert model.pprint(conexpr) == \"1*x+1*y\"\n\n model.delete_constraint(con1)\n assert model.number_of_constraints(poi.ConstraintType.Linear) == 0\n con2 = model.add_linear_constraint(conexpr, poi.ConstraintSense.GreaterEqual, 20.0)\n assert model.number_of_constraints(poi.ConstraintType.Linear) == 1\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n x_val = model.get_variable_attribute(x, poi.VariableAttribute.Value)\n y_val = model.get_variable_attribute(y, poi.VariableAttribute.Value)\n assert x_val == approx(10.0, abs=1e-3)\n assert y_val == approx(10.0, abs=1e-3)\n\n model.delete_constraint(con2)\n con3 = model.add_linear_constraint(conexpr, poi.ConstraintSense.GreaterEqual, 20.05)\n model.set_variable_attribute(\n x, poi.VariableAttribute.Domain, poi.VariableDomain.Integer\n )\n model.set_objective(x + 2 * y, poi.ObjectiveSense.Minimize)\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n x_val = model.get_variable_attribute(x, poi.VariableAttribute.Value)\n y_val = model.get_variable_attribute(y, poi.VariableAttribute.Value)\n assert x_val == approx(12.0)\n assert y_val == approx(8.05)\n\n model.delete_constraint(con3)\n con4 = model.add_linear_constraint(conexpr, poi.ConstraintSense.GreaterEqual, 10.0)\n model.set_variable_attribute(\n x, poi.VariableAttribute.Domain, poi.VariableDomain.Continuous\n )\n model.set_variable_attribute(y, poi.VariableAttribute.LowerBound, 0.0)\n model.set_objective(obj, poi.ObjectiveSense.Minimize)\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n x_val = model.get_variable_attribute(x, poi.VariableAttribute.Value)\n y_val = model.get_variable_attribute(y, poi.VariableAttribute.Value)\n assert x_val == approx(5.0)\n assert y_val == approx(5.0)\n\n model.set_normalized_rhs(con4, 16.0)\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n x_val = model.get_variable_attribute(x, poi.VariableAttribute.Value)\n y_val = model.get_variable_attribute(y, poi.VariableAttribute.Value)\n assert x_val == approx(8.0)\n assert y_val == approx(8.0)\n\n\ndef test_constant_objective(model_interface_oneshot):\n model = model_interface_oneshot\n\n x = model.add_variable(lb=0.0, ub=1.0)\n obj = 1.0\n model.set_objective(obj, poi.ObjectiveSense.Minimize)\n model.optimize()\n obj_val = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n assert obj_val == approx(1.0)\n model.set_objective(obj, poi.ObjectiveSense.Maximize)\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert (\n status == poi.TerminationStatusCode.OPTIMAL\n or status == poi.TerminationStatusCode.LOCALLY_SOLVED\n )\n obj_val = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n assert obj_val == approx(1.0)\n\n\ndef test_constraint_primal_dual(model_interface_oneshot):\n model = model_interface_oneshot\n\n x = model.add_variable(lb=0.0, ub=1.0)\n y = model.add_variable(lb=0.0, ub=1.0)\n\n model.set_variable_attribute(x, poi.VariableAttribute.Name, \"x\")\n model.set_variable_attribute(y, poi.VariableAttribute.Name, \"y\")\n\n obj = x + y\n model.set_objective(obj, poi.ObjectiveSense.Minimize)\n\n conexpr = x + 2 * y\n con1 = model.add_linear_constraint(conexpr, poi.Geq, 1.0, name=\"con1\")\n\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert (\n status == poi.TerminationStatusCode.OPTIMAL\n or status == poi.TerminationStatusCode.LOCALLY_SOLVED\n )\n\n primal_val = model.get_constraint_attribute(con1, poi.ConstraintAttribute.Primal)\n assert primal_val == approx(1.0)\n\n dual_val = model.get_constraint_attribute(con1, poi.ConstraintAttribute.Dual)\n assert dual_val == approx(0.5)\n\n\ndef test_add_quadratic_expr_as_linear_throws_error(model_interface_oneshot):\n model = model_interface_oneshot\n\n xs = model.add_m_variables(10)\n x2_sum = poi.quicksum(x * x for x in xs.flat)\n\n with pytest.raises(RuntimeError, match=\"add_linear_constraint\"):\n model.add_linear_constraint(x2_sum <= 1.0)\n\n\ndef test_exprbuilder_self_operation(model_interface_oneshot):\n model = model_interface_oneshot\n\n x = model.add_m_variables(2, lb=1.0, ub=4.0)\n\n expr = poi.ExprBuilder(x[0] + 2.0 * x[1] + 3.0)\n expr += expr\n model.set_objective(expr)\n model.optimize()\n obj_value = model.get_value(expr)\n assert obj_value == approx(12.0)\n\n expr = poi.ExprBuilder(x[0] + 2.0 * x[1] + 3.0)\n expr -= expr\n model.set_objective(expr)\n model.optimize()\n obj_value = model.get_value(expr)\n assert obj_value == approx(0.0)\n\n expr = poi.ExprBuilder(x[0] + 2.0 * x[1] + 3.0)\n expr *= expr\n model.set_objective(expr)\n model.optimize()\n obj_value = model.get_value(expr)\n assert obj_value == approx(36.0)\n" }, { "path": "tests/test_soc.py", "content": "import pyoptinterface as poi\nfrom pytest import approx\nimport pytest\n\n\ndef test_soc(model_interface):\n model = model_interface\n\n if not hasattr(model, \"add_second_order_cone_constraint\"):\n pytest.skip(\"Model interface does not support second order cone constraints\")\n\n x = model.add_variable(lb=0.0, name=\"x\")\n y = model.add_variable(lb=3.0, name=\"y\")\n z = model.add_variable(lb=4.0, name=\"z\")\n\n obj = x + y + z\n model.set_objective(obj, poi.ObjectiveSense.Minimize)\n\n con1 = model.add_second_order_cone_constraint([x, y, z])\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n x_val = model.get_value(x)\n y_val = model.get_value(y)\n z_val = model.get_value(z)\n assert x_val == approx(5.0, rel=1e-5)\n assert y_val == approx(3.0, rel=1e-5)\n assert z_val == approx(4.0, rel=1e-5)\n obj_val = model.get_value(obj)\n assert obj_val == approx(12.0, rel=1e-5)\n\n model.delete_constraint(con1)\n xx = model.add_variable(lb=0.0, name=\"xx\")\n model.add_linear_constraint(xx - 2 * x, poi.ConstraintSense.Equal, 0.0)\n\n model.add_second_order_cone_constraint([xx, y, z])\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n x_val = model.get_value(x)\n y_val = model.get_value(y)\n z_val = model.get_value(z)\n assert x_val == approx(2.5, rel=1e-5)\n assert y_val == approx(3.0, rel=1e-5)\n assert z_val == approx(4.0, rel=1e-5)\n obj_val = model.get_value(obj)\n assert obj_val == approx(9.5, rel=1e-5)\n\n\ndef test_rotated_soc(model_interface):\n model = model_interface\n\n if not hasattr(model, \"add_second_order_cone_constraint\"):\n pytest.skip(\"Model interface does not support second order cone constraints\")\n\n x = model.add_variable(lb=0.0, name=\"x\")\n y = model.add_variable(lb=0.0, name=\"y\")\n z = model.add_variable(lb=4.0, ub=4.0, name=\"z\")\n\n obj = x + 2 * y\n model.set_objective(obj, poi.ObjectiveSense.Minimize)\n\n con1 = model.add_second_order_cone_constraint([x, y, z], rotated=True)\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n x_val = model.get_value(x)\n y_val = model.get_value(y)\n assert x_val == approx(4.0, rel=1e-3)\n assert y_val == approx(2.0, rel=1e-3)\n obj_val = model.get_value(obj)\n assert obj_val == approx(8.0, rel=1e-3)\n\n model.delete_constraint(con1)\n xx = model.add_variable(lb=0.0, name=\"xx\")\n model.add_linear_constraint(xx - 4 * x, poi.ConstraintSense.Equal, 0.0)\n\n model.add_second_order_cone_constraint([xx, y, z], rotated=True)\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n x_val = model.get_value(x)\n y_val = model.get_value(y)\n assert x_val == approx(2.0, rel=1e-3)\n assert y_val == approx(1.0, rel=1e-3)\n obj_val = model.get_value(obj)\n assert obj_val == approx(4.0, rel=1e-3)\n" }, { "path": "tests/test_sos.py", "content": "import pyoptinterface as poi\nfrom pytest import approx\nimport pytest\n\n\n# write a test to test if SOS1 and SOS2 constraint are functional\ndef test_sos(model_interface):\n model = model_interface\n\n if not hasattr(model, \"add_sos_constraint\"):\n pytest.skip(\"Model interface does not support SOS constraints\")\n\n N = 10\n vars = [model.add_variable(lb=0.0, ub=1.0) for _ in range(N)]\n\n obj = poi.quicksum(vars)\n model.set_objective(obj, poi.ObjectiveSense.Maximize)\n\n con1 = model.add_sos_constraint(vars, poi.SOSType.SOS1)\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n obj_val = model.get_value(obj)\n assert obj_val == approx(1.0)\n\n nz_indices = [i for i in range(N) if model.get_value(vars[i]) > 1e-3]\n assert len(nz_indices) == 1\n\n model.delete_constraint(con1)\n con2 = model.add_sos_constraint(vars, poi.SOSType.SOS2)\n model.optimize()\n status = model.get_model_attribute(poi.ModelAttribute.TerminationStatus)\n assert status == poi.TerminationStatusCode.OPTIMAL\n obj_val = model.get_value(obj)\n assert obj_val == approx(2.0)\n\n nz_indices = [i for i in range(N) if model.get_value(vars[i]) > 1e-3]\n assert len(nz_indices) == 2\n v1, v2 = nz_indices\n assert v1 + 1 == v2\n" }, { "path": "tests/test_tupledict.py", "content": "from pyoptinterface._src.tupledict import (\n flatten_tuple,\n make_tupledict,\n tupledict,\n WILDCARD,\n)\n\n\ndef test_flatten_tuple():\n assert list(flatten_tuple((1, (2, 3), (4, 5)))) == [1, 2, 3, 4, 5]\n assert list(flatten_tuple((1, 2, 3))) == [1, 2, 3]\n assert list(flatten_tuple(((1, 2), 3))) == [1, 2, 3]\n\n\ndef test_make_tupledict():\n assert make_tupledict([1, 2], [3, 4], rule=lambda x, y: x * y) == {\n (1, 3): 3,\n (1, 4): 4,\n (2, 3): 6,\n (2, 4): 8,\n }\n assert make_tupledict([1, 2], [3, 4], rule=lambda x, y: None) == {}\n assert make_tupledict([1, 2], rule=lambda x: x) == {1: 1, 2: 2}\n assert make_tupledict([1, 2], [(3, 3), (4, 4)], rule=lambda x, y, z: x) == {\n (1, 3, 3): 1,\n (1, 4, 4): 1,\n (2, 3, 3): 2,\n (2, 4, 4): 2,\n }\n\n\ndef test_tupledict_select():\n # Create a tupledict instance\n td = tupledict(\n {\n (1, 2): \"a\",\n (1, 3): \"b\",\n (2, 2): \"c\",\n (2, 3): \"d\",\n }\n )\n\n # Test select with specific keys\n assert list(td.select(1, 2)) == [\"a\"]\n assert list(td.select(2, WILDCARD)) == [\"c\", \"d\"]\n\n # Test select with wildcard\n assert list(td.select(WILDCARD, 2)) == [\"a\", \"c\"]\n\n # Test select with all wildcards\n assert list(td.select(WILDCARD, WILDCARD)) == [\"a\", \"b\", \"c\", \"d\"]\n\n # Test select with non-existing key\n assert list(td.select(3, 2)) == []\n\n # Test select with key and value\n assert list(td.select(1, 2, with_key=True)) == [((1, 2), \"a\")]\n assert list(td.select(2, WILDCARD, with_key=True)) == [((2, 2), \"c\"), ((2, 3), \"d\")]\n\n\ndef test_tupledict_map():\n td = tupledict([((i, i + 1), i) for i in range(10)])\n\n td_m = td.map(lambda x: x**2)\n\n assert isinstance(td_m, tupledict)\n\n assert list(td_m.values()) == [i**2 for i in range(10)]\n\n assert list(td_m.keys()) == list(td.keys())\n" }, { "path": "tests/test_update.py", "content": "import pyoptinterface as poi\nfrom pytest import approx\n\n\ndef test_update(model_interface):\n model = model_interface\n\n x = model.add_variables(range(3), lb=1.0, ub=2.0)\n\n model.delete_variable(x[1])\n\n expr = x[0] - x[2]\n con = model.add_linear_constraint(expr, poi.Eq, 0.0)\n\n obj = x[0] - x[2]\n model.set_objective(obj)\n\n model.optimize()\n\n assert model.get_value(obj) == approx(0.0)\n\n model.delete_constraint(con)\n model.set_variable_attribute(x[0], poi.VariableAttribute.LowerBound, 2.0)\n assert model.get_variable_attribute(\n x[0], poi.VariableAttribute.LowerBound\n ) == approx(2.0)\n\n model.optimize()\n\n assert model.get_value(x[0]) == approx(2.0)\n assert model.get_value(x[2]) == approx(2.0)\n\n con = model.add_linear_constraint(expr, poi.Eq, 0.0)\n model.set_normalized_coefficient(con, x[2], -2.0)\n\n model.optimize()\n\n assert model.get_value(x[0]) == approx(2.0)\n assert model.get_value(x[2]) == approx(1.0)\n\n model.set_variable_attribute(x[0], poi.VariableAttribute.LowerBound, 1.5)\n model.set_variable_attribute(x[2], poi.VariableAttribute.LowerBound, 0.5)\n model.set_objective_coefficient(x[0], 2.0)\n model.set_objective_coefficient(x[2], 1.0)\n model.optimize()\n\n assert model.get_value(x[0]) == approx(1.5)\n assert model.get_value(x[2]) == approx(0.75)\n" }, { "path": "tests/tsp_cb.py", "content": "# This file is adapted from the examples/python/tsp.py in Gurobi installation.\n# We use this file to ensure our callback implementation is correct and the result is compared with gurobipy/coptpy/xpress\n# this test is currently run manually\n\n# Copyright 2024, Gurobi Optimization, LLC\n\nfrom typing import List, Tuple\nimport math\nimport random\nimport time\nfrom collections import defaultdict\nfrom itertools import combinations\n\n# Test what is available in the current system\nGUROBIPY_AVAILABLE = False\nCOPTPY_AVAILABLE = False\nXPRESS_AVAILABLE = False\n\ntry:\n import gurobipy as gp\n\n GUROBIPY_AVAILABLE = True\nexcept ImportError:\n print(\"Gurobipy not found.\")\n\ntry:\n import coptpy as cp\n\n COPTPY_AVAILABLE = True\nexcept ImportError:\n print(\"Coptpy not found.\")\n\ntry:\n import xpress as xp\n\n XPRESS_AVAILABLE = True\nexcept ImportError:\n print(\"Xpress Python Interface not found.\")\n\nimport pyoptinterface as poi\nfrom pyoptinterface import gurobi, copt, xpress\n\nGRB = gurobi.GRB\nCOPT = copt.COPT\nXPRS = xpress.XPRS\n\n\ndef shortest_subtour(edges: List[Tuple[int, int]]) -> List[int]:\n node_neighbors = defaultdict(list)\n for i, j in edges:\n node_neighbors[i].append(j)\n assert all(len(neighbors) == 2 for neighbors in node_neighbors.values())\n\n # Follow edges to find cycles. Each time a new cycle is found, keep track\n # of the shortest cycle found so far and restart from an unvisited node.\n unvisited = set(node_neighbors)\n shortest = None\n while unvisited:\n cycle = []\n neighbors = list(unvisited)\n while neighbors:\n current = neighbors.pop()\n cycle.append(current)\n unvisited.remove(current)\n neighbors = [j for j in node_neighbors[current] if j in unvisited]\n if shortest is None or len(cycle) < len(shortest):\n shortest = cycle\n\n assert shortest is not None\n return shortest\n\n\nif GUROBIPY_AVAILABLE:\n\n class GurobiTSPCallback:\n def __init__(self, nodes, x):\n self.nodes = nodes\n self.x = x\n\n def __call__(self, model, where):\n if where == GRB.Callback.MIPSOL:\n self.eliminate_subtours_gurobipy(model)\n\n def eliminate_subtours_gurobipy(self, model):\n values = model.cbGetSolution(self.x)\n edges = [(i, j) for (i, j), v in values.items() if v > 0.5]\n tour = shortest_subtour(edges)\n if len(tour) < len(self.nodes):\n # add subtour elimination constraint for every pair of cities in tour\n model.cbLazy(\n gp.quicksum(self.x[i, j] for i, j in combinations(tour, 2))\n <= len(tour) - 1\n )\n\n def solve_tsp_gurobipy(nodes, distances):\n \"\"\"\n Solve a dense symmetric TSP using the following base formulation:\n\n min sum_ij d_ij x_ij\n s.t. sum_j x_ij == 2 forall i in V\n x_ij binary forall (i,j) in E\n\n and subtours eliminated using lazy constraints.\n \"\"\"\n\n m = gp.Model()\n\n x = m.addVars(distances.keys(), obj=distances, vtype=GRB.BINARY, name=\"e\")\n x.update({(j, i): v for (i, j), v in x.items()})\n\n # Create degree 2 constraints\n for i in nodes:\n m.addConstr(gp.quicksum(x[i, j] for j in nodes if i != j) == 2)\n\n m.Params.OutputFlag = 0\n m.Params.LazyConstraints = 1\n cb = GurobiTSPCallback(nodes, x)\n m.optimize(cb)\n\n edges = [(i, j) for (i, j), v in x.items() if v.X > 0.5]\n tour = shortest_subtour(edges)\n assert set(tour) == set(nodes)\n\n return tour, m.ObjVal\n\n\nif COPTPY_AVAILABLE:\n\n class COPTTSPCallback(cp.CallbackBase):\n def __init__(self, nodes, x):\n super().__init__()\n self.nodes = nodes\n self.x = x\n\n def callback(self):\n if self.where() == COPT.CBCONTEXT_MIPSOL:\n self.eliminate_subtours_coptpy()\n\n def eliminate_subtours_coptpy(self):\n values = self.getSolution(self.x)\n edges = [(i, j) for (i, j), v in values.items() if v > 0.5]\n tour = shortest_subtour(edges)\n if len(tour) < len(self.nodes):\n # add subtour elimination constraint for every pair of cities in tour\n self.addLazyConstr(\n cp.quicksum(self.x[i, j] for i, j in combinations(tour, 2))\n <= len(tour) - 1\n )\n\n def solve_tsp_coptpy(nodes, distances):\n env = cp.Envr()\n m = env.createModel(\"TSP Callback Example\")\n\n x = m.addVars(distances.keys(), vtype=COPT.BINARY, nameprefix=\"e\")\n for (i, j), v in x.items():\n v.setInfo(COPT.Info.Obj, distances[i, j])\n for i, j in distances.keys():\n x[j, i] = x[i, j]\n\n # Create degree 2 constraints\n for i in nodes:\n m.addConstr(cp.quicksum(x[i, j] for j in nodes if i != j) == 2)\n\n m.Param.Logging = 0\n cb = COPTTSPCallback(nodes, x)\n m.setCallback(cb, COPT.CBCONTEXT_MIPSOL)\n m.solve()\n\n edges = [(i, j) for (i, j), v in x.items() if v.x > 0.5]\n tour = shortest_subtour(edges)\n assert set(tour) == set(nodes)\n\n return tour, m.objval\n\n\nif XPRESS_AVAILABLE:\n\n class XpressTSPCallback:\n def __init__(self, nodes, x):\n self.nodes = nodes\n self.x = x\n\n def __call__(self, prob, data, soltype, cutoff):\n \"\"\"\n Pre-integer solution callback: checks candidate solution and adds\n subtour elimination cuts.\n\n Args:\n soltype: Solution origin (0=B&B node, 1=heuristic, 2=user)\n cutoff: Current cutoff value\n\n Returns:\n (reject, new_cutoff): reject=1 to discard solution, new_cutoff\n to update solution cutoff value\n \"\"\"\n\n # Extract solution and identify active edges\n sol = prob.getCallbackSolution()\n edges = [(i, j) for i, j in self.x if sol[self.x[i, j].index] > 0.5]\n\n tour = shortest_subtour(edges)\n if len(tour) == len(self.nodes): # Complete tour\n return (0, None)\n\n if soltype != 0: # Can only add cuts at B&B nodes\n return (1, None)\n\n # Build and presolve SEC\n idxs = [self.x[i, j].index for i, j in combinations(tour, 2)]\n coeffs = [1.0] * len(idxs)\n rhs = len(tour) - 1\n\n idxs, coeffs, rhs, status = prob.presolveRow(\"L\", idxs, coeffs, rhs)\n if status < 0: # Presolve failed (dual reductions on?)\n return (1, None)\n\n # Add cut\n prob.addCuts([0], [\"L\"], [rhs], [0, len(idxs)], idxs, coeffs)\n return (0, None) # reject=1 would drop the node as well!\n\n def solve_tsp_xpress(nodes, distances):\n prob = xp.problem()\n\n x = prob.addVariables(distances.keys(), vartype=xp.binary, name=\"e\")\n prob.setObjective(xp.Sum(dist * x[i, j] for (i, j), dist in distances.items()))\n x.update({(j, i): v for (i, j), v in x.items()})\n\n # Create degree 2 constraints\n for i in nodes:\n prob.addConstraint(xp.Sum(x[i, j] for j in nodes if i != j) == 2)\n\n prob.controls.outputlog = 0\n prob.controls.mipdualreductions = 0\n cb = XpressTSPCallback(nodes, x)\n prob.addPreIntsolCallback(cb, None, 0)\n\n prob.optimize()\n\n edges = [(i, j) for (i, j), v in x.items() if prob.getSolution(v) > 0.5]\n tour = shortest_subtour(edges)\n assert set(tour) == set(nodes)\n return tour, prob.attributes.objval\n\n\nclass POITSPCallback:\n def __init__(self, nodes, x):\n self.nodes = nodes\n self.x = x\n\n def run_gurobi(self, model, where):\n if where == GRB.Callback.MIPSOL:\n self.eliminate_subtours_poi(model)\n\n def run_copt(self, model, where):\n if where == COPT.CBCONTEXT_MIPSOL:\n self.eliminate_subtours_poi(model)\n\n def run_xpress(self, model, where):\n if where == XPRS.CB_CONTEXT.PREINTSOL:\n self.eliminate_subtours_poi(model)\n\n def eliminate_subtours_poi(self, model):\n edges = []\n for (i, j), xij in self.x.items():\n v = model.cb_get_solution(xij)\n if v > 0.5:\n edges.append((i, j))\n tour = shortest_subtour(edges)\n if len(tour) < len(self.nodes):\n # add subtour elimination constraint for every pair of cities in tour\n model.cb_add_lazy_constraint(\n poi.quicksum(self.x[i, j] for i, j in combinations(tour, 2)),\n poi.Leq,\n len(tour) - 1,\n )\n\n\ndef solve_tsp_poi(f, nodes, distances):\n m = f()\n x = m.add_variables(distances.keys(), domain=poi.VariableDomain.Binary, name=\"e\")\n m.set_objective(poi.quicksum(distances[k] * x[k] for k in distances))\n for i, j in distances.keys():\n x[j, i] = x[i, j]\n\n for i in nodes:\n m.add_linear_constraint(\n poi.quicksum(x[i, j] for j in nodes if i != j), poi.Eq, 2\n )\n\n m.set_model_attribute(poi.ModelAttribute.Silent, True)\n cb = POITSPCallback(nodes, x)\n if isinstance(m, gurobi.Model):\n m.set_raw_parameter(\"LazyConstraints\", 1)\n m.set_callback(cb.run_gurobi)\n elif isinstance(m, copt.Model):\n m.set_callback(cb.run_copt, COPT.CBCONTEXT_MIPSOL)\n elif isinstance(m, xpress.Model):\n m.set_raw_control(\"XPRS_MIPDUALREDUCTIONS\", 0)\n m.set_callback(cb.run_xpress, XPRS.CB_CONTEXT.PREINTSOL)\n m.optimize()\n\n # Extract the solution as a tour\n edges = [(i, j) for (i, j), v in x.items() if m.get_value(v) > 0.5]\n tour = shortest_subtour(edges)\n assert set(tour) == set(nodes)\n\n objval = m.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n\n return tour, objval\n\n\ndef create_map(npoints, seed):\n # Create n random points in 2D\n random.seed(seed)\n nodes = list(range(npoints))\n points = [(random.randint(0, 100), random.randint(0, 100)) for i in nodes]\n\n # Dictionary of Euclidean distance between each pair of points\n distances = {\n (i, j): math.sqrt(sum((points[i][k] - points[j][k]) ** 2 for k in range(2)))\n for i, j in combinations(nodes, 2)\n }\n\n return nodes, distances\n\n\ndef test_gurobi(npoints_series, seed):\n for npoints in npoints_series:\n nodes, distances = create_map(npoints, seed)\n\n print(f\"npoints = {npoints}\")\n\n t0 = time.time()\n tour1, cost1 = solve_tsp_gurobipy(nodes, distances)\n t1 = time.time()\n print(f\"\\t gurobipy time: {t1 - t0:g} seconds\")\n\n t0 = time.time()\n f = gurobi.Model\n tour2, cost2 = solve_tsp_poi(f, nodes, distances)\n t1 = time.time()\n print(f\"\\t poi time: {t1 - t0:g} seconds\")\n\n assert tour1 == tour2\n assert abs(cost1 - cost2) < 1e-6\n\n\ndef test_copt(npoints_series, seed):\n for npoints in npoints_series:\n nodes, distances = create_map(npoints, seed)\n\n print(f\"npoints = {npoints}\")\n\n t0 = time.time()\n tour1, cost1 = solve_tsp_coptpy(nodes, distances)\n t1 = time.time()\n print(f\"\\t coptpy time: {t1 - t0:g} seconds\")\n\n t0 = time.time()\n f = copt.Model\n tour2, cost2 = solve_tsp_poi(f, nodes, distances)\n t1 = time.time()\n print(f\"\\t poi time: {t1 - t0:g} seconds\")\n\n assert tour1 == tour2\n assert abs(cost1 - cost2) < 1e-6\n\n\ndef test_xpress(npoints_series, seed):\n for npoints in npoints_series:\n nodes, distances = create_map(npoints, seed)\n\n print(f\"npoints = {npoints}\")\n\n t0 = time.time()\n tour1, cost1 = solve_tsp_xpress(nodes, distances)\n t1 = time.time()\n print(f\"\\t Xpress-Python cost: {cost1}, time: {t1 - t0:g} seconds\")\n\n t0 = time.time()\n f = xpress.Model\n tour2, cost2 = solve_tsp_poi(f, nodes, distances)\n t1 = time.time()\n print(f\"\\t PyOptInterface cost: {cost2}, time: {t1 - t0:g} seconds\")\n\n assert tour1 == tour2\n assert abs(cost1 - cost2) < 1e-6\n\n\nif __name__ == \"__main__\":\n seed = 987651234\n\n X = range(10, 90, 10)\n\n if copt.is_library_loaded():\n test_copt(X, seed)\n else:\n print(\"PyOptInterface did not find COPT.\")\n\n if gurobi.is_library_loaded():\n test_gurobi(X, seed)\n else:\n print(\"PyOptInterface did not find Gurobi.\")\n\n if xpress.is_library_loaded():\n test_xpress(X, seed)\n else:\n print(\"PyOptInterface did not find Xpress.\")\n" }, { "path": "tests/tsp_xpress.py", "content": "# TSP example using numpy functions (for efficiency)\n#\n# (C) Fair Isaac Corp., 1983-2025\n\nfrom typing import List, Tuple\nimport math\nimport random\nimport time\nfrom collections import defaultdict\nfrom itertools import combinations\n\nimport pyoptinterface as poi\nfrom pyoptinterface import xpress\n\nimport xpress as xp\nimport numpy as np\n\nXPRS = xpress.XPRS\n\n\ndef cb_preintsol(prob, data, soltype, cutoff):\n \"\"\"Callback for checking if solution is acceptable\"\"\"\n\n n = data\n xsol = prob.getCallbackSolution()\n xsolf = np.array(xsol)\n xsol = xsolf.reshape(n, n)\n nextc = np.argmax(xsol, axis=1)\n\n i = 0\n ncities = 1\n\n while nextc[i] != 0 and ncities < n:\n ncities += 1\n i = nextc[i]\n\n reject = False\n if ncities < n:\n if soltype != 0:\n reject = True\n else:\n unchecked = np.zeros(n)\n ngroup = 0\n\n cut_mstart = [0]\n cut_ind = []\n cut_coe = []\n cut_rhs = []\n\n nnz = 0\n ncuts = 0\n\n while np.min(unchecked) == 0 and ngroup <= n:\n \"\"\"Seek a tour\"\"\"\n\n ngroup += 1\n firstcity = np.argmin(unchecked)\n i = firstcity\n ncities = 0\n while True:\n unchecked[i] = ngroup\n ncities += 1\n i = nextc[i]\n\n if i == firstcity or ncities > n + 1:\n break\n\n S = np.where(unchecked == ngroup)[0].tolist()\n compS = np.where(unchecked != ngroup)[0].tolist()\n\n indices = [i * n + j for i in S for j in compS]\n\n if sum(xsolf[i] for i in indices) < 1 - 1e-3:\n mcolsp, dvalp = [], []\n\n drhsp, status = prob.presolverow(\n rowtype=\"G\",\n origcolind=indices,\n origrowcoef=np.ones(len(indices)),\n origrhs=1,\n maxcoefs=prob.attributes.cols,\n colind=mcolsp,\n rowcoef=dvalp,\n )\n assert status == 0\n\n nnz += len(mcolsp)\n ncuts += 1\n\n cut_ind.extend(mcolsp)\n cut_coe.extend(dvalp)\n cut_rhs.append(drhsp)\n cut_mstart.append(nnz)\n\n if ncuts > 0:\n prob.addcuts(\n cuttype=[0] * ncuts,\n rowtype=[\"G\"] * ncuts,\n rhs=cut_rhs,\n start=cut_mstart,\n colind=cut_ind,\n cutcoef=cut_coe,\n )\n\n return (reject, None)\n\n\ndef print_sol(p, n):\n \"\"\"Print the solution: order of nodes and cost\"\"\"\n\n xsol = np.array(p.getSolution()).reshape(n, n)\n nextc = np.argmax(xsol, axis=1)\n\n i = 0\n\n tour = []\n while i != 0 or len(tour) == 0:\n tour.append(str(i))\n i = nextc[i]\n print(\"->\".join(tour), \"->0; cost: \", p.attributes.objval, sep=\"\")\n\n\ndef create_initial_tour(n):\n \"\"\"Returns a permuted trivial solution 0->1->2->...->(n-1)->0\"\"\"\n sol = np.zeros((n, n))\n p = np.random.permutation(n)\n for i in range(n):\n sol[p[i], p[(i + 1) % n]] = 1\n return sol.flatten()\n\n\ndef solve_xpress(nodes, distances):\n n = len(nodes)\n nodes = range(n)\n p = xp.problem()\n p.controls.outputlog = 0\n\n fly = np.array(\n [\n p.addVariable(vartype=xp.binary, name=f\"x_{i}_{j}\")\n for i in nodes\n for j in nodes\n ],\n dtype=xp.npvar,\n ).reshape(n, n)\n\n # Outgoing constraints: sum of outgoing arcs from i equals 1\n for i in nodes:\n p.addConstraint(xp.Sum(fly[i, :]) - fly[i, i] == 1)\n\n # Incoming constraints: sum of incoming arcs to i equals 1\n for i in nodes:\n p.addConstraint(xp.Sum(fly[:, i]) - fly[i, i] == 1)\n\n # No self-loops\n for i in nodes:\n p.addConstraint(fly[i, i] == 0)\n\n p.setObjective(xp.Sum(fly[i, j] * distances[i, j] for i in nodes for j in nodes))\n p.addcbpreintsol(cb_preintsol, n)\n p.controls.mipdualreductions = 0\n\n for k in range(10):\n InitTour = create_initial_tour(n)\n p.addmipsol(solval=InitTour, name=f\"InitTour_{k}\")\n\n p.optimize()\n\n if p.attributes.solstatus not in [xp.SolStatus.OPTIMAL, xp.SolStatus.FEASIBLE]:\n print(\"Solve status:\", p.attributes.solvestatus.name)\n print(\"Solution status:\", p.attributes.solstatus.name)\n else:\n print_sol(p, n)\n\n xvals = np.array(p.getSolution()).reshape(n, n)\n edges = [(i, j) for i in nodes for j in nodes if xvals[i, j] > 0.5]\n print(edges)\n\n tour = shortest_subtour(edges)\n objval = p.attributes.objval\n\n return tour, objval\n\n\ndef shortest_subtour(edges: List[Tuple[int, int]]) -> List[int]:\n node_neighbors = defaultdict(list)\n for i, j in edges:\n node_neighbors[i].append(j)\n\n # Follow edges to find cycles. Each time a new cycle is found, keep track\n # of the shortest cycle found so far and restart from an unvisited node.\n unvisited = set(node_neighbors)\n shortest = None\n while unvisited:\n cycle = []\n neighbors = list(unvisited)\n while neighbors:\n current = neighbors.pop()\n cycle.append(current)\n unvisited.remove(current)\n neighbors = [j for j in node_neighbors[current] if j in unvisited]\n if shortest is None or len(cycle) < len(shortest):\n shortest = cycle\n\n assert shortest is not None\n return shortest\n\n\ndef solve_poi(f, nodes, distances):\n n = len(nodes)\n m = f()\n\n fly = np.array(\n [\n m.add_variable(name=f\"x_{i}_{j}\", domain=poi.VariableDomain.Binary)\n for i in nodes\n for j in nodes\n ],\n dtype=object, # Changed from xp.npvar\n ).reshape(n, n)\n\n # Outgoing constraints: sum of outgoing arcs from i equals 1\n for i in nodes:\n m.add_linear_constraint(poi.quicksum(fly[i, :]) - fly[i, i], poi.Eq, 1)\n\n # Incoming constraints: sum of incoming arcs to i equals 1\n for i in nodes:\n m.add_linear_constraint(poi.quicksum(fly[:, i]) - fly[i, i], poi.Eq, 1)\n\n # No self-loops\n for i in nodes:\n m.add_linear_constraint(fly[i, i], poi.Eq, 0)\n\n m.set_objective(\n poi.quicksum(fly[i, j] * distances[i, j] for i in nodes for j in nodes)\n )\n\n def eliminate_subtours_poi(model):\n edges = [\n (i, j)\n for (i, j), v in np.ndenumerate(fly)\n if model.cb_get_solution(v) > 0.5\n ]\n tour = shortest_subtour(edges)\n if len(tour) < len(nodes):\n print(\" Shortest subtour:\", tour)\n print(\n f\" Adding new cut with {len(tour)**2 - len(tour)} nonzeros.\"\n )\n model.cb_add_lazy_constraint(\n poi.quicksum(fly[i, j] + fly[j, i] for i, j in combinations(tour, 2)),\n poi.Leq,\n len(tour) - 1,\n )\n\n def cb(model, ctx):\n args = model.cb_get_arguments()\n if ctx == XPRS.CB_CONTEXT.MESSAGE and args.msgtype > 0:\n print(f\"{ctx.name:>16}: {args.msg}\")\n if ctx == XPRS.CB_CONTEXT.BARITERATION:\n print(\n f\"{ctx.name:>16}: Barrier iter {model.get_raw_attribute(\"XPRS_BARITER\")}, primal {model.get_raw_attribute(\"XPRS_BARPRIMALOBJ\")}, dual {model.get_raw_attribute(\"XPRS_BARDUALOBJ\")}, primal inf {model.get_raw_attribute(\"XPRS_BARPRIMALINF\")}, dual inf{model.get_raw_attribute(\"XPRS_BARDUALINF\")}, gap {model.get_raw_attribute(\"XPRS_BARCGAP\")}\"\n )\n if ctx == XPRS.CB_CONTEXT.BARLOG:\n print(\n f\"{ctx.name:>16}: Barrier iter {model.get_raw_attribute(\"XPRS_BARITER\")}, primal {model.get_raw_attribute(\"XPRS_BARPRIMALOBJ\")}, dual {model.get_raw_attribute(\"XPRS_BARDUALOBJ\")}, primal inf {model.get_raw_attribute(\"XPRS_BARPRIMALINF\")}, dual inf{model.get_raw_attribute(\"XPRS_BARDUALINF\")}, gap {model.get_raw_attribute(\"XPRS_BARCGAP\")}\"\n )\n if ctx == XPRS.CB_CONTEXT.AFTEROBJECTIVE:\n print(\n f\"{ctx.name:>16}: Completed obj solve {model.get_raw_attribute(\"XPRS_SOLVEDOBJS\")}\"\n )\n if ctx == XPRS.CB_CONTEXT.BEFOREOBJECTIVE:\n print(\n f\"{ctx.name:>16}: Starting obj solve {model.get_raw_attribute(\"XPRS_SOLVEDOBJS\")}\"\n )\n if ctx == XPRS.CB_CONTEXT.PRESOLVE:\n runtime = model.get_raw_attribute_dbl_by_id(XPRS.TIME)\n coldel = model.get_raw_attribute_int_by_id(\n XPRS.ORIGINALCOLS\n ) - model.get_raw_attribute_int_by_id(XPRS.COLS)\n rowdel = model.get_raw_attribute_int_by_id(\n XPRS.ORIGINALROWS\n ) - model.get_raw_attribute_int_by_id(XPRS.ROWS)\n print(\n f\"{ctx.name:>16}: Runtime: {runtime}, Coldel: {coldel}, Rowdel: {rowdel}\"\n )\n if ctx == XPRS.CB_CONTEXT.CHECKTIME:\n print(\n f\"{ctx.name:>16}: {model.get_raw_attribute(\"XPRS_TIME\")} seconds have passed.\"\n )\n if ctx == XPRS.CB_CONTEXT.CHGBRANCHOBJECT:\n print(f\"{ctx.name:>16}: Not a lot to print here at the moment\")\n if ctx == XPRS.CB_CONTEXT.CUTLOG:\n print(\n f\"{ctx.name:>16}: You should see the cutlog somewhere near this message.\"\n )\n if ctx == XPRS.CB_CONTEXT.CUTROUND:\n print(\n f\"{ctx.name:>16}: The optimizer would have done another cut round? {args.ifxpresscuts} - Forcing it.\"\n )\n args.p_action = 1\n if ctx == XPRS.CB_CONTEXT.DESTROYMT:\n print(f\"{ctx.name:>16}: Somewhere someone is killing a MIP Thread. RIP :(\")\n if ctx == XPRS.CB_CONTEXT.GAPNOTIFY:\n obj = model.get_raw_attribute_dbl_by_id(XPRS.MIPOBJVAL)\n bound = model.get_raw_attribute_dbl_by_id(XPRS.BESTBOUND)\n gap = 0\n if obj != 0 or bound != 0:\n gap = abs(obj - bound) / max(abs(obj), abs(bound))\n print(f\"{ctx.name:>16}: Current gap {gap}, next target set to {gap/2}\")\n if ctx == XPRS.CB_CONTEXT.MIPLOG:\n print(\n f\"{ctx.name:>16}: Node {model.get_raw_attribute(\"XPRS_CURRENTNODE\")} with depth {model.get_raw_attribute(\"XPRS_NODEDEPTH\")} has just been processed\"\n )\n if ctx == XPRS.CB_CONTEXT.INFNODE:\n print(\n f\"{ctx.name:>16}: Infeasible node id {model.get_raw_attribute(\"XPRS_CURRENTNODE\")}\"\n )\n if ctx == XPRS.CB_CONTEXT.INTSOL:\n print(\n f\"{ctx.name:>16}: Integer solution value: {model.get_raw_attribute(\"XPRS_MIPOBJVAL\")}\"\n )\n if ctx == XPRS.CB_CONTEXT.LPLOG:\n print(\n f\"{ctx.name:>16}: At iteration {model.get_raw_attribute(\"XPRS_SIMPLEXITER\")} objval is {model.get_raw_attribute(\"XPRS_LPOBJVAL\")}\"\n )\n if ctx == XPRS.CB_CONTEXT.NEWNODE:\n print(\n f\"{ctx.name:>16}: New node id {args.node}, parent node {args.parentnode}, branch {args.branch}\"\n )\n # if ctx == XPRS.CB_CONTEXT.MIPTHREAD:\n # print(f\"{ctx.name:>16}: Not a lot to print here at the moment\")\n if ctx == XPRS.CB_CONTEXT.NODECUTOFF:\n print(f\"{ctx.name:>16}: Node {args.node} cut off.\")\n if ctx == XPRS.CB_CONTEXT.NODELPSOLVED:\n obj = model.get_raw_attribute_dbl_by_id(XPRS.LPOBJVAL)\n print(\n f\"{ctx.name:>16}: Solved relaxation at node {model.get_raw_attribute(\"XPRS_CURRENTNODE\")}, lp obj {obj}\"\n )\n if ctx == XPRS.CB_CONTEXT.OPTNODE:\n obj = model.get_raw_attribute_dbl_by_id(XPRS.LPOBJVAL)\n print(\n f\"{ctx.name:>16}: Finished processing node {model.get_raw_attribute(\"XPRS_CURRENTNODE\")}, lp obj {obj}\"\n )\n if ctx == XPRS.CB_CONTEXT.PREINTSOL:\n print(\n f\"{ctx.name:>16}: Candidate integer solution objective {model.get_raw_attribute(\"LPOBJVAL\")}, soltype: {args.soltype}, p_reject: {args.p_reject}, p_cutoff: {args.p_cutoff}\"\n )\n eliminate_subtours_poi(model)\n if ctx == XPRS.CB_CONTEXT.PRENODE:\n print(f\"{ctx.name:>16}: Node optimization is about to start...\")\n if ctx == XPRS.CB_CONTEXT.USERSOLNOTIFY:\n print(\n f\"{ctx.name:>16}: Solution {args.solname} was processed resulting in status {args.status}.\"\n )\n\n m.set_callback(\n cb,\n XPRS.CB_CONTEXT.MESSAGE\n | XPRS.CB_CONTEXT.BARITERATION\n | XPRS.CB_CONTEXT.BARLOG\n | XPRS.CB_CONTEXT.AFTEROBJECTIVE\n | XPRS.CB_CONTEXT.BEFOREOBJECTIVE\n | XPRS.CB_CONTEXT.PRESOLVE\n | XPRS.CB_CONTEXT.CHECKTIME\n | XPRS.CB_CONTEXT.CHGBRANCHOBJECT\n | XPRS.CB_CONTEXT.CUTLOG\n | XPRS.CB_CONTEXT.CUTROUND\n | XPRS.CB_CONTEXT.DESTROYMT\n | XPRS.CB_CONTEXT.GAPNOTIFY\n | XPRS.CB_CONTEXT.MIPLOG\n | XPRS.CB_CONTEXT.INFNODE\n | XPRS.CB_CONTEXT.INTSOL\n | XPRS.CB_CONTEXT.LPLOG\n # |XPRS.CB_CONTEXT.MIPTHREAD\n | XPRS.CB_CONTEXT.NEWNODE\n | XPRS.CB_CONTEXT.NODECUTOFF\n | XPRS.CB_CONTEXT.NODELPSOLVED\n | XPRS.CB_CONTEXT.OPTNODE\n | XPRS.CB_CONTEXT.PREINTSOL\n | XPRS.CB_CONTEXT.PRENODE\n | XPRS.CB_CONTEXT.USERSOLNOTIFY,\n )\n m.set_raw_control_int_by_id(XPRS.CALLBACKCHECKTIMEDELAY, 10)\n m.set_raw_control_dbl_by_id(XPRS.MIPRELGAPNOTIFY, 1.0)\n m.set_raw_control(\"XPRS_MIPDUALREDUCTIONS\", 0)\n m.optimize()\n\n # Extract the solution as a tour\n edges = [(i, j) for (i, j), v in np.ndenumerate(fly) if m.get_value(v) > 0.5]\n tour = shortest_subtour(edges)\n\n objval = m.get_model_attribute(poi.ModelAttribute.ObjectiveValue)\n\n return tour, objval\n\n\ndef create_map(npoints, seed):\n # Create n random points in 2D\n random.seed(seed)\n nodes = list(range(npoints))\n points = [(random.randint(0, 100), random.randint(0, 100)) for _ in nodes]\n\n # Dictionary of Euclidean distance between each pair of points\n distances = {\n (i, j): math.sqrt(sum((points[i][k] - points[j][k]) ** 2 for k in range(2)))\n for i in nodes\n for j in nodes\n }\n return nodes, distances\n\n\ndef test_xpress(npoints_series, seed):\n for npoints in npoints_series:\n nodes, distances = create_map(npoints, seed)\n\n print(f\"npoints = {npoints}\")\n\n t0 = time.time()\n f = xpress.Model\n _, cost2 = solve_poi(f, nodes, distances)\n t1 = time.time()\n print(f\"\\t poi time: {t1 - t0:g} seconds\")\n print(f\"POI solution value: {cost2}\")\n\n t0 = time.time()\n _, cost1 = solve_xpress(nodes, distances)\n t1 = time.time()\n print(f\"\\t xpress time: {t1 - t0:g} seconds\")\n print(f\"Xpress solution value: {cost1}\")\n\n\nif __name__ == \"__main__\":\n seed = 987651234\n\n X = range(20, 10000, 10000)\n test_xpress(X, seed)\n" }, { "path": "thirdparty/ankerl/stl.h", "content": "///////////////////////// ankerl::unordered_dense::{map, set} /////////////////////////\n\n// A fast & densely stored hashmap and hashset based on robin-hood backward shift deletion.\n// Version 4.8.1\n// https://github.com/martinus/unordered_dense\n//\n// Licensed under the MIT License .\n// SPDX-License-Identifier: MIT\n// Copyright (c) 2022 Martin Leitner-Ankerl \n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\n#ifndef ANKERL_STL_H\n#define ANKERL_STL_H\n\n#include // for array\n#include // for uint64_t, uint32_t, std::uint8_t, UINT64_C\n#include // for size_t, memcpy, memset\n#include // for equal_to, hash\n#include // for initializer_list\n#include // for pair, distance\n#include // for numeric_limits\n#include // for allocator, allocator_traits, shared_ptr\n#include // for optional\n#include // for out_of_range\n#include // for basic_string\n#include // for basic_string_view, hash\n#include // for forward_as_tuple\n#include // for enable_if_t, declval, conditional_t, ena...\n#include // for forward, exchange, pair, as_const, piece...\n#include // for vector\n\n// includes , which fails to compile if\n// targeting GCC >= 13 with the (rewritten) win32 thread model, and\n// targeting Windows earlier than Vista (0x600). GCC predefines\n// _REENTRANT when using the 'posix' model, and doesn't when using the\n// 'win32' model.\n#if defined __MINGW64__ && defined __GNUC__ && __GNUC__ >= 13 && !defined _REENTRANT\n// _WIN32_WINNT is guaranteed to be defined here because of the\n// inclusion above.\n# ifndef _WIN32_WINNT\n# error \"_WIN32_WINNT not defined\"\n# endif\n# if _WIN32_WINNT < 0x600\n# define ANKERL_MEMORY_RESOURCE_IS_BAD() 1 // NOLINT(cppcoreguidelines-macro-usage)\n# endif\n#endif\n#ifndef ANKERL_MEMORY_RESOURCE_IS_BAD\n# define ANKERL_MEMORY_RESOURCE_IS_BAD() 0 // NOLINT(cppcoreguidelines-macro-usage)\n#endif\n\n#if defined(__has_include) && !defined(ANKERL_UNORDERED_DENSE_DISABLE_PMR)\n# if __has_include() && !ANKERL_MEMORY_RESOURCE_IS_BAD()\n# define ANKERL_UNORDERED_DENSE_PMR std::pmr // NOLINT(cppcoreguidelines-macro-usage)\n# include // for polymorphic_allocator\n# elif __has_include()\n# define ANKERL_UNORDERED_DENSE_PMR std::experimental::pmr // NOLINT(cppcoreguidelines-macro-usage)\n# include // for polymorphic_allocator\n# endif\n#endif\n\n#if defined(_MSC_VER) && defined(_M_X64)\n# include \n# pragma intrinsic(_umul128)\n#endif\n\n#endif\n" }, { "path": "thirdparty/ankerl/unordered_dense.h", "content": "///////////////////////// ankerl::unordered_dense::{map, set} /////////////////////////\n\n// A fast & densely stored hashmap and hashset based on robin-hood backward shift deletion.\n// Version 4.8.1\n// https://github.com/martinus/unordered_dense\n//\n// Licensed under the MIT License .\n// SPDX-License-Identifier: MIT\n// Copyright (c) 2022 Martin Leitner-Ankerl \n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\n#ifndef ANKERL_UNORDERED_DENSE_H\n#define ANKERL_UNORDERED_DENSE_H\n\n// see https://semver.org/spec/v2.0.0.html\n#define ANKERL_UNORDERED_DENSE_VERSION_MAJOR 4 // NOLINT(cppcoreguidelines-macro-usage) incompatible API changes\n#define ANKERL_UNORDERED_DENSE_VERSION_MINOR 8 // NOLINT(cppcoreguidelines-macro-usage) backwards compatible functionality\n#define ANKERL_UNORDERED_DENSE_VERSION_PATCH 1 // NOLINT(cppcoreguidelines-macro-usage) backwards compatible bug fixes\n\n// API versioning with inline namespace, see https://www.foonathan.net/2018/11/inline-namespaces/\n\n// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)\n#define ANKERL_UNORDERED_DENSE_VERSION_CONCAT1(major, minor, patch) v##major##_##minor##_##patch\n// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)\n#define ANKERL_UNORDERED_DENSE_VERSION_CONCAT(major, minor, patch) ANKERL_UNORDERED_DENSE_VERSION_CONCAT1(major, minor, patch)\n#define ANKERL_UNORDERED_DENSE_NAMESPACE \\\n ANKERL_UNORDERED_DENSE_VERSION_CONCAT( \\\n ANKERL_UNORDERED_DENSE_VERSION_MAJOR, ANKERL_UNORDERED_DENSE_VERSION_MINOR, ANKERL_UNORDERED_DENSE_VERSION_PATCH)\n\n#if defined(_MSVC_LANG)\n# define ANKERL_UNORDERED_DENSE_CPP_VERSION _MSVC_LANG\n#else\n# define ANKERL_UNORDERED_DENSE_CPP_VERSION __cplusplus\n#endif\n\n#if defined(__GNUC__)\n// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)\n# define ANKERL_UNORDERED_DENSE_PACK(decl) decl __attribute__((__packed__))\n#elif defined(_MSC_VER)\n// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)\n# define ANKERL_UNORDERED_DENSE_PACK(decl) __pragma(pack(push, 1)) decl __pragma(pack(pop))\n#endif\n\n// exceptions\n#if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)\n# define ANKERL_UNORDERED_DENSE_HAS_EXCEPTIONS() 1 // NOLINT(cppcoreguidelines-macro-usage)\n#else\n# define ANKERL_UNORDERED_DENSE_HAS_EXCEPTIONS() 0 // NOLINT(cppcoreguidelines-macro-usage)\n#endif\n#ifdef _MSC_VER\n# define ANKERL_UNORDERED_DENSE_NOINLINE __declspec(noinline)\n#else\n# define ANKERL_UNORDERED_DENSE_NOINLINE __attribute__((noinline))\n#endif\n\n#if defined(__clang__) && defined(__has_attribute)\n# if __has_attribute(__no_sanitize__)\n# define ANKERL_UNORDERED_DENSE_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK \\\n __attribute__((__no_sanitize__(\"unsigned-integer-overflow\")))\n# endif\n#endif\n\n#if !defined(ANKERL_UNORDERED_DENSE_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK)\n# define ANKERL_UNORDERED_DENSE_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK\n#endif\n\n#if ANKERL_UNORDERED_DENSE_CPP_VERSION < 201703L\n# error ankerl::unordered_dense requires C++17 or higher\n#else\n\n# if !defined(ANKERL_UNORDERED_DENSE_STD_MODULE)\n// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)\n# define ANKERL_UNORDERED_DENSE_STD_MODULE 0\n# endif\n\n# if !ANKERL_UNORDERED_DENSE_STD_MODULE\n# include \"stl.h\"\n# endif\n\n# if __has_cpp_attribute(likely) && __has_cpp_attribute(unlikely) && ANKERL_UNORDERED_DENSE_CPP_VERSION >= 202002L\n# define ANKERL_UNORDERED_DENSE_LIKELY_ATTR [[likely]] // NOLINT(cppcoreguidelines-macro-usage)\n# define ANKERL_UNORDERED_DENSE_UNLIKELY_ATTR [[unlikely]] // NOLINT(cppcoreguidelines-macro-usage)\n# define ANKERL_UNORDERED_DENSE_LIKELY(x) (x) // NOLINT(cppcoreguidelines-macro-usage)\n# define ANKERL_UNORDERED_DENSE_UNLIKELY(x) (x) // NOLINT(cppcoreguidelines-macro-usage)\n# else\n# define ANKERL_UNORDERED_DENSE_LIKELY_ATTR // NOLINT(cppcoreguidelines-macro-usage)\n# define ANKERL_UNORDERED_DENSE_UNLIKELY_ATTR // NOLINT(cppcoreguidelines-macro-usage)\n\n# if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)\n# define ANKERL_UNORDERED_DENSE_LIKELY(x) __builtin_expect(x, 1) // NOLINT(cppcoreguidelines-macro-usage)\n# define ANKERL_UNORDERED_DENSE_UNLIKELY(x) __builtin_expect(x, 0) // NOLINT(cppcoreguidelines-macro-usage)\n# else\n# define ANKERL_UNORDERED_DENSE_LIKELY(x) (x) // NOLINT(cppcoreguidelines-macro-usage)\n# define ANKERL_UNORDERED_DENSE_UNLIKELY(x) (x) // NOLINT(cppcoreguidelines-macro-usage)\n# endif\n\n# endif\n\nnamespace ankerl::unordered_dense {\ninline namespace ANKERL_UNORDERED_DENSE_NAMESPACE {\n\nnamespace detail {\n\n# if ANKERL_UNORDERED_DENSE_HAS_EXCEPTIONS()\n\n// make sure this is not inlined as it is slow and dramatically enlarges code, thus making other\n// inlinings more difficult. Throws are also generally the slow path.\n[[noreturn]] inline ANKERL_UNORDERED_DENSE_NOINLINE void on_error_key_not_found() {\n throw std::out_of_range(\"ankerl::unordered_dense::map::at(): key not found\");\n}\n[[noreturn]] inline ANKERL_UNORDERED_DENSE_NOINLINE void on_error_bucket_overflow() {\n throw std::overflow_error(\"ankerl::unordered_dense: reached max bucket size, cannot increase size\");\n}\n[[noreturn]] inline ANKERL_UNORDERED_DENSE_NOINLINE void on_error_too_many_elements() {\n throw std::out_of_range(\"ankerl::unordered_dense::map::replace(): too many elements\");\n}\n\n# else\n\n[[noreturn]] inline void on_error_key_not_found() {\n abort();\n}\n[[noreturn]] inline void on_error_bucket_overflow() {\n abort();\n}\n[[noreturn]] inline void on_error_too_many_elements() {\n abort();\n}\n\n# endif\n\n} // namespace detail\n\n// hash ///////////////////////////////////////////////////////////////////////\n\n// This is a stripped-down implementation of wyhash: https://github.com/wangyi-fudan/wyhash\n// No big-endian support (because different values on different machines don't matter),\n// hardcodes seed and the secret, reformats the code, and clang-tidy fixes.\nnamespace detail::wyhash {\n\ninline void mum(std::uint64_t* a, std::uint64_t* b) {\n# if defined(__SIZEOF_INT128__)\n __uint128_t r = *a;\n r *= *b;\n *a = static_cast(r);\n *b = static_cast(r >> 64U);\n# elif defined(_MSC_VER) && defined(_M_X64)\n *a = _umul128(*a, *b, b);\n# else\n std::uint64_t ha = *a >> 32U;\n std::uint64_t hb = *b >> 32U;\n std::uint64_t la = static_cast(*a);\n std::uint64_t lb = static_cast(*b);\n std::uint64_t hi{};\n std::uint64_t lo{};\n std::uint64_t rh = ha * hb;\n std::uint64_t rm0 = ha * lb;\n std::uint64_t rm1 = hb * la;\n std::uint64_t rl = la * lb;\n std::uint64_t t = rl + (rm0 << 32U);\n auto c = static_cast(t < rl);\n lo = t + (rm1 << 32U);\n c += static_cast(lo < t);\n hi = rh + (rm0 >> 32U) + (rm1 >> 32U) + c;\n *a = lo;\n *b = hi;\n# endif\n}\n\n// multiply and xor mix function, aka MUM\n[[nodiscard]] inline auto mix(std::uint64_t a, std::uint64_t b) -> std::uint64_t {\n mum(&a, &b);\n return a ^ b;\n}\n\n// read functions. WARNING: we don't care about endianness, so results are different on big endian!\n[[nodiscard]] inline auto r8(const std::uint8_t* p) -> std::uint64_t {\n std::uint64_t v{};\n std::memcpy(&v, p, 8U);\n return v;\n}\n\n[[nodiscard]] inline auto r4(const std::uint8_t* p) -> std::uint64_t {\n std::uint32_t v{};\n std::memcpy(&v, p, 4);\n return v;\n}\n\n// reads 1, 2, or 3 bytes\n[[nodiscard]] inline auto r3(const std::uint8_t* p, std::size_t k) -> std::uint64_t {\n return (static_cast(p[0]) << 16U) | (static_cast(p[k >> 1U]) << 8U) | p[k - 1];\n}\n\n[[maybe_unused]] [[nodiscard]] inline auto hash(void const* key, std::size_t len) -> std::uint64_t {\n static constexpr auto secret = std::array{UINT64_C(0xa0761d6478bd642f),\n UINT64_C(0xe7037ed1a0b428db),\n UINT64_C(0x8ebc6af09c88c6e3),\n UINT64_C(0x589965cc75374cc3)};\n\n auto const* p = static_cast(key);\n std::uint64_t seed = secret[0];\n std::uint64_t a{};\n std::uint64_t b{};\n if (ANKERL_UNORDERED_DENSE_LIKELY(len <= 16))\n ANKERL_UNORDERED_DENSE_LIKELY_ATTR {\n if (ANKERL_UNORDERED_DENSE_LIKELY(len >= 4))\n ANKERL_UNORDERED_DENSE_LIKELY_ATTR {\n a = (r4(p) << 32U) | r4(p + ((len >> 3U) << 2U));\n b = (r4(p + len - 4) << 32U) | r4(p + len - 4 - ((len >> 3U) << 2U));\n }\n else if (ANKERL_UNORDERED_DENSE_LIKELY(len > 0))\n ANKERL_UNORDERED_DENSE_LIKELY_ATTR {\n a = r3(p, len);\n b = 0;\n }\n else {\n a = 0;\n b = 0;\n }\n }\n else {\n std::size_t i = len;\n if (ANKERL_UNORDERED_DENSE_UNLIKELY(i > 48))\n ANKERL_UNORDERED_DENSE_UNLIKELY_ATTR {\n std::uint64_t see1 = seed;\n std::uint64_t see2 = seed;\n do {\n seed = mix(r8(p) ^ secret[1], r8(p + 8) ^ seed);\n see1 = mix(r8(p + 16) ^ secret[2], r8(p + 24) ^ see1);\n see2 = mix(r8(p + 32) ^ secret[3], r8(p + 40) ^ see2);\n p += 48;\n i -= 48;\n } while (ANKERL_UNORDERED_DENSE_LIKELY(i > 48));\n seed ^= see1 ^ see2;\n }\n while (ANKERL_UNORDERED_DENSE_UNLIKELY(i > 16))\n ANKERL_UNORDERED_DENSE_UNLIKELY_ATTR {\n seed = mix(r8(p) ^ secret[1], r8(p + 8) ^ seed);\n i -= 16;\n p += 16;\n }\n a = r8(p + i - 16);\n b = r8(p + i - 8);\n }\n\n return mix(secret[1] ^ len, mix(a ^ secret[1], b ^ seed));\n}\n\n[[nodiscard]] inline auto hash(std::uint64_t x) -> std::uint64_t {\n return detail::wyhash::mix(x, UINT64_C(0x9E3779B97F4A7C15));\n}\n\n} // namespace detail::wyhash\n\ntemplate \nstruct hash {\n auto operator()(T const& obj) const noexcept(noexcept(std::declval>().operator()(std::declval())))\n -> std::uint64_t {\n return std::hash{}(obj);\n }\n};\n\ntemplate \nstruct hash::is_avalanching> {\n using is_avalanching = void;\n auto operator()(T const& obj) const noexcept(noexcept(std::declval>().operator()(std::declval())))\n -> std::uint64_t {\n return std::hash{}(obj);\n }\n};\n\ntemplate \nstruct hash> {\n using is_avalanching = void;\n auto operator()(std::basic_string const& str) const noexcept -> std::uint64_t {\n return detail::wyhash::hash(str.data(), sizeof(CharT) * str.size());\n }\n};\n\ntemplate \nstruct hash> {\n using is_avalanching = void;\n auto operator()(std::basic_string_view const& sv) const noexcept -> std::uint64_t {\n return detail::wyhash::hash(sv.data(), sizeof(CharT) * sv.size());\n }\n};\n\ntemplate \nstruct hash {\n using is_avalanching = void;\n auto operator()(T* ptr) const noexcept -> std::uint64_t {\n // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)\n return detail::wyhash::hash(reinterpret_cast(ptr));\n }\n};\n\ntemplate \nstruct hash> {\n using is_avalanching = void;\n auto operator()(std::unique_ptr const& ptr) const noexcept -> std::uint64_t {\n // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)\n return detail::wyhash::hash(reinterpret_cast(ptr.get()));\n }\n};\n\ntemplate \nstruct hash> {\n using is_avalanching = void;\n auto operator()(std::shared_ptr const& ptr) const noexcept -> std::uint64_t {\n // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)\n return detail::wyhash::hash(reinterpret_cast(ptr.get()));\n }\n};\n\ntemplate \nstruct hash>> {\n using is_avalanching = void;\n auto operator()(Enum e) const noexcept -> std::uint64_t {\n using underlying = std::underlying_type_t;\n return detail::wyhash::hash(static_cast(e));\n }\n};\n\ntemplate \nstruct tuple_hash_helper {\n // Converts the value into 64bit. If it is an integral type, just cast it. Mixing is doing the rest.\n // If it isn't an integral we need to hash it.\n template \n [[nodiscard]] constexpr static auto to64(Arg const& arg) -> std::uint64_t {\n if constexpr (std::is_integral_v || std::is_enum_v) {\n return static_cast(arg);\n } else {\n return hash{}(arg);\n }\n }\n\n [[nodiscard]] ANKERL_UNORDERED_DENSE_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK static auto mix64(std::uint64_t state,\n std::uint64_t v)\n -> std::uint64_t {\n return detail::wyhash::mix(state + v, std::uint64_t{0x9ddfea08eb382d69});\n }\n\n // Creates a buffer that holds all the data from each element of the tuple. If possible we memcpy the data directly. If\n // not, we hash the object and use this for the array. Size of the array is known at compile time, and memcpy is optimized\n // away, so filling the buffer is highly efficient. Finally, call wyhash with this buffer.\n template \n [[nodiscard]] static auto calc_hash(T const& t, std::index_sequence /*unused*/) noexcept -> std::uint64_t {\n auto h = std::uint64_t{};\n ((h = mix64(h, to64(std::get(t)))), ...);\n return h;\n }\n};\n\ntemplate \nstruct hash> : tuple_hash_helper {\n using is_avalanching = void;\n auto operator()(std::tuple const& t) const noexcept -> std::uint64_t {\n return tuple_hash_helper::calc_hash(t, std::index_sequence_for{});\n }\n};\n\ntemplate \nstruct hash> : tuple_hash_helper {\n using is_avalanching = void;\n auto operator()(std::pair const& t) const noexcept -> std::uint64_t {\n return tuple_hash_helper::calc_hash(t, std::index_sequence_for{});\n }\n};\n\n// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)\n# define ANKERL_UNORDERED_DENSE_HASH_STATICCAST(T) \\\n template <> \\\n struct hash { \\\n using is_avalanching = void; \\\n auto operator()(T const& obj) const noexcept -> std::uint64_t { \\\n return detail::wyhash::hash(static_cast(obj)); \\\n } \\\n }\n\n# if defined(__GNUC__) && !defined(__clang__)\n# pragma GCC diagnostic push\n# pragma GCC diagnostic ignored \"-Wuseless-cast\"\n# endif\n// see https://en.cppreference.com/w/cpp/utility/hash\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(bool);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(char);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(signed char);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(unsigned char);\n# if ANKERL_UNORDERED_DENSE_CPP_VERSION >= 202002L && defined(__cpp_char8_t)\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(char8_t);\n# endif\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(char16_t);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(char32_t);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(wchar_t);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(short);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(unsigned short);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(int);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(unsigned int);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(long);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(long long);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(unsigned long);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(unsigned long long);\n\n# if defined(__GNUC__) && !defined(__clang__)\n# pragma GCC diagnostic pop\n# endif\n\n// bucket_type //////////////////////////////////////////////////////////\n\nnamespace bucket_type {\n\nstruct standard {\n static constexpr std::uint32_t dist_inc = 1U << 8U; // skip 1 byte fingerprint\n static constexpr std::uint32_t fingerprint_mask = dist_inc - 1; // mask for 1 byte of fingerprint\n\n std::uint32_t m_dist_and_fingerprint; // upper 3 byte: distance to original bucket. lower byte: fingerprint from hash\n std::uint32_t m_value_idx; // index into the m_values vector.\n};\n\nANKERL_UNORDERED_DENSE_PACK(struct big {\n static constexpr std::uint32_t dist_inc = 1U << 8U; // skip 1 byte fingerprint\n static constexpr std::uint32_t fingerprint_mask = dist_inc - 1; // mask for 1 byte of fingerprint\n\n std::uint32_t m_dist_and_fingerprint; // upper 3 byte: distance to original bucket. lower byte: fingerprint from hash\n std::size_t m_value_idx; // index into the m_values vector.\n});\n\n} // namespace bucket_type\n\nnamespace detail {\n\nstruct nonesuch {};\nstruct default_container_t {};\n\ntemplate class Op, class... Args>\nstruct detector {\n using value_t = std::false_type;\n using type = Default;\n};\n\ntemplate class Op, class... Args>\nstruct detector>, Op, Args...> {\n using value_t = std::true_type;\n using type = Op;\n};\n\ntemplate