Fortran bindings for the NLopt library. While the NLopt library supports Fortran by using implicit interface calling conventions, those are not type-safe. This project offers an alternative interface to the NLopt C-API.

To build this project from the source code in this repository you need to have

• a Fortran compiler supporting Fortran 2008 (GCC 5 or newer or Intel Fortran)

• One of the supported build systems

  • meson version 0.55 or newer, with a build-system backend, i.e. ninja version 1.7 or newer
  • cmake version 3.14 or newer, with a build-system backend, i.e. ninja version 1.10 or newer
  • Fortran package manager (fpm) version 0.2.0 or newer

• nlopt version 2.0.0 or later

Setup a build with

meson setup _build 

You can select the Fortran compiler by the FC environment variable. To compile the project run

meson compile -C _build 

You can run the projects testsuite with

meson test -C _build --print-errorlogs 

To include nlopt-f in your project add the following wrap file to your subprojects directory:

[wrap-git] directory = nlopt-f url = https://github.com/grimme-lab/nlopt-f revision = head

You can retrieve the dependency from the wrap fallback with

nlopt_dep = dependency('nlopt-f', fallback: ['nlopt-f', 'nlopt_dep'])

and add it as dependency to your targets.

Alternatively, this project can be build with CMake (in this case ninja 1.10 or newer is required):

cmake -B _build -G Ninja 

To compile the project with CMake run

cmake --build _build 

You can run the project testsuite with

pushd _build && ctest && popd 

Finally, install the project using (the install prefix can be customized with -DCMAKE_INSTALL_PREFIX=/path/to/install in the first step)

cmake --install _build 

Now you can use it in your CMake project by finding it again

if(NOT "nlopt-f::nlopt-f") find_package("nlopt-f" REQUIRED) endif() # ... target_link_libraries("${PROJECT_NAME}-lib" PRIVATE "nlopt-f::nlopt-f")

Invoke fpm in the project root with

fpm build 

To run the testsuite use

fpm test 

To use nlopt-f include it as dependency in your package manifest

[dependencies] nlopt-f.git = "https://github.com/grimme-lab/nlopt-f"

The Fortran bindings target NLopt 2.5.0 by default. You can target a specific NLopt version by adding the preprocessor define NLOPT_VERSION using a compact integer representation (major * 10000 + minor * 100 + patch). To target NLopt 2.6.2 use

fpm <cmd> --profile debug --flag "-DNLOPT_VERSION=20602" 

If NLopt is not installed in a standard location use pkg-config to find it

fpm <cmd> --profile debug --flag "$(pkg-config nlopt --cflags --libs-only-L)" 

You can check your installed NLopt version using

pkg-config nlopt --modversion 

Which will print the version number.

The Fortran bindings allow an object oriented usage of the NLopt C-API:

module example_funcs implicit none integer, parameter :: wp = kind(0.0d0) type :: constraint_data real(wp) :: d(2) end type contains function myfunc(x, gradient, func_data) result(f) real(wp), intent(in) :: x(:) real(wp), intent(inout), optional :: gradient(:) class(*), intent(in), optional :: func_data real(wp) :: f if (present(gradient)) then gradient(1) = 0.0_wp gradient(2) = 0.5_wp / sqrt(x(2)) endif f = sqrt(x(2)) end function myfunc function myconstraint(x, gradient, func_data) result(f) real(wp), intent(in) :: x(:) real(wp), intent(inout), optional :: gradient(:) class(*), intent(in), optional :: func_data real(wp) :: f select type(func_data) type is(constraint_data) associate(a => func_data%d(1), b => func_data%d(2)) if (present(gradient)) then gradient(1) = 3.0_wp * a * (a*x(1) + b)**2 gradient(2) = -1.0_wp endif f = (a*x(1) + b)**3 - x(2) end associate end select end function myconstraint end module example_funcs program example use example_funcs use nlopt_wrap, only : nlopt_opt, nlopt_func, create, destroy use nlopt_enum, only : NLOPT_SUCCESS, algorithm_from_string implicit none type(nlopt_opt) :: opt real(wp) :: lb(2), x(2), minf integer :: stat type(constraint_data), target :: d1, d2 real(wp), parameter :: xtol = 1.0e-4_wp call create(opt, algorithm_from_string("LD_MMA"), 2) call opt%get_lower_bounds(lb) lb(2) = 0.0_wp call opt%set_lower_bounds(lb) d1%d = [+2.0_wp, +0.0_wp] d2%d = [-1.0_wp, +1.0_wp] associate(& & f => nlopt_func(myfunc), & & fc1 => nlopt_func(myconstraint, d1), & & fc2 => nlopt_func(myconstraint, d2)) call opt%set_min_objective(f) call opt%add_inequality_constraint(fc1, 1.0e-8_wp) call opt%add_inequality_constraint(fc2, 1.0e-8_wp) call opt%set_xtol_rel(xtol) x = [1.234_wp, 5.678_wp] call opt%optimize(x, minf, stat) end associate if (stat < NLOPT_SUCCESS) then write(*, '(a)') "NLopt failed!" stop 1 endif write(*, '(a, *(1x, g0))') "Found minimum at", x write(*, '(a, *(1x, g0))') "Minimum value is", minf call destroy(opt) end program example

This project is free software: you can redistribute it and/or modify it under the terms of the Apache License, Version 2.0 or MIT license at your opinion.

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an as is basis, without warranties or conditions of any kind, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this project by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.