diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml index b689bcd39..91d479b6b 100644 --- a/.github/workflows/build.yaml +++ b/.github/workflows/build.yaml @@ -267,6 +267,42 @@ jobs: artifact-name: "cuopt_docs" container_image: "rapidsai/ci-conda:26.06-latest" script: "ci/build_docs.sh" + java-build: + # Build cuopt-java JAR (amd64) for main / release-branch / tag pushes. + # Integration tests are not run here — they live in test.yaml. + needs: [cpp-build] + secrets: inherit # zizmor: ignore[secrets-inherit] + uses: rapidsai/shared-workflows/.github/workflows/custom-job.yaml@main + with: + build_type: ${{ inputs.build_type || 'branch' }} + node_type: "linux-amd64-cpu16" + sha: ${{ inputs.sha }} + branch: ${{ inputs.branch }} + date: ${{ inputs.date }} + arch: "amd64" + file_to_upload: "java/cuopt-java/target/" + artifact-name: "cuopt-java" + container_image: "rapidsai/ci-conda:26.06-latest" + script: "ci/build_java.sh" + java-build-arm64: + # Build cuopt-java JAR (arm64) for main / release-branch / tag pushes. + # Build-only (no IT) — matches the amd64 java-build sibling. PR + # integration tests run on the conda-java-build-and-tests-arm64 + # GPU job in pr.yaml. + needs: [cpp-build] + secrets: inherit # zizmor: ignore[secrets-inherit] + uses: rapidsai/shared-workflows/.github/workflows/custom-job.yaml@main + with: + build_type: ${{ inputs.build_type || 'branch' }} + node_type: "linux-arm64-cpu16" + sha: ${{ inputs.sha }} + branch: ${{ inputs.branch }} + date: ${{ inputs.date }} + arch: "arm64" + file_to_upload: "java/cuopt-java/target/" + artifact-name: "cuopt-java-arm64" + container_image: "rapidsai/ci-conda:26.06-latest" + script: "ci/build_java.sh" wheel-build-cuopt-sh-client: permissions: actions: read diff --git a/.github/workflows/pr.yaml b/.github/workflows/pr.yaml index 1f38fb6cb..d558f55f8 100644 --- a/.github/workflows/pr.yaml +++ b/.github/workflows/pr.yaml @@ -24,6 +24,10 @@ jobs: - checks - conda-cpp-build - conda-cpp-tests + - conda-java-build-and-tests-matrix + - conda-java-build-and-tests + - conda-java-build-and-tests-arm64-matrix + - conda-java-build-and-tests-arm64 - conda-python-build - conda-python-tests - docs-build @@ -418,6 +422,82 @@ jobs: script-env-secret-2-value: ${{ secrets.CUOPT_AWS_ACCESS_KEY_ID }} script-env-secret-3-key: CUOPT_AWS_SECRET_ACCESS_KEY script-env-secret-3-value: ${{ secrets.CUOPT_AWS_SECRET_ACCESS_KEY }} + conda-java-build-and-tests-matrix: + # Derives the matrix from conda-cpp-build, filtered to amd64. The arm64 + # sibling job conda-java-build-and-tests-arm64 handles arm64. + needs: [conda-cpp-build, changed-files] + if: fromJSON(needs.changed-files.outputs.changed_file_groups).test_java + permissions: + actions: read + contents: read + id-token: write + packages: read + pull-requests: read + uses: rapidsai/shared-workflows/.github/workflows/compute-matrix.yaml@cuda-13.2.0 + with: + build_type: pull-request + matrix_name: conda-cpp-build + matrix_filter: 'map(select(.ARCH == "amd64"))' + conda-java-build-and-tests: + # Combined build+test in one job (matches cuvs pattern). Splitting + # this is a follow-up: requires shared-workflow surface for cross-job + # artifact passing. cuvs Issue #868 tracks the same split. + needs: conda-java-build-and-tests-matrix + if: fromJSON(needs.changed-files.outputs.changed_file_groups).test_java + permissions: + actions: read + contents: read + id-token: write + packages: read + pull-requests: read + secrets: inherit # zizmor: ignore[secrets-inherit] + uses: rapidsai/shared-workflows/.github/workflows/custom-job.yaml@cuda-13.2.0 + with: + build_type: pull-request + node_type: "gpu-l4-latest-1" + arch: "amd64" + script: "ci/test_java.sh" + file_to_upload: "java/cuopt-java/target/" + artifact-name: "cuopt-java-cuda${{ needs.conda-java-build-and-tests-matrix.outputs.CUDA_VER }}" + conda-java-build-and-tests-arm64-matrix: + # Matrix for the arm64 Java build+tests, filtered to arm64 rows of + # conda-cpp-build. Sibling of conda-java-build-and-tests-matrix + # which handles amd64. + needs: [conda-cpp-build, changed-files] + if: fromJSON(needs.changed-files.outputs.changed_file_groups).test_java + permissions: + actions: read + contents: read + id-token: write + packages: read + pull-requests: read + uses: rapidsai/shared-workflows/.github/workflows/compute-matrix.yaml@cuda-13.2.0 + with: + build_type: pull-request + matrix_name: conda-cpp-build + matrix_filter: 'map(select(.ARCH == "arm64"))' + conda-java-build-and-tests-arm64: + # Build the JAR + run unit + integration tests on arm64 GPU. Mirrors + # conda-java-build-and-tests (amd64). custom-job.yaml resolves + # runs-on to "linux-${arch}-${node_type}", so node_type is the + # suffix only (same as the amd64 sibling above). + needs: conda-java-build-and-tests-arm64-matrix + if: fromJSON(needs.changed-files.outputs.changed_file_groups).test_java + permissions: + actions: read + contents: read + id-token: write + packages: read + pull-requests: read + secrets: inherit # zizmor: ignore[secrets-inherit] + uses: rapidsai/shared-workflows/.github/workflows/custom-job.yaml@cuda-13.2.0 + with: + build_type: pull-request + node_type: "gpu-l4-latest-1" + arch: "arm64" + script: "ci/test_java.sh" + file_to_upload: "java/cuopt-java/target/" + artifact-name: "cuopt-java-arm64-cuda${{ needs.conda-java-build-and-tests-arm64-matrix.outputs.CUDA_VER }}" conda-python-build: needs: [conda-cpp-build, compute-matrix-filters, changed-files] # Consumed by conda-python-tests and docs-build. diff --git a/ci/build_java.sh b/ci/build_java.sh new file mode 100755 index 000000000..92acaa376 --- /dev/null +++ b/ci/build_java.sh @@ -0,0 +1,102 @@ +#!/bin/bash +# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +# Build cuopt-java in CI. +# +# Usage: +# ci/build_java.sh # build only, skip tests +# ci/build_java.sh --run-java-tests # build + unit + integration tests (GPU required) +# ci/build_java.sh --unit-tests-only # build + unit tests, skip IT (no GPU available) +# +# Inputs (set by RAPIDS shared workflow): +# RAPIDS_CUDA_VERSION +# +# Outputs: +# java/cuopt-java/target/cuopt-java-*.jar (uploaded by the calling +# workflow via artifact-name) + +set -euo pipefail + +EXITCODE=0 +trap "EXITCODE=1" ERR +set +e + +# Argument handling — match cuvs build_java.sh contract +RUN_JAVA_TESTS="false" +UNIT_TESTS_ONLY="false" +case "${1:-}" in + --run-java-tests) RUN_JAVA_TESTS="true" ;; + --unit-tests-only) UNIT_TESTS_ONLY="true" ;; +esac + +source rapids-configure-sccache + +. /opt/conda/etc/profile.d/conda.sh + +rapids-logger "Configuring conda strict channel priority" +conda config --set channel_priority strict + +# Pull libcuopt conda package built by upstream conda-cpp-build job. +# libcuopt.so + cuopt_c.h + constants.h end up in $CPP_CHANNEL. +CPP_CHANNEL=$(rapids-download-conda-from-github cpp) + +rapids-logger "Generate Java conda environment" +rapids-dependency-file-generator \ + --output conda \ + --file-key test_java \ + --matrix "cuda=${RAPIDS_CUDA_VERSION%.*};arch=$(arch)" \ + --prepend-channel "${CPP_CHANNEL}" \ + | tee env.yaml + +rapids-mamba-retry env create --yes -f env.yaml -n java + +set +u +conda activate java +set -u + +rapids-logger "Build cuopt-java (run_tests=${RUN_JAVA_TESTS})" + +# Point the Java build at the conda prefix where libcuopt lives. +export CUOPT_INCLUDE="${CONDA_PREFIX}/include" +export CMAKE_PREFIX_PATH="${CONDA_PREFIX}/lib" + +# Produce the per-(arch, cuda) classifier JAR alongside the base JAR +# on every CI run. The classifier JAR bundles libcuopt.so + libmps_parser.so +# + librmm.so + librapids_logger.so and carries the manifest entry +# Embedded-Libraries-Cuda-Version. Matches cuvs's java/build.sh behavior +# of always activating the build profile (cuvs sets -P $arch-cuda$major). +export CLASSIFIER_CUDA="${RAPIDS_CUDA_VERSION%%.*}" + +# In CI there is no local cpp/build directory; libcuopt.so + libmps_parser.so +# come from the conda env populated by rapids-download-conda-from-github. +# Tell the maven classifier-jar profile to pull them from $CONDA_PREFIX/lib. +export NATIVE_CPP_BUILD_PATH="${CONDA_PREFIX}/lib" + +# jextract is auto-downloaded by panama-bindings/generate-bindings.sh on +# first run (cuvs pattern). No CI image change required. +# +# SKIP_DRIFT_CHECK=true in CI because the CI build uses conda's headers +# ($CONDA_PREFIX/include) while dev uses repo headers (cpp/include); +# minor formatting differences between the two sources would falsely +# trip the drift gate. The dev-workstation gate (./java/build.sh +# without this flag) is the authoritative one. +# SKIP_BINDINGS_REGEN=true because the conda env used in CI does not +# install CUDA development headers (only libcuopt + openjdk + maven), +# so jextract cannot regenerate the panama bindings from cuopt_c.h. +# The committed bindings are trusted; the dev-workstation drift gate +# in ./java/build.sh (run without SKIP_DRIFT_CHECK locally) is the +# authoritative check that they stay in sync. +if [[ "${RUN_JAVA_TESTS}" == "true" ]]; then + SKIP_DRIFT_CHECK=true SKIP_BINDINGS_REGEN=true ./java/build.sh +elif [[ "${UNIT_TESTS_ONLY}" == "true" ]]; then + SKIP_DRIFT_CHECK=true SKIP_BINDINGS_REGEN=true UNIT_TESTS_ONLY=true ./java/build.sh +else + SKIP_DRIFT_CHECK=true SKIP_BINDINGS_REGEN=true SKIP_TESTS=true ./java/build.sh +fi + +rapids-logger "Show sccache stats" +sccache --show-adv-stats || true + +rapids-logger "Build script exiting with value: $EXITCODE" +exit ${EXITCODE} diff --git a/ci/test_java.sh b/ci/test_java.sh new file mode 100755 index 000000000..6c6874fb9 --- /dev/null +++ b/ci/test_java.sh @@ -0,0 +1,31 @@ +#!/bin/bash +# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +# Run cuopt-java tests in CI. +# +# Currently a thin wrapper that delegates to ci/build_java.sh with the +# --run-java-tests flag (matches cuvs's pattern). The build/test split +# tracked in cuvs Issue #868 is a deferred follow-up — switching to +# pre-built artifact consumption requires shared-workflow surface area +# for cross-job artifact download that doesn't exist yet. + +set -euo pipefail + +EXITCODE=0 +trap "EXITCODE=1" ERR +set +e + +rapids-logger "Check GPU usage" +nvidia-smi + +rapids-logger "Run Java build and tests" + +# TODO(java-build-test-split): switch to consuming a prebuilt JAR from +# conda-java-build job. Requires custom-job.yaml to expose artifact +# download or use of actions/download-artifact in this script. +# Ref: cuvs Issue rapidsai/cuvs#868 +ci/build_java.sh --run-java-tests + +rapids-logger "Test script exiting with value: $EXITCODE" +exit ${EXITCODE} diff --git a/conda/environments/all_cuda-129_arch-aarch64.yaml b/conda/environments/all_cuda-129_arch-aarch64.yaml index 145850d4d..be6b6ff29 100644 --- a/conda/environments/all_cuda-129_arch-aarch64.yaml +++ b/conda/environments/all_cuda-129_arch-aarch64.yaml @@ -14,6 +14,7 @@ dependencies: - clang==20.1.8 - cmake>=4.0 - cpp-argparse +- cuda-cudart - cuda-nvcc - cuda-nvtx-dev - cuda-python>=12.9.2,<13.0 @@ -30,15 +31,20 @@ dependencies: - jsonref==1.1.0 - libabseil - libboost-devel +- libcublas +- libcudss - libcudss-dev >=0.7 - libcurand-dev - libcusolver-dev +- libcusparse - libcusparse-dev - libgrpc >=1.78.0,<1.80.0a0 +- libnvjitlink - libprotobuf - libraft-headers==26.6.*,>=0.0.0a0 - librmm==26.6.*,>=0.0.0a0 - make +- maven>=3.9.6 - msgpack-numpy==0.4.8 - msgpack-python==1.1.2 - myst-parser @@ -48,6 +54,7 @@ dependencies: - numba>=0.60.0,<0.65.0 - numpy>=1.23.5,<3.0 - numpydoc +- openjdk=22.* - openssl - pandas>=2.0 - pexpect diff --git a/conda/environments/all_cuda-129_arch-x86_64.yaml b/conda/environments/all_cuda-129_arch-x86_64.yaml index 293b49fbe..c7b58d645 100644 --- a/conda/environments/all_cuda-129_arch-x86_64.yaml +++ b/conda/environments/all_cuda-129_arch-x86_64.yaml @@ -14,6 +14,7 @@ dependencies: - clang==20.1.8 - cmake>=4.0 - cpp-argparse +- cuda-cudart - cuda-nvcc - cuda-nvtx-dev - cuda-python>=12.9.2,<13.0 @@ -30,15 +31,20 @@ dependencies: - jsonref==1.1.0 - libabseil - libboost-devel +- libcublas +- libcudss - libcudss-dev >=0.7 - libcurand-dev - libcusolver-dev +- libcusparse - libcusparse-dev - libgrpc >=1.78.0,<1.80.0a0 +- libnvjitlink - libprotobuf - libraft-headers==26.6.*,>=0.0.0a0 - librmm==26.6.*,>=0.0.0a0 - make +- maven>=3.9.6 - msgpack-numpy==0.4.8 - msgpack-python==1.1.2 - myst-parser @@ -48,6 +54,7 @@ dependencies: - numba>=0.60.0,<0.65.0 - numpy>=1.23.5,<3.0 - numpydoc +- openjdk=22.* - openssl - pandas>=2.0 - pexpect diff --git a/conda/environments/all_cuda-132_arch-aarch64.yaml b/conda/environments/all_cuda-132_arch-aarch64.yaml index fa8844a1f..7b6bfc169 100644 --- a/conda/environments/all_cuda-132_arch-aarch64.yaml +++ b/conda/environments/all_cuda-132_arch-aarch64.yaml @@ -14,6 +14,7 @@ dependencies: - clang==20.1.8 - cmake>=4.0 - cpp-argparse +- cuda-cudart - cuda-nvcc - cuda-nvtx-dev - cuda-python>=13.0.1,<14.0 @@ -30,15 +31,20 @@ dependencies: - jsonref==1.1.0 - libabseil - libboost-devel +- libcublas +- libcudss - libcudss-dev >=0.7 - libcurand-dev - libcusolver-dev +- libcusparse - libcusparse-dev - libgrpc >=1.78.0,<1.80.0a0 +- libnvjitlink - libprotobuf - libraft-headers==26.6.*,>=0.0.0a0 - librmm==26.6.*,>=0.0.0a0 - make +- maven>=3.9.6 - msgpack-numpy==0.4.8 - msgpack-python==1.1.2 - myst-parser @@ -48,6 +54,7 @@ dependencies: - numba>=0.60.0,<0.65.0 - numpy>=1.23.5,<3.0 - numpydoc +- openjdk=22.* - openssl - pandas>=2.0 - pexpect diff --git a/conda/environments/all_cuda-132_arch-x86_64.yaml b/conda/environments/all_cuda-132_arch-x86_64.yaml index a37d8718c..0e77939e7 100644 --- a/conda/environments/all_cuda-132_arch-x86_64.yaml +++ b/conda/environments/all_cuda-132_arch-x86_64.yaml @@ -14,6 +14,7 @@ dependencies: - clang==20.1.8 - cmake>=4.0 - cpp-argparse +- cuda-cudart - cuda-nvcc - cuda-nvtx-dev - cuda-python>=13.0.1,<14.0 @@ -30,15 +31,20 @@ dependencies: - jsonref==1.1.0 - libabseil - libboost-devel +- libcublas +- libcudss - libcudss-dev >=0.7 - libcurand-dev - libcusolver-dev +- libcusparse - libcusparse-dev - libgrpc >=1.78.0,<1.80.0a0 +- libnvjitlink - libprotobuf - libraft-headers==26.6.*,>=0.0.0a0 - librmm==26.6.*,>=0.0.0a0 - make +- maven>=3.9.6 - msgpack-numpy==0.4.8 - msgpack-python==1.1.2 - myst-parser @@ -48,6 +54,7 @@ dependencies: - numba>=0.60.0,<0.65.0 - numpy>=1.23.5,<3.0 - numpydoc +- openjdk=22.* - openssl - pandas>=2.0 - pexpect diff --git a/dependencies.yaml b/dependencies.yaml index 1601058cf..e6468bb8d 100644 --- a/dependencies.yaml +++ b/dependencies.yaml @@ -37,6 +37,7 @@ files: - depends_on_rapids_logger - depends_on_rmm - rapids_build_backend + - java test_cpp: output: none includes: @@ -45,6 +46,12 @@ files: - test_cpp - test_cpp_cuopt - depends_on_libcuopt + test_java: + output: none + includes: + - cuda_version + - java + - depends_on_libcuopt test_python: output: none includes: @@ -313,6 +320,31 @@ dependencies: - output_types: [conda] packages: - cuda-sanitizer-api + java: + common: + - output_types: [conda] + packages: + # Java 22 is the minimum for FFM final (no preview flag). + # Public API compiles to Java 21 release; runtime requires Java 22+. + # See java/README.md for the full multi-release-JAR rationale. + - openjdk=22.* + - maven>=3.9.6 + # jextract is not on conda-forge. java/panama-bindings/ + # generate-bindings.sh auto-downloads it (cuvs pattern). For + # CI to be hermetic, consider preinstalling jextract in the + # ci-conda image; for now, the build pulls it on first run. + # + # libcuopt's conda recipe omits CUDA runtime libs from its + # `run:` deps (host-only). Python tests pick them up + # transitively via cudf/cupy/cuda-python; Java tests have no + # such chain, so we declare them explicitly here. Matches the + # ldd of libcuopt.so: libcublas, libcusparse, libcudart, + # libcudss, libnvjitlink (libcublasLt ships with libcublas). + - cuda-cudart + - libcublas + - libcudss + - libcusparse + - libnvjitlink test_cpp_cuopt: common: - output_types: [conda] diff --git a/java/.gitignore b/java/.gitignore new file mode 100644 index 000000000..2b0a43176 --- /dev/null +++ b/java/.gitignore @@ -0,0 +1,27 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +# Maven build output +target/ +*.class +.mvn/ + +# IDE +.idea/ +*.iml +.classpath +.project +.settings/ +.factorypath +.vscode/ + +# Logs +*.log + +# OS +.DS_Store +Thumbs.db + +# NOTE: panama bindings under +# cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama/ +# ARE committed (cuvs convention) — the drift gate in build.sh enforces this. diff --git a/java/README.md b/java/README.md new file mode 100644 index 000000000..0a4570400 --- /dev/null +++ b/java/README.md @@ -0,0 +1,135 @@ +# cuopt-java + +Java interface to NVIDIA cuOpt for Linear Programming (LP), Mixed-Integer +Linear Programming (MILP), and Quadratic Programming (QP). + +This directory contains the source for the `com.nvidia.cuopt:cuopt-java` +Maven artifact. + +## Status + +This is the initial skeleton. The first end-to-end demo (`Solver.getVersion()`) +proves the FFM bridge from Java to `libcuopt.so` works. The full LP / MILP / QP +public API will land in subsequent PRs. + +## Architecture (5 layers) + +``` +Layer 5 Public API (Java 21) src/main/java/com/nvidia/cuopt/ + ▼ ServiceLoader / SPI +Layer 4 CuOptProvider (sealed) src/main/java/.../spi/ + ▼ resolved to java22 impl on Java 22+ JVMs +Layer 3 FFM Implementation src/main/java22/.../internal/ + (Java 22) Owns Arena.ofConfined(), MemorySegment + ▼ +Layer 2 Panama Bindings src/main/java22/.../internal/panama/ + (jextract output) Generated; never edited by hand + ▼ MethodHandle.invokeExact (no JNI) +Layer 1 Native library libcuopt.so (cpp/build/) + cpp/include/cuopt/linear_programming/cuopt_c.h +``` + +The public API (Layer 5) compiles to **Java 21 release** so the JAR can be +loaded on Java 21 classpaths at compile time. The FFM implementation (Layer 3) +uses `java.lang.foreign.*` types which require **Java 22 runtime**. The +multi-release JAR resolves the right classes at runtime via the JVM's +`META-INF/versions/22/` lookup. + +The SPI bridge (Layer 4) exists because Layer 5 cannot reference `MemorySegment` +or other Java 22 types in its method signatures (those classes don't exist in +Java 21). `CuOptProvider` is a Java-21-compatible interface that +`ServiceLoader` resolves to the Java 22 implementation at runtime. + +## Layout + +``` +java/ +├── README.md (this file) +├── build.sh Top-level entry point — auto-downloads +│ jextract, regenerates bindings, runs mvn. +├── license-header.txt Apache 2.0 SPDX header for source files. +├── cuopt-java/ The published Maven artifact. +│ ├── pom.xml Java 21 + Java 22 MR-JAR config. +│ └── src/ +│ ├── main/java/ Java 21 public API. +│ ├── main/java22/ Java 22 FFM implementation. +│ ├── main/resources/ ServiceLoader registration; platform table. +│ └── test/java/ JUnit 5 tests. +└── panama-bindings/ jextract binding generation. + ├── headers.h Umbrella include of cuopt_c.h. + └── generate-bindings.sh jextract invocation. +``` + +## Building (developer workstation) + +Prerequisites: + +- JDK 22+ (`conda install -c conda-forge openjdk=22`) +- Maven 3.9.6+ (`conda install -c conda-forge maven`) +- A built `libcuopt.so` (from `../cpp/build/`) + +**jextract** is not available on conda-forge — `panama-bindings/generate-bindings.sh` +auto-downloads `openjdk-22-jextract+6-47` from `download.java.net` on first +run and extracts it to `panama-bindings/jextract-22/` (gitignored). Subsequent +builds reuse the local copy. Set `JEXTRACT=/path/to/jextract` to override. + +```bash +# Build libcuopt.so first if not already built +cd /path/to/cuopt +./build.sh libcuopt + +# Then build the Java side (auto-downloads jextract on first run) +./java/build.sh +``` + +This regenerates panama bindings from `cpp/include/cuopt/linear_programming/cuopt_c.h`, +then runs `mvn clean verify`. Output JARs land in `java/cuopt-java/target/`. + +## Distribution modes + +Two JAR shapes: + +- **Base JAR** (always built) — `cuopt-java-.jar`. Contains only + Java classes. At runtime expects `libcuopt.so` to be reachable via + `java.library.path` (typical conda install: `LD_LIBRARY_PATH=$CONDA_PREFIX/lib`). + Loader path: `System.loadLibrary("cuopt")`. + +- **Classifier JAR** (opt-in) — `cuopt-java---cuda.jar`. + Bundles `libcuopt.so`, `libmps_parser.so`, `librmm.so`, `librapids_logger.so` + under `/Linux/` inside the JAR, with manifest entry + `Embedded-Libraries-Cuda-Version: `. Loader extracts to a temp + directory + `System.load`. User must still install the CUDA toolkit + matching `` (cuBLAS, cuSPARSE, cuDSS, cuBLASLt, cuDART, nvJitLink). + +To produce a classifier JAR locally: + +```bash +# Activate a RAPIDS conda env (provides librmm + librapids_logger). +conda activate cuopt +CLASSIFIER_CUDA=13 SKIP_TESTS=true ./java/build.sh +# Output: +# target/cuopt-java-.jar ← base +# target/cuopt-java--x86_64-cuda13.jar ← classifier +``` + +Excluded by policy (size + license + ABI risk; see issue #1203 for +follow-up on static-linking these into `libcuopt.so`): +CUDA toolkit, gRPC, protobuf, abseil, TBB, OpenMP, libstdc++. + +## Per-folder design notes + +Each directory under `java/` has its own `README.md` explaining the role +of that layer in the architecture. Read them in this order if you want +the full picture: + +1. `cuopt-java/README.md` — the published artifact +2. `cuopt-java/src/main/java/com/nvidia/cuopt/README.md` — Layer 5 public API +3. `cuopt-java/src/main/java22/com/nvidia/cuopt/README.md` — Layers 3 + 2 (FFM impl + panama) +4. `panama-bindings/README.md` — binding generation pipeline + +## References + +- C API header: `cpp/include/cuopt/linear_programming/cuopt_c.h` +- cuvs-java reference: https://github.com/rapidsai/cuvs/tree/main/java +- jextract: https://github.com/openjdk/jextract +- JEP 454 (FFM Final): https://openjdk.org/jeps/454 diff --git a/java/build.sh b/java/build.sh new file mode 100755 index 000000000..e4b9ecbcb --- /dev/null +++ b/java/build.sh @@ -0,0 +1,153 @@ +#!/bin/bash +# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Build entry point for cuopt-java. +# +# Pipeline: +# 1. Verify JDK 22 + Maven 3.9.6+ are available. +# 2. Verify libcuopt.so is reachable. +# 3. Run panama-bindings/generate-bindings.sh (regenerates jextract output). +# 4. Run drift gate: 'git diff --exit-code' on the generated panama dir +# forces commit of any changes. +# 5. Run 'mvn clean verify'. +# +# Environment variables (all optional): +# JEXTRACT Path to jextract binary. Default: search PATH. +# CUOPT_INCLUDE Path to cuopt include dir. Default: ../cpp/include. +# CUDA_INCLUDE Path to CUDA include dir. Default: /usr/local/cuda/include. +# CUOPT_LIB_DIR Directory containing libcuopt.so. Default: ../cpp/build, +# or $CONDA_PREFIX/lib if libcuopt.so is installed there. +# SKIP_DRIFT_CHECK If set to 'true', skips the panama drift gate. +# Useful in initial-bootstrap commits before the +# bindings are first committed. +# SKIP_BINDINGS_REGEN +# If set to 'true', skips the panama bindings +# regeneration step (jextract invocation). Useful +# in CI where the committed bindings are trusted +# and the build env lacks CUDA headers needed by +# jextract. +# SKIP_TESTS If set to 'true', runs 'mvn package' instead of +# 'mvn verify'. +# UNIT_TESTS_ONLY If set to 'true', runs 'mvn test' (unit tests only, +# skips integration tests). Useful for fast local +# feedback when no GPU is available. +# CLASSIFIER_CUDA If set (e.g. '12' or '13'), additionally produces a +# classifier JAR cuopt-java---cuda.jar +# that bundles libcuopt + libmps_parser + librmm + +# librapids_logger. Requires CONDA_PREFIX to point at +# an env with librmm.so and librapids_logger.so. + +set -euo pipefail + +CURDIR="$(cd "$(dirname "$0")" && pwd)" +REPODIR="$(cd "${CURDIR}/.." && pwd)" + +JEXTRACT="${JEXTRACT:-jextract}" +CUOPT_INCLUDE="${CUOPT_INCLUDE:-${REPODIR}/cpp/include}" + +# Find libcuopt.so. Prefer explicit CUOPT_LIB_DIR; otherwise look in the +# local cpp/build/ (developer build) and the active conda env's lib/ +# (conda-installed libcuopt). +if [[ -z "${CUOPT_LIB_DIR:-}" ]]; then + if [[ -f "${REPODIR}/cpp/build/libcuopt.so" ]]; then + CUOPT_LIB_DIR="${REPODIR}/cpp/build" + elif [[ -n "${CONDA_PREFIX:-}" ]] && [[ -f "${CONDA_PREFIX}/lib/libcuopt.so" ]]; then + CUOPT_LIB_DIR="${CONDA_PREFIX}/lib" + else + CUOPT_LIB_DIR="${REPODIR}/cpp/build" + fi +fi + +echo "==> cuopt-java build" +echo " REPODIR=${REPODIR}" +echo " JEXTRACT=${JEXTRACT}" +echo " CUOPT_INCLUDE=${CUOPT_INCLUDE}" +echo " CUOPT_LIB_DIR=${CUOPT_LIB_DIR}" + +# 1. Toolchain checks +if ! command -v java >/dev/null 2>&1; then + echo "ERROR: java not found in PATH." >&2 + exit 1 +fi +JAVA_VERSION="$(java -version 2>&1 | head -1 | sed -E 's/.*"([0-9]+).*/\1/')" +if [[ -z "${JAVA_VERSION}" || "${JAVA_VERSION}" -lt 22 ]]; then + echo "ERROR: cuopt-java requires JDK 22 or higher (got: $(java -version 2>&1 | head -1))." >&2 + echo " Install with: conda install -c conda-forge openjdk=22" >&2 + exit 1 +fi + +if ! command -v mvn >/dev/null 2>&1; then + echo "ERROR: mvn not found in PATH." >&2 + echo " Install with: conda install -c conda-forge maven" >&2 + exit 1 +fi + +# jextract is auto-downloaded by panama-bindings/generate-bindings.sh +# on first run (cuvs pattern). No need to require it on PATH here. + +# 2. libcuopt.so check +if [[ ! -f "${CUOPT_LIB_DIR}/libcuopt.so" ]]; then + echo "WARNING: libcuopt.so not found at ${CUOPT_LIB_DIR}/libcuopt.so" >&2 + echo " Tests will fail unless libcuopt is on java.library.path." >&2 +fi +export LD_LIBRARY_PATH="${CUOPT_LIB_DIR}:${LD_LIBRARY_PATH:-}" + +# 3. Regenerate panama bindings (skipped in CI; bindings are committed +# and the dev-workstation gate is authoritative, see SKIP_BINDINGS_REGEN +# in the env block above). +if [[ "${SKIP_BINDINGS_REGEN:-false}" != "true" ]]; then + echo "==> Regenerating panama bindings" + "${CURDIR}/panama-bindings/generate-bindings.sh" +fi + +# 4. Drift gate +if [[ "${SKIP_DRIFT_CHECK:-false}" != "true" ]]; then + echo "==> Checking for panama bindings drift" + PANAMA_REL="java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama" + if ! git -C "${REPODIR}" diff --quiet -- "${PANAMA_REL}" 2>/dev/null; then + echo "ERROR: Panama bindings drifted from committed state." >&2 + echo " Run './java/build.sh' and commit the regenerated files at:" >&2 + echo " ${PANAMA_REL}/" >&2 + echo " (Use SKIP_DRIFT_CHECK=true to bypass during initial bootstrap.)" >&2 + git -C "${REPODIR}" diff --stat -- "${PANAMA_REL}" >&2 + exit 1 + fi +fi + +# 5. Maven build +echo "==> Running Maven" +cd "${CURDIR}/cuopt-java" + +MVN_ARGS=() +if [[ -n "${CLASSIFIER_CUDA:-}" ]]; then + # Activate the classifier-jar profile. The profile copies librmm.so + # and librapids_logger.so from $CONDA_PREFIX/lib, so a conda env with + # those libs must be active. + if [[ -z "${CONDA_PREFIX:-}" ]]; then + echo "ERROR: CLASSIFIER_CUDA=${CLASSIFIER_CUDA} requires CONDA_PREFIX to be set" >&2 + echo " (the classifier JAR bundles librmm.so + librapids_logger.so" >&2 + echo " from \$CONDA_PREFIX/lib). Activate a RAPIDS conda env first." >&2 + exit 1 + fi + MVN_ARGS+=("-Dcuda.version=${CLASSIFIER_CUDA}") + echo " Building classifier JAR for cuda${CLASSIFIER_CUDA} (RAPIDS libs from ${CONDA_PREFIX}/lib)" + + # CI sets NATIVE_CPP_BUILD_PATH because there's no local cpp/build; libcuopt.so + # and libmps_parser.so live at $CONDA_PREFIX/lib alongside librmm/rapids_logger. + # For local dev with a populated cpp/build/, leave it unset to use the pom default. + if [[ -n "${NATIVE_CPP_BUILD_PATH:-}" ]]; then + MVN_ARGS+=("-Dnative.cpp.build.path=${NATIVE_CPP_BUILD_PATH}") + echo " libcuopt + libmps_parser sourced from ${NATIVE_CPP_BUILD_PATH}" + fi +fi + +if [[ "${SKIP_TESTS:-false}" == "true" ]]; then + mvn clean package -DskipTests "${MVN_ARGS[@]}" +elif [[ "${UNIT_TESTS_ONLY:-false}" == "true" ]]; then + mvn clean test "${MVN_ARGS[@]}" +else + mvn clean verify -Djava.library.path="${CUOPT_LIB_DIR}" "${MVN_ARGS[@]}" +fi + +echo "==> cuopt-java build complete" diff --git a/java/cuopt-java/README.md b/java/cuopt-java/README.md new file mode 100644 index 000000000..7549c55b7 --- /dev/null +++ b/java/cuopt-java/README.md @@ -0,0 +1,41 @@ +# cuopt-java (Maven artifact) + +Source for the published `com.nvidia.cuopt:cuopt-java` artifact. + +## Build setup highlights + +The `pom.xml` encodes three lessons from cuvs-java: + +- **Java 21 base + Java 22 multi-release JAR** (cuvs Issue #1066): the + default-compile execution targets `21`; a separate + `compile-java-22` execution targets `22` and writes + to the `META-INF/versions/22/` section of the JAR via + `multiReleaseOutput=true`. + +- **`maven-compiler-plugin` 3.11.0+ with explicit phase bindings** + (cuvs Issue #1293): the two compile executions are bound to the + `compile` and `process-classes` lifecycle phases respectively, so they + run **serially** rather than in parallel. Without this, ~50% of builds + fail with phantom "cannot find symbol" errors as the java22 compile + starts before the java21 compile finishes. + +- **Spotless in `` only** (cuvs Issue #1090): never list + spotless under `` — that pulls spotless code into a + fat JAR with multiple `module-info.class` files, breaking modularized + consumers. + +## Layout + +``` +cuopt-java/ +├── pom.xml +└── src/ + ├── main/ + │ ├── java/ ← Java 21 public API (Layer 5) + │ ├── java22/ ← Java 22 FFM impl (Layers 3 + 2) + │ └── resources/META-INF/ + │ ├── cuopt/supported-platforms.properties ← data-driven platform check + │ └── services/ ← ServiceLoader registration + └── test/ + └── java/ ← JUnit 5 +``` diff --git a/java/cuopt-java/pom.xml b/java/cuopt-java/pom.xml new file mode 100644 index 000000000..22051de85 --- /dev/null +++ b/java/cuopt-java/pom.xml @@ -0,0 +1,324 @@ + + + + 4.0.0 + + com.nvidia.cuopt + cuopt-java + 26.6.0-SNAPSHOT + jar + + cuopt-java + Java interface to NVIDIA cuOpt for LP, MILP, and QP. + https://github.com/NVIDIA/cuopt + + + + Apache License, Version 2.0 + https://www.apache.org/licenses/LICENSE-2.0.txt + + + + + UTF-8 + + 22 + 22 + + 5.11.4 + + + + + + + org.junit.jupiter + junit-jupiter-api + ${junit.jupiter.version} + test + + + org.junit.jupiter + junit-jupiter-engine + ${junit.jupiter.version} + test + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.13.0 + + + default-compile + compile + + compile + + + 21 + + ${project.basedir}/src/main/java + + + + + compile-java-22 + process-classes + + compile + + + 22 + + ${project.basedir}/src/main/java22 + + true + + + + + + + + org.apache.maven.plugins + maven-jar-plugin + 3.4.2 + + + + true + + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.5.2 + + --enable-native-access=ALL-UNNAMED + + + + + + org.apache.maven.plugins + maven-failsafe-plugin + 3.5.2 + + --enable-native-access=ALL-UNNAMED + ${project.build.directory}/${project.build.finalName}.jar + + + + + integration-test + verify + + + + + + + + + + + + arch-amd64 + + + amd64 + + + + x86_64 + + + + + arch-aarch64 + + + aarch64 + + + + aarch64 + + + + + classifier-jar + + + cuda.version + + + + ${native.arch}-cuda${cuda.version} + ${project.basedir}/../../cpp/build + + + + + org.apache.maven.plugins + maven-resources-plugin + 3.3.1 + + + copy-cuopt-libs + prepare-package + + copy-resources + + + true + ${project.build.directory}/native-libs/${os.arch}/${os.name} + + + + ${native.cpp.build.path} + + libcuopt.so + libmps_parser.so + + + + ${native.cpp.build.path}/libmps_parser + + libmps_parser.so + + + + + + + copy-rapids-libs + prepare-package + + copy-resources + + + true + ${project.build.directory}/native-libs/${os.arch}/${os.name} + + + ${env.CONDA_PREFIX}/lib + + librmm.so + librapids_logger.so + + + + + + + + + org.apache.maven.plugins + maven-assembly-plugin + 3.7.1 + + + src/assembly/native-with-deps.xml + + + + true + ${cuda.version} + + + + + + assemble-native + package + + single + + + + + + + + + + diff --git a/java/cuopt-java/src/assembly/native-with-deps.xml b/java/cuopt-java/src/assembly/native-with-deps.xml new file mode 100644 index 000000000..d01593318 --- /dev/null +++ b/java/cuopt-java/src/assembly/native-with-deps.xml @@ -0,0 +1,49 @@ + + + + + ${native.classifier} + + jar + + + false + + + + / + true + true + runtime + + + + + + ${project.build.directory}/native-libs + / + + **/* + + + + + diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/README.md b/java/cuopt-java/src/main/java/com/nvidia/cuopt/README.md new file mode 100644 index 000000000..abd2daeab --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/README.md @@ -0,0 +1,34 @@ +# Layer 5 — Public API (Java 21) + +This package compiles to **Java 21 release**. Code here cannot reference +`java.lang.foreign.*` types (`MemorySegment`, `Arena`, etc.) because those +classes don't exist in Java 21. + +## What lives here + +- The user-facing API: `Solver` (currently exposes `getVersion()` only; + `Problem`, `Variable`, `LinearExpr`, etc. land in subsequent PRs). +- Public exceptions: `cuOptException`. +- The SPI interface (`spi/cuOptProvider.java`) — sealed; permits only the + Java 22 implementation in `internal/`. + +## How calls reach the FFM implementation + +Layer 5 calls the SPI: + +```java +public final class Solver { + public static String getVersion() { + return cuOptProvider.instance().getVersion(); + } +} +``` + +`cuOptProvider.instance()` uses `java.util.ServiceLoader` to find the +implementation registered in `META-INF/services/`. On a Java 22+ JVM, +the registered class lives in `META-INF/versions/22/com/nvidia/cuopt/internal/` +(the multi-release JAR layer), so the JVM picks it up automatically. + +On a Java 21 JVM the implementation class is missing entirely, and +`ServiceLoader.findFirst()` returns empty. We throw a clear error in +that case — the JAR loads at compile time but cannot run. diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/Solver.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/Solver.java new file mode 100644 index 000000000..5428377c0 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/Solver.java @@ -0,0 +1,42 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt; + +import com.nvidia.cuopt.optimization.Problem; +import com.nvidia.cuopt.optimization.SolverSettings; +import com.nvidia.cuopt.spi.cuOptProvider; + +/** + * Static utility entry points for cuopt-java. + * + *

Most users call {@link Problem#solve()} or + * {@link Problem#solve(SolverSettings)} on a Problem directly. The + * static {@code Solver.solve(...)} overloads here are convenience + * wrappers. + */ +public final class Solver { + + private Solver() {} + + /** + * Returns the cuOpt library version (from {@code libcuopt.so}) as a + * human-readable {@code major.minor.patch} string. + * + * @throws cuOptException if the native library cannot be loaded. + */ + public static String getVersion() { + return cuOptProvider.instance().getVersion(); + } + + // ── solve overloads ────────────────────────────────────────── + + public static void solve(Problem problem) { + problem.solve(); + } + + public static void solve(Problem problem, SolverSettings settings) { + problem.solve(settings); + } +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/cuOpt.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/cuOpt.java new file mode 100644 index 000000000..e822c43c3 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/cuOpt.java @@ -0,0 +1,76 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt; + +import com.nvidia.cuopt.optimization.CType; +import com.nvidia.cuopt.optimization.Sense; +import com.nvidia.cuopt.optimization.VType; + +/** + * Constants holder for cuopt-java. Designed for static import: + * + * 

{@code
+ *     import static com.nvidia.cuopt.cuOpt.*;
+ *
+ *     Variable x = problem.addVariable(0, INF, CONTINUOUS, "x");
+ *     problem.addConstraint(expr, LESS_EQUAL, 100, "c1");
+ *     problem.setObjective(obj, MAXIMIZE);
+ * }
+ * + *

Parameter name string constants (mirrors of the C-side + * {@code CUOPT_*} preprocessor macros from {@code constants.h}) are + * grouped at the bottom. They're used with + * {@link com.nvidia.cuopt.optimization.SolverSettings#setParameter(String, Object)}. + */ +public final class cuOpt { + + private cuOpt() {} + + // ── numeric constants ──────────────────────────────────────── + /** Positive infinity, for unbounded variable / constraint sides. */ + public static final double INF = Double.POSITIVE_INFINITY; + /** Negative infinity. */ + public static final double NEG_INF = Double.NEGATIVE_INFINITY; + + // ── enum re-exports (static-importable shortcuts) ──────────── + public static final VType CONTINUOUS = VType.CONTINUOUS; + public static final VType INTEGER = VType.INTEGER; + public static final VType BINARY = VType.BINARY; + + public static final CType LESS_EQUAL = CType.LE; + public static final CType GREATER_EQUAL = CType.GE; + public static final CType EQUAL = CType.EQ; + + public static final Sense MINIMIZE = Sense.MINIMIZE; + public static final Sense MAXIMIZE = Sense.MAXIMIZE; + + // ── solver parameter name strings (subset; the rest are + // available via setParameter(name, value) with raw strings) ─ + public static final String TIME_LIMIT = "time_limit"; + public static final String ITERATION_LIMIT = "iteration_limit"; + public static final String WORK_LIMIT = "work_limit"; + public static final String METHOD = "method"; + public static final String PDLP_SOLVER_MODE = "pdlp_solver_mode"; + + public static final String ABSOLUTE_PRIMAL_TOLERANCE = "absolute_primal_tolerance"; + public static final String RELATIVE_PRIMAL_TOLERANCE = "relative_primal_tolerance"; + public static final String ABSOLUTE_DUAL_TOLERANCE = "absolute_dual_tolerance"; + public static final String RELATIVE_DUAL_TOLERANCE = "relative_dual_tolerance"; + public static final String ABSOLUTE_GAP_TOLERANCE = "absolute_gap_tolerance"; + public static final String RELATIVE_GAP_TOLERANCE = "relative_gap_tolerance"; + + public static final String MIP_ABSOLUTE_GAP = "mip_absolute_gap"; + public static final String MIP_RELATIVE_GAP = "mip_relative_gap"; + public static final String MIP_INTEGRALITY_TOLERANCE = "mip_integrality_tolerance"; + + public static final String LOG_TO_CONSOLE = "log_to_console"; + public static final String LOG_FILE = "log_file"; + public static final String NUM_CPU_THREADS = "num_cpu_threads"; + public static final String NUM_GPUS = "num_gpus"; + public static final String RANDOM_SEED = "random_seed"; + public static final String CROSSOVER = "crossover"; + public static final String PRESOLVE = "presolve"; + public static final String INFEASIBILITY_DETECTION = "infeasibility_detection"; +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/cuOptException.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/cuOptException.java new file mode 100644 index 000000000..c67ea6659 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/cuOptException.java @@ -0,0 +1,27 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt; + +/** + * Unchecked exception thrown by cuopt-java when a native call fails or + * the runtime environment is misconfigured (e.g., the native library + * cannot be loaded, or the JVM is older than Java 22). + */ +public class cuOptException extends RuntimeException { + + private static final long serialVersionUID = 1L; + + public cuOptException(String message) { + super(message); + } + + public cuOptException(String message, Throwable cause) { + super(message, cause); + } + + public cuOptException(Throwable cause) { + super(cause); + } +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/CType.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/CType.java new file mode 100644 index 000000000..8ffd3e693 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/CType.java @@ -0,0 +1,32 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +/** + * Constraint sense for {@code Problem.addConstraint(...)}. + * + *

Maps to the C API constants {@code CUOPT_LESS_THAN} ({@code 'L'}), + * {@code CUOPT_GREATER_THAN} ({@code 'G'}), and {@code CUOPT_EQUAL} + * ({@code 'E'}). + */ +public enum CType { + /** Less than or equal: {@code lhs <= rhs}. */ + LE('L'), + /** Greater than or equal: {@code lhs >= rhs}. */ + GE('G'), + /** Equal: {@code lhs == rhs}. */ + EQ('E'); + + private final char code; + + CType(char code) { + this.code = code; + } + + /** Returns the C-API char encoding. */ + public char code() { + return code; + } +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/Constraint.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/Constraint.java new file mode 100644 index 000000000..d4dffaf0e --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/Constraint.java @@ -0,0 +1,98 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +import com.nvidia.cuopt.cuOptException; +import java.util.Objects; + +/** + * A constraint owned by a {@link Problem}. + * + *

Like {@link Variable}, this is an immutable handle. Post-solve + * accessors ({@link #dualValue()}, {@link #slack()}) delegate back to + * the owning Problem. + * + *

A constraint has a sense ({@link CType#LE}, {@link CType#GE}, + * {@link CType#EQ}) and a right-hand-side value. + */ +public final class Constraint { + + private final Problem owner; + private final int index; + private final CType sense; + private final double rhs; + private final String name; + + // Package-private constructor. + Constraint(Problem owner, int index, CType sense, double rhs, String name) { + this.owner = Objects.requireNonNull(owner, "owner"); + this.index = index; + this.sense = Objects.requireNonNull(sense, "sense"); + this.rhs = rhs; + this.name = name == null ? "" : name; + } + + public int index() { + return index; + } + + public String name() { + return name; + } + + /** Constraint sense ({@link CType#LE}, {@link CType#GE}, {@link CType#EQ}). */ + public CType sense() { + return sense; + } + + /** Right-hand side of the constraint. */ + public double rhs() { + return rhs; + } + + // ── post-solve accessors ───────────────────────────────────── + + /** + * Dual value (shadow price) of this constraint in the current + * LP solution. LP only — for MIP solves, returns {@code Double.NaN}. + * + * @throws cuOptException if the owning Problem has not been solved + * or has been closed. + */ + public double dualValue() { + return owner.dualValueOf(index); + } + + /** + * Slack of this constraint in the current solution. + * + * @throws cuOptException if the owning Problem has not been solved + * or has been closed. + */ + public double slack() { + return owner.slackOf(index); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof Constraint other)) return false; + return owner == other.owner && index == other.index; + } + + @Override + public int hashCode() { + return System.identityHashCode(owner) * 31 + index; + } + + @Override + public String toString() { + return name.isEmpty() ? "Constraint[" + index + "]" : "Constraint[" + name + "]"; + } + + Problem owner() { + return owner; + } +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/ErrorStatus.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/ErrorStatus.java new file mode 100644 index 000000000..67b6c3981 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/ErrorStatus.java @@ -0,0 +1,43 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +/** + * Solver error status, distinct from {@link TerminationStatus}. + * {@code SUCCESS} indicates the solver ran without errors (regardless of + * whether it found an optimal solution). + * + *

Maps to the C API status codes (return values from cuOpt functions). + */ +public enum ErrorStatus { + SUCCESS(0), + INVALID_ARGUMENT(1), + MPS_FILE_ERROR(2), + MPS_PARSE_ERROR(3), + VALIDATION_ERROR(4), + OUT_OF_MEMORY(5), + RUNTIME_ERROR(6); + + private final int code; + + ErrorStatus(int code) { + this.code = code; + } + + public int code() { + return code; + } + + public static ErrorStatus fromCode(int code) { + for (ErrorStatus s : values()) { + if (s.code == code) { + return s; + } + } + // Unknown code — fall back to RUNTIME_ERROR rather than throwing, + // since this is on the error-reporting path. + return RUNTIME_ERROR; + } +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/LinearExpr.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/LinearExpr.java new file mode 100644 index 000000000..26cdaa321 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/LinearExpr.java @@ -0,0 +1,129 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Objects; + +/** + * A mutable linear expression of the form {@code Σ cᵢ·xᵢ + constant}. + * + *

Supports two construction styles, both chainable, freely + * interchangeable. Same-variable coefficients accumulate (Gurobi + * convention): + * + * 

{@code
+ *   // Hand-written, per-term:
+ *   LinearExpr e = new LinearExpr()
+ *       .addTerm(2.0, x)
+ *       .addTerm(3.0, y);
+ *
+ *   // Bulk arrays (good for data-driven generation):
+ *   LinearExpr e = new LinearExpr().addTerms(coeffs, vars);
+ *
+ *   // Mix and match:
+ *   LinearExpr e = new LinearExpr()
+ *       .addTerms(baseCoeffs, baseVars)
+ *       .addTerm(0.5, special)
+ *       .addConstant(10);
+ * }
+ * + *

All terms in one expression must reference Variables owned by the + * same {@link Problem}. Mixing across problems throws + * {@link IllegalArgumentException}. + */ +public final class LinearExpr { + + // LinkedHashMap preserves insertion order (useful for deterministic + // CSR builds), keys are Variables, values are summed coefficients. + private final Map terms = new LinkedHashMap<>(); + private double constant = 0.0; + private Problem owner; // null until first term is added + + public LinearExpr() {} + + /** + * Adds a single term {@code coeff · var} to this expression. + * Returns this for chaining. If {@code var} is already present, the + * coefficients sum. + */ + public LinearExpr addTerm(double coeff, Variable var) { + Objects.requireNonNull(var, "var"); + bindOwner(var); + terms.merge(var, coeff, Double::sum); + return this; + } + + /** + * Adds n terms in bulk. {@code coeffs} and {@code vars} must have + * the same length. Same-variable coefficients accumulate. + */ + public LinearExpr addTerms(double[] coeffs, Variable[] vars) { + Objects.requireNonNull(coeffs, "coeffs"); + Objects.requireNonNull(vars, "vars"); + if (coeffs.length != vars.length) { + throw new IllegalArgumentException( + "coefficient array length " + coeffs.length + + " != variable array length " + vars.length); + } + for (int i = 0; i < coeffs.length; i++) { + addTerm(coeffs[i], vars[i]); + } + return this; + } + + /** Adds a scalar offset to the expression. Returns this for chaining. */ + public LinearExpr addConstant(double c) { + this.constant += c; + return this; + } + + /** Adds another linear expression to this one. Returns this. */ + public LinearExpr add(LinearExpr other) { + Objects.requireNonNull(other, "other"); + for (Map.Entry e : other.terms.entrySet()) { + addTerm(e.getValue(), e.getKey()); + } + this.constant += other.constant; + return this; + } + + /** Number of distinct variables in this expression. */ + public int numTerms() { + return terms.size(); + } + + /** Constant offset. */ + public double constant() { + return constant; + } + + /** + * Read-only view of the terms map. Order is insertion order + * (deterministic). Same-variable coefficients have already been + * summed at construction time. + */ + public Map terms() { + return java.util.Collections.unmodifiableMap(terms); + } + + /** + * Owning Problem (the Problem all variables in this expression + * belong to). {@code null} if no terms have been added. + */ + public Problem owner() { + return owner; + } + + private void bindOwner(Variable v) { + if (owner == null) { + owner = v.owner(); + } else if (owner != v.owner()) { + throw new IllegalArgumentException( + "Cannot mix variables from different Problems in one LinearExpr"); + } + } +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/LpStats.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/LpStats.java new file mode 100644 index 000000000..c3f836da5 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/LpStats.java @@ -0,0 +1,27 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +/** + * Solver statistics for LP solves. Returned by {@code Problem.lpStats()}. + * + *

Fields not measured by the underlying solver are reported as + * {@code Double.NaN} (doubles) or {@code -1L} (longs). + * + * @param primalResidual primal infeasibility residual at termination + * @param dualResidual dual infeasibility residual at termination + * @param primalObjective primal objective value + * @param dualObjective dual objective value + * @param iterations total iteration count + * @param gap relative primal-dual gap at termination + */ +public record LpStats( + double primalResidual, + double dualResidual, + double primalObjective, + double dualObjective, + long iterations, + double gap +) {} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/MIPGetSolutionCallback.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/MIPGetSolutionCallback.java new file mode 100644 index 000000000..bcdcc2217 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/MIPGetSolutionCallback.java @@ -0,0 +1,34 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +/** + * User-provided callback invoked by the MIP solver each time a new + * incumbent solution is found. Register via + * {@link SolverSettings#setMIPGetSolutionCallback(MIPGetSolutionCallback)}. + * + *

The arrays and scalars passed in are valid only for the duration + * of the callback. Copy any data you need to keep beyond the call. + * + *

Exceptions thrown by the callback are caught and dropped; they will + * not propagate to the native solver. + * + *

Do not call back into the solver (e.g. {@code Problem.solve()}) from + * within this callback — the solver is single-threaded and re-entry will + * deadlock or corrupt state. + * + * @see MIPSetSolutionCallback + */ +@FunctionalInterface +public interface MIPGetSolutionCallback { + + /** + * @param solution The incumbent's primal values, one per variable + * (length = number of variables in the problem). + * @param objectiveValue The incumbent's objective value. + * @param solutionBound The current dual / user bound on the optimal value. + */ + void onSolution(double[] solution, double objectiveValue, double solutionBound); +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/MIPSetSolutionCallback.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/MIPSetSolutionCallback.java new file mode 100644 index 000000000..2f99b451a --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/MIPSetSolutionCallback.java @@ -0,0 +1,42 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +/** + * User-provided callback invoked by the MIP solver when it would like + * the user to inject a candidate primal solution. Register via + * {@link SolverSettings#setMIPSetSolutionCallback(MIPSetSolutionCallback)}. + * + *

Registering a set-solution callback disables presolve. + * + *

The callback must write the candidate's primal values into + * {@code outSolution} (one per variable) and its objective value into + * {@code outObjective[0]}. If the user has no candidate to inject, the + * callback should still leave the buffer in a defined state; the + * solver will use whatever is written. The arrays are valid only for + * the duration of the callback. + * + *

Exceptions thrown by the callback are caught and dropped; they will + * not propagate to the native solver. In that case, the buffer is not + * written back and the solver proceeds without an injected solution. + * + *

Do not call back into the solver (e.g. {@code Problem.solve()}) from + * within this callback — the solver is single-threaded and re-entry will + * deadlock or corrupt state. + * + * @see MIPGetSolutionCallback + */ +@FunctionalInterface +public interface MIPSetSolutionCallback { + + /** + * @param outSolution Output buffer for primal values (length = number + * of variables). Write your candidate values here. + * @param outObjective Single-element output buffer. Write the candidate's + * objective value into {@code outObjective[0]}. + * @param solutionBound The current dual / user bound on the optimal value. + */ + void provideSolution(double[] outSolution, double[] outObjective, double solutionBound); +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/MIPStats.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/MIPStats.java new file mode 100644 index 000000000..dcf85c1d5 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/MIPStats.java @@ -0,0 +1,25 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +/** + * Solver statistics for MILP solves. Returned by + * {@code Problem.mipStats()} (empty {@link java.util.Optional} for LP-only problems). + * + * @param mipGap relative MIP gap at termination ({@code (UB - LB) / |UB|}) + * @param bestBound best dual bound found + * @param nodesExplored number of branch-and-bound nodes explored + * @param incumbentsFound number of distinct incumbent solutions found + * @param presolveTime wall-clock time spent in presolve, seconds + * @param rootRelaxationTime wall-clock time spent on the root LP relaxation, seconds + */ +public record MIPStats( + double mipGap, + double bestBound, + long nodesExplored, + long incumbentsFound, + double presolveTime, + double rootRelaxationTime +) {} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/PdlpSolverMode.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/PdlpSolverMode.java new file mode 100644 index 000000000..663f38f77 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/PdlpSolverMode.java @@ -0,0 +1,38 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +/** + * PDLP-specific solver mode tuning. Set via + * {@code SolverSettings.setParameter(cuOpt.PDLP_SOLVER_MODE, mode)}. + * + *

Maps to the C API constants {@code CUOPT_PDLP_SOLVER_MODE_*}. + */ +public enum PdlpSolverMode { + STABLE1(0), + STABLE2(1), + METHODICAL1(2), + FAST1(3), + STABLE3(4); + + private final int code; + + PdlpSolverMode(int code) { + this.code = code; + } + + public int code() { + return code; + } + + public static PdlpSolverMode fromCode(int code) { + for (PdlpSolverMode m : values()) { + if (m.code == code) { + return m; + } + } + throw new IllegalArgumentException("Unknown PdlpSolverMode code: " + code); + } +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/Problem.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/Problem.java new file mode 100644 index 000000000..73e452dd8 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/Problem.java @@ -0,0 +1,417 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +import com.nvidia.cuopt.cuOptException; +import com.nvidia.cuopt.spi.cuOptProvider; +import com.nvidia.cuopt.spi.SolveResult; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; + +/** + * An LP / MILP / QP optimization problem. + * + *

{@code Problem} owns all post-solve state. Variables and + * Constraints are lightweight handles that delegate back to the + * Problem for value queries. There is no separate {@code Solution} + * class — primal values are accessed via {@link Variable#value()}, + * duals via {@link Constraint#dualValue()}, and solver-level info + * (status, objective, stats) via accessors on this class. + * + * 

{@code
+ *   import static com.nvidia.cuopt.cuOpt.*;
+ *
+ *   try (var problem = new Problem("diet")) {
+ *       Variable x = problem.addVariable(0, INF, CONTINUOUS, "x");
+ *       Variable y = problem.addVariable(0, INF, CONTINUOUS, "y");
+ *
+ *       LinearExpr expr = new LinearExpr().addTerm(2, x).addTerm(3, y);
+ *       problem.addConstraint(expr, LESS_EQUAL, 100, "c1");
+ *
+ *       LinearExpr obj = new LinearExpr().addTerm(1, x).addTerm(1, y);
+ *       problem.setObjective(obj, MAXIMIZE);
+ *
+ *       problem.solve();
+ *
+ *       if (problem.status() == TerminationStatus.OPTIMAL) {
+ *           System.out.println("Optimal: " + problem.objectiveValue());
+ *           System.out.println("x = " + x.value());
+ *           System.out.println("y = " + y.value());
+ *       }
+ *   }
+ * }
+ */ +public final class Problem implements AutoCloseable { + + // ── build-time state ───────────────────────────────────────── + private final String name; + private final List variables = new ArrayList<>(); + private final List constraints = new ArrayList<>(); + private final List constraintExpressions = new ArrayList<>(); + private final Map variablesByName = new HashMap<>(); + private final Map constraintsByName = new HashMap<>(); + + private LinearExpr linearObjective; + private QuadraticExpr quadraticObjective; + private Sense objectiveSense = Sense.MINIMIZE; + private double objectiveOffset = 0.0; + + // ── post-solve state (populated by solve()) ────────────────── + private boolean solved = false; + private double[] primalSolution; + private double[] dualSolution; + private double[] reducedCost; + private double[] slack; + private TerminationStatus status; + private String terminationReason; + private ErrorStatus errorStatus; + private String errorMessage; + private double objectiveValue; + private double dualObjectiveValue; + private double solveTime; + private SolverMethod solvedBy; + private LpStats lpStats; + private MIPStats mipStats; + + private boolean closed = false; + + public Problem() { + this(""); + } + + public Problem(String name) { + this.name = name == null ? "" : name; + } + + public String name() { + return name; + } + + // ── building the problem ───────────────────────────────────── + + public Variable addVariable(double lb, double ub, VType vtype, String name) { + checkNotSolved(); + int index = variables.size(); + Variable v = new Variable(this, index, lb, ub, Objects.requireNonNull(vtype), name); + variables.add(v); + if (name != null && !name.isEmpty()) { + variablesByName.put(name, v); + } + return v; + } + + public Variable addVariable(double lb, double ub, VType vtype) { + return addVariable(lb, ub, vtype, ""); + } + + public Variable addVariable(double lb, double ub) { + return addVariable(lb, ub, VType.CONTINUOUS, ""); + } + + /** Adds a continuous variable with bounds {@code [0, +inf)}. */ + public Variable addVariable() { + return addVariable(0.0, Double.POSITIVE_INFINITY, VType.CONTINUOUS, ""); + } + + public Constraint addConstraint(LinearExpr lhs, CType sense, double rhs, String name) { + checkNotSolved(); + Objects.requireNonNull(lhs, "lhs"); + Objects.requireNonNull(sense, "sense"); + if (lhs.owner() != null && lhs.owner() != this) { + throw new IllegalArgumentException("LinearExpr uses variables from a different Problem"); + } + int index = constraints.size(); + // The constraint constant becomes part of the RHS: lhs + c <= rhs ≡ lhs <= rhs - c + double adjustedRhs = rhs - lhs.constant(); + Constraint c = new Constraint(this, index, sense, adjustedRhs, name); + constraints.add(c); + constraintExpressions.add(snapshotLinear(lhs)); + if (name != null && !name.isEmpty()) { + constraintsByName.put(name, c); + } + return c; + } + + public Constraint addConstraint(LinearExpr lhs, CType sense, double rhs) { + return addConstraint(lhs, sense, rhs, ""); + } + + public Constraint addConstraint(LinearExpr lhs, CType sense, Variable rhsVar, String name) { + // lhs rhsVar ≡ (lhs - rhsVar) 0 + LinearExpr combined = snapshotLinear(lhs); + combined.addTerm(-1.0, rhsVar); + return addConstraint(combined, sense, 0.0, name); + } + + public Constraint addConstraint(LinearExpr lhs, CType sense, LinearExpr rhs, String name) { + // lhs rhs ≡ (lhs - rhs) 0 + LinearExpr combined = snapshotLinear(lhs); + for (Map.Entry e : rhs.terms().entrySet()) { + combined.addTerm(-e.getValue(), e.getKey()); + } + combined.addConstant(-rhs.constant()); + return addConstraint(combined, sense, 0.0, name); + } + + public void setObjective(LinearExpr expr, Sense sense) { + checkNotSolved(); + Objects.requireNonNull(expr, "expr"); + Objects.requireNonNull(sense, "sense"); + if (expr.owner() != null && expr.owner() != this) { + throw new IllegalArgumentException("LinearExpr uses variables from a different Problem"); + } + this.linearObjective = snapshotLinear(expr); + this.quadraticObjective = null; + this.objectiveSense = sense; + this.objectiveOffset = expr.constant(); + } + + public void setObjective(QuadraticExpr expr, Sense sense) { + checkNotSolved(); + Objects.requireNonNull(expr, "expr"); + Objects.requireNonNull(sense, "sense"); + if (expr.owner() != null && expr.owner() != this) { + throw new IllegalArgumentException("QuadraticExpr uses variables from a different Problem"); + } + this.quadraticObjective = expr; + this.linearObjective = null; + this.objectiveSense = sense; + this.objectiveOffset = expr.linearPart().constant(); + } + + // ── introspection ──────────────────────────────────────────── + + public List getVariables() { + return java.util.Collections.unmodifiableList(variables); + } + + public List getConstraints() { + return java.util.Collections.unmodifiableList(constraints); + } + + public Variable getVariable(int index) { + return variables.get(index); + } + + public Variable getVariable(String name) { + return variablesByName.get(name); + } + + public Constraint getConstraint(int index) { + return constraints.get(index); + } + + public Constraint getConstraint(String name) { + return constraintsByName.get(name); + } + + public int numVariables() { + return variables.size(); + } + + public int numConstraints() { + return constraints.size(); + } + + public int numNonZeros() { + int n = 0; + for (LinearExpr e : constraintExpressions) n += e.numTerms(); + return n; + } + + public boolean isMIP() { + for (Variable v : variables) { + if (v.variableType() != VType.CONTINUOUS) return true; + } + return false; + } + + public boolean isQP() { + return quadraticObjective != null && quadraticObjective.numQuadraticTerms() > 0; + } + + // ── solve ──────────────────────────────────────────────────── + + public void solve() { + solve(null); + } + + public void solve(SolverSettings settings) { + checkOpen(); + SolveResult result = cuOptProvider.instance().solveProblem(this, settings); + populateFromResult(result); + this.solved = true; + } + + // ── post-solve accessors ───────────────────────────────────── + + public TerminationStatus status() { + checkSolved(); + return status; + } + + public String terminationReason() { + checkSolved(); + return terminationReason; + } + + public ErrorStatus errorStatus() { + checkSolved(); + return errorStatus; + } + + public Optional errorMessage() { + checkSolved(); + return Optional.ofNullable(errorMessage); + } + + public double objectiveValue() { + checkSolved(); + return objectiveValue; + } + + public double dualObjectiveValue() { + checkSolved(); + return dualObjectiveValue; + } + + public double solveTime() { + checkSolved(); + return solveTime; + } + + public SolverMethod solvedBy() { + checkSolved(); + return solvedBy; + } + + public ProblemCategory problemCategory() { + if (isQP()) return ProblemCategory.QP; + if (!isMIP()) return ProblemCategory.LP; + return ProblemCategory.MIP; + } + + public LpStats lpStats() { + checkSolved(); + return lpStats; + } + + public Optional mipStats() { + checkSolved(); + return Optional.ofNullable(mipStats); + } + + public boolean isSolved() { + return solved; + } + + // ── delegation targets used by Variable / Constraint ───────── + + double primalValueOf(int index) { + checkSolved(); + return primalSolution[index]; + } + + double dualValueOf(int index) { + checkSolved(); + if (dualSolution == null) return Double.NaN; + return dualSolution[index]; + } + + double reducedCostOf(int index) { + checkSolved(); + if (reducedCost == null) return Double.NaN; + return reducedCost[index]; + } + + double slackOf(int index) { + checkSolved(); + if (slack == null) return Double.NaN; + return slack[index]; + } + + // ── lifecycle ──────────────────────────────────────────────── + + @Override + public void close() { + if (closed) return; + closed = true; + // Native handles are owned by the SPI implementation (per-instance Arena + // inside ProblemImpl). Closing happens there. + } + + // ── internal accessors used by the FFM implementation + // (public for cross-package access from internal/; not part of + // the stable user-facing API — do not rely on these in user code) ─ + + public LinearExpr linearObjective() { + return linearObjective; + } + + public QuadraticExpr quadraticObjective() { + return quadraticObjective; + } + + public Sense objectiveSense() { + return objectiveSense; + } + + public double objectiveOffset() { + return objectiveOffset; + } + + public List constraintExpressions() { + return java.util.Collections.unmodifiableList(constraintExpressions); + } + + // ── helpers ────────────────────────────────────────────────── + + private void checkOpen() { + if (closed) throw new cuOptException("Problem has been closed"); + } + + private void checkSolved() { + checkOpen(); + if (!solved) throw new cuOptException("Problem has not been solved"); + } + + private void checkNotSolved() { + checkOpen(); + if (solved) throw new cuOptException("Problem has already been solved; create a new Problem to re-build"); + } + + private void populateFromResult(SolveResult r) { + this.primalSolution = r.primalSolution(); + this.dualSolution = r.dualSolution(); + this.reducedCost = r.reducedCost(); + this.slack = r.slack(); + this.status = r.terminationStatus(); + this.terminationReason = r.terminationReason(); + this.errorStatus = r.errorStatus(); + this.errorMessage = r.errorMessage(); + this.objectiveValue = r.objectiveValue(); + this.dualObjectiveValue = r.dualObjectiveValue(); + this.solveTime = r.solveTime(); + this.solvedBy = r.solvedBy(); + this.lpStats = r.lpStats(); + this.mipStats = r.mipStats(); + } + + // LinearExpr copy used at addConstraint time so the user's + // subsequent mutation of the expression doesn't change the + // constraint we already accepted. + private LinearExpr snapshotLinear(LinearExpr src) { + LinearExpr copy = new LinearExpr(); + for (Map.Entry e : src.terms().entrySet()) { + copy.addTerm(e.getValue(), e.getKey()); + } + copy.addConstant(src.constant()); + return copy; + } +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/ProblemCategory.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/ProblemCategory.java new file mode 100644 index 000000000..933aa9993 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/ProblemCategory.java @@ -0,0 +1,18 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +/** + * Coarse classification of an optimization problem. Returned by + * {@code Problem.problemCategory()}. + */ +public enum ProblemCategory { + /** Linear program: linear objective, linear constraints, all continuous variables. */ + LP, + /** Mixed-integer (linear) program: at least one integer/binary variable. */ + MIP, + /** Quadratic program: quadratic objective, linear constraints. */ + QP +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/QuadraticExpr.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/QuadraticExpr.java new file mode 100644 index 000000000..f8fb31368 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/QuadraticExpr.java @@ -0,0 +1,141 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +/** + * A mutable quadratic expression of the form + * {@code Σ qᵢⱼ·xᵢ·xⱼ + Σ cᵢ·xᵢ + constant}. + * + *

The linear part is stored as a {@link LinearExpr}; quadratic terms + * are stored as parallel arrays of (coefficient, var1, var2) triples + * (one entry per Q-matrix non-zero). All chainable methods return + * {@code this}. + * + * 

{@code
+ *   QuadraticExpr obj = new QuadraticExpr()
+ *       .addTerms(linearCoeffs, x)              // linear part bulk
+ *       .addQuadraticTerm(1.0, x[0], x[0])      // x[0]² term
+ *       .addQuadraticTerm(0.5, x[0], x[1]);     // 0.5 · x[0]·x[1] term
+ * }
+ */ +public final class QuadraticExpr { + + private final LinearExpr linearPart = new LinearExpr(); + private final List qVar1 = new ArrayList<>(); + private final List qVar2 = new ArrayList<>(); + private final List qCoeff = new ArrayList<>(); + private Problem owner; + + public QuadraticExpr() {} + + /** Adds a linear term {@code coeff · var}. Same convention as {@link LinearExpr#addTerm}. */ + public QuadraticExpr addTerm(double coeff, Variable var) { + bindOwner(Objects.requireNonNull(var, "var")); + linearPart.addTerm(coeff, var); + return this; + } + + /** Adds a bulk linear part. */ + public QuadraticExpr addTerms(double[] coeffs, Variable[] vars) { + Objects.requireNonNull(coeffs, "coeffs"); + Objects.requireNonNull(vars, "vars"); + if (coeffs.length != vars.length) { + throw new IllegalArgumentException( + "coefficient array length " + coeffs.length + + " != variable array length " + vars.length); + } + for (int i = 0; i < vars.length; i++) { + addTerm(coeffs[i], vars[i]); + } + return this; + } + + /** + * Adds a quadratic term {@code coeff · v1 · v2} to the objective. + * For squared terms, pass the same variable twice. + */ + public QuadraticExpr addQuadraticTerm(double coeff, Variable v1, Variable v2) { + Objects.requireNonNull(v1, "v1"); + Objects.requireNonNull(v2, "v2"); + bindOwner(v1); + bindOwner(v2); + qVar1.add(v1); + qVar2.add(v2); + qCoeff.add(coeff); + return this; + } + + /** Adds a scalar offset. */ + public QuadraticExpr addConstant(double c) { + linearPart.addConstant(c); + return this; + } + + /** Adds another quadratic expression. */ + public QuadraticExpr add(QuadraticExpr other) { + Objects.requireNonNull(other, "other"); + linearPart.add(other.linearPart); + for (int i = 0; i < other.qVar1.size(); i++) { + addQuadraticTerm(other.qCoeff.get(i), other.qVar1.get(i), other.qVar2.get(i)); + } + return this; + } + + /** Adds a linear expression to the linear part. */ + public QuadraticExpr add(LinearExpr linear) { + Objects.requireNonNull(linear, "linear"); + if (linear.owner() != null) { + if (owner == null) owner = linear.owner(); + else if (owner != linear.owner()) { + throw new IllegalArgumentException( + "Cannot mix variables from different Problems in one QuadraticExpr"); + } + } + linearPart.add(linear); + return this; + } + + /** Number of quadratic (non-linear) terms. */ + public int numQuadraticTerms() { + return qVar1.size(); + } + + public LinearExpr linearPart() { + return linearPart; + } + + public Problem owner() { + return owner != null ? owner : linearPart.owner(); + } + + // ── internal accessors used by the FFM implementation + // (public for cross-package access from internal/; not part of + // the stable user-facing API — do not rely on these in user code) ─ + + public Variable quadVar1(int i) { + return qVar1.get(i); + } + + public Variable quadVar2(int i) { + return qVar2.get(i); + } + + public double quadCoeff(int i) { + return qCoeff.get(i); + } + + private void bindOwner(Variable v) { + if (owner == null) { + owner = v.owner(); + } else if (owner != v.owner()) { + throw new IllegalArgumentException( + "Cannot mix variables from different Problems in one QuadraticExpr"); + } + } +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/Sense.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/Sense.java new file mode 100644 index 000000000..98990a404 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/Sense.java @@ -0,0 +1,27 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +/** + * Objective sense for {@code Problem.setObjective(...)}. + * + *

Maps to the C API constants {@code CUOPT_MINIMIZE} (1) and + * {@code CUOPT_MAXIMIZE} (-1). + */ +public enum Sense { + MINIMIZE(1), + MAXIMIZE(-1); + + private final int code; + + Sense(int code) { + this.code = code; + } + + /** Returns the C-API int encoding (1 for MINIMIZE, -1 for MAXIMIZE). */ + public int code() { + return code; + } +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/SolverMethod.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/SolverMethod.java new file mode 100644 index 000000000..793551751 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/SolverMethod.java @@ -0,0 +1,39 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +/** + * Solver method selection for LP problems. + * + *

Maps to the C API constants {@code CUOPT_METHOD_*}. + */ +public enum SolverMethod { + CONCURRENT(0), + PDLP(1), + DUAL_SIMPLEX(2), + BARRIER(3), + UNSET(4); + + private final int code; + + SolverMethod(int code) { + this.code = code; + } + + /** Returns the C-API int encoding. */ + public int code() { + return code; + } + + /** Inverse of {@link #code()}. Throws {@link IllegalArgumentException} for unknown codes. */ + public static SolverMethod fromCode(int code) { + for (SolverMethod m : values()) { + if (m.code == code) { + return m; + } + } + throw new IllegalArgumentException("Unknown SolverMethod code: " + code); + } +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/SolverSettings.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/SolverSettings.java new file mode 100644 index 000000000..a52351cf3 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/SolverSettings.java @@ -0,0 +1,239 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +import com.nvidia.cuopt.cuOpt; +import com.nvidia.cuopt.cuOptException; +import com.nvidia.cuopt.spi.cuOptProvider; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Objects; + +/** + * Solver tuning settings. {@link AutoCloseable} — owns a native + * {@code cuOptSolverSettings} handle. + * + *

Top-frequency parameters have typed setters with IDE autocomplete. + * Anything else falls through to {@link #setParameter(String, Object)} + * for forward compatibility with new C-API parameters. + * + * 

{@code
+ *   try (var settings = new SolverSettings()
+ *           .setTimeLimit(60)
+ *           .setOptimalityTolerance(1e-6)
+ *           .setMethod(SolverMethod.PDLP)) {
+ *       // ...
+ *   }
+ * }
+ */ +public final class SolverSettings implements AutoCloseable { + + // We hold parameter values in a Java-side map and replay them onto + // the native handle lazily (just before solve, or eagerly on each + // setParameter call). For now we replay eagerly via the SPI. + private final Map parameters = new LinkedHashMap<>(); + private long nativeHandle; // address of the native cuOptSolverSettings + private boolean closed = false; + + // MIP user callbacks. The Java 22 FFM impl reads these at solve time + // and binds them to per-solve Arena-scoped upcall stubs. + private MIPGetSolutionCallback mipGetCallback; + private MIPSetSolutionCallback mipSetCallback; + + public SolverSettings() { + this.nativeHandle = cuOptProvider.instance().createSolverSettings(); + } + + // ── typed setters (top-frequency parameters) ───────────────── + + public SolverSettings setTimeLimit(double seconds) { + return setFloatParameter(cuOpt.TIME_LIMIT, seconds); + } + + public SolverSettings setIterationLimit(long iterations) { + return setIntegerParameter(cuOpt.ITERATION_LIMIT, iterations); + } + + public SolverSettings setOptimalityTolerance(double eps) { + // Cuopt's "optimality tolerance" is the relative gap tolerance. + return setFloatParameter(cuOpt.RELATIVE_GAP_TOLERANCE, eps); + } + + public SolverSettings setMethod(SolverMethod method) { + return setIntegerParameter(cuOpt.METHOD, method.code()); + } + + public SolverSettings setPdlpSolverMode(PdlpSolverMode mode) { + return setIntegerParameter(cuOpt.PDLP_SOLVER_MODE, mode.code()); + } + + public SolverSettings setRelativeMipGap(double gap) { + return setFloatParameter(cuOpt.MIP_RELATIVE_GAP, gap); + } + + public SolverSettings setAbsoluteMipGap(double gap) { + return setFloatParameter(cuOpt.MIP_ABSOLUTE_GAP, gap); + } + + public SolverSettings setLogToConsole(boolean enabled) { + return setIntegerParameter(cuOpt.LOG_TO_CONSOLE, enabled ? 1 : 0); + } + + public SolverSettings setNumCpuThreads(int n) { + return setIntegerParameter(cuOpt.NUM_CPU_THREADS, n); + } + + public SolverSettings setRandomSeed(long seed) { + return setIntegerParameter(cuOpt.RANDOM_SEED, seed); + } + + // ── MIP user callbacks ─────────────────────────────────────── + + /** + * Registers a callback to receive incumbent MIP solutions. The + * callback is invoked by the solver each time a new incumbent is + * found. Note: only meaningful for MIP solves. + * + *

Pass {@code null} to clear a previously-set callback. + * + * @see MIPGetSolutionCallback + */ + public SolverSettings setMIPGetSolutionCallback(MIPGetSolutionCallback cb) { + checkOpen(); + this.mipGetCallback = cb; + return this; + } + + /** + * Registers a callback to inject candidate MIP solutions. + * Registering this callback disables presolve. + * + *

Pass {@code null} to clear a previously-set callback. Note: once + * a non-null callback has been registered and used in a solve, + * clearing it on the same {@code SolverSettings} and reusing for + * another solve is not supported (the previous native registration + * persists). Create a fresh {@link SolverSettings} instead. + * + * @see MIPSetSolutionCallback + */ + public SolverSettings setMIPSetSolutionCallback(MIPSetSolutionCallback cb) { + checkOpen(); + this.mipSetCallback = cb; + return this; + } + + /** Returns the registered MIP get-solution callback, or {@code null}. */ + public MIPGetSolutionCallback getMIPGetSolutionCallback() { + return mipGetCallback; + } + + /** Returns the registered MIP set-solution callback, or {@code null}. */ + public MIPSetSolutionCallback getMIPSetSolutionCallback() { + return mipSetCallback; + } + + // ── generic escape hatch ───────────────────────────────────── + + /** + * Sets a parameter by name. Dispatches to the appropriate typed C-side + * setter based on the value's runtime type: + * + *

    + *
  • {@code Integer}, {@code Long}, {@code Boolean}, or an enum + * with an {@code int code()} method → integer parameter
    • + *
  • {@code Float}, {@code Double} → float parameter
    • + *
  • {@code String} or anything else → string parameter + * (via {@code Object.toString()})
    • + *
+ */ + public SolverSettings setParameter(String name, Object value) { + Objects.requireNonNull(name, "name"); + Objects.requireNonNull(value, "value"); + checkOpen(); + parameters.put(name, value); + + if (value instanceof Boolean b) { + setIntegerParameter(name, b ? 1 : 0); + } else if (value instanceof Integer i) { + setIntegerParameter(name, i.longValue()); + } else if (value instanceof Long l) { + setIntegerParameter(name, l); + } else if (value instanceof Float f) { + setFloatParameter(name, f.doubleValue()); + } else if (value instanceof Double d) { + setFloatParameter(name, d); + } else if (value instanceof SolverMethod sm) { + setIntegerParameter(name, sm.code()); + } else if (value instanceof PdlpSolverMode pm) { + setIntegerParameter(name, pm.code()); + } else if (value instanceof Enum e) { + // Best-effort: try to find a code() method; fallback to ordinal. + try { + java.lang.reflect.Method m = e.getClass().getMethod("code"); + Object code = m.invoke(e); + if (code instanceof Integer ci) { + setIntegerParameter(name, ci.longValue()); + } else if (code instanceof Long cl) { + setIntegerParameter(name, cl); + } else { + setIntegerParameter(name, ((Number) code).longValue()); + } + } catch (ReflectiveOperationException reflectFail) { + setIntegerParameter(name, e.ordinal()); + } + } else { + setStringParameter(name, value.toString()); + } + return this; + } + + public SolverSettings setIntegerParameter(String name, long value) { + checkOpen(); + parameters.put(name, value); + cuOptProvider.instance().setSolverIntegerParameter(nativeHandle, name, value); + return this; + } + + public SolverSettings setFloatParameter(String name, double value) { + checkOpen(); + parameters.put(name, value); + cuOptProvider.instance().setSolverFloatParameter(nativeHandle, name, value); + return this; + } + + public SolverSettings setStringParameter(String name, String value) { + checkOpen(); + parameters.put(name, value); + cuOptProvider.instance().setSolverStringParameter(nativeHandle, name, value); + return this; + } + + /** Returns the last-set value for a parameter, or {@code null} if never set. */ + public Object getParameter(String name) { + return parameters.get(name); + } + + // ── internal accessor used by the FFM implementation + // (public for cross-package access; not for user code) ──── + + public long nativeHandle() { + checkOpen(); + return nativeHandle; + } + + private void checkOpen() { + if (closed) { + throw new cuOptException("SolverSettings has been closed"); + } + } + + @Override + public synchronized void close() { + if (closed) return; + closed = true; + cuOptProvider.instance().destroySolverSettings(nativeHandle); + nativeHandle = 0L; + } +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/TerminationStatus.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/TerminationStatus.java new file mode 100644 index 000000000..06fe9bf1d --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/TerminationStatus.java @@ -0,0 +1,45 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +/** + * Solver termination status. Returned by {@code Problem.status()} after + * {@code Problem.solve(...)}. + * + *

Maps to the C API constants {@code CUOPT_TERMINATION_STATUS_*}. + */ +public enum TerminationStatus { + NO_TERMINATION(0), + OPTIMAL(1), + INFEASIBLE(2), + UNBOUNDED(3), + ITERATION_LIMIT(4), + TIME_LIMIT(5), + NUMERICAL_ERROR(6), + PRIMAL_FEASIBLE(7), + FEASIBLE_FOUND(8), + CONCURRENT_LIMIT(9), + WORK_LIMIT(10), + UNBOUNDED_OR_INFEASIBLE(11); + + private final int code; + + TerminationStatus(int code) { + this.code = code; + } + + public int code() { + return code; + } + + public static TerminationStatus fromCode(int code) { + for (TerminationStatus s : values()) { + if (s.code == code) { + return s; + } + } + throw new IllegalArgumentException("Unknown TerminationStatus code: " + code); + } +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/VType.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/VType.java new file mode 100644 index 000000000..92a2e5475 --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/VType.java @@ -0,0 +1,30 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +/** + * Variable type for {@code Problem.addVariable(...)}. + * + *

The C API only distinguishes {@code CONTINUOUS} (char {@code 'C'}) + * and {@code INTEGER} (char {@code 'I'}). {@code BINARY} is exposed as + * a convenience — it's equivalent to {@code INTEGER} with bounds + * {@code [0, 1]}, and is marshalled to the C side as {@code 'I'}. + */ +public enum VType { + CONTINUOUS('C'), + INTEGER('I'), + BINARY('I'); + + private final char code; + + VType(char code) { + this.code = code; + } + + /** Returns the C-API char encoding ({@code 'C'} or {@code 'I'}). */ + public char code() { + return code; + } +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/Variable.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/Variable.java new file mode 100644 index 000000000..5e42f6f7f --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/optimization/Variable.java @@ -0,0 +1,111 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +import com.nvidia.cuopt.cuOptException; +import java.util.Objects; + +/** + * A decision variable owned by a {@link Problem}. + * + *

{@code Variable} is an immutable handle — all fields are + * {@code final}. Post-solve accessors ({@link #value()}, + * {@link #reducedCost()}) delegate back to the owning Problem rather + * than holding state themselves. + * + *

Variables are equal iff they refer to the same Problem and have + * the same index. + */ +public final class Variable { + + private final Problem owner; + private final int index; + private final double lowerBound; + private final double upperBound; + private final VType variableType; + private final String name; + + // Package-private — only Problem can create Variables. + Variable(Problem owner, int index, double lowerBound, double upperBound, + VType variableType, String name) { + this.owner = Objects.requireNonNull(owner, "owner"); + this.index = index; + this.lowerBound = lowerBound; + this.upperBound = upperBound; + this.variableType = Objects.requireNonNull(variableType, "variableType"); + this.name = name == null ? "" : name; + } + + // ── identity / spec accessors ──────────────────────────────── + + /** Zero-based index of this variable in its owning Problem. */ + public int index() { + return index; + } + + /** Variable name; empty string if none provided. */ + public String name() { + return name; + } + + public double lowerBound() { + return lowerBound; + } + + public double upperBound() { + return upperBound; + } + + public VType variableType() { + return variableType; + } + + // ── post-solve accessors (delegate to owning Problem) ──────── + + /** + * Primal value of this variable in the current solution. + * + * @throws cuOptException if the owning Problem has not been solved + * or has been closed. + */ + public double value() { + return owner.primalValueOf(index); + } + + /** + * Reduced cost of this variable in the current LP solution. LP only; + * returns {@code Double.NaN} for MIP solves. + * + * @throws cuOptException if the owning Problem has not been solved + * or has been closed. + */ + public double reducedCost() { + return owner.reducedCostOf(index); + } + + // ── equality / hashing ─────────────────────────────────────── + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof Variable other)) return false; + return owner == other.owner && index == other.index; + } + + @Override + public int hashCode() { + return System.identityHashCode(owner) * 31 + index; + } + + @Override + public String toString() { + return name.isEmpty() ? "Variable[" + index + "]" : "Variable[" + name + "]"; + } + + // Package-private accessor for owner identity checks in expressions. + Problem owner() { + return owner; + } +} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/spi/SolveResult.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/spi/SolveResult.java new file mode 100644 index 000000000..0a4c2dceb --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/spi/SolveResult.java @@ -0,0 +1,38 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.spi; + +import com.nvidia.cuopt.optimization.ErrorStatus; +import com.nvidia.cuopt.optimization.LpStats; +import com.nvidia.cuopt.optimization.MIPStats; +import com.nvidia.cuopt.optimization.SolverMethod; +import com.nvidia.cuopt.optimization.TerminationStatus; + +/** + * Internal data carrier from the FFM implementation back to the + * {@link com.nvidia.cuopt.optimization.Problem} or + * {@link com.nvidia.cuopt.optimization.Problem} that requested + * the solve. Pre-extracted from the native {@code cuOptSolution} + * handle before that handle is freed. + * + *

This is on the SPI boundary because {@code Problem} (Java 21) + * cannot reference Java 22 FFM types. Pure Java types only. + */ +public record SolveResult( + double[] primalSolution, + double[] dualSolution, + double[] reducedCost, + double[] slack, + TerminationStatus terminationStatus, + String terminationReason, + ErrorStatus errorStatus, + String errorMessage, + double objectiveValue, + double dualObjectiveValue, + double solveTime, + SolverMethod solvedBy, + LpStats lpStats, + MIPStats mipStats +) {} diff --git a/java/cuopt-java/src/main/java/com/nvidia/cuopt/spi/cuOptProvider.java b/java/cuopt-java/src/main/java/com/nvidia/cuopt/spi/cuOptProvider.java new file mode 100644 index 000000000..70153e4db --- /dev/null +++ b/java/cuopt-java/src/main/java/com/nvidia/cuopt/spi/cuOptProvider.java @@ -0,0 +1,88 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.spi; + +import com.nvidia.cuopt.cuOptException; +import com.nvidia.cuopt.optimization.Problem; +import com.nvidia.cuopt.optimization.SolverSettings; +import java.util.ServiceLoader; + +/** + * Service provider interface bridging the Java 21 public API to the + * Java 22 FFM implementation. + * + *

This interface compiles to Java 21 release. Method signatures use + * only Java 21-compatible types (no {@code MemorySegment}, no + * {@code Arena}) — native handles cross the boundary as opaque + * {@code long} values (raw addresses). + * + *

The implementation lives in + * {@code com.nvidia.cuopt.internal.cuOptProviderImpl} under + * {@code src/main/java22/}; the JVM resolves it via + * {@link java.util.ServiceLoader} on Java 22+ runtimes. + */ +public interface cuOptProvider { + + // ── library-level ──────────────────────────────────────────── + + /** + * Returns the cuOpt library version as a human-readable string in + * {@code major.minor.patch} format. + */ + String getVersion(); + + // ── SolverSettings lifecycle (native cuOptSolverSettings) ──── + + /** Creates a native solver-settings handle. Returns the raw pointer as {@code long}. */ + long createSolverSettings(); + + /** Destroys a native solver-settings handle. Idempotent on already-destroyed handles. */ + void destroySolverSettings(long handle); + + void setSolverIntegerParameter(long handle, String name, long value); + void setSolverFloatParameter(long handle, String name, double value); + void setSolverStringParameter(long handle, String name, String value); + + // ── Solve entry points ─────────────────────────────────────── + + /** + * Solves the given Problem with the given settings (or default settings + * if {@code null}). Builds the native problem handle from + * {@code problem}'s collected variables / constraints / objective, + * calls {@code cuOptSolve}, extracts all solution data into a + * {@link SolveResult}, then frees the native solution and problem + * handles before returning. + */ + SolveResult solveProblem(Problem problem, SolverSettings settings); + + // ── lookup ─────────────────────────────────────────────────── + + /** + * Returns the singleton implementation, resolved via + * {@link ServiceLoader}. + * + * @throws cuOptException if no implementation is registered + * (e.g., running on Java 21 — the FFM + * impl lives in the Java 22 multi-release + * layer of the JAR and is not visible to + * Java 21 JVMs). + */ + static cuOptProvider instance() { + return Holder.INSTANCE; + } + + final class Holder { + private static final cuOptProvider INSTANCE = ServiceLoader + .load(cuOptProvider.class) + .findFirst() + .orElseThrow(() -> new cuOptException( + "No cuOptProvider implementation found. cuopt-java requires " + + "Java 22 or higher at runtime; the FFM implementation lives " + + "in the Java 22 multi-release layer of the JAR and is not " + + "visible to Java 21 JVMs.")); + + private Holder() {} + } +} diff --git a/java/cuopt-java/src/main/java22/com/nvidia/cuopt/README.md b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/README.md new file mode 100644 index 000000000..78d76e892 --- /dev/null +++ b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/README.md @@ -0,0 +1,29 @@ +# Layers 3 + 2 — FFM Implementation and Panama Bindings (Java 22) + +Code in this directory compiles to **Java 22 release** and lives in +`META-INF/versions/22/` of the published JAR. It only loads on JVMs at +Java 22 or higher. + +## Layer 3 — FFM Implementation (`internal/`) + +- `cuOptProviderImpl` — the SPI implementation. Bridges Layer 5's public + API to the panama bindings. +- `NativeLibraryLoader` — loads `libcuopt.so` (or `.dll`/`.dylib`). + Reads `META-INF/cuopt/supported-platforms.properties` for the platform + table; falls back to `java.library.path` if the lib isn't bundled in + the JAR. + +Each native-handle-owning class will hold its own `Arena.ofConfined()` +when full LP / MILP / QP support lands. For the current `getVersion()` +demo, the only allocations are short-lived per-call segments. + +## Layer 2 — Panama Bindings (`internal/panama/`) + +Generated by `jextract` from `cpp/include/cuopt/linear_programming/cuopt_c.h`. +**Never edited by hand.** Regenerated on every build by +`../../../panama-bindings/generate-bindings.sh`. + +A drift gate in `build.sh` runs `git diff --exit-code` after +regeneration — any drift between the generated output and the committed +files fails the build, forcing a deliberate commit of the regenerated +bindings. diff --git a/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/CSRBuilder.java b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/CSRBuilder.java new file mode 100644 index 000000000..88b1b6bcc --- /dev/null +++ b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/CSRBuilder.java @@ -0,0 +1,152 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.internal; + +import com.nvidia.cuopt.optimization.LinearExpr; +import com.nvidia.cuopt.optimization.QuadraticExpr; +import com.nvidia.cuopt.optimization.Variable; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +/** + * Builds CSR (compressed sparse row) representations from + * {@link LinearExpr} / {@link QuadraticExpr} for the FFM bridge. + * + *

Output arrays are ready to copy into native {@code MemorySegment}s. + */ +final class CSRBuilder { + + private CSRBuilder() {} + + /** Output of CSR construction for the linear constraint matrix. */ + static final class CSR { + final int[] rowOffsets; + final int[] colIndices; + final double[] values; + + CSR(int[] rowOffsets, int[] colIndices, double[] values) { + this.rowOffsets = rowOffsets; + this.colIndices = colIndices; + this.values = values; + } + } + + /** + * Builds CSR for the constraint matrix. One row per constraint + * expression, terms sorted by column (variable index) within each + * row. Empty constraints produce a row with no non-zeros. + */ + static CSR buildConstraintCSR(List rows) { + int numRows = rows.size(); + int[] rowOffsets = new int[numRows + 1]; + + // First pass: count non-zeros to size the value/column arrays. + int totalNnz = 0; + for (LinearExpr e : rows) { + totalNnz += e.numTerms(); + } + int[] colIndices = new int[totalNnz]; + double[] values = new double[totalNnz]; + + int writeIdx = 0; + for (int i = 0; i < numRows; i++) { + rowOffsets[i] = writeIdx; + LinearExpr row = rows.get(i); + // Materialize sorted-by-column entries. + List indexBox = new ArrayList<>(row.numTerms()); + List valueBox = new ArrayList<>(row.numTerms()); + for (Map.Entry e : row.terms().entrySet()) { + indexBox.add(new int[]{e.getKey().index()}); + valueBox.add(e.getValue()); + } + // Sort by column index ascending. + Integer[] sortIdx = new Integer[row.numTerms()]; + for (int k = 0; k < sortIdx.length; k++) sortIdx[k] = k; + int[][] indexFinal = indexBox.toArray(new int[0][]); + Double[] valueFinal = valueBox.toArray(new Double[0]); + java.util.Arrays.sort(sortIdx, + (a, b) -> Integer.compare(indexFinal[a][0], indexFinal[b][0])); + + for (int k = 0; k < sortIdx.length; k++) { + colIndices[writeIdx] = indexFinal[sortIdx[k]][0]; + values[writeIdx] = valueFinal[sortIdx[k]]; + writeIdx++; + } + } + rowOffsets[numRows] = writeIdx; + return new CSR(rowOffsets, colIndices, values); + } + + /** + * Builds CSR for the quadratic-objective Q matrix, indexed by + * variable (rows = variables, cols = variables). The user-supplied + * quadratic terms may be upper-triangular or full; we forward them + * as given. cuOpt is expected to accept either form and symmetrize + * internally. + * + *

Returns CSR with {@code numVariables + 1} row offsets. + */ + static CSR buildQuadraticCSR(QuadraticExpr qexpr, int numVariables) { + int n = qexpr.numQuadraticTerms(); + int[] rowOffsets = new int[numVariables + 1]; + + // Bucket entries by row (var1.index()), sort each bucket by col. + List entriesByRow = new ArrayList<>(numVariables); + for (int i = 0; i < numVariables; i++) entriesByRow.add(null); + + // Collect (row, col, val) triples. + int[] rowsRaw = new int[n]; + int[] colsRaw = new int[n]; + double[] valsRaw = new double[n]; + for (int i = 0; i < n; i++) { + rowsRaw[i] = qexpr.quadVar1(i).index(); + colsRaw[i] = qexpr.quadVar2(i).index(); + valsRaw[i] = qexpr.quadCoeff(i); + } + + // Count entries per row. + int[] rowCount = new int[numVariables]; + for (int i = 0; i < n; i++) rowCount[rowsRaw[i]]++; + + rowOffsets[0] = 0; + for (int i = 0; i < numVariables; i++) rowOffsets[i + 1] = rowOffsets[i] + rowCount[i]; + + int[] colIndices = new int[n]; + double[] values = new double[n]; + int[] cursor = new int[numVariables]; + for (int i = 0; i < n; i++) { + int r = rowsRaw[i]; + int pos = rowOffsets[r] + cursor[r]++; + colIndices[pos] = colsRaw[i]; + values[pos] = valsRaw[i]; + } + + // Sort each row by column index. + for (int r = 0; r < numVariables; r++) { + int start = rowOffsets[r]; + int end = rowOffsets[r + 1]; + sortRow(colIndices, values, start, end); + } + return new CSR(rowOffsets, colIndices, values); + } + + private static void sortRow(int[] cols, double[] vals, int start, int end) { + // Simple insertion sort; row sizes in OR matrices are typically small. + for (int i = start + 1; i < end; i++) { + int col = cols[i]; + double val = vals[i]; + int j = i - 1; + while (j >= start && cols[j] > col) { + cols[j + 1] = cols[j]; + vals[j + 1] = vals[j]; + j--; + } + cols[j + 1] = col; + vals[j + 1] = val; + } + } +} diff --git a/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/NativeLibraryLoader.java b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/NativeLibraryLoader.java new file mode 100644 index 000000000..de4a32eeb --- /dev/null +++ b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/NativeLibraryLoader.java @@ -0,0 +1,190 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.internal; + +import com.nvidia.cuopt.cuOptException; +import java.io.IOException; +import java.io.InputStream; +import java.net.URL; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.StandardCopyOption; +import java.security.CodeSource; +import java.util.Locale; +import java.util.Properties; +import java.util.jar.Attributes; +import java.util.jar.JarFile; +import java.util.jar.Manifest; + +/** + * Loads {@code libcuopt.so} (and its bundled RAPIDS dependencies, when + * present) on first use. + * + *

Two modes, chosen automatically by inspecting the JAR manifest: + * + *

    + *
  1. Embedded mode — the JAR carries the manifest entry + * {@code Embedded-Libraries-Cuda-Version}. Native libs are + * extracted from {@code //} entries in the JAR to a + * temporary directory and {@code System.load}-ed in dependency + * order. Used by classifier JARs + * (e.g. {@code cuopt-java--x86_64-cuda13.jar}) which bundle + * {@code libcuopt.so}, {@code libmps_parser.so}, {@code librmm.so}, + * and {@code librapids_logger.so}.
    2. + *
  2. System (BYO) mode — the JAR has no + * {@code Embedded-Libraries-Cuda-Version} entry. Falls back to + * {@code System.loadLibrary("cuopt")}, requiring the user to have + * {@code libcuopt.so} on {@code java.library.path} (typical conda + * install).
    3. + *
+ * + *

The platform table at + * {@code META-INF/cuopt/supported-platforms.properties} controls which + * OS+arch combinations are accepted. + */ +public final class NativeLibraryLoader { + + private static final String PLATFORM_PROPS = + "/META-INF/cuopt/supported-platforms.properties"; + + private static final String EMBEDDED_MARKER = "Embedded-Libraries-Cuda-Version"; + + /** + * Libraries bundled in classifier JARs, in load order. {@code libcuopt} + * dlopen-resolves symbols from {@code librmm} and {@code librapids_logger} + * at load time, so those must be present in memory before + * {@code libcuopt} is loaded. + */ + private static final String[] EMBEDDED_LIBS = { + "rapids_logger", "rmm", "mps_parser", "cuopt", + }; + + private static volatile boolean loaded = false; + + private NativeLibraryLoader() {} + + /** + * Idempotent load of {@code libcuopt} and its bundled deps (if any). + * Safe to call from multiple threads. + */ + public static synchronized void ensureLoaded() { + if (loaded) { + return; + } + verifyPlatformSupported(); + if (jarHasEmbeddedLibraries()) { + loadEmbedded(); + } else { + loadSystem(); + } + loaded = true; + } + + private static void loadSystem() { + try { + System.loadLibrary("cuopt"); + } catch (UnsatisfiedLinkError e) { + throw new cuOptException( + "Failed to load libcuopt. Either add the directory containing " + + "libcuopt.so to java.library.path (typical conda install), " + + "or use a classifier JAR that bundles the native library " + + "(e.g. cuopt-java--x86_64-cuda13.jar).", + e); + } + } + + private static void loadEmbedded() { + String os = System.getProperty("os.name", ""); + String arch = System.getProperty("os.arch", ""); + for (String name : EMBEDDED_LIBS) { + String libFile = System.mapLibraryName(name); + String resourcePath = "/" + arch + "/" + os + "/" + libFile; + try { + Path extracted = extractResource(resourcePath, libFile); + System.load(extracted.toAbsolutePath().toString()); + } catch (Throwable t) { + throw new cuOptException( + "Failed to load embedded native dependency: " + libFile + + " from resource path " + resourcePath, t); + } + } + } + + private static Path extractResource(String resourcePath, String libFile) + throws IOException { + URL url = NativeLibraryLoader.class.getResource(resourcePath); + if (url == null) { + throw new IOException( + "Embedded native library not found at " + resourcePath); + } + Path tmp = Files.createTempFile("cuopt-native-", "-" + libFile); + tmp.toFile().deleteOnExit(); + try (InputStream in = url.openStream()) { + Files.copy(in, tmp, StandardCopyOption.REPLACE_EXISTING); + } + return tmp; + } + + private static boolean jarHasEmbeddedLibraries() { + // Locate the JAR that this class was loaded from, not any other + // META-INF/MANIFEST.MF that happens to be on the classpath. + CodeSource codeSource = NativeLibraryLoader.class.getProtectionDomain().getCodeSource(); + if (codeSource == null || codeSource.getLocation() == null) { + return false; + } + String path = codeSource.getLocation().getPath(); + if (path == null || !path.endsWith(".jar")) { + // Running from exploded classes (e.g. surefire on target/classes/); + // there is no JAR manifest to inspect. + return false; + } + try (JarFile jar = new JarFile(path)) { + Manifest manifest = jar.getManifest(); + if (manifest == null) { + return false; + } + Attributes attrs = manifest.getMainAttributes(); + return attrs.getValue(EMBEDDED_MARKER) != null; + } catch (IOException e) { + return false; + } + } + + private static void verifyPlatformSupported() { + String os = System.getProperty("os.name", "").toLowerCase(Locale.ROOT); + String arch = System.getProperty("os.arch", "").toLowerCase(Locale.ROOT); + String key = osKey(os) + "-" + archKey(arch); + + Properties props = new Properties(); + try (InputStream in = NativeLibraryLoader.class.getResourceAsStream(PLATFORM_PROPS)) { + if (in == null) { + throw new cuOptException( + "Internal error: " + PLATFORM_PROPS + " not found in JAR."); + } + props.load(in); + } catch (IOException e) { + throw new cuOptException("Failed to read " + PLATFORM_PROPS, e); + } + + if (!"true".equalsIgnoreCase(props.getProperty(key))) { + throw new cuOptException( + "Unsupported platform: " + key + ". Supported platforms: " + + props.stringPropertyNames()); + } + } + + private static String osKey(String os) { + if (os.contains("linux")) return "linux"; + if (os.contains("mac") || os.contains("darwin")) return "macos"; + if (os.contains("win")) return "windows"; + return os; + } + + private static String archKey(String arch) { + if (arch.equals("amd64") || arch.equals("x86_64")) return "amd64"; + if (arch.equals("aarch64") || arch.equals("arm64")) return "aarch64"; + return arch; + } +} diff --git a/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/cuOptProviderImpl.java b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/cuOptProviderImpl.java new file mode 100644 index 000000000..bd484c56c --- /dev/null +++ b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/cuOptProviderImpl.java @@ -0,0 +1,502 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.internal; + +import com.nvidia.cuopt.cuOptException; +import com.nvidia.cuopt.internal.panama.cuOptMIPGetSolutionCallback; +import com.nvidia.cuopt.internal.panama.cuOptMIPSetSolutionCallback; +import com.nvidia.cuopt.internal.panama.cuopt_c_h; +import com.nvidia.cuopt.optimization.CType; +import com.nvidia.cuopt.optimization.Constraint; +import com.nvidia.cuopt.optimization.ErrorStatus; +import com.nvidia.cuopt.optimization.LinearExpr; +import com.nvidia.cuopt.optimization.LpStats; +import com.nvidia.cuopt.optimization.MIPGetSolutionCallback; +import com.nvidia.cuopt.optimization.MIPSetSolutionCallback; +import com.nvidia.cuopt.optimization.MIPStats; +import com.nvidia.cuopt.optimization.Problem; +import com.nvidia.cuopt.optimization.QuadraticExpr; +import com.nvidia.cuopt.optimization.SolverMethod; +import com.nvidia.cuopt.optimization.SolverSettings; +import com.nvidia.cuopt.optimization.TerminationStatus; +import com.nvidia.cuopt.optimization.VType; +import com.nvidia.cuopt.optimization.Variable; +import com.nvidia.cuopt.spi.cuOptProvider; +import com.nvidia.cuopt.spi.SolveResult; +import java.lang.foreign.Arena; +import java.lang.foreign.MemorySegment; +import java.lang.foreign.ValueLayout; +import java.nio.charset.StandardCharsets; +import java.util.List; + +/** + * FFM implementation of {@link cuOptProvider}. Registered via + * {@code META-INF/services/com.nvidia.cuopt.spi.cuOptProvider}. + * + *

Lives in the Java 22 multi-release layer; loaded only on JVMs at + * Java 22 or higher. + * + *

Native handles cross the SPI boundary as {@code long} (raw + * addresses); this class reconstructs {@code MemorySegment} from the + * addresses on each call. + */ +public final class cuOptProviderImpl implements cuOptProvider { + + public cuOptProviderImpl() { + NativeLibraryLoader.ensureLoaded(); + } + + // ── library-level ──────────────────────────────────────────── + + @Override + public String getVersion() { + try (Arena arena = Arena.ofConfined()) { + MemorySegment major = arena.allocate(ValueLayout.JAVA_INT); + MemorySegment minor = arena.allocate(ValueLayout.JAVA_INT); + MemorySegment patch = arena.allocate(ValueLayout.JAVA_INT); + + int rc = cuopt_c_h.cuOptGetVersion(major, minor, patch); + checkRc(rc, "cuOptGetVersion"); + return major.get(ValueLayout.JAVA_INT, 0) + + "." + minor.get(ValueLayout.JAVA_INT, 0) + + "." + patch.get(ValueLayout.JAVA_INT, 0); + } + } + + // ── SolverSettings lifecycle ───────────────────────────────── + + @Override + public long createSolverSettings() { + try (Arena local = Arena.ofConfined()) { + MemorySegment outPtr = local.allocate(ValueLayout.ADDRESS); + int rc = cuopt_c_h.cuOptCreateSolverSettings(outPtr); + checkRc(rc, "cuOptCreateSolverSettings"); + return outPtr.get(ValueLayout.ADDRESS, 0).address(); + } + } + + @Override + public void destroySolverSettings(long handle) { + if (handle == 0L) return; + try (Arena local = Arena.ofConfined()) { + MemorySegment ptr = local.allocate(ValueLayout.ADDRESS); + ptr.set(ValueLayout.ADDRESS, 0, MemorySegment.ofAddress(handle)); + cuopt_c_h.cuOptDestroySolverSettings(ptr); + } + } + + @Override + public void setSolverIntegerParameter(long handle, String name, long value) { + try (Arena local = Arena.ofConfined()) { + MemorySegment nameSeg = cString(local, name); + int rc = cuopt_c_h.cuOptSetIntegerParameter( + MemorySegment.ofAddress(handle), nameSeg, (int) value); + checkRc(rc, "cuOptSetIntegerParameter(" + name + ")"); + } + } + + @Override + public void setSolverFloatParameter(long handle, String name, double value) { + try (Arena local = Arena.ofConfined()) { + MemorySegment nameSeg = cString(local, name); + int rc = cuopt_c_h.cuOptSetFloatParameter( + MemorySegment.ofAddress(handle), nameSeg, value); + checkRc(rc, "cuOptSetFloatParameter(" + name + ")"); + } + } + + @Override + public void setSolverStringParameter(long handle, String name, String value) { + try (Arena local = Arena.ofConfined()) { + MemorySegment nameSeg = cString(local, name); + MemorySegment valueSeg = cString(local, value); + int rc = cuopt_c_h.cuOptSetParameter( + MemorySegment.ofAddress(handle), nameSeg, valueSeg); + checkRc(rc, "cuOptSetParameter(" + name + ")"); + } + } + + // ── solve entry points ─────────────────────────────────────── + + @Override + public SolveResult solveProblem(Problem problem, SolverSettings settings) { + try (Arena arena = Arena.ofConfined()) { + ProblemBuild build = buildNativeProblem(arena, problem); + return solveAndExtract(arena, problem, build, settings); + } + } + + + // ── native problem construction from Problem (modeling API) ── + + private static final class ProblemBuild { + long problemHandle; + int numVariables; + int numConstraints; + + ProblemBuild(long handle, int numVariables, int numConstraints) { + this.problemHandle = handle; + this.numVariables = numVariables; + this.numConstraints = numConstraints; + } + } + + private ProblemBuild buildNativeProblem(Arena arena, Problem problem) { + int numV = problem.numVariables(); + int numC = problem.numConstraints(); + + // Variable bounds + types + double[] varLb = new double[numV]; + double[] varUb = new double[numV]; + byte[] varTypes = new byte[numV]; + boolean anyBinary = false; + for (int i = 0; i < numV; i++) { + Variable v = problem.getVariable(i); + varLb[i] = v.lowerBound(); + varUb[i] = v.upperBound(); + varTypes[i] = (byte) v.variableType().code(); + if (v.variableType() == VType.BINARY) anyBinary = true; + } + // BINARY is INTEGER with bounds clamped to [0, 1]. The user may + // already have set these bounds, but enforce here too. + if (anyBinary) { + for (int i = 0; i < numV; i++) { + if (problem.getVariable(i).variableType() == VType.BINARY) { + if (Double.isNaN(varLb[i]) || varLb[i] < 0.0) varLb[i] = 0.0; + if (Double.isNaN(varUb[i]) || varUb[i] > 1.0) varUb[i] = 1.0; + } + } + } + + // Build constraint CSR from per-constraint LinearExprs. + List rows = problem.constraintExpressions(); + CSRBuilder.CSR ccsr = CSRBuilder.buildConstraintCSR(rows); + + // Constraint sense + rhs from the Constraint metadata. + byte[] sense = new byte[numC]; + double[] rhs = new double[numC]; + for (int i = 0; i < numC; i++) { + Constraint c = problem.getConstraint(i); + sense[i] = (byte) c.sense().code(); + rhs[i] = c.rhs(); + } + + // Objective coefficients from linear / linear-part-of-quadratic. + double[] objCoeffs = new double[numV]; + LinearExpr objLinear = problem.linearObjective() != null + ? problem.linearObjective() + : problem.quadraticObjective() != null + ? problem.quadraticObjective().linearPart() + : null; + if (objLinear != null) { + for (var e : objLinear.terms().entrySet()) { + objCoeffs[e.getKey().index()] += e.getValue(); + } + } + + // Allocate and copy into native segments. + MemorySegment objCoeffsSeg = doubleArray(arena, objCoeffs); + MemorySegment rowOffsetsSeg = intArray(arena, ccsr.rowOffsets); + MemorySegment colIndicesSeg = intArray(arena, ccsr.colIndices); + MemorySegment ccoeffsSeg = doubleArray(arena, ccsr.values); + MemorySegment senseSeg = byteArray(arena, sense); + MemorySegment rhsSeg = doubleArray(arena, rhs); + MemorySegment lbSeg = doubleArray(arena, varLb); + MemorySegment ubSeg = doubleArray(arena, varUb); + MemorySegment varTypesSeg = byteArray(arena, varTypes); + MemorySegment problemPtr = arena.allocate(ValueLayout.ADDRESS); + + int sense_code = problem.objectiveSense().code(); + double offset = problem.objectiveOffset(); + + int rc; + if (problem.isQP() && problem.quadraticObjective() != null) { + QuadraticExpr q = problem.quadraticObjective(); + CSRBuilder.CSR qcsr = CSRBuilder.buildQuadraticCSR(q, numV); + MemorySegment qRowOff = intArray(arena, qcsr.rowOffsets); + MemorySegment qColIdx = intArray(arena, qcsr.colIndices); + MemorySegment qVals = doubleArray(arena, qcsr.values); + rc = cuopt_c_h.cuOptCreateQuadraticProblem( + numC, numV, sense_code, offset, objCoeffsSeg, + qRowOff, qColIdx, qVals, + rowOffsetsSeg, colIndicesSeg, ccoeffsSeg, + senseSeg, rhsSeg, lbSeg, ubSeg, problemPtr); + checkRc(rc, "cuOptCreateQuadraticProblem"); + } else { + rc = cuopt_c_h.cuOptCreateProblem( + numC, numV, sense_code, offset, objCoeffsSeg, + rowOffsetsSeg, colIndicesSeg, ccoeffsSeg, + senseSeg, rhsSeg, lbSeg, ubSeg, varTypesSeg, problemPtr); + checkRc(rc, "cuOptCreateProblem"); + } + + long handle = problemPtr.get(ValueLayout.ADDRESS, 0).address(); + return new ProblemBuild(handle, numV, numC); + } + + + // ── solve + extract ───────────────────────────────────────── + + private SolveResult solveAndExtract(Arena arena, Problem problem, + ProblemBuild build, SolverSettings settings) { + return solveAndExtract(arena, build, settings, build.numConstraints, build.numVariables, + problem); + } + + + private SolveResult solveAndExtract(Arena arena, ProblemBuild build, + SolverSettings settings, int numC, int numV, + Problem problemForSlack) { + long settingsHandle = settings != null ? settings.nativeHandle() : createSolverSettings(); + boolean ownSettingsHandle = (settings == null); + try { + registerMipCallbacks(settings, settingsHandle, numV, arena); + + MemorySegment solPtr = arena.allocate(ValueLayout.ADDRESS); + int rc = cuopt_c_h.cuOptSolve( + MemorySegment.ofAddress(build.problemHandle), + MemorySegment.ofAddress(settingsHandle), + solPtr); + checkRc(rc, "cuOptSolve"); + MemorySegment solutionHandle = solPtr.get(ValueLayout.ADDRESS, 0); + + try { + // Termination + error + MemorySegment outInt = arena.allocate(ValueLayout.JAVA_INT); + cuopt_c_h.cuOptGetTerminationStatus(solutionHandle, outInt); + TerminationStatus term = TerminationStatus.fromCode(outInt.get(ValueLayout.JAVA_INT, 0)); + + cuopt_c_h.cuOptGetErrorStatus(solutionHandle, outInt); + ErrorStatus err = ErrorStatus.fromCode(outInt.get(ValueLayout.JAVA_INT, 0)); + + String errMsg = null; + if (err != ErrorStatus.SUCCESS) { + MemorySegment buf = arena.allocate(1024); + cuopt_c_h.cuOptGetErrorString(solutionHandle, buf, 1024); + errMsg = buf.getString(0); + if (errMsg != null && errMsg.isEmpty()) errMsg = null; + } + + // Primal / dual / reduced cost + double[] primal = new double[numV]; + if (numV > 0) { + MemorySegment primalSeg = arena.allocate( + ValueLayout.JAVA_DOUBLE.byteSize() * numV); + cuopt_c_h.cuOptGetPrimalSolution(solutionHandle, primalSeg); + MemorySegment.copy(primalSeg, ValueLayout.JAVA_DOUBLE, 0, primal, 0, numV); + } + + double[] dual = null; + double[] reduced = null; + // cuOptIsMIP determines whether dual is meaningful. + MemorySegment isMipPtr = arena.allocate(ValueLayout.JAVA_INT); + cuopt_c_h.cuOptIsMIP(MemorySegment.ofAddress(build.problemHandle), isMipPtr); + boolean isMip = isMipPtr.get(ValueLayout.JAVA_INT, 0) != 0; + + if (!isMip && numC > 0) { + dual = new double[numC]; + MemorySegment dualSeg = arena.allocate( + ValueLayout.JAVA_DOUBLE.byteSize() * numC); + cuopt_c_h.cuOptGetDualSolution(solutionHandle, dualSeg); + MemorySegment.copy(dualSeg, ValueLayout.JAVA_DOUBLE, 0, dual, 0, numC); + } + + if (!isMip && numV > 0) { + reduced = new double[numV]; + MemorySegment rcSeg = arena.allocate( + ValueLayout.JAVA_DOUBLE.byteSize() * numV); + cuopt_c_h.cuOptGetReducedCosts(solutionHandle, rcSeg); + MemorySegment.copy(rcSeg, ValueLayout.JAVA_DOUBLE, 0, reduced, 0, numV); + } + + // Slack (computed Java-side from primal + constraint expressions) + double[] slack = (problemForSlack != null && numC > 0) + ? computeSlackFromExpressions(problemForSlack, primal) : null; + + // Objective values + time + MemorySegment outDbl = arena.allocate(ValueLayout.JAVA_DOUBLE); + cuopt_c_h.cuOptGetObjectiveValue(solutionHandle, outDbl); + double objVal = outDbl.get(ValueLayout.JAVA_DOUBLE, 0); + + double dualObjVal = Double.NaN; + if (!isMip) { + cuopt_c_h.cuOptGetDualObjectiveValue(solutionHandle, outDbl); + dualObjVal = outDbl.get(ValueLayout.JAVA_DOUBLE, 0); + } + + cuopt_c_h.cuOptGetSolveTime(solutionHandle, outDbl); + double solveTime = outDbl.get(ValueLayout.JAVA_DOUBLE, 0); + + // Stats — LP and MIP. We populate what's readily available; + // missing fields are NaN / -1. + LpStats lpStats = new LpStats( + Double.NaN, Double.NaN, objVal, dualObjVal, -1L, Double.NaN); + + MIPStats mipStats = null; + if (isMip) { + cuopt_c_h.cuOptGetMIPGap(solutionHandle, outDbl); + double mipGap = outDbl.get(ValueLayout.JAVA_DOUBLE, 0); + cuopt_c_h.cuOptGetSolutionBound(solutionHandle, outDbl); + double bound = outDbl.get(ValueLayout.JAVA_DOUBLE, 0); + mipStats = new MIPStats(mipGap, bound, -1L, -1L, Double.NaN, Double.NaN); + } + + return new SolveResult( + primal, dual, reduced, slack, + term, term.name(), err, errMsg, + objVal, dualObjVal, solveTime, + SolverMethod.UNSET, + lpStats, mipStats); + } finally { + MemorySegment solDestroyPtr = arena.allocate(ValueLayout.ADDRESS); + solDestroyPtr.set(ValueLayout.ADDRESS, 0, solutionHandle); + cuopt_c_h.cuOptDestroySolution(solDestroyPtr); + } + } finally { + // Destroy the problem handle we built. + MemorySegment probDestroyPtr = arena.allocate(ValueLayout.ADDRESS); + probDestroyPtr.set(ValueLayout.ADDRESS, 0, + MemorySegment.ofAddress(build.problemHandle)); + cuopt_c_h.cuOptDestroyProblem(probDestroyPtr); + if (ownSettingsHandle) destroySolverSettings(settingsHandle); + } + } + + // ── helpers ────────────────────────────────────────────────── + + /** + * Wires MIP user callbacks from {@code settings} (if any) to the native + * solver via FFM upcall stubs allocated in {@code arena}. + * + *

The Get callback is always registered when {@code settings} is non-null — + * the trampoline reads {@code settings.getMIPGetSolutionCallback()} at + * invocation time and no-ops if it's null. This is safe: registering a + * Get callback has no solver side effects. + * + *

The Set callback is registered only when the user has provided one, + * because registering it disables presolve (per the C API contract). If + * the user clears the Set callback after a previous solve registered one, + * the stale native registration persists; users should construct a new + * {@link SolverSettings} instead. + */ + private static void registerMipCallbacks( + SolverSettings settings, long settingsHandle, int numV, Arena arena) { + if (settings == null) return; + final int finalNumV = numV; + final SolverSettings finalSettings = settings; + + cuOptMIPGetSolutionCallback.Function getTrampoline = (solPtr, objPtr, boundPtr, userData) -> { + MIPGetSolutionCallback cb = finalSettings.getMIPGetSolutionCallback(); + if (cb == null) return; + try { + double[] solution = (finalNumV > 0) + ? solPtr.reinterpret(ValueLayout.JAVA_DOUBLE.byteSize() * finalNumV) + .toArray(ValueLayout.JAVA_DOUBLE) + : new double[0]; + double objVal = objPtr.reinterpret(ValueLayout.JAVA_DOUBLE.byteSize()) + .get(ValueLayout.JAVA_DOUBLE, 0); + double boundVal = boundPtr.reinterpret(ValueLayout.JAVA_DOUBLE.byteSize()) + .get(ValueLayout.JAVA_DOUBLE, 0); + cb.onSolution(solution, objVal, boundVal); + } catch (Throwable ignore) { + // Never propagate exceptions across the FFM upcall boundary. + } + }; + MemorySegment getStub = cuOptMIPGetSolutionCallback.allocate(getTrampoline, arena); + int rcGet = cuopt_c_h.cuOptSetMIPGetSolutionCallback( + MemorySegment.ofAddress(settingsHandle), getStub, MemorySegment.NULL); + checkRc(rcGet, "cuOptSetMIPGetSolutionCallback"); + + MIPSetSolutionCallback setCb = settings.getMIPSetSolutionCallback(); + if (setCb != null) { + final MIPSetSolutionCallback finalSetCb = setCb; + cuOptMIPSetSolutionCallback.Function setTrampoline = (solPtr, objPtr, boundPtr, userData) -> { + try { + double[] outSolution = new double[finalNumV]; + double[] outObjective = new double[1]; + double boundVal = boundPtr.reinterpret(ValueLayout.JAVA_DOUBLE.byteSize()) + .get(ValueLayout.JAVA_DOUBLE, 0); + finalSetCb.provideSolution(outSolution, outObjective, boundVal); + if (finalNumV > 0) { + MemorySegment.copy(outSolution, 0, + solPtr.reinterpret(ValueLayout.JAVA_DOUBLE.byteSize() * finalNumV), + ValueLayout.JAVA_DOUBLE, 0, finalNumV); + } + objPtr.reinterpret(ValueLayout.JAVA_DOUBLE.byteSize()) + .set(ValueLayout.JAVA_DOUBLE, 0, outObjective[0]); + } catch (Throwable ignore) { + // Never propagate exceptions across the FFM upcall boundary. + } + }; + MemorySegment setStub = cuOptMIPSetSolutionCallback.allocate(setTrampoline, arena); + int rcSet = cuopt_c_h.cuOptSetMIPSetSolutionCallback( + MemorySegment.ofAddress(settingsHandle), setStub, MemorySegment.NULL); + checkRc(rcSet, "cuOptSetMIPSetSolutionCallback"); + } + } + + private static double[] computeSlackFromExpressions(Problem p, double[] primal) { + List rows = p.constraintExpressions(); + double[] slack = new double[rows.size()]; + for (int i = 0; i < rows.size(); i++) { + double lhs = 0.0; + for (var e : rows.get(i).terms().entrySet()) { + lhs += primal[e.getKey().index()] * e.getValue(); + } + Constraint c = p.getConstraint(i); + // Slack convention: rhs - lhs (positive for satisfied <= constraints). + slack[i] = c.rhs() - lhs; + } + return slack; + } + + private static MemorySegment cString(Arena arena, String s) { + if (s == null) return MemorySegment.NULL; + byte[] bytes = s.getBytes(StandardCharsets.UTF_8); + MemorySegment seg = arena.allocate(bytes.length + 1); + MemorySegment.copy(bytes, 0, seg, ValueLayout.JAVA_BYTE, 0, bytes.length); + seg.set(ValueLayout.JAVA_BYTE, bytes.length, (byte) 0); + return seg; + } + + private static MemorySegment doubleArray(Arena arena, double[] arr) { + if (arr == null || arr.length == 0) return MemorySegment.NULL; + MemorySegment seg = arena.allocate(ValueLayout.JAVA_DOUBLE.byteSize() * arr.length); + MemorySegment.copy(arr, 0, seg, ValueLayout.JAVA_DOUBLE, 0, arr.length); + return seg; + } + + private static MemorySegment intArray(Arena arena, int[] arr) { + if (arr == null || arr.length == 0) return MemorySegment.NULL; + MemorySegment seg = arena.allocate(ValueLayout.JAVA_INT.byteSize() * arr.length); + MemorySegment.copy(arr, 0, seg, ValueLayout.JAVA_INT, 0, arr.length); + return seg; + } + + private static MemorySegment byteArray(Arena arena, byte[] arr) { + if (arr == null || arr.length == 0) return MemorySegment.NULL; + MemorySegment seg = arena.allocate(arr.length); + MemorySegment.copy(arr, 0, seg, ValueLayout.JAVA_BYTE, 0, arr.length); + return seg; + } + + private static byte[] ctypesToBytes(CType[] types, int n) { + byte[] out = new byte[n]; + if (types == null) { + java.util.Arrays.fill(out, (byte) 'L'); + } else { + for (int i = 0; i < n; i++) out[i] = (byte) types[i].code(); + } + return out; + } + + + private static void checkRc(int rc, String op) { + if (rc != 0) { + ErrorStatus err = ErrorStatus.fromCode(rc); + throw new cuOptException(op + " returned non-zero status " + rc + " (" + err + ")"); + } + } +} diff --git a/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama/__fsid_t.java b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama/__fsid_t.java new file mode 100644 index 000000000..0f538396e --- /dev/null +++ b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama/__fsid_t.java @@ -0,0 +1,159 @@ +// Generated by jextract + +package com.nvidia.cuopt.internal.panama; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * struct { + * int __val[2]; + * } + * } + */ +public class __fsid_t { + + __fsid_t() { + // Should not be called directly + } + + private static final GroupLayout $LAYOUT = MemoryLayout.structLayout( + MemoryLayout.sequenceLayout(2, cuopt_c_h.C_INT).withName("__val") + ).withName("$anon$155:12"); + + /** + * The layout of this struct + */ + public static final GroupLayout layout() { + return $LAYOUT; + } + + private static final SequenceLayout __val$LAYOUT = (SequenceLayout)$LAYOUT.select(groupElement("__val")); + + /** + * Layout for field: + * {@snippet lang=c : + * int __val[2] + * } + */ + public static final SequenceLayout __val$layout() { + return __val$LAYOUT; + } + + private static final long __val$OFFSET = 0; + + /** + * Offset for field: + * {@snippet lang=c : + * int __val[2] + * } + */ + public static final long __val$offset() { + return __val$OFFSET; + } + + /** + * Getter for field: + * {@snippet lang=c : + * int __val[2] + * } + */ + public static MemorySegment __val(MemorySegment struct) { + return struct.asSlice(__val$OFFSET, __val$LAYOUT.byteSize()); + } + + /** + * Setter for field: + * {@snippet lang=c : + * int __val[2] + * } + */ + public static void __val(MemorySegment struct, MemorySegment fieldValue) { + MemorySegment.copy(fieldValue, 0L, struct, __val$OFFSET, __val$LAYOUT.byteSize()); + } + + private static long[] __val$DIMS = { 2 }; + + /** + * Dimensions for array field: + * {@snippet lang=c : + * int __val[2] + * } + */ + public static long[] __val$dimensions() { + return __val$DIMS; + } + private static final VarHandle __val$ELEM_HANDLE = __val$LAYOUT.varHandle(sequenceElement()); + + /** + * Indexed getter for field: + * {@snippet lang=c : + * int __val[2] + * } + */ + public static int __val(MemorySegment struct, long index0) { + return (int)__val$ELEM_HANDLE.get(struct, 0L, index0); + } + + /** + * Indexed setter for field: + * {@snippet lang=c : + * int __val[2] + * } + */ + public static void __val(MemorySegment struct, long index0, int fieldValue) { + __val$ELEM_HANDLE.set(struct, 0L, index0, fieldValue); + } + + /** + * Obtains a slice of {@code arrayParam} which selects the array element at {@code index}. + * The returned segment has address {@code arrayParam.address() + index * layout().byteSize()} + */ + public static MemorySegment asSlice(MemorySegment array, long index) { + return array.asSlice(layout().byteSize() * index); + } + + /** + * The size (in bytes) of this struct + */ + public static long sizeof() { return layout().byteSize(); } + + /** + * Allocate a segment of size {@code layout().byteSize()} using {@code allocator} + */ + public static MemorySegment allocate(SegmentAllocator allocator) { + return allocator.allocate(layout()); + } + + /** + * Allocate an array of size {@code elementCount} using {@code allocator}. + * The returned segment has size {@code elementCount * layout().byteSize()}. + */ + public static MemorySegment allocateArray(long elementCount, SegmentAllocator allocator) { + return allocator.allocate(MemoryLayout.sequenceLayout(elementCount, layout())); + } + + /** + * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction} (if any). + * The returned segment has size {@code layout().byteSize()} + */ + public static MemorySegment reinterpret(MemorySegment addr, Arena arena, Consumer cleanup) { + return reinterpret(addr, 1, arena, cleanup); + } + + /** + * Reinterprets {@code addr} using target {@code arena} and {@code cleanupAction} (if any). + * The returned segment has size {@code elementCount * layout().byteSize()} + */ + public static MemorySegment reinterpret(MemorySegment addr, long elementCount, Arena arena, Consumer cleanup) { + return addr.reinterpret(layout().byteSize() * elementCount, arena, cleanup); + } +} diff --git a/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama/cuOptMIPGetSolutionCallback.java b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama/cuOptMIPGetSolutionCallback.java new file mode 100644 index 000000000..abc9ef6e8 --- /dev/null +++ b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama/cuOptMIPGetSolutionCallback.java @@ -0,0 +1,69 @@ +// Generated by jextract + +package com.nvidia.cuopt.internal.panama; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef void (*cuOptMIPGetSolutionCallback)(const cuopt_float_t *, const cuopt_float_t *, const cuopt_float_t *, void *) + * } + */ +public class cuOptMIPGetSolutionCallback { + + cuOptMIPGetSolutionCallback() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + void apply(MemorySegment solution, MemorySegment objective_value, MemorySegment solution_bound, MemorySegment user_data); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.ofVoid( + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = cuopt_c_h.upcallHandle(cuOptMIPGetSolutionCallback.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(cuOptMIPGetSolutionCallback.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static void invoke(MemorySegment funcPtr,MemorySegment solution, MemorySegment objective_value, MemorySegment solution_bound, MemorySegment user_data) { + try { + DOWN$MH.invokeExact(funcPtr, solution, objective_value, solution_bound, user_data); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } +} diff --git a/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama/cuOptMIPSetSolutionCallback.java b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama/cuOptMIPSetSolutionCallback.java new file mode 100644 index 000000000..b6168de63 --- /dev/null +++ b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama/cuOptMIPSetSolutionCallback.java @@ -0,0 +1,69 @@ +// Generated by jextract + +package com.nvidia.cuopt.internal.panama; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +/** + * {@snippet lang=c : + * typedef void (*cuOptMIPSetSolutionCallback)(cuopt_float_t *, cuopt_float_t *, const cuopt_float_t *, void *) + * } + */ +public class cuOptMIPSetSolutionCallback { + + cuOptMIPSetSolutionCallback() { + // Should not be called directly + } + + /** + * The function pointer signature, expressed as a functional interface + */ + public interface Function { + void apply(MemorySegment solution, MemorySegment objective_value, MemorySegment solution_bound, MemorySegment user_data); + } + + private static final FunctionDescriptor $DESC = FunctionDescriptor.ofVoid( + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + /** + * The descriptor of this function pointer + */ + public static FunctionDescriptor descriptor() { + return $DESC; + } + + private static final MethodHandle UP$MH = cuopt_c_h.upcallHandle(cuOptMIPSetSolutionCallback.Function.class, "apply", $DESC); + + /** + * Allocates a new upcall stub, whose implementation is defined by {@code fi}. + * The lifetime of the returned segment is managed by {@code arena} + */ + public static MemorySegment allocate(cuOptMIPSetSolutionCallback.Function fi, Arena arena) { + return Linker.nativeLinker().upcallStub(UP$MH.bindTo(fi), $DESC, arena); + } + + private static final MethodHandle DOWN$MH = Linker.nativeLinker().downcallHandle($DESC); + + /** + * Invoke the upcall stub {@code funcPtr}, with given parameters + */ + public static void invoke(MemorySegment funcPtr,MemorySegment solution, MemorySegment objective_value, MemorySegment solution_bound, MemorySegment user_data) { + try { + DOWN$MH.invokeExact(funcPtr, solution, objective_value, solution_bound, user_data); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } +} diff --git a/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama/cuopt_c_h.java b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama/cuopt_c_h.java new file mode 100644 index 000000000..1b6fcaddc --- /dev/null +++ b/java/cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama/cuopt_c_h.java @@ -0,0 +1,23515 @@ +// Generated by jextract + +package com.nvidia.cuopt.internal.panama; + +import java.lang.invoke.*; +import java.lang.foreign.*; +import java.nio.ByteOrder; +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import static java.lang.foreign.ValueLayout.*; +import static java.lang.foreign.MemoryLayout.PathElement.*; + +public class cuopt_c_h { + + cuopt_c_h() { + // Should not be called directly + } + + static final Arena LIBRARY_ARENA = Arena.ofAuto(); + static final boolean TRACE_DOWNCALLS = Boolean.getBoolean("jextract.trace.downcalls"); + + static void traceDowncall(String name, Object... args) { + String traceArgs = Arrays.stream(args) + .map(Object::toString) + .collect(Collectors.joining(", ")); + System.out.printf("%s(%s)\n", name, traceArgs); + } + + static MemorySegment findOrThrow(String symbol) { + return SYMBOL_LOOKUP.find(symbol) + .orElseThrow(() -> new UnsatisfiedLinkError("unresolved symbol: " + symbol)); + } + + static MethodHandle upcallHandle(Class fi, String name, FunctionDescriptor fdesc) { + try { + return MethodHandles.lookup().findVirtual(fi, name, fdesc.toMethodType()); + } catch (ReflectiveOperationException ex) { + throw new AssertionError(ex); + } + } + + static MemoryLayout align(MemoryLayout layout, long align) { + return switch (layout) { + case PaddingLayout p -> p; + case ValueLayout v -> v.withByteAlignment(align); + case GroupLayout g -> { + MemoryLayout[] alignedMembers = g.memberLayouts().stream() + .map(m -> align(m, align)).toArray(MemoryLayout[]::new); + yield g instanceof StructLayout ? + MemoryLayout.structLayout(alignedMembers) : MemoryLayout.unionLayout(alignedMembers); + } + case SequenceLayout s -> MemoryLayout.sequenceLayout(s.elementCount(), align(s.elementLayout(), align)); + }; + } + + + static { + com.nvidia.cuopt.internal.NativeLibraryLoader.ensureLoaded(); + } + + static final SymbolLookup SYMBOL_LOOKUP = SymbolLookup.loaderLookup() + .or(Linker.nativeLinker().defaultLookup()); + + public static final ValueLayout.OfBoolean C_BOOL = ValueLayout.JAVA_BOOLEAN; + public static final ValueLayout.OfByte C_CHAR = ValueLayout.JAVA_BYTE; + public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT; + public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT; + public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG; + public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT; + public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE; + public static final AddressLayout C_POINTER = ValueLayout.ADDRESS + .withTargetLayout(MemoryLayout.sequenceLayout(java.lang.Long.MAX_VALUE, JAVA_BYTE)); + public static final ValueLayout.OfLong C_LONG = ValueLayout.JAVA_LONG; + private static final int _MATH_H = (int)1L; + /** + * {@snippet lang=c : + * #define _MATH_H 1 + * } + */ + public static int _MATH_H() { + return _MATH_H; + } + private static final int _FEATURES_H = (int)1L; + /** + * {@snippet lang=c : + * #define _FEATURES_H 1 + * } + */ + public static int _FEATURES_H() { + return _FEATURES_H; + } + private static final int _DEFAULT_SOURCE = (int)1L; + /** + * {@snippet lang=c : + * #define _DEFAULT_SOURCE 1 + * } + */ + public static int _DEFAULT_SOURCE() { + return _DEFAULT_SOURCE; + } + private static final int __GLIBC_USE_ISOC2X = (int)0L; + /** + * {@snippet lang=c : + * #define __GLIBC_USE_ISOC2X 0 + * } + */ + public static int __GLIBC_USE_ISOC2X() { + return __GLIBC_USE_ISOC2X; + } + private static final int __USE_ISOC11 = (int)1L; + /** + * {@snippet lang=c : + * #define __USE_ISOC11 1 + * } + */ + public static int __USE_ISOC11() { + return __USE_ISOC11; + } + private static final int __USE_ISOC99 = (int)1L; + /** + * {@snippet lang=c : + * #define __USE_ISOC99 1 + * } + */ + public static int __USE_ISOC99() { + return __USE_ISOC99; + } + private static final int __USE_ISOC95 = (int)1L; + /** + * {@snippet lang=c : + * #define __USE_ISOC95 1 + * } + */ + public static int __USE_ISOC95() { + return __USE_ISOC95; + } + private static final int __USE_POSIX_IMPLICITLY = (int)1L; + /** + * {@snippet lang=c : + * #define __USE_POSIX_IMPLICITLY 1 + * } + */ + public static int __USE_POSIX_IMPLICITLY() { + return __USE_POSIX_IMPLICITLY; + } + private static final int _POSIX_SOURCE = (int)1L; + /** + * {@snippet lang=c : + * #define _POSIX_SOURCE 1 + * } + */ + public static int _POSIX_SOURCE() { + return _POSIX_SOURCE; + } + private static final int __USE_POSIX = (int)1L; + /** + * {@snippet lang=c : + * #define __USE_POSIX 1 + * } + */ + public static int __USE_POSIX() { + return __USE_POSIX; + } + private static final int __USE_POSIX2 = (int)1L; + /** + * {@snippet lang=c : + * #define __USE_POSIX2 1 + * } + */ + public static int __USE_POSIX2() { + return __USE_POSIX2; + } + private static final int __USE_POSIX199309 = (int)1L; + /** + * {@snippet lang=c : + * #define __USE_POSIX199309 1 + * } + */ + public static int __USE_POSIX199309() { + return __USE_POSIX199309; + } + private static final int __USE_POSIX199506 = (int)1L; + /** + * {@snippet lang=c : + * #define __USE_POSIX199506 1 + * } + */ + public static int __USE_POSIX199506() { + return __USE_POSIX199506; + } + private static final int __USE_XOPEN2K = (int)1L; + /** + * {@snippet lang=c : + * #define __USE_XOPEN2K 1 + * } + */ + public static int __USE_XOPEN2K() { + return __USE_XOPEN2K; + } + private static final int __USE_XOPEN2K8 = (int)1L; + /** + * {@snippet lang=c : + * #define __USE_XOPEN2K8 1 + * } + */ + public static int __USE_XOPEN2K8() { + return __USE_XOPEN2K8; + } + private static final int _ATFILE_SOURCE = (int)1L; + /** + * {@snippet lang=c : + * #define _ATFILE_SOURCE 1 + * } + */ + public static int _ATFILE_SOURCE() { + return _ATFILE_SOURCE; + } + private static final int __WORDSIZE = (int)64L; + /** + * {@snippet lang=c : + * #define __WORDSIZE 64 + * } + */ + public static int __WORDSIZE() { + return __WORDSIZE; + } + private static final int __WORDSIZE_TIME64_COMPAT32 = (int)1L; + /** + * {@snippet lang=c : + * #define __WORDSIZE_TIME64_COMPAT32 1 + * } + */ + public static int __WORDSIZE_TIME64_COMPAT32() { + return __WORDSIZE_TIME64_COMPAT32; + } + private static final int __SYSCALL_WORDSIZE = (int)64L; + /** + * {@snippet lang=c : + * #define __SYSCALL_WORDSIZE 64 + * } + */ + public static int __SYSCALL_WORDSIZE() { + return __SYSCALL_WORDSIZE; + } + private static final int __USE_MISC = (int)1L; + /** + * {@snippet lang=c : + * #define __USE_MISC 1 + * } + */ + public static int __USE_MISC() { + return __USE_MISC; + } + private static final int __USE_ATFILE = (int)1L; + /** + * {@snippet lang=c : + * #define __USE_ATFILE 1 + * } + */ + public static int __USE_ATFILE() { + return __USE_ATFILE; + } + private static final int __USE_FORTIFY_LEVEL = (int)0L; + /** + * {@snippet lang=c : + * #define __USE_FORTIFY_LEVEL 0 + * } + */ + public static int __USE_FORTIFY_LEVEL() { + return __USE_FORTIFY_LEVEL; + } + private static final int __GLIBC_USE_DEPRECATED_GETS = (int)0L; + /** + * {@snippet lang=c : + * #define __GLIBC_USE_DEPRECATED_GETS 0 + * } + */ + public static int __GLIBC_USE_DEPRECATED_GETS() { + return __GLIBC_USE_DEPRECATED_GETS; + } + private static final int __GLIBC_USE_DEPRECATED_SCANF = (int)0L; + /** + * {@snippet lang=c : + * #define __GLIBC_USE_DEPRECATED_SCANF 0 + * } + */ + public static int __GLIBC_USE_DEPRECATED_SCANF() { + return __GLIBC_USE_DEPRECATED_SCANF; + } + private static final int _STDC_PREDEF_H = (int)1L; + /** + * {@snippet lang=c : + * #define _STDC_PREDEF_H 1 + * } + */ + public static int _STDC_PREDEF_H() { + return _STDC_PREDEF_H; + } + private static final int __STDC_IEC_559__ = (int)1L; + /** + * {@snippet lang=c : + * #define __STDC_IEC_559__ 1 + * } + */ + public static int __STDC_IEC_559__() { + return __STDC_IEC_559__; + } + private static final int __STDC_IEC_559_COMPLEX__ = (int)1L; + /** + * {@snippet lang=c : + * #define __STDC_IEC_559_COMPLEX__ 1 + * } + */ + public static int __STDC_IEC_559_COMPLEX__() { + return __STDC_IEC_559_COMPLEX__; + } + private static final int __GNU_LIBRARY__ = (int)6L; + /** + * {@snippet lang=c : + * #define __GNU_LIBRARY__ 6 + * } + */ + public static int __GNU_LIBRARY__() { + return __GNU_LIBRARY__; + } + private static final int __GLIBC__ = (int)2L; + /** + * {@snippet lang=c : + * #define __GLIBC__ 2 + * } + */ + public static int __GLIBC__() { + return __GLIBC__; + } + private static final int __GLIBC_MINOR__ = (int)35L; + /** + * {@snippet lang=c : + * #define __GLIBC_MINOR__ 35 + * } + */ + public static int __GLIBC_MINOR__() { + return __GLIBC_MINOR__; + } + private static final int _SYS_CDEFS_H = (int)1L; + /** + * {@snippet lang=c : + * #define _SYS_CDEFS_H 1 + * } + */ + public static int _SYS_CDEFS_H() { + return _SYS_CDEFS_H; + } + private static final int __glibc_c99_flexarr_available = (int)1L; + /** + * {@snippet lang=c : + * #define __glibc_c99_flexarr_available 1 + * } + */ + public static int __glibc_c99_flexarr_available() { + return __glibc_c99_flexarr_available; + } + private static final int __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI = (int)0L; + /** + * {@snippet lang=c : + * #define __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI 0 + * } + */ + public static int __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI() { + return __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI; + } + private static final int __HAVE_GENERIC_SELECTION = (int)1L; + /** + * {@snippet lang=c : + * #define __HAVE_GENERIC_SELECTION 1 + * } + */ + public static int __HAVE_GENERIC_SELECTION() { + return __HAVE_GENERIC_SELECTION; + } + private static final int __GLIBC_USE_LIB_EXT2 = (int)0L; + /** + * {@snippet lang=c : + * #define __GLIBC_USE_LIB_EXT2 0 + * } + */ + public static int __GLIBC_USE_LIB_EXT2() { + return __GLIBC_USE_LIB_EXT2; + } + private static final int __GLIBC_USE_IEC_60559_BFP_EXT = (int)0L; + /** + * {@snippet lang=c : + * #define __GLIBC_USE_IEC_60559_BFP_EXT 0 + * } + */ + public static int __GLIBC_USE_IEC_60559_BFP_EXT() { + return __GLIBC_USE_IEC_60559_BFP_EXT; + } + private static final int __GLIBC_USE_IEC_60559_BFP_EXT_C2X = (int)0L; + /** + * {@snippet lang=c : + * #define __GLIBC_USE_IEC_60559_BFP_EXT_C2X 0 + * } + */ + public static int __GLIBC_USE_IEC_60559_BFP_EXT_C2X() { + return __GLIBC_USE_IEC_60559_BFP_EXT_C2X; + } + private static final int __GLIBC_USE_IEC_60559_EXT = (int)0L; + /** + * {@snippet lang=c : + * #define __GLIBC_USE_IEC_60559_EXT 0 + * } + */ + public static int __GLIBC_USE_IEC_60559_EXT() { + return __GLIBC_USE_IEC_60559_EXT; + } + private static final int __GLIBC_USE_IEC_60559_FUNCS_EXT = (int)0L; + /** + * {@snippet lang=c : + * #define __GLIBC_USE_IEC_60559_FUNCS_EXT 0 + * } + */ + public static int __GLIBC_USE_IEC_60559_FUNCS_EXT() { + return __GLIBC_USE_IEC_60559_FUNCS_EXT; + } + private static final int __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X = (int)0L; + /** + * {@snippet lang=c : + * #define __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X 0 + * } + */ + public static int __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X() { + return __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X; + } + private static final int __GLIBC_USE_IEC_60559_TYPES_EXT = (int)0L; + /** + * {@snippet lang=c : + * #define __GLIBC_USE_IEC_60559_TYPES_EXT 0 + * } + */ + public static int __GLIBC_USE_IEC_60559_TYPES_EXT() { + return __GLIBC_USE_IEC_60559_TYPES_EXT; + } + private static final int _BITS_TYPES_H = (int)1L; + /** + * {@snippet lang=c : + * #define _BITS_TYPES_H 1 + * } + */ + public static int _BITS_TYPES_H() { + return _BITS_TYPES_H; + } + private static final int _BITS_TYPESIZES_H = (int)1L; + /** + * {@snippet lang=c : + * #define _BITS_TYPESIZES_H 1 + * } + */ + public static int _BITS_TYPESIZES_H() { + return _BITS_TYPESIZES_H; + } + private static final int __OFF_T_MATCHES_OFF64_T = (int)1L; + /** + * {@snippet lang=c : + * #define __OFF_T_MATCHES_OFF64_T 1 + * } + */ + public static int __OFF_T_MATCHES_OFF64_T() { + return __OFF_T_MATCHES_OFF64_T; + } + private static final int __INO_T_MATCHES_INO64_T = (int)1L; + /** + * {@snippet lang=c : + * #define __INO_T_MATCHES_INO64_T 1 + * } + */ + public static int __INO_T_MATCHES_INO64_T() { + return __INO_T_MATCHES_INO64_T; + } + private static final int __RLIM_T_MATCHES_RLIM64_T = (int)1L; + /** + * {@snippet lang=c : + * #define __RLIM_T_MATCHES_RLIM64_T 1 + * } + */ + public static int __RLIM_T_MATCHES_RLIM64_T() { + return __RLIM_T_MATCHES_RLIM64_T; + } + private static final int __STATFS_MATCHES_STATFS64 = (int)1L; + /** + * {@snippet lang=c : + * #define __STATFS_MATCHES_STATFS64 1 + * } + */ + public static int __STATFS_MATCHES_STATFS64() { + return __STATFS_MATCHES_STATFS64; + } + private static final int __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64 = (int)1L; + /** + * {@snippet lang=c : + * #define __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64 1 + * } + */ + public static int __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64() { + return __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64; + } + private static final int __FD_SETSIZE = (int)1024L; + /** + * {@snippet lang=c : + * #define __FD_SETSIZE 1024 + * } + */ + public static int __FD_SETSIZE() { + return __FD_SETSIZE; + } + private static final int _BITS_TIME64_H = (int)1L; + /** + * {@snippet lang=c : + * #define _BITS_TIME64_H 1 + * } + */ + public static int _BITS_TIME64_H() { + return _BITS_TIME64_H; + } + private static final int _BITS_LIBM_SIMD_DECL_STUBS_H = (int)1L; + /** + * {@snippet lang=c : + * #define _BITS_LIBM_SIMD_DECL_STUBS_H 1 + * } + */ + public static int _BITS_LIBM_SIMD_DECL_STUBS_H() { + return _BITS_LIBM_SIMD_DECL_STUBS_H; + } + private static final int __HAVE_FLOAT128 = (int)0L; + /** + * {@snippet lang=c : + * #define __HAVE_FLOAT128 0 + * } + */ + public static int __HAVE_FLOAT128() { + return __HAVE_FLOAT128; + } + private static final int __HAVE_DISTINCT_FLOAT128 = (int)0L; + /** + * {@snippet lang=c : + * #define __HAVE_DISTINCT_FLOAT128 0 + * } + */ + public static int __HAVE_DISTINCT_FLOAT128() { + return __HAVE_DISTINCT_FLOAT128; + } + private static final int __HAVE_FLOAT64X = (int)1L; + /** + * {@snippet lang=c : + * #define __HAVE_FLOAT64X 1 + * } + */ + public static int __HAVE_FLOAT64X() { + return __HAVE_FLOAT64X; + } + private static final int __HAVE_FLOAT64X_LONG_DOUBLE = (int)1L; + /** + * {@snippet lang=c : + * #define __HAVE_FLOAT64X_LONG_DOUBLE 1 + * } + */ + public static int __HAVE_FLOAT64X_LONG_DOUBLE() { + return __HAVE_FLOAT64X_LONG_DOUBLE; + } + private static final int __HAVE_FLOAT16 = (int)0L; + /** + * {@snippet lang=c : + * #define __HAVE_FLOAT16 0 + * } + */ + public static int __HAVE_FLOAT16() { + return __HAVE_FLOAT16; + } + private static final int __HAVE_FLOAT32 = (int)1L; + /** + * {@snippet lang=c : + * #define __HAVE_FLOAT32 1 + * } + */ + public static int __HAVE_FLOAT32() { + return __HAVE_FLOAT32; + } + private static final int __HAVE_FLOAT64 = (int)1L; + /** + * {@snippet lang=c : + * #define __HAVE_FLOAT64 1 + * } + */ + public static int __HAVE_FLOAT64() { + return __HAVE_FLOAT64; + } + private static final int __HAVE_FLOAT32X = (int)1L; + /** + * {@snippet lang=c : + * #define __HAVE_FLOAT32X 1 + * } + */ + public static int __HAVE_FLOAT32X() { + return __HAVE_FLOAT32X; + } + private static final int __HAVE_FLOAT128X = (int)0L; + /** + * {@snippet lang=c : + * #define __HAVE_FLOAT128X 0 + * } + */ + public static int __HAVE_FLOAT128X() { + return __HAVE_FLOAT128X; + } + private static final int __HAVE_DISTINCT_FLOAT32 = (int)0L; + /** + * {@snippet lang=c : + * #define __HAVE_DISTINCT_FLOAT32 0 + * } + */ + public static int __HAVE_DISTINCT_FLOAT32() { + return __HAVE_DISTINCT_FLOAT32; + } + private static final int __HAVE_DISTINCT_FLOAT64 = (int)0L; + /** + * {@snippet lang=c : + * #define __HAVE_DISTINCT_FLOAT64 0 + * } + */ + public static int __HAVE_DISTINCT_FLOAT64() { + return __HAVE_DISTINCT_FLOAT64; + } + private static final int __HAVE_DISTINCT_FLOAT32X = (int)0L; + /** + * {@snippet lang=c : + * #define __HAVE_DISTINCT_FLOAT32X 0 + * } + */ + public static int __HAVE_DISTINCT_FLOAT32X() { + return __HAVE_DISTINCT_FLOAT32X; + } + private static final int __HAVE_DISTINCT_FLOAT64X = (int)0L; + /** + * {@snippet lang=c : + * #define __HAVE_DISTINCT_FLOAT64X 0 + * } + */ + public static int __HAVE_DISTINCT_FLOAT64X() { + return __HAVE_DISTINCT_FLOAT64X; + } + private static final int __HAVE_FLOATN_NOT_TYPEDEF = (int)0L; + /** + * {@snippet lang=c : + * #define __HAVE_FLOATN_NOT_TYPEDEF 0 + * } + */ + public static int __HAVE_FLOATN_NOT_TYPEDEF() { + return __HAVE_FLOATN_NOT_TYPEDEF; + } + private static final int __FP_LOGB0_IS_MIN = (int)1L; + /** + * {@snippet lang=c : + * #define __FP_LOGB0_IS_MIN 1 + * } + */ + public static int __FP_LOGB0_IS_MIN() { + return __FP_LOGB0_IS_MIN; + } + private static final int __FP_LOGBNAN_IS_MIN = (int)1L; + /** + * {@snippet lang=c : + * #define __FP_LOGBNAN_IS_MIN 1 + * } + */ + public static int __FP_LOGBNAN_IS_MIN() { + return __FP_LOGBNAN_IS_MIN; + } + private static final int __MATH_DECLARING_DOUBLE = (int)1L; + /** + * {@snippet lang=c : + * #define __MATH_DECLARING_DOUBLE 1 + * } + */ + public static int __MATH_DECLARING_DOUBLE() { + return __MATH_DECLARING_DOUBLE; + } + private static final int __MATH_DECLARING_FLOATN = (int)0L; + /** + * {@snippet lang=c : + * #define __MATH_DECLARING_FLOATN 0 + * } + */ + public static int __MATH_DECLARING_FLOATN() { + return __MATH_DECLARING_FLOATN; + } + private static final int __MATH_DECLARE_LDOUBLE = (int)1L; + /** + * {@snippet lang=c : + * #define __MATH_DECLARE_LDOUBLE 1 + * } + */ + public static int __MATH_DECLARE_LDOUBLE() { + return __MATH_DECLARE_LDOUBLE; + } + private static final int FP_NAN = (int)0L; + /** + * {@snippet lang=c : + * #define FP_NAN 0 + * } + */ + public static int FP_NAN() { + return FP_NAN; + } + private static final int FP_INFINITE = (int)1L; + /** + * {@snippet lang=c : + * #define FP_INFINITE 1 + * } + */ + public static int FP_INFINITE() { + return FP_INFINITE; + } + private static final int FP_ZERO = (int)2L; + /** + * {@snippet lang=c : + * #define FP_ZERO 2 + * } + */ + public static int FP_ZERO() { + return FP_ZERO; + } + private static final int FP_SUBNORMAL = (int)3L; + /** + * {@snippet lang=c : + * #define FP_SUBNORMAL 3 + * } + */ + public static int FP_SUBNORMAL() { + return FP_SUBNORMAL; + } + private static final int FP_NORMAL = (int)4L; + /** + * {@snippet lang=c : + * #define FP_NORMAL 4 + * } + */ + public static int FP_NORMAL() { + return FP_NORMAL; + } + private static final int MATH_ERRNO = (int)1L; + /** + * {@snippet lang=c : + * #define MATH_ERRNO 1 + * } + */ + public static int MATH_ERRNO() { + return MATH_ERRNO; + } + private static final int MATH_ERREXCEPT = (int)2L; + /** + * {@snippet lang=c : + * #define MATH_ERREXCEPT 2 + * } + */ + public static int MATH_ERREXCEPT() { + return MATH_ERREXCEPT; + } + private static final int CUOPT_INSTANTIATE_FLOAT = (int)0L; + /** + * {@snippet lang=c : + * #define CUOPT_INSTANTIATE_FLOAT 0 + * } + */ + public static int CUOPT_INSTANTIATE_FLOAT() { + return CUOPT_INSTANTIATE_FLOAT; + } + private static final int CUOPT_INSTANTIATE_DOUBLE = (int)1L; + /** + * {@snippet lang=c : + * #define CUOPT_INSTANTIATE_DOUBLE 1 + * } + */ + public static int CUOPT_INSTANTIATE_DOUBLE() { + return CUOPT_INSTANTIATE_DOUBLE; + } + private static final int CUOPT_INSTANTIATE_INT32 = (int)1L; + /** + * {@snippet lang=c : + * #define CUOPT_INSTANTIATE_INT32 1 + * } + */ + public static int CUOPT_INSTANTIATE_INT32() { + return CUOPT_INSTANTIATE_INT32; + } + private static final int CUOPT_INSTANTIATE_INT64 = (int)0L; + /** + * {@snippet lang=c : + * #define CUOPT_INSTANTIATE_INT64 0 + * } + */ + public static int CUOPT_INSTANTIATE_INT64() { + return CUOPT_INSTANTIATE_INT64; + } + private static final int CUOPT_MODE_OPPORTUNISTIC = (int)0L; + /** + * {@snippet lang=c : + * #define CUOPT_MODE_OPPORTUNISTIC 0 + * } + */ + public static int CUOPT_MODE_OPPORTUNISTIC() { + return CUOPT_MODE_OPPORTUNISTIC; + } + private static final int CUOPT_MODE_DETERMINISTIC = (int)1L; + /** + * {@snippet lang=c : + * #define CUOPT_MODE_DETERMINISTIC 1 + * } + */ + public static int CUOPT_MODE_DETERMINISTIC() { + return CUOPT_MODE_DETERMINISTIC; + } + private static final int CUOPT_TERMINATION_STATUS_NO_TERMINATION = (int)0L; + /** + * {@snippet lang=c : + * #define CUOPT_TERMINATION_STATUS_NO_TERMINATION 0 + * } + */ + public static int CUOPT_TERMINATION_STATUS_NO_TERMINATION() { + return CUOPT_TERMINATION_STATUS_NO_TERMINATION; + } + private static final int CUOPT_TERMINATION_STATUS_OPTIMAL = (int)1L; + /** + * {@snippet lang=c : + * #define CUOPT_TERMINATION_STATUS_OPTIMAL 1 + * } + */ + public static int CUOPT_TERMINATION_STATUS_OPTIMAL() { + return CUOPT_TERMINATION_STATUS_OPTIMAL; + } + private static final int CUOPT_TERMINATION_STATUS_INFEASIBLE = (int)2L; + /** + * {@snippet lang=c : + * #define CUOPT_TERMINATION_STATUS_INFEASIBLE 2 + * } + */ + public static int CUOPT_TERMINATION_STATUS_INFEASIBLE() { + return CUOPT_TERMINATION_STATUS_INFEASIBLE; + } + private static final int CUOPT_TERMINATION_STATUS_UNBOUNDED = (int)3L; + /** + * {@snippet lang=c : + * #define CUOPT_TERMINATION_STATUS_UNBOUNDED 3 + * } + */ + public static int CUOPT_TERMINATION_STATUS_UNBOUNDED() { + return CUOPT_TERMINATION_STATUS_UNBOUNDED; + } + private static final int CUOPT_TERMINATION_STATUS_ITERATION_LIMIT = (int)4L; + /** + * {@snippet lang=c : + * #define CUOPT_TERMINATION_STATUS_ITERATION_LIMIT 4 + * } + */ + public static int CUOPT_TERMINATION_STATUS_ITERATION_LIMIT() { + return CUOPT_TERMINATION_STATUS_ITERATION_LIMIT; + } + private static final int CUOPT_TERMINATION_STATUS_TIME_LIMIT = (int)5L; + /** + * {@snippet lang=c : + * #define CUOPT_TERMINATION_STATUS_TIME_LIMIT 5 + * } + */ + public static int CUOPT_TERMINATION_STATUS_TIME_LIMIT() { + return CUOPT_TERMINATION_STATUS_TIME_LIMIT; + } + private static final int CUOPT_TERMINATION_STATUS_NUMERICAL_ERROR = (int)6L; + /** + * {@snippet lang=c : + * #define CUOPT_TERMINATION_STATUS_NUMERICAL_ERROR 6 + * } + */ + public static int CUOPT_TERMINATION_STATUS_NUMERICAL_ERROR() { + return CUOPT_TERMINATION_STATUS_NUMERICAL_ERROR; + } + private static final int CUOPT_TERMINATION_STATUS_PRIMAL_FEASIBLE = (int)7L; + /** + * {@snippet lang=c : + * #define CUOPT_TERMINATION_STATUS_PRIMAL_FEASIBLE 7 + * } + */ + public static int CUOPT_TERMINATION_STATUS_PRIMAL_FEASIBLE() { + return CUOPT_TERMINATION_STATUS_PRIMAL_FEASIBLE; + } + private static final int CUOPT_TERMINATION_STATUS_FEASIBLE_FOUND = (int)8L; + /** + * {@snippet lang=c : + * #define CUOPT_TERMINATION_STATUS_FEASIBLE_FOUND 8 + * } + */ + public static int CUOPT_TERMINATION_STATUS_FEASIBLE_FOUND() { + return CUOPT_TERMINATION_STATUS_FEASIBLE_FOUND; + } + private static final int CUOPT_TERMINATION_STATUS_CONCURRENT_LIMIT = (int)9L; + /** + * {@snippet lang=c : + * #define CUOPT_TERMINATION_STATUS_CONCURRENT_LIMIT 9 + * } + */ + public static int CUOPT_TERMINATION_STATUS_CONCURRENT_LIMIT() { + return CUOPT_TERMINATION_STATUS_CONCURRENT_LIMIT; + } + private static final int CUOPT_TERMINATION_STATUS_WORK_LIMIT = (int)10L; + /** + * {@snippet lang=c : + * #define CUOPT_TERMINATION_STATUS_WORK_LIMIT 10 + * } + */ + public static int CUOPT_TERMINATION_STATUS_WORK_LIMIT() { + return CUOPT_TERMINATION_STATUS_WORK_LIMIT; + } + private static final int CUOPT_TERMINATION_STATUS_UNBOUNDED_OR_INFEASIBLE = (int)11L; + /** + * {@snippet lang=c : + * #define CUOPT_TERMINATION_STATUS_UNBOUNDED_OR_INFEASIBLE 11 + * } + */ + public static int CUOPT_TERMINATION_STATUS_UNBOUNDED_OR_INFEASIBLE() { + return CUOPT_TERMINATION_STATUS_UNBOUNDED_OR_INFEASIBLE; + } + private static final int CUOPT_MINIMIZE = (int)1L; + /** + * {@snippet lang=c : + * #define CUOPT_MINIMIZE 1 + * } + */ + public static int CUOPT_MINIMIZE() { + return CUOPT_MINIMIZE; + } + private static final int CUOPT_PDLP_SOLVER_MODE_STABLE1 = (int)0L; + /** + * {@snippet lang=c : + * #define CUOPT_PDLP_SOLVER_MODE_STABLE1 0 + * } + */ + public static int CUOPT_PDLP_SOLVER_MODE_STABLE1() { + return CUOPT_PDLP_SOLVER_MODE_STABLE1; + } + private static final int CUOPT_PDLP_SOLVER_MODE_STABLE2 = (int)1L; + /** + * {@snippet lang=c : + * #define CUOPT_PDLP_SOLVER_MODE_STABLE2 1 + * } + */ + public static int CUOPT_PDLP_SOLVER_MODE_STABLE2() { + return CUOPT_PDLP_SOLVER_MODE_STABLE2; + } + private static final int CUOPT_PDLP_SOLVER_MODE_METHODICAL1 = (int)2L; + /** + * {@snippet lang=c : + * #define CUOPT_PDLP_SOLVER_MODE_METHODICAL1 2 + * } + */ + public static int CUOPT_PDLP_SOLVER_MODE_METHODICAL1() { + return CUOPT_PDLP_SOLVER_MODE_METHODICAL1; + } + private static final int CUOPT_PDLP_SOLVER_MODE_FAST1 = (int)3L; + /** + * {@snippet lang=c : + * #define CUOPT_PDLP_SOLVER_MODE_FAST1 3 + * } + */ + public static int CUOPT_PDLP_SOLVER_MODE_FAST1() { + return CUOPT_PDLP_SOLVER_MODE_FAST1; + } + private static final int CUOPT_PDLP_SOLVER_MODE_STABLE3 = (int)4L; + /** + * {@snippet lang=c : + * #define CUOPT_PDLP_SOLVER_MODE_STABLE3 4 + * } + */ + public static int CUOPT_PDLP_SOLVER_MODE_STABLE3() { + return CUOPT_PDLP_SOLVER_MODE_STABLE3; + } + private static final int CUOPT_METHOD_CONCURRENT = (int)0L; + /** + * {@snippet lang=c : + * #define CUOPT_METHOD_CONCURRENT 0 + * } + */ + public static int CUOPT_METHOD_CONCURRENT() { + return CUOPT_METHOD_CONCURRENT; + } + private static final int CUOPT_METHOD_PDLP = (int)1L; + /** + * {@snippet lang=c : + * #define CUOPT_METHOD_PDLP 1 + * } + */ + public static int CUOPT_METHOD_PDLP() { + return CUOPT_METHOD_PDLP; + } + private static final int CUOPT_METHOD_DUAL_SIMPLEX = (int)2L; + /** + * {@snippet lang=c : + * #define CUOPT_METHOD_DUAL_SIMPLEX 2 + * } + */ + public static int CUOPT_METHOD_DUAL_SIMPLEX() { + return CUOPT_METHOD_DUAL_SIMPLEX; + } + private static final int CUOPT_METHOD_BARRIER = (int)3L; + /** + * {@snippet lang=c : + * #define CUOPT_METHOD_BARRIER 3 + * } + */ + public static int CUOPT_METHOD_BARRIER() { + return CUOPT_METHOD_BARRIER; + } + private static final int CUOPT_METHOD_UNSET = (int)4L; + /** + * {@snippet lang=c : + * #define CUOPT_METHOD_UNSET 4 + * } + */ + public static int CUOPT_METHOD_UNSET() { + return CUOPT_METHOD_UNSET; + } + private static final int CUOPT_PDLP_SINGLE_PRECISION = (int)0L; + /** + * {@snippet lang=c : + * #define CUOPT_PDLP_SINGLE_PRECISION 0 + * } + */ + public static int CUOPT_PDLP_SINGLE_PRECISION() { + return CUOPT_PDLP_SINGLE_PRECISION; + } + private static final int CUOPT_PDLP_DOUBLE_PRECISION = (int)1L; + /** + * {@snippet lang=c : + * #define CUOPT_PDLP_DOUBLE_PRECISION 1 + * } + */ + public static int CUOPT_PDLP_DOUBLE_PRECISION() { + return CUOPT_PDLP_DOUBLE_PRECISION; + } + private static final int CUOPT_PDLP_MIXED_PRECISION = (int)2L; + /** + * {@snippet lang=c : + * #define CUOPT_PDLP_MIXED_PRECISION 2 + * } + */ + public static int CUOPT_PDLP_MIXED_PRECISION() { + return CUOPT_PDLP_MIXED_PRECISION; + } + private static final int CUOPT_FILE_FORMAT_MPS = (int)0L; + /** + * {@snippet lang=c : + * #define CUOPT_FILE_FORMAT_MPS 0 + * } + */ + public static int CUOPT_FILE_FORMAT_MPS() { + return CUOPT_FILE_FORMAT_MPS; + } + private static final int CUOPT_SUCCESS = (int)0L; + /** + * {@snippet lang=c : + * #define CUOPT_SUCCESS 0 + * } + */ + public static int CUOPT_SUCCESS() { + return CUOPT_SUCCESS; + } + private static final int CUOPT_INVALID_ARGUMENT = (int)1L; + /** + * {@snippet lang=c : + * #define CUOPT_INVALID_ARGUMENT 1 + * } + */ + public static int CUOPT_INVALID_ARGUMENT() { + return CUOPT_INVALID_ARGUMENT; + } + private static final int CUOPT_MPS_FILE_ERROR = (int)2L; + /** + * {@snippet lang=c : + * #define CUOPT_MPS_FILE_ERROR 2 + * } + */ + public static int CUOPT_MPS_FILE_ERROR() { + return CUOPT_MPS_FILE_ERROR; + } + private static final int CUOPT_MPS_PARSE_ERROR = (int)3L; + /** + * {@snippet lang=c : + * #define CUOPT_MPS_PARSE_ERROR 3 + * } + */ + public static int CUOPT_MPS_PARSE_ERROR() { + return CUOPT_MPS_PARSE_ERROR; + } + private static final int CUOPT_VALIDATION_ERROR = (int)4L; + /** + * {@snippet lang=c : + * #define CUOPT_VALIDATION_ERROR 4 + * } + */ + public static int CUOPT_VALIDATION_ERROR() { + return CUOPT_VALIDATION_ERROR; + } + private static final int CUOPT_OUT_OF_MEMORY = (int)5L; + /** + * {@snippet lang=c : + * #define CUOPT_OUT_OF_MEMORY 5 + * } + */ + public static int CUOPT_OUT_OF_MEMORY() { + return CUOPT_OUT_OF_MEMORY; + } + private static final int CUOPT_RUNTIME_ERROR = (int)6L; + /** + * {@snippet lang=c : + * #define CUOPT_RUNTIME_ERROR 6 + * } + */ + public static int CUOPT_RUNTIME_ERROR() { + return CUOPT_RUNTIME_ERROR; + } + private static final int CUOPT_PRESOLVE_OFF = (int)0L; + /** + * {@snippet lang=c : + * #define CUOPT_PRESOLVE_OFF 0 + * } + */ + public static int CUOPT_PRESOLVE_OFF() { + return CUOPT_PRESOLVE_OFF; + } + private static final int CUOPT_PRESOLVE_PAPILO = (int)1L; + /** + * {@snippet lang=c : + * #define CUOPT_PRESOLVE_PAPILO 1 + * } + */ + public static int CUOPT_PRESOLVE_PAPILO() { + return CUOPT_PRESOLVE_PAPILO; + } + private static final int CUOPT_PRESOLVE_PSLP = (int)2L; + /** + * {@snippet lang=c : + * #define CUOPT_PRESOLVE_PSLP 2 + * } + */ + public static int CUOPT_PRESOLVE_PSLP() { + return CUOPT_PRESOLVE_PSLP; + } + private static final int CUOPT_MIP_SCALING_OFF = (int)0L; + /** + * {@snippet lang=c : + * #define CUOPT_MIP_SCALING_OFF 0 + * } + */ + public static int CUOPT_MIP_SCALING_OFF() { + return CUOPT_MIP_SCALING_OFF; + } + private static final int CUOPT_MIP_SCALING_ON = (int)1L; + /** + * {@snippet lang=c : + * #define CUOPT_MIP_SCALING_ON 1 + * } + */ + public static int CUOPT_MIP_SCALING_ON() { + return CUOPT_MIP_SCALING_ON; + } + private static final int CUOPT_MIP_SCALING_NO_OBJECTIVE = (int)2L; + /** + * {@snippet lang=c : + * #define CUOPT_MIP_SCALING_NO_OBJECTIVE 2 + * } + */ + public static int CUOPT_MIP_SCALING_NO_OBJECTIVE() { + return CUOPT_MIP_SCALING_NO_OBJECTIVE; + } + private static final int _STDINT_H = (int)1L; + /** + * {@snippet lang=c : + * #define _STDINT_H 1 + * } + */ + public static int _STDINT_H() { + return _STDINT_H; + } + private static final int _BITS_WCHAR_H = (int)1L; + /** + * {@snippet lang=c : + * #define _BITS_WCHAR_H 1 + * } + */ + public static int _BITS_WCHAR_H() { + return _BITS_WCHAR_H; + } + private static final int _BITS_STDINT_INTN_H = (int)1L; + /** + * {@snippet lang=c : + * #define _BITS_STDINT_INTN_H 1 + * } + */ + public static int _BITS_STDINT_INTN_H() { + return _BITS_STDINT_INTN_H; + } + private static final int _BITS_STDINT_UINTN_H = (int)1L; + /** + * {@snippet lang=c : + * #define _BITS_STDINT_UINTN_H 1 + * } + */ + public static int _BITS_STDINT_UINTN_H() { + return _BITS_STDINT_UINTN_H; + } + /** + * {@snippet lang=c : + * typedef unsigned char __u_char + * } + */ + public static final OfByte __u_char = cuopt_c_h.C_CHAR; + /** + * {@snippet lang=c : + * typedef unsigned short __u_short + * } + */ + public static final OfShort __u_short = cuopt_c_h.C_SHORT; + /** + * {@snippet lang=c : + * typedef unsigned int __u_int + * } + */ + public static final OfInt __u_int = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef unsigned long __u_long + * } + */ + public static final OfLong __u_long = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef signed char __int8_t + * } + */ + public static final OfByte __int8_t = cuopt_c_h.C_CHAR; + /** + * {@snippet lang=c : + * typedef unsigned char __uint8_t + * } + */ + public static final OfByte __uint8_t = cuopt_c_h.C_CHAR; + /** + * {@snippet lang=c : + * typedef short __int16_t + * } + */ + public static final OfShort __int16_t = cuopt_c_h.C_SHORT; + /** + * {@snippet lang=c : + * typedef unsigned short __uint16_t + * } + */ + public static final OfShort __uint16_t = cuopt_c_h.C_SHORT; + /** + * {@snippet lang=c : + * typedef int __int32_t + * } + */ + public static final OfInt __int32_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef unsigned int __uint32_t + * } + */ + public static final OfInt __uint32_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef long __int64_t + * } + */ + public static final OfLong __int64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long __uint64_t + * } + */ + public static final OfLong __uint64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef __int8_t __int_least8_t + * } + */ + public static final OfByte __int_least8_t = cuopt_c_h.C_CHAR; + /** + * {@snippet lang=c : + * typedef __uint8_t __uint_least8_t + * } + */ + public static final OfByte __uint_least8_t = cuopt_c_h.C_CHAR; + /** + * {@snippet lang=c : + * typedef __int16_t __int_least16_t + * } + */ + public static final OfShort __int_least16_t = cuopt_c_h.C_SHORT; + /** + * {@snippet lang=c : + * typedef __uint16_t __uint_least16_t + * } + */ + public static final OfShort __uint_least16_t = cuopt_c_h.C_SHORT; + /** + * {@snippet lang=c : + * typedef __int32_t __int_least32_t + * } + */ + public static final OfInt __int_least32_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef __uint32_t __uint_least32_t + * } + */ + public static final OfInt __uint_least32_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef __int64_t __int_least64_t + * } + */ + public static final OfLong __int_least64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef __uint64_t __uint_least64_t + * } + */ + public static final OfLong __uint_least64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef long __quad_t + * } + */ + public static final OfLong __quad_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long __u_quad_t + * } + */ + public static final OfLong __u_quad_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef long __intmax_t + * } + */ + public static final OfLong __intmax_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long __uintmax_t + * } + */ + public static final OfLong __uintmax_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long __dev_t + * } + */ + public static final OfLong __dev_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned int __uid_t + * } + */ + public static final OfInt __uid_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef unsigned int __gid_t + * } + */ + public static final OfInt __gid_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef unsigned long __ino_t + * } + */ + public static final OfLong __ino_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long __ino64_t + * } + */ + public static final OfLong __ino64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned int __mode_t + * } + */ + public static final OfInt __mode_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef unsigned long __nlink_t + * } + */ + public static final OfLong __nlink_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef long __off_t + * } + */ + public static final OfLong __off_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef long __off64_t + * } + */ + public static final OfLong __off64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef int __pid_t + * } + */ + public static final OfInt __pid_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef long __clock_t + * } + */ + public static final OfLong __clock_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long __rlim_t + * } + */ + public static final OfLong __rlim_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long __rlim64_t + * } + */ + public static final OfLong __rlim64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned int __id_t + * } + */ + public static final OfInt __id_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef long __time_t + * } + */ + public static final OfLong __time_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned int __useconds_t + * } + */ + public static final OfInt __useconds_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef long __suseconds_t + * } + */ + public static final OfLong __suseconds_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef long __suseconds64_t + * } + */ + public static final OfLong __suseconds64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef int __daddr_t + * } + */ + public static final OfInt __daddr_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef int __key_t + * } + */ + public static final OfInt __key_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef int __clockid_t + * } + */ + public static final OfInt __clockid_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef void *__timer_t + * } + */ + public static final AddressLayout __timer_t = cuopt_c_h.C_POINTER; + /** + * {@snippet lang=c : + * typedef long __blksize_t + * } + */ + public static final OfLong __blksize_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef long __blkcnt_t + * } + */ + public static final OfLong __blkcnt_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef long __blkcnt64_t + * } + */ + public static final OfLong __blkcnt64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long __fsblkcnt_t + * } + */ + public static final OfLong __fsblkcnt_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long __fsblkcnt64_t + * } + */ + public static final OfLong __fsblkcnt64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long __fsfilcnt_t + * } + */ + public static final OfLong __fsfilcnt_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long __fsfilcnt64_t + * } + */ + public static final OfLong __fsfilcnt64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef long __fsword_t + * } + */ + public static final OfLong __fsword_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef long __ssize_t + * } + */ + public static final OfLong __ssize_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef long __syscall_slong_t + * } + */ + public static final OfLong __syscall_slong_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long __syscall_ulong_t + * } + */ + public static final OfLong __syscall_ulong_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef __off64_t __loff_t + * } + */ + public static final OfLong __loff_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef char *__caddr_t + * } + */ + public static final AddressLayout __caddr_t = cuopt_c_h.C_POINTER; + /** + * {@snippet lang=c : + * typedef long __intptr_t + * } + */ + public static final OfLong __intptr_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned int __socklen_t + * } + */ + public static final OfInt __socklen_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef int __sig_atomic_t + * } + */ + public static final OfInt __sig_atomic_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef float _Float32 + * } + */ + public static final OfFloat _Float32 = cuopt_c_h.C_FLOAT; + /** + * {@snippet lang=c : + * typedef double _Float64 + * } + */ + public static final OfDouble _Float64 = cuopt_c_h.C_DOUBLE; + /** + * {@snippet lang=c : + * typedef double _Float32x + * } + */ + public static final OfDouble _Float32x = cuopt_c_h.C_DOUBLE; + /** + * {@snippet lang=c : + * typedef float float_t + * } + */ + public static final OfFloat float_t = cuopt_c_h.C_FLOAT; + /** + * {@snippet lang=c : + * typedef double double_t + * } + */ + public static final OfDouble double_t = cuopt_c_h.C_DOUBLE; + + private static class __fpclassify { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__fpclassify"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __fpclassify(double __value) + * } + */ + public static FunctionDescriptor __fpclassify$descriptor() { + return __fpclassify.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __fpclassify(double __value) + * } + */ + public static MethodHandle __fpclassify$handle() { + return __fpclassify.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __fpclassify(double __value) + * } + */ + public static MemorySegment __fpclassify$address() { + return __fpclassify.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __fpclassify(double __value) + * } + */ + public static int __fpclassify(double __value) { + var mh$ = __fpclassify.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__fpclassify", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __signbit { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__signbit"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __signbit(double __value) + * } + */ + public static FunctionDescriptor __signbit$descriptor() { + return __signbit.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __signbit(double __value) + * } + */ + public static MethodHandle __signbit$handle() { + return __signbit.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __signbit(double __value) + * } + */ + public static MemorySegment __signbit$address() { + return __signbit.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __signbit(double __value) + * } + */ + public static int __signbit(double __value) { + var mh$ = __signbit.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__signbit", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __isinf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__isinf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __isinf(double __value) + * } + */ + public static FunctionDescriptor __isinf$descriptor() { + return __isinf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __isinf(double __value) + * } + */ + public static MethodHandle __isinf$handle() { + return __isinf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __isinf(double __value) + * } + */ + public static MemorySegment __isinf$address() { + return __isinf.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __isinf(double __value) + * } + */ + public static int __isinf(double __value) { + var mh$ = __isinf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__isinf", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __finite { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__finite"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __finite(double __value) + * } + */ + public static FunctionDescriptor __finite$descriptor() { + return __finite.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __finite(double __value) + * } + */ + public static MethodHandle __finite$handle() { + return __finite.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __finite(double __value) + * } + */ + public static MemorySegment __finite$address() { + return __finite.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __finite(double __value) + * } + */ + public static int __finite(double __value) { + var mh$ = __finite.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__finite", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __isnan { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__isnan"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __isnan(double __value) + * } + */ + public static FunctionDescriptor __isnan$descriptor() { + return __isnan.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __isnan(double __value) + * } + */ + public static MethodHandle __isnan$handle() { + return __isnan.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __isnan(double __value) + * } + */ + public static MemorySegment __isnan$address() { + return __isnan.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __isnan(double __value) + * } + */ + public static int __isnan(double __value) { + var mh$ = __isnan.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__isnan", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __iseqsig { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__iseqsig"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __iseqsig(double __x, double __y) + * } + */ + public static FunctionDescriptor __iseqsig$descriptor() { + return __iseqsig.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __iseqsig(double __x, double __y) + * } + */ + public static MethodHandle __iseqsig$handle() { + return __iseqsig.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __iseqsig(double __x, double __y) + * } + */ + public static MemorySegment __iseqsig$address() { + return __iseqsig.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __iseqsig(double __x, double __y) + * } + */ + public static int __iseqsig(double __x, double __y) { + var mh$ = __iseqsig.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__iseqsig", __x, __y); + } + return (int)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __issignaling { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__issignaling"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __issignaling(double __value) + * } + */ + public static FunctionDescriptor __issignaling$descriptor() { + return __issignaling.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __issignaling(double __value) + * } + */ + public static MethodHandle __issignaling$handle() { + return __issignaling.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __issignaling(double __value) + * } + */ + public static MemorySegment __issignaling$address() { + return __issignaling.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __issignaling(double __value) + * } + */ + public static int __issignaling(double __value) { + var mh$ = __issignaling.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__issignaling", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class acos { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("acos"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double acos(double __x) + * } + */ + public static FunctionDescriptor acos$descriptor() { + return acos.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double acos(double __x) + * } + */ + public static MethodHandle acos$handle() { + return acos.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double acos(double __x) + * } + */ + public static MemorySegment acos$address() { + return acos.ADDR; + } + + /** + * {@snippet lang=c : + * extern double acos(double __x) + * } + */ + public static double acos(double __x) { + var mh$ = acos.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("acos", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __acos { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__acos"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __acos(double __x) + * } + */ + public static FunctionDescriptor __acos$descriptor() { + return __acos.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __acos(double __x) + * } + */ + public static MethodHandle __acos$handle() { + return __acos.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __acos(double __x) + * } + */ + public static MemorySegment __acos$address() { + return __acos.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __acos(double __x) + * } + */ + public static double __acos(double __x) { + var mh$ = __acos.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__acos", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class asin { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("asin"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double asin(double __x) + * } + */ + public static FunctionDescriptor asin$descriptor() { + return asin.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double asin(double __x) + * } + */ + public static MethodHandle asin$handle() { + return asin.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double asin(double __x) + * } + */ + public static MemorySegment asin$address() { + return asin.ADDR; + } + + /** + * {@snippet lang=c : + * extern double asin(double __x) + * } + */ + public static double asin(double __x) { + var mh$ = asin.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("asin", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __asin { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__asin"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __asin(double __x) + * } + */ + public static FunctionDescriptor __asin$descriptor() { + return __asin.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __asin(double __x) + * } + */ + public static MethodHandle __asin$handle() { + return __asin.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __asin(double __x) + * } + */ + public static MemorySegment __asin$address() { + return __asin.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __asin(double __x) + * } + */ + public static double __asin(double __x) { + var mh$ = __asin.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__asin", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class atan { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("atan"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double atan(double __x) + * } + */ + public static FunctionDescriptor atan$descriptor() { + return atan.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double atan(double __x) + * } + */ + public static MethodHandle atan$handle() { + return atan.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double atan(double __x) + * } + */ + public static MemorySegment atan$address() { + return atan.ADDR; + } + + /** + * {@snippet lang=c : + * extern double atan(double __x) + * } + */ + public static double atan(double __x) { + var mh$ = atan.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("atan", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __atan { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__atan"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __atan(double __x) + * } + */ + public static FunctionDescriptor __atan$descriptor() { + return __atan.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __atan(double __x) + * } + */ + public static MethodHandle __atan$handle() { + return __atan.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __atan(double __x) + * } + */ + public static MemorySegment __atan$address() { + return __atan.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __atan(double __x) + * } + */ + public static double __atan(double __x) { + var mh$ = __atan.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__atan", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class atan2 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("atan2"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double atan2(double __y, double __x) + * } + */ + public static FunctionDescriptor atan2$descriptor() { + return atan2.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double atan2(double __y, double __x) + * } + */ + public static MethodHandle atan2$handle() { + return atan2.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double atan2(double __y, double __x) + * } + */ + public static MemorySegment atan2$address() { + return atan2.ADDR; + } + + /** + * {@snippet lang=c : + * extern double atan2(double __y, double __x) + * } + */ + public static double atan2(double __y, double __x) { + var mh$ = atan2.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("atan2", __y, __x); + } + return (double)mh$.invokeExact(__y, __x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __atan2 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__atan2"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __atan2(double __y, double __x) + * } + */ + public static FunctionDescriptor __atan2$descriptor() { + return __atan2.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __atan2(double __y, double __x) + * } + */ + public static MethodHandle __atan2$handle() { + return __atan2.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __atan2(double __y, double __x) + * } + */ + public static MemorySegment __atan2$address() { + return __atan2.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __atan2(double __y, double __x) + * } + */ + public static double __atan2(double __y, double __x) { + var mh$ = __atan2.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__atan2", __y, __x); + } + return (double)mh$.invokeExact(__y, __x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cos { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cos"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double cos(double __x) + * } + */ + public static FunctionDescriptor cos$descriptor() { + return cos.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double cos(double __x) + * } + */ + public static MethodHandle cos$handle() { + return cos.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double cos(double __x) + * } + */ + public static MemorySegment cos$address() { + return cos.ADDR; + } + + /** + * {@snippet lang=c : + * extern double cos(double __x) + * } + */ + public static double cos(double __x) { + var mh$ = cos.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cos", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __cos { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__cos"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __cos(double __x) + * } + */ + public static FunctionDescriptor __cos$descriptor() { + return __cos.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __cos(double __x) + * } + */ + public static MethodHandle __cos$handle() { + return __cos.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __cos(double __x) + * } + */ + public static MemorySegment __cos$address() { + return __cos.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __cos(double __x) + * } + */ + public static double __cos(double __x) { + var mh$ = __cos.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__cos", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class sin { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("sin"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double sin(double __x) + * } + */ + public static FunctionDescriptor sin$descriptor() { + return sin.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double sin(double __x) + * } + */ + public static MethodHandle sin$handle() { + return sin.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double sin(double __x) + * } + */ + public static MemorySegment sin$address() { + return sin.ADDR; + } + + /** + * {@snippet lang=c : + * extern double sin(double __x) + * } + */ + public static double sin(double __x) { + var mh$ = sin.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("sin", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __sin { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__sin"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __sin(double __x) + * } + */ + public static FunctionDescriptor __sin$descriptor() { + return __sin.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __sin(double __x) + * } + */ + public static MethodHandle __sin$handle() { + return __sin.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __sin(double __x) + * } + */ + public static MemorySegment __sin$address() { + return __sin.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __sin(double __x) + * } + */ + public static double __sin(double __x) { + var mh$ = __sin.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__sin", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class tan { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("tan"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double tan(double __x) + * } + */ + public static FunctionDescriptor tan$descriptor() { + return tan.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double tan(double __x) + * } + */ + public static MethodHandle tan$handle() { + return tan.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double tan(double __x) + * } + */ + public static MemorySegment tan$address() { + return tan.ADDR; + } + + /** + * {@snippet lang=c : + * extern double tan(double __x) + * } + */ + public static double tan(double __x) { + var mh$ = tan.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("tan", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __tan { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__tan"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __tan(double __x) + * } + */ + public static FunctionDescriptor __tan$descriptor() { + return __tan.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __tan(double __x) + * } + */ + public static MethodHandle __tan$handle() { + return __tan.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __tan(double __x) + * } + */ + public static MemorySegment __tan$address() { + return __tan.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __tan(double __x) + * } + */ + public static double __tan(double __x) { + var mh$ = __tan.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__tan", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cosh { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cosh"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double cosh(double __x) + * } + */ + public static FunctionDescriptor cosh$descriptor() { + return cosh.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double cosh(double __x) + * } + */ + public static MethodHandle cosh$handle() { + return cosh.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double cosh(double __x) + * } + */ + public static MemorySegment cosh$address() { + return cosh.ADDR; + } + + /** + * {@snippet lang=c : + * extern double cosh(double __x) + * } + */ + public static double cosh(double __x) { + var mh$ = cosh.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cosh", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __cosh { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__cosh"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __cosh(double __x) + * } + */ + public static FunctionDescriptor __cosh$descriptor() { + return __cosh.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __cosh(double __x) + * } + */ + public static MethodHandle __cosh$handle() { + return __cosh.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __cosh(double __x) + * } + */ + public static MemorySegment __cosh$address() { + return __cosh.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __cosh(double __x) + * } + */ + public static double __cosh(double __x) { + var mh$ = __cosh.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__cosh", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class sinh { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("sinh"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double sinh(double __x) + * } + */ + public static FunctionDescriptor sinh$descriptor() { + return sinh.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double sinh(double __x) + * } + */ + public static MethodHandle sinh$handle() { + return sinh.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double sinh(double __x) + * } + */ + public static MemorySegment sinh$address() { + return sinh.ADDR; + } + + /** + * {@snippet lang=c : + * extern double sinh(double __x) + * } + */ + public static double sinh(double __x) { + var mh$ = sinh.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("sinh", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __sinh { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__sinh"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __sinh(double __x) + * } + */ + public static FunctionDescriptor __sinh$descriptor() { + return __sinh.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __sinh(double __x) + * } + */ + public static MethodHandle __sinh$handle() { + return __sinh.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __sinh(double __x) + * } + */ + public static MemorySegment __sinh$address() { + return __sinh.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __sinh(double __x) + * } + */ + public static double __sinh(double __x) { + var mh$ = __sinh.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__sinh", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class tanh { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("tanh"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double tanh(double __x) + * } + */ + public static FunctionDescriptor tanh$descriptor() { + return tanh.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double tanh(double __x) + * } + */ + public static MethodHandle tanh$handle() { + return tanh.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double tanh(double __x) + * } + */ + public static MemorySegment tanh$address() { + return tanh.ADDR; + } + + /** + * {@snippet lang=c : + * extern double tanh(double __x) + * } + */ + public static double tanh(double __x) { + var mh$ = tanh.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("tanh", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __tanh { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__tanh"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __tanh(double __x) + * } + */ + public static FunctionDescriptor __tanh$descriptor() { + return __tanh.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __tanh(double __x) + * } + */ + public static MethodHandle __tanh$handle() { + return __tanh.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __tanh(double __x) + * } + */ + public static MemorySegment __tanh$address() { + return __tanh.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __tanh(double __x) + * } + */ + public static double __tanh(double __x) { + var mh$ = __tanh.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__tanh", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class acosh { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("acosh"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double acosh(double __x) + * } + */ + public static FunctionDescriptor acosh$descriptor() { + return acosh.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double acosh(double __x) + * } + */ + public static MethodHandle acosh$handle() { + return acosh.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double acosh(double __x) + * } + */ + public static MemorySegment acosh$address() { + return acosh.ADDR; + } + + /** + * {@snippet lang=c : + * extern double acosh(double __x) + * } + */ + public static double acosh(double __x) { + var mh$ = acosh.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("acosh", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __acosh { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__acosh"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __acosh(double __x) + * } + */ + public static FunctionDescriptor __acosh$descriptor() { + return __acosh.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __acosh(double __x) + * } + */ + public static MethodHandle __acosh$handle() { + return __acosh.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __acosh(double __x) + * } + */ + public static MemorySegment __acosh$address() { + return __acosh.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __acosh(double __x) + * } + */ + public static double __acosh(double __x) { + var mh$ = __acosh.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__acosh", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class asinh { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("asinh"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double asinh(double __x) + * } + */ + public static FunctionDescriptor asinh$descriptor() { + return asinh.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double asinh(double __x) + * } + */ + public static MethodHandle asinh$handle() { + return asinh.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double asinh(double __x) + * } + */ + public static MemorySegment asinh$address() { + return asinh.ADDR; + } + + /** + * {@snippet lang=c : + * extern double asinh(double __x) + * } + */ + public static double asinh(double __x) { + var mh$ = asinh.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("asinh", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __asinh { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__asinh"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __asinh(double __x) + * } + */ + public static FunctionDescriptor __asinh$descriptor() { + return __asinh.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __asinh(double __x) + * } + */ + public static MethodHandle __asinh$handle() { + return __asinh.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __asinh(double __x) + * } + */ + public static MemorySegment __asinh$address() { + return __asinh.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __asinh(double __x) + * } + */ + public static double __asinh(double __x) { + var mh$ = __asinh.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__asinh", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class atanh { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("atanh"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double atanh(double __x) + * } + */ + public static FunctionDescriptor atanh$descriptor() { + return atanh.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double atanh(double __x) + * } + */ + public static MethodHandle atanh$handle() { + return atanh.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double atanh(double __x) + * } + */ + public static MemorySegment atanh$address() { + return atanh.ADDR; + } + + /** + * {@snippet lang=c : + * extern double atanh(double __x) + * } + */ + public static double atanh(double __x) { + var mh$ = atanh.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("atanh", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __atanh { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__atanh"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __atanh(double __x) + * } + */ + public static FunctionDescriptor __atanh$descriptor() { + return __atanh.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __atanh(double __x) + * } + */ + public static MethodHandle __atanh$handle() { + return __atanh.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __atanh(double __x) + * } + */ + public static MemorySegment __atanh$address() { + return __atanh.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __atanh(double __x) + * } + */ + public static double __atanh(double __x) { + var mh$ = __atanh.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__atanh", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class exp { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("exp"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double exp(double __x) + * } + */ + public static FunctionDescriptor exp$descriptor() { + return exp.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double exp(double __x) + * } + */ + public static MethodHandle exp$handle() { + return exp.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double exp(double __x) + * } + */ + public static MemorySegment exp$address() { + return exp.ADDR; + } + + /** + * {@snippet lang=c : + * extern double exp(double __x) + * } + */ + public static double exp(double __x) { + var mh$ = exp.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("exp", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __exp { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__exp"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __exp(double __x) + * } + */ + public static FunctionDescriptor __exp$descriptor() { + return __exp.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __exp(double __x) + * } + */ + public static MethodHandle __exp$handle() { + return __exp.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __exp(double __x) + * } + */ + public static MemorySegment __exp$address() { + return __exp.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __exp(double __x) + * } + */ + public static double __exp(double __x) { + var mh$ = __exp.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__exp", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class frexp { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("frexp"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double frexp(double __x, int *__exponent) + * } + */ + public static FunctionDescriptor frexp$descriptor() { + return frexp.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double frexp(double __x, int *__exponent) + * } + */ + public static MethodHandle frexp$handle() { + return frexp.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double frexp(double __x, int *__exponent) + * } + */ + public static MemorySegment frexp$address() { + return frexp.ADDR; + } + + /** + * {@snippet lang=c : + * extern double frexp(double __x, int *__exponent) + * } + */ + public static double frexp(double __x, MemorySegment __exponent) { + var mh$ = frexp.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("frexp", __x, __exponent); + } + return (double)mh$.invokeExact(__x, __exponent); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __frexp { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__frexp"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __frexp(double __x, int *__exponent) + * } + */ + public static FunctionDescriptor __frexp$descriptor() { + return __frexp.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __frexp(double __x, int *__exponent) + * } + */ + public static MethodHandle __frexp$handle() { + return __frexp.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __frexp(double __x, int *__exponent) + * } + */ + public static MemorySegment __frexp$address() { + return __frexp.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __frexp(double __x, int *__exponent) + * } + */ + public static double __frexp(double __x, MemorySegment __exponent) { + var mh$ = __frexp.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__frexp", __x, __exponent); + } + return (double)mh$.invokeExact(__x, __exponent); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ldexp { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_INT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("ldexp"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double ldexp(double __x, int __exponent) + * } + */ + public static FunctionDescriptor ldexp$descriptor() { + return ldexp.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double ldexp(double __x, int __exponent) + * } + */ + public static MethodHandle ldexp$handle() { + return ldexp.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double ldexp(double __x, int __exponent) + * } + */ + public static MemorySegment ldexp$address() { + return ldexp.ADDR; + } + + /** + * {@snippet lang=c : + * extern double ldexp(double __x, int __exponent) + * } + */ + public static double ldexp(double __x, int __exponent) { + var mh$ = ldexp.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ldexp", __x, __exponent); + } + return (double)mh$.invokeExact(__x, __exponent); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __ldexp { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_INT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__ldexp"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __ldexp(double __x, int __exponent) + * } + */ + public static FunctionDescriptor __ldexp$descriptor() { + return __ldexp.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __ldexp(double __x, int __exponent) + * } + */ + public static MethodHandle __ldexp$handle() { + return __ldexp.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __ldexp(double __x, int __exponent) + * } + */ + public static MemorySegment __ldexp$address() { + return __ldexp.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __ldexp(double __x, int __exponent) + * } + */ + public static double __ldexp(double __x, int __exponent) { + var mh$ = __ldexp.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__ldexp", __x, __exponent); + } + return (double)mh$.invokeExact(__x, __exponent); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class log { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("log"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double log(double __x) + * } + */ + public static FunctionDescriptor log$descriptor() { + return log.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double log(double __x) + * } + */ + public static MethodHandle log$handle() { + return log.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double log(double __x) + * } + */ + public static MemorySegment log$address() { + return log.ADDR; + } + + /** + * {@snippet lang=c : + * extern double log(double __x) + * } + */ + public static double log(double __x) { + var mh$ = log.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("log", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __log { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__log"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __log(double __x) + * } + */ + public static FunctionDescriptor __log$descriptor() { + return __log.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __log(double __x) + * } + */ + public static MethodHandle __log$handle() { + return __log.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __log(double __x) + * } + */ + public static MemorySegment __log$address() { + return __log.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __log(double __x) + * } + */ + public static double __log(double __x) { + var mh$ = __log.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__log", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class log10 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("log10"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double log10(double __x) + * } + */ + public static FunctionDescriptor log10$descriptor() { + return log10.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double log10(double __x) + * } + */ + public static MethodHandle log10$handle() { + return log10.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double log10(double __x) + * } + */ + public static MemorySegment log10$address() { + return log10.ADDR; + } + + /** + * {@snippet lang=c : + * extern double log10(double __x) + * } + */ + public static double log10(double __x) { + var mh$ = log10.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("log10", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __log10 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__log10"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __log10(double __x) + * } + */ + public static FunctionDescriptor __log10$descriptor() { + return __log10.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __log10(double __x) + * } + */ + public static MethodHandle __log10$handle() { + return __log10.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __log10(double __x) + * } + */ + public static MemorySegment __log10$address() { + return __log10.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __log10(double __x) + * } + */ + public static double __log10(double __x) { + var mh$ = __log10.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__log10", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class modf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("modf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double modf(double __x, double *__iptr) + * } + */ + public static FunctionDescriptor modf$descriptor() { + return modf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double modf(double __x, double *__iptr) + * } + */ + public static MethodHandle modf$handle() { + return modf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double modf(double __x, double *__iptr) + * } + */ + public static MemorySegment modf$address() { + return modf.ADDR; + } + + /** + * {@snippet lang=c : + * extern double modf(double __x, double *__iptr) + * } + */ + public static double modf(double __x, MemorySegment __iptr) { + var mh$ = modf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("modf", __x, __iptr); + } + return (double)mh$.invokeExact(__x, __iptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __modf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__modf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __modf(double __x, double *__iptr) + * } + */ + public static FunctionDescriptor __modf$descriptor() { + return __modf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __modf(double __x, double *__iptr) + * } + */ + public static MethodHandle __modf$handle() { + return __modf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __modf(double __x, double *__iptr) + * } + */ + public static MemorySegment __modf$address() { + return __modf.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __modf(double __x, double *__iptr) + * } + */ + public static double __modf(double __x, MemorySegment __iptr) { + var mh$ = __modf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__modf", __x, __iptr); + } + return (double)mh$.invokeExact(__x, __iptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class expm1 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("expm1"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double expm1(double __x) + * } + */ + public static FunctionDescriptor expm1$descriptor() { + return expm1.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double expm1(double __x) + * } + */ + public static MethodHandle expm1$handle() { + return expm1.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double expm1(double __x) + * } + */ + public static MemorySegment expm1$address() { + return expm1.ADDR; + } + + /** + * {@snippet lang=c : + * extern double expm1(double __x) + * } + */ + public static double expm1(double __x) { + var mh$ = expm1.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("expm1", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __expm1 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__expm1"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __expm1(double __x) + * } + */ + public static FunctionDescriptor __expm1$descriptor() { + return __expm1.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __expm1(double __x) + * } + */ + public static MethodHandle __expm1$handle() { + return __expm1.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __expm1(double __x) + * } + */ + public static MemorySegment __expm1$address() { + return __expm1.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __expm1(double __x) + * } + */ + public static double __expm1(double __x) { + var mh$ = __expm1.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__expm1", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class log1p { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("log1p"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double log1p(double __x) + * } + */ + public static FunctionDescriptor log1p$descriptor() { + return log1p.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double log1p(double __x) + * } + */ + public static MethodHandle log1p$handle() { + return log1p.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double log1p(double __x) + * } + */ + public static MemorySegment log1p$address() { + return log1p.ADDR; + } + + /** + * {@snippet lang=c : + * extern double log1p(double __x) + * } + */ + public static double log1p(double __x) { + var mh$ = log1p.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("log1p", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __log1p { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__log1p"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __log1p(double __x) + * } + */ + public static FunctionDescriptor __log1p$descriptor() { + return __log1p.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __log1p(double __x) + * } + */ + public static MethodHandle __log1p$handle() { + return __log1p.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __log1p(double __x) + * } + */ + public static MemorySegment __log1p$address() { + return __log1p.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __log1p(double __x) + * } + */ + public static double __log1p(double __x) { + var mh$ = __log1p.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__log1p", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class logb { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("logb"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double logb(double __x) + * } + */ + public static FunctionDescriptor logb$descriptor() { + return logb.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double logb(double __x) + * } + */ + public static MethodHandle logb$handle() { + return logb.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double logb(double __x) + * } + */ + public static MemorySegment logb$address() { + return logb.ADDR; + } + + /** + * {@snippet lang=c : + * extern double logb(double __x) + * } + */ + public static double logb(double __x) { + var mh$ = logb.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("logb", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __logb { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__logb"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __logb(double __x) + * } + */ + public static FunctionDescriptor __logb$descriptor() { + return __logb.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __logb(double __x) + * } + */ + public static MethodHandle __logb$handle() { + return __logb.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __logb(double __x) + * } + */ + public static MemorySegment __logb$address() { + return __logb.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __logb(double __x) + * } + */ + public static double __logb(double __x) { + var mh$ = __logb.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__logb", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class exp2 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("exp2"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double exp2(double __x) + * } + */ + public static FunctionDescriptor exp2$descriptor() { + return exp2.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double exp2(double __x) + * } + */ + public static MethodHandle exp2$handle() { + return exp2.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double exp2(double __x) + * } + */ + public static MemorySegment exp2$address() { + return exp2.ADDR; + } + + /** + * {@snippet lang=c : + * extern double exp2(double __x) + * } + */ + public static double exp2(double __x) { + var mh$ = exp2.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("exp2", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __exp2 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__exp2"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __exp2(double __x) + * } + */ + public static FunctionDescriptor __exp2$descriptor() { + return __exp2.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __exp2(double __x) + * } + */ + public static MethodHandle __exp2$handle() { + return __exp2.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __exp2(double __x) + * } + */ + public static MemorySegment __exp2$address() { + return __exp2.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __exp2(double __x) + * } + */ + public static double __exp2(double __x) { + var mh$ = __exp2.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__exp2", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class log2 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("log2"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double log2(double __x) + * } + */ + public static FunctionDescriptor log2$descriptor() { + return log2.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double log2(double __x) + * } + */ + public static MethodHandle log2$handle() { + return log2.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double log2(double __x) + * } + */ + public static MemorySegment log2$address() { + return log2.ADDR; + } + + /** + * {@snippet lang=c : + * extern double log2(double __x) + * } + */ + public static double log2(double __x) { + var mh$ = log2.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("log2", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __log2 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__log2"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __log2(double __x) + * } + */ + public static FunctionDescriptor __log2$descriptor() { + return __log2.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __log2(double __x) + * } + */ + public static MethodHandle __log2$handle() { + return __log2.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __log2(double __x) + * } + */ + public static MemorySegment __log2$address() { + return __log2.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __log2(double __x) + * } + */ + public static double __log2(double __x) { + var mh$ = __log2.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__log2", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class pow { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("pow"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double pow(double __x, double __y) + * } + */ + public static FunctionDescriptor pow$descriptor() { + return pow.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double pow(double __x, double __y) + * } + */ + public static MethodHandle pow$handle() { + return pow.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double pow(double __x, double __y) + * } + */ + public static MemorySegment pow$address() { + return pow.ADDR; + } + + /** + * {@snippet lang=c : + * extern double pow(double __x, double __y) + * } + */ + public static double pow(double __x, double __y) { + var mh$ = pow.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("pow", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __pow { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__pow"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __pow(double __x, double __y) + * } + */ + public static FunctionDescriptor __pow$descriptor() { + return __pow.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __pow(double __x, double __y) + * } + */ + public static MethodHandle __pow$handle() { + return __pow.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __pow(double __x, double __y) + * } + */ + public static MemorySegment __pow$address() { + return __pow.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __pow(double __x, double __y) + * } + */ + public static double __pow(double __x, double __y) { + var mh$ = __pow.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__pow", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class sqrt { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("sqrt"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double sqrt(double __x) + * } + */ + public static FunctionDescriptor sqrt$descriptor() { + return sqrt.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double sqrt(double __x) + * } + */ + public static MethodHandle sqrt$handle() { + return sqrt.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double sqrt(double __x) + * } + */ + public static MemorySegment sqrt$address() { + return sqrt.ADDR; + } + + /** + * {@snippet lang=c : + * extern double sqrt(double __x) + * } + */ + public static double sqrt(double __x) { + var mh$ = sqrt.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("sqrt", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __sqrt { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__sqrt"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __sqrt(double __x) + * } + */ + public static FunctionDescriptor __sqrt$descriptor() { + return __sqrt.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __sqrt(double __x) + * } + */ + public static MethodHandle __sqrt$handle() { + return __sqrt.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __sqrt(double __x) + * } + */ + public static MemorySegment __sqrt$address() { + return __sqrt.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __sqrt(double __x) + * } + */ + public static double __sqrt(double __x) { + var mh$ = __sqrt.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__sqrt", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class hypot { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("hypot"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double hypot(double __x, double __y) + * } + */ + public static FunctionDescriptor hypot$descriptor() { + return hypot.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double hypot(double __x, double __y) + * } + */ + public static MethodHandle hypot$handle() { + return hypot.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double hypot(double __x, double __y) + * } + */ + public static MemorySegment hypot$address() { + return hypot.ADDR; + } + + /** + * {@snippet lang=c : + * extern double hypot(double __x, double __y) + * } + */ + public static double hypot(double __x, double __y) { + var mh$ = hypot.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("hypot", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __hypot { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__hypot"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __hypot(double __x, double __y) + * } + */ + public static FunctionDescriptor __hypot$descriptor() { + return __hypot.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __hypot(double __x, double __y) + * } + */ + public static MethodHandle __hypot$handle() { + return __hypot.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __hypot(double __x, double __y) + * } + */ + public static MemorySegment __hypot$address() { + return __hypot.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __hypot(double __x, double __y) + * } + */ + public static double __hypot(double __x, double __y) { + var mh$ = __hypot.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__hypot", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cbrt { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cbrt"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double cbrt(double __x) + * } + */ + public static FunctionDescriptor cbrt$descriptor() { + return cbrt.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double cbrt(double __x) + * } + */ + public static MethodHandle cbrt$handle() { + return cbrt.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double cbrt(double __x) + * } + */ + public static MemorySegment cbrt$address() { + return cbrt.ADDR; + } + + /** + * {@snippet lang=c : + * extern double cbrt(double __x) + * } + */ + public static double cbrt(double __x) { + var mh$ = cbrt.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cbrt", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __cbrt { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__cbrt"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __cbrt(double __x) + * } + */ + public static FunctionDescriptor __cbrt$descriptor() { + return __cbrt.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __cbrt(double __x) + * } + */ + public static MethodHandle __cbrt$handle() { + return __cbrt.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __cbrt(double __x) + * } + */ + public static MemorySegment __cbrt$address() { + return __cbrt.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __cbrt(double __x) + * } + */ + public static double __cbrt(double __x) { + var mh$ = __cbrt.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__cbrt", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ceil { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("ceil"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double ceil(double __x) + * } + */ + public static FunctionDescriptor ceil$descriptor() { + return ceil.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double ceil(double __x) + * } + */ + public static MethodHandle ceil$handle() { + return ceil.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double ceil(double __x) + * } + */ + public static MemorySegment ceil$address() { + return ceil.ADDR; + } + + /** + * {@snippet lang=c : + * extern double ceil(double __x) + * } + */ + public static double ceil(double __x) { + var mh$ = ceil.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ceil", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __ceil { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__ceil"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __ceil(double __x) + * } + */ + public static FunctionDescriptor __ceil$descriptor() { + return __ceil.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __ceil(double __x) + * } + */ + public static MethodHandle __ceil$handle() { + return __ceil.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __ceil(double __x) + * } + */ + public static MemorySegment __ceil$address() { + return __ceil.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __ceil(double __x) + * } + */ + public static double __ceil(double __x) { + var mh$ = __ceil.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__ceil", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class fabs { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("fabs"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double fabs(double __x) + * } + */ + public static FunctionDescriptor fabs$descriptor() { + return fabs.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double fabs(double __x) + * } + */ + public static MethodHandle fabs$handle() { + return fabs.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double fabs(double __x) + * } + */ + public static MemorySegment fabs$address() { + return fabs.ADDR; + } + + /** + * {@snippet lang=c : + * extern double fabs(double __x) + * } + */ + public static double fabs(double __x) { + var mh$ = fabs.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("fabs", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __fabs { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__fabs"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __fabs(double __x) + * } + */ + public static FunctionDescriptor __fabs$descriptor() { + return __fabs.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __fabs(double __x) + * } + */ + public static MethodHandle __fabs$handle() { + return __fabs.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __fabs(double __x) + * } + */ + public static MemorySegment __fabs$address() { + return __fabs.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __fabs(double __x) + * } + */ + public static double __fabs(double __x) { + var mh$ = __fabs.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__fabs", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class floor { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("floor"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double floor(double __x) + * } + */ + public static FunctionDescriptor floor$descriptor() { + return floor.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double floor(double __x) + * } + */ + public static MethodHandle floor$handle() { + return floor.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double floor(double __x) + * } + */ + public static MemorySegment floor$address() { + return floor.ADDR; + } + + /** + * {@snippet lang=c : + * extern double floor(double __x) + * } + */ + public static double floor(double __x) { + var mh$ = floor.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("floor", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __floor { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__floor"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __floor(double __x) + * } + */ + public static FunctionDescriptor __floor$descriptor() { + return __floor.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __floor(double __x) + * } + */ + public static MethodHandle __floor$handle() { + return __floor.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __floor(double __x) + * } + */ + public static MemorySegment __floor$address() { + return __floor.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __floor(double __x) + * } + */ + public static double __floor(double __x) { + var mh$ = __floor.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__floor", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class fmod { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("fmod"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double fmod(double __x, double __y) + * } + */ + public static FunctionDescriptor fmod$descriptor() { + return fmod.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double fmod(double __x, double __y) + * } + */ + public static MethodHandle fmod$handle() { + return fmod.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double fmod(double __x, double __y) + * } + */ + public static MemorySegment fmod$address() { + return fmod.ADDR; + } + + /** + * {@snippet lang=c : + * extern double fmod(double __x, double __y) + * } + */ + public static double fmod(double __x, double __y) { + var mh$ = fmod.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("fmod", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __fmod { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__fmod"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __fmod(double __x, double __y) + * } + */ + public static FunctionDescriptor __fmod$descriptor() { + return __fmod.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __fmod(double __x, double __y) + * } + */ + public static MethodHandle __fmod$handle() { + return __fmod.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __fmod(double __x, double __y) + * } + */ + public static MemorySegment __fmod$address() { + return __fmod.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __fmod(double __x, double __y) + * } + */ + public static double __fmod(double __x, double __y) { + var mh$ = __fmod.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__fmod", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class isinf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("isinf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int isinf(double __value) + * } + */ + public static FunctionDescriptor isinf$descriptor() { + return isinf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int isinf(double __value) + * } + */ + public static MethodHandle isinf$handle() { + return isinf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int isinf(double __value) + * } + */ + public static MemorySegment isinf$address() { + return isinf.ADDR; + } + + /** + * {@snippet lang=c : + * extern int isinf(double __value) + * } + */ + public static int isinf(double __value) { + var mh$ = isinf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("isinf", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class finite { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("finite"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int finite(double __value) + * } + */ + public static FunctionDescriptor finite$descriptor() { + return finite.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int finite(double __value) + * } + */ + public static MethodHandle finite$handle() { + return finite.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int finite(double __value) + * } + */ + public static MemorySegment finite$address() { + return finite.ADDR; + } + + /** + * {@snippet lang=c : + * extern int finite(double __value) + * } + */ + public static int finite(double __value) { + var mh$ = finite.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("finite", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class drem { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("drem"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double drem(double __x, double __y) + * } + */ + public static FunctionDescriptor drem$descriptor() { + return drem.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double drem(double __x, double __y) + * } + */ + public static MethodHandle drem$handle() { + return drem.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double drem(double __x, double __y) + * } + */ + public static MemorySegment drem$address() { + return drem.ADDR; + } + + /** + * {@snippet lang=c : + * extern double drem(double __x, double __y) + * } + */ + public static double drem(double __x, double __y) { + var mh$ = drem.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("drem", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __drem { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__drem"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __drem(double __x, double __y) + * } + */ + public static FunctionDescriptor __drem$descriptor() { + return __drem.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __drem(double __x, double __y) + * } + */ + public static MethodHandle __drem$handle() { + return __drem.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __drem(double __x, double __y) + * } + */ + public static MemorySegment __drem$address() { + return __drem.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __drem(double __x, double __y) + * } + */ + public static double __drem(double __x, double __y) { + var mh$ = __drem.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__drem", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class significand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("significand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double significand(double __x) + * } + */ + public static FunctionDescriptor significand$descriptor() { + return significand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double significand(double __x) + * } + */ + public static MethodHandle significand$handle() { + return significand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double significand(double __x) + * } + */ + public static MemorySegment significand$address() { + return significand.ADDR; + } + + /** + * {@snippet lang=c : + * extern double significand(double __x) + * } + */ + public static double significand(double __x) { + var mh$ = significand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("significand", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __significand { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__significand"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __significand(double __x) + * } + */ + public static FunctionDescriptor __significand$descriptor() { + return __significand.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __significand(double __x) + * } + */ + public static MethodHandle __significand$handle() { + return __significand.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __significand(double __x) + * } + */ + public static MemorySegment __significand$address() { + return __significand.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __significand(double __x) + * } + */ + public static double __significand(double __x) { + var mh$ = __significand.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__significand", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class copysign { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("copysign"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double copysign(double __x, double __y) + * } + */ + public static FunctionDescriptor copysign$descriptor() { + return copysign.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double copysign(double __x, double __y) + * } + */ + public static MethodHandle copysign$handle() { + return copysign.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double copysign(double __x, double __y) + * } + */ + public static MemorySegment copysign$address() { + return copysign.ADDR; + } + + /** + * {@snippet lang=c : + * extern double copysign(double __x, double __y) + * } + */ + public static double copysign(double __x, double __y) { + var mh$ = copysign.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("copysign", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __copysign { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__copysign"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __copysign(double __x, double __y) + * } + */ + public static FunctionDescriptor __copysign$descriptor() { + return __copysign.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __copysign(double __x, double __y) + * } + */ + public static MethodHandle __copysign$handle() { + return __copysign.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __copysign(double __x, double __y) + * } + */ + public static MemorySegment __copysign$address() { + return __copysign.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __copysign(double __x, double __y) + * } + */ + public static double __copysign(double __x, double __y) { + var mh$ = __copysign.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__copysign", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class nan { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("nan"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double nan(const char *__tagb) + * } + */ + public static FunctionDescriptor nan$descriptor() { + return nan.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double nan(const char *__tagb) + * } + */ + public static MethodHandle nan$handle() { + return nan.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double nan(const char *__tagb) + * } + */ + public static MemorySegment nan$address() { + return nan.ADDR; + } + + /** + * {@snippet lang=c : + * extern double nan(const char *__tagb) + * } + */ + public static double nan(MemorySegment __tagb) { + var mh$ = nan.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("nan", __tagb); + } + return (double)mh$.invokeExact(__tagb); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __nan { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__nan"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __nan(const char *__tagb) + * } + */ + public static FunctionDescriptor __nan$descriptor() { + return __nan.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __nan(const char *__tagb) + * } + */ + public static MethodHandle __nan$handle() { + return __nan.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __nan(const char *__tagb) + * } + */ + public static MemorySegment __nan$address() { + return __nan.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __nan(const char *__tagb) + * } + */ + public static double __nan(MemorySegment __tagb) { + var mh$ = __nan.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__nan", __tagb); + } + return (double)mh$.invokeExact(__tagb); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class isnan { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("isnan"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int isnan(double __value) + * } + */ + public static FunctionDescriptor isnan$descriptor() { + return isnan.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int isnan(double __value) + * } + */ + public static MethodHandle isnan$handle() { + return isnan.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int isnan(double __value) + * } + */ + public static MemorySegment isnan$address() { + return isnan.ADDR; + } + + /** + * {@snippet lang=c : + * extern int isnan(double __value) + * } + */ + public static int isnan(double __value) { + var mh$ = isnan.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("isnan", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class j0 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("j0"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double j0(double) + * } + */ + public static FunctionDescriptor j0$descriptor() { + return j0.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double j0(double) + * } + */ + public static MethodHandle j0$handle() { + return j0.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double j0(double) + * } + */ + public static MemorySegment j0$address() { + return j0.ADDR; + } + + /** + * {@snippet lang=c : + * extern double j0(double) + * } + */ + public static double j0(double x0) { + var mh$ = j0.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("j0", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __j0 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__j0"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __j0(double) + * } + */ + public static FunctionDescriptor __j0$descriptor() { + return __j0.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __j0(double) + * } + */ + public static MethodHandle __j0$handle() { + return __j0.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __j0(double) + * } + */ + public static MemorySegment __j0$address() { + return __j0.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __j0(double) + * } + */ + public static double __j0(double x0) { + var mh$ = __j0.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__j0", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class j1 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("j1"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double j1(double) + * } + */ + public static FunctionDescriptor j1$descriptor() { + return j1.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double j1(double) + * } + */ + public static MethodHandle j1$handle() { + return j1.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double j1(double) + * } + */ + public static MemorySegment j1$address() { + return j1.ADDR; + } + + /** + * {@snippet lang=c : + * extern double j1(double) + * } + */ + public static double j1(double x0) { + var mh$ = j1.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("j1", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __j1 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__j1"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __j1(double) + * } + */ + public static FunctionDescriptor __j1$descriptor() { + return __j1.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __j1(double) + * } + */ + public static MethodHandle __j1$handle() { + return __j1.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __j1(double) + * } + */ + public static MemorySegment __j1$address() { + return __j1.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __j1(double) + * } + */ + public static double __j1(double x0) { + var mh$ = __j1.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__j1", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class jn { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("jn"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double jn(int, double) + * } + */ + public static FunctionDescriptor jn$descriptor() { + return jn.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double jn(int, double) + * } + */ + public static MethodHandle jn$handle() { + return jn.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double jn(int, double) + * } + */ + public static MemorySegment jn$address() { + return jn.ADDR; + } + + /** + * {@snippet lang=c : + * extern double jn(int, double) + * } + */ + public static double jn(int x0, double x1) { + var mh$ = jn.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("jn", x0, x1); + } + return (double)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __jn { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__jn"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __jn(int, double) + * } + */ + public static FunctionDescriptor __jn$descriptor() { + return __jn.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __jn(int, double) + * } + */ + public static MethodHandle __jn$handle() { + return __jn.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __jn(int, double) + * } + */ + public static MemorySegment __jn$address() { + return __jn.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __jn(int, double) + * } + */ + public static double __jn(int x0, double x1) { + var mh$ = __jn.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__jn", x0, x1); + } + return (double)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class y0 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("y0"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double y0(double) + * } + */ + public static FunctionDescriptor y0$descriptor() { + return y0.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double y0(double) + * } + */ + public static MethodHandle y0$handle() { + return y0.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double y0(double) + * } + */ + public static MemorySegment y0$address() { + return y0.ADDR; + } + + /** + * {@snippet lang=c : + * extern double y0(double) + * } + */ + public static double y0(double x0) { + var mh$ = y0.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("y0", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __y0 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__y0"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __y0(double) + * } + */ + public static FunctionDescriptor __y0$descriptor() { + return __y0.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __y0(double) + * } + */ + public static MethodHandle __y0$handle() { + return __y0.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __y0(double) + * } + */ + public static MemorySegment __y0$address() { + return __y0.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __y0(double) + * } + */ + public static double __y0(double x0) { + var mh$ = __y0.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__y0", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class y1 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("y1"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double y1(double) + * } + */ + public static FunctionDescriptor y1$descriptor() { + return y1.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double y1(double) + * } + */ + public static MethodHandle y1$handle() { + return y1.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double y1(double) + * } + */ + public static MemorySegment y1$address() { + return y1.ADDR; + } + + /** + * {@snippet lang=c : + * extern double y1(double) + * } + */ + public static double y1(double x0) { + var mh$ = y1.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("y1", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __y1 { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__y1"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __y1(double) + * } + */ + public static FunctionDescriptor __y1$descriptor() { + return __y1.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __y1(double) + * } + */ + public static MethodHandle __y1$handle() { + return __y1.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __y1(double) + * } + */ + public static MemorySegment __y1$address() { + return __y1.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __y1(double) + * } + */ + public static double __y1(double x0) { + var mh$ = __y1.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__y1", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class yn { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("yn"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double yn(int, double) + * } + */ + public static FunctionDescriptor yn$descriptor() { + return yn.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double yn(int, double) + * } + */ + public static MethodHandle yn$handle() { + return yn.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double yn(int, double) + * } + */ + public static MemorySegment yn$address() { + return yn.ADDR; + } + + /** + * {@snippet lang=c : + * extern double yn(int, double) + * } + */ + public static double yn(int x0, double x1) { + var mh$ = yn.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("yn", x0, x1); + } + return (double)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __yn { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__yn"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __yn(int, double) + * } + */ + public static FunctionDescriptor __yn$descriptor() { + return __yn.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __yn(int, double) + * } + */ + public static MethodHandle __yn$handle() { + return __yn.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __yn(int, double) + * } + */ + public static MemorySegment __yn$address() { + return __yn.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __yn(int, double) + * } + */ + public static double __yn(int x0, double x1) { + var mh$ = __yn.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__yn", x0, x1); + } + return (double)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class erf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("erf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double erf(double) + * } + */ + public static FunctionDescriptor erf$descriptor() { + return erf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double erf(double) + * } + */ + public static MethodHandle erf$handle() { + return erf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double erf(double) + * } + */ + public static MemorySegment erf$address() { + return erf.ADDR; + } + + /** + * {@snippet lang=c : + * extern double erf(double) + * } + */ + public static double erf(double x0) { + var mh$ = erf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("erf", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __erf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__erf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __erf(double) + * } + */ + public static FunctionDescriptor __erf$descriptor() { + return __erf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __erf(double) + * } + */ + public static MethodHandle __erf$handle() { + return __erf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __erf(double) + * } + */ + public static MemorySegment __erf$address() { + return __erf.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __erf(double) + * } + */ + public static double __erf(double x0) { + var mh$ = __erf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__erf", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class erfc { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("erfc"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double erfc(double) + * } + */ + public static FunctionDescriptor erfc$descriptor() { + return erfc.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double erfc(double) + * } + */ + public static MethodHandle erfc$handle() { + return erfc.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double erfc(double) + * } + */ + public static MemorySegment erfc$address() { + return erfc.ADDR; + } + + /** + * {@snippet lang=c : + * extern double erfc(double) + * } + */ + public static double erfc(double x0) { + var mh$ = erfc.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("erfc", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __erfc { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__erfc"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __erfc(double) + * } + */ + public static FunctionDescriptor __erfc$descriptor() { + return __erfc.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __erfc(double) + * } + */ + public static MethodHandle __erfc$handle() { + return __erfc.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __erfc(double) + * } + */ + public static MemorySegment __erfc$address() { + return __erfc.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __erfc(double) + * } + */ + public static double __erfc(double x0) { + var mh$ = __erfc.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__erfc", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class lgamma { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("lgamma"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double lgamma(double) + * } + */ + public static FunctionDescriptor lgamma$descriptor() { + return lgamma.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double lgamma(double) + * } + */ + public static MethodHandle lgamma$handle() { + return lgamma.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double lgamma(double) + * } + */ + public static MemorySegment lgamma$address() { + return lgamma.ADDR; + } + + /** + * {@snippet lang=c : + * extern double lgamma(double) + * } + */ + public static double lgamma(double x0) { + var mh$ = lgamma.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("lgamma", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __lgamma { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__lgamma"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __lgamma(double) + * } + */ + public static FunctionDescriptor __lgamma$descriptor() { + return __lgamma.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __lgamma(double) + * } + */ + public static MethodHandle __lgamma$handle() { + return __lgamma.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __lgamma(double) + * } + */ + public static MemorySegment __lgamma$address() { + return __lgamma.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __lgamma(double) + * } + */ + public static double __lgamma(double x0) { + var mh$ = __lgamma.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__lgamma", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class tgamma { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("tgamma"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double tgamma(double) + * } + */ + public static FunctionDescriptor tgamma$descriptor() { + return tgamma.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double tgamma(double) + * } + */ + public static MethodHandle tgamma$handle() { + return tgamma.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double tgamma(double) + * } + */ + public static MemorySegment tgamma$address() { + return tgamma.ADDR; + } + + /** + * {@snippet lang=c : + * extern double tgamma(double) + * } + */ + public static double tgamma(double x0) { + var mh$ = tgamma.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("tgamma", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __tgamma { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__tgamma"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __tgamma(double) + * } + */ + public static FunctionDescriptor __tgamma$descriptor() { + return __tgamma.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __tgamma(double) + * } + */ + public static MethodHandle __tgamma$handle() { + return __tgamma.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __tgamma(double) + * } + */ + public static MemorySegment __tgamma$address() { + return __tgamma.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __tgamma(double) + * } + */ + public static double __tgamma(double x0) { + var mh$ = __tgamma.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__tgamma", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class gamma { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("gamma"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double gamma(double) + * } + */ + public static FunctionDescriptor gamma$descriptor() { + return gamma.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double gamma(double) + * } + */ + public static MethodHandle gamma$handle() { + return gamma.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double gamma(double) + * } + */ + public static MemorySegment gamma$address() { + return gamma.ADDR; + } + + /** + * {@snippet lang=c : + * extern double gamma(double) + * } + */ + public static double gamma(double x0) { + var mh$ = gamma.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("gamma", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __gamma { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__gamma"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __gamma(double) + * } + */ + public static FunctionDescriptor __gamma$descriptor() { + return __gamma.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __gamma(double) + * } + */ + public static MethodHandle __gamma$handle() { + return __gamma.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __gamma(double) + * } + */ + public static MemorySegment __gamma$address() { + return __gamma.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __gamma(double) + * } + */ + public static double __gamma(double x0) { + var mh$ = __gamma.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__gamma", x0); + } + return (double)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class lgamma_r { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("lgamma_r"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double lgamma_r(double, int *__signgamp) + * } + */ + public static FunctionDescriptor lgamma_r$descriptor() { + return lgamma_r.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double lgamma_r(double, int *__signgamp) + * } + */ + public static MethodHandle lgamma_r$handle() { + return lgamma_r.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double lgamma_r(double, int *__signgamp) + * } + */ + public static MemorySegment lgamma_r$address() { + return lgamma_r.ADDR; + } + + /** + * {@snippet lang=c : + * extern double lgamma_r(double, int *__signgamp) + * } + */ + public static double lgamma_r(double x0, MemorySegment __signgamp) { + var mh$ = lgamma_r.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("lgamma_r", x0, __signgamp); + } + return (double)mh$.invokeExact(x0, __signgamp); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __lgamma_r { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__lgamma_r"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __lgamma_r(double, int *__signgamp) + * } + */ + public static FunctionDescriptor __lgamma_r$descriptor() { + return __lgamma_r.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __lgamma_r(double, int *__signgamp) + * } + */ + public static MethodHandle __lgamma_r$handle() { + return __lgamma_r.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __lgamma_r(double, int *__signgamp) + * } + */ + public static MemorySegment __lgamma_r$address() { + return __lgamma_r.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __lgamma_r(double, int *__signgamp) + * } + */ + public static double __lgamma_r(double x0, MemorySegment __signgamp) { + var mh$ = __lgamma_r.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__lgamma_r", x0, __signgamp); + } + return (double)mh$.invokeExact(x0, __signgamp); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class rint { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("rint"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double rint(double __x) + * } + */ + public static FunctionDescriptor rint$descriptor() { + return rint.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double rint(double __x) + * } + */ + public static MethodHandle rint$handle() { + return rint.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double rint(double __x) + * } + */ + public static MemorySegment rint$address() { + return rint.ADDR; + } + + /** + * {@snippet lang=c : + * extern double rint(double __x) + * } + */ + public static double rint(double __x) { + var mh$ = rint.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("rint", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __rint { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__rint"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __rint(double __x) + * } + */ + public static FunctionDescriptor __rint$descriptor() { + return __rint.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __rint(double __x) + * } + */ + public static MethodHandle __rint$handle() { + return __rint.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __rint(double __x) + * } + */ + public static MemorySegment __rint$address() { + return __rint.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __rint(double __x) + * } + */ + public static double __rint(double __x) { + var mh$ = __rint.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__rint", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class nextafter { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("nextafter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double nextafter(double __x, double __y) + * } + */ + public static FunctionDescriptor nextafter$descriptor() { + return nextafter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double nextafter(double __x, double __y) + * } + */ + public static MethodHandle nextafter$handle() { + return nextafter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double nextafter(double __x, double __y) + * } + */ + public static MemorySegment nextafter$address() { + return nextafter.ADDR; + } + + /** + * {@snippet lang=c : + * extern double nextafter(double __x, double __y) + * } + */ + public static double nextafter(double __x, double __y) { + var mh$ = nextafter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("nextafter", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __nextafter { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__nextafter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __nextafter(double __x, double __y) + * } + */ + public static FunctionDescriptor __nextafter$descriptor() { + return __nextafter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __nextafter(double __x, double __y) + * } + */ + public static MethodHandle __nextafter$handle() { + return __nextafter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __nextafter(double __x, double __y) + * } + */ + public static MemorySegment __nextafter$address() { + return __nextafter.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __nextafter(double __x, double __y) + * } + */ + public static double __nextafter(double __x, double __y) { + var mh$ = __nextafter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__nextafter", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class remainder { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("remainder"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double remainder(double __x, double __y) + * } + */ + public static FunctionDescriptor remainder$descriptor() { + return remainder.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double remainder(double __x, double __y) + * } + */ + public static MethodHandle remainder$handle() { + return remainder.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double remainder(double __x, double __y) + * } + */ + public static MemorySegment remainder$address() { + return remainder.ADDR; + } + + /** + * {@snippet lang=c : + * extern double remainder(double __x, double __y) + * } + */ + public static double remainder(double __x, double __y) { + var mh$ = remainder.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("remainder", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __remainder { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__remainder"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __remainder(double __x, double __y) + * } + */ + public static FunctionDescriptor __remainder$descriptor() { + return __remainder.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __remainder(double __x, double __y) + * } + */ + public static MethodHandle __remainder$handle() { + return __remainder.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __remainder(double __x, double __y) + * } + */ + public static MemorySegment __remainder$address() { + return __remainder.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __remainder(double __x, double __y) + * } + */ + public static double __remainder(double __x, double __y) { + var mh$ = __remainder.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__remainder", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class scalbn { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_INT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("scalbn"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double scalbn(double __x, int __n) + * } + */ + public static FunctionDescriptor scalbn$descriptor() { + return scalbn.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double scalbn(double __x, int __n) + * } + */ + public static MethodHandle scalbn$handle() { + return scalbn.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double scalbn(double __x, int __n) + * } + */ + public static MemorySegment scalbn$address() { + return scalbn.ADDR; + } + + /** + * {@snippet lang=c : + * extern double scalbn(double __x, int __n) + * } + */ + public static double scalbn(double __x, int __n) { + var mh$ = scalbn.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("scalbn", __x, __n); + } + return (double)mh$.invokeExact(__x, __n); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __scalbn { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_INT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__scalbn"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __scalbn(double __x, int __n) + * } + */ + public static FunctionDescriptor __scalbn$descriptor() { + return __scalbn.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __scalbn(double __x, int __n) + * } + */ + public static MethodHandle __scalbn$handle() { + return __scalbn.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __scalbn(double __x, int __n) + * } + */ + public static MemorySegment __scalbn$address() { + return __scalbn.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __scalbn(double __x, int __n) + * } + */ + public static double __scalbn(double __x, int __n) { + var mh$ = __scalbn.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__scalbn", __x, __n); + } + return (double)mh$.invokeExact(__x, __n); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ilogb { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("ilogb"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int ilogb(double __x) + * } + */ + public static FunctionDescriptor ilogb$descriptor() { + return ilogb.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int ilogb(double __x) + * } + */ + public static MethodHandle ilogb$handle() { + return ilogb.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int ilogb(double __x) + * } + */ + public static MemorySegment ilogb$address() { + return ilogb.ADDR; + } + + /** + * {@snippet lang=c : + * extern int ilogb(double __x) + * } + */ + public static int ilogb(double __x) { + var mh$ = ilogb.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ilogb", __x); + } + return (int)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __ilogb { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__ilogb"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __ilogb(double __x) + * } + */ + public static FunctionDescriptor __ilogb$descriptor() { + return __ilogb.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __ilogb(double __x) + * } + */ + public static MethodHandle __ilogb$handle() { + return __ilogb.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __ilogb(double __x) + * } + */ + public static MemorySegment __ilogb$address() { + return __ilogb.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __ilogb(double __x) + * } + */ + public static int __ilogb(double __x) { + var mh$ = __ilogb.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__ilogb", __x); + } + return (int)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class scalbln { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_LONG + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("scalbln"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double scalbln(double __x, long __n) + * } + */ + public static FunctionDescriptor scalbln$descriptor() { + return scalbln.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double scalbln(double __x, long __n) + * } + */ + public static MethodHandle scalbln$handle() { + return scalbln.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double scalbln(double __x, long __n) + * } + */ + public static MemorySegment scalbln$address() { + return scalbln.ADDR; + } + + /** + * {@snippet lang=c : + * extern double scalbln(double __x, long __n) + * } + */ + public static double scalbln(double __x, long __n) { + var mh$ = scalbln.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("scalbln", __x, __n); + } + return (double)mh$.invokeExact(__x, __n); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __scalbln { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_LONG + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__scalbln"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __scalbln(double __x, long __n) + * } + */ + public static FunctionDescriptor __scalbln$descriptor() { + return __scalbln.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __scalbln(double __x, long __n) + * } + */ + public static MethodHandle __scalbln$handle() { + return __scalbln.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __scalbln(double __x, long __n) + * } + */ + public static MemorySegment __scalbln$address() { + return __scalbln.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __scalbln(double __x, long __n) + * } + */ + public static double __scalbln(double __x, long __n) { + var mh$ = __scalbln.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__scalbln", __x, __n); + } + return (double)mh$.invokeExact(__x, __n); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class nearbyint { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("nearbyint"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double nearbyint(double __x) + * } + */ + public static FunctionDescriptor nearbyint$descriptor() { + return nearbyint.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double nearbyint(double __x) + * } + */ + public static MethodHandle nearbyint$handle() { + return nearbyint.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double nearbyint(double __x) + * } + */ + public static MemorySegment nearbyint$address() { + return nearbyint.ADDR; + } + + /** + * {@snippet lang=c : + * extern double nearbyint(double __x) + * } + */ + public static double nearbyint(double __x) { + var mh$ = nearbyint.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("nearbyint", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __nearbyint { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__nearbyint"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __nearbyint(double __x) + * } + */ + public static FunctionDescriptor __nearbyint$descriptor() { + return __nearbyint.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __nearbyint(double __x) + * } + */ + public static MethodHandle __nearbyint$handle() { + return __nearbyint.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __nearbyint(double __x) + * } + */ + public static MemorySegment __nearbyint$address() { + return __nearbyint.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __nearbyint(double __x) + * } + */ + public static double __nearbyint(double __x) { + var mh$ = __nearbyint.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__nearbyint", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class round { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("round"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double round(double __x) + * } + */ + public static FunctionDescriptor round$descriptor() { + return round.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double round(double __x) + * } + */ + public static MethodHandle round$handle() { + return round.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double round(double __x) + * } + */ + public static MemorySegment round$address() { + return round.ADDR; + } + + /** + * {@snippet lang=c : + * extern double round(double __x) + * } + */ + public static double round(double __x) { + var mh$ = round.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("round", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __round { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__round"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __round(double __x) + * } + */ + public static FunctionDescriptor __round$descriptor() { + return __round.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __round(double __x) + * } + */ + public static MethodHandle __round$handle() { + return __round.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __round(double __x) + * } + */ + public static MemorySegment __round$address() { + return __round.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __round(double __x) + * } + */ + public static double __round(double __x) { + var mh$ = __round.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__round", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class trunc { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("trunc"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double trunc(double __x) + * } + */ + public static FunctionDescriptor trunc$descriptor() { + return trunc.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double trunc(double __x) + * } + */ + public static MethodHandle trunc$handle() { + return trunc.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double trunc(double __x) + * } + */ + public static MemorySegment trunc$address() { + return trunc.ADDR; + } + + /** + * {@snippet lang=c : + * extern double trunc(double __x) + * } + */ + public static double trunc(double __x) { + var mh$ = trunc.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("trunc", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __trunc { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__trunc"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __trunc(double __x) + * } + */ + public static FunctionDescriptor __trunc$descriptor() { + return __trunc.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __trunc(double __x) + * } + */ + public static MethodHandle __trunc$handle() { + return __trunc.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __trunc(double __x) + * } + */ + public static MemorySegment __trunc$address() { + return __trunc.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __trunc(double __x) + * } + */ + public static double __trunc(double __x) { + var mh$ = __trunc.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__trunc", __x); + } + return (double)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class remquo { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("remquo"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double remquo(double __x, double __y, int *__quo) + * } + */ + public static FunctionDescriptor remquo$descriptor() { + return remquo.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double remquo(double __x, double __y, int *__quo) + * } + */ + public static MethodHandle remquo$handle() { + return remquo.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double remquo(double __x, double __y, int *__quo) + * } + */ + public static MemorySegment remquo$address() { + return remquo.ADDR; + } + + /** + * {@snippet lang=c : + * extern double remquo(double __x, double __y, int *__quo) + * } + */ + public static double remquo(double __x, double __y, MemorySegment __quo) { + var mh$ = remquo.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("remquo", __x, __y, __quo); + } + return (double)mh$.invokeExact(__x, __y, __quo); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __remquo { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__remquo"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __remquo(double __x, double __y, int *__quo) + * } + */ + public static FunctionDescriptor __remquo$descriptor() { + return __remquo.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __remquo(double __x, double __y, int *__quo) + * } + */ + public static MethodHandle __remquo$handle() { + return __remquo.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __remquo(double __x, double __y, int *__quo) + * } + */ + public static MemorySegment __remquo$address() { + return __remquo.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __remquo(double __x, double __y, int *__quo) + * } + */ + public static double __remquo(double __x, double __y, MemorySegment __quo) { + var mh$ = __remquo.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__remquo", __x, __y, __quo); + } + return (double)mh$.invokeExact(__x, __y, __quo); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class lrint { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("lrint"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long lrint(double __x) + * } + */ + public static FunctionDescriptor lrint$descriptor() { + return lrint.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long lrint(double __x) + * } + */ + public static MethodHandle lrint$handle() { + return lrint.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long lrint(double __x) + * } + */ + public static MemorySegment lrint$address() { + return lrint.ADDR; + } + + /** + * {@snippet lang=c : + * extern long lrint(double __x) + * } + */ + public static long lrint(double __x) { + var mh$ = lrint.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("lrint", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __lrint { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__lrint"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long __lrint(double __x) + * } + */ + public static FunctionDescriptor __lrint$descriptor() { + return __lrint.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long __lrint(double __x) + * } + */ + public static MethodHandle __lrint$handle() { + return __lrint.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long __lrint(double __x) + * } + */ + public static MemorySegment __lrint$address() { + return __lrint.ADDR; + } + + /** + * {@snippet lang=c : + * extern long __lrint(double __x) + * } + */ + public static long __lrint(double __x) { + var mh$ = __lrint.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__lrint", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class llrint { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG_LONG, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("llrint"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long long llrint(double __x) + * } + */ + public static FunctionDescriptor llrint$descriptor() { + return llrint.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long long llrint(double __x) + * } + */ + public static MethodHandle llrint$handle() { + return llrint.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long long llrint(double __x) + * } + */ + public static MemorySegment llrint$address() { + return llrint.ADDR; + } + + /** + * {@snippet lang=c : + * extern long long llrint(double __x) + * } + */ + public static long llrint(double __x) { + var mh$ = llrint.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("llrint", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __llrint { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG_LONG, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__llrint"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long long __llrint(double __x) + * } + */ + public static FunctionDescriptor __llrint$descriptor() { + return __llrint.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long long __llrint(double __x) + * } + */ + public static MethodHandle __llrint$handle() { + return __llrint.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long long __llrint(double __x) + * } + */ + public static MemorySegment __llrint$address() { + return __llrint.ADDR; + } + + /** + * {@snippet lang=c : + * extern long long __llrint(double __x) + * } + */ + public static long __llrint(double __x) { + var mh$ = __llrint.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__llrint", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class lround { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("lround"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long lround(double __x) + * } + */ + public static FunctionDescriptor lround$descriptor() { + return lround.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long lround(double __x) + * } + */ + public static MethodHandle lround$handle() { + return lround.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long lround(double __x) + * } + */ + public static MemorySegment lround$address() { + return lround.ADDR; + } + + /** + * {@snippet lang=c : + * extern long lround(double __x) + * } + */ + public static long lround(double __x) { + var mh$ = lround.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("lround", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __lround { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__lround"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long __lround(double __x) + * } + */ + public static FunctionDescriptor __lround$descriptor() { + return __lround.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long __lround(double __x) + * } + */ + public static MethodHandle __lround$handle() { + return __lround.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long __lround(double __x) + * } + */ + public static MemorySegment __lround$address() { + return __lround.ADDR; + } + + /** + * {@snippet lang=c : + * extern long __lround(double __x) + * } + */ + public static long __lround(double __x) { + var mh$ = __lround.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__lround", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class llround { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG_LONG, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("llround"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long long llround(double __x) + * } + */ + public static FunctionDescriptor llround$descriptor() { + return llround.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long long llround(double __x) + * } + */ + public static MethodHandle llround$handle() { + return llround.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long long llround(double __x) + * } + */ + public static MemorySegment llround$address() { + return llround.ADDR; + } + + /** + * {@snippet lang=c : + * extern long long llround(double __x) + * } + */ + public static long llround(double __x) { + var mh$ = llround.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("llround", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __llround { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG_LONG, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__llround"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long long __llround(double __x) + * } + */ + public static FunctionDescriptor __llround$descriptor() { + return __llround.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long long __llround(double __x) + * } + */ + public static MethodHandle __llround$handle() { + return __llround.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long long __llround(double __x) + * } + */ + public static MemorySegment __llround$address() { + return __llround.ADDR; + } + + /** + * {@snippet lang=c : + * extern long long __llround(double __x) + * } + */ + public static long __llround(double __x) { + var mh$ = __llround.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__llround", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class fdim { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("fdim"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double fdim(double __x, double __y) + * } + */ + public static FunctionDescriptor fdim$descriptor() { + return fdim.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double fdim(double __x, double __y) + * } + */ + public static MethodHandle fdim$handle() { + return fdim.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double fdim(double __x, double __y) + * } + */ + public static MemorySegment fdim$address() { + return fdim.ADDR; + } + + /** + * {@snippet lang=c : + * extern double fdim(double __x, double __y) + * } + */ + public static double fdim(double __x, double __y) { + var mh$ = fdim.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("fdim", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __fdim { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__fdim"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __fdim(double __x, double __y) + * } + */ + public static FunctionDescriptor __fdim$descriptor() { + return __fdim.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __fdim(double __x, double __y) + * } + */ + public static MethodHandle __fdim$handle() { + return __fdim.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __fdim(double __x, double __y) + * } + */ + public static MemorySegment __fdim$address() { + return __fdim.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __fdim(double __x, double __y) + * } + */ + public static double __fdim(double __x, double __y) { + var mh$ = __fdim.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__fdim", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class fmax { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("fmax"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double fmax(double __x, double __y) + * } + */ + public static FunctionDescriptor fmax$descriptor() { + return fmax.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double fmax(double __x, double __y) + * } + */ + public static MethodHandle fmax$handle() { + return fmax.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double fmax(double __x, double __y) + * } + */ + public static MemorySegment fmax$address() { + return fmax.ADDR; + } + + /** + * {@snippet lang=c : + * extern double fmax(double __x, double __y) + * } + */ + public static double fmax(double __x, double __y) { + var mh$ = fmax.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("fmax", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __fmax { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__fmax"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __fmax(double __x, double __y) + * } + */ + public static FunctionDescriptor __fmax$descriptor() { + return __fmax.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __fmax(double __x, double __y) + * } + */ + public static MethodHandle __fmax$handle() { + return __fmax.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __fmax(double __x, double __y) + * } + */ + public static MemorySegment __fmax$address() { + return __fmax.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __fmax(double __x, double __y) + * } + */ + public static double __fmax(double __x, double __y) { + var mh$ = __fmax.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__fmax", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class fmin { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("fmin"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double fmin(double __x, double __y) + * } + */ + public static FunctionDescriptor fmin$descriptor() { + return fmin.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double fmin(double __x, double __y) + * } + */ + public static MethodHandle fmin$handle() { + return fmin.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double fmin(double __x, double __y) + * } + */ + public static MemorySegment fmin$address() { + return fmin.ADDR; + } + + /** + * {@snippet lang=c : + * extern double fmin(double __x, double __y) + * } + */ + public static double fmin(double __x, double __y) { + var mh$ = fmin.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("fmin", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __fmin { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__fmin"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __fmin(double __x, double __y) + * } + */ + public static FunctionDescriptor __fmin$descriptor() { + return __fmin.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __fmin(double __x, double __y) + * } + */ + public static MethodHandle __fmin$handle() { + return __fmin.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __fmin(double __x, double __y) + * } + */ + public static MemorySegment __fmin$address() { + return __fmin.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __fmin(double __x, double __y) + * } + */ + public static double __fmin(double __x, double __y) { + var mh$ = __fmin.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__fmin", __x, __y); + } + return (double)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class fma { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("fma"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double fma(double __x, double __y, double __z) + * } + */ + public static FunctionDescriptor fma$descriptor() { + return fma.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double fma(double __x, double __y, double __z) + * } + */ + public static MethodHandle fma$handle() { + return fma.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double fma(double __x, double __y, double __z) + * } + */ + public static MemorySegment fma$address() { + return fma.ADDR; + } + + /** + * {@snippet lang=c : + * extern double fma(double __x, double __y, double __z) + * } + */ + public static double fma(double __x, double __y, double __z) { + var mh$ = fma.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("fma", __x, __y, __z); + } + return (double)mh$.invokeExact(__x, __y, __z); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __fma { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__fma"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __fma(double __x, double __y, double __z) + * } + */ + public static FunctionDescriptor __fma$descriptor() { + return __fma.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __fma(double __x, double __y, double __z) + * } + */ + public static MethodHandle __fma$handle() { + return __fma.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __fma(double __x, double __y, double __z) + * } + */ + public static MemorySegment __fma$address() { + return __fma.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __fma(double __x, double __y, double __z) + * } + */ + public static double __fma(double __x, double __y, double __z) { + var mh$ = __fma.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__fma", __x, __y, __z); + } + return (double)mh$.invokeExact(__x, __y, __z); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class scalb { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("scalb"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double scalb(double __x, double __n) + * } + */ + public static FunctionDescriptor scalb$descriptor() { + return scalb.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double scalb(double __x, double __n) + * } + */ + public static MethodHandle scalb$handle() { + return scalb.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double scalb(double __x, double __n) + * } + */ + public static MemorySegment scalb$address() { + return scalb.ADDR; + } + + /** + * {@snippet lang=c : + * extern double scalb(double __x, double __n) + * } + */ + public static double scalb(double __x, double __n) { + var mh$ = scalb.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("scalb", __x, __n); + } + return (double)mh$.invokeExact(__x, __n); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __scalb { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__scalb"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern double __scalb(double __x, double __n) + * } + */ + public static FunctionDescriptor __scalb$descriptor() { + return __scalb.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern double __scalb(double __x, double __n) + * } + */ + public static MethodHandle __scalb$handle() { + return __scalb.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern double __scalb(double __x, double __n) + * } + */ + public static MemorySegment __scalb$address() { + return __scalb.ADDR; + } + + /** + * {@snippet lang=c : + * extern double __scalb(double __x, double __n) + * } + */ + public static double __scalb(double __x, double __n) { + var mh$ = __scalb.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__scalb", __x, __n); + } + return (double)mh$.invokeExact(__x, __n); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __fpclassifyf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__fpclassifyf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __fpclassifyf(float __value) + * } + */ + public static FunctionDescriptor __fpclassifyf$descriptor() { + return __fpclassifyf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __fpclassifyf(float __value) + * } + */ + public static MethodHandle __fpclassifyf$handle() { + return __fpclassifyf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __fpclassifyf(float __value) + * } + */ + public static MemorySegment __fpclassifyf$address() { + return __fpclassifyf.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __fpclassifyf(float __value) + * } + */ + public static int __fpclassifyf(float __value) { + var mh$ = __fpclassifyf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__fpclassifyf", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __signbitf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__signbitf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __signbitf(float __value) + * } + */ + public static FunctionDescriptor __signbitf$descriptor() { + return __signbitf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __signbitf(float __value) + * } + */ + public static MethodHandle __signbitf$handle() { + return __signbitf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __signbitf(float __value) + * } + */ + public static MemorySegment __signbitf$address() { + return __signbitf.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __signbitf(float __value) + * } + */ + public static int __signbitf(float __value) { + var mh$ = __signbitf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__signbitf", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __isinff { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__isinff"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __isinff(float __value) + * } + */ + public static FunctionDescriptor __isinff$descriptor() { + return __isinff.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __isinff(float __value) + * } + */ + public static MethodHandle __isinff$handle() { + return __isinff.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __isinff(float __value) + * } + */ + public static MemorySegment __isinff$address() { + return __isinff.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __isinff(float __value) + * } + */ + public static int __isinff(float __value) { + var mh$ = __isinff.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__isinff", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __finitef { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__finitef"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __finitef(float __value) + * } + */ + public static FunctionDescriptor __finitef$descriptor() { + return __finitef.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __finitef(float __value) + * } + */ + public static MethodHandle __finitef$handle() { + return __finitef.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __finitef(float __value) + * } + */ + public static MemorySegment __finitef$address() { + return __finitef.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __finitef(float __value) + * } + */ + public static int __finitef(float __value) { + var mh$ = __finitef.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__finitef", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __isnanf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__isnanf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __isnanf(float __value) + * } + */ + public static FunctionDescriptor __isnanf$descriptor() { + return __isnanf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __isnanf(float __value) + * } + */ + public static MethodHandle __isnanf$handle() { + return __isnanf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __isnanf(float __value) + * } + */ + public static MemorySegment __isnanf$address() { + return __isnanf.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __isnanf(float __value) + * } + */ + public static int __isnanf(float __value) { + var mh$ = __isnanf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__isnanf", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __iseqsigf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__iseqsigf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __iseqsigf(float __x, float __y) + * } + */ + public static FunctionDescriptor __iseqsigf$descriptor() { + return __iseqsigf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __iseqsigf(float __x, float __y) + * } + */ + public static MethodHandle __iseqsigf$handle() { + return __iseqsigf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __iseqsigf(float __x, float __y) + * } + */ + public static MemorySegment __iseqsigf$address() { + return __iseqsigf.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __iseqsigf(float __x, float __y) + * } + */ + public static int __iseqsigf(float __x, float __y) { + var mh$ = __iseqsigf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__iseqsigf", __x, __y); + } + return (int)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __issignalingf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__issignalingf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __issignalingf(float __value) + * } + */ + public static FunctionDescriptor __issignalingf$descriptor() { + return __issignalingf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __issignalingf(float __value) + * } + */ + public static MethodHandle __issignalingf$handle() { + return __issignalingf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __issignalingf(float __value) + * } + */ + public static MemorySegment __issignalingf$address() { + return __issignalingf.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __issignalingf(float __value) + * } + */ + public static int __issignalingf(float __value) { + var mh$ = __issignalingf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__issignalingf", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class acosf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("acosf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float acosf(float __x) + * } + */ + public static FunctionDescriptor acosf$descriptor() { + return acosf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float acosf(float __x) + * } + */ + public static MethodHandle acosf$handle() { + return acosf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float acosf(float __x) + * } + */ + public static MemorySegment acosf$address() { + return acosf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float acosf(float __x) + * } + */ + public static float acosf(float __x) { + var mh$ = acosf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("acosf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __acosf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__acosf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __acosf(float __x) + * } + */ + public static FunctionDescriptor __acosf$descriptor() { + return __acosf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __acosf(float __x) + * } + */ + public static MethodHandle __acosf$handle() { + return __acosf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __acosf(float __x) + * } + */ + public static MemorySegment __acosf$address() { + return __acosf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __acosf(float __x) + * } + */ + public static float __acosf(float __x) { + var mh$ = __acosf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__acosf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class asinf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("asinf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float asinf(float __x) + * } + */ + public static FunctionDescriptor asinf$descriptor() { + return asinf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float asinf(float __x) + * } + */ + public static MethodHandle asinf$handle() { + return asinf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float asinf(float __x) + * } + */ + public static MemorySegment asinf$address() { + return asinf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float asinf(float __x) + * } + */ + public static float asinf(float __x) { + var mh$ = asinf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("asinf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __asinf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__asinf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __asinf(float __x) + * } + */ + public static FunctionDescriptor __asinf$descriptor() { + return __asinf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __asinf(float __x) + * } + */ + public static MethodHandle __asinf$handle() { + return __asinf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __asinf(float __x) + * } + */ + public static MemorySegment __asinf$address() { + return __asinf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __asinf(float __x) + * } + */ + public static float __asinf(float __x) { + var mh$ = __asinf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__asinf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class atanf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("atanf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float atanf(float __x) + * } + */ + public static FunctionDescriptor atanf$descriptor() { + return atanf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float atanf(float __x) + * } + */ + public static MethodHandle atanf$handle() { + return atanf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float atanf(float __x) + * } + */ + public static MemorySegment atanf$address() { + return atanf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float atanf(float __x) + * } + */ + public static float atanf(float __x) { + var mh$ = atanf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("atanf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __atanf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__atanf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __atanf(float __x) + * } + */ + public static FunctionDescriptor __atanf$descriptor() { + return __atanf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __atanf(float __x) + * } + */ + public static MethodHandle __atanf$handle() { + return __atanf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __atanf(float __x) + * } + */ + public static MemorySegment __atanf$address() { + return __atanf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __atanf(float __x) + * } + */ + public static float __atanf(float __x) { + var mh$ = __atanf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__atanf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class atan2f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("atan2f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float atan2f(float __y, float __x) + * } + */ + public static FunctionDescriptor atan2f$descriptor() { + return atan2f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float atan2f(float __y, float __x) + * } + */ + public static MethodHandle atan2f$handle() { + return atan2f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float atan2f(float __y, float __x) + * } + */ + public static MemorySegment atan2f$address() { + return atan2f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float atan2f(float __y, float __x) + * } + */ + public static float atan2f(float __y, float __x) { + var mh$ = atan2f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("atan2f", __y, __x); + } + return (float)mh$.invokeExact(__y, __x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __atan2f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__atan2f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __atan2f(float __y, float __x) + * } + */ + public static FunctionDescriptor __atan2f$descriptor() { + return __atan2f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __atan2f(float __y, float __x) + * } + */ + public static MethodHandle __atan2f$handle() { + return __atan2f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __atan2f(float __y, float __x) + * } + */ + public static MemorySegment __atan2f$address() { + return __atan2f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __atan2f(float __y, float __x) + * } + */ + public static float __atan2f(float __y, float __x) { + var mh$ = __atan2f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__atan2f", __y, __x); + } + return (float)mh$.invokeExact(__y, __x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cosf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cosf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float cosf(float __x) + * } + */ + public static FunctionDescriptor cosf$descriptor() { + return cosf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float cosf(float __x) + * } + */ + public static MethodHandle cosf$handle() { + return cosf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float cosf(float __x) + * } + */ + public static MemorySegment cosf$address() { + return cosf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float cosf(float __x) + * } + */ + public static float cosf(float __x) { + var mh$ = cosf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cosf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __cosf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__cosf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __cosf(float __x) + * } + */ + public static FunctionDescriptor __cosf$descriptor() { + return __cosf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __cosf(float __x) + * } + */ + public static MethodHandle __cosf$handle() { + return __cosf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __cosf(float __x) + * } + */ + public static MemorySegment __cosf$address() { + return __cosf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __cosf(float __x) + * } + */ + public static float __cosf(float __x) { + var mh$ = __cosf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__cosf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class sinf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("sinf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float sinf(float __x) + * } + */ + public static FunctionDescriptor sinf$descriptor() { + return sinf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float sinf(float __x) + * } + */ + public static MethodHandle sinf$handle() { + return sinf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float sinf(float __x) + * } + */ + public static MemorySegment sinf$address() { + return sinf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float sinf(float __x) + * } + */ + public static float sinf(float __x) { + var mh$ = sinf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("sinf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __sinf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__sinf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __sinf(float __x) + * } + */ + public static FunctionDescriptor __sinf$descriptor() { + return __sinf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __sinf(float __x) + * } + */ + public static MethodHandle __sinf$handle() { + return __sinf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __sinf(float __x) + * } + */ + public static MemorySegment __sinf$address() { + return __sinf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __sinf(float __x) + * } + */ + public static float __sinf(float __x) { + var mh$ = __sinf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__sinf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class tanf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("tanf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float tanf(float __x) + * } + */ + public static FunctionDescriptor tanf$descriptor() { + return tanf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float tanf(float __x) + * } + */ + public static MethodHandle tanf$handle() { + return tanf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float tanf(float __x) + * } + */ + public static MemorySegment tanf$address() { + return tanf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float tanf(float __x) + * } + */ + public static float tanf(float __x) { + var mh$ = tanf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("tanf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __tanf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__tanf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __tanf(float __x) + * } + */ + public static FunctionDescriptor __tanf$descriptor() { + return __tanf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __tanf(float __x) + * } + */ + public static MethodHandle __tanf$handle() { + return __tanf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __tanf(float __x) + * } + */ + public static MemorySegment __tanf$address() { + return __tanf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __tanf(float __x) + * } + */ + public static float __tanf(float __x) { + var mh$ = __tanf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__tanf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class coshf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("coshf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float coshf(float __x) + * } + */ + public static FunctionDescriptor coshf$descriptor() { + return coshf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float coshf(float __x) + * } + */ + public static MethodHandle coshf$handle() { + return coshf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float coshf(float __x) + * } + */ + public static MemorySegment coshf$address() { + return coshf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float coshf(float __x) + * } + */ + public static float coshf(float __x) { + var mh$ = coshf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("coshf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __coshf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__coshf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __coshf(float __x) + * } + */ + public static FunctionDescriptor __coshf$descriptor() { + return __coshf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __coshf(float __x) + * } + */ + public static MethodHandle __coshf$handle() { + return __coshf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __coshf(float __x) + * } + */ + public static MemorySegment __coshf$address() { + return __coshf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __coshf(float __x) + * } + */ + public static float __coshf(float __x) { + var mh$ = __coshf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__coshf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class sinhf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("sinhf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float sinhf(float __x) + * } + */ + public static FunctionDescriptor sinhf$descriptor() { + return sinhf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float sinhf(float __x) + * } + */ + public static MethodHandle sinhf$handle() { + return sinhf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float sinhf(float __x) + * } + */ + public static MemorySegment sinhf$address() { + return sinhf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float sinhf(float __x) + * } + */ + public static float sinhf(float __x) { + var mh$ = sinhf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("sinhf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __sinhf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__sinhf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __sinhf(float __x) + * } + */ + public static FunctionDescriptor __sinhf$descriptor() { + return __sinhf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __sinhf(float __x) + * } + */ + public static MethodHandle __sinhf$handle() { + return __sinhf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __sinhf(float __x) + * } + */ + public static MemorySegment __sinhf$address() { + return __sinhf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __sinhf(float __x) + * } + */ + public static float __sinhf(float __x) { + var mh$ = __sinhf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__sinhf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class tanhf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("tanhf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float tanhf(float __x) + * } + */ + public static FunctionDescriptor tanhf$descriptor() { + return tanhf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float tanhf(float __x) + * } + */ + public static MethodHandle tanhf$handle() { + return tanhf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float tanhf(float __x) + * } + */ + public static MemorySegment tanhf$address() { + return tanhf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float tanhf(float __x) + * } + */ + public static float tanhf(float __x) { + var mh$ = tanhf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("tanhf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __tanhf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__tanhf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __tanhf(float __x) + * } + */ + public static FunctionDescriptor __tanhf$descriptor() { + return __tanhf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __tanhf(float __x) + * } + */ + public static MethodHandle __tanhf$handle() { + return __tanhf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __tanhf(float __x) + * } + */ + public static MemorySegment __tanhf$address() { + return __tanhf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __tanhf(float __x) + * } + */ + public static float __tanhf(float __x) { + var mh$ = __tanhf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__tanhf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class acoshf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("acoshf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float acoshf(float __x) + * } + */ + public static FunctionDescriptor acoshf$descriptor() { + return acoshf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float acoshf(float __x) + * } + */ + public static MethodHandle acoshf$handle() { + return acoshf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float acoshf(float __x) + * } + */ + public static MemorySegment acoshf$address() { + return acoshf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float acoshf(float __x) + * } + */ + public static float acoshf(float __x) { + var mh$ = acoshf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("acoshf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __acoshf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__acoshf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __acoshf(float __x) + * } + */ + public static FunctionDescriptor __acoshf$descriptor() { + return __acoshf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __acoshf(float __x) + * } + */ + public static MethodHandle __acoshf$handle() { + return __acoshf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __acoshf(float __x) + * } + */ + public static MemorySegment __acoshf$address() { + return __acoshf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __acoshf(float __x) + * } + */ + public static float __acoshf(float __x) { + var mh$ = __acoshf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__acoshf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class asinhf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("asinhf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float asinhf(float __x) + * } + */ + public static FunctionDescriptor asinhf$descriptor() { + return asinhf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float asinhf(float __x) + * } + */ + public static MethodHandle asinhf$handle() { + return asinhf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float asinhf(float __x) + * } + */ + public static MemorySegment asinhf$address() { + return asinhf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float asinhf(float __x) + * } + */ + public static float asinhf(float __x) { + var mh$ = asinhf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("asinhf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __asinhf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__asinhf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __asinhf(float __x) + * } + */ + public static FunctionDescriptor __asinhf$descriptor() { + return __asinhf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __asinhf(float __x) + * } + */ + public static MethodHandle __asinhf$handle() { + return __asinhf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __asinhf(float __x) + * } + */ + public static MemorySegment __asinhf$address() { + return __asinhf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __asinhf(float __x) + * } + */ + public static float __asinhf(float __x) { + var mh$ = __asinhf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__asinhf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class atanhf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("atanhf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float atanhf(float __x) + * } + */ + public static FunctionDescriptor atanhf$descriptor() { + return atanhf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float atanhf(float __x) + * } + */ + public static MethodHandle atanhf$handle() { + return atanhf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float atanhf(float __x) + * } + */ + public static MemorySegment atanhf$address() { + return atanhf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float atanhf(float __x) + * } + */ + public static float atanhf(float __x) { + var mh$ = atanhf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("atanhf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __atanhf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__atanhf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __atanhf(float __x) + * } + */ + public static FunctionDescriptor __atanhf$descriptor() { + return __atanhf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __atanhf(float __x) + * } + */ + public static MethodHandle __atanhf$handle() { + return __atanhf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __atanhf(float __x) + * } + */ + public static MemorySegment __atanhf$address() { + return __atanhf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __atanhf(float __x) + * } + */ + public static float __atanhf(float __x) { + var mh$ = __atanhf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__atanhf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class expf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("expf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float expf(float __x) + * } + */ + public static FunctionDescriptor expf$descriptor() { + return expf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float expf(float __x) + * } + */ + public static MethodHandle expf$handle() { + return expf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float expf(float __x) + * } + */ + public static MemorySegment expf$address() { + return expf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float expf(float __x) + * } + */ + public static float expf(float __x) { + var mh$ = expf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("expf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __expf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__expf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __expf(float __x) + * } + */ + public static FunctionDescriptor __expf$descriptor() { + return __expf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __expf(float __x) + * } + */ + public static MethodHandle __expf$handle() { + return __expf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __expf(float __x) + * } + */ + public static MemorySegment __expf$address() { + return __expf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __expf(float __x) + * } + */ + public static float __expf(float __x) { + var mh$ = __expf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__expf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class frexpf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("frexpf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float frexpf(float __x, int *__exponent) + * } + */ + public static FunctionDescriptor frexpf$descriptor() { + return frexpf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float frexpf(float __x, int *__exponent) + * } + */ + public static MethodHandle frexpf$handle() { + return frexpf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float frexpf(float __x, int *__exponent) + * } + */ + public static MemorySegment frexpf$address() { + return frexpf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float frexpf(float __x, int *__exponent) + * } + */ + public static float frexpf(float __x, MemorySegment __exponent) { + var mh$ = frexpf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("frexpf", __x, __exponent); + } + return (float)mh$.invokeExact(__x, __exponent); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __frexpf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__frexpf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __frexpf(float __x, int *__exponent) + * } + */ + public static FunctionDescriptor __frexpf$descriptor() { + return __frexpf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __frexpf(float __x, int *__exponent) + * } + */ + public static MethodHandle __frexpf$handle() { + return __frexpf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __frexpf(float __x, int *__exponent) + * } + */ + public static MemorySegment __frexpf$address() { + return __frexpf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __frexpf(float __x, int *__exponent) + * } + */ + public static float __frexpf(float __x, MemorySegment __exponent) { + var mh$ = __frexpf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__frexpf", __x, __exponent); + } + return (float)mh$.invokeExact(__x, __exponent); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ldexpf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_INT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("ldexpf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float ldexpf(float __x, int __exponent) + * } + */ + public static FunctionDescriptor ldexpf$descriptor() { + return ldexpf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float ldexpf(float __x, int __exponent) + * } + */ + public static MethodHandle ldexpf$handle() { + return ldexpf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float ldexpf(float __x, int __exponent) + * } + */ + public static MemorySegment ldexpf$address() { + return ldexpf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float ldexpf(float __x, int __exponent) + * } + */ + public static float ldexpf(float __x, int __exponent) { + var mh$ = ldexpf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ldexpf", __x, __exponent); + } + return (float)mh$.invokeExact(__x, __exponent); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __ldexpf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_INT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__ldexpf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __ldexpf(float __x, int __exponent) + * } + */ + public static FunctionDescriptor __ldexpf$descriptor() { + return __ldexpf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __ldexpf(float __x, int __exponent) + * } + */ + public static MethodHandle __ldexpf$handle() { + return __ldexpf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __ldexpf(float __x, int __exponent) + * } + */ + public static MemorySegment __ldexpf$address() { + return __ldexpf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __ldexpf(float __x, int __exponent) + * } + */ + public static float __ldexpf(float __x, int __exponent) { + var mh$ = __ldexpf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__ldexpf", __x, __exponent); + } + return (float)mh$.invokeExact(__x, __exponent); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class logf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("logf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float logf(float __x) + * } + */ + public static FunctionDescriptor logf$descriptor() { + return logf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float logf(float __x) + * } + */ + public static MethodHandle logf$handle() { + return logf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float logf(float __x) + * } + */ + public static MemorySegment logf$address() { + return logf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float logf(float __x) + * } + */ + public static float logf(float __x) { + var mh$ = logf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("logf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __logf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__logf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __logf(float __x) + * } + */ + public static FunctionDescriptor __logf$descriptor() { + return __logf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __logf(float __x) + * } + */ + public static MethodHandle __logf$handle() { + return __logf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __logf(float __x) + * } + */ + public static MemorySegment __logf$address() { + return __logf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __logf(float __x) + * } + */ + public static float __logf(float __x) { + var mh$ = __logf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__logf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class log10f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("log10f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float log10f(float __x) + * } + */ + public static FunctionDescriptor log10f$descriptor() { + return log10f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float log10f(float __x) + * } + */ + public static MethodHandle log10f$handle() { + return log10f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float log10f(float __x) + * } + */ + public static MemorySegment log10f$address() { + return log10f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float log10f(float __x) + * } + */ + public static float log10f(float __x) { + var mh$ = log10f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("log10f", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __log10f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__log10f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __log10f(float __x) + * } + */ + public static FunctionDescriptor __log10f$descriptor() { + return __log10f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __log10f(float __x) + * } + */ + public static MethodHandle __log10f$handle() { + return __log10f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __log10f(float __x) + * } + */ + public static MemorySegment __log10f$address() { + return __log10f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __log10f(float __x) + * } + */ + public static float __log10f(float __x) { + var mh$ = __log10f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__log10f", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class modff { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("modff"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float modff(float __x, float *__iptr) + * } + */ + public static FunctionDescriptor modff$descriptor() { + return modff.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float modff(float __x, float *__iptr) + * } + */ + public static MethodHandle modff$handle() { + return modff.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float modff(float __x, float *__iptr) + * } + */ + public static MemorySegment modff$address() { + return modff.ADDR; + } + + /** + * {@snippet lang=c : + * extern float modff(float __x, float *__iptr) + * } + */ + public static float modff(float __x, MemorySegment __iptr) { + var mh$ = modff.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("modff", __x, __iptr); + } + return (float)mh$.invokeExact(__x, __iptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __modff { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__modff"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __modff(float __x, float *__iptr) + * } + */ + public static FunctionDescriptor __modff$descriptor() { + return __modff.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __modff(float __x, float *__iptr) + * } + */ + public static MethodHandle __modff$handle() { + return __modff.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __modff(float __x, float *__iptr) + * } + */ + public static MemorySegment __modff$address() { + return __modff.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __modff(float __x, float *__iptr) + * } + */ + public static float __modff(float __x, MemorySegment __iptr) { + var mh$ = __modff.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__modff", __x, __iptr); + } + return (float)mh$.invokeExact(__x, __iptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class expm1f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("expm1f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float expm1f(float __x) + * } + */ + public static FunctionDescriptor expm1f$descriptor() { + return expm1f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float expm1f(float __x) + * } + */ + public static MethodHandle expm1f$handle() { + return expm1f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float expm1f(float __x) + * } + */ + public static MemorySegment expm1f$address() { + return expm1f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float expm1f(float __x) + * } + */ + public static float expm1f(float __x) { + var mh$ = expm1f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("expm1f", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __expm1f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__expm1f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __expm1f(float __x) + * } + */ + public static FunctionDescriptor __expm1f$descriptor() { + return __expm1f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __expm1f(float __x) + * } + */ + public static MethodHandle __expm1f$handle() { + return __expm1f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __expm1f(float __x) + * } + */ + public static MemorySegment __expm1f$address() { + return __expm1f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __expm1f(float __x) + * } + */ + public static float __expm1f(float __x) { + var mh$ = __expm1f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__expm1f", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class log1pf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("log1pf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float log1pf(float __x) + * } + */ + public static FunctionDescriptor log1pf$descriptor() { + return log1pf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float log1pf(float __x) + * } + */ + public static MethodHandle log1pf$handle() { + return log1pf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float log1pf(float __x) + * } + */ + public static MemorySegment log1pf$address() { + return log1pf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float log1pf(float __x) + * } + */ + public static float log1pf(float __x) { + var mh$ = log1pf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("log1pf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __log1pf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__log1pf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __log1pf(float __x) + * } + */ + public static FunctionDescriptor __log1pf$descriptor() { + return __log1pf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __log1pf(float __x) + * } + */ + public static MethodHandle __log1pf$handle() { + return __log1pf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __log1pf(float __x) + * } + */ + public static MemorySegment __log1pf$address() { + return __log1pf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __log1pf(float __x) + * } + */ + public static float __log1pf(float __x) { + var mh$ = __log1pf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__log1pf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class logbf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("logbf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float logbf(float __x) + * } + */ + public static FunctionDescriptor logbf$descriptor() { + return logbf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float logbf(float __x) + * } + */ + public static MethodHandle logbf$handle() { + return logbf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float logbf(float __x) + * } + */ + public static MemorySegment logbf$address() { + return logbf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float logbf(float __x) + * } + */ + public static float logbf(float __x) { + var mh$ = logbf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("logbf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __logbf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__logbf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __logbf(float __x) + * } + */ + public static FunctionDescriptor __logbf$descriptor() { + return __logbf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __logbf(float __x) + * } + */ + public static MethodHandle __logbf$handle() { + return __logbf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __logbf(float __x) + * } + */ + public static MemorySegment __logbf$address() { + return __logbf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __logbf(float __x) + * } + */ + public static float __logbf(float __x) { + var mh$ = __logbf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__logbf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class exp2f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("exp2f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float exp2f(float __x) + * } + */ + public static FunctionDescriptor exp2f$descriptor() { + return exp2f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float exp2f(float __x) + * } + */ + public static MethodHandle exp2f$handle() { + return exp2f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float exp2f(float __x) + * } + */ + public static MemorySegment exp2f$address() { + return exp2f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float exp2f(float __x) + * } + */ + public static float exp2f(float __x) { + var mh$ = exp2f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("exp2f", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __exp2f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__exp2f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __exp2f(float __x) + * } + */ + public static FunctionDescriptor __exp2f$descriptor() { + return __exp2f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __exp2f(float __x) + * } + */ + public static MethodHandle __exp2f$handle() { + return __exp2f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __exp2f(float __x) + * } + */ + public static MemorySegment __exp2f$address() { + return __exp2f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __exp2f(float __x) + * } + */ + public static float __exp2f(float __x) { + var mh$ = __exp2f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__exp2f", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class log2f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("log2f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float log2f(float __x) + * } + */ + public static FunctionDescriptor log2f$descriptor() { + return log2f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float log2f(float __x) + * } + */ + public static MethodHandle log2f$handle() { + return log2f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float log2f(float __x) + * } + */ + public static MemorySegment log2f$address() { + return log2f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float log2f(float __x) + * } + */ + public static float log2f(float __x) { + var mh$ = log2f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("log2f", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __log2f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__log2f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __log2f(float __x) + * } + */ + public static FunctionDescriptor __log2f$descriptor() { + return __log2f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __log2f(float __x) + * } + */ + public static MethodHandle __log2f$handle() { + return __log2f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __log2f(float __x) + * } + */ + public static MemorySegment __log2f$address() { + return __log2f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __log2f(float __x) + * } + */ + public static float __log2f(float __x) { + var mh$ = __log2f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__log2f", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class powf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("powf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float powf(float __x, float __y) + * } + */ + public static FunctionDescriptor powf$descriptor() { + return powf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float powf(float __x, float __y) + * } + */ + public static MethodHandle powf$handle() { + return powf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float powf(float __x, float __y) + * } + */ + public static MemorySegment powf$address() { + return powf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float powf(float __x, float __y) + * } + */ + public static float powf(float __x, float __y) { + var mh$ = powf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("powf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __powf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__powf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __powf(float __x, float __y) + * } + */ + public static FunctionDescriptor __powf$descriptor() { + return __powf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __powf(float __x, float __y) + * } + */ + public static MethodHandle __powf$handle() { + return __powf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __powf(float __x, float __y) + * } + */ + public static MemorySegment __powf$address() { + return __powf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __powf(float __x, float __y) + * } + */ + public static float __powf(float __x, float __y) { + var mh$ = __powf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__powf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class sqrtf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("sqrtf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float sqrtf(float __x) + * } + */ + public static FunctionDescriptor sqrtf$descriptor() { + return sqrtf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float sqrtf(float __x) + * } + */ + public static MethodHandle sqrtf$handle() { + return sqrtf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float sqrtf(float __x) + * } + */ + public static MemorySegment sqrtf$address() { + return sqrtf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float sqrtf(float __x) + * } + */ + public static float sqrtf(float __x) { + var mh$ = sqrtf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("sqrtf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __sqrtf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__sqrtf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __sqrtf(float __x) + * } + */ + public static FunctionDescriptor __sqrtf$descriptor() { + return __sqrtf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __sqrtf(float __x) + * } + */ + public static MethodHandle __sqrtf$handle() { + return __sqrtf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __sqrtf(float __x) + * } + */ + public static MemorySegment __sqrtf$address() { + return __sqrtf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __sqrtf(float __x) + * } + */ + public static float __sqrtf(float __x) { + var mh$ = __sqrtf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__sqrtf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class hypotf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("hypotf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float hypotf(float __x, float __y) + * } + */ + public static FunctionDescriptor hypotf$descriptor() { + return hypotf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float hypotf(float __x, float __y) + * } + */ + public static MethodHandle hypotf$handle() { + return hypotf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float hypotf(float __x, float __y) + * } + */ + public static MemorySegment hypotf$address() { + return hypotf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float hypotf(float __x, float __y) + * } + */ + public static float hypotf(float __x, float __y) { + var mh$ = hypotf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("hypotf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __hypotf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__hypotf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __hypotf(float __x, float __y) + * } + */ + public static FunctionDescriptor __hypotf$descriptor() { + return __hypotf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __hypotf(float __x, float __y) + * } + */ + public static MethodHandle __hypotf$handle() { + return __hypotf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __hypotf(float __x, float __y) + * } + */ + public static MemorySegment __hypotf$address() { + return __hypotf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __hypotf(float __x, float __y) + * } + */ + public static float __hypotf(float __x, float __y) { + var mh$ = __hypotf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__hypotf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cbrtf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cbrtf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float cbrtf(float __x) + * } + */ + public static FunctionDescriptor cbrtf$descriptor() { + return cbrtf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float cbrtf(float __x) + * } + */ + public static MethodHandle cbrtf$handle() { + return cbrtf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float cbrtf(float __x) + * } + */ + public static MemorySegment cbrtf$address() { + return cbrtf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float cbrtf(float __x) + * } + */ + public static float cbrtf(float __x) { + var mh$ = cbrtf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cbrtf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __cbrtf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__cbrtf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __cbrtf(float __x) + * } + */ + public static FunctionDescriptor __cbrtf$descriptor() { + return __cbrtf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __cbrtf(float __x) + * } + */ + public static MethodHandle __cbrtf$handle() { + return __cbrtf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __cbrtf(float __x) + * } + */ + public static MemorySegment __cbrtf$address() { + return __cbrtf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __cbrtf(float __x) + * } + */ + public static float __cbrtf(float __x) { + var mh$ = __cbrtf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__cbrtf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ceilf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("ceilf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float ceilf(float __x) + * } + */ + public static FunctionDescriptor ceilf$descriptor() { + return ceilf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float ceilf(float __x) + * } + */ + public static MethodHandle ceilf$handle() { + return ceilf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float ceilf(float __x) + * } + */ + public static MemorySegment ceilf$address() { + return ceilf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float ceilf(float __x) + * } + */ + public static float ceilf(float __x) { + var mh$ = ceilf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ceilf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __ceilf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__ceilf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __ceilf(float __x) + * } + */ + public static FunctionDescriptor __ceilf$descriptor() { + return __ceilf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __ceilf(float __x) + * } + */ + public static MethodHandle __ceilf$handle() { + return __ceilf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __ceilf(float __x) + * } + */ + public static MemorySegment __ceilf$address() { + return __ceilf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __ceilf(float __x) + * } + */ + public static float __ceilf(float __x) { + var mh$ = __ceilf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__ceilf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class fabsf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("fabsf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float fabsf(float __x) + * } + */ + public static FunctionDescriptor fabsf$descriptor() { + return fabsf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float fabsf(float __x) + * } + */ + public static MethodHandle fabsf$handle() { + return fabsf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float fabsf(float __x) + * } + */ + public static MemorySegment fabsf$address() { + return fabsf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float fabsf(float __x) + * } + */ + public static float fabsf(float __x) { + var mh$ = fabsf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("fabsf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __fabsf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__fabsf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __fabsf(float __x) + * } + */ + public static FunctionDescriptor __fabsf$descriptor() { + return __fabsf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __fabsf(float __x) + * } + */ + public static MethodHandle __fabsf$handle() { + return __fabsf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __fabsf(float __x) + * } + */ + public static MemorySegment __fabsf$address() { + return __fabsf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __fabsf(float __x) + * } + */ + public static float __fabsf(float __x) { + var mh$ = __fabsf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__fabsf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class floorf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("floorf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float floorf(float __x) + * } + */ + public static FunctionDescriptor floorf$descriptor() { + return floorf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float floorf(float __x) + * } + */ + public static MethodHandle floorf$handle() { + return floorf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float floorf(float __x) + * } + */ + public static MemorySegment floorf$address() { + return floorf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float floorf(float __x) + * } + */ + public static float floorf(float __x) { + var mh$ = floorf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("floorf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __floorf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__floorf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __floorf(float __x) + * } + */ + public static FunctionDescriptor __floorf$descriptor() { + return __floorf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __floorf(float __x) + * } + */ + public static MethodHandle __floorf$handle() { + return __floorf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __floorf(float __x) + * } + */ + public static MemorySegment __floorf$address() { + return __floorf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __floorf(float __x) + * } + */ + public static float __floorf(float __x) { + var mh$ = __floorf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__floorf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class fmodf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("fmodf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float fmodf(float __x, float __y) + * } + */ + public static FunctionDescriptor fmodf$descriptor() { + return fmodf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float fmodf(float __x, float __y) + * } + */ + public static MethodHandle fmodf$handle() { + return fmodf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float fmodf(float __x, float __y) + * } + */ + public static MemorySegment fmodf$address() { + return fmodf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float fmodf(float __x, float __y) + * } + */ + public static float fmodf(float __x, float __y) { + var mh$ = fmodf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("fmodf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __fmodf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__fmodf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __fmodf(float __x, float __y) + * } + */ + public static FunctionDescriptor __fmodf$descriptor() { + return __fmodf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __fmodf(float __x, float __y) + * } + */ + public static MethodHandle __fmodf$handle() { + return __fmodf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __fmodf(float __x, float __y) + * } + */ + public static MemorySegment __fmodf$address() { + return __fmodf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __fmodf(float __x, float __y) + * } + */ + public static float __fmodf(float __x, float __y) { + var mh$ = __fmodf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__fmodf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class isinff { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("isinff"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int isinff(float __value) + * } + */ + public static FunctionDescriptor isinff$descriptor() { + return isinff.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int isinff(float __value) + * } + */ + public static MethodHandle isinff$handle() { + return isinff.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int isinff(float __value) + * } + */ + public static MemorySegment isinff$address() { + return isinff.ADDR; + } + + /** + * {@snippet lang=c : + * extern int isinff(float __value) + * } + */ + public static int isinff(float __value) { + var mh$ = isinff.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("isinff", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class finitef { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("finitef"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int finitef(float __value) + * } + */ + public static FunctionDescriptor finitef$descriptor() { + return finitef.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int finitef(float __value) + * } + */ + public static MethodHandle finitef$handle() { + return finitef.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int finitef(float __value) + * } + */ + public static MemorySegment finitef$address() { + return finitef.ADDR; + } + + /** + * {@snippet lang=c : + * extern int finitef(float __value) + * } + */ + public static int finitef(float __value) { + var mh$ = finitef.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("finitef", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class dremf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("dremf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float dremf(float __x, float __y) + * } + */ + public static FunctionDescriptor dremf$descriptor() { + return dremf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float dremf(float __x, float __y) + * } + */ + public static MethodHandle dremf$handle() { + return dremf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float dremf(float __x, float __y) + * } + */ + public static MemorySegment dremf$address() { + return dremf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float dremf(float __x, float __y) + * } + */ + public static float dremf(float __x, float __y) { + var mh$ = dremf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("dremf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __dremf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__dremf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __dremf(float __x, float __y) + * } + */ + public static FunctionDescriptor __dremf$descriptor() { + return __dremf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __dremf(float __x, float __y) + * } + */ + public static MethodHandle __dremf$handle() { + return __dremf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __dremf(float __x, float __y) + * } + */ + public static MemorySegment __dremf$address() { + return __dremf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __dremf(float __x, float __y) + * } + */ + public static float __dremf(float __x, float __y) { + var mh$ = __dremf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__dremf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class significandf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("significandf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float significandf(float __x) + * } + */ + public static FunctionDescriptor significandf$descriptor() { + return significandf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float significandf(float __x) + * } + */ + public static MethodHandle significandf$handle() { + return significandf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float significandf(float __x) + * } + */ + public static MemorySegment significandf$address() { + return significandf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float significandf(float __x) + * } + */ + public static float significandf(float __x) { + var mh$ = significandf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("significandf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __significandf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__significandf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __significandf(float __x) + * } + */ + public static FunctionDescriptor __significandf$descriptor() { + return __significandf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __significandf(float __x) + * } + */ + public static MethodHandle __significandf$handle() { + return __significandf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __significandf(float __x) + * } + */ + public static MemorySegment __significandf$address() { + return __significandf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __significandf(float __x) + * } + */ + public static float __significandf(float __x) { + var mh$ = __significandf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__significandf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class copysignf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("copysignf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float copysignf(float __x, float __y) + * } + */ + public static FunctionDescriptor copysignf$descriptor() { + return copysignf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float copysignf(float __x, float __y) + * } + */ + public static MethodHandle copysignf$handle() { + return copysignf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float copysignf(float __x, float __y) + * } + */ + public static MemorySegment copysignf$address() { + return copysignf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float copysignf(float __x, float __y) + * } + */ + public static float copysignf(float __x, float __y) { + var mh$ = copysignf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("copysignf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __copysignf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__copysignf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __copysignf(float __x, float __y) + * } + */ + public static FunctionDescriptor __copysignf$descriptor() { + return __copysignf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __copysignf(float __x, float __y) + * } + */ + public static MethodHandle __copysignf$handle() { + return __copysignf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __copysignf(float __x, float __y) + * } + */ + public static MemorySegment __copysignf$address() { + return __copysignf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __copysignf(float __x, float __y) + * } + */ + public static float __copysignf(float __x, float __y) { + var mh$ = __copysignf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__copysignf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class nanf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("nanf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float nanf(const char *__tagb) + * } + */ + public static FunctionDescriptor nanf$descriptor() { + return nanf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float nanf(const char *__tagb) + * } + */ + public static MethodHandle nanf$handle() { + return nanf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float nanf(const char *__tagb) + * } + */ + public static MemorySegment nanf$address() { + return nanf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float nanf(const char *__tagb) + * } + */ + public static float nanf(MemorySegment __tagb) { + var mh$ = nanf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("nanf", __tagb); + } + return (float)mh$.invokeExact(__tagb); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __nanf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__nanf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __nanf(const char *__tagb) + * } + */ + public static FunctionDescriptor __nanf$descriptor() { + return __nanf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __nanf(const char *__tagb) + * } + */ + public static MethodHandle __nanf$handle() { + return __nanf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __nanf(const char *__tagb) + * } + */ + public static MemorySegment __nanf$address() { + return __nanf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __nanf(const char *__tagb) + * } + */ + public static float __nanf(MemorySegment __tagb) { + var mh$ = __nanf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__nanf", __tagb); + } + return (float)mh$.invokeExact(__tagb); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class isnanf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("isnanf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int isnanf(float __value) + * } + */ + public static FunctionDescriptor isnanf$descriptor() { + return isnanf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int isnanf(float __value) + * } + */ + public static MethodHandle isnanf$handle() { + return isnanf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int isnanf(float __value) + * } + */ + public static MemorySegment isnanf$address() { + return isnanf.ADDR; + } + + /** + * {@snippet lang=c : + * extern int isnanf(float __value) + * } + */ + public static int isnanf(float __value) { + var mh$ = isnanf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("isnanf", __value); + } + return (int)mh$.invokeExact(__value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class j0f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("j0f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float j0f(float) + * } + */ + public static FunctionDescriptor j0f$descriptor() { + return j0f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float j0f(float) + * } + */ + public static MethodHandle j0f$handle() { + return j0f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float j0f(float) + * } + */ + public static MemorySegment j0f$address() { + return j0f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float j0f(float) + * } + */ + public static float j0f(float x0) { + var mh$ = j0f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("j0f", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __j0f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__j0f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __j0f(float) + * } + */ + public static FunctionDescriptor __j0f$descriptor() { + return __j0f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __j0f(float) + * } + */ + public static MethodHandle __j0f$handle() { + return __j0f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __j0f(float) + * } + */ + public static MemorySegment __j0f$address() { + return __j0f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __j0f(float) + * } + */ + public static float __j0f(float x0) { + var mh$ = __j0f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__j0f", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class j1f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("j1f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float j1f(float) + * } + */ + public static FunctionDescriptor j1f$descriptor() { + return j1f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float j1f(float) + * } + */ + public static MethodHandle j1f$handle() { + return j1f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float j1f(float) + * } + */ + public static MemorySegment j1f$address() { + return j1f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float j1f(float) + * } + */ + public static float j1f(float x0) { + var mh$ = j1f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("j1f", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __j1f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__j1f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __j1f(float) + * } + */ + public static FunctionDescriptor __j1f$descriptor() { + return __j1f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __j1f(float) + * } + */ + public static MethodHandle __j1f$handle() { + return __j1f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __j1f(float) + * } + */ + public static MemorySegment __j1f$address() { + return __j1f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __j1f(float) + * } + */ + public static float __j1f(float x0) { + var mh$ = __j1f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__j1f", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class jnf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("jnf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float jnf(int, float) + * } + */ + public static FunctionDescriptor jnf$descriptor() { + return jnf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float jnf(int, float) + * } + */ + public static MethodHandle jnf$handle() { + return jnf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float jnf(int, float) + * } + */ + public static MemorySegment jnf$address() { + return jnf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float jnf(int, float) + * } + */ + public static float jnf(int x0, float x1) { + var mh$ = jnf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("jnf", x0, x1); + } + return (float)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __jnf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__jnf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __jnf(int, float) + * } + */ + public static FunctionDescriptor __jnf$descriptor() { + return __jnf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __jnf(int, float) + * } + */ + public static MethodHandle __jnf$handle() { + return __jnf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __jnf(int, float) + * } + */ + public static MemorySegment __jnf$address() { + return __jnf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __jnf(int, float) + * } + */ + public static float __jnf(int x0, float x1) { + var mh$ = __jnf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__jnf", x0, x1); + } + return (float)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class y0f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("y0f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float y0f(float) + * } + */ + public static FunctionDescriptor y0f$descriptor() { + return y0f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float y0f(float) + * } + */ + public static MethodHandle y0f$handle() { + return y0f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float y0f(float) + * } + */ + public static MemorySegment y0f$address() { + return y0f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float y0f(float) + * } + */ + public static float y0f(float x0) { + var mh$ = y0f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("y0f", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __y0f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__y0f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __y0f(float) + * } + */ + public static FunctionDescriptor __y0f$descriptor() { + return __y0f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __y0f(float) + * } + */ + public static MethodHandle __y0f$handle() { + return __y0f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __y0f(float) + * } + */ + public static MemorySegment __y0f$address() { + return __y0f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __y0f(float) + * } + */ + public static float __y0f(float x0) { + var mh$ = __y0f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__y0f", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class y1f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("y1f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float y1f(float) + * } + */ + public static FunctionDescriptor y1f$descriptor() { + return y1f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float y1f(float) + * } + */ + public static MethodHandle y1f$handle() { + return y1f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float y1f(float) + * } + */ + public static MemorySegment y1f$address() { + return y1f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float y1f(float) + * } + */ + public static float y1f(float x0) { + var mh$ = y1f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("y1f", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __y1f { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__y1f"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __y1f(float) + * } + */ + public static FunctionDescriptor __y1f$descriptor() { + return __y1f.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __y1f(float) + * } + */ + public static MethodHandle __y1f$handle() { + return __y1f.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __y1f(float) + * } + */ + public static MemorySegment __y1f$address() { + return __y1f.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __y1f(float) + * } + */ + public static float __y1f(float x0) { + var mh$ = __y1f.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__y1f", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ynf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("ynf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float ynf(int, float) + * } + */ + public static FunctionDescriptor ynf$descriptor() { + return ynf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float ynf(int, float) + * } + */ + public static MethodHandle ynf$handle() { + return ynf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float ynf(int, float) + * } + */ + public static MemorySegment ynf$address() { + return ynf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float ynf(int, float) + * } + */ + public static float ynf(int x0, float x1) { + var mh$ = ynf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ynf", x0, x1); + } + return (float)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __ynf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__ynf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __ynf(int, float) + * } + */ + public static FunctionDescriptor __ynf$descriptor() { + return __ynf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __ynf(int, float) + * } + */ + public static MethodHandle __ynf$handle() { + return __ynf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __ynf(int, float) + * } + */ + public static MemorySegment __ynf$address() { + return __ynf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __ynf(int, float) + * } + */ + public static float __ynf(int x0, float x1) { + var mh$ = __ynf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__ynf", x0, x1); + } + return (float)mh$.invokeExact(x0, x1); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class erff { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("erff"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float erff(float) + * } + */ + public static FunctionDescriptor erff$descriptor() { + return erff.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float erff(float) + * } + */ + public static MethodHandle erff$handle() { + return erff.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float erff(float) + * } + */ + public static MemorySegment erff$address() { + return erff.ADDR; + } + + /** + * {@snippet lang=c : + * extern float erff(float) + * } + */ + public static float erff(float x0) { + var mh$ = erff.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("erff", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __erff { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__erff"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __erff(float) + * } + */ + public static FunctionDescriptor __erff$descriptor() { + return __erff.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __erff(float) + * } + */ + public static MethodHandle __erff$handle() { + return __erff.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __erff(float) + * } + */ + public static MemorySegment __erff$address() { + return __erff.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __erff(float) + * } + */ + public static float __erff(float x0) { + var mh$ = __erff.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__erff", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class erfcf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("erfcf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float erfcf(float) + * } + */ + public static FunctionDescriptor erfcf$descriptor() { + return erfcf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float erfcf(float) + * } + */ + public static MethodHandle erfcf$handle() { + return erfcf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float erfcf(float) + * } + */ + public static MemorySegment erfcf$address() { + return erfcf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float erfcf(float) + * } + */ + public static float erfcf(float x0) { + var mh$ = erfcf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("erfcf", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __erfcf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__erfcf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __erfcf(float) + * } + */ + public static FunctionDescriptor __erfcf$descriptor() { + return __erfcf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __erfcf(float) + * } + */ + public static MethodHandle __erfcf$handle() { + return __erfcf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __erfcf(float) + * } + */ + public static MemorySegment __erfcf$address() { + return __erfcf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __erfcf(float) + * } + */ + public static float __erfcf(float x0) { + var mh$ = __erfcf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__erfcf", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class lgammaf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("lgammaf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float lgammaf(float) + * } + */ + public static FunctionDescriptor lgammaf$descriptor() { + return lgammaf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float lgammaf(float) + * } + */ + public static MethodHandle lgammaf$handle() { + return lgammaf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float lgammaf(float) + * } + */ + public static MemorySegment lgammaf$address() { + return lgammaf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float lgammaf(float) + * } + */ + public static float lgammaf(float x0) { + var mh$ = lgammaf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("lgammaf", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __lgammaf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__lgammaf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __lgammaf(float) + * } + */ + public static FunctionDescriptor __lgammaf$descriptor() { + return __lgammaf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __lgammaf(float) + * } + */ + public static MethodHandle __lgammaf$handle() { + return __lgammaf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __lgammaf(float) + * } + */ + public static MemorySegment __lgammaf$address() { + return __lgammaf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __lgammaf(float) + * } + */ + public static float __lgammaf(float x0) { + var mh$ = __lgammaf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__lgammaf", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class tgammaf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("tgammaf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float tgammaf(float) + * } + */ + public static FunctionDescriptor tgammaf$descriptor() { + return tgammaf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float tgammaf(float) + * } + */ + public static MethodHandle tgammaf$handle() { + return tgammaf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float tgammaf(float) + * } + */ + public static MemorySegment tgammaf$address() { + return tgammaf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float tgammaf(float) + * } + */ + public static float tgammaf(float x0) { + var mh$ = tgammaf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("tgammaf", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __tgammaf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__tgammaf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __tgammaf(float) + * } + */ + public static FunctionDescriptor __tgammaf$descriptor() { + return __tgammaf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __tgammaf(float) + * } + */ + public static MethodHandle __tgammaf$handle() { + return __tgammaf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __tgammaf(float) + * } + */ + public static MemorySegment __tgammaf$address() { + return __tgammaf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __tgammaf(float) + * } + */ + public static float __tgammaf(float x0) { + var mh$ = __tgammaf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__tgammaf", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class gammaf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("gammaf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float gammaf(float) + * } + */ + public static FunctionDescriptor gammaf$descriptor() { + return gammaf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float gammaf(float) + * } + */ + public static MethodHandle gammaf$handle() { + return gammaf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float gammaf(float) + * } + */ + public static MemorySegment gammaf$address() { + return gammaf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float gammaf(float) + * } + */ + public static float gammaf(float x0) { + var mh$ = gammaf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("gammaf", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __gammaf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__gammaf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __gammaf(float) + * } + */ + public static FunctionDescriptor __gammaf$descriptor() { + return __gammaf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __gammaf(float) + * } + */ + public static MethodHandle __gammaf$handle() { + return __gammaf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __gammaf(float) + * } + */ + public static MemorySegment __gammaf$address() { + return __gammaf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __gammaf(float) + * } + */ + public static float __gammaf(float x0) { + var mh$ = __gammaf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__gammaf", x0); + } + return (float)mh$.invokeExact(x0); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class lgammaf_r { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("lgammaf_r"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float lgammaf_r(float, int *__signgamp) + * } + */ + public static FunctionDescriptor lgammaf_r$descriptor() { + return lgammaf_r.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float lgammaf_r(float, int *__signgamp) + * } + */ + public static MethodHandle lgammaf_r$handle() { + return lgammaf_r.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float lgammaf_r(float, int *__signgamp) + * } + */ + public static MemorySegment lgammaf_r$address() { + return lgammaf_r.ADDR; + } + + /** + * {@snippet lang=c : + * extern float lgammaf_r(float, int *__signgamp) + * } + */ + public static float lgammaf_r(float x0, MemorySegment __signgamp) { + var mh$ = lgammaf_r.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("lgammaf_r", x0, __signgamp); + } + return (float)mh$.invokeExact(x0, __signgamp); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __lgammaf_r { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__lgammaf_r"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __lgammaf_r(float, int *__signgamp) + * } + */ + public static FunctionDescriptor __lgammaf_r$descriptor() { + return __lgammaf_r.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __lgammaf_r(float, int *__signgamp) + * } + */ + public static MethodHandle __lgammaf_r$handle() { + return __lgammaf_r.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __lgammaf_r(float, int *__signgamp) + * } + */ + public static MemorySegment __lgammaf_r$address() { + return __lgammaf_r.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __lgammaf_r(float, int *__signgamp) + * } + */ + public static float __lgammaf_r(float x0, MemorySegment __signgamp) { + var mh$ = __lgammaf_r.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__lgammaf_r", x0, __signgamp); + } + return (float)mh$.invokeExact(x0, __signgamp); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class rintf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("rintf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float rintf(float __x) + * } + */ + public static FunctionDescriptor rintf$descriptor() { + return rintf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float rintf(float __x) + * } + */ + public static MethodHandle rintf$handle() { + return rintf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float rintf(float __x) + * } + */ + public static MemorySegment rintf$address() { + return rintf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float rintf(float __x) + * } + */ + public static float rintf(float __x) { + var mh$ = rintf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("rintf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __rintf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__rintf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __rintf(float __x) + * } + */ + public static FunctionDescriptor __rintf$descriptor() { + return __rintf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __rintf(float __x) + * } + */ + public static MethodHandle __rintf$handle() { + return __rintf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __rintf(float __x) + * } + */ + public static MemorySegment __rintf$address() { + return __rintf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __rintf(float __x) + * } + */ + public static float __rintf(float __x) { + var mh$ = __rintf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__rintf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class nextafterf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("nextafterf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float nextafterf(float __x, float __y) + * } + */ + public static FunctionDescriptor nextafterf$descriptor() { + return nextafterf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float nextafterf(float __x, float __y) + * } + */ + public static MethodHandle nextafterf$handle() { + return nextafterf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float nextafterf(float __x, float __y) + * } + */ + public static MemorySegment nextafterf$address() { + return nextafterf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float nextafterf(float __x, float __y) + * } + */ + public static float nextafterf(float __x, float __y) { + var mh$ = nextafterf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("nextafterf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __nextafterf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__nextafterf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __nextafterf(float __x, float __y) + * } + */ + public static FunctionDescriptor __nextafterf$descriptor() { + return __nextafterf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __nextafterf(float __x, float __y) + * } + */ + public static MethodHandle __nextafterf$handle() { + return __nextafterf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __nextafterf(float __x, float __y) + * } + */ + public static MemorySegment __nextafterf$address() { + return __nextafterf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __nextafterf(float __x, float __y) + * } + */ + public static float __nextafterf(float __x, float __y) { + var mh$ = __nextafterf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__nextafterf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class remainderf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("remainderf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float remainderf(float __x, float __y) + * } + */ + public static FunctionDescriptor remainderf$descriptor() { + return remainderf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float remainderf(float __x, float __y) + * } + */ + public static MethodHandle remainderf$handle() { + return remainderf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float remainderf(float __x, float __y) + * } + */ + public static MemorySegment remainderf$address() { + return remainderf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float remainderf(float __x, float __y) + * } + */ + public static float remainderf(float __x, float __y) { + var mh$ = remainderf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("remainderf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __remainderf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__remainderf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __remainderf(float __x, float __y) + * } + */ + public static FunctionDescriptor __remainderf$descriptor() { + return __remainderf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __remainderf(float __x, float __y) + * } + */ + public static MethodHandle __remainderf$handle() { + return __remainderf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __remainderf(float __x, float __y) + * } + */ + public static MemorySegment __remainderf$address() { + return __remainderf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __remainderf(float __x, float __y) + * } + */ + public static float __remainderf(float __x, float __y) { + var mh$ = __remainderf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__remainderf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class scalbnf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_INT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("scalbnf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float scalbnf(float __x, int __n) + * } + */ + public static FunctionDescriptor scalbnf$descriptor() { + return scalbnf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float scalbnf(float __x, int __n) + * } + */ + public static MethodHandle scalbnf$handle() { + return scalbnf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float scalbnf(float __x, int __n) + * } + */ + public static MemorySegment scalbnf$address() { + return scalbnf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float scalbnf(float __x, int __n) + * } + */ + public static float scalbnf(float __x, int __n) { + var mh$ = scalbnf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("scalbnf", __x, __n); + } + return (float)mh$.invokeExact(__x, __n); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __scalbnf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_INT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__scalbnf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __scalbnf(float __x, int __n) + * } + */ + public static FunctionDescriptor __scalbnf$descriptor() { + return __scalbnf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __scalbnf(float __x, int __n) + * } + */ + public static MethodHandle __scalbnf$handle() { + return __scalbnf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __scalbnf(float __x, int __n) + * } + */ + public static MemorySegment __scalbnf$address() { + return __scalbnf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __scalbnf(float __x, int __n) + * } + */ + public static float __scalbnf(float __x, int __n) { + var mh$ = __scalbnf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__scalbnf", __x, __n); + } + return (float)mh$.invokeExact(__x, __n); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class ilogbf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("ilogbf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int ilogbf(float __x) + * } + */ + public static FunctionDescriptor ilogbf$descriptor() { + return ilogbf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int ilogbf(float __x) + * } + */ + public static MethodHandle ilogbf$handle() { + return ilogbf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int ilogbf(float __x) + * } + */ + public static MemorySegment ilogbf$address() { + return ilogbf.ADDR; + } + + /** + * {@snippet lang=c : + * extern int ilogbf(float __x) + * } + */ + public static int ilogbf(float __x) { + var mh$ = ilogbf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("ilogbf", __x); + } + return (int)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __ilogbf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__ilogbf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern int __ilogbf(float __x) + * } + */ + public static FunctionDescriptor __ilogbf$descriptor() { + return __ilogbf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern int __ilogbf(float __x) + * } + */ + public static MethodHandle __ilogbf$handle() { + return __ilogbf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern int __ilogbf(float __x) + * } + */ + public static MemorySegment __ilogbf$address() { + return __ilogbf.ADDR; + } + + /** + * {@snippet lang=c : + * extern int __ilogbf(float __x) + * } + */ + public static int __ilogbf(float __x) { + var mh$ = __ilogbf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__ilogbf", __x); + } + return (int)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class scalblnf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_LONG + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("scalblnf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float scalblnf(float __x, long __n) + * } + */ + public static FunctionDescriptor scalblnf$descriptor() { + return scalblnf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float scalblnf(float __x, long __n) + * } + */ + public static MethodHandle scalblnf$handle() { + return scalblnf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float scalblnf(float __x, long __n) + * } + */ + public static MemorySegment scalblnf$address() { + return scalblnf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float scalblnf(float __x, long __n) + * } + */ + public static float scalblnf(float __x, long __n) { + var mh$ = scalblnf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("scalblnf", __x, __n); + } + return (float)mh$.invokeExact(__x, __n); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __scalblnf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_LONG + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__scalblnf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __scalblnf(float __x, long __n) + * } + */ + public static FunctionDescriptor __scalblnf$descriptor() { + return __scalblnf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __scalblnf(float __x, long __n) + * } + */ + public static MethodHandle __scalblnf$handle() { + return __scalblnf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __scalblnf(float __x, long __n) + * } + */ + public static MemorySegment __scalblnf$address() { + return __scalblnf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __scalblnf(float __x, long __n) + * } + */ + public static float __scalblnf(float __x, long __n) { + var mh$ = __scalblnf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__scalblnf", __x, __n); + } + return (float)mh$.invokeExact(__x, __n); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class nearbyintf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("nearbyintf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float nearbyintf(float __x) + * } + */ + public static FunctionDescriptor nearbyintf$descriptor() { + return nearbyintf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float nearbyintf(float __x) + * } + */ + public static MethodHandle nearbyintf$handle() { + return nearbyintf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float nearbyintf(float __x) + * } + */ + public static MemorySegment nearbyintf$address() { + return nearbyintf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float nearbyintf(float __x) + * } + */ + public static float nearbyintf(float __x) { + var mh$ = nearbyintf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("nearbyintf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __nearbyintf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__nearbyintf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __nearbyintf(float __x) + * } + */ + public static FunctionDescriptor __nearbyintf$descriptor() { + return __nearbyintf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __nearbyintf(float __x) + * } + */ + public static MethodHandle __nearbyintf$handle() { + return __nearbyintf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __nearbyintf(float __x) + * } + */ + public static MemorySegment __nearbyintf$address() { + return __nearbyintf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __nearbyintf(float __x) + * } + */ + public static float __nearbyintf(float __x) { + var mh$ = __nearbyintf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__nearbyintf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class roundf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("roundf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float roundf(float __x) + * } + */ + public static FunctionDescriptor roundf$descriptor() { + return roundf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float roundf(float __x) + * } + */ + public static MethodHandle roundf$handle() { + return roundf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float roundf(float __x) + * } + */ + public static MemorySegment roundf$address() { + return roundf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float roundf(float __x) + * } + */ + public static float roundf(float __x) { + var mh$ = roundf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("roundf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __roundf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__roundf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __roundf(float __x) + * } + */ + public static FunctionDescriptor __roundf$descriptor() { + return __roundf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __roundf(float __x) + * } + */ + public static MethodHandle __roundf$handle() { + return __roundf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __roundf(float __x) + * } + */ + public static MemorySegment __roundf$address() { + return __roundf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __roundf(float __x) + * } + */ + public static float __roundf(float __x) { + var mh$ = __roundf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__roundf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class truncf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("truncf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float truncf(float __x) + * } + */ + public static FunctionDescriptor truncf$descriptor() { + return truncf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float truncf(float __x) + * } + */ + public static MethodHandle truncf$handle() { + return truncf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float truncf(float __x) + * } + */ + public static MemorySegment truncf$address() { + return truncf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float truncf(float __x) + * } + */ + public static float truncf(float __x) { + var mh$ = truncf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("truncf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __truncf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__truncf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __truncf(float __x) + * } + */ + public static FunctionDescriptor __truncf$descriptor() { + return __truncf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __truncf(float __x) + * } + */ + public static MethodHandle __truncf$handle() { + return __truncf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __truncf(float __x) + * } + */ + public static MemorySegment __truncf$address() { + return __truncf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __truncf(float __x) + * } + */ + public static float __truncf(float __x) { + var mh$ = __truncf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__truncf", __x); + } + return (float)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class remquof { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("remquof"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float remquof(float __x, float __y, int *__quo) + * } + */ + public static FunctionDescriptor remquof$descriptor() { + return remquof.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float remquof(float __x, float __y, int *__quo) + * } + */ + public static MethodHandle remquof$handle() { + return remquof.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float remquof(float __x, float __y, int *__quo) + * } + */ + public static MemorySegment remquof$address() { + return remquof.ADDR; + } + + /** + * {@snippet lang=c : + * extern float remquof(float __x, float __y, int *__quo) + * } + */ + public static float remquof(float __x, float __y, MemorySegment __quo) { + var mh$ = remquof.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("remquof", __x, __y, __quo); + } + return (float)mh$.invokeExact(__x, __y, __quo); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __remquof { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__remquof"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __remquof(float __x, float __y, int *__quo) + * } + */ + public static FunctionDescriptor __remquof$descriptor() { + return __remquof.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __remquof(float __x, float __y, int *__quo) + * } + */ + public static MethodHandle __remquof$handle() { + return __remquof.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __remquof(float __x, float __y, int *__quo) + * } + */ + public static MemorySegment __remquof$address() { + return __remquof.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __remquof(float __x, float __y, int *__quo) + * } + */ + public static float __remquof(float __x, float __y, MemorySegment __quo) { + var mh$ = __remquof.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__remquof", __x, __y, __quo); + } + return (float)mh$.invokeExact(__x, __y, __quo); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class lrintf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("lrintf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long lrintf(float __x) + * } + */ + public static FunctionDescriptor lrintf$descriptor() { + return lrintf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long lrintf(float __x) + * } + */ + public static MethodHandle lrintf$handle() { + return lrintf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long lrintf(float __x) + * } + */ + public static MemorySegment lrintf$address() { + return lrintf.ADDR; + } + + /** + * {@snippet lang=c : + * extern long lrintf(float __x) + * } + */ + public static long lrintf(float __x) { + var mh$ = lrintf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("lrintf", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __lrintf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__lrintf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long __lrintf(float __x) + * } + */ + public static FunctionDescriptor __lrintf$descriptor() { + return __lrintf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long __lrintf(float __x) + * } + */ + public static MethodHandle __lrintf$handle() { + return __lrintf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long __lrintf(float __x) + * } + */ + public static MemorySegment __lrintf$address() { + return __lrintf.ADDR; + } + + /** + * {@snippet lang=c : + * extern long __lrintf(float __x) + * } + */ + public static long __lrintf(float __x) { + var mh$ = __lrintf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__lrintf", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class llrintf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG_LONG, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("llrintf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long long llrintf(float __x) + * } + */ + public static FunctionDescriptor llrintf$descriptor() { + return llrintf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long long llrintf(float __x) + * } + */ + public static MethodHandle llrintf$handle() { + return llrintf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long long llrintf(float __x) + * } + */ + public static MemorySegment llrintf$address() { + return llrintf.ADDR; + } + + /** + * {@snippet lang=c : + * extern long long llrintf(float __x) + * } + */ + public static long llrintf(float __x) { + var mh$ = llrintf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("llrintf", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __llrintf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG_LONG, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__llrintf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long long __llrintf(float __x) + * } + */ + public static FunctionDescriptor __llrintf$descriptor() { + return __llrintf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long long __llrintf(float __x) + * } + */ + public static MethodHandle __llrintf$handle() { + return __llrintf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long long __llrintf(float __x) + * } + */ + public static MemorySegment __llrintf$address() { + return __llrintf.ADDR; + } + + /** + * {@snippet lang=c : + * extern long long __llrintf(float __x) + * } + */ + public static long __llrintf(float __x) { + var mh$ = __llrintf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__llrintf", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class lroundf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("lroundf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long lroundf(float __x) + * } + */ + public static FunctionDescriptor lroundf$descriptor() { + return lroundf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long lroundf(float __x) + * } + */ + public static MethodHandle lroundf$handle() { + return lroundf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long lroundf(float __x) + * } + */ + public static MemorySegment lroundf$address() { + return lroundf.ADDR; + } + + /** + * {@snippet lang=c : + * extern long lroundf(float __x) + * } + */ + public static long lroundf(float __x) { + var mh$ = lroundf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("lroundf", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __lroundf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__lroundf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long __lroundf(float __x) + * } + */ + public static FunctionDescriptor __lroundf$descriptor() { + return __lroundf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long __lroundf(float __x) + * } + */ + public static MethodHandle __lroundf$handle() { + return __lroundf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long __lroundf(float __x) + * } + */ + public static MemorySegment __lroundf$address() { + return __lroundf.ADDR; + } + + /** + * {@snippet lang=c : + * extern long __lroundf(float __x) + * } + */ + public static long __lroundf(float __x) { + var mh$ = __lroundf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__lroundf", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class llroundf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG_LONG, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("llroundf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long long llroundf(float __x) + * } + */ + public static FunctionDescriptor llroundf$descriptor() { + return llroundf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long long llroundf(float __x) + * } + */ + public static MethodHandle llroundf$handle() { + return llroundf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long long llroundf(float __x) + * } + */ + public static MemorySegment llroundf$address() { + return llroundf.ADDR; + } + + /** + * {@snippet lang=c : + * extern long long llroundf(float __x) + * } + */ + public static long llroundf(float __x) { + var mh$ = llroundf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("llroundf", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __llroundf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_LONG_LONG, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__llroundf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern long long __llroundf(float __x) + * } + */ + public static FunctionDescriptor __llroundf$descriptor() { + return __llroundf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern long long __llroundf(float __x) + * } + */ + public static MethodHandle __llroundf$handle() { + return __llroundf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern long long __llroundf(float __x) + * } + */ + public static MemorySegment __llroundf$address() { + return __llroundf.ADDR; + } + + /** + * {@snippet lang=c : + * extern long long __llroundf(float __x) + * } + */ + public static long __llroundf(float __x) { + var mh$ = __llroundf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__llroundf", __x); + } + return (long)mh$.invokeExact(__x); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class fdimf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("fdimf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float fdimf(float __x, float __y) + * } + */ + public static FunctionDescriptor fdimf$descriptor() { + return fdimf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float fdimf(float __x, float __y) + * } + */ + public static MethodHandle fdimf$handle() { + return fdimf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float fdimf(float __x, float __y) + * } + */ + public static MemorySegment fdimf$address() { + return fdimf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float fdimf(float __x, float __y) + * } + */ + public static float fdimf(float __x, float __y) { + var mh$ = fdimf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("fdimf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __fdimf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__fdimf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __fdimf(float __x, float __y) + * } + */ + public static FunctionDescriptor __fdimf$descriptor() { + return __fdimf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __fdimf(float __x, float __y) + * } + */ + public static MethodHandle __fdimf$handle() { + return __fdimf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __fdimf(float __x, float __y) + * } + */ + public static MemorySegment __fdimf$address() { + return __fdimf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __fdimf(float __x, float __y) + * } + */ + public static float __fdimf(float __x, float __y) { + var mh$ = __fdimf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__fdimf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class fmaxf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("fmaxf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float fmaxf(float __x, float __y) + * } + */ + public static FunctionDescriptor fmaxf$descriptor() { + return fmaxf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float fmaxf(float __x, float __y) + * } + */ + public static MethodHandle fmaxf$handle() { + return fmaxf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float fmaxf(float __x, float __y) + * } + */ + public static MemorySegment fmaxf$address() { + return fmaxf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float fmaxf(float __x, float __y) + * } + */ + public static float fmaxf(float __x, float __y) { + var mh$ = fmaxf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("fmaxf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __fmaxf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__fmaxf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __fmaxf(float __x, float __y) + * } + */ + public static FunctionDescriptor __fmaxf$descriptor() { + return __fmaxf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __fmaxf(float __x, float __y) + * } + */ + public static MethodHandle __fmaxf$handle() { + return __fmaxf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __fmaxf(float __x, float __y) + * } + */ + public static MemorySegment __fmaxf$address() { + return __fmaxf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __fmaxf(float __x, float __y) + * } + */ + public static float __fmaxf(float __x, float __y) { + var mh$ = __fmaxf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__fmaxf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class fminf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("fminf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float fminf(float __x, float __y) + * } + */ + public static FunctionDescriptor fminf$descriptor() { + return fminf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float fminf(float __x, float __y) + * } + */ + public static MethodHandle fminf$handle() { + return fminf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float fminf(float __x, float __y) + * } + */ + public static MemorySegment fminf$address() { + return fminf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float fminf(float __x, float __y) + * } + */ + public static float fminf(float __x, float __y) { + var mh$ = fminf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("fminf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __fminf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__fminf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __fminf(float __x, float __y) + * } + */ + public static FunctionDescriptor __fminf$descriptor() { + return __fminf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __fminf(float __x, float __y) + * } + */ + public static MethodHandle __fminf$handle() { + return __fminf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __fminf(float __x, float __y) + * } + */ + public static MemorySegment __fminf$address() { + return __fminf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __fminf(float __x, float __y) + * } + */ + public static float __fminf(float __x, float __y) { + var mh$ = __fminf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__fminf", __x, __y); + } + return (float)mh$.invokeExact(__x, __y); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class fmaf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("fmaf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float fmaf(float __x, float __y, float __z) + * } + */ + public static FunctionDescriptor fmaf$descriptor() { + return fmaf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float fmaf(float __x, float __y, float __z) + * } + */ + public static MethodHandle fmaf$handle() { + return fmaf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float fmaf(float __x, float __y, float __z) + * } + */ + public static MemorySegment fmaf$address() { + return fmaf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float fmaf(float __x, float __y, float __z) + * } + */ + public static float fmaf(float __x, float __y, float __z) { + var mh$ = fmaf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("fmaf", __x, __y, __z); + } + return (float)mh$.invokeExact(__x, __y, __z); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __fmaf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__fmaf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __fmaf(float __x, float __y, float __z) + * } + */ + public static FunctionDescriptor __fmaf$descriptor() { + return __fmaf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __fmaf(float __x, float __y, float __z) + * } + */ + public static MethodHandle __fmaf$handle() { + return __fmaf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __fmaf(float __x, float __y, float __z) + * } + */ + public static MemorySegment __fmaf$address() { + return __fmaf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __fmaf(float __x, float __y, float __z) + * } + */ + public static float __fmaf(float __x, float __y, float __z) { + var mh$ = __fmaf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__fmaf", __x, __y, __z); + } + return (float)mh$.invokeExact(__x, __y, __z); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class scalbf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("scalbf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float scalbf(float __x, float __n) + * } + */ + public static FunctionDescriptor scalbf$descriptor() { + return scalbf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float scalbf(float __x, float __n) + * } + */ + public static MethodHandle scalbf$handle() { + return scalbf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float scalbf(float __x, float __n) + * } + */ + public static MemorySegment scalbf$address() { + return scalbf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float scalbf(float __x, float __n) + * } + */ + public static float scalbf(float __x, float __n) { + var mh$ = scalbf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("scalbf", __x, __n); + } + return (float)mh$.invokeExact(__x, __n); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class __scalbf { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT, + cuopt_c_h.C_FLOAT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("__scalbf"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * extern float __scalbf(float __x, float __n) + * } + */ + public static FunctionDescriptor __scalbf$descriptor() { + return __scalbf.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * extern float __scalbf(float __x, float __n) + * } + */ + public static MethodHandle __scalbf$handle() { + return __scalbf.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * extern float __scalbf(float __x, float __n) + * } + */ + public static MemorySegment __scalbf$address() { + return __scalbf.ADDR; + } + + /** + * {@snippet lang=c : + * extern float __scalbf(float __x, float __n) + * } + */ + public static float __scalbf(float __x, float __n) { + var mh$ = __scalbf.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("__scalbf", __x, __n); + } + return (float)mh$.invokeExact(__x, __n); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class signgam$constants { + public static final OfInt LAYOUT = cuopt_c_h.C_INT; + public static final MemorySegment SEGMENT = cuopt_c_h.findOrThrow("signgam").reinterpret(LAYOUT.byteSize()); + } + + /** + * Layout for variable: + * {@snippet lang=c : + * extern int signgam + * } + */ + public static OfInt signgam$layout() { + return signgam$constants.LAYOUT; + } + + /** + * Segment for variable: + * {@snippet lang=c : + * extern int signgam + * } + */ + public static MemorySegment signgam$segment() { + return signgam$constants.SEGMENT; + } + + /** + * Getter for variable: + * {@snippet lang=c : + * extern int signgam + * } + */ + public static int signgam() { + return signgam$constants.SEGMENT.get(signgam$constants.LAYOUT, 0L); + } + + /** + * Setter for variable: + * {@snippet lang=c : + * extern int signgam + * } + */ + public static void signgam(int varValue) { + signgam$constants.SEGMENT.set(signgam$constants.LAYOUT, 0L, varValue); + } + /** + * {@snippet lang=c : + * typedef __int8_t int8_t + * } + */ + public static final OfByte int8_t = cuopt_c_h.C_CHAR; + /** + * {@snippet lang=c : + * typedef __int16_t int16_t + * } + */ + public static final OfShort int16_t = cuopt_c_h.C_SHORT; + /** + * {@snippet lang=c : + * typedef __int32_t int32_t + * } + */ + public static final OfInt int32_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef __int64_t int64_t + * } + */ + public static final OfLong int64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef __uint8_t uint8_t + * } + */ + public static final OfByte uint8_t = cuopt_c_h.C_CHAR; + /** + * {@snippet lang=c : + * typedef __uint16_t uint16_t + * } + */ + public static final OfShort uint16_t = cuopt_c_h.C_SHORT; + /** + * {@snippet lang=c : + * typedef __uint32_t uint32_t + * } + */ + public static final OfInt uint32_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef __uint64_t uint64_t + * } + */ + public static final OfLong uint64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef __int_least8_t int_least8_t + * } + */ + public static final OfByte int_least8_t = cuopt_c_h.C_CHAR; + /** + * {@snippet lang=c : + * typedef __int_least16_t int_least16_t + * } + */ + public static final OfShort int_least16_t = cuopt_c_h.C_SHORT; + /** + * {@snippet lang=c : + * typedef __int_least32_t int_least32_t + * } + */ + public static final OfInt int_least32_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef __int_least64_t int_least64_t + * } + */ + public static final OfLong int_least64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef __uint_least8_t uint_least8_t + * } + */ + public static final OfByte uint_least8_t = cuopt_c_h.C_CHAR; + /** + * {@snippet lang=c : + * typedef __uint_least16_t uint_least16_t + * } + */ + public static final OfShort uint_least16_t = cuopt_c_h.C_SHORT; + /** + * {@snippet lang=c : + * typedef __uint_least32_t uint_least32_t + * } + */ + public static final OfInt uint_least32_t = cuopt_c_h.C_INT; + /** + * {@snippet lang=c : + * typedef __uint_least64_t uint_least64_t + * } + */ + public static final OfLong uint_least64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef signed char int_fast8_t + * } + */ + public static final OfByte int_fast8_t = cuopt_c_h.C_CHAR; + /** + * {@snippet lang=c : + * typedef long int_fast16_t + * } + */ + public static final OfLong int_fast16_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef long int_fast32_t + * } + */ + public static final OfLong int_fast32_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef long int_fast64_t + * } + */ + public static final OfLong int_fast64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned char uint_fast8_t + * } + */ + public static final OfByte uint_fast8_t = cuopt_c_h.C_CHAR; + /** + * {@snippet lang=c : + * typedef unsigned long uint_fast16_t + * } + */ + public static final OfLong uint_fast16_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long uint_fast32_t + * } + */ + public static final OfLong uint_fast32_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long uint_fast64_t + * } + */ + public static final OfLong uint_fast64_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef long intptr_t + * } + */ + public static final OfLong intptr_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef unsigned long uintptr_t + * } + */ + public static final OfLong uintptr_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef __intmax_t intmax_t + * } + */ + public static final OfLong intmax_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef __uintmax_t uintmax_t + * } + */ + public static final OfLong uintmax_t = cuopt_c_h.C_LONG; + /** + * {@snippet lang=c : + * typedef void *cuOptOptimizationProblem + * } + */ + public static final AddressLayout cuOptOptimizationProblem = cuopt_c_h.C_POINTER; + /** + * {@snippet lang=c : + * typedef void *cuOptSolverSettings + * } + */ + public static final AddressLayout cuOptSolverSettings = cuopt_c_h.C_POINTER; + /** + * {@snippet lang=c : + * typedef void *cuOptSolution + * } + */ + public static final AddressLayout cuOptSolution = cuopt_c_h.C_POINTER; + /** + * {@snippet lang=c : + * typedef double cuopt_float_t + * } + */ + public static final OfDouble cuopt_float_t = cuopt_c_h.C_DOUBLE; + /** + * {@snippet lang=c : + * typedef int32_t cuopt_int_t + * } + */ + public static final OfInt cuopt_int_t = cuopt_c_h.C_INT; + + /** + * Variadic invoker class for: + * {@snippet lang=c : + * int8_t cuOptGetFloatSize() + * } + */ + public static class cuOptGetFloatSize { + private static final FunctionDescriptor BASE_DESC = FunctionDescriptor.of( + cuopt_c_h.C_CHAR ); + private static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetFloatSize"); + + private final MethodHandle handle; + private final FunctionDescriptor descriptor; + private final MethodHandle spreader; + + private cuOptGetFloatSize(MethodHandle handle, FunctionDescriptor descriptor, MethodHandle spreader) { + this.handle = handle; + this.descriptor = descriptor; + this.spreader = spreader; + } + + /** + * Variadic invoker factory for: + * {@snippet lang=c : + * int8_t cuOptGetFloatSize() + * } + */ + public static cuOptGetFloatSize makeInvoker(MemoryLayout... layouts) { + FunctionDescriptor desc$ = BASE_DESC.appendArgumentLayouts(layouts); + Linker.Option fva$ = Linker.Option.firstVariadicArg(BASE_DESC.argumentLayouts().size()); + var mh$ = Linker.nativeLinker().downcallHandle(ADDR, desc$, fva$); + var spreader$ = mh$.asSpreader(Object[].class, layouts.length); + return new cuOptGetFloatSize(mh$, desc$, spreader$); + } + + /** + * {@return the address} + */ + public static MemorySegment address() { + return ADDR; + } + + /** + * {@return the specialized method handle} + */ + public MethodHandle handle() { + return handle; + } + + /** + * {@return the specialized descriptor} + */ + public FunctionDescriptor descriptor() { + return descriptor; + } + + public byte apply(Object... x0) { + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetFloatSize", x0); + } + return (byte) spreader.invokeExact(x0); + } catch(IllegalArgumentException | ClassCastException ex$) { + throw ex$; // rethrow IAE from passing wrong number/type of args + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + /** + * Variadic invoker class for: + * {@snippet lang=c : + * int8_t cuOptGetIntSize() + * } + */ + public static class cuOptGetIntSize { + private static final FunctionDescriptor BASE_DESC = FunctionDescriptor.of( + cuopt_c_h.C_CHAR ); + private static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetIntSize"); + + private final MethodHandle handle; + private final FunctionDescriptor descriptor; + private final MethodHandle spreader; + + private cuOptGetIntSize(MethodHandle handle, FunctionDescriptor descriptor, MethodHandle spreader) { + this.handle = handle; + this.descriptor = descriptor; + this.spreader = spreader; + } + + /** + * Variadic invoker factory for: + * {@snippet lang=c : + * int8_t cuOptGetIntSize() + * } + */ + public static cuOptGetIntSize makeInvoker(MemoryLayout... layouts) { + FunctionDescriptor desc$ = BASE_DESC.appendArgumentLayouts(layouts); + Linker.Option fva$ = Linker.Option.firstVariadicArg(BASE_DESC.argumentLayouts().size()); + var mh$ = Linker.nativeLinker().downcallHandle(ADDR, desc$, fva$); + var spreader$ = mh$.asSpreader(Object[].class, layouts.length); + return new cuOptGetIntSize(mh$, desc$, spreader$); + } + + /** + * {@return the address} + */ + public static MemorySegment address() { + return ADDR; + } + + /** + * {@return the specialized method handle} + */ + public MethodHandle handle() { + return handle; + } + + /** + * {@return the specialized descriptor} + */ + public FunctionDescriptor descriptor() { + return descriptor; + } + + public byte apply(Object... x0) { + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetIntSize", x0); + } + return (byte) spreader.invokeExact(x0); + } catch(IllegalArgumentException | ClassCastException ex$) { + throw ex$; // rethrow IAE from passing wrong number/type of args + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + } + + private static class cuOptGetVersion { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetVersion"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetVersion(cuopt_int_t *version_major, cuopt_int_t *version_minor, cuopt_int_t *version_patch) + * } + */ + public static FunctionDescriptor cuOptGetVersion$descriptor() { + return cuOptGetVersion.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetVersion(cuopt_int_t *version_major, cuopt_int_t *version_minor, cuopt_int_t *version_patch) + * } + */ + public static MethodHandle cuOptGetVersion$handle() { + return cuOptGetVersion.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetVersion(cuopt_int_t *version_major, cuopt_int_t *version_minor, cuopt_int_t *version_patch) + * } + */ + public static MemorySegment cuOptGetVersion$address() { + return cuOptGetVersion.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetVersion(cuopt_int_t *version_major, cuopt_int_t *version_minor, cuopt_int_t *version_patch) + * } + */ + public static int cuOptGetVersion(MemorySegment version_major, MemorySegment version_minor, MemorySegment version_patch) { + var mh$ = cuOptGetVersion.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetVersion", version_major, version_minor, version_patch); + } + return (int)mh$.invokeExact(version_major, version_minor, version_patch); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptReadProblem { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptReadProblem"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptReadProblem(const char *filename, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static FunctionDescriptor cuOptReadProblem$descriptor() { + return cuOptReadProblem.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptReadProblem(const char *filename, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static MethodHandle cuOptReadProblem$handle() { + return cuOptReadProblem.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptReadProblem(const char *filename, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static MemorySegment cuOptReadProblem$address() { + return cuOptReadProblem.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptReadProblem(const char *filename, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static int cuOptReadProblem(MemorySegment filename, MemorySegment problem_ptr) { + var mh$ = cuOptReadProblem.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptReadProblem", filename, problem_ptr); + } + return (int)mh$.invokeExact(filename, problem_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptWriteProblem { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_INT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptWriteProblem"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptWriteProblem(cuOptOptimizationProblem problem, const char *filename, cuopt_int_t format) + * } + */ + public static FunctionDescriptor cuOptWriteProblem$descriptor() { + return cuOptWriteProblem.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptWriteProblem(cuOptOptimizationProblem problem, const char *filename, cuopt_int_t format) + * } + */ + public static MethodHandle cuOptWriteProblem$handle() { + return cuOptWriteProblem.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptWriteProblem(cuOptOptimizationProblem problem, const char *filename, cuopt_int_t format) + * } + */ + public static MemorySegment cuOptWriteProblem$address() { + return cuOptWriteProblem.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptWriteProblem(cuOptOptimizationProblem problem, const char *filename, cuopt_int_t format) + * } + */ + public static int cuOptWriteProblem(MemorySegment problem, MemorySegment filename, int format) { + var mh$ = cuOptWriteProblem.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptWriteProblem", problem, filename, format); + } + return (int)mh$.invokeExact(problem, filename, format); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptCreateProblem { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_INT, + cuopt_c_h.C_INT, + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptCreateProblem"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptCreateProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficent_values, const char *constraint_sense, const cuopt_float_t *rhs, const cuopt_float_t *lower_bounds, const cuopt_float_t *upper_bounds, const char *variable_types, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static FunctionDescriptor cuOptCreateProblem$descriptor() { + return cuOptCreateProblem.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptCreateProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficent_values, const char *constraint_sense, const cuopt_float_t *rhs, const cuopt_float_t *lower_bounds, const cuopt_float_t *upper_bounds, const char *variable_types, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static MethodHandle cuOptCreateProblem$handle() { + return cuOptCreateProblem.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptCreateProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficent_values, const char *constraint_sense, const cuopt_float_t *rhs, const cuopt_float_t *lower_bounds, const cuopt_float_t *upper_bounds, const char *variable_types, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static MemorySegment cuOptCreateProblem$address() { + return cuOptCreateProblem.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptCreateProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficent_values, const char *constraint_sense, const cuopt_float_t *rhs, const cuopt_float_t *lower_bounds, const cuopt_float_t *upper_bounds, const char *variable_types, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static int cuOptCreateProblem(int num_constraints, int num_variables, int objective_sense, double objective_offset, MemorySegment objective_coefficients, MemorySegment constraint_matrix_row_offsets, MemorySegment constraint_matrix_column_indices, MemorySegment constraint_matrix_coefficent_values, MemorySegment constraint_sense, MemorySegment rhs, MemorySegment lower_bounds, MemorySegment upper_bounds, MemorySegment variable_types, MemorySegment problem_ptr) { + var mh$ = cuOptCreateProblem.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptCreateProblem", num_constraints, num_variables, objective_sense, objective_offset, objective_coefficients, constraint_matrix_row_offsets, constraint_matrix_column_indices, constraint_matrix_coefficent_values, constraint_sense, rhs, lower_bounds, upper_bounds, variable_types, problem_ptr); + } + return (int)mh$.invokeExact(num_constraints, num_variables, objective_sense, objective_offset, objective_coefficients, constraint_matrix_row_offsets, constraint_matrix_column_indices, constraint_matrix_coefficent_values, constraint_sense, rhs, lower_bounds, upper_bounds, variable_types, problem_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptCreateRangedProblem { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_INT, + cuopt_c_h.C_INT, + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptCreateRangedProblem"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptCreateRangedProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficients, const cuopt_float_t *constraint_lower_bounds, const cuopt_float_t *constraint_upper_bounds, const cuopt_float_t *variable_lower_bounds, const cuopt_float_t *variable_upper_bounds, const char *variable_types, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static FunctionDescriptor cuOptCreateRangedProblem$descriptor() { + return cuOptCreateRangedProblem.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptCreateRangedProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficients, const cuopt_float_t *constraint_lower_bounds, const cuopt_float_t *constraint_upper_bounds, const cuopt_float_t *variable_lower_bounds, const cuopt_float_t *variable_upper_bounds, const char *variable_types, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static MethodHandle cuOptCreateRangedProblem$handle() { + return cuOptCreateRangedProblem.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptCreateRangedProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficients, const cuopt_float_t *constraint_lower_bounds, const cuopt_float_t *constraint_upper_bounds, const cuopt_float_t *variable_lower_bounds, const cuopt_float_t *variable_upper_bounds, const char *variable_types, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static MemorySegment cuOptCreateRangedProblem$address() { + return cuOptCreateRangedProblem.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptCreateRangedProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficients, const cuopt_float_t *constraint_lower_bounds, const cuopt_float_t *constraint_upper_bounds, const cuopt_float_t *variable_lower_bounds, const cuopt_float_t *variable_upper_bounds, const char *variable_types, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static int cuOptCreateRangedProblem(int num_constraints, int num_variables, int objective_sense, double objective_offset, MemorySegment objective_coefficients, MemorySegment constraint_matrix_row_offsets, MemorySegment constraint_matrix_column_indices, MemorySegment constraint_matrix_coefficients, MemorySegment constraint_lower_bounds, MemorySegment constraint_upper_bounds, MemorySegment variable_lower_bounds, MemorySegment variable_upper_bounds, MemorySegment variable_types, MemorySegment problem_ptr) { + var mh$ = cuOptCreateRangedProblem.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptCreateRangedProblem", num_constraints, num_variables, objective_sense, objective_offset, objective_coefficients, constraint_matrix_row_offsets, constraint_matrix_column_indices, constraint_matrix_coefficients, constraint_lower_bounds, constraint_upper_bounds, variable_lower_bounds, variable_upper_bounds, variable_types, problem_ptr); + } + return (int)mh$.invokeExact(num_constraints, num_variables, objective_sense, objective_offset, objective_coefficients, constraint_matrix_row_offsets, constraint_matrix_column_indices, constraint_matrix_coefficients, constraint_lower_bounds, constraint_upper_bounds, variable_lower_bounds, variable_upper_bounds, variable_types, problem_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptCreateQuadraticProblem { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_INT, + cuopt_c_h.C_INT, + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptCreateQuadraticProblem"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptCreateQuadraticProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *quadratic_objective_matrix_row_offsets, const cuopt_int_t *quadratic_objective_matrix_column_indices, const cuopt_float_t *quadratic_objective_matrix_coefficent_values, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficent_values, const char *constraint_sense, const cuopt_float_t *rhs, const cuopt_float_t *lower_bounds, const cuopt_float_t *upper_bounds, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static FunctionDescriptor cuOptCreateQuadraticProblem$descriptor() { + return cuOptCreateQuadraticProblem.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptCreateQuadraticProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *quadratic_objective_matrix_row_offsets, const cuopt_int_t *quadratic_objective_matrix_column_indices, const cuopt_float_t *quadratic_objective_matrix_coefficent_values, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficent_values, const char *constraint_sense, const cuopt_float_t *rhs, const cuopt_float_t *lower_bounds, const cuopt_float_t *upper_bounds, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static MethodHandle cuOptCreateQuadraticProblem$handle() { + return cuOptCreateQuadraticProblem.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptCreateQuadraticProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *quadratic_objective_matrix_row_offsets, const cuopt_int_t *quadratic_objective_matrix_column_indices, const cuopt_float_t *quadratic_objective_matrix_coefficent_values, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficent_values, const char *constraint_sense, const cuopt_float_t *rhs, const cuopt_float_t *lower_bounds, const cuopt_float_t *upper_bounds, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static MemorySegment cuOptCreateQuadraticProblem$address() { + return cuOptCreateQuadraticProblem.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptCreateQuadraticProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *quadratic_objective_matrix_row_offsets, const cuopt_int_t *quadratic_objective_matrix_column_indices, const cuopt_float_t *quadratic_objective_matrix_coefficent_values, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficent_values, const char *constraint_sense, const cuopt_float_t *rhs, const cuopt_float_t *lower_bounds, const cuopt_float_t *upper_bounds, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static int cuOptCreateQuadraticProblem(int num_constraints, int num_variables, int objective_sense, double objective_offset, MemorySegment objective_coefficients, MemorySegment quadratic_objective_matrix_row_offsets, MemorySegment quadratic_objective_matrix_column_indices, MemorySegment quadratic_objective_matrix_coefficent_values, MemorySegment constraint_matrix_row_offsets, MemorySegment constraint_matrix_column_indices, MemorySegment constraint_matrix_coefficent_values, MemorySegment constraint_sense, MemorySegment rhs, MemorySegment lower_bounds, MemorySegment upper_bounds, MemorySegment problem_ptr) { + var mh$ = cuOptCreateQuadraticProblem.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptCreateQuadraticProblem", num_constraints, num_variables, objective_sense, objective_offset, objective_coefficients, quadratic_objective_matrix_row_offsets, quadratic_objective_matrix_column_indices, quadratic_objective_matrix_coefficent_values, constraint_matrix_row_offsets, constraint_matrix_column_indices, constraint_matrix_coefficent_values, constraint_sense, rhs, lower_bounds, upper_bounds, problem_ptr); + } + return (int)mh$.invokeExact(num_constraints, num_variables, objective_sense, objective_offset, objective_coefficients, quadratic_objective_matrix_row_offsets, quadratic_objective_matrix_column_indices, quadratic_objective_matrix_coefficent_values, constraint_matrix_row_offsets, constraint_matrix_column_indices, constraint_matrix_coefficent_values, constraint_sense, rhs, lower_bounds, upper_bounds, problem_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptCreateQuadraticRangedProblem { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_INT, + cuopt_c_h.C_INT, + cuopt_c_h.C_INT, + cuopt_c_h.C_DOUBLE, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptCreateQuadraticRangedProblem"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptCreateQuadraticRangedProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *quadratic_objective_matrix_row_offsets, const cuopt_int_t *quadratic_objective_matrix_column_indices, const cuopt_float_t *quadratic_objective_matrix_coefficent_values, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficients, const cuopt_float_t *constraint_lower_bounds, const cuopt_float_t *constraint_upper_bounds, const cuopt_float_t *variable_lower_bounds, const cuopt_float_t *variable_upper_bounds, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static FunctionDescriptor cuOptCreateQuadraticRangedProblem$descriptor() { + return cuOptCreateQuadraticRangedProblem.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptCreateQuadraticRangedProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *quadratic_objective_matrix_row_offsets, const cuopt_int_t *quadratic_objective_matrix_column_indices, const cuopt_float_t *quadratic_objective_matrix_coefficent_values, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficients, const cuopt_float_t *constraint_lower_bounds, const cuopt_float_t *constraint_upper_bounds, const cuopt_float_t *variable_lower_bounds, const cuopt_float_t *variable_upper_bounds, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static MethodHandle cuOptCreateQuadraticRangedProblem$handle() { + return cuOptCreateQuadraticRangedProblem.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptCreateQuadraticRangedProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *quadratic_objective_matrix_row_offsets, const cuopt_int_t *quadratic_objective_matrix_column_indices, const cuopt_float_t *quadratic_objective_matrix_coefficent_values, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficients, const cuopt_float_t *constraint_lower_bounds, const cuopt_float_t *constraint_upper_bounds, const cuopt_float_t *variable_lower_bounds, const cuopt_float_t *variable_upper_bounds, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static MemorySegment cuOptCreateQuadraticRangedProblem$address() { + return cuOptCreateQuadraticRangedProblem.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptCreateQuadraticRangedProblem(cuopt_int_t num_constraints, cuopt_int_t num_variables, cuopt_int_t objective_sense, cuopt_float_t objective_offset, const cuopt_float_t *objective_coefficients, const cuopt_int_t *quadratic_objective_matrix_row_offsets, const cuopt_int_t *quadratic_objective_matrix_column_indices, const cuopt_float_t *quadratic_objective_matrix_coefficent_values, const cuopt_int_t *constraint_matrix_row_offsets, const cuopt_int_t *constraint_matrix_column_indices, const cuopt_float_t *constraint_matrix_coefficients, const cuopt_float_t *constraint_lower_bounds, const cuopt_float_t *constraint_upper_bounds, const cuopt_float_t *variable_lower_bounds, const cuopt_float_t *variable_upper_bounds, cuOptOptimizationProblem *problem_ptr) + * } + */ + public static int cuOptCreateQuadraticRangedProblem(int num_constraints, int num_variables, int objective_sense, double objective_offset, MemorySegment objective_coefficients, MemorySegment quadratic_objective_matrix_row_offsets, MemorySegment quadratic_objective_matrix_column_indices, MemorySegment quadratic_objective_matrix_coefficent_values, MemorySegment constraint_matrix_row_offsets, MemorySegment constraint_matrix_column_indices, MemorySegment constraint_matrix_coefficients, MemorySegment constraint_lower_bounds, MemorySegment constraint_upper_bounds, MemorySegment variable_lower_bounds, MemorySegment variable_upper_bounds, MemorySegment problem_ptr) { + var mh$ = cuOptCreateQuadraticRangedProblem.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptCreateQuadraticRangedProblem", num_constraints, num_variables, objective_sense, objective_offset, objective_coefficients, quadratic_objective_matrix_row_offsets, quadratic_objective_matrix_column_indices, quadratic_objective_matrix_coefficent_values, constraint_matrix_row_offsets, constraint_matrix_column_indices, constraint_matrix_coefficients, constraint_lower_bounds, constraint_upper_bounds, variable_lower_bounds, variable_upper_bounds, problem_ptr); + } + return (int)mh$.invokeExact(num_constraints, num_variables, objective_sense, objective_offset, objective_coefficients, quadratic_objective_matrix_row_offsets, quadratic_objective_matrix_column_indices, quadratic_objective_matrix_coefficent_values, constraint_matrix_row_offsets, constraint_matrix_column_indices, constraint_matrix_coefficients, constraint_lower_bounds, constraint_upper_bounds, variable_lower_bounds, variable_upper_bounds, problem_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptDestroyProblem { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptDestroyProblem"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * void cuOptDestroyProblem(cuOptOptimizationProblem *problem_ptr) + * } + */ + public static FunctionDescriptor cuOptDestroyProblem$descriptor() { + return cuOptDestroyProblem.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * void cuOptDestroyProblem(cuOptOptimizationProblem *problem_ptr) + * } + */ + public static MethodHandle cuOptDestroyProblem$handle() { + return cuOptDestroyProblem.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * void cuOptDestroyProblem(cuOptOptimizationProblem *problem_ptr) + * } + */ + public static MemorySegment cuOptDestroyProblem$address() { + return cuOptDestroyProblem.ADDR; + } + + /** + * {@snippet lang=c : + * void cuOptDestroyProblem(cuOptOptimizationProblem *problem_ptr) + * } + */ + public static void cuOptDestroyProblem(MemorySegment problem_ptr) { + var mh$ = cuOptDestroyProblem.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptDestroyProblem", problem_ptr); + } + mh$.invokeExact(problem_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetNumConstraints { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetNumConstraints"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetNumConstraints(cuOptOptimizationProblem problem, cuopt_int_t *num_constraints_ptr) + * } + */ + public static FunctionDescriptor cuOptGetNumConstraints$descriptor() { + return cuOptGetNumConstraints.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetNumConstraints(cuOptOptimizationProblem problem, cuopt_int_t *num_constraints_ptr) + * } + */ + public static MethodHandle cuOptGetNumConstraints$handle() { + return cuOptGetNumConstraints.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetNumConstraints(cuOptOptimizationProblem problem, cuopt_int_t *num_constraints_ptr) + * } + */ + public static MemorySegment cuOptGetNumConstraints$address() { + return cuOptGetNumConstraints.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetNumConstraints(cuOptOptimizationProblem problem, cuopt_int_t *num_constraints_ptr) + * } + */ + public static int cuOptGetNumConstraints(MemorySegment problem, MemorySegment num_constraints_ptr) { + var mh$ = cuOptGetNumConstraints.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetNumConstraints", problem, num_constraints_ptr); + } + return (int)mh$.invokeExact(problem, num_constraints_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetNumVariables { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetNumVariables"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetNumVariables(cuOptOptimizationProblem problem, cuopt_int_t *num_variables_ptr) + * } + */ + public static FunctionDescriptor cuOptGetNumVariables$descriptor() { + return cuOptGetNumVariables.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetNumVariables(cuOptOptimizationProblem problem, cuopt_int_t *num_variables_ptr) + * } + */ + public static MethodHandle cuOptGetNumVariables$handle() { + return cuOptGetNumVariables.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetNumVariables(cuOptOptimizationProblem problem, cuopt_int_t *num_variables_ptr) + * } + */ + public static MemorySegment cuOptGetNumVariables$address() { + return cuOptGetNumVariables.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetNumVariables(cuOptOptimizationProblem problem, cuopt_int_t *num_variables_ptr) + * } + */ + public static int cuOptGetNumVariables(MemorySegment problem, MemorySegment num_variables_ptr) { + var mh$ = cuOptGetNumVariables.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetNumVariables", problem, num_variables_ptr); + } + return (int)mh$.invokeExact(problem, num_variables_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetObjectiveSense { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetObjectiveSense"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveSense(cuOptOptimizationProblem problem, cuopt_int_t *objective_sense_ptr) + * } + */ + public static FunctionDescriptor cuOptGetObjectiveSense$descriptor() { + return cuOptGetObjectiveSense.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveSense(cuOptOptimizationProblem problem, cuopt_int_t *objective_sense_ptr) + * } + */ + public static MethodHandle cuOptGetObjectiveSense$handle() { + return cuOptGetObjectiveSense.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveSense(cuOptOptimizationProblem problem, cuopt_int_t *objective_sense_ptr) + * } + */ + public static MemorySegment cuOptGetObjectiveSense$address() { + return cuOptGetObjectiveSense.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveSense(cuOptOptimizationProblem problem, cuopt_int_t *objective_sense_ptr) + * } + */ + public static int cuOptGetObjectiveSense(MemorySegment problem, MemorySegment objective_sense_ptr) { + var mh$ = cuOptGetObjectiveSense.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetObjectiveSense", problem, objective_sense_ptr); + } + return (int)mh$.invokeExact(problem, objective_sense_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetObjectiveOffset { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetObjectiveOffset"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveOffset(cuOptOptimizationProblem problem, cuopt_float_t *objective_offset_ptr) + * } + */ + public static FunctionDescriptor cuOptGetObjectiveOffset$descriptor() { + return cuOptGetObjectiveOffset.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveOffset(cuOptOptimizationProblem problem, cuopt_float_t *objective_offset_ptr) + * } + */ + public static MethodHandle cuOptGetObjectiveOffset$handle() { + return cuOptGetObjectiveOffset.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveOffset(cuOptOptimizationProblem problem, cuopt_float_t *objective_offset_ptr) + * } + */ + public static MemorySegment cuOptGetObjectiveOffset$address() { + return cuOptGetObjectiveOffset.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveOffset(cuOptOptimizationProblem problem, cuopt_float_t *objective_offset_ptr) + * } + */ + public static int cuOptGetObjectiveOffset(MemorySegment problem, MemorySegment objective_offset_ptr) { + var mh$ = cuOptGetObjectiveOffset.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetObjectiveOffset", problem, objective_offset_ptr); + } + return (int)mh$.invokeExact(problem, objective_offset_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetObjectiveCoefficients { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetObjectiveCoefficients"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveCoefficients(cuOptOptimizationProblem problem, cuopt_float_t *objective_coefficients_ptr) + * } + */ + public static FunctionDescriptor cuOptGetObjectiveCoefficients$descriptor() { + return cuOptGetObjectiveCoefficients.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveCoefficients(cuOptOptimizationProblem problem, cuopt_float_t *objective_coefficients_ptr) + * } + */ + public static MethodHandle cuOptGetObjectiveCoefficients$handle() { + return cuOptGetObjectiveCoefficients.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveCoefficients(cuOptOptimizationProblem problem, cuopt_float_t *objective_coefficients_ptr) + * } + */ + public static MemorySegment cuOptGetObjectiveCoefficients$address() { + return cuOptGetObjectiveCoefficients.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveCoefficients(cuOptOptimizationProblem problem, cuopt_float_t *objective_coefficients_ptr) + * } + */ + public static int cuOptGetObjectiveCoefficients(MemorySegment problem, MemorySegment objective_coefficients_ptr) { + var mh$ = cuOptGetObjectiveCoefficients.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetObjectiveCoefficients", problem, objective_coefficients_ptr); + } + return (int)mh$.invokeExact(problem, objective_coefficients_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetNumNonZeros { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetNumNonZeros"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetNumNonZeros(cuOptOptimizationProblem problem, cuopt_int_t *num_non_zeros_ptr) + * } + */ + public static FunctionDescriptor cuOptGetNumNonZeros$descriptor() { + return cuOptGetNumNonZeros.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetNumNonZeros(cuOptOptimizationProblem problem, cuopt_int_t *num_non_zeros_ptr) + * } + */ + public static MethodHandle cuOptGetNumNonZeros$handle() { + return cuOptGetNumNonZeros.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetNumNonZeros(cuOptOptimizationProblem problem, cuopt_int_t *num_non_zeros_ptr) + * } + */ + public static MemorySegment cuOptGetNumNonZeros$address() { + return cuOptGetNumNonZeros.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetNumNonZeros(cuOptOptimizationProblem problem, cuopt_int_t *num_non_zeros_ptr) + * } + */ + public static int cuOptGetNumNonZeros(MemorySegment problem, MemorySegment num_non_zeros_ptr) { + var mh$ = cuOptGetNumNonZeros.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetNumNonZeros", problem, num_non_zeros_ptr); + } + return (int)mh$.invokeExact(problem, num_non_zeros_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetConstraintMatrix { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetConstraintMatrix"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintMatrix(cuOptOptimizationProblem problem, cuopt_int_t *constraint_matrix_row_offsets_ptr, cuopt_int_t *constraint_matrix_column_indices_ptr, cuopt_float_t *constraint_matrix_coefficients_ptr) + * } + */ + public static FunctionDescriptor cuOptGetConstraintMatrix$descriptor() { + return cuOptGetConstraintMatrix.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintMatrix(cuOptOptimizationProblem problem, cuopt_int_t *constraint_matrix_row_offsets_ptr, cuopt_int_t *constraint_matrix_column_indices_ptr, cuopt_float_t *constraint_matrix_coefficients_ptr) + * } + */ + public static MethodHandle cuOptGetConstraintMatrix$handle() { + return cuOptGetConstraintMatrix.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintMatrix(cuOptOptimizationProblem problem, cuopt_int_t *constraint_matrix_row_offsets_ptr, cuopt_int_t *constraint_matrix_column_indices_ptr, cuopt_float_t *constraint_matrix_coefficients_ptr) + * } + */ + public static MemorySegment cuOptGetConstraintMatrix$address() { + return cuOptGetConstraintMatrix.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintMatrix(cuOptOptimizationProblem problem, cuopt_int_t *constraint_matrix_row_offsets_ptr, cuopt_int_t *constraint_matrix_column_indices_ptr, cuopt_float_t *constraint_matrix_coefficients_ptr) + * } + */ + public static int cuOptGetConstraintMatrix(MemorySegment problem, MemorySegment constraint_matrix_row_offsets_ptr, MemorySegment constraint_matrix_column_indices_ptr, MemorySegment constraint_matrix_coefficients_ptr) { + var mh$ = cuOptGetConstraintMatrix.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetConstraintMatrix", problem, constraint_matrix_row_offsets_ptr, constraint_matrix_column_indices_ptr, constraint_matrix_coefficients_ptr); + } + return (int)mh$.invokeExact(problem, constraint_matrix_row_offsets_ptr, constraint_matrix_column_indices_ptr, constraint_matrix_coefficients_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetConstraintSense { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetConstraintSense"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintSense(cuOptOptimizationProblem problem, char *constraint_sense_ptr) + * } + */ + public static FunctionDescriptor cuOptGetConstraintSense$descriptor() { + return cuOptGetConstraintSense.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintSense(cuOptOptimizationProblem problem, char *constraint_sense_ptr) + * } + */ + public static MethodHandle cuOptGetConstraintSense$handle() { + return cuOptGetConstraintSense.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintSense(cuOptOptimizationProblem problem, char *constraint_sense_ptr) + * } + */ + public static MemorySegment cuOptGetConstraintSense$address() { + return cuOptGetConstraintSense.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintSense(cuOptOptimizationProblem problem, char *constraint_sense_ptr) + * } + */ + public static int cuOptGetConstraintSense(MemorySegment problem, MemorySegment constraint_sense_ptr) { + var mh$ = cuOptGetConstraintSense.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetConstraintSense", problem, constraint_sense_ptr); + } + return (int)mh$.invokeExact(problem, constraint_sense_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetConstraintRightHandSide { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetConstraintRightHandSide"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintRightHandSide(cuOptOptimizationProblem problem, cuopt_float_t *rhs_ptr) + * } + */ + public static FunctionDescriptor cuOptGetConstraintRightHandSide$descriptor() { + return cuOptGetConstraintRightHandSide.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintRightHandSide(cuOptOptimizationProblem problem, cuopt_float_t *rhs_ptr) + * } + */ + public static MethodHandle cuOptGetConstraintRightHandSide$handle() { + return cuOptGetConstraintRightHandSide.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintRightHandSide(cuOptOptimizationProblem problem, cuopt_float_t *rhs_ptr) + * } + */ + public static MemorySegment cuOptGetConstraintRightHandSide$address() { + return cuOptGetConstraintRightHandSide.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintRightHandSide(cuOptOptimizationProblem problem, cuopt_float_t *rhs_ptr) + * } + */ + public static int cuOptGetConstraintRightHandSide(MemorySegment problem, MemorySegment rhs_ptr) { + var mh$ = cuOptGetConstraintRightHandSide.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetConstraintRightHandSide", problem, rhs_ptr); + } + return (int)mh$.invokeExact(problem, rhs_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetConstraintLowerBounds { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetConstraintLowerBounds"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintLowerBounds(cuOptOptimizationProblem problem, cuopt_float_t *lower_bounds_ptr) + * } + */ + public static FunctionDescriptor cuOptGetConstraintLowerBounds$descriptor() { + return cuOptGetConstraintLowerBounds.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintLowerBounds(cuOptOptimizationProblem problem, cuopt_float_t *lower_bounds_ptr) + * } + */ + public static MethodHandle cuOptGetConstraintLowerBounds$handle() { + return cuOptGetConstraintLowerBounds.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintLowerBounds(cuOptOptimizationProblem problem, cuopt_float_t *lower_bounds_ptr) + * } + */ + public static MemorySegment cuOptGetConstraintLowerBounds$address() { + return cuOptGetConstraintLowerBounds.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintLowerBounds(cuOptOptimizationProblem problem, cuopt_float_t *lower_bounds_ptr) + * } + */ + public static int cuOptGetConstraintLowerBounds(MemorySegment problem, MemorySegment lower_bounds_ptr) { + var mh$ = cuOptGetConstraintLowerBounds.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetConstraintLowerBounds", problem, lower_bounds_ptr); + } + return (int)mh$.invokeExact(problem, lower_bounds_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetConstraintUpperBounds { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetConstraintUpperBounds"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintUpperBounds(cuOptOptimizationProblem problem, cuopt_float_t *upper_bounds_ptr) + * } + */ + public static FunctionDescriptor cuOptGetConstraintUpperBounds$descriptor() { + return cuOptGetConstraintUpperBounds.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintUpperBounds(cuOptOptimizationProblem problem, cuopt_float_t *upper_bounds_ptr) + * } + */ + public static MethodHandle cuOptGetConstraintUpperBounds$handle() { + return cuOptGetConstraintUpperBounds.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintUpperBounds(cuOptOptimizationProblem problem, cuopt_float_t *upper_bounds_ptr) + * } + */ + public static MemorySegment cuOptGetConstraintUpperBounds$address() { + return cuOptGetConstraintUpperBounds.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetConstraintUpperBounds(cuOptOptimizationProblem problem, cuopt_float_t *upper_bounds_ptr) + * } + */ + public static int cuOptGetConstraintUpperBounds(MemorySegment problem, MemorySegment upper_bounds_ptr) { + var mh$ = cuOptGetConstraintUpperBounds.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetConstraintUpperBounds", problem, upper_bounds_ptr); + } + return (int)mh$.invokeExact(problem, upper_bounds_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetVariableLowerBounds { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetVariableLowerBounds"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetVariableLowerBounds(cuOptOptimizationProblem problem, cuopt_float_t *lower_bounds_ptr) + * } + */ + public static FunctionDescriptor cuOptGetVariableLowerBounds$descriptor() { + return cuOptGetVariableLowerBounds.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetVariableLowerBounds(cuOptOptimizationProblem problem, cuopt_float_t *lower_bounds_ptr) + * } + */ + public static MethodHandle cuOptGetVariableLowerBounds$handle() { + return cuOptGetVariableLowerBounds.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetVariableLowerBounds(cuOptOptimizationProblem problem, cuopt_float_t *lower_bounds_ptr) + * } + */ + public static MemorySegment cuOptGetVariableLowerBounds$address() { + return cuOptGetVariableLowerBounds.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetVariableLowerBounds(cuOptOptimizationProblem problem, cuopt_float_t *lower_bounds_ptr) + * } + */ + public static int cuOptGetVariableLowerBounds(MemorySegment problem, MemorySegment lower_bounds_ptr) { + var mh$ = cuOptGetVariableLowerBounds.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetVariableLowerBounds", problem, lower_bounds_ptr); + } + return (int)mh$.invokeExact(problem, lower_bounds_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetVariableUpperBounds { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetVariableUpperBounds"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetVariableUpperBounds(cuOptOptimizationProblem problem, cuopt_float_t *upper_bounds_ptr) + * } + */ + public static FunctionDescriptor cuOptGetVariableUpperBounds$descriptor() { + return cuOptGetVariableUpperBounds.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetVariableUpperBounds(cuOptOptimizationProblem problem, cuopt_float_t *upper_bounds_ptr) + * } + */ + public static MethodHandle cuOptGetVariableUpperBounds$handle() { + return cuOptGetVariableUpperBounds.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetVariableUpperBounds(cuOptOptimizationProblem problem, cuopt_float_t *upper_bounds_ptr) + * } + */ + public static MemorySegment cuOptGetVariableUpperBounds$address() { + return cuOptGetVariableUpperBounds.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetVariableUpperBounds(cuOptOptimizationProblem problem, cuopt_float_t *upper_bounds_ptr) + * } + */ + public static int cuOptGetVariableUpperBounds(MemorySegment problem, MemorySegment upper_bounds_ptr) { + var mh$ = cuOptGetVariableUpperBounds.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetVariableUpperBounds", problem, upper_bounds_ptr); + } + return (int)mh$.invokeExact(problem, upper_bounds_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetVariableTypes { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetVariableTypes"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetVariableTypes(cuOptOptimizationProblem problem, char *variable_types_ptr) + * } + */ + public static FunctionDescriptor cuOptGetVariableTypes$descriptor() { + return cuOptGetVariableTypes.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetVariableTypes(cuOptOptimizationProblem problem, char *variable_types_ptr) + * } + */ + public static MethodHandle cuOptGetVariableTypes$handle() { + return cuOptGetVariableTypes.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetVariableTypes(cuOptOptimizationProblem problem, char *variable_types_ptr) + * } + */ + public static MemorySegment cuOptGetVariableTypes$address() { + return cuOptGetVariableTypes.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetVariableTypes(cuOptOptimizationProblem problem, char *variable_types_ptr) + * } + */ + public static int cuOptGetVariableTypes(MemorySegment problem, MemorySegment variable_types_ptr) { + var mh$ = cuOptGetVariableTypes.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetVariableTypes", problem, variable_types_ptr); + } + return (int)mh$.invokeExact(problem, variable_types_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptCreateSolverSettings { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptCreateSolverSettings"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptCreateSolverSettings(cuOptSolverSettings *settings_ptr) + * } + */ + public static FunctionDescriptor cuOptCreateSolverSettings$descriptor() { + return cuOptCreateSolverSettings.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptCreateSolverSettings(cuOptSolverSettings *settings_ptr) + * } + */ + public static MethodHandle cuOptCreateSolverSettings$handle() { + return cuOptCreateSolverSettings.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptCreateSolverSettings(cuOptSolverSettings *settings_ptr) + * } + */ + public static MemorySegment cuOptCreateSolverSettings$address() { + return cuOptCreateSolverSettings.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptCreateSolverSettings(cuOptSolverSettings *settings_ptr) + * } + */ + public static int cuOptCreateSolverSettings(MemorySegment settings_ptr) { + var mh$ = cuOptCreateSolverSettings.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptCreateSolverSettings", settings_ptr); + } + return (int)mh$.invokeExact(settings_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptDestroySolverSettings { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptDestroySolverSettings"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * void cuOptDestroySolverSettings(cuOptSolverSettings *settings_ptr) + * } + */ + public static FunctionDescriptor cuOptDestroySolverSettings$descriptor() { + return cuOptDestroySolverSettings.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * void cuOptDestroySolverSettings(cuOptSolverSettings *settings_ptr) + * } + */ + public static MethodHandle cuOptDestroySolverSettings$handle() { + return cuOptDestroySolverSettings.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * void cuOptDestroySolverSettings(cuOptSolverSettings *settings_ptr) + * } + */ + public static MemorySegment cuOptDestroySolverSettings$address() { + return cuOptDestroySolverSettings.ADDR; + } + + /** + * {@snippet lang=c : + * void cuOptDestroySolverSettings(cuOptSolverSettings *settings_ptr) + * } + */ + public static void cuOptDestroySolverSettings(MemorySegment settings_ptr) { + var mh$ = cuOptDestroySolverSettings.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptDestroySolverSettings", settings_ptr); + } + mh$.invokeExact(settings_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptSetParameter { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptSetParameter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetParameter(cuOptSolverSettings settings, const char *parameter_name, const char *parameter_value) + * } + */ + public static FunctionDescriptor cuOptSetParameter$descriptor() { + return cuOptSetParameter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetParameter(cuOptSolverSettings settings, const char *parameter_name, const char *parameter_value) + * } + */ + public static MethodHandle cuOptSetParameter$handle() { + return cuOptSetParameter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetParameter(cuOptSolverSettings settings, const char *parameter_name, const char *parameter_value) + * } + */ + public static MemorySegment cuOptSetParameter$address() { + return cuOptSetParameter.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptSetParameter(cuOptSolverSettings settings, const char *parameter_name, const char *parameter_value) + * } + */ + public static int cuOptSetParameter(MemorySegment settings, MemorySegment parameter_name, MemorySegment parameter_value) { + var mh$ = cuOptSetParameter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptSetParameter", settings, parameter_name, parameter_value); + } + return (int)mh$.invokeExact(settings, parameter_name, parameter_value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetParameter { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetParameter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_int_t parameter_value_size, char *parameter_value) + * } + */ + public static FunctionDescriptor cuOptGetParameter$descriptor() { + return cuOptGetParameter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_int_t parameter_value_size, char *parameter_value) + * } + */ + public static MethodHandle cuOptGetParameter$handle() { + return cuOptGetParameter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_int_t parameter_value_size, char *parameter_value) + * } + */ + public static MemorySegment cuOptGetParameter$address() { + return cuOptGetParameter.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_int_t parameter_value_size, char *parameter_value) + * } + */ + public static int cuOptGetParameter(MemorySegment settings, MemorySegment parameter_name, int parameter_value_size, MemorySegment parameter_value) { + var mh$ = cuOptGetParameter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetParameter", settings, parameter_name, parameter_value_size, parameter_value); + } + return (int)mh$.invokeExact(settings, parameter_name, parameter_value_size, parameter_value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptSetIntegerParameter { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_INT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptSetIntegerParameter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetIntegerParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_int_t parameter_value) + * } + */ + public static FunctionDescriptor cuOptSetIntegerParameter$descriptor() { + return cuOptSetIntegerParameter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetIntegerParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_int_t parameter_value) + * } + */ + public static MethodHandle cuOptSetIntegerParameter$handle() { + return cuOptSetIntegerParameter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetIntegerParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_int_t parameter_value) + * } + */ + public static MemorySegment cuOptSetIntegerParameter$address() { + return cuOptSetIntegerParameter.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptSetIntegerParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_int_t parameter_value) + * } + */ + public static int cuOptSetIntegerParameter(MemorySegment settings, MemorySegment parameter_name, int parameter_value) { + var mh$ = cuOptSetIntegerParameter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptSetIntegerParameter", settings, parameter_name, parameter_value); + } + return (int)mh$.invokeExact(settings, parameter_name, parameter_value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetIntegerParameter { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetIntegerParameter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetIntegerParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_int_t *parameter_value) + * } + */ + public static FunctionDescriptor cuOptGetIntegerParameter$descriptor() { + return cuOptGetIntegerParameter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetIntegerParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_int_t *parameter_value) + * } + */ + public static MethodHandle cuOptGetIntegerParameter$handle() { + return cuOptGetIntegerParameter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetIntegerParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_int_t *parameter_value) + * } + */ + public static MemorySegment cuOptGetIntegerParameter$address() { + return cuOptGetIntegerParameter.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetIntegerParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_int_t *parameter_value) + * } + */ + public static int cuOptGetIntegerParameter(MemorySegment settings, MemorySegment parameter_name, MemorySegment parameter_value) { + var mh$ = cuOptGetIntegerParameter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetIntegerParameter", settings, parameter_name, parameter_value); + } + return (int)mh$.invokeExact(settings, parameter_name, parameter_value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptSetFloatParameter { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_DOUBLE + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptSetFloatParameter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetFloatParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_float_t parameter_value) + * } + */ + public static FunctionDescriptor cuOptSetFloatParameter$descriptor() { + return cuOptSetFloatParameter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetFloatParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_float_t parameter_value) + * } + */ + public static MethodHandle cuOptSetFloatParameter$handle() { + return cuOptSetFloatParameter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetFloatParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_float_t parameter_value) + * } + */ + public static MemorySegment cuOptSetFloatParameter$address() { + return cuOptSetFloatParameter.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptSetFloatParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_float_t parameter_value) + * } + */ + public static int cuOptSetFloatParameter(MemorySegment settings, MemorySegment parameter_name, double parameter_value) { + var mh$ = cuOptSetFloatParameter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptSetFloatParameter", settings, parameter_name, parameter_value); + } + return (int)mh$.invokeExact(settings, parameter_name, parameter_value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetFloatParameter { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetFloatParameter"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetFloatParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_float_t *parameter_value) + * } + */ + public static FunctionDescriptor cuOptGetFloatParameter$descriptor() { + return cuOptGetFloatParameter.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetFloatParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_float_t *parameter_value) + * } + */ + public static MethodHandle cuOptGetFloatParameter$handle() { + return cuOptGetFloatParameter.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetFloatParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_float_t *parameter_value) + * } + */ + public static MemorySegment cuOptGetFloatParameter$address() { + return cuOptGetFloatParameter.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetFloatParameter(cuOptSolverSettings settings, const char *parameter_name, cuopt_float_t *parameter_value) + * } + */ + public static int cuOptGetFloatParameter(MemorySegment settings, MemorySegment parameter_name, MemorySegment parameter_value) { + var mh$ = cuOptGetFloatParameter.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetFloatParameter", settings, parameter_name, parameter_value); + } + return (int)mh$.invokeExact(settings, parameter_name, parameter_value); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptSetMIPGetSolutionCallback { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptSetMIPGetSolutionCallback"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetMIPGetSolutionCallback(cuOptSolverSettings settings, cuOptMIPGetSolutionCallback callback, void *user_data) + * } + */ + public static FunctionDescriptor cuOptSetMIPGetSolutionCallback$descriptor() { + return cuOptSetMIPGetSolutionCallback.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetMIPGetSolutionCallback(cuOptSolverSettings settings, cuOptMIPGetSolutionCallback callback, void *user_data) + * } + */ + public static MethodHandle cuOptSetMIPGetSolutionCallback$handle() { + return cuOptSetMIPGetSolutionCallback.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetMIPGetSolutionCallback(cuOptSolverSettings settings, cuOptMIPGetSolutionCallback callback, void *user_data) + * } + */ + public static MemorySegment cuOptSetMIPGetSolutionCallback$address() { + return cuOptSetMIPGetSolutionCallback.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptSetMIPGetSolutionCallback(cuOptSolverSettings settings, cuOptMIPGetSolutionCallback callback, void *user_data) + * } + */ + public static int cuOptSetMIPGetSolutionCallback(MemorySegment settings, MemorySegment callback, MemorySegment user_data) { + var mh$ = cuOptSetMIPGetSolutionCallback.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptSetMIPGetSolutionCallback", settings, callback, user_data); + } + return (int)mh$.invokeExact(settings, callback, user_data); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptSetMIPSetSolutionCallback { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptSetMIPSetSolutionCallback"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetMIPSetSolutionCallback(cuOptSolverSettings settings, cuOptMIPSetSolutionCallback callback, void *user_data) + * } + */ + public static FunctionDescriptor cuOptSetMIPSetSolutionCallback$descriptor() { + return cuOptSetMIPSetSolutionCallback.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetMIPSetSolutionCallback(cuOptSolverSettings settings, cuOptMIPSetSolutionCallback callback, void *user_data) + * } + */ + public static MethodHandle cuOptSetMIPSetSolutionCallback$handle() { + return cuOptSetMIPSetSolutionCallback.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetMIPSetSolutionCallback(cuOptSolverSettings settings, cuOptMIPSetSolutionCallback callback, void *user_data) + * } + */ + public static MemorySegment cuOptSetMIPSetSolutionCallback$address() { + return cuOptSetMIPSetSolutionCallback.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptSetMIPSetSolutionCallback(cuOptSolverSettings settings, cuOptMIPSetSolutionCallback callback, void *user_data) + * } + */ + public static int cuOptSetMIPSetSolutionCallback(MemorySegment settings, MemorySegment callback, MemorySegment user_data) { + var mh$ = cuOptSetMIPSetSolutionCallback.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptSetMIPSetSolutionCallback", settings, callback, user_data); + } + return (int)mh$.invokeExact(settings, callback, user_data); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptSetInitialPrimalSolution { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_INT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptSetInitialPrimalSolution"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetInitialPrimalSolution(cuOptSolverSettings settings, const cuopt_float_t *primal_solution, cuopt_int_t num_variables) + * } + */ + public static FunctionDescriptor cuOptSetInitialPrimalSolution$descriptor() { + return cuOptSetInitialPrimalSolution.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetInitialPrimalSolution(cuOptSolverSettings settings, const cuopt_float_t *primal_solution, cuopt_int_t num_variables) + * } + */ + public static MethodHandle cuOptSetInitialPrimalSolution$handle() { + return cuOptSetInitialPrimalSolution.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetInitialPrimalSolution(cuOptSolverSettings settings, const cuopt_float_t *primal_solution, cuopt_int_t num_variables) + * } + */ + public static MemorySegment cuOptSetInitialPrimalSolution$address() { + return cuOptSetInitialPrimalSolution.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptSetInitialPrimalSolution(cuOptSolverSettings settings, const cuopt_float_t *primal_solution, cuopt_int_t num_variables) + * } + */ + public static int cuOptSetInitialPrimalSolution(MemorySegment settings, MemorySegment primal_solution, int num_variables) { + var mh$ = cuOptSetInitialPrimalSolution.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptSetInitialPrimalSolution", settings, primal_solution, num_variables); + } + return (int)mh$.invokeExact(settings, primal_solution, num_variables); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptSetInitialDualSolution { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_INT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptSetInitialDualSolution"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetInitialDualSolution(cuOptSolverSettings settings, const cuopt_float_t *dual_solution, cuopt_int_t num_constraints) + * } + */ + public static FunctionDescriptor cuOptSetInitialDualSolution$descriptor() { + return cuOptSetInitialDualSolution.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetInitialDualSolution(cuOptSolverSettings settings, const cuopt_float_t *dual_solution, cuopt_int_t num_constraints) + * } + */ + public static MethodHandle cuOptSetInitialDualSolution$handle() { + return cuOptSetInitialDualSolution.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptSetInitialDualSolution(cuOptSolverSettings settings, const cuopt_float_t *dual_solution, cuopt_int_t num_constraints) + * } + */ + public static MemorySegment cuOptSetInitialDualSolution$address() { + return cuOptSetInitialDualSolution.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptSetInitialDualSolution(cuOptSolverSettings settings, const cuopt_float_t *dual_solution, cuopt_int_t num_constraints) + * } + */ + public static int cuOptSetInitialDualSolution(MemorySegment settings, MemorySegment dual_solution, int num_constraints) { + var mh$ = cuOptSetInitialDualSolution.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptSetInitialDualSolution", settings, dual_solution, num_constraints); + } + return (int)mh$.invokeExact(settings, dual_solution, num_constraints); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptAddMIPStart { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_INT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptAddMIPStart"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptAddMIPStart(cuOptSolverSettings settings, const cuopt_float_t *solution, cuopt_int_t num_variables) + * } + */ + public static FunctionDescriptor cuOptAddMIPStart$descriptor() { + return cuOptAddMIPStart.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptAddMIPStart(cuOptSolverSettings settings, const cuopt_float_t *solution, cuopt_int_t num_variables) + * } + */ + public static MethodHandle cuOptAddMIPStart$handle() { + return cuOptAddMIPStart.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptAddMIPStart(cuOptSolverSettings settings, const cuopt_float_t *solution, cuopt_int_t num_variables) + * } + */ + public static MemorySegment cuOptAddMIPStart$address() { + return cuOptAddMIPStart.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptAddMIPStart(cuOptSolverSettings settings, const cuopt_float_t *solution, cuopt_int_t num_variables) + * } + */ + public static int cuOptAddMIPStart(MemorySegment settings, MemorySegment solution, int num_variables) { + var mh$ = cuOptAddMIPStart.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptAddMIPStart", settings, solution, num_variables); + } + return (int)mh$.invokeExact(settings, solution, num_variables); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptIsMIP { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptIsMIP"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptIsMIP(cuOptOptimizationProblem problem, cuopt_int_t *is_mip_ptr) + * } + */ + public static FunctionDescriptor cuOptIsMIP$descriptor() { + return cuOptIsMIP.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptIsMIP(cuOptOptimizationProblem problem, cuopt_int_t *is_mip_ptr) + * } + */ + public static MethodHandle cuOptIsMIP$handle() { + return cuOptIsMIP.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptIsMIP(cuOptOptimizationProblem problem, cuopt_int_t *is_mip_ptr) + * } + */ + public static MemorySegment cuOptIsMIP$address() { + return cuOptIsMIP.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptIsMIP(cuOptOptimizationProblem problem, cuopt_int_t *is_mip_ptr) + * } + */ + public static int cuOptIsMIP(MemorySegment problem, MemorySegment is_mip_ptr) { + var mh$ = cuOptIsMIP.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptIsMIP", problem, is_mip_ptr); + } + return (int)mh$.invokeExact(problem, is_mip_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptSolve { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptSolve"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptSolve(cuOptOptimizationProblem problem, cuOptSolverSettings settings, cuOptSolution *solution_ptr) + * } + */ + public static FunctionDescriptor cuOptSolve$descriptor() { + return cuOptSolve.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptSolve(cuOptOptimizationProblem problem, cuOptSolverSettings settings, cuOptSolution *solution_ptr) + * } + */ + public static MethodHandle cuOptSolve$handle() { + return cuOptSolve.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptSolve(cuOptOptimizationProblem problem, cuOptSolverSettings settings, cuOptSolution *solution_ptr) + * } + */ + public static MemorySegment cuOptSolve$address() { + return cuOptSolve.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptSolve(cuOptOptimizationProblem problem, cuOptSolverSettings settings, cuOptSolution *solution_ptr) + * } + */ + public static int cuOptSolve(MemorySegment problem, MemorySegment settings, MemorySegment solution_ptr) { + var mh$ = cuOptSolve.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptSolve", problem, settings, solution_ptr); + } + return (int)mh$.invokeExact(problem, settings, solution_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptDestroySolution { + public static final FunctionDescriptor DESC = FunctionDescriptor.ofVoid( + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptDestroySolution"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * void cuOptDestroySolution(cuOptSolution *solution_ptr) + * } + */ + public static FunctionDescriptor cuOptDestroySolution$descriptor() { + return cuOptDestroySolution.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * void cuOptDestroySolution(cuOptSolution *solution_ptr) + * } + */ + public static MethodHandle cuOptDestroySolution$handle() { + return cuOptDestroySolution.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * void cuOptDestroySolution(cuOptSolution *solution_ptr) + * } + */ + public static MemorySegment cuOptDestroySolution$address() { + return cuOptDestroySolution.ADDR; + } + + /** + * {@snippet lang=c : + * void cuOptDestroySolution(cuOptSolution *solution_ptr) + * } + */ + public static void cuOptDestroySolution(MemorySegment solution_ptr) { + var mh$ = cuOptDestroySolution.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptDestroySolution", solution_ptr); + } + mh$.invokeExact(solution_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetTerminationStatus { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetTerminationStatus"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetTerminationStatus(cuOptSolution solution, cuopt_int_t *termination_status_ptr) + * } + */ + public static FunctionDescriptor cuOptGetTerminationStatus$descriptor() { + return cuOptGetTerminationStatus.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetTerminationStatus(cuOptSolution solution, cuopt_int_t *termination_status_ptr) + * } + */ + public static MethodHandle cuOptGetTerminationStatus$handle() { + return cuOptGetTerminationStatus.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetTerminationStatus(cuOptSolution solution, cuopt_int_t *termination_status_ptr) + * } + */ + public static MemorySegment cuOptGetTerminationStatus$address() { + return cuOptGetTerminationStatus.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetTerminationStatus(cuOptSolution solution, cuopt_int_t *termination_status_ptr) + * } + */ + public static int cuOptGetTerminationStatus(MemorySegment solution, MemorySegment termination_status_ptr) { + var mh$ = cuOptGetTerminationStatus.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetTerminationStatus", solution, termination_status_ptr); + } + return (int)mh$.invokeExact(solution, termination_status_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetErrorStatus { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetErrorStatus"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetErrorStatus(cuOptSolution solution, cuopt_int_t *error_status_ptr) + * } + */ + public static FunctionDescriptor cuOptGetErrorStatus$descriptor() { + return cuOptGetErrorStatus.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetErrorStatus(cuOptSolution solution, cuopt_int_t *error_status_ptr) + * } + */ + public static MethodHandle cuOptGetErrorStatus$handle() { + return cuOptGetErrorStatus.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetErrorStatus(cuOptSolution solution, cuopt_int_t *error_status_ptr) + * } + */ + public static MemorySegment cuOptGetErrorStatus$address() { + return cuOptGetErrorStatus.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetErrorStatus(cuOptSolution solution, cuopt_int_t *error_status_ptr) + * } + */ + public static int cuOptGetErrorStatus(MemorySegment solution, MemorySegment error_status_ptr) { + var mh$ = cuOptGetErrorStatus.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetErrorStatus", solution, error_status_ptr); + } + return (int)mh$.invokeExact(solution, error_status_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetErrorString { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_INT + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetErrorString"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetErrorString(cuOptSolution solution, char *error_string_ptr, cuopt_int_t error_string_size) + * } + */ + public static FunctionDescriptor cuOptGetErrorString$descriptor() { + return cuOptGetErrorString.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetErrorString(cuOptSolution solution, char *error_string_ptr, cuopt_int_t error_string_size) + * } + */ + public static MethodHandle cuOptGetErrorString$handle() { + return cuOptGetErrorString.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetErrorString(cuOptSolution solution, char *error_string_ptr, cuopt_int_t error_string_size) + * } + */ + public static MemorySegment cuOptGetErrorString$address() { + return cuOptGetErrorString.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetErrorString(cuOptSolution solution, char *error_string_ptr, cuopt_int_t error_string_size) + * } + */ + public static int cuOptGetErrorString(MemorySegment solution, MemorySegment error_string_ptr, int error_string_size) { + var mh$ = cuOptGetErrorString.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetErrorString", solution, error_string_ptr, error_string_size); + } + return (int)mh$.invokeExact(solution, error_string_ptr, error_string_size); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetPrimalSolution { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetPrimalSolution"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetPrimalSolution(cuOptSolution solution, cuopt_float_t *solution_values) + * } + */ + public static FunctionDescriptor cuOptGetPrimalSolution$descriptor() { + return cuOptGetPrimalSolution.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetPrimalSolution(cuOptSolution solution, cuopt_float_t *solution_values) + * } + */ + public static MethodHandle cuOptGetPrimalSolution$handle() { + return cuOptGetPrimalSolution.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetPrimalSolution(cuOptSolution solution, cuopt_float_t *solution_values) + * } + */ + public static MemorySegment cuOptGetPrimalSolution$address() { + return cuOptGetPrimalSolution.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetPrimalSolution(cuOptSolution solution, cuopt_float_t *solution_values) + * } + */ + public static int cuOptGetPrimalSolution(MemorySegment solution, MemorySegment solution_values) { + var mh$ = cuOptGetPrimalSolution.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetPrimalSolution", solution, solution_values); + } + return (int)mh$.invokeExact(solution, solution_values); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetObjectiveValue { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetObjectiveValue"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveValue(cuOptSolution solution, cuopt_float_t *objective_value_ptr) + * } + */ + public static FunctionDescriptor cuOptGetObjectiveValue$descriptor() { + return cuOptGetObjectiveValue.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveValue(cuOptSolution solution, cuopt_float_t *objective_value_ptr) + * } + */ + public static MethodHandle cuOptGetObjectiveValue$handle() { + return cuOptGetObjectiveValue.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveValue(cuOptSolution solution, cuopt_float_t *objective_value_ptr) + * } + */ + public static MemorySegment cuOptGetObjectiveValue$address() { + return cuOptGetObjectiveValue.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetObjectiveValue(cuOptSolution solution, cuopt_float_t *objective_value_ptr) + * } + */ + public static int cuOptGetObjectiveValue(MemorySegment solution, MemorySegment objective_value_ptr) { + var mh$ = cuOptGetObjectiveValue.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetObjectiveValue", solution, objective_value_ptr); + } + return (int)mh$.invokeExact(solution, objective_value_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetSolveTime { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetSolveTime"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetSolveTime(cuOptSolution solution, cuopt_float_t *solve_time_ptr) + * } + */ + public static FunctionDescriptor cuOptGetSolveTime$descriptor() { + return cuOptGetSolveTime.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetSolveTime(cuOptSolution solution, cuopt_float_t *solve_time_ptr) + * } + */ + public static MethodHandle cuOptGetSolveTime$handle() { + return cuOptGetSolveTime.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetSolveTime(cuOptSolution solution, cuopt_float_t *solve_time_ptr) + * } + */ + public static MemorySegment cuOptGetSolveTime$address() { + return cuOptGetSolveTime.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetSolveTime(cuOptSolution solution, cuopt_float_t *solve_time_ptr) + * } + */ + public static int cuOptGetSolveTime(MemorySegment solution, MemorySegment solve_time_ptr) { + var mh$ = cuOptGetSolveTime.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetSolveTime", solution, solve_time_ptr); + } + return (int)mh$.invokeExact(solution, solve_time_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetMIPGap { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetMIPGap"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetMIPGap(cuOptSolution solution, cuopt_float_t *mip_gap_ptr) + * } + */ + public static FunctionDescriptor cuOptGetMIPGap$descriptor() { + return cuOptGetMIPGap.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetMIPGap(cuOptSolution solution, cuopt_float_t *mip_gap_ptr) + * } + */ + public static MethodHandle cuOptGetMIPGap$handle() { + return cuOptGetMIPGap.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetMIPGap(cuOptSolution solution, cuopt_float_t *mip_gap_ptr) + * } + */ + public static MemorySegment cuOptGetMIPGap$address() { + return cuOptGetMIPGap.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetMIPGap(cuOptSolution solution, cuopt_float_t *mip_gap_ptr) + * } + */ + public static int cuOptGetMIPGap(MemorySegment solution, MemorySegment mip_gap_ptr) { + var mh$ = cuOptGetMIPGap.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetMIPGap", solution, mip_gap_ptr); + } + return (int)mh$.invokeExact(solution, mip_gap_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetSolutionBound { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetSolutionBound"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetSolutionBound(cuOptSolution solution, cuopt_float_t *solution_bound_ptr) + * } + */ + public static FunctionDescriptor cuOptGetSolutionBound$descriptor() { + return cuOptGetSolutionBound.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetSolutionBound(cuOptSolution solution, cuopt_float_t *solution_bound_ptr) + * } + */ + public static MethodHandle cuOptGetSolutionBound$handle() { + return cuOptGetSolutionBound.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetSolutionBound(cuOptSolution solution, cuopt_float_t *solution_bound_ptr) + * } + */ + public static MemorySegment cuOptGetSolutionBound$address() { + return cuOptGetSolutionBound.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetSolutionBound(cuOptSolution solution, cuopt_float_t *solution_bound_ptr) + * } + */ + public static int cuOptGetSolutionBound(MemorySegment solution, MemorySegment solution_bound_ptr) { + var mh$ = cuOptGetSolutionBound.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetSolutionBound", solution, solution_bound_ptr); + } + return (int)mh$.invokeExact(solution, solution_bound_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetDualSolution { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetDualSolution"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetDualSolution(cuOptSolution solution, cuopt_float_t *dual_solution_ptr) + * } + */ + public static FunctionDescriptor cuOptGetDualSolution$descriptor() { + return cuOptGetDualSolution.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetDualSolution(cuOptSolution solution, cuopt_float_t *dual_solution_ptr) + * } + */ + public static MethodHandle cuOptGetDualSolution$handle() { + return cuOptGetDualSolution.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetDualSolution(cuOptSolution solution, cuopt_float_t *dual_solution_ptr) + * } + */ + public static MemorySegment cuOptGetDualSolution$address() { + return cuOptGetDualSolution.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetDualSolution(cuOptSolution solution, cuopt_float_t *dual_solution_ptr) + * } + */ + public static int cuOptGetDualSolution(MemorySegment solution, MemorySegment dual_solution_ptr) { + var mh$ = cuOptGetDualSolution.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetDualSolution", solution, dual_solution_ptr); + } + return (int)mh$.invokeExact(solution, dual_solution_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetDualObjectiveValue { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetDualObjectiveValue"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetDualObjectiveValue(cuOptSolution solution, cuopt_float_t *dual_objective_value_ptr) + * } + */ + public static FunctionDescriptor cuOptGetDualObjectiveValue$descriptor() { + return cuOptGetDualObjectiveValue.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetDualObjectiveValue(cuOptSolution solution, cuopt_float_t *dual_objective_value_ptr) + * } + */ + public static MethodHandle cuOptGetDualObjectiveValue$handle() { + return cuOptGetDualObjectiveValue.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetDualObjectiveValue(cuOptSolution solution, cuopt_float_t *dual_objective_value_ptr) + * } + */ + public static MemorySegment cuOptGetDualObjectiveValue$address() { + return cuOptGetDualObjectiveValue.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetDualObjectiveValue(cuOptSolution solution, cuopt_float_t *dual_objective_value_ptr) + * } + */ + public static int cuOptGetDualObjectiveValue(MemorySegment solution, MemorySegment dual_objective_value_ptr) { + var mh$ = cuOptGetDualObjectiveValue.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetDualObjectiveValue", solution, dual_objective_value_ptr); + } + return (int)mh$.invokeExact(solution, dual_objective_value_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + + private static class cuOptGetReducedCosts { + public static final FunctionDescriptor DESC = FunctionDescriptor.of( + cuopt_c_h.C_INT, + cuopt_c_h.C_POINTER, + cuopt_c_h.C_POINTER + ); + + public static final MemorySegment ADDR = cuopt_c_h.findOrThrow("cuOptGetReducedCosts"); + + public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC); + } + + /** + * Function descriptor for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetReducedCosts(cuOptSolution solution, cuopt_float_t *reduced_cost_ptr) + * } + */ + public static FunctionDescriptor cuOptGetReducedCosts$descriptor() { + return cuOptGetReducedCosts.DESC; + } + + /** + * Downcall method handle for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetReducedCosts(cuOptSolution solution, cuopt_float_t *reduced_cost_ptr) + * } + */ + public static MethodHandle cuOptGetReducedCosts$handle() { + return cuOptGetReducedCosts.HANDLE; + } + + /** + * Address for: + * {@snippet lang=c : + * cuopt_int_t cuOptGetReducedCosts(cuOptSolution solution, cuopt_float_t *reduced_cost_ptr) + * } + */ + public static MemorySegment cuOptGetReducedCosts$address() { + return cuOptGetReducedCosts.ADDR; + } + + /** + * {@snippet lang=c : + * cuopt_int_t cuOptGetReducedCosts(cuOptSolution solution, cuopt_float_t *reduced_cost_ptr) + * } + */ + public static int cuOptGetReducedCosts(MemorySegment solution, MemorySegment reduced_cost_ptr) { + var mh$ = cuOptGetReducedCosts.HANDLE; + try { + if (TRACE_DOWNCALLS) { + traceDowncall("cuOptGetReducedCosts", solution, reduced_cost_ptr); + } + return (int)mh$.invokeExact(solution, reduced_cost_ptr); + } catch (Throwable ex$) { + throw new AssertionError("should not reach here", ex$); + } + } + private static final long _POSIX_C_SOURCE = 200809L; + /** + * {@snippet lang=c : + * #define _POSIX_C_SOURCE 200809 + * } + */ + public static long _POSIX_C_SOURCE() { + return _POSIX_C_SOURCE; + } + private static final int __TIMESIZE = (int)64L; + /** + * {@snippet lang=c : + * #define __TIMESIZE 64 + * } + */ + public static int __TIMESIZE() { + return __TIMESIZE; + } + private static final long __STDC_IEC_60559_BFP__ = 201404L; + /** + * {@snippet lang=c : + * #define __STDC_IEC_60559_BFP__ 201404 + * } + */ + public static long __STDC_IEC_60559_BFP__() { + return __STDC_IEC_60559_BFP__; + } + private static final long __STDC_IEC_60559_COMPLEX__ = 201404L; + /** + * {@snippet lang=c : + * #define __STDC_IEC_60559_COMPLEX__ 201404 + * } + */ + public static long __STDC_IEC_60559_COMPLEX__() { + return __STDC_IEC_60559_COMPLEX__; + } + private static final long __STDC_ISO_10646__ = 201706L; + /** + * {@snippet lang=c : + * #define __STDC_ISO_10646__ 201706 + * } + */ + public static long __STDC_ISO_10646__() { + return __STDC_ISO_10646__; + } + private static final int __HAVE_DISTINCT_FLOAT16 = (int)0L; + /** + * {@snippet lang=c : + * #define __HAVE_DISTINCT_FLOAT16 0 + * } + */ + public static int __HAVE_DISTINCT_FLOAT16() { + return __HAVE_DISTINCT_FLOAT16; + } + private static final int __HAVE_DISTINCT_FLOAT128X = (int)0L; + /** + * {@snippet lang=c : + * #define __HAVE_DISTINCT_FLOAT128X 0 + * } + */ + public static int __HAVE_DISTINCT_FLOAT128X() { + return __HAVE_DISTINCT_FLOAT128X; + } + private static final int __HAVE_FLOAT128_UNLIKE_LDBL = (int)0L; + /** + * {@snippet lang=c : + * #define __HAVE_FLOAT128_UNLIKE_LDBL 0 + * } + */ + public static int __HAVE_FLOAT128_UNLIKE_LDBL() { + return __HAVE_FLOAT128_UNLIKE_LDBL; + } + private static final double HUGE_VAL = Double.valueOf("Infinity"); + /** + * {@snippet lang=c : + * #define HUGE_VAL Infinity + * } + */ + public static double HUGE_VAL() { + return HUGE_VAL; + } + private static final float HUGE_VALF = Float.valueOf("Infinity"); + /** + * {@snippet lang=c : + * #define HUGE_VALF Infinity + * } + */ + public static float HUGE_VALF() { + return HUGE_VALF; + } + private static final float INFINITY = Float.valueOf("Infinity"); + /** + * {@snippet lang=c : + * #define INFINITY Infinity + * } + */ + public static float INFINITY() { + return INFINITY; + } + private static final float NAN = Float.valueOf("NaN"); + /** + * {@snippet lang=c : + * #define NAN NaN + * } + */ + public static float NAN() { + return NAN; + } + private static final int __GLIBC_FLT_EVAL_METHOD = (int)0L; + /** + * {@snippet lang=c : + * #define __GLIBC_FLT_EVAL_METHOD 0 + * } + */ + public static int __GLIBC_FLT_EVAL_METHOD() { + return __GLIBC_FLT_EVAL_METHOD; + } + private static final int FP_ILOGB0 = (int)-2147483648L; + /** + * {@snippet lang=c : + * #define FP_ILOGB0 -2147483648 + * } + */ + public static int FP_ILOGB0() { + return FP_ILOGB0; + } + private static final int FP_ILOGBNAN = (int)-2147483648L; + /** + * {@snippet lang=c : + * #define FP_ILOGBNAN -2147483648 + * } + */ + public static int FP_ILOGBNAN() { + return FP_ILOGBNAN; + } + private static final int math_errhandling = (int)3L; + /** + * {@snippet lang=c : + * #define math_errhandling 3 + * } + */ + public static int math_errhandling() { + return math_errhandling; + } + private static final double M_E = 2.718281828459045d; + /** + * {@snippet lang=c : + * #define M_E 2.718281828459045 + * } + */ + public static double M_E() { + return M_E; + } + private static final double M_LOG2E = 1.4426950408889634d; + /** + * {@snippet lang=c : + * #define M_LOG2E 1.4426950408889634 + * } + */ + public static double M_LOG2E() { + return M_LOG2E; + } + private static final double M_LOG10E = 0.4342944819032518d; + /** + * {@snippet lang=c : + * #define M_LOG10E 0.4342944819032518 + * } + */ + public static double M_LOG10E() { + return M_LOG10E; + } + private static final double M_LN2 = 0.6931471805599453d; + /** + * {@snippet lang=c : + * #define M_LN2 0.6931471805599453 + * } + */ + public static double M_LN2() { + return M_LN2; + } + private static final double M_LN10 = 2.302585092994046d; + /** + * {@snippet lang=c : + * #define M_LN10 2.302585092994046 + * } + */ + public static double M_LN10() { + return M_LN10; + } + private static final double M_PI = 3.141592653589793d; + /** + * {@snippet lang=c : + * #define M_PI 3.141592653589793 + * } + */ + public static double M_PI() { + return M_PI; + } + private static final double M_PI_2 = 1.5707963267948966d; + /** + * {@snippet lang=c : + * #define M_PI_2 1.5707963267948966 + * } + */ + public static double M_PI_2() { + return M_PI_2; + } + private static final double M_PI_4 = 0.7853981633974483d; + /** + * {@snippet lang=c : + * #define M_PI_4 0.7853981633974483 + * } + */ + public static double M_PI_4() { + return M_PI_4; + } + private static final double M_1_PI = 0.3183098861837907d; + /** + * {@snippet lang=c : + * #define M_1_PI 0.3183098861837907 + * } + */ + public static double M_1_PI() { + return M_1_PI; + } + private static final double M_2_PI = 0.6366197723675814d; + /** + * {@snippet lang=c : + * #define M_2_PI 0.6366197723675814 + * } + */ + public static double M_2_PI() { + return M_2_PI; + } + private static final double M_2_SQRTPI = 1.1283791670955126d; + /** + * {@snippet lang=c : + * #define M_2_SQRTPI 1.1283791670955126 + * } + */ + public static double M_2_SQRTPI() { + return M_2_SQRTPI; + } + private static final double M_SQRT2 = 1.4142135623730951d; + /** + * {@snippet lang=c : + * #define M_SQRT2 1.4142135623730951 + * } + */ + public static double M_SQRT2() { + return M_SQRT2; + } + private static final double M_SQRT1_2 = 0.7071067811865476d; + /** + * {@snippet lang=c : + * #define M_SQRT1_2 0.7071067811865476 + * } + */ + public static double M_SQRT1_2() { + return M_SQRT1_2; + } + /** + * {@snippet lang=c : + * #define CUOPT_ABSOLUTE_DUAL_TOLERANCE "absolute_dual_tolerance" + * } + */ + public static MemorySegment CUOPT_ABSOLUTE_DUAL_TOLERANCE() { + class Holder { + static final MemorySegment CUOPT_ABSOLUTE_DUAL_TOLERANCE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("absolute_dual_tolerance"); + } + return Holder.CUOPT_ABSOLUTE_DUAL_TOLERANCE; + } + /** + * {@snippet lang=c : + * #define CUOPT_RELATIVE_DUAL_TOLERANCE "relative_dual_tolerance" + * } + */ + public static MemorySegment CUOPT_RELATIVE_DUAL_TOLERANCE() { + class Holder { + static final MemorySegment CUOPT_RELATIVE_DUAL_TOLERANCE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("relative_dual_tolerance"); + } + return Holder.CUOPT_RELATIVE_DUAL_TOLERANCE; + } + /** + * {@snippet lang=c : + * #define CUOPT_ABSOLUTE_PRIMAL_TOLERANCE "absolute_primal_tolerance" + * } + */ + public static MemorySegment CUOPT_ABSOLUTE_PRIMAL_TOLERANCE() { + class Holder { + static final MemorySegment CUOPT_ABSOLUTE_PRIMAL_TOLERANCE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("absolute_primal_tolerance"); + } + return Holder.CUOPT_ABSOLUTE_PRIMAL_TOLERANCE; + } + /** + * {@snippet lang=c : + * #define CUOPT_RELATIVE_PRIMAL_TOLERANCE "relative_primal_tolerance" + * } + */ + public static MemorySegment CUOPT_RELATIVE_PRIMAL_TOLERANCE() { + class Holder { + static final MemorySegment CUOPT_RELATIVE_PRIMAL_TOLERANCE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("relative_primal_tolerance"); + } + return Holder.CUOPT_RELATIVE_PRIMAL_TOLERANCE; + } + /** + * {@snippet lang=c : + * #define CUOPT_ABSOLUTE_GAP_TOLERANCE "absolute_gap_tolerance" + * } + */ + public static MemorySegment CUOPT_ABSOLUTE_GAP_TOLERANCE() { + class Holder { + static final MemorySegment CUOPT_ABSOLUTE_GAP_TOLERANCE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("absolute_gap_tolerance"); + } + return Holder.CUOPT_ABSOLUTE_GAP_TOLERANCE; + } + /** + * {@snippet lang=c : + * #define CUOPT_RELATIVE_GAP_TOLERANCE "relative_gap_tolerance" + * } + */ + public static MemorySegment CUOPT_RELATIVE_GAP_TOLERANCE() { + class Holder { + static final MemorySegment CUOPT_RELATIVE_GAP_TOLERANCE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("relative_gap_tolerance"); + } + return Holder.CUOPT_RELATIVE_GAP_TOLERANCE; + } + /** + * {@snippet lang=c : + * #define CUOPT_INFEASIBILITY_DETECTION "infeasibility_detection" + * } + */ + public static MemorySegment CUOPT_INFEASIBILITY_DETECTION() { + class Holder { + static final MemorySegment CUOPT_INFEASIBILITY_DETECTION + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("infeasibility_detection"); + } + return Holder.CUOPT_INFEASIBILITY_DETECTION; + } + /** + * {@snippet lang=c : + * #define CUOPT_STRICT_INFEASIBILITY "strict_infeasibility" + * } + */ + public static MemorySegment CUOPT_STRICT_INFEASIBILITY() { + class Holder { + static final MemorySegment CUOPT_STRICT_INFEASIBILITY + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("strict_infeasibility"); + } + return Holder.CUOPT_STRICT_INFEASIBILITY; + } + /** + * {@snippet lang=c : + * #define CUOPT_PRIMAL_INFEASIBLE_TOLERANCE "primal_infeasible_tolerance" + * } + */ + public static MemorySegment CUOPT_PRIMAL_INFEASIBLE_TOLERANCE() { + class Holder { + static final MemorySegment CUOPT_PRIMAL_INFEASIBLE_TOLERANCE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("primal_infeasible_tolerance"); + } + return Holder.CUOPT_PRIMAL_INFEASIBLE_TOLERANCE; + } + /** + * {@snippet lang=c : + * #define CUOPT_DUAL_INFEASIBLE_TOLERANCE "dual_infeasible_tolerance" + * } + */ + public static MemorySegment CUOPT_DUAL_INFEASIBLE_TOLERANCE() { + class Holder { + static final MemorySegment CUOPT_DUAL_INFEASIBLE_TOLERANCE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("dual_infeasible_tolerance"); + } + return Holder.CUOPT_DUAL_INFEASIBLE_TOLERANCE; + } + /** + * {@snippet lang=c : + * #define CUOPT_ITERATION_LIMIT "iteration_limit" + * } + */ + public static MemorySegment CUOPT_ITERATION_LIMIT() { + class Holder { + static final MemorySegment CUOPT_ITERATION_LIMIT + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("iteration_limit"); + } + return Holder.CUOPT_ITERATION_LIMIT; + } + /** + * {@snippet lang=c : + * #define CUOPT_TIME_LIMIT "time_limit" + * } + */ + public static MemorySegment CUOPT_TIME_LIMIT() { + class Holder { + static final MemorySegment CUOPT_TIME_LIMIT + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("time_limit"); + } + return Holder.CUOPT_TIME_LIMIT; + } + /** + * {@snippet lang=c : + * #define CUOPT_WORK_LIMIT "work_limit" + * } + */ + public static MemorySegment CUOPT_WORK_LIMIT() { + class Holder { + static final MemorySegment CUOPT_WORK_LIMIT + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("work_limit"); + } + return Holder.CUOPT_WORK_LIMIT; + } + /** + * {@snippet lang=c : + * #define CUOPT_PDLP_SOLVER_MODE "pdlp_solver_mode" + * } + */ + public static MemorySegment CUOPT_PDLP_SOLVER_MODE() { + class Holder { + static final MemorySegment CUOPT_PDLP_SOLVER_MODE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("pdlp_solver_mode"); + } + return Holder.CUOPT_PDLP_SOLVER_MODE; + } + /** + * {@snippet lang=c : + * #define CUOPT_METHOD "method" + * } + */ + public static MemorySegment CUOPT_METHOD() { + class Holder { + static final MemorySegment CUOPT_METHOD + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("method"); + } + return Holder.CUOPT_METHOD; + } + /** + * {@snippet lang=c : + * #define CUOPT_PER_CONSTRAINT_RESIDUAL "per_constraint_residual" + * } + */ + public static MemorySegment CUOPT_PER_CONSTRAINT_RESIDUAL() { + class Holder { + static final MemorySegment CUOPT_PER_CONSTRAINT_RESIDUAL + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("per_constraint_residual"); + } + return Holder.CUOPT_PER_CONSTRAINT_RESIDUAL; + } + /** + * {@snippet lang=c : + * #define CUOPT_SAVE_BEST_PRIMAL_SO_FAR "save_best_primal_so_far" + * } + */ + public static MemorySegment CUOPT_SAVE_BEST_PRIMAL_SO_FAR() { + class Holder { + static final MemorySegment CUOPT_SAVE_BEST_PRIMAL_SO_FAR + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("save_best_primal_so_far"); + } + return Holder.CUOPT_SAVE_BEST_PRIMAL_SO_FAR; + } + /** + * {@snippet lang=c : + * #define CUOPT_FIRST_PRIMAL_FEASIBLE "first_primal_feasible" + * } + */ + public static MemorySegment CUOPT_FIRST_PRIMAL_FEASIBLE() { + class Holder { + static final MemorySegment CUOPT_FIRST_PRIMAL_FEASIBLE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("first_primal_feasible"); + } + return Holder.CUOPT_FIRST_PRIMAL_FEASIBLE; + } + /** + * {@snippet lang=c : + * #define CUOPT_LOG_FILE "log_file" + * } + */ + public static MemorySegment CUOPT_LOG_FILE() { + class Holder { + static final MemorySegment CUOPT_LOG_FILE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("log_file"); + } + return Holder.CUOPT_LOG_FILE; + } + /** + * {@snippet lang=c : + * #define CUOPT_LOG_TO_CONSOLE "log_to_console" + * } + */ + public static MemorySegment CUOPT_LOG_TO_CONSOLE() { + class Holder { + static final MemorySegment CUOPT_LOG_TO_CONSOLE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("log_to_console"); + } + return Holder.CUOPT_LOG_TO_CONSOLE; + } + /** + * {@snippet lang=c : + * #define CUOPT_CROSSOVER "crossover" + * } + */ + public static MemorySegment CUOPT_CROSSOVER() { + class Holder { + static final MemorySegment CUOPT_CROSSOVER + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("crossover"); + } + return Holder.CUOPT_CROSSOVER; + } + /** + * {@snippet lang=c : + * #define CUOPT_FOLDING "folding" + * } + */ + public static MemorySegment CUOPT_FOLDING() { + class Holder { + static final MemorySegment CUOPT_FOLDING + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("folding"); + } + return Holder.CUOPT_FOLDING; + } + /** + * {@snippet lang=c : + * #define CUOPT_AUGMENTED "augmented" + * } + */ + public static MemorySegment CUOPT_AUGMENTED() { + class Holder { + static final MemorySegment CUOPT_AUGMENTED + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("augmented"); + } + return Holder.CUOPT_AUGMENTED; + } + /** + * {@snippet lang=c : + * #define CUOPT_DUALIZE "dualize" + * } + */ + public static MemorySegment CUOPT_DUALIZE() { + class Holder { + static final MemorySegment CUOPT_DUALIZE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("dualize"); + } + return Holder.CUOPT_DUALIZE; + } + /** + * {@snippet lang=c : + * #define CUOPT_ORDERING "ordering" + * } + */ + public static MemorySegment CUOPT_ORDERING() { + class Holder { + static final MemorySegment CUOPT_ORDERING + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("ordering"); + } + return Holder.CUOPT_ORDERING; + } + /** + * {@snippet lang=c : + * #define CUOPT_BARRIER_DUAL_INITIAL_POINT "barrier_dual_initial_point" + * } + */ + public static MemorySegment CUOPT_BARRIER_DUAL_INITIAL_POINT() { + class Holder { + static final MemorySegment CUOPT_BARRIER_DUAL_INITIAL_POINT + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("barrier_dual_initial_point"); + } + return Holder.CUOPT_BARRIER_DUAL_INITIAL_POINT; + } + /** + * {@snippet lang=c : + * #define CUOPT_ELIMINATE_DENSE_COLUMNS "eliminate_dense_columns" + * } + */ + public static MemorySegment CUOPT_ELIMINATE_DENSE_COLUMNS() { + class Holder { + static final MemorySegment CUOPT_ELIMINATE_DENSE_COLUMNS + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("eliminate_dense_columns"); + } + return Holder.CUOPT_ELIMINATE_DENSE_COLUMNS; + } + /** + * {@snippet lang=c : + * #define CUOPT_CUDSS_DETERMINISTIC "cudss_deterministic" + * } + */ + public static MemorySegment CUOPT_CUDSS_DETERMINISTIC() { + class Holder { + static final MemorySegment CUOPT_CUDSS_DETERMINISTIC + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("cudss_deterministic"); + } + return Holder.CUOPT_CUDSS_DETERMINISTIC; + } + /** + * {@snippet lang=c : + * #define CUOPT_PRESOLVE "presolve" + * } + */ + public static MemorySegment CUOPT_PRESOLVE() { + class Holder { + static final MemorySegment CUOPT_PRESOLVE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("presolve"); + } + return Holder.CUOPT_PRESOLVE; + } + /** + * {@snippet lang=c : + * #define CUOPT_DUAL_POSTSOLVE "dual_postsolve" + * } + */ + public static MemorySegment CUOPT_DUAL_POSTSOLVE() { + class Holder { + static final MemorySegment CUOPT_DUAL_POSTSOLVE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("dual_postsolve"); + } + return Holder.CUOPT_DUAL_POSTSOLVE; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_DETERMINISM_MODE "mip_determinism_mode" + * } + */ + public static MemorySegment CUOPT_MIP_DETERMINISM_MODE() { + class Holder { + static final MemorySegment CUOPT_MIP_DETERMINISM_MODE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_determinism_mode"); + } + return Holder.CUOPT_MIP_DETERMINISM_MODE; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_ABSOLUTE_TOLERANCE "mip_absolute_tolerance" + * } + */ + public static MemorySegment CUOPT_MIP_ABSOLUTE_TOLERANCE() { + class Holder { + static final MemorySegment CUOPT_MIP_ABSOLUTE_TOLERANCE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_absolute_tolerance"); + } + return Holder.CUOPT_MIP_ABSOLUTE_TOLERANCE; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_RELATIVE_TOLERANCE "mip_relative_tolerance" + * } + */ + public static MemorySegment CUOPT_MIP_RELATIVE_TOLERANCE() { + class Holder { + static final MemorySegment CUOPT_MIP_RELATIVE_TOLERANCE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_relative_tolerance"); + } + return Holder.CUOPT_MIP_RELATIVE_TOLERANCE; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_INTEGRALITY_TOLERANCE "mip_integrality_tolerance" + * } + */ + public static MemorySegment CUOPT_MIP_INTEGRALITY_TOLERANCE() { + class Holder { + static final MemorySegment CUOPT_MIP_INTEGRALITY_TOLERANCE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_integrality_tolerance"); + } + return Holder.CUOPT_MIP_INTEGRALITY_TOLERANCE; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_ABSOLUTE_GAP "mip_absolute_gap" + * } + */ + public static MemorySegment CUOPT_MIP_ABSOLUTE_GAP() { + class Holder { + static final MemorySegment CUOPT_MIP_ABSOLUTE_GAP + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_absolute_gap"); + } + return Holder.CUOPT_MIP_ABSOLUTE_GAP; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_RELATIVE_GAP "mip_relative_gap" + * } + */ + public static MemorySegment CUOPT_MIP_RELATIVE_GAP() { + class Holder { + static final MemorySegment CUOPT_MIP_RELATIVE_GAP + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_relative_gap"); + } + return Holder.CUOPT_MIP_RELATIVE_GAP; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HEURISTICS_ONLY "mip_heuristics_only" + * } + */ + public static MemorySegment CUOPT_MIP_HEURISTICS_ONLY() { + class Holder { + static final MemorySegment CUOPT_MIP_HEURISTICS_ONLY + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_heuristics_only"); + } + return Holder.CUOPT_MIP_HEURISTICS_ONLY; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_SCALING "mip_scaling" + * } + */ + public static MemorySegment CUOPT_MIP_SCALING() { + class Holder { + static final MemorySegment CUOPT_MIP_SCALING + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_scaling"); + } + return Holder.CUOPT_MIP_SCALING; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_PRESOLVE "mip_presolve" + * } + */ + public static MemorySegment CUOPT_MIP_PRESOLVE() { + class Holder { + static final MemorySegment CUOPT_MIP_PRESOLVE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_presolve"); + } + return Holder.CUOPT_MIP_PRESOLVE; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_RELIABILITY_BRANCHING "mip_reliability_branching" + * } + */ + public static MemorySegment CUOPT_MIP_RELIABILITY_BRANCHING() { + class Holder { + static final MemorySegment CUOPT_MIP_RELIABILITY_BRANCHING + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_reliability_branching"); + } + return Holder.CUOPT_MIP_RELIABILITY_BRANCHING; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_CUT_PASSES "mip_cut_passes" + * } + */ + public static MemorySegment CUOPT_MIP_CUT_PASSES() { + class Holder { + static final MemorySegment CUOPT_MIP_CUT_PASSES + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_cut_passes"); + } + return Holder.CUOPT_MIP_CUT_PASSES; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_MIXED_INTEGER_ROUNDING_CUTS "mip_mixed_integer_rounding_cuts" + * } + */ + public static MemorySegment CUOPT_MIP_MIXED_INTEGER_ROUNDING_CUTS() { + class Holder { + static final MemorySegment CUOPT_MIP_MIXED_INTEGER_ROUNDING_CUTS + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_mixed_integer_rounding_cuts"); + } + return Holder.CUOPT_MIP_MIXED_INTEGER_ROUNDING_CUTS; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_MIXED_INTEGER_GOMORY_CUTS "mip_mixed_integer_gomory_cuts" + * } + */ + public static MemorySegment CUOPT_MIP_MIXED_INTEGER_GOMORY_CUTS() { + class Holder { + static final MemorySegment CUOPT_MIP_MIXED_INTEGER_GOMORY_CUTS + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_mixed_integer_gomory_cuts"); + } + return Holder.CUOPT_MIP_MIXED_INTEGER_GOMORY_CUTS; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_KNAPSACK_CUTS "mip_knapsack_cuts" + * } + */ + public static MemorySegment CUOPT_MIP_KNAPSACK_CUTS() { + class Holder { + static final MemorySegment CUOPT_MIP_KNAPSACK_CUTS + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_knapsack_cuts"); + } + return Holder.CUOPT_MIP_KNAPSACK_CUTS; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_IMPLIED_BOUND_CUTS "mip_implied_bound_cuts" + * } + */ + public static MemorySegment CUOPT_MIP_IMPLIED_BOUND_CUTS() { + class Holder { + static final MemorySegment CUOPT_MIP_IMPLIED_BOUND_CUTS + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_implied_bound_cuts"); + } + return Holder.CUOPT_MIP_IMPLIED_BOUND_CUTS; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_CLIQUE_CUTS "mip_clique_cuts" + * } + */ + public static MemorySegment CUOPT_MIP_CLIQUE_CUTS() { + class Holder { + static final MemorySegment CUOPT_MIP_CLIQUE_CUTS + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_clique_cuts"); + } + return Holder.CUOPT_MIP_CLIQUE_CUTS; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_STRONG_CHVATAL_GOMORY_CUTS "mip_strong_chvatal_gomory_cuts" + * } + */ + public static MemorySegment CUOPT_MIP_STRONG_CHVATAL_GOMORY_CUTS() { + class Holder { + static final MemorySegment CUOPT_MIP_STRONG_CHVATAL_GOMORY_CUTS + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_strong_chvatal_gomory_cuts"); + } + return Holder.CUOPT_MIP_STRONG_CHVATAL_GOMORY_CUTS; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_REDUCED_COST_STRENGTHENING "mip_reduced_cost_strengthening" + * } + */ + public static MemorySegment CUOPT_MIP_REDUCED_COST_STRENGTHENING() { + class Holder { + static final MemorySegment CUOPT_MIP_REDUCED_COST_STRENGTHENING + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_reduced_cost_strengthening"); + } + return Holder.CUOPT_MIP_REDUCED_COST_STRENGTHENING; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_CUT_CHANGE_THRESHOLD "mip_cut_change_threshold" + * } + */ + public static MemorySegment CUOPT_MIP_CUT_CHANGE_THRESHOLD() { + class Holder { + static final MemorySegment CUOPT_MIP_CUT_CHANGE_THRESHOLD + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_cut_change_threshold"); + } + return Holder.CUOPT_MIP_CUT_CHANGE_THRESHOLD; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_CUT_MIN_ORTHOGONALITY "mip_cut_min_orthogonality" + * } + */ + public static MemorySegment CUOPT_MIP_CUT_MIN_ORTHOGONALITY() { + class Holder { + static final MemorySegment CUOPT_MIP_CUT_MIN_ORTHOGONALITY + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_cut_min_orthogonality"); + } + return Holder.CUOPT_MIP_CUT_MIN_ORTHOGONALITY; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_BATCH_PDLP_STRONG_BRANCHING "mip_batch_pdlp_strong_branching" + * } + */ + public static MemorySegment CUOPT_MIP_BATCH_PDLP_STRONG_BRANCHING() { + class Holder { + static final MemorySegment CUOPT_MIP_BATCH_PDLP_STRONG_BRANCHING + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_batch_pdlp_strong_branching"); + } + return Holder.CUOPT_MIP_BATCH_PDLP_STRONG_BRANCHING; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_BATCH_PDLP_RELIABILITY_BRANCHING "mip_batch_pdlp_reliability_branching" + * } + */ + public static MemorySegment CUOPT_MIP_BATCH_PDLP_RELIABILITY_BRANCHING() { + class Holder { + static final MemorySegment CUOPT_MIP_BATCH_PDLP_RELIABILITY_BRANCHING + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_batch_pdlp_reliability_branching"); + } + return Holder.CUOPT_MIP_BATCH_PDLP_RELIABILITY_BRANCHING; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_STRONG_BRANCHING_SIMPLEX_ITERATION_LIMIT "mip_strong_branching_simplex_iteration_limit" + * } + */ + public static MemorySegment CUOPT_MIP_STRONG_BRANCHING_SIMPLEX_ITERATION_LIMIT() { + class Holder { + static final MemorySegment CUOPT_MIP_STRONG_BRANCHING_SIMPLEX_ITERATION_LIMIT + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_strong_branching_simplex_iteration_limit"); + } + return Holder.CUOPT_MIP_STRONG_BRANCHING_SIMPLEX_ITERATION_LIMIT; + } + /** + * {@snippet lang=c : + * #define CUOPT_SOLUTION_FILE "solution_file" + * } + */ + public static MemorySegment CUOPT_SOLUTION_FILE() { + class Holder { + static final MemorySegment CUOPT_SOLUTION_FILE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("solution_file"); + } + return Holder.CUOPT_SOLUTION_FILE; + } + /** + * {@snippet lang=c : + * #define CUOPT_NUM_CPU_THREADS "num_cpu_threads" + * } + */ + public static MemorySegment CUOPT_NUM_CPU_THREADS() { + class Holder { + static final MemorySegment CUOPT_NUM_CPU_THREADS + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("num_cpu_threads"); + } + return Holder.CUOPT_NUM_CPU_THREADS; + } + /** + * {@snippet lang=c : + * #define CUOPT_NUM_GPUS "num_gpus" + * } + */ + public static MemorySegment CUOPT_NUM_GPUS() { + class Holder { + static final MemorySegment CUOPT_NUM_GPUS + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("num_gpus"); + } + return Holder.CUOPT_NUM_GPUS; + } + /** + * {@snippet lang=c : + * #define CUOPT_USER_PROBLEM_FILE "user_problem_file" + * } + */ + public static MemorySegment CUOPT_USER_PROBLEM_FILE() { + class Holder { + static final MemorySegment CUOPT_USER_PROBLEM_FILE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("user_problem_file"); + } + return Holder.CUOPT_USER_PROBLEM_FILE; + } + /** + * {@snippet lang=c : + * #define CUOPT_PRESOLVE_FILE "presolve_file" + * } + */ + public static MemorySegment CUOPT_PRESOLVE_FILE() { + class Holder { + static final MemorySegment CUOPT_PRESOLVE_FILE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("presolve_file"); + } + return Holder.CUOPT_PRESOLVE_FILE; + } + /** + * {@snippet lang=c : + * #define CUOPT_RANDOM_SEED "random_seed" + * } + */ + public static MemorySegment CUOPT_RANDOM_SEED() { + class Holder { + static final MemorySegment CUOPT_RANDOM_SEED + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("random_seed"); + } + return Holder.CUOPT_RANDOM_SEED; + } + /** + * {@snippet lang=c : + * #define CUOPT_PDLP_PRECISION "pdlp_precision" + * } + */ + public static MemorySegment CUOPT_PDLP_PRECISION() { + class Holder { + static final MemorySegment CUOPT_PDLP_PRECISION + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("pdlp_precision"); + } + return Holder.CUOPT_PDLP_PRECISION; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_SEMICONTINUOUS_BIG_M "mip_semi_continuous_big_m" + * } + */ + public static MemorySegment CUOPT_MIP_SEMICONTINUOUS_BIG_M() { + class Holder { + static final MemorySegment CUOPT_MIP_SEMICONTINUOUS_BIG_M + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_semi_continuous_big_m"); + } + return Holder.CUOPT_MIP_SEMICONTINUOUS_BIG_M; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_POPULATION_SIZE "mip_hyper_heuristic_population_size" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_POPULATION_SIZE() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_POPULATION_SIZE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_population_size"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_POPULATION_SIZE; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_NUM_CPUFJ_THREADS "mip_hyper_heuristic_num_cpufj_threads" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_NUM_CPUFJ_THREADS() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_NUM_CPUFJ_THREADS + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_num_cpufj_threads"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_NUM_CPUFJ_THREADS; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_PRESOLVE_TIME_RATIO "mip_hyper_heuristic_presolve_time_ratio" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_PRESOLVE_TIME_RATIO() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_PRESOLVE_TIME_RATIO + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_presolve_time_ratio"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_PRESOLVE_TIME_RATIO; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_PRESOLVE_MAX_TIME "mip_hyper_heuristic_presolve_max_time" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_PRESOLVE_MAX_TIME() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_PRESOLVE_MAX_TIME + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_presolve_max_time"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_PRESOLVE_MAX_TIME; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_ROOT_LP_TIME_RATIO "mip_hyper_heuristic_root_lp_time_ratio" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_ROOT_LP_TIME_RATIO() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_ROOT_LP_TIME_RATIO + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_root_lp_time_ratio"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_ROOT_LP_TIME_RATIO; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_ROOT_LP_MAX_TIME "mip_hyper_heuristic_root_lp_max_time" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_ROOT_LP_MAX_TIME() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_ROOT_LP_MAX_TIME + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_root_lp_max_time"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_ROOT_LP_MAX_TIME; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_RINS_TIME_LIMIT "mip_hyper_heuristic_rins_time_limit" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_RINS_TIME_LIMIT() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_RINS_TIME_LIMIT + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_rins_time_limit"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_RINS_TIME_LIMIT; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_RINS_MAX_TIME_LIMIT "mip_hyper_heuristic_rins_max_time_limit" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_RINS_MAX_TIME_LIMIT() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_RINS_MAX_TIME_LIMIT + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_rins_max_time_limit"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_RINS_MAX_TIME_LIMIT; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_RINS_FIX_RATE "mip_hyper_heuristic_rins_fix_rate" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_RINS_FIX_RATE() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_RINS_FIX_RATE + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_rins_fix_rate"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_RINS_FIX_RATE; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_STAGNATION_TRIGGER "mip_hyper_heuristic_stagnation_trigger" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_STAGNATION_TRIGGER() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_STAGNATION_TRIGGER + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_stagnation_trigger"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_STAGNATION_TRIGGER; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_MAX_ITERS_WITHOUT_IMPROVEMENT "mip_hyper_heuristic_max_iterations_without_improvement" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_MAX_ITERS_WITHOUT_IMPROVEMENT() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_MAX_ITERS_WITHOUT_IMPROVEMENT + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_max_iterations_without_improvement"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_MAX_ITERS_WITHOUT_IMPROVEMENT; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_INITIAL_INFEASIBILITY_WEIGHT "mip_hyper_heuristic_initial_infeasibility_weight" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_INITIAL_INFEASIBILITY_WEIGHT() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_INITIAL_INFEASIBILITY_WEIGHT + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_initial_infeasibility_weight"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_INITIAL_INFEASIBILITY_WEIGHT; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_N_OF_MINIMUMS_FOR_EXIT "mip_hyper_heuristic_n_of_minimums_for_exit" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_N_OF_MINIMUMS_FOR_EXIT() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_N_OF_MINIMUMS_FOR_EXIT + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_n_of_minimums_for_exit"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_N_OF_MINIMUMS_FOR_EXIT; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_ENABLED_RECOMBINERS "mip_hyper_heuristic_enabled_recombiners" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_ENABLED_RECOMBINERS() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_ENABLED_RECOMBINERS + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_enabled_recombiners"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_ENABLED_RECOMBINERS; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_CYCLE_DETECTION_LENGTH "mip_hyper_heuristic_cycle_detection_length" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_CYCLE_DETECTION_LENGTH() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_CYCLE_DETECTION_LENGTH + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_cycle_detection_length"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_CYCLE_DETECTION_LENGTH; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_RELAXED_LP_TIME_LIMIT "mip_hyper_heuristic_relaxed_lp_time_limit" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_RELAXED_LP_TIME_LIMIT() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_RELAXED_LP_TIME_LIMIT + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_relaxed_lp_time_limit"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_RELAXED_LP_TIME_LIMIT; + } + /** + * {@snippet lang=c : + * #define CUOPT_MIP_HYPER_HEURISTIC_RELATED_VARS_TIME_LIMIT "mip_hyper_heuristic_related_vars_time_limit" + * } + */ + public static MemorySegment CUOPT_MIP_HYPER_HEURISTIC_RELATED_VARS_TIME_LIMIT() { + class Holder { + static final MemorySegment CUOPT_MIP_HYPER_HEURISTIC_RELATED_VARS_TIME_LIMIT + = cuopt_c_h.LIBRARY_ARENA.allocateFrom("mip_hyper_heuristic_related_vars_time_limit"); + } + return Holder.CUOPT_MIP_HYPER_HEURISTIC_RELATED_VARS_TIME_LIMIT; + } + private static final int CUOPT_MAXIMIZE = (int)-1L; + /** + * {@snippet lang=c : + * #define CUOPT_MAXIMIZE -1 + * } + */ + public static int CUOPT_MAXIMIZE() { + return CUOPT_MAXIMIZE; + } + private static final int CUOPT_LESS_THAN = (int)76L; + /** + * {@snippet lang=c : + * #define CUOPT_LESS_THAN 76 + * } + */ + public static int CUOPT_LESS_THAN() { + return CUOPT_LESS_THAN; + } + private static final int CUOPT_GREATER_THAN = (int)71L; + /** + * {@snippet lang=c : + * #define CUOPT_GREATER_THAN 71 + * } + */ + public static int CUOPT_GREATER_THAN() { + return CUOPT_GREATER_THAN; + } + private static final int CUOPT_EQUAL = (int)69L; + /** + * {@snippet lang=c : + * #define CUOPT_EQUAL 69 + * } + */ + public static int CUOPT_EQUAL() { + return CUOPT_EQUAL; + } + private static final int CUOPT_CONTINUOUS = (int)67L; + /** + * {@snippet lang=c : + * #define CUOPT_CONTINUOUS 67 + * } + */ + public static int CUOPT_CONTINUOUS() { + return CUOPT_CONTINUOUS; + } + private static final int CUOPT_INTEGER = (int)73L; + /** + * {@snippet lang=c : + * #define CUOPT_INTEGER 73 + * } + */ + public static int CUOPT_INTEGER() { + return CUOPT_INTEGER; + } + private static final float CUOPT_INFINITY = Float.valueOf("Infinity"); + /** + * {@snippet lang=c : + * #define CUOPT_INFINITY Infinity + * } + */ + public static float CUOPT_INFINITY() { + return CUOPT_INFINITY; + } + private static final int CUOPT_PDLP_DEFAULT_PRECISION = (int)-1L; + /** + * {@snippet lang=c : + * #define CUOPT_PDLP_DEFAULT_PRECISION -1 + * } + */ + public static int CUOPT_PDLP_DEFAULT_PRECISION() { + return CUOPT_PDLP_DEFAULT_PRECISION; + } + private static final int CUOPT_PRESOLVE_DEFAULT = (int)-1L; + /** + * {@snippet lang=c : + * #define CUOPT_PRESOLVE_DEFAULT -1 + * } + */ + public static int CUOPT_PRESOLVE_DEFAULT() { + return CUOPT_PRESOLVE_DEFAULT; + } + private static final int __WCHAR_MAX = (int)2147483647L; + /** + * {@snippet lang=c : + * #define __WCHAR_MAX 2147483647 + * } + */ + public static int __WCHAR_MAX() { + return __WCHAR_MAX; + } + private static final int __WCHAR_MIN = (int)-2147483648L; + /** + * {@snippet lang=c : + * #define __WCHAR_MIN -2147483648 + * } + */ + public static int __WCHAR_MIN() { + return __WCHAR_MIN; + } + private static final int INT8_MIN = (int)-128L; + /** + * {@snippet lang=c : + * #define INT8_MIN -128 + * } + */ + public static int INT8_MIN() { + return INT8_MIN; + } + private static final int INT16_MIN = (int)-32768L; + /** + * {@snippet lang=c : + * #define INT16_MIN -32768 + * } + */ + public static int INT16_MIN() { + return INT16_MIN; + } + private static final int INT32_MIN = (int)-2147483648L; + /** + * {@snippet lang=c : + * #define INT32_MIN -2147483648 + * } + */ + public static int INT32_MIN() { + return INT32_MIN; + } + private static final long INT64_MIN = -9223372036854775808L; + /** + * {@snippet lang=c : + * #define INT64_MIN -9223372036854775808 + * } + */ + public static long INT64_MIN() { + return INT64_MIN; + } + private static final int INT8_MAX = (int)127L; + /** + * {@snippet lang=c : + * #define INT8_MAX 127 + * } + */ + public static int INT8_MAX() { + return INT8_MAX; + } + private static final int INT16_MAX = (int)32767L; + /** + * {@snippet lang=c : + * #define INT16_MAX 32767 + * } + */ + public static int INT16_MAX() { + return INT16_MAX; + } + private static final int INT32_MAX = (int)2147483647L; + /** + * {@snippet lang=c : + * #define INT32_MAX 2147483647 + * } + */ + public static int INT32_MAX() { + return INT32_MAX; + } + private static final long INT64_MAX = 9223372036854775807L; + /** + * {@snippet lang=c : + * #define INT64_MAX 9223372036854775807 + * } + */ + public static long INT64_MAX() { + return INT64_MAX; + } + private static final int UINT8_MAX = (int)255L; + /** + * {@snippet lang=c : + * #define UINT8_MAX 255 + * } + */ + public static int UINT8_MAX() { + return UINT8_MAX; + } + private static final int UINT16_MAX = (int)65535L; + /** + * {@snippet lang=c : + * #define UINT16_MAX 65535 + * } + */ + public static int UINT16_MAX() { + return UINT16_MAX; + } + private static final int UINT32_MAX = (int)4294967295L; + /** + * {@snippet lang=c : + * #define UINT32_MAX 4294967295 + * } + */ + public static int UINT32_MAX() { + return UINT32_MAX; + } + private static final long UINT64_MAX = -1L; + /** + * {@snippet lang=c : + * #define UINT64_MAX -1 + * } + */ + public static long UINT64_MAX() { + return UINT64_MAX; + } + private static final int INT_LEAST8_MIN = (int)-128L; + /** + * {@snippet lang=c : + * #define INT_LEAST8_MIN -128 + * } + */ + public static int INT_LEAST8_MIN() { + return INT_LEAST8_MIN; + } + private static final int INT_LEAST16_MIN = (int)-32768L; + /** + * {@snippet lang=c : + * #define INT_LEAST16_MIN -32768 + * } + */ + public static int INT_LEAST16_MIN() { + return INT_LEAST16_MIN; + } + private static final int INT_LEAST32_MIN = (int)-2147483648L; + /** + * {@snippet lang=c : + * #define INT_LEAST32_MIN -2147483648 + * } + */ + public static int INT_LEAST32_MIN() { + return INT_LEAST32_MIN; + } + private static final long INT_LEAST64_MIN = -9223372036854775808L; + /** + * {@snippet lang=c : + * #define INT_LEAST64_MIN -9223372036854775808 + * } + */ + public static long INT_LEAST64_MIN() { + return INT_LEAST64_MIN; + } + private static final int INT_LEAST8_MAX = (int)127L; + /** + * {@snippet lang=c : + * #define INT_LEAST8_MAX 127 + * } + */ + public static int INT_LEAST8_MAX() { + return INT_LEAST8_MAX; + } + private static final int INT_LEAST16_MAX = (int)32767L; + /** + * {@snippet lang=c : + * #define INT_LEAST16_MAX 32767 + * } + */ + public static int INT_LEAST16_MAX() { + return INT_LEAST16_MAX; + } + private static final int INT_LEAST32_MAX = (int)2147483647L; + /** + * {@snippet lang=c : + * #define INT_LEAST32_MAX 2147483647 + * } + */ + public static int INT_LEAST32_MAX() { + return INT_LEAST32_MAX; + } + private static final long INT_LEAST64_MAX = 9223372036854775807L; + /** + * {@snippet lang=c : + * #define INT_LEAST64_MAX 9223372036854775807 + * } + */ + public static long INT_LEAST64_MAX() { + return INT_LEAST64_MAX; + } + private static final int UINT_LEAST8_MAX = (int)255L; + /** + * {@snippet lang=c : + * #define UINT_LEAST8_MAX 255 + * } + */ + public static int UINT_LEAST8_MAX() { + return UINT_LEAST8_MAX; + } + private static final int UINT_LEAST16_MAX = (int)65535L; + /** + * {@snippet lang=c : + * #define UINT_LEAST16_MAX 65535 + * } + */ + public static int UINT_LEAST16_MAX() { + return UINT_LEAST16_MAX; + } + private static final int UINT_LEAST32_MAX = (int)4294967295L; + /** + * {@snippet lang=c : + * #define UINT_LEAST32_MAX 4294967295 + * } + */ + public static int UINT_LEAST32_MAX() { + return UINT_LEAST32_MAX; + } + private static final long UINT_LEAST64_MAX = -1L; + /** + * {@snippet lang=c : + * #define UINT_LEAST64_MAX -1 + * } + */ + public static long UINT_LEAST64_MAX() { + return UINT_LEAST64_MAX; + } + private static final int INT_FAST8_MIN = (int)-128L; + /** + * {@snippet lang=c : + * #define INT_FAST8_MIN -128 + * } + */ + public static int INT_FAST8_MIN() { + return INT_FAST8_MIN; + } + private static final long INT_FAST16_MIN = -9223372036854775808L; + /** + * {@snippet lang=c : + * #define INT_FAST16_MIN -9223372036854775808 + * } + */ + public static long INT_FAST16_MIN() { + return INT_FAST16_MIN; + } + private static final long INT_FAST32_MIN = -9223372036854775808L; + /** + * {@snippet lang=c : + * #define INT_FAST32_MIN -9223372036854775808 + * } + */ + public static long INT_FAST32_MIN() { + return INT_FAST32_MIN; + } + private static final long INT_FAST64_MIN = -9223372036854775808L; + /** + * {@snippet lang=c : + * #define INT_FAST64_MIN -9223372036854775808 + * } + */ + public static long INT_FAST64_MIN() { + return INT_FAST64_MIN; + } + private static final int INT_FAST8_MAX = (int)127L; + /** + * {@snippet lang=c : + * #define INT_FAST8_MAX 127 + * } + */ + public static int INT_FAST8_MAX() { + return INT_FAST8_MAX; + } + private static final long INT_FAST16_MAX = 9223372036854775807L; + /** + * {@snippet lang=c : + * #define INT_FAST16_MAX 9223372036854775807 + * } + */ + public static long INT_FAST16_MAX() { + return INT_FAST16_MAX; + } + private static final long INT_FAST32_MAX = 9223372036854775807L; + /** + * {@snippet lang=c : + * #define INT_FAST32_MAX 9223372036854775807 + * } + */ + public static long INT_FAST32_MAX() { + return INT_FAST32_MAX; + } + private static final long INT_FAST64_MAX = 9223372036854775807L; + /** + * {@snippet lang=c : + * #define INT_FAST64_MAX 9223372036854775807 + * } + */ + public static long INT_FAST64_MAX() { + return INT_FAST64_MAX; + } + private static final int UINT_FAST8_MAX = (int)255L; + /** + * {@snippet lang=c : + * #define UINT_FAST8_MAX 255 + * } + */ + public static int UINT_FAST8_MAX() { + return UINT_FAST8_MAX; + } + private static final long UINT_FAST16_MAX = -1L; + /** + * {@snippet lang=c : + * #define UINT_FAST16_MAX -1 + * } + */ + public static long UINT_FAST16_MAX() { + return UINT_FAST16_MAX; + } + private static final long UINT_FAST32_MAX = -1L; + /** + * {@snippet lang=c : + * #define UINT_FAST32_MAX -1 + * } + */ + public static long UINT_FAST32_MAX() { + return UINT_FAST32_MAX; + } + private static final long UINT_FAST64_MAX = -1L; + /** + * {@snippet lang=c : + * #define UINT_FAST64_MAX -1 + * } + */ + public static long UINT_FAST64_MAX() { + return UINT_FAST64_MAX; + } + private static final long INTPTR_MIN = -9223372036854775808L; + /** + * {@snippet lang=c : + * #define INTPTR_MIN -9223372036854775808 + * } + */ + public static long INTPTR_MIN() { + return INTPTR_MIN; + } + private static final long INTPTR_MAX = 9223372036854775807L; + /** + * {@snippet lang=c : + * #define INTPTR_MAX 9223372036854775807 + * } + */ + public static long INTPTR_MAX() { + return INTPTR_MAX; + } + private static final long UINTPTR_MAX = -1L; + /** + * {@snippet lang=c : + * #define UINTPTR_MAX -1 + * } + */ + public static long UINTPTR_MAX() { + return UINTPTR_MAX; + } + private static final long INTMAX_MIN = -9223372036854775808L; + /** + * {@snippet lang=c : + * #define INTMAX_MIN -9223372036854775808 + * } + */ + public static long INTMAX_MIN() { + return INTMAX_MIN; + } + private static final long INTMAX_MAX = 9223372036854775807L; + /** + * {@snippet lang=c : + * #define INTMAX_MAX 9223372036854775807 + * } + */ + public static long INTMAX_MAX() { + return INTMAX_MAX; + } + private static final long UINTMAX_MAX = -1L; + /** + * {@snippet lang=c : + * #define UINTMAX_MAX -1 + * } + */ + public static long UINTMAX_MAX() { + return UINTMAX_MAX; + } + private static final long PTRDIFF_MIN = -9223372036854775808L; + /** + * {@snippet lang=c : + * #define PTRDIFF_MIN -9223372036854775808 + * } + */ + public static long PTRDIFF_MIN() { + return PTRDIFF_MIN; + } + private static final long PTRDIFF_MAX = 9223372036854775807L; + /** + * {@snippet lang=c : + * #define PTRDIFF_MAX 9223372036854775807 + * } + */ + public static long PTRDIFF_MAX() { + return PTRDIFF_MAX; + } + private static final int SIG_ATOMIC_MIN = (int)-2147483648L; + /** + * {@snippet lang=c : + * #define SIG_ATOMIC_MIN -2147483648 + * } + */ + public static int SIG_ATOMIC_MIN() { + return SIG_ATOMIC_MIN; + } + private static final int SIG_ATOMIC_MAX = (int)2147483647L; + /** + * {@snippet lang=c : + * #define SIG_ATOMIC_MAX 2147483647 + * } + */ + public static int SIG_ATOMIC_MAX() { + return SIG_ATOMIC_MAX; + } + private static final long SIZE_MAX = -1L; + /** + * {@snippet lang=c : + * #define SIZE_MAX -1 + * } + */ + public static long SIZE_MAX() { + return SIZE_MAX; + } + private static final int WCHAR_MIN = (int)-2147483648L; + /** + * {@snippet lang=c : + * #define WCHAR_MIN -2147483648 + * } + */ + public static int WCHAR_MIN() { + return WCHAR_MIN; + } + private static final int WCHAR_MAX = (int)2147483647L; + /** + * {@snippet lang=c : + * #define WCHAR_MAX 2147483647 + * } + */ + public static int WCHAR_MAX() { + return WCHAR_MAX; + } + private static final int WINT_MIN = (int)0L; + /** + * {@snippet lang=c : + * #define WINT_MIN 0 + * } + */ + public static int WINT_MIN() { + return WINT_MIN; + } + private static final int WINT_MAX = (int)4294967295L; + /** + * {@snippet lang=c : + * #define WINT_MAX 4294967295 + * } + */ + public static int WINT_MAX() { + return WINT_MAX; + } +} diff --git a/java/cuopt-java/src/main/resources/META-INF/cuopt/supported-platforms.properties b/java/cuopt-java/src/main/resources/META-INF/cuopt/supported-platforms.properties new file mode 100644 index 000000000..a155a80ff --- /dev/null +++ b/java/cuopt-java/src/main/resources/META-INF/cuopt/supported-platforms.properties @@ -0,0 +1,11 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Supported (os, arch) combinations for cuopt-java. +# Adding arm64 support is a properties-file edit, not a code change. + +linux-amd64=true +linux-aarch64=true +macos-amd64=false +macos-aarch64=false +windows-amd64=false diff --git a/java/cuopt-java/src/main/resources/META-INF/services/com.nvidia.cuopt.spi.cuOptProvider b/java/cuopt-java/src/main/resources/META-INF/services/com.nvidia.cuopt.spi.cuOptProvider new file mode 100644 index 000000000..908b831f8 --- /dev/null +++ b/java/cuopt-java/src/main/resources/META-INF/services/com.nvidia.cuopt.spi.cuOptProvider @@ -0,0 +1 @@ +com.nvidia.cuopt.internal.cuOptProviderImpl diff --git a/java/cuopt-java/src/test/java/com/nvidia/cuopt/SolverIT.java b/java/cuopt-java/src/test/java/com/nvidia/cuopt/SolverIT.java new file mode 100644 index 000000000..00d53d65e --- /dev/null +++ b/java/cuopt-java/src/test/java/com/nvidia/cuopt/SolverIT.java @@ -0,0 +1,21 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + +class SolverIT { + + @Test + void getVersionReturnsNonEmptyString() { + String version = Solver.getVersion(); + assertNotNull(version); + assertTrue(version.matches("\\d+\\.\\d+\\.\\d+"), + "Expected version in 'major.minor.patch' format, got: " + version); + } +} diff --git a/java/cuopt-java/src/test/java/com/nvidia/cuopt/optimization/LinearExprTest.java b/java/cuopt-java/src/test/java/com/nvidia/cuopt/optimization/LinearExprTest.java new file mode 100644 index 000000000..f57dac19c --- /dev/null +++ b/java/cuopt-java/src/test/java/com/nvidia/cuopt/optimization/LinearExprTest.java @@ -0,0 +1,64 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +import static com.nvidia.cuopt.cuOpt.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.Test; + +class LinearExprTest { + + @Test + void addTerm_and_addTerms_are_interchangeable() { + try (var p = new Problem()) { + Variable x = p.addVariable(0, INF, CONTINUOUS, "x"); + Variable y = p.addVariable(0, INF, CONTINUOUS, "y"); + Variable z = p.addVariable(0, INF, CONTINUOUS, "z"); + + LinearExpr a = new LinearExpr() + .addTerm(2.0, x).addTerm(3.0, y).addTerm(1.0, z); + + LinearExpr b = new LinearExpr() + .addTerms(new double[]{2.0, 3.0, 1.0}, new Variable[]{x, y, z}); + + assertEquals(a.numTerms(), b.numTerms()); + assertEquals(a.terms(), b.terms()); + } + } + + @Test + void same_variable_coefficients_accumulate() { + try (var p = new Problem()) { + Variable x = p.addVariable(0, INF, CONTINUOUS, "x"); + LinearExpr e = new LinearExpr() + .addTerm(2.0, x).addTerm(3.0, x); + assertEquals(1, e.numTerms()); + assertEquals(5.0, e.terms().get(x), 1e-12); + } + } + + @Test + void length_mismatch_throws() { + try (var p = new Problem()) { + Variable x = p.addVariable(0, INF, CONTINUOUS, "x"); + LinearExpr e = new LinearExpr(); + assertThrows(IllegalArgumentException.class, + () -> e.addTerms(new double[]{1.0, 2.0}, new Variable[]{x})); + } + } + + @Test + void mixed_problem_variables_throws() { + try (var p1 = new Problem(); var p2 = new Problem()) { + Variable x1 = p1.addVariable(0, INF, CONTINUOUS, "x1"); + Variable x2 = p2.addVariable(0, INF, CONTINUOUS, "x2"); + LinearExpr e = new LinearExpr().addTerm(1.0, x1); + assertThrows(IllegalArgumentException.class, + () -> e.addTerm(1.0, x2)); + } + } +} diff --git a/java/cuopt-java/src/test/java/com/nvidia/cuopt/optimization/LpSolverIT.java b/java/cuopt-java/src/test/java/com/nvidia/cuopt/optimization/LpSolverIT.java new file mode 100644 index 000000000..29bdedb61 --- /dev/null +++ b/java/cuopt-java/src/test/java/com/nvidia/cuopt/optimization/LpSolverIT.java @@ -0,0 +1,111 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +import static com.nvidia.cuopt.cuOpt.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + +class LpSolverIT { + + /** + * Minimal LP that mirrors the cuOpt Python LP solver test in + * {@code test_lp_solver.py::test_solver}. + */ + @Test + void simpleLpSolveToOptimal() { + try (var problem = new Problem("test_lp"); + var settings = new SolverSettings() + .setOptimalityTolerance(1e-2) + .setMethod(SolverMethod.PDLP)) { + + Variable x1 = problem.addVariable(0.0, INF, CONTINUOUS, "x1"); + Variable x2 = problem.addVariable(0.0, INF, CONTINUOUS, "x2"); + + // x1 + x2 <= 1.0 (twice to mirror the Python test's offsets array [0,1,2]) + LinearExpr c1 = new LinearExpr().addTerm(1.0, x1); + problem.addConstraint(c1, LESS_EQUAL, 1.0, "c1"); + LinearExpr c2 = new LinearExpr().addTerm(1.0, x1); + problem.addConstraint(c2, LESS_EQUAL, 1.0, "c2"); + + // minimize x1 + LinearExpr obj = new LinearExpr().addTerm(1.0, x1); + problem.setObjective(obj, MINIMIZE); + + problem.solve(settings); + + assertEquals(TerminationStatus.OPTIMAL, problem.status(), + "expected OPTIMAL; got " + problem.terminationReason()); + assertEquals(0.0, x1.value(), 1e-6); + assertEquals(0.0, problem.objectiveValue(), 1e-6); + assertTrue(problem.solveTime() >= 0.0); + } + } + + @Test + void diet_lp_optimal_objective() { + // Diet problem (toy LP): + // min 1.5*bread + 0.8*milk + // s.t. 2*bread + 3*milk >= 50 (calories) + // 1*bread + 4*milk >= 12 (protein) + // 0 <= bread <= 10 + // 0 <= milk <= 10 + try (var problem = new Problem("diet")) { + Variable bread = problem.addVariable(0, 10, CONTINUOUS, "bread"); + Variable milk = problem.addVariable(0, 10, CONTINUOUS, "milk"); + + LinearExpr calories = new LinearExpr() + .addTerm(2.0, bread).addTerm(3.0, milk); + problem.addConstraint(calories, GREATER_EQUAL, 50.0, "calories"); + + LinearExpr protein = new LinearExpr() + .addTerm(1.0, bread).addTerm(4.0, milk); + problem.addConstraint(protein, GREATER_EQUAL, 12.0, "protein"); + + LinearExpr cost = new LinearExpr() + .addTerm(1.5, bread).addTerm(0.8, milk); + problem.setObjective(cost, MINIMIZE); + + problem.solve(); + + // We don't pin the objective to an exact value (numerical + // tolerances vary), but it should be feasible and finite. + assertEquals(TerminationStatus.OPTIMAL, problem.status(), + "diet LP should be feasible and optimal"); + double obj = problem.objectiveValue(); + assertTrue(Double.isFinite(obj)); + assertTrue(obj >= 0.0); + // Values should be within bounds. + assertTrue(bread.value() >= -1e-6 && bread.value() <= 10.0 + 1e-6); + assertTrue(milk.value() >= -1e-6 && milk.value() <= 10.0 + 1e-6); + } + } + + @Test + void problem_introspection_reflects_build_state() { + try (var problem = new Problem("introspection")) { + assertEquals(0, problem.numVariables()); + assertEquals(0, problem.numConstraints()); + assertEquals(0, problem.numNonZeros()); + + Variable x = problem.addVariable(0, 5, CONTINUOUS, "x"); + Variable y = problem.addVariable(0, 5, CONTINUOUS, "y"); + assertEquals(2, problem.numVariables()); + + problem.addConstraint( + new LinearExpr().addTerm(1, x).addTerm(1, y), + LESS_EQUAL, 10.0, "c"); + assertEquals(1, problem.numConstraints()); + assertEquals(2, problem.numNonZeros()); + + assertEquals(ProblemCategory.LP, problem.problemCategory()); + assertNotNull(problem.getVariable("x")); + assertEquals(x, problem.getVariable("x")); + } + } +} diff --git a/java/cuopt-java/src/test/java/com/nvidia/cuopt/optimization/MIPCallbackIT.java b/java/cuopt-java/src/test/java/com/nvidia/cuopt/optimization/MIPCallbackIT.java new file mode 100644 index 000000000..4f749cc11 --- /dev/null +++ b/java/cuopt-java/src/test/java/com/nvidia/cuopt/optimization/MIPCallbackIT.java @@ -0,0 +1,116 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +import static com.nvidia.cuopt.cuOpt.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.atomic.AtomicInteger; +import org.junit.jupiter.api.Test; + +class MIPCallbackIT { + + /** Captures one incumbent delivered by the solver. */ + private record Incumbent(double[] solution, double objective, double bound) {} + + /** + * Same 5-item knapsack as {@link MilpSolverIT}. Registers a Get callback + * and asserts that at least one incumbent was delivered, that array + * lengths match the problem dimensions, and that the final objective + * reported via {@link Problem#objectiveValue()} agrees with the last + * incumbent's objective. + */ + @Test + void get_callback_receives_incumbents() { + double[] values = {8.0, 4.0, 12.0, 3.0, 9.0}; + double[] weights = {5.0, 3.0, 8.0, 2.0, 6.0}; + double capacity = 15.0; + int n = values.length; + + List incumbents = new ArrayList<>(); + + try (var problem = new Problem("knapsack-cb"); + var settings = new SolverSettings() + .setTimeLimit(30.0) + .setRelativeMipGap(0.01)) { + + settings.setMIPGetSolutionCallback((sol, obj, bound) -> { + // Snapshot — solver may overwrite the underlying buffer after we return. + incumbents.add(new Incumbent(sol.clone(), obj, bound)); + }); + + Variable[] x = new Variable[n]; + for (int i = 0; i < n; i++) { + x[i] = problem.addVariable(0, 1, INTEGER, "x" + i); + } + problem.addConstraint(new LinearExpr().addTerms(weights, x), + LESS_EQUAL, capacity, "capacity"); + problem.setObjective(new LinearExpr().addTerms(values, x), MAXIMIZE); + + problem.solve(settings); + + assertTrue(problem.isMIP()); + assertTrue(!incumbents.isEmpty(), + "Get callback should have been invoked at least once"); + + for (Incumbent inc : incumbents) { + assertEquals(n, inc.solution().length, + "Each incumbent's primal array must match numVariables"); + } + + // The final solver-reported objective should match the best incumbent's. + double bestSeen = Double.NEGATIVE_INFINITY; + for (Incumbent inc : incumbents) { + if (inc.objective() > bestSeen) bestSeen = inc.objective(); + } + assertEquals(problem.objectiveValue(), bestSeen, 1e-6, + "Final objectiveValue() should match the best incumbent observed"); + } + } + + /** + * Registers a Set callback that injects a known-feasible solution + * (all-zero, which trivially satisfies the capacity constraint). + * Confirms the callback was invoked at least once. + */ + @Test + void set_callback_is_invoked() { + double[] values = {8.0, 4.0, 12.0, 3.0, 9.0}; + double[] weights = {5.0, 3.0, 8.0, 2.0, 6.0}; + double capacity = 15.0; + int n = values.length; + + AtomicInteger setInvocations = new AtomicInteger(); + + try (var problem = new Problem("knapsack-set-cb"); + var settings = new SolverSettings() + .setTimeLimit(30.0) + .setRelativeMipGap(0.01)) { + + settings.setMIPSetSolutionCallback((outSol, outObj, bound) -> { + setInvocations.incrementAndGet(); + // All-zero is trivially feasible for this knapsack (no items chosen). + java.util.Arrays.fill(outSol, 0.0); + outObj[0] = 0.0; + }); + + Variable[] x = new Variable[n]; + for (int i = 0; i < n; i++) { + x[i] = problem.addVariable(0, 1, INTEGER, "x" + i); + } + problem.addConstraint(new LinearExpr().addTerms(weights, x), + LESS_EQUAL, capacity, "capacity"); + problem.setObjective(new LinearExpr().addTerms(values, x), MAXIMIZE); + + problem.solve(settings); + + assertTrue(setInvocations.get() >= 1, + "Set callback should have been invoked at least once, got " + setInvocations.get()); + } + } +} diff --git a/java/cuopt-java/src/test/java/com/nvidia/cuopt/optimization/MilpSolverIT.java b/java/cuopt-java/src/test/java/com/nvidia/cuopt/optimization/MilpSolverIT.java new file mode 100644 index 000000000..377b3db45 --- /dev/null +++ b/java/cuopt-java/src/test/java/com/nvidia/cuopt/optimization/MilpSolverIT.java @@ -0,0 +1,63 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +import static com.nvidia.cuopt.cuOpt.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + +class MilpSolverIT { + + @Test + void simple_knapsack_binary_milp() { + // 0-1 knapsack: + // maximize Σ vᵢ·xᵢ + // s.t. Σ wᵢ·xᵢ <= capacity + // xᵢ in {0, 1} + double[] values = {8.0, 4.0, 12.0, 3.0, 9.0}; + double[] weights = {5.0, 3.0, 8.0, 2.0, 6.0}; + double capacity = 15.0; + int n = values.length; + + try (var problem = new Problem("knapsack"); + var settings = new SolverSettings() + .setTimeLimit(30.0) + .setRelativeMipGap(0.01)) { + + Variable[] x = new Variable[n]; + for (int i = 0; i < n; i++) { + x[i] = problem.addVariable(0, 1, INTEGER, "x" + i); + } + + LinearExpr cap = new LinearExpr().addTerms(weights, x); + problem.addConstraint(cap, LESS_EQUAL, capacity, "capacity"); + + LinearExpr obj = new LinearExpr().addTerms(values, x); + problem.setObjective(obj, MAXIMIZE); + + problem.solve(settings); + + assertTrue(problem.isMIP()); + // Termination should be OPTIMAL, FEASIBLE_FOUND, or a limit. + TerminationStatus s = problem.status(); + assertTrue(s == TerminationStatus.OPTIMAL + || s == TerminationStatus.FEASIBLE_FOUND + || s == TerminationStatus.PRIMAL_FEASIBLE, + "MIP should find a feasible solution, got " + s); + + // Values must be near 0 or 1. + for (int i = 0; i < n; i++) { + double v = x[i].value(); + assertTrue(v < 0.5 || v > 0.5, + "x[" + i + "] should be near 0 or 1, was " + v); + } + + // MILP stats should be present. + assertTrue(problem.mipStats().isPresent()); + } + } +} diff --git a/java/cuopt-java/src/test/java/com/nvidia/cuopt/optimization/QpSolverIT.java b/java/cuopt-java/src/test/java/com/nvidia/cuopt/optimization/QpSolverIT.java new file mode 100644 index 000000000..703c637f4 --- /dev/null +++ b/java/cuopt-java/src/test/java/com/nvidia/cuopt/optimization/QpSolverIT.java @@ -0,0 +1,56 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +package com.nvidia.cuopt.optimization; + +import static com.nvidia.cuopt.cuOpt.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + +class QpSolverIT { + + /** + * Mirrors cuOpt Python {@code test_qp.py::test_solver}: + * minimize x1^2 + 4*x2^2 - 8*x1 - 16*x2 + * s.t. x1 + x2 >= 5 + * x1 >= 3 + * x2 >= 0 + */ + @Test + void simple_qp_minimize() { + try (var problem = new Problem("qp_test")) { + Variable x1 = problem.addVariable(3.0, 10.0, CONTINUOUS, "x1"); + Variable x2 = problem.addVariable(0.0, 10.0, CONTINUOUS, "x2"); + + LinearExpr c = new LinearExpr() + .addTerm(1.0, x1).addTerm(1.0, x2); + problem.addConstraint(c, GREATER_EQUAL, 5.0, "sum"); + + QuadraticExpr obj = new QuadraticExpr() + .addQuadraticTerm(1.0, x1, x1) + .addQuadraticTerm(4.0, x2, x2) + .addTerm(-8.0, x1) + .addTerm(-16.0, x2); + problem.setObjective(obj, MINIMIZE); + + assertEquals(ProblemCategory.QP, problem.problemCategory()); + + problem.solve(); + + // QP should terminate with OPTIMAL or a feasible status. + TerminationStatus s = problem.status(); + assertTrue(s == TerminationStatus.OPTIMAL + || s == TerminationStatus.PRIMAL_FEASIBLE, + "QP should be feasible and optimal, got " + s); + + // Solution within bounds. + assertTrue(x1.value() >= 3.0 - 1e-6); + assertTrue(x2.value() >= 0.0 - 1e-6); + assertTrue(x1.value() + x2.value() >= 5.0 - 1e-6, + "sum constraint should be satisfied"); + } + } +} diff --git a/java/license-header.txt b/java/license-header.txt new file mode 100644 index 000000000..2c4220c33 --- /dev/null +++ b/java/license-header.txt @@ -0,0 +1,4 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) $YEAR$, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ diff --git a/java/panama-bindings/.gitignore b/java/panama-bindings/.gitignore new file mode 100644 index 000000000..91672b2fd --- /dev/null +++ b/java/panama-bindings/.gitignore @@ -0,0 +1,2 @@ +jextract-22/ +openjdk-22-jextract*.tar.gz diff --git a/java/panama-bindings/README.md b/java/panama-bindings/README.md new file mode 100644 index 000000000..8ed197191 --- /dev/null +++ b/java/panama-bindings/README.md @@ -0,0 +1,34 @@ +# panama-bindings — jextract binding generation + +This directory invokes [`jextract`](https://github.com/openjdk/jextract) +to generate Java bindings for cuOpt's C API. + +## Files + +- `headers.h` — umbrella include listing the C headers to bind. Currently + pulls in `cpp/include/cuopt/linear_programming/cuopt_c.h` and + `constants.h`. +- `generate-bindings.sh` — invokes `jextract` with the right flags. + Output goes to + `cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama/`. + +## When this runs + +`build.sh` (one level up) runs this script on every build. The generated +files are committed to the repo so reviewers can see the binding surface +and IntelliJ can navigate to symbols. + +## Drift detection + +After regeneration, `build.sh` runs `git diff --exit-code` on the +generated directory. If `jextract` produces output that differs from +what's committed (e.g., because `cuopt_c.h` changed), the build fails +with a clear message asking the developer to commit the regenerated +files. This catches additive C API changes that the upstream +`check-c-abi` gate (planned in a follow-up PR) accepts as non-breaking. + +## Why we don't use a Maven plugin + +Running `jextract` from `mvn` (e.g., via `exec-maven-plugin`) would tie +binding regeneration to `mvn verify`, which developers may skip locally. +Running it from `build.sh` keeps it as a deliberate step. diff --git a/java/panama-bindings/generate-bindings.sh b/java/panama-bindings/generate-bindings.sh new file mode 100755 index 000000000..7feb4b250 --- /dev/null +++ b/java/panama-bindings/generate-bindings.sh @@ -0,0 +1,115 @@ +#!/bin/bash +# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Regenerates Panama bindings for cuOpt's C API into +# cuopt-java/src/main/java22/com/nvidia/cuopt/internal/panama/. +# +# Auto-downloads jextract for JDK 22 into ./jextract-22/ on first run +# (cuvs pattern). Subsequent runs reuse the local copy. Pass JEXTRACT +# explicitly to use an externally-installed jextract. +# +# Inputs: +# JEXTRACT Path to a jextract binary. Default: search PATH (and +# the local ./jextract-22/bin/). +# CUOPT_INCLUDE Path to cpp/include (defaults to ../../cpp/include). +# CUDA_INCLUDE_DIR Path to CUDA include dir. Default: $CONDA_PREFIX/ +# targets/-linux/include if present, else +# /usr/local/cuda/include. + +set -euo pipefail + +CURDIR="$(cd "$(dirname "$0")" && pwd)" +REPODIR="$(cd "${CURDIR}/../.." && pwd)" + +CUOPT_INCLUDE="${CUOPT_INCLUDE:-${REPODIR}/cpp/include}" +OUTPUT_DIR="${REPODIR}/java/cuopt-java/src/main/java22" +TARGET_PACKAGE="com.nvidia.cuopt.internal.panama" + +# Architecture detection — used to select the jextract tarball and the +# CUDA toolkit include subdirectory. +HOST_ARCH="$(uname -m)" +case "${HOST_ARCH}" in + x86_64) JEXTRACT_ARCH=x64; CUDA_TARGET_DIR="targets/x86_64-linux/include" ;; + aarch64) JEXTRACT_ARCH=aarch64; CUDA_TARGET_DIR="targets/aarch64-linux/include" ;; + *) + echo "ERROR: unsupported architecture: ${HOST_ARCH}" >&2 + echo " Supported: x86_64, aarch64." >&2 + exit 1 + ;; +esac + +# CUDA include detection — prefer the conda env's CUDA toolkit if active. +if [[ -z "${CUDA_INCLUDE_DIR:-}" ]]; then + if [[ -n "${CONDA_PREFIX:-}" ]] && [[ -d "${CONDA_PREFIX}/${CUDA_TARGET_DIR}" ]]; then + CUDA_INCLUDE_DIR="${CONDA_PREFIX}/${CUDA_TARGET_DIR}" + elif [[ -d "/usr/local/cuda/${CUDA_TARGET_DIR}" ]]; then + CUDA_INCLUDE_DIR="/usr/local/cuda/${CUDA_TARGET_DIR}" + elif [[ -d "/usr/local/cuda/include" ]]; then + CUDA_INCLUDE_DIR="/usr/local/cuda/include" + else + echo "ERROR: Could not locate a CUDA include directory." >&2 + echo " Set CUDA_INCLUDE_DIR explicitly." >&2 + exit 1 + fi +fi + +# Auto-download jextract (cuvs pattern): prepend local ./jextract-22/bin/ +# to PATH, then check if jextract is reachable. If not, download. +PATH="${CURDIR}/jextract-22/bin:${PATH}" +export PATH + +JEXTRACT="${JEXTRACT:-jextract}" +if ! command -v "${JEXTRACT}" >/dev/null 2>&1; then + JEXTRACT_FILENAME="openjdk-22-jextract+6-47_linux-${JEXTRACT_ARCH}_bin.tar.gz" + JEXTRACT_DOWNLOAD_URL="https://download.java.net/java/early_access/jextract/22/6/${JEXTRACT_FILENAME}" + echo "jextract not found. Downloading from ${JEXTRACT_DOWNLOAD_URL} ..." + ( + cd "${CURDIR}" + wget -c "${JEXTRACT_DOWNLOAD_URL}" + tar -xzf "./${JEXTRACT_FILENAME}" + echo "jextract installed to ${CURDIR}/jextract-22" + ) + # PATH was already updated above to include ${CURDIR}/jextract-22/bin +fi + +# Clean previous output so removed symbols actually disappear. +PANAMA_DIR="${OUTPUT_DIR}/com/nvidia/cuopt/internal/panama" +mkdir -p "${PANAMA_DIR}" +find "${PANAMA_DIR}" -name '*.java' -delete 2>/dev/null || true + +echo "Running jextract ..." +jextract \ + --include-dir "${CUOPT_INCLUDE}" \ + --include-dir "${CUDA_INCLUDE_DIR}" \ + --output "${OUTPUT_DIR}" \ + --target-package "${TARGET_PACKAGE}" \ + --header-class-name cuopt_c_h \ + --use-system-load-library \ + --library cuopt \ + "${CURDIR}/headers.h" + +# jextract emits `System.loadLibrary("cuopt")` in cuopt_c_h's static +# initializer (because we pass --use-system-load-library). That bypasses +# our NativeLibraryLoader and fails in embedded-classifier-JAR mode where +# libcuopt is bundled inside the JAR. Rewrite the call to route through +# our loader, which handles both embedded and BYO modes. +HEADER_CLASS_FILE="${PANAMA_DIR}/cuopt_c_h.java" +if [[ -f "${HEADER_CLASS_FILE}" ]]; then + sed -i \ + 's|System\.loadLibrary("cuopt");|com.nvidia.cuopt.internal.NativeLibraryLoader.ensureLoaded();|' \ + "${HEADER_CLASS_FILE}" +fi + +# Normalize each generated file to end with exactly one trailing newline, +# matching pre-commit's end-of-file-fixer. jextract output is inconsistent +# (sometimes 0, sometimes 2 trailing newlines); without this the drift gate +# fails after pre-commit rewrites the committed files. +for f in "${PANAMA_DIR}"/*.java; do + [[ -f "$f" ]] || continue + content="$(cat "$f")" + printf '%s\n' "$content" > "$f" +done + +echo "Panama bindings regenerated at:" +echo " ${PANAMA_DIR}" diff --git a/java/panama-bindings/headers.h b/java/panama-bindings/headers.h new file mode 100644 index 000000000..2a54eb416 --- /dev/null +++ b/java/panama-bindings/headers.h @@ -0,0 +1,9 @@ +/* SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + * + * Umbrella header for jextract. Adding a new C header here exposes its + * symbols to the Java bindings. + */ + +#include +#include