unopy 0.1.0__tar.gz

unopy-0.1.0/.github/C/CMakeLists.txt

@@ -0,0 +1,25 @@
+# Copyright (c) 2025 Charlie Vanaret
+# Licensed under the MIT license. See LICENSE file in the project directory for details.
+
+cmake_minimum_required(VERSION 3.7)
+if(${CMAKE_VERSION} VERSION_LESS 3.12)
+   cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
+endif()
+
+project(tests_hs015 LANGUAGES C)
+
+# compile options
+if (MSVC)
+   add_compile_options("$<$<COMPILE_LANGUAGE:C>:/utf-8>")
+else()
+   set(CMAKE_CXX_FLAGS "-Wall -Wextra -Wnon-virtual-dtor -pedantic -Wunused-value -Wconversion")
+   set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG") # disable asserts
+endif()
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+   SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wmaybe-uninitialized")
+endif()
+
+find_library(UNO REQUIRED)
+add_executable(tests_hs015 tests_hs015.c)
+# link the math library and Uno
+target_link_libraries(tests_hs015 PUBLIC m ${UNO})

unopy-0.1.0/.github/C/tests_hs015.c

@@ -0,0 +1,217 @@
+#include <assert.h>
+#include <stdio.h>
+#include <math.h>
+#include "Uno_C_API.h"
+
+uno_int objective_function(uno_int /*number_variables*/, const double* x, double* objective_value, void* /*user_data*/) {
+	*objective_value = 100.*pow(x[1] - pow(x[0], 2.), 2.) + pow(1. - x[0], 2.);
+	return 0;
+}
+
+uno_int objective_function_max(uno_int /*number_variables*/, const double* x, double* objective_value, void* /*user_data*/) {
+	*objective_value = -(100.*pow(x[1] - pow(x[0], 2.), 2.) + pow(1. - x[0], 2.));
+	return 0;
+}
+
+uno_int constraint_functions(uno_int /*number_variables*/, uno_int /*number_constraints*/, const double* x,
+		double* constraint_values, void* /*user_data*/) {
+	constraint_values[0] = x[0]*x[1];
+	constraint_values[1] = x[0] + pow(x[1], 2.);
+	return 0;
+}
+
+uno_int objective_gradient(uno_int /*number_variables*/, const double* x, double* gradient, void* /*user_data*/) {
+	gradient[0] = 400.*pow(x[0], 3.) - 400.*x[0]*x[1] + 2.*x[0] - 2.;
+	gradient[1] = 200.*(x[1] - pow(x[0], 2.));
+	return 0;
+}
+
+uno_int objective_gradient_max(uno_int /*number_variables*/, const double* x, double* gradient, void* /*user_data*/) {
+	gradient[0] = -(400.*pow(x[0], 3.) - 400.*x[0]*x[1] + 2.*x[0] - 2.);
+	gradient[1] = -(200.*(x[1] - pow(x[0], 2.)));
+	return 0;
+}
+
+uno_int constraint_jacobian(uno_int /*number_variables*/, uno_int /*number_jacobian_nonzeros*/, const double* x,
+		double* jacobian, void* /*user_data*/) {
+	jacobian[0] = x[1];
+	jacobian[1] = 1.;
+	jacobian[2] = x[0];
+	jacobian[3] = 2.*x[1];
+	return 0.;
+}
+
+uno_int lagrangian_hessian_negative_sign(uno_int /*number_variables*/, uno_int /*number_constraints*/, uno_int /*number_hessian_nonzeros*/,
+      const double* x, double objective_multiplier, const double* multipliers, double* hessian, void* /*user_data*/) {
+	hessian[0] = objective_multiplier*(1200*pow(x[0], 2.) - 400.*x[1] + 2.);
+	hessian[1] = -400.*objective_multiplier*x[0] - multipliers[0];
+	hessian[2] = 200.*objective_multiplier - 2.*multipliers[1];
+	return 0;
+}
+
+uno_int lagrangian_hessian_positive_sign(uno_int /*number_variables*/, uno_int /*number_constraints*/, uno_int /*number_hessian_nonzeros*/,
+      const double* x, double objective_multiplier, const double* multipliers, double* hessian, void* /*user_data*/) {
+	hessian[0] = objective_multiplier*(1200*pow(x[0], 2.) - 400.*x[1] + 2.);
+	hessian[1] = -400.*objective_multiplier*x[0] + multipliers[0];
+	hessian[2] = 200.*objective_multiplier + 2.*multipliers[1];
+	return 0;
+}
+
+uno_int lagrangian_hessian_max_negative_sign(uno_int /*number_variables*/, uno_int /*number_constraints*/, uno_int /*number_hessian_nonzeros*/,
+		const double* x, double objective_multiplier, const double* multipliers, double* hessian, void* /*user_data*/) {
+	hessian[0] = -objective_multiplier*(1200*pow(x[0], 2.) - 400.*x[1] + 2.);
+	hessian[1] = -400.*-objective_multiplier*x[0] - multipliers[0];
+	hessian[2] = 200.*-objective_multiplier - 2.*multipliers[1];
+	return 0;
+}
+
+uno_int lagrangian_hessian_max_positive_sign(uno_int /*number_variables*/, uno_int /*number_constraints*/, uno_int /*number_hessian_nonzeros*/,
+		const double* x, double objective_multiplier, const double* multipliers, double* hessian, void* /*user_data*/) {
+	hessian[0] = -objective_multiplier*(1200*pow(x[0], 2.) - 400.*x[1] + 2.);
+	hessian[1] = -400.*-objective_multiplier*x[0] + multipliers[0];
+	hessian[2] = 200.*-objective_multiplier + 2.*multipliers[1];
+	return 0;
+}
+
+void print_vector(const double* vector, uno_int size) {
+	for (size_t index = 0; index < size; ++index) {
+		printf("%g ", vector[index]);
+	}
+	printf("\n");
+}
+
+void solve_instance(uno_int optimization_sense, double lagrangian_sign_convention, double reference_objective,
+		const double reference_primal_solution[], const double reference_constraint_dual_solution[],
+		const double reference_lower_bound_dual_solution[], const double reference_upper_bound_dual_solution[]) {
+	// model creation
+	const uno_int base_indexing = UNO_ZERO_BASED_INDEXING;
+	// variables
+	const uno_int number_variables = 2;
+	double variables_lower_bounds[] = {-INFINITY, -INFINITY};
+	double variables_upper_bounds[] = {0.5, INFINITY};
+	// constraints
+	const uno_int number_constraints = 2;
+	double constraints_lower_bounds[] = {1., 0.};
+	double constraints_upper_bounds[] = {INFINITY, INFINITY};
+	const uno_int number_jacobian_nonzeros = 4;
+	uno_int jacobian_row_indices[] = {0, 1, 0, 1};
+	uno_int jacobian_column_indices[] = {0, 0, 1, 1};
+	// Hessian
+	const uno_int number_hessian_nonzeros = 3;
+	const char hessian_triangular_part = UNO_LOWER_TRIANGLE;
+	uno_int hessian_row_indices[] = {0, 1, 1};
+	uno_int hessian_column_indices[] = {0, 0, 1};
+	// initial point
+	double x0[] = {-2., 1.};
+	
+	void* model = uno_create_model(UNO_PROBLEM_NONLINEAR, number_variables, variables_lower_bounds,
+      variables_upper_bounds, base_indexing);
+	if (optimization_sense == UNO_MINIMIZE) {
+		assert(uno_set_objective(model, optimization_sense, objective_function, objective_gradient));
+	}
+	else {
+		assert(uno_set_objective(model, optimization_sense, objective_function_max, objective_gradient_max));
+	}
+	assert(uno_set_constraints(model, number_constraints, constraint_functions,
+		constraints_lower_bounds, constraints_upper_bounds, number_jacobian_nonzeros,
+		jacobian_row_indices, jacobian_column_indices, constraint_jacobian));
+	if (lagrangian_sign_convention == UNO_MULTIPLIER_NEGATIVE) {
+		if (optimization_sense == UNO_MINIMIZE) {
+			assert(uno_set_lagrangian_hessian(model, number_hessian_nonzeros, hessian_triangular_part,
+				hessian_row_indices, hessian_column_indices, lagrangian_hessian_negative_sign,
+				lagrangian_sign_convention));
+		}
+		else {
+			assert(uno_set_lagrangian_hessian(model, number_hessian_nonzeros, hessian_triangular_part,
+				hessian_row_indices, hessian_column_indices, lagrangian_hessian_max_negative_sign,
+				lagrangian_sign_convention));
+		}
+	}
+	else {
+		if (optimization_sense == UNO_MINIMIZE) {
+			assert(uno_set_lagrangian_hessian(model, number_hessian_nonzeros, hessian_triangular_part,
+				hessian_row_indices, hessian_column_indices, lagrangian_hessian_positive_sign,
+				lagrangian_sign_convention));
+		}
+		else {
+			assert(uno_set_lagrangian_hessian(model, number_hessian_nonzeros, hessian_triangular_part,
+				hessian_row_indices, hessian_column_indices, lagrangian_hessian_max_positive_sign,
+				lagrangian_sign_convention));
+		}
+	}
+	assert(uno_set_initial_primal_iterate(model, x0));
+
+	// solver creation
+	void* solver = uno_create_solver();
+	uno_set_solver_preset(solver, "filtersqp");
+	uno_set_solver_string_option(solver, "logger", "INFO");
+
+	// solve
+	uno_optimize(solver, model);
+	
+	// tests
+	const uno_int optimization_status = uno_get_optimization_status(solver);
+	assert(optimization_status == UNO_SUCCESS);
+	const uno_int iterate_status = uno_get_solution_status(solver);
+	assert(iterate_status == UNO_FEASIBLE_KKT_POINT);
+	// objective
+	const double solution_objective = uno_get_solution_objective(solver);
+	assert(solution_objective == reference_objective);
+	// primal solution
+	double primal_solution[number_variables];
+	uno_get_primal_solution(solver, primal_solution);
+	for (size_t variable_index = 0; variable_index < number_variables; ++variable_index) {
+		assert(primal_solution[variable_index] == reference_primal_solution[variable_index]);
+	}
+	// constraint dual solution
+	double constraint_dual_solution[number_constraints];
+	uno_get_constraint_dual_solution(solver, constraint_dual_solution);
+	for (size_t constraint_index = 0; constraint_index < number_constraints; ++constraint_index) {
+		assert(constraint_dual_solution[constraint_index] == reference_constraint_dual_solution[constraint_index]);
+	}
+	// lower bound dual solution
+	double lower_bound_dual_solution[number_variables];
+	uno_get_lower_bound_dual_solution(solver, lower_bound_dual_solution);
+	for (size_t variable_index = 0; variable_index < number_variables; ++variable_index) {
+		assert(lower_bound_dual_solution[variable_index] == reference_lower_bound_dual_solution[variable_index]);
+	}
+	// upper bound dual solution
+	double upper_bound_dual_solution[number_variables];
+	uno_get_upper_bound_dual_solution(solver, upper_bound_dual_solution);
+	for (size_t variable_index = 0; variable_index < number_variables; ++variable_index) {
+		assert(upper_bound_dual_solution[variable_index] == reference_upper_bound_dual_solution[variable_index]);
+	}
+	
+	// cleanup
+	uno_destroy_solver(solver);
+	uno_destroy_model(model);
+}
+
+int main() {
+	const double reference_objective = 306.5;
+	const double reference_primal_solution[] = {0.5, 2};
+	const double reference_constraint_dual_solution_negative[] = {700., 0.};
+	const double reference_constraint_dual_solution_positive[] = {-700., 0.};
+	const double reference_lower_bound_dual_solution[] = {0., 0.};
+	const double reference_upper_bound_dual_solution_negative[] = {-1751., 0.};
+	const double reference_upper_bound_dual_solution_positive[] = {1751., 0.};
+	
+	solve_instance(UNO_MINIMIZE, UNO_MULTIPLIER_NEGATIVE, reference_objective,
+		reference_primal_solution, reference_constraint_dual_solution_negative,
+		reference_lower_bound_dual_solution, reference_upper_bound_dual_solution_negative);
+	printf("(UNO_MINIMIZE, UNO_MULTIPLIER_NEGATIVE) passed.\n");
+	solve_instance(UNO_MINIMIZE, UNO_MULTIPLIER_POSITIVE, reference_objective,
+		reference_primal_solution, reference_constraint_dual_solution_positive,
+		reference_lower_bound_dual_solution, reference_upper_bound_dual_solution_positive);
+	printf("(UNO_MINIMIZE, UNO_MULTIPLIER_POSITIVE) passed.\n");
+	solve_instance(UNO_MAXIMIZE, UNO_MULTIPLIER_NEGATIVE, -reference_objective,
+			reference_primal_solution, reference_constraint_dual_solution_positive,
+			reference_lower_bound_dual_solution, reference_upper_bound_dual_solution_positive);
+	printf("(UNO_MAXIMIZE, UNO_MULTIPLIER_NEGATIVE) passed.\n");
+	solve_instance(UNO_MAXIMIZE, UNO_MULTIPLIER_POSITIVE, -reference_objective,
+		reference_primal_solution, reference_constraint_dual_solution_negative,
+		reference_lower_bound_dual_solution, reference_upper_bound_dual_solution_negative);
+	printf("(UNO_MAXIMIZE, UNO_MULTIPLIER_POSITIVE) passed.\n");
+	
+	return 0;
+}

unopy-0.1.0/.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: cvanaret

unopy-0.1.0/.github/julia/.gitignore

@@ -0,0 +1,2 @@
+# Don't check Julia's Manifest.toml file into Git
+Manifest.toml

unopy-0.1.0/.github/julia/Project.toml

@@ -0,0 +1,14 @@
+[deps]
+AmplNLWriter = "7c4d4715-977e-5154-bfe0-e096adeac482"
+MINLPTests = "ee0a3090-8ee9-5cdb-b8cb-8eeba3165522"
+MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
+
+[compat]
+AmplNLWriter = "1"
+MINLPTests = "0.6.1"
+MathOptInterface = "1.33"
+Test = "1.10"
+JuMP = "1.28.0"
+julia = "1.10"

unopy-0.1.0/.github/julia/build_tarballs_release.jl

@@ -0,0 +1,170 @@
+using BinaryBuilder, Pkg
+
+haskey(ENV, "UNO_RELEASE") || error("The environment variable UNO_RELEASE is not defined.")
+haskey(ENV, "UNO_COMMIT") || error("The environment variable UNO_COMMIT is not defined.")
+haskey(ENV, "UNO_URL") || error("The environment variable UNO_URL is not defined.")
+
+name = "Uno"
+version = VersionNumber(ENV["UNO_RELEASE"])
+
+# Collection of sources required to complete build
+sources = [
+    GitSource(ENV["UNO_URL"], ENV["UNO_COMMIT"]),
+    ArchiveSource("https://mumps-solver.org/MUMPS_5.8.0.tar.gz",
+                  "d762eb8b1d9843a0993b8cfc137d043d04c7c51877ad37c94560433a474340a0"),
+]
+
+# Bash recipe for building across all platforms
+script = raw"""
+# Export dependencies
+mkdir ${prefix}/deps
+cd ${libdir}
+for file in $(ls .); do
+   if [[ -f $file ]]; then
+      if [[ -z $(ls -la $file | grep 'artifacts') ]]; then
+         cp -P ${file} ${prefix}/deps/${file}
+      else
+         cp -L ${file} ${prefix}/deps/${file}
+      fi
+   fi
+done
+cd ${prefix}
+cp -rL share/licenses deps/licenses
+mkdir deps/licenses/MUMPS
+cp $WORKSPACE/srcdir/MUMPS_5.8.0/LICENSE deps/licenses/MUMPS/LICENSE
+chmod -R u=rwx deps
+tar -czvf deps.tar.gz deps
+rm -r deps
+
+# Compile MUMPS
+mkdir -p ${libdir}
+cd $WORKSPACE/srcdir/MUMPS*
+
+makefile="Makefile.G95.SEQ"
+cp Make.inc/${makefile} Makefile.inc
+
+# Add `-fallow-argument-mismatch` if supported
+: >empty.f
+FFLAGS=()
+if gfortran -c -fallow-argument-mismatch empty.f >/dev/null 2>&1; then
+    FFLAGS+=("-fallow-argument-mismatch")
+fi
+rm -f empty.*
+
+if [[ "${target}" == *apple* ]]; then
+    SONAME="-install_name"
+else
+    SONAME="-soname"
+fi
+
+make_args+=(OPTF="-O3"
+            OPTL="-O3"
+            OPTC="-O3"
+            CDEFS=-DAdd_
+            LMETISDIR=${libdir}
+            IMETIS=-I${includedir}
+            LMETIS="-L${libdir} -lmetis"
+            ORDERINGSF="-Dpord -Dmetis"
+            LIBEXT_SHARED=".${dlext}"
+            SHARED_OPT="-shared"
+            SONAME="${SONAME}"
+            CC="$CC ${CFLAGS[@]}"
+            FC="gfortran ${FFLAGS[@]}"
+            FL="gfortran"
+            RANLIB="echo"
+            LIBBLAS="-L${libdir} -lopenblas"
+            LAPACK="-L${libdir} -lopenblas")
+
+make -j${nproc} dshared "${make_args[@]}"
+
+mkdir ${includedir}/libseq
+cp include/*.h ${includedir}
+cp libseq/*.h ${includedir}/libseq
+cp lib/*.${dlext} ${libdir}
+
+# Compile Uno
+cd $WORKSPACE/srcdir/Uno
+mkdir -p build
+cd build
+
+if [[ "${target}" == *mingw* ]]; then
+    HIGHS_DIR=${prefix}/lib
+else
+    HIGHS_DIR=${libdir}
+fi
+
+if [[ "${target}" == *apple* ]] || [[ "${target}" == *freebsd* ]]; then
+    OMP=omp
+else
+    OMP=gomp
+fi
+
+cmake \
+    -DCMAKE_INSTALL_PREFIX=${prefix} \
+    -DCMAKE_PREFIX_PATH=${libdir} \
+    -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TARGET_TOOLCHAIN} \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DAMPLSOLVER=${libdir}/libasl.${dlext} \
+    -DHIGHS_DIR=${HIGHS_DIR} \
+    -DBQPD=${prefix}/lib/libbqpd.a \
+    -DHSL=${libdir}/libhsl.${dlext} \
+    -DMUMPS_INCLUDE_DIR=${includedir} \
+    -DMETIS_INCLUDE_DIR=${includedir} \
+    -DMUMPS_LIBRARY="${libdir}/libdmumps.${dlext}" \
+    -DMUMPS_COMMON_LIBRARY="${libdir}/libmumps_common.${dlext}" \
+    -DMUMPS_PORD_LIBRARY="${libdir}/libpord.${dlext}" \
+    -DMUMPS_MPISEQ_LIBRARY="${libdir}/libmpiseq.${dlext}" \
+    -DBLAS_LIBRARIES="${libdir}/libopenblas.${dlext}" \
+    -DLAPACK_LIBRARIES="${libdir}/libopenblas.${dlext}" \
+    -DBUILD_STATIC_LIBS=ON \
+    -DBUILD_SHARED_LIBS=ON \
+    ..
+
+make uno_ampl -j${nproc}
+make install
+
+# Uno
+install_license ${WORKSPACE}/srcdir/Uno/LICENSE
+"""
+
+# These are the platforms we will build for by default, unless further
+# platforms are passed in on the command line
+platforms = supported_platforms()
+platforms = expand_gfortran_versions(platforms)
+
+# The products that we will ensure are always built
+products = [
+   LibraryProduct("libdmumps", :libdmumps),
+   ExecutableProduct("uno_ampl", :amplexe),
+   LibraryProduct("libuno", :libuno),
+   FileProduct("lib/libuno.a", :libuno_a),
+]
+
+# Dependencies that must be installed before this package can be built
+dependencies = [
+    BuildDependency(PackageSpec(name="BQPD_jll", uuid="1325ac01-0a49-589f-8355-43321054aaab")),
+    Dependency(PackageSpec(name="HiGHS_jll", uuid="8fd58aa0-07eb-5a78-9b36-339c94fd15ea"), compat="=1.12.0"),
+    Dependency(PackageSpec(name="HSL_jll", uuid="017b0a0e-03f4-516a-9b91-836bbd1904dd")),
+    Dependency(PackageSpec(name="METIS_jll", uuid="d00139f3-1899-568f-a2f0-47f597d42d70")),
+    Dependency(PackageSpec(name="ASL_jll", uuid="ae81ac8f-d209-56e5-92de-9978fef736f9"), compat="0.1.3"),
+    Dependency(PackageSpec(name="OpenBLAS32_jll", uuid="656ef2d0-ae68-5445-9ca0-591084a874a2")),
+    # For OpenMP we use libomp from `LLVMOpenMP_jll` where we use LLVM as compiler (BSD systems),
+    # and libgomp from `CompilerSupportLibraries_jll` everywhere else.
+    Dependency(PackageSpec(name="CompilerSupportLibraries_jll", uuid="e66e0078-7015-5450-92f7-15fbd957f2ae"); platforms=filter(!Sys.isbsd, platforms)),
+    Dependency(PackageSpec(name="LLVMOpenMP_jll", uuid="1d63c593-3942-5779-bab2-d838dc0a180e"); platforms=filter(Sys.isbsd, platforms)),
+    HostBuildDependency(PackageSpec(name="CMake_jll", uuid="3f4e10e2-61f2-5801-8945-23b9d642d0e6")),
+]
+
+build_tarballs(
+    ARGS,
+    name,
+    version,
+    sources,
+    script,
+    platforms,
+    products,
+    dependencies;
+    julia_compat = "1.6",
+    preferred_gcc_version = v"10.2.0",
+    clang_use_lld=false,
+)

unopy-0.1.0/.github/julia/build_tarballs_yggdrasil.jl

@@ -0,0 +1,115 @@
+# Note that this script can accept some limited command-line arguments, run
+# `julia build_tarballs.jl --help` to see a usage message.
+using BinaryBuilder, Pkg
+
+haskey(ENV, "UNO_RELEASE") || error("The environment variable UNO_RELEASE is not defined.")
+haskey(ENV, "UNO_COMMIT") || error("The environment variable UNO_COMMIT is not defined.")
+haskey(ENV, "UNO_URL") || error("The environment variable UNO_URL is not defined.")
+
+name = "Uno"
+version = VersionNumber(ENV["UNO_RELEASE"])
+
+# Collection of sources required to complete build
+sources = [
+    GitSource(ENV["UNO_URL"], ENV["UNO_COMMIT"]),
+]
+
+# The remainder of the file is similar to the content found at the following link:
+# https://raw.githubusercontent.com/JuliaPackaging/Yggdrasil/refs/heads/master/U/Uno/build_tarballs.jl
+script = raw"""
+cd $WORKSPACE/srcdir/Uno
+mkdir -p build
+cd build
+
+if [[ "${target}" == *mingw* ]]; then
+    LBT=blastrampoline-5
+    HIGHS_DIR=${prefix}/lib
+else
+    LBT=blastrampoline
+    HIGHS_DIR=${libdir}
+fi
+
+if [[ "${target}" == *apple* ]] || [[ "${target}" == *freebsd* ]]; then
+    OMP=omp
+else
+    OMP=gomp
+fi
+
+cmake \
+    -DCMAKE_INSTALL_PREFIX=${prefix} \
+    -DCMAKE_PREFIX_PATH=${libdir} \
+    -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TARGET_TOOLCHAIN} \
+    -DCMAKE_BUILD_TYPE=Debug \
+    -DAMPLSOLVER=${libdir}/libasl.${dlext} \
+    -DHIGHS_DIR=${HIGHS_DIR} \
+    -DBQPD=${prefix}/lib/libbqpd.a \
+    -DHSL=${libdir}/libhsl.${dlext} \
+    -DBLA_VENDOR="libblastrampoline" \
+    -DMUMPS_INCLUDE_DIR=${includedir} \
+    -DMETIS_INCLUDE_DIR=${includedir} \
+    -DMUMPS_LIBRARY="${libdir}/libdmumps.${dlext}" \
+    -DMUMPS_COMMON_LIBRARY="${libdir}/libmumps_common.${dlext}" \
+    -DMUMPS_PORD_LIBRARY="${libdir}/libpord.${dlext}" \
+    -DMUMPS_MPISEQ_LIBRARY="${libdir}/libmpiseq.${dlext}" \
+    -DBLAS_LIBRARIES="${libdir}/lib${LBT}.${dlext}" \
+    -DLAPACK_LIBRARIES="${libdir}/lib${LBT}.${dlext}" \
+    -DBUILD_STATIC_LIBS=ON \
+    -DBUILD_SHARED_LIBS=ON \
+    ..
+
+make uno_ampl -j${nproc}
+make install
+
+# Uno
+install_license ${WORKSPACE}/srcdir/Uno/LICENSE
+
+# BQPD
+cp ${prefix}/share/licenses/BQPD/LICENSE ${WORKSPACE}/srcdir/Uno/LICENSE_BQPD
+install_license ${WORKSPACE}/srcdir/Uno/LICENSE_BQPD
+"""
+
+platforms = supported_platforms()
+filter!(p -> !(Sys.isfreebsd(p) && arch(p) == "aarch64"), platforms)
+platforms = expand_cxxstring_abis(platforms)
+platforms = expand_gfortran_versions(platforms)
+
+products = [
+    # This LibraryProduct may be useful once Uno provides a C API. We omit it for now.
+    # LibraryProduct("libuno", :libuno),
+    # We call this amplexe to match the convention of other JLL packages (like Ipopt_jll) that provide AMPL wrappers
+    ExecutableProduct("uno_ampl", :amplexe),
+    LibraryProduct("libuno", :libuno),
+    FileProduct("lib/libuno.a", :libuno_a),
+]
+
+dependencies = [
+    BuildDependency(PackageSpec(name="BQPD_jll", uuid="1325ac01-0a49-589f-8355-43321054aaab")),
+    Dependency(PackageSpec(name="HiGHS_jll", uuid="8fd58aa0-07eb-5a78-9b36-339c94fd15ea"), compat="1.12.0"),
+    Dependency(PackageSpec(name="HSL_jll", uuid="017b0a0e-03f4-516a-9b91-836bbd1904dd")),
+    Dependency(PackageSpec(name="METIS_jll", uuid="d00139f3-1899-568f-a2f0-47f597d42d70")),
+    Dependency(PackageSpec(name="ASL_jll", uuid="ae81ac8f-d209-56e5-92de-9978fef736f9"), compat="0.1.3"),
+    Dependency(PackageSpec(name="MUMPS_seq_jll", uuid="d7ed1dd3-d0ae-5e8e-bfb4-87a502085b8d")),
+    Dependency(PackageSpec(name="libblastrampoline_jll", uuid="8e850b90-86db-534c-a0d3-1478176c7d93"), compat="5.4.0"),
+    # For OpenMP we use libomp from `LLVMOpenMP_jll` where we use LLVM as compiler (BSD systems),
+    # and libgomp from `CompilerSupportLibraries_jll` everywhere else.
+    Dependency(PackageSpec(name="CompilerSupportLibraries_jll", uuid="e66e0078-7015-5450-92f7-15fbd957f2ae"); platforms=filter(!Sys.isbsd, platforms)),
+    Dependency(PackageSpec(name="LLVMOpenMP_jll", uuid="1d63c593-3942-5779-bab2-d838dc0a180e"); platforms=filter(Sys.isbsd, platforms)),
+
+    # We need at least 3.29 (Ygg version), or 3.30 upstream version for LBT support,
+    # so always pull the most recent CMake version.
+    HostBuildDependency(PackageSpec(name="CMake_jll", uuid="3f4e10e2-61f2-5801-8945-23b9d642d0e6")),
+]
+
+build_tarballs(
+    ARGS,
+    name,
+    version,
+    sources,
+    script,
+    platforms,
+    products,
+    dependencies;
+    julia_compat = "1.9",
+    preferred_gcc_version = v"10.2.0",
+    clang_use_lld=false,
+)

unopy-0.1.0/.github/julia/generate_binaries.jl

@@ -0,0 +1,75 @@
+# Version
+haskey(ENV, "UNO_RELEASE") || error("The environment variable UNO_RELEASE is not defined.")
+version = VersionNumber(ENV["UNO_RELEASE"])
+version2 = ENV["UNO_RELEASE"]
+package = "Uno"
+
+platforms = [
+   ("aarch64-apple-darwin-cxx11"  , "lib", "dylib"),
+   ("aarch64-linux-gnu-cxx11"     , "lib", "so"   ),
+#  ("aarch64-linux-musl-cxx11"    , "lib", "so"   ),
+#  ("powerpc64le-linux-gnu-cxx11" , "lib", "so"   ),
+   ("x86_64-apple-darwin-cxx11"   , "lib", "dylib"),
+   ("x86_64-linux-gnu-cxx11"      , "lib", "so"   ),
+#  ("x86_64-linux-musl-cxx11"     , "lib", "so"   ),
+#  ("x86_64-unknown-freebsd-cxx11", "lib", "so"   ),
+   ("x86_64-w64-mingw32-cxx11"    , "bin", "dll"  ),
+]
+
+for (platform, libdir, ext) in platforms
+
+  tarball_name = "$package.v$version.$platform.tar.gz"
+
+  if isfile("products/$(tarball_name)")
+    # Unzip the tarball generated by BinaryBuilder.jl
+    isdir("products/$platform") && rm("products/$platform", recursive=true)
+    mkdir("products/$platform")
+    run(`tar -xzf products/$(tarball_name) -C products/$platform`)
+
+    if isfile("products/$platform/deps.tar.gz")
+      # Unzip the tarball of the dependencies
+      run(`tar -xzf products/$platform/deps.tar.gz -C products/$platform`)
+
+      # Copy the license of each dependency
+      for folder in readdir("products/$platform/deps/licenses")
+       cp("products/$platform/deps/licenses/$folder", "products/$platform/share/licenses/$folder")
+      end
+      rm("products/$platform/deps/licenses", recursive=true)
+
+      # Copy the shared library of each dependency
+      for file in readdir("products/$platform/deps")
+        cp("products/$platform/deps/$file", "products/$platform/$libdir/$file")
+      end
+
+      # Remove the folder used to unzip the tarball of the dependencies
+      rm("products/$platform/deps", recursive=true)
+      rm("products/$platform/deps.tar.gz", recursive=true)
+
+      # Create the archives *_binaries
+      isfile("$(package)_binaries.$version2.$platform.tar.gz") && rm("$(package)_binaries.$version2.$platform.tar.gz")
+      isfile("$(package)_binaries.$version2.$platform.zip") && rm("$(package)_binaries.$version2.$platform.zip")
+      cd("products/$platform")
+
+      # Create a folder with the version number of the package
+      mkdir("$(package)_binaries.$version2")
+      for folder in ("lib", "bin", "share")
+        cp(folder, "$(package)_binaries.$version2/$folder")
+      end
+
+      cd("$(package)_binaries.$version2")
+      if ext == "dll"
+        run(`zip -r --symlinks ../../../$(package)_binaries.$version2.$platform.zip lib bin share`)
+      else
+        run(`tar -czf ../../../$(package)_binaries.$version2.$platform.tar.gz lib bin share`)
+      end
+      cd("../../..")
+
+      # Remove the folder used to unzip the tarball generated by BinaryBuilder.jl
+      rm("products/$platform", recursive=true)
+    else
+      @warn("The tarball deps.tar.gz is missing in $(tarball_name)!")
+    end
+  # else
+  #   @warn("The tarball for the platform $platform was not generated!")
+  end
+end