nlopt 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4700baee481eb9311b975cfd317df2f242f8e38f126b36fd44f14a34e9bee18b
-  data.tar.gz: 8b11358fa772f186d6b562e85b23e8c8c7879d3d208b0cd7f4b2cf007481f867
+  metadata.gz: c779a5c494c4f27159c477063ddf7574c40b9813936d25ca24a0e9b72a6c897c
+  data.tar.gz: dc7dd6083dfc4696ad9795fcb3565d7a67ecd150ca14b56bc99afdc171908335
 SHA512:
-  metadata.gz: 73da0c81d6aafc93c9e21c0ae9474f112bdb9923a9dd08d176ac24a3b191047ca902f011cc37015395d7b2159237c9895d6cea9a869bd00c092263e9259d3204
-  data.tar.gz: 57c37e5d06d5e5ebe37c70e70e8744225ecb2c5b7732c77a8c9b19c76d2f0d064f7bc4bd5146c4f1c46017f2f597583e1854a2695152cd9cc8bb1fdf630e7c44
+  metadata.gz: f9dde169b1604d8a2c4a726aff6faecfde7d63180a936ec4f0d640d02bb6f36cee1833718f3486c926da8332b34e0a6cdcf34518b853c1cbcf7a386873ccb378
+  data.tar.gz: 37b4f469c22ff6e21d4e1012ad1fcd7f6c09cc478cc215917d01a73c9aef04003dbce4c95f44f836dbf6b71c82e604acf43dddc8f9b8bb6ff510a871e6d3bd69

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.1.2 (2024-12-16)
+
+- Added `add_inequality_constraint` and `add_equality_constraint` methods
+- Added `initial_step` method
+
+## 0.1.1 (2024-12-15)
+
+- Added more methods
+
 ## 0.1.0 (2024-12-14)
 
 - First release

data/README.md

@@ -12,7 +12,7 @@ First, install NLopt. For Homebrew, use:
 brew install nlopt
 ```
 
-And for Ubuntu, use:
+And for Ubuntu 22.04+, use:
 
 ```sh
 sudo apt-get install libnlopt0
@@ -54,6 +54,10 @@ Perform the optimization
 xopt = opt.optimize([2, 3])
 ```
 
+## API
+
+This library follows the [NLopt Python API](https://nlopt.readthedocs.io/en/latest/NLopt_Python_Reference/). You can follow Python tutorials and convert the code to Ruby in many cases. Feel free to open an issue if you run into problems.
+
 ## History
 
 View the [changelog](https://github.com/ankane/nlopt-ruby/blob/master/CHANGELOG.md)

data/lib/nlopt/ffi.rb

@@ -14,18 +14,31 @@ module NLopt
 
     typealias "nlopt_algorithm", "int"
     typealias "nlopt_func", "void *"
+    typealias "nlopt_mfunc", "void *"
     typealias "nlopt_opt", "void *"
+    typealias "nlopt_precond", "void *"
     typealias "nlopt_result", "int"
     typealias "unsigned", "unsigned int"
 
     extern "const char * nlopt_algorithm_name(nlopt_algorithm a)"
+
+    # nlopt_algorithm enum <-> string conversion
+
     extern "const char * nlopt_algorithm_to_string(nlopt_algorithm algorithm)"
     extern "nlopt_algorithm nlopt_algorithm_from_string(const char *name)"
 
+    # nlopt_result enum <-> string conversion
+
     extern "const char * nlopt_result_to_string(nlopt_result algorithm)"
+    extern "nlopt_result nlopt_result_from_string(const char *name)"
+
+    extern "void nlopt_srand(unsigned long seed)"
+    extern "void nlopt_srand_time(void)"
 
     extern "void nlopt_version(int *major, int *minor, int *bugfix)"
 
+    # object-oriented api
+
     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)"
@@ -35,10 +48,24 @@ module NLopt
     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_result nlopt_set_precond_min_objective(nlopt_opt opt, nlopt_func f, nlopt_precond pre, void *f_data)"
+    extern "nlopt_result nlopt_set_precond_max_objective(nlopt_opt opt, nlopt_func f, nlopt_precond pre, 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)"
 
+    # generic algorithm parameters
+
+    extern "nlopt_result nlopt_set_param(nlopt_opt opt, const char *name, double val)"
+    extern "double nlopt_get_param(const nlopt_opt opt, const char *name, double defaultval)"
+    extern "int nlopt_has_param(const nlopt_opt opt, const char *name)"
+    extern "unsigned nlopt_num_params(const nlopt_opt opt)"
+    extern "const char * nlopt_nth_param(const nlopt_opt opt, unsigned n)"
+
+    # constraints
+
     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)"
@@ -48,9 +75,60 @@ module NLopt
     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_remove_inequality_constraints(nlopt_opt opt)"
+    extern "nlopt_result nlopt_add_inequality_constraint(nlopt_opt opt, nlopt_func fc, void *fc_data, double tol)"
+    extern "nlopt_result nlopt_add_precond_inequality_constraint(nlopt_opt opt, nlopt_func fc, nlopt_precond pre, void *fc_data, double tol)"
+    extern "nlopt_result nlopt_add_inequality_mconstraint(nlopt_opt opt, unsigned m, nlopt_mfunc fc, void *fc_data, const double *tol)"
+
+    extern "nlopt_result nlopt_remove_equality_constraints(nlopt_opt opt)"
+    extern "nlopt_result nlopt_add_equality_constraint(nlopt_opt opt, nlopt_func h, void *h_data, double tol)"
+    extern "nlopt_result nlopt_add_precond_equality_constraint(nlopt_opt opt, nlopt_func h, nlopt_precond pre, void *h_data, double tol)"
+    extern "nlopt_result nlopt_add_equality_mconstraint(nlopt_opt opt, unsigned m, nlopt_mfunc h, void *h_data, const double *tol)"
+
+    # stopping criteria
+
+    extern "nlopt_result nlopt_set_stopval(nlopt_opt opt, double stopval)"
+    extern "double nlopt_get_stopval(const nlopt_opt opt)"
+
+    extern "nlopt_result nlopt_set_ftol_rel(nlopt_opt opt, double tol)"
+    extern "double nlopt_get_ftol_rel(const nlopt_opt opt)"
+    extern "nlopt_result nlopt_set_ftol_abs(nlopt_opt opt, double tol)"
+    extern "double nlopt_get_ftol_abs(const nlopt_opt opt)"
+
+    extern "nlopt_result nlopt_set_xtol_rel(nlopt_opt opt, double tol)"
+    extern "double nlopt_get_xtol_rel(const nlopt_opt opt)"
+    extern "nlopt_result nlopt_set_xtol_abs1(nlopt_opt opt, double tol)"
+    extern "nlopt_result nlopt_set_xtol_abs(nlopt_opt opt, const double *tol)"
+    extern "nlopt_result nlopt_get_xtol_abs(const nlopt_opt opt, double *tol)"
+    extern "nlopt_result nlopt_set_x_weights1(nlopt_opt opt, double w)"
+    extern "nlopt_result nlopt_set_x_weights(nlopt_opt opt, const double *w)"
+    extern "nlopt_result nlopt_get_x_weights(const nlopt_opt opt, double *w)"
+
     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)"
+
+    extern "nlopt_result nlopt_set_maxtime(nlopt_opt opt, double maxtime)"
+    extern "double nlopt_get_maxtime(const nlopt_opt opt)"
+
+    extern "nlopt_result nlopt_force_stop(nlopt_opt opt)"
+    extern "nlopt_result nlopt_set_force_stop(nlopt_opt opt, int val)"
+    extern "int nlopt_get_force_stop(const nlopt_opt opt)"
+
+    # more algorithm-specific parameters
+
+    extern "nlopt_result nlopt_set_local_optimizer(nlopt_opt opt, const nlopt_opt local_opt)"
+
+    extern "nlopt_result nlopt_set_population(nlopt_opt opt, unsigned pop)"
+    extern "unsigned nlopt_get_population(const nlopt_opt opt)"
+
+    extern "nlopt_result nlopt_set_vector_storage(nlopt_opt opt, unsigned dim)"
+    extern "unsigned nlopt_get_vector_storage(const nlopt_opt opt)"
+
+    extern "nlopt_result nlopt_set_default_initial_step(nlopt_opt opt, const double *x)"
+    extern "nlopt_result nlopt_set_initial_step(nlopt_opt opt, const double *dx)"
+    extern "nlopt_result nlopt_set_initial_step1(nlopt_opt opt, double dx)"
+    extern "nlopt_result nlopt_get_initial_step(const nlopt_opt opt, const double *x, double *dx)"
   end
 end

data/lib/nlopt/gradient.rb

@@ -6,12 +6,12 @@ module NLopt
     end
 
     def [](index)
-      check_index(index)
+      index = check_index(index)
       @ptr[index * Fiddle::SIZEOF_DOUBLE, Fiddle::SIZEOF_DOUBLE].unpack1("d")
     end
 
     def []=(index, value)
-      check_index(index)
+      index = check_index(index)
       @ptr[index * Fiddle::SIZEOF_DOUBLE, Fiddle::SIZEOF_DOUBLE] = [value].pack("d")
     end
 
@@ -26,10 +26,13 @@ module NLopt
 
     private
 
-    def check_index(index)
-      if index >= @n
-        raise IndexError, "index #{index} outside of array bounds"
+    def check_index(original_index)
+      index = original_index
+      index += @n if index < 0
+      if index < 0 || index >= @n
+        raise IndexError, "index #{original_index} outside of array bounds"
       end
+      index
     end
   end
 end

data/lib/nlopt/opt.rb

@@ -1,5 +1,7 @@
 module NLopt
   class Opt
+    attr_reader :last_optimum_value
+
     def initialize(algorithm, n)
       algorithm = FFI.nlopt_algorithm_from_string(algorithm)
       if algorithm < 0
@@ -12,23 +14,34 @@ module NLopt
 
       @opt = FFI.nlopt_create(algorithm, n)
       @opt.free = FFI["nlopt_destroy"]
+
+      @inequality_constraints = []
+      @equality_constraints = []
+    end
+
+    def dimension
+      FFI.nlopt_get_dimension(@opt)
+    end
+
+    def algorithm_name
+      FFI.nlopt_algorithm_name(FFI.nlopt_get_algorithm(@opt)).to_s
     end
 
     def set_min_objective(f)
-      # keep reference
-      @f = objective_callback(f)
-      check_res FFI.nlopt_set_min_objective(@opt, @f, nil)
+      cb = objective_callback(f)
+      check_res FFI.nlopt_set_min_objective(@opt, cb, nil)
+      @cb = cb # keep reference
     end
 
     def set_max_objective(f)
-      # keep reference
-      @f = objective_callback(f)
-      check_res FFI.nlopt_set_max_objective(@opt, @f, nil)
+      cb = objective_callback(f)
+      check_res FFI.nlopt_set_max_objective(@opt, cb, nil)
+      @cb = cb # keep reference
     end
 
     def set_lower_bounds(lb)
       if lb.is_a?(Array)
-        check_res FFI.nlopt_set_lower_bounds(@opt, Fiddle::Pointer[lb.pack("d*")])
+        check_res FFI.nlopt_set_lower_bounds(@opt, alloc_dptr(lb))
       elsif lb.is_a?(Numeric)
         check_res FFI.nlopt_set_lower_bounds1(@opt, lb)
       else
@@ -38,7 +51,7 @@ module NLopt
 
     def set_upper_bounds(ub)
       if ub.is_a?(Array)
-        check_res FFI.nlopt_set_upper_bounds(@opt, Fiddle::Pointer[ub.pack("d*")])
+        check_res FFI.nlopt_set_upper_bounds(@opt, alloc_dptr(ub))
       elsif ub.is_a?(Numeric)
         check_res FFI.nlopt_set_upper_bounds1(@opt, ub)
       else
@@ -46,16 +59,139 @@ module NLopt
       end
     end
 
+    def lower_bounds
+      out_dptr { |ptr| FFI.nlopt_get_lower_bounds(@opt, ptr) }
+    end
+
+    def upper_bounds
+      out_dptr { |ptr| FFI.nlopt_get_upper_bounds(@opt, ptr) }
+    end
+
+    def add_inequality_constraint(fc, tol: 0)
+      cb = objective_callback(fc)
+      check_res FFI.nlopt_add_inequality_constraint(@opt, cb, nil, tol)
+      @inequality_constraints << cb # keep reference
+    end
+
+    def add_equality_constraint(h, tol: 0)
+      cb = objective_callback(h)
+      check_res FFI.nlopt_add_equality_constraint(@opt, cb, nil, tol)
+      @equality_constraints << cb # keep reference
+    end
+
+    def remove_inequality_constraints
+      check_res FFI.nlopt_remove_inequality_constraints(@opt)
+      @inequality_constraints.clear
+    end
+
+    def remove_equality_constraints
+      check_res FFI.nlopt_remove_equality_constraints(@opt)
+      @equality_constraints.clear
+    end
+
+    def set_stopval(stopval)
+      check_res FFI.nlopt_set_stopval(@opt, stopval)
+    end
+
+    def stopval
+      FFI.nlopt_get_stopval(@opt)
+    end
+
+    def set_ftol_rel(tol)
+      check_res FFI.nlopt_set_ftol_rel(@opt, tol)
+    end
+
+    def ftol_rel
+      FFI.nlopt_get_ftol_rel(@opt)
+    end
+
+    def set_ftol_abs(tol)
+      check_res FFI.nlopt_set_ftol_abs(@opt, tol)
+    end
+
+    def ftol_abs
+      FFI.nlopt_get_ftol_abs(@opt)
+    end
+
+    def set_xtol_rel(tol)
+      check_res FFI.nlopt_set_xtol_rel(@opt, tol)
+    end
+
+    def xtol_rel
+      FFI.nlopt_get_xtol_rel(@opt)
+    end
+
+    def set_xtol_abs(tol)
+      if tol.is_a?(Array)
+        check_res FFI.nlopt_set_xtol_abs(@opt, alloc_dptr(tol))
+      elsif tol.is_a?(Numeric)
+        check_res FFI.nlopt_set_xtol_abs1(@opt, tol)
+      else
+        raise TypeError, "expected array or numeric"
+      end
+    end
+
+    def xtol_abs
+      out_dptr { |ptr| FFI.nlopt_get_xtol_abs(@opt, ptr) }
+    end
+
+    def set_x_weights(w)
+      if w.is_a?(Array)
+        check_res FFI.nlopt_set_x_weights(@opt, alloc_dptr(w))
+      elsif w.is_a?(Numeric)
+        check_res FFI.nlopt_set_x_weights1(@opt, w)
+      else
+        raise TypeError, "expected array or numeric"
+      end
+    end
+
+    def x_weights
+      out_dptr { |ptr| FFI.nlopt_get_x_weights(@opt, ptr) }
+    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
+    def maxeval
+      FFI.nlopt_get_maxeval(@opt)
+    end
+
+    def set_maxtime(maxtime)
+      check_res FFI.nlopt_set_maxtime(@opt, maxtime)
+    end
+
+    def maxtime
+      FFI.nlopt_get_maxtime(@opt)
+    end
+
+    def numevals
+      FFI.nlopt_get_numevals(@opt)
+    end
+
+    def set_param(name, val)
+      check_res FFI.nlopt_set_param(@opt, name, val)
+    end
 
-      x = Fiddle::Pointer[init.pack("d*")]
+    def param(name, defaultval)
+      FFI.nlopt_get_param(@opt, name, defaultval)
+    end
+
+    def has_param?(name)
+      FFI.nlopt_has_param(@opt, name) == 1
+    end
+
+    def num_params
+      FFI.nlopt_num_params(@opt)
+    end
+
+    def nth_param(n)
+      ptr = FFI.nlopt_nth_param(@opt, n)
+      !ptr.null? ? ptr.to_s : nil
+    end
+
+    def optimize(init)
+      x = alloc_dptr(init)
       opt_f = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE)
       res = FFI.nlopt_optimize(@opt, x, opt_f)
 
@@ -65,19 +201,51 @@ module NLopt
         raise Error, msg
       end
 
-      x.to_s(x.size).unpack("d*")
+      @last_optimum_value = read_dptr(opt_f)[0]
+
+      read_dptr(x)
     end
 
-    def algorithm_name
-      FFI.nlopt_algorithm_name(FFI.nlopt_get_algorithm(@opt)).to_s
+    def force_stop
+      check_res FFI.nlopt_force_stop(@opt)
     end
 
-    def dimension
-      FFI.nlopt_get_dimension(@opt)
+    def set_local_optimizer(local_opt)
+      check_res FFI.nlopt_set_local_optimizer(@opt, local_opt)
     end
 
-    def numevals
-      FFI.nlopt_get_numevals(@opt)
+    def set_initial_step(dx)
+      if dx.is_a?(Array)
+        check_res FFI.nlopt_set_initial_step(@opt, alloc_dptr(dx))
+      elsif dx.is_a?(Numeric)
+        check_res FFI.nlopt_set_initial_step1(@opt, dx)
+      else
+        raise TypeError, "expected array or numeric"
+      end
+    end
+
+    def initial_step(x)
+      out_dptr { |ptr| FFI.nlopt_get_initial_step(@opt, alloc_dptr(x), ptr) }
+    end
+
+    def set_population(pop)
+      check_res FFI.nlopt_set_population(@opt, pop)
+    end
+
+    def population
+      FFI.nlopt_get_population(@opt)
+    end
+
+    def set_vector_storage(dim)
+      check_res FFI.nlopt_set_vector_storage(@opt, dim)
+    end
+
+    def vector_storage
+      FFI.nlopt_get_vector_storage(@opt)
+    end
+
+    def to_ptr
+      @opt
     end
 
     private
@@ -88,9 +256,29 @@ module NLopt
       end
     end
 
+    def alloc_dptr(arr)
+      n = dimension
+      if arr.size != n
+        raise ArgumentError, "size does not match dimension"
+      end
+      Fiddle::Pointer[arr.pack("d#{n}")]
+    end
+
+    def read_dptr(ptr, size = nil)
+      size ||= ptr.size
+      ptr.to_s(size).unpack("d*")
+    end
+
+    def out_dptr
+      ptr = Fiddle::Pointer.malloc(dimension * Fiddle::SIZEOF_DOUBLE)
+      res = yield ptr
+      check_res res
+      read_dptr(ptr)
+    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*")
+        x = read_dptr(x, n * Fiddle::SIZEOF_DOUBLE)
         grad = !gradient.null? ? Gradient.new(gradient, n) : nil
         f.call(x, grad)
       end

data/lib/nlopt/version.rb

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

data/lib/nlopt.rb

@@ -37,4 +37,24 @@ module NLopt
     FFI.nlopt_version(major, minor, bugfix)
     [major, minor, bugfix].map { |v| v.to_s(v.size).unpack1("i") }.join(".")
   end
+
+  def self.srand(seed)
+    FFI.nlopt_srand(seed)
+  end
+
+  def self.srand_time
+    FFI.nlopt_srand_time
+  end
+
+  def self.version_major
+    lib_version.split(".")[0].to_i
+  end
+
+  def self.version_minor
+    lib_version.split(".")[1].to_i
+  end
+
+  def self.version_bugfix
+    lib_version.split(".")[2].to_i
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nlopt
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-14 00:00:00.000000000 Z
+date: 2024-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fiddle