numo-optimize 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f81cd59ec9e2ae660daef989ae28a5e5a075063897598e39a1457e5d5107037
-  data.tar.gz: 304c618243188c812c8a37a9d7060bf40526c8bce3f306f21f3a75cdfb917532
+  metadata.gz: e5bf17fec048bdf99094a8885389a99b41460947c008d213e11c371ee0025792
+  data.tar.gz: 50346f22f0db6c04e33b5096f243a234e645fc2690789267d853c73918555a10
 SHA512:
-  metadata.gz: 64f1624de1f310cbb58fc390f0108e94dfbfcfd714c6f1c1a012af626bb96bf7da713470bfe076b1b0bf64a7016e5925801e6eb2e5ea014bb669ae16ab5b952d
-  data.tar.gz: 373769fc7093dc7b429f296a5f4b2361489cede752618ec6c280a612bf13c64bca2fb9d4dd027c0b147a9691f032d41ccb7c498782e850986ec8c485de1233ed
+  metadata.gz: 99b8f8600c23d3f55695ec9baf9ddeb3e00ff294fe73a6fec3a82f201b25894202dc96f3cc49b0f8455f1a703628c70f873a683351037dcbe7093472ac6fba7b
+  data.tar.gz: e95043ecd9e6b497aeb6fcedfe3fe6c9bcad124d45e5cecd89a7bda4ecf2bdb81041c5400667e0607033f3d61ac3a7b773b57518a5571b425041f1d53c90809a

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [[0.2.0](https://github.com/yoshoku/numo-optimize/compare/v0.1.0...v0.2.0)] - 2025-10-03
+
+- Add the scaled conjugate gradient method for minimization method:
+
+```ruby
+result = Numo::Optimize.minimize(method: 'SCG', ...)
+```
+
+- Add the Nelder-Mead method for minimization method:
+
+```ruby
+result = Numo::Optimize.minimize(method: 'Nelder-Mead', ...)
+```
+
 ## [0.1.0] - 2025-10-01
 
 - First release.

data/README.md

@@ -1,12 +1,13 @@
 # Numo::Optimize
 
+[![Gem Version](https://badge.fury.io/rb/numo-optimize.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/numo-optimize)
 [![Build Status](https://github.com/yoshoku/numo-optimize/actions/workflows/main.yml/badge.svg)](https://github.com/yoshoku/numo-optimize/actions/workflows/main.yml)
 [![BSD 3-Clause License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](https://github.com/yoshoku/numo-optimize/blob/main/LICENSE.txt)
+[![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://gemdocs.org/gems/numo-optimize/)
 
 Numo::Optimize (numo-optimize) provides functions for minimizing objective functions.
 This gem is based on [Lbfgsb.rb](https://github.com/yoshoku/lbfgsb.rb) and
 [mopti](https://github.com/yoshoku/mopti) by the same author.
-As for optimization algorithms, only L-BFGS-B is currently supported.
 
 Please note that numo-optimize depends on [numo-narray-alt](https://github.com/yoshoku/numo-narray-alt), not Numo::NArray.
 

data/ext/numo/optimize/optimize.c

@@ -2,6 +2,235 @@
 
 VALUE rb_mOptimize;
 VALUE rb_mLbfgsb;
+VALUE rb_mScg;
+
+#define SIGMA_INIT 1e-4
+#define BETA_MIN 1e-15
+#define BETA_MAX 1e+15
+
+static VALUE scg_fmin(VALUE self, VALUE fnc, VALUE x_val, VALUE jcb, VALUE args,
+                      VALUE xtol_val, VALUE ftol_val, VALUE jtol_val, VALUE maxiter) {
+  F77_int inc = 1;
+  double xtol = NUM2DBL(xtol_val);
+  double ftol = NUM2DBL(ftol_val);
+  double jtol = NUM2DBL(jtol_val);
+  int32_t max_iter = NUM2INT(maxiter);
+
+  if (CLASS_OF(x_val) != numo_cDFloat) {
+    x_val = rb_funcall(numo_cDFloat, rb_intern("cast"), 1, x_val);
+  }
+  if (!RTEST(nary_check_contiguous(x_val))) {
+    x_val = nary_dup(x_val);
+  }
+  narray_t* x_nary = NULL;
+  GetNArray(x_val, x_nary);
+  if (NA_NDIM(x_nary) != 1) {
+    rb_raise(rb_eArgError, "x must be a 1-D array.");
+    return Qnil;
+  }
+  F77_int n = (F77_int)NA_SIZE(x_nary);
+
+  int32_t n_fev = 0;
+  int32_t n_jev = 0;
+  double f_prev = 0.0;
+  double f_curr = 0.0;
+  VALUE j_next_val = Qnil;
+  if (RB_TYPE_P(jcb, T_TRUE)) {
+    VALUE fg_arr = rb_funcall(self, rb_intern("fnc"), 3, fnc, x_val, args);
+    f_prev = NUM2DBL(rb_ary_entry(fg_arr, 0));
+    n_fev = 1;
+    f_curr = f_prev;
+    j_next_val = rb_ary_entry(fg_arr, 1);
+    n_jev = 1;
+  } else {
+    f_prev = NUM2DBL(rb_funcall(self, rb_intern("fnc"), 3, fnc, x_val, args));
+    n_fev = 1;
+    f_curr = f_prev;
+    j_next_val = rb_funcall(self, rb_intern("jcb"), 3, jcb, x_val, args);
+    n_jev = 1;
+  }
+  if (CLASS_OF(j_next_val) != numo_cDFloat) {
+    j_next_val = rb_funcall(numo_cDFloat, rb_intern("cast"), 1, j_next_val);
+  }
+  if (!RTEST(nary_check_contiguous(j_next_val))) {
+    j_next_val = nary_dup(j_next_val);
+  }
+  double* j_next_ptr = (double*)na_get_pointer_for_read(j_next_val);
+  double j_norm = ddot_(&n, j_next_ptr, &inc, j_next_ptr, &inc);
+  VALUE j_prev_val = nary_dup(j_next_val);
+  double* d_vec = ALLOC_N(double, n);
+  for (F77_int i = 0; i < n; i++) {
+    d_vec[i] = -j_next_ptr[i];
+  }
+
+  bool success = true;
+  int32_t n_successes = 0;
+  int32_t n_iter = 0;
+  double mu = 0.0;
+  double kappa = 0.0;
+  double theta = 0.0;
+  double beta = 1.0;
+  double* j_diff_vec = ALLOC_N(double, n);
+
+  while (n_iter < max_iter) {
+    if (success) {
+      j_next_ptr = (double*)na_get_pointer_for_read(j_next_val);
+      mu = ddot_(&n, d_vec, &inc, j_next_ptr, &inc);
+      if (mu >= 0.0) {
+        for (F77_int i = 0; i < n; i++) {
+          d_vec[i] = -j_next_ptr[i];
+        }
+        mu = ddot_(&n, d_vec, &inc, j_next_ptr, &inc);
+      }
+      kappa = ddot_(&n, d_vec, &inc, d_vec, &inc);
+      if (kappa < 1e-16) {
+        break;
+      }
+
+      double sigma = SIGMA_INIT / sqrt(kappa);
+      VALUE x_plus_val = nary_dup(x_val);
+      double* x_plus_ptr = (double*)na_get_pointer_for_read_write(x_plus_val);
+      daxpy_(&n, &sigma, d_vec, &inc, x_plus_ptr, &inc);
+      VALUE j_plus_val = Qnil;
+      if (RB_TYPE_P(jcb, T_TRUE)) {
+        VALUE fg_arr = rb_funcall(self, rb_intern("fnc"), 3, fnc, x_plus_val, args);
+        j_plus_val = rb_ary_entry(fg_arr, 1);
+        n_jev++;
+      } else {
+        j_plus_val = rb_funcall(self, rb_intern("jcb"), 3, jcb, x_plus_val, args);
+        n_jev++;
+      }
+      if (CLASS_OF(j_plus_val) != numo_cDFloat) {
+        j_plus_val = rb_funcall(numo_cDFloat, rb_intern("cast"), 1, j_plus_val);
+      }
+      if (!RTEST(nary_check_contiguous(j_plus_val))) {
+        j_plus_val = nary_dup(j_plus_val);
+      }
+      double* j_plus_ptr = (double*)na_get_pointer_for_read(j_plus_val);
+      for (F77_int i = 0; i < n; i++) {
+        j_diff_vec[i] = j_plus_ptr[i] - j_next_ptr[i];
+      }
+      theta = ddot_(&n, d_vec, &inc, j_diff_vec, &inc);
+      theta /= sigma;
+      RB_GC_GUARD(x_plus_val);
+      RB_GC_GUARD(j_plus_val);
+    }
+
+    double delta = theta + beta * kappa;
+    if (delta <= 0.0) {
+      delta = beta * kappa;
+      beta -= theta / kappa;
+    }
+    double alpha = -mu / delta;
+
+    VALUE x_next_val = nary_dup(x_val);
+    double* x_next_ptr = (double*)na_get_pointer_for_read_write(x_next_val);
+    daxpy_(&n, &alpha, d_vec, &inc, x_next_ptr, &inc);
+    double f_next = 0.0;
+    if (RB_TYPE_P(jcb, T_TRUE)) {
+      VALUE fg_arr = rb_funcall(self, rb_intern("fnc"), 3, fnc, x_next_val, args);
+      f_next = NUM2DBL(rb_ary_entry(fg_arr, 0));
+      n_fev++;
+    } else {
+      f_next = NUM2DBL(rb_funcall(self, rb_intern("fnc"), 3, fnc, x_next_val, args));
+      n_fev++;
+    }
+
+    delta = 2 * (f_next - f_prev) / (alpha * mu);
+    if (delta >= 0.0) {
+      success = true;
+      n_successes++;
+      x_val = nary_dup(x_next_val);
+      f_curr = f_next;
+    } else {
+      success = false;
+      f_curr = f_prev;
+    }
+
+    RB_GC_GUARD(x_next_val);
+    n_iter++;
+
+    if (success) {
+      if (fabs(f_next - f_prev) < ftol) {
+        break;
+      }
+      double err = 0.0;
+      for (F77_int i = 0; i < n; i++) {
+        err = fmax(err, fabs(alpha * d_vec[i]));
+      }
+      if (err < xtol) {
+        break;
+      }
+
+      f_prev = f_next;
+
+      j_prev_val = nary_dup(j_next_val);
+      if (RB_TYPE_P(jcb, T_TRUE)) {
+        VALUE fg_arr = rb_funcall(self, rb_intern("fnc"), 3, fnc, x_val, args);
+        j_next_val = rb_ary_entry(fg_arr, 1);
+        n_jev++;
+      } else {
+        j_next_val = rb_funcall(self, rb_intern("jcb"), 3, jcb, x_val, args);
+        n_jev++;
+      }
+      if (CLASS_OF(j_next_val) != numo_cDFloat) {
+        j_next_val = rb_funcall(numo_cDFloat, rb_intern("cast"), 1, j_next_val);
+      }
+      if (!RTEST(nary_check_contiguous(j_next_val))) {
+        j_next_val = nary_dup(j_next_val);
+      }
+      j_next_ptr = (double*)na_get_pointer_for_read(j_next_val);
+      j_norm = ddot_(&n, j_next_ptr, &inc, j_next_ptr, &inc);
+      if (j_norm <= jtol) {
+        break;
+      }
+    }
+
+    if (delta < 0.25) {
+      beta = fmin(beta * 4, BETA_MAX);
+    } else if (delta > 0.75) {
+      beta = fmax(beta / 4, BETA_MIN);
+    }
+
+    j_next_ptr = (double*)na_get_pointer_for_read(j_next_val);
+    if (n_successes == n) {
+      for (F77_int i = 0; i < n; i++) {
+        d_vec[i] = -j_next_ptr[i];
+      }
+      beta = 1.0;
+      n_successes = 0;
+    } else if (success) {
+      double* j_prev_ptr = (double*)na_get_pointer_for_read(j_prev_val);
+      for (F77_int i = 0; i < n; i++) {
+        j_diff_vec[i] = j_prev_ptr[i] - j_next_ptr[i];
+      }
+      double gamma = ddot_(&n, j_diff_vec, &inc, j_next_ptr, &inc);
+      gamma /= mu;
+      for (F77_int i = 0; i < n; i++) {
+        d_vec[i] = -j_next_ptr[i] + gamma * d_vec[i];
+      }
+    }
+  }
+
+  xfree(j_diff_vec);
+  xfree(d_vec);
+
+  VALUE ret = rb_hash_new();
+  rb_hash_aset(ret, ID2SYM(rb_intern("task")), Qnil);
+  rb_hash_aset(ret, ID2SYM(rb_intern("x")), x_val);
+  rb_hash_aset(ret, ID2SYM(rb_intern("fnc")), DBL2NUM(f_curr));
+  rb_hash_aset(ret, ID2SYM(rb_intern("jcb")), j_next_val);
+  rb_hash_aset(ret, ID2SYM(rb_intern("n_iter")), INT2NUM(n_iter));
+  rb_hash_aset(ret, ID2SYM(rb_intern("n_fev")), INT2NUM(n_fev));
+  rb_hash_aset(ret, ID2SYM(rb_intern("n_jev")), INT2NUM(n_jev));
+  rb_hash_aset(ret, ID2SYM(rb_intern("success")), n_iter < max_iter ? Qtrue : Qfalse);
+
+  RB_GC_GUARD(x_val);
+  RB_GC_GUARD(j_next_val);
+  RB_GC_GUARD(j_prev_val);
+
+  return ret;
+}
 
 static VALUE lbfgsb_fmin(VALUE self, VALUE fnc, VALUE x_val, VALUE jcb, VALUE args, VALUE l_val, VALUE u_val,
                          VALUE nbd_val, VALUE maxcor, VALUE ftol, VALUE gtol, VALUE maxiter, VALUE disp) {
@@ -195,6 +424,10 @@ Init_optimize(void) {
    * Document-module: Numo::Optimize::Lbfgsb
    */
   rb_mLbfgsb = rb_define_module_under(rb_mOptimize, "Lbfgsb");
+  /**
+   * Document-module: Numo::Optimize::Scg
+   */
+  rb_mScg = rb_define_module_under(rb_mOptimize, "Scg");
 
 #ifdef USE_INT64
   /* The bit size of fortran integer. */
@@ -225,4 +458,23 @@ Init_optimize(void) {
    *   @return [Hash{Symbol => Object}]
    */
   rb_define_module_function(rb_mLbfgsb, "fmin", lbfgsb_fmin, 12);
+  /**
+   * Minimize a function using the scaled conjugate gradient algorithm.
+   * This module function is for internal use. It is recommended to use `Numo::Optimize.minimize`.
+   *
+   * References:
+   * - Moller, M F., "A Scaled Conjugate Gradient Algorithm for Fast Supervised Learning," Neural Networks, Vol. 6, pp. 525--533, 1993.
+   *
+   * @overload fmin(fnc, x, jcb, args, xtol, ftol, jtol, maxiter)
+   *   @param fnc [Method/Proc]
+   *   @param x [Numo::DFloat]
+   *   @param jcb [Method/Proc/boolean]
+   *   @param args [Object]
+   *   @param xtol [Float]
+   *   @param ftol [Float]
+   *   @param gtol [Float]
+   *   @param maxiter [Integer]
+   *   @return [Hash{Symbol => Object}]
+   */
+  rb_define_module_function(rb_mScg, "fmin", scg_fmin, 8);
 }

data/ext/numo/optimize/optimize.h

@@ -2,12 +2,14 @@
 #define NUMO_OPTIMIZE_H 1
 
 #include <float.h>
+#include <stdbool.h>
 
 #include <ruby.h>
 
 #include <numo/narray.h>
 #include <numo/template.h>
 
+#include "src/blas.h"
 #include "src/lbfgsb.h"
 
 #endif /* NUMO_OPTIMIZE_H */

data/lib/numo/optimize/lbfgsb.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Numo
+  module Optimize
+    # Lbfgsb module provides functions for minimization using L-BFGS-B algorithm.
+    module Lbfgsb
+      module_function
+
+      # @!visibility private
+      def fnc(fnc, x, args)
+        if args.is_a?(Hash)
+          fnc.call(x, **args)
+        elsif args.is_a?(Array)
+          fnc.call(x, *args)
+        elsif args.nil?
+          fnc.call(x)
+        else
+          fnc.call(x, args)
+        end
+      end
+
+      # @!visibility private
+      def jcb(jcb, x, args)
+        if args.is_a?(Hash)
+          jcb.call(x, **args)
+        elsif args.is_a?(Array)
+          jcb.call(x, *args)
+        elsif args.nil?
+          jcb.call(x)
+        else
+          jcb.call(x, args)
+        end
+      end
+
+      private_class_method :fnc, :jcb
+    end
+  end
+end

data/lib/numo/optimize/nelder_mead.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Numo
+  module Optimize
+    # NelderMead module provides functions for minimization using the Nelder-Mead simplex algorithm.
+    module NelderMead
+      # @!visibility private
+      ZERO_TAU = 0.00025
+
+      # @!visibility private
+      NONZERO_TAU = 0.05
+
+      module_function
+
+      # Minimize a function using the Nelder-Mead simplex algorithm.
+      # This module function is for internal use. It is recommended to use `Numo::Optimize.minimize`.
+      #
+      # @param f [Method/Proc]
+      # @param x [Numo::DFloat]
+      # @param args [Object]
+      # @param maxiter [Integer]
+      # @param xtol [Float]
+      # @param ftol [Float]
+      def fmin(f, x, args, maxiter = nil, xtol = 1e-6, ftol = 1e-6) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        n = x.size
+        maxiter ||= 200 * n
+
+        alpha = 1.0
+        beta = n > 1 ? 1 + 2.fdiv(n) : 2.0
+        gamma = n > 1 ? 0.75 - 1.fdiv(2 * n) : 0.5
+        delta = n > 1 ? 1 - 1.fdiv(n) : 0.5
+
+        sim = x.class.zeros(n + 1, n)
+        sim[0, true] = x
+        n.times do |k|
+          y = x.dup
+          y[k] = y[k].zero? ? ZERO_TAU : (1 + NONZERO_TAU) * y[k]
+          sim[k + 1, true] = y
+        end
+
+        fsim = Numo::DFloat.zeros(n + 1)
+
+        (n + 1).times { |k| fsim[k] = fnc(f, sim[k, true], args) }
+        n_fev = n + 1
+
+        res = {}
+
+        n_iter = 0
+        while n_iter < maxiter
+          break if ((sim[1..-1,
+                         true] - sim[0, true]).abs.flatten.max <= xtol) && ((fsim[0] - fsim[1..]).abs.max <= ftol)
+
+          xbar = sim[0...-1, true].sum(axis: 0) / n
+          xr = xbar + (alpha * (xbar - sim[-1, true]))
+          fr = fnc(f, xr, args)
+          n_fev += 1
+
+          shrink = true
+          if fr < fsim[0]
+            xe = xbar + (beta * (xr - xbar))
+            fe = fnc(f, xe, args)
+            n_fev += 1
+            shrink = false
+            if fe < fr
+              sim[-1, true] = xe
+              fsim[-1] = fe
+            else
+              sim[-1, true] = xr
+              fsim[-1] = fr
+            end
+          elsif fr < fsim[-2]
+            shrink = false
+            sim[-1, true] = xr
+            fsim[-1] = fr
+          elsif fr < fsim[-1]
+            xoc = xbar + (gamma * (xr - xbar))
+            foc = fnc(f, xoc, args)
+            n_fev += 1
+            if foc <= fr
+              shrink = false
+              sim[-1, true] = xoc
+              fsim[-1] = foc
+            end
+          else
+            xic = xbar - (gamma * (xr - xbar))
+            fic = fnc(f, xic, args)
+            n_fev += 1
+            if fic < fsim[-1]
+              shrink = false
+              sim[-1, true] = xic
+              fsim[-1] = fic
+            end
+          end
+
+          if shrink
+            (1..n).to_a.each do |j|
+              sim[j, true] = sim[0, true] + (delta * (sim[j, true] - sim[0, true]))
+              fsim[j] = fnc(f, sim[j, true], args)
+              n_fev += 1
+            end
+          end
+
+          ind = fsim.sort_index
+          sim = sim[ind, true].dup
+          fsim = fsim[ind].dup
+
+          res[:x] = sim[0, true]
+          res[:fnc] = fsim[0]
+          res[:n_iter] = n_iter
+          res[:n_fev] = n_fev
+
+          n_iter += 1
+        end
+
+        res
+      end
+
+      # @!visibility private
+      def fnc(fnc, x, args)
+        if args.is_a?(Hash)
+          fnc.call(x, **args)
+        elsif args.is_a?(Array)
+          fnc.call(x, *args)
+        elsif args.nil?
+          fnc.call(x)
+        else
+          fnc.call(x, args)
+        end
+      end
+    end
+  end
+end

data/lib/numo/optimize/scg.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Numo
+  module Optimize
+    # Scg module provides functions for minimization using scaled conjugate gradient (SCG) algorithm.
+    module Scg
+      module_function
+
+      # @!visibility private
+      def fnc(fnc, x, args)
+        if args.is_a?(Hash)
+          fnc.call(x, **args)
+        elsif args.is_a?(Array)
+          fnc.call(x, *args)
+        elsif args.nil?
+          fnc.call(x)
+        else
+          fnc.call(x, args)
+        end
+      end
+
+      # @!visibility private
+      def jcb(jcb, x, args)
+        if args.is_a?(Hash)
+          jcb.call(x, **args)
+        elsif args.is_a?(Array)
+          jcb.call(x, *args)
+        elsif args.nil?
+          jcb.call(x)
+        else
+          jcb.call(x, args)
+        end
+      end
+
+      private_class_method :fnc, :jcb
+    end
+  end
+end

data/lib/numo/optimize/version.rb

@@ -5,6 +5,6 @@ module Numo
   # Numo::Optimize provides functions for minimizing objective functions.
   module Optimize
     # The version of numo-optimize you install.
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/lib/numo/optimize.rb

@@ -4,44 +4,14 @@ require 'numo/narray'
 
 require_relative 'optimize/version'
 require_relative 'optimize/optimize'
+require_relative 'optimize/lbfgsb'
+require_relative 'optimize/scg'
+require_relative 'optimize/nelder_mead'
 
 # Ruby/Numo (NUmerical MOdules)
 module Numo
   # Numo::Optimize provides functions for minimizing objective functions.
   module Optimize
-    # Lbfgsb module provides functions for minimization using L-BFGS-B algorithm.
-    module Lbfgsb
-      module_function
-
-      # @!visibility private
-      def fnc(fnc, x, args)
-        if args.is_a?(Hash)
-          fnc.call(x, **args)
-        elsif args.is_a?(Array)
-          fnc.call(x, *args)
-        elsif args.nil?
-          fnc.call(x)
-        else
-          fnc.call(x, args)
-        end
-      end
-
-      # @!visibility private
-      def jcb(jcb, x, args)
-        if args.is_a?(Hash)
-          jcb.call(x, **args)
-        elsif args.is_a?(Array)
-          jcb.call(x, *args)
-        elsif args.nil?
-          jcb.call(x)
-        else
-          jcb.call(x, args)
-        end
-      end
-
-      private_class_method :fnc, :jcb
-    end
-
     module_function
 
     # Minimize the given function.
@@ -50,23 +20,29 @@ module Numo
     # @param x_init [Numo::DFloat] (shape: [n_elements]) Initial point.
     # @param jcb [Method/Proc/Boolean] Method for calculating the gradient vector.
     #   If true is given, fnc is assumed to return the function value and gardient vector as [f, g] array.
-    # @param method [String] Type of algorithm. Now only 'L-BFGS-B' is supported.
+    # @param method [String] Type of algorithm. 'L-BFGS-B', 'SCG', or 'Nelder-Mead' is available.
     # @param args [Object] Arguments pass to the 'fnc' and 'jcb'.
     # @param bounds [Numo::DFloat/Nil] (shape: [n_elements, 2])
     #   \[lower, upper\] bounds for each element x. If nil is given, x is unbounded.
+    #   This argument is only used 'L-BFGS-B' method.
     # @param factr [Float] The iteration will be stop when
     #
     #   (f^k - f^\{k+1\})/max{|f^k|,|f^\{k+1\}|,1} <= factr * Lbfgsb::DBL_EPSILON
     #
     #   Typical values for factr: 1e12 for low accuracy; 1e7 for moderate accuracy; 1e1 for extremely high accuracy.
+    #   This argument is only used 'L-BFGS-B' method.
     # @param pgtol [Float] The iteration will be stop when
     #
     #   max{|pg_i| i = 1, ..., n} <= pgtol
     #
     #   where pg_i is the ith component of the projected gradient.
-    # @param maxcor [Integer] The maximum number of variable metric corrections used to define the limited memory matrix.
+    #   This argument is only used 'L-BFGS-B' method.
+    # @param maxcor [Integer] The maximum number of variable metric corrections used to define the limited memory matrix. This argument is only used 'L-BFGS-B' method.
+    # @param xtol [Float] Tolerance for termination by the change of the optimal vector norm. This argument is used 'SCG' and 'Nelder-Mead' methods.
+    # @param ftol [Float] Tolerance for termination by the change of the objective function value. This argument is used 'SCG' and 'Nelder-Mead' methods
+    # @param jtol [Float] Tolerance for termination by the norm of the gradient vector. This argument is only used 'SCG' method.
     # @param maxiter [Integer] The maximum number of iterations.
-    # @param verbose [Integer/Nil] If negative value or nil is given, no display output is generated.
+    # @param verbose [Integer/Nil] If negative value or nil is given, no display output is generated. This argument is only used 'L-BFGS-B' method.
     # @return [Hash] Optimization results; { x:, n_fev:, n_jev:, n_iter:, fnc:, jcb:, task:, success: }
     #   - x [Numo::DFloat] Updated vector by optimization.
     #   - n_fev [Interger] Number of calls of the objective function.
@@ -76,35 +52,44 @@ module Numo
     #   - jcb [Numo::Narray] Values of the jacobian
     #   - task [String] Description of the cause of the termination.
     #   - success [Boolean] Whether or not the optimization exited successfully.
-    def minimize(fnc:, x_init:, jcb:, method: 'L-BFGS-B', args: nil, bounds: nil, factr: 1e7, pgtol: 1e-5, # rubocop:disable Lint/UnusedMethodArgument
-                 maxcor: 10, maxiter: 15_000, verbose: nil)
-      n_elements = x_init.size
-      l = Numo::DFloat.zeros(n_elements)
-      u = Numo::DFloat.zeros(n_elements)
-      nbd = if Numo::Optimize::Lbfgsb::SZ_F77_INTEGER == 64
-              Numo::Int64.zeros(n_elements)
-            else
-              Numo::Int32.zeros(n_elements)
-            end
+    def minimize(fnc:, x_init:, jcb:, method: 'L-BFGS-B', args: nil, bounds: nil, factr: 1e7, pgtol: 1e-5,
+                 maxcor: 10, xtol: 1e-6, ftol: 1e-8, jtol: 1e-7, maxiter: 15_000, verbose: nil)
+      case method.downcase.delete('-')
+      when 'lbfgsb'
+        n_elements = x_init.size
+        l = Numo::DFloat.zeros(n_elements)
+        u = Numo::DFloat.zeros(n_elements)
+        nbd = if Numo::Optimize::Lbfgsb::SZ_F77_INTEGER == 64
+                Numo::Int64.zeros(n_elements)
+              else
+                Numo::Int32.zeros(n_elements)
+              end
 
-      unless bounds.nil?
-        n_elements.times do |n|
-          lower = bounds[n, 0]
-          upper = bounds[n, 1]
-          l[n] = lower
-          u[n] = upper
-          if lower.finite? && !upper.finite?
-            nbd[n] = 1
-          elsif lower.finite? && upper.finite?
-            nbd[n] = 2
-          elsif !lower.finite? && upper.finite?
-            nbd[n] = 3
+        unless bounds.nil?
+          n_elements.times do |n|
+            lower = bounds[n, 0]
+            upper = bounds[n, 1]
+            l[n] = lower
+            u[n] = upper
+            if lower.finite? && !upper.finite?
+              nbd[n] = 1
+            elsif lower.finite? && upper.finite?
+              nbd[n] = 2
+            elsif !lower.finite? && upper.finite?
+              nbd[n] = 3
+            end
           end
         end
-      end
 
-      Numo::Optimize::Lbfgsb.fmin(fnc, x_init.dup, jcb, args, l, u, nbd, maxcor,
-                                  factr, pgtol, maxiter, verbose)
+        Numo::Optimize::Lbfgsb.fmin(fnc, x_init.dup, jcb, args, l, u, nbd, maxcor,
+                                    factr, pgtol, maxiter, verbose)
+      when 'neldermead'
+        Numo::Optimize::NelderMead.fmin(fnc, x_init.dup, args, maxiter, xtol, ftol)
+      when 'scg'
+        Numo::Optimize::Scg.fmin(fnc, x_init.dup, jcb, args, xtol, ftol, jtol, maxiter)
+      else
+        raise ArgumentError, "Unknown method: #{method}"
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: numo-optimize
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - yoshoku
@@ -48,6 +48,9 @@ files:
 - ext/numo/optimize/src/linpack.c
 - ext/numo/optimize/src/linpack.h
 - lib/numo/optimize.rb
+- lib/numo/optimize/lbfgsb.rb
+- lib/numo/optimize/nelder_mead.rb
+- lib/numo/optimize/scg.rb
 - lib/numo/optimize/version.rb
 homepage: https://github.com/yoshoku/numo-optimize
 licenses:
@@ -56,7 +59,7 @@ metadata:
   homepage_uri: https://github.com/yoshoku/numo-optimize
   source_code_uri: https://github.com/yoshoku/numo-optimize
   changelog_uri: https://github.com/yoshoku/numo-optimize/blob/main/CHANGELOG.md
-  documentation_uri: https://gemdocs.org/gems/numo-optimize/0.1.0/
+  documentation_uri: https://gemdocs.org/gems/numo-optimize/0.2.0/
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: