nlopt 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4700baee481eb9311b975cfd317df2f242f8e38f126b36fd44f14a34e9bee18b
+  data.tar.gz: 8b11358fa772f186d6b562e85b23e8c8c7879d3d208b0cd7f4b2cf007481f867
+SHA512:
+  metadata.gz: 73da0c81d6aafc93c9e21c0ae9474f112bdb9923a9dd08d176ac24a3b191047ca902f011cc37015395d7b2159237c9895d6cea9a869bd00c092263e9259d3204
+  data.tar.gz: 57c37e5d06d5e5ebe37c70e70e8744225ecb2c5b7732c77a8c9b19c76d2f0d064f7bc4bd5146c4f1c46017f2f597583e1854a2695152cd9cc8bb1fdf630e7c44

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 (2024-12-14)
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+Copyright (c) 2007-2024 Massachusetts Institute of Technology
+Copyright (c) 2024 Andrew Kane
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,77 @@
+# NLopt Ruby
+
+[NLopt](https://github.com/stevengj/nlopt) - nonlinear optimization - for Ruby
+
+[![Build Status](https://github.com/ankane/nlopt-ruby/actions/workflows/build.yml/badge.svg)](https://github.com/ankane/nlopt-ruby/actions)
+
+## Installation
+
+First, install NLopt. For Homebrew, use:
+
+```sh
+brew install nlopt
+```
+
+And for Ubuntu, use:
+
+```sh
+sudo apt-get install libnlopt0
+```
+
+Then add this line to your application’s Gemfile:
+
+```ruby
+gem "nlopt"
+```
+
+## Getting Started
+
+Create an optimization
+
+```ruby
+opt = NLopt::Opt.new("LN_COBYLA", 2)
+```
+
+Set the objective function
+
+```ruby
+f = lambda do |x, grad|
+  x[0] + x[1]
+end
+opt.set_min_objective(f)
+```
+
+Set constraints
+
+```ruby
+opt.set_lower_bounds([1, 2])
+opt.set_upper_bounds([3, 4])
+```
+
+Perform the optimization
+
+```ruby
+xopt = opt.optimize([2, 3])
+```
+
+## History
+
+View the [changelog](https://github.com/ankane/nlopt-ruby/blob/master/CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/ankane/nlopt-ruby/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/nlopt-ruby/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features
+
+To get started with development:
+
+```sh
+git clone https://github.com/ankane/nlopt-ruby.git
+cd nlopt-ruby
+bundle install
+bundle exec rake test
+```

data/lib/nlopt/ffi.rb

@@ -0,0 +1,56 @@
+module NLopt
+  module FFI
+    extend Fiddle::Importer
+
+    libs = Array(NLopt.ffi_lib).dup
+    begin
+      dlload Fiddle.dlopen(libs.shift)
+    rescue Fiddle::DLError => e
+      retry if libs.any?
+      raise e
+    end
+
+    # https://github.com/stevengj/nlopt/blob/master/src/api/nlopt.h
+
+    typealias "nlopt_algorithm", "int"
+    typealias "nlopt_func", "void *"
+    typealias "nlopt_opt", "void *"
+    typealias "nlopt_result", "int"
+    typealias "unsigned", "unsigned int"
+
+    extern "const char * nlopt_algorithm_name(nlopt_algorithm a)"
+    extern "const char * nlopt_algorithm_to_string(nlopt_algorithm algorithm)"
+    extern "nlopt_algorithm nlopt_algorithm_from_string(const char *name)"
+
+    extern "const char * nlopt_result_to_string(nlopt_result algorithm)"
+
+    extern "void nlopt_version(int *major, int *minor, int *bugfix)"
+
+    extern "nlopt_opt nlopt_create(nlopt_algorithm algorithm, unsigned n)"
+    extern "void nlopt_destroy(nlopt_opt opt)"
+    extern "nlopt_opt nlopt_copy(const nlopt_opt opt)"
+
+    extern "nlopt_result nlopt_optimize(nlopt_opt opt, double *x, double *opt_f)"
+
+    extern "nlopt_result nlopt_set_min_objective(nlopt_opt opt, nlopt_func f, void *f_data)"
+    extern "nlopt_result nlopt_set_max_objective(nlopt_opt opt, nlopt_func f, void *f_data)"
+
+    extern "nlopt_algorithm nlopt_get_algorithm(const nlopt_opt opt)"
+    extern "unsigned nlopt_get_dimension(const nlopt_opt opt)"
+    extern "const char * nlopt_get_errmsg(nlopt_opt opt)"
+
+    extern "nlopt_result nlopt_set_lower_bounds(nlopt_opt opt, const double *lb)"
+    extern "nlopt_result nlopt_set_lower_bounds1(nlopt_opt opt, double lb)"
+    extern "nlopt_result nlopt_set_lower_bound(nlopt_opt opt, int i, double lb)"
+    extern "nlopt_result nlopt_get_lower_bounds(const nlopt_opt opt, double *lb)"
+    extern "nlopt_result nlopt_set_upper_bounds(nlopt_opt opt, const double *ub)"
+    extern "nlopt_result nlopt_set_upper_bounds1(nlopt_opt opt, double ub)"
+    extern "nlopt_result nlopt_set_upper_bound(nlopt_opt opt, int i, double ub)"
+    extern "nlopt_result nlopt_get_upper_bounds(const nlopt_opt opt, double *ub)"
+
+    extern "nlopt_result nlopt_set_maxeval(nlopt_opt opt, int maxeval)"
+    extern "int nlopt_get_maxeval(const nlopt_opt opt)"
+
+    extern "int nlopt_get_numevals(const nlopt_opt opt)"
+  end
+end

data/lib/nlopt/gradient.rb

@@ -0,0 +1,35 @@
+module NLopt
+  class Gradient
+    def initialize(ptr, n)
+      @ptr = ptr
+      @n = n
+    end
+
+    def [](index)
+      check_index(index)
+      @ptr[index * Fiddle::SIZEOF_DOUBLE, Fiddle::SIZEOF_DOUBLE].unpack1("d")
+    end
+
+    def []=(index, value)
+      check_index(index)
+      @ptr[index * Fiddle::SIZEOF_DOUBLE, Fiddle::SIZEOF_DOUBLE] = [value].pack("d")
+    end
+
+    def size
+      @n
+    end
+
+    def inspect
+      "#<#{self.class.name} #{@n.times.map { |i| self[i] }.inspect}>"
+    end
+    alias_method :to_s, :inspect
+
+    private
+
+    def check_index(index)
+      if index >= @n
+        raise IndexError, "index #{index} outside of array bounds"
+      end
+    end
+  end
+end

data/lib/nlopt/opt.rb

@@ -0,0 +1,99 @@
+module NLopt
+  class Opt
+    def initialize(algorithm, n)
+      algorithm = FFI.nlopt_algorithm_from_string(algorithm)
+      if algorithm < 0
+        raise ArgumentError, "Invalid algorithm"
+      end
+
+      if n <= 0
+        raise ArgumentError, "Invalid dimension"
+      end
+
+      @opt = FFI.nlopt_create(algorithm, n)
+      @opt.free = FFI["nlopt_destroy"]
+    end
+
+    def set_min_objective(f)
+      # keep reference
+      @f = objective_callback(f)
+      check_res FFI.nlopt_set_min_objective(@opt, @f, nil)
+    end
+
+    def set_max_objective(f)
+      # keep reference
+      @f = objective_callback(f)
+      check_res FFI.nlopt_set_max_objective(@opt, @f, nil)
+    end
+
+    def set_lower_bounds(lb)
+      if lb.is_a?(Array)
+        check_res FFI.nlopt_set_lower_bounds(@opt, Fiddle::Pointer[lb.pack("d*")])
+      elsif lb.is_a?(Numeric)
+        check_res FFI.nlopt_set_lower_bounds1(@opt, lb)
+      else
+        raise TypeError, "expected array or numeric"
+      end
+    end
+
+    def set_upper_bounds(ub)
+      if ub.is_a?(Array)
+        check_res FFI.nlopt_set_upper_bounds(@opt, Fiddle::Pointer[ub.pack("d*")])
+      elsif ub.is_a?(Numeric)
+        check_res FFI.nlopt_set_upper_bounds1(@opt, ub)
+      else
+        raise TypeError, "expected array or numeric"
+      end
+    end
+
+    def set_maxeval(maxeval)
+      check_res FFI.nlopt_set_maxeval(@opt, maxeval)
+    end
+
+    def optimize(init)
+      if init.size != dimension
+        raise ArgumentError, "size does not match dimension"
+      end
+
+      x = Fiddle::Pointer[init.pack("d*")]
+      opt_f = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE)
+      res = FFI.nlopt_optimize(@opt, x, opt_f)
+
+      if res < 0 && res != -4
+        errmsg = FFI.nlopt_get_errmsg(@opt)
+        msg = !errmsg.null? ? errmsg.to_s : "Bad result: #{FFI.nlopt_result_to_string(res).to_s}"
+        raise Error, msg
+      end
+
+      x.to_s(x.size).unpack("d*")
+    end
+
+    def algorithm_name
+      FFI.nlopt_algorithm_name(FFI.nlopt_get_algorithm(@opt)).to_s
+    end
+
+    def dimension
+      FFI.nlopt_get_dimension(@opt)
+    end
+
+    def numevals
+      FFI.nlopt_get_numevals(@opt)
+    end
+
+    private
+
+    def check_res(res)
+      if res != 1
+        raise Error, "Bad result: #{FFI.nlopt_result_to_string(res).to_s}"
+      end
+    end
+
+    def objective_callback(f)
+     Fiddle::Closure::BlockCaller.new(Fiddle::TYPE_DOUBLE, [Fiddle::TYPE_UINT, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP]) do |n, x, gradient, func_data|
+        x = x.to_s(n * Fiddle::SIZEOF_DOUBLE).unpack("d*")
+        grad = !gradient.null? ? Gradient.new(gradient, n) : nil
+        f.call(x, grad)
+      end
+    end
+  end
+end

data/lib/nlopt/version.rb

@@ -0,0 +1,3 @@
+module NLopt
+  VERSION = "0.1.0"
+end

data/lib/nlopt.rb

@@ -0,0 +1,40 @@
+# stdlib
+require "fiddle/import"
+
+# modules
+require_relative "nlopt/gradient"
+require_relative "nlopt/opt"
+require_relative "nlopt/version"
+
+module NLopt
+  class Error < StandardError; end
+
+  class << self
+    attr_accessor :ffi_lib
+  end
+  lib_name =
+    if Gem.win_platform?
+      # TODO test
+      ["nlopt.dll"]
+    elsif RbConfig::CONFIG["host_os"] =~ /darwin/i
+      if RbConfig::CONFIG["host_cpu"] =~ /arm|aarch64/i
+        ["libnlopt.dylib", "/opt/homebrew/lib/libnlopt.dylib"]
+      else
+        ["libnlopt.dylib"]
+      end
+    else
+      # libnlopt-dev has libnlopt.so
+      # libnlopt0 has libnlopt.so.0
+      ["libnlopt.so", "libnlopt.so.0"]
+    end
+  self.ffi_lib = lib_name
+
+  # friendlier error message
+  autoload :FFI, "nlopt/ffi"
+
+  def self.lib_version
+    major, minor, bugfix = 3.times.map { Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT) }
+    FFI.nlopt_version(major, minor, bugfix)
+    [major, minor, bugfix].map { |v| v.to_s(v.size).unpack1("i") }.join(".")
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: nlopt
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Kane
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fiddle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email: andrew@ankane.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/nlopt.rb
+- lib/nlopt/ffi.rb
+- lib/nlopt/gradient.rb
+- lib/nlopt/opt.rb
+- lib/nlopt/version.rb
+homepage: https://github.com/ankane/nlopt-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Nonlinear optimization for Ruby
+test_files: []