numo-optimize 0.1.0

data/ext/numo/optimize/src/lbfgsb.h

@@ -0,0 +1,83 @@
+#ifndef NUMO_OPTIMIZE_LBFGSB_H_
+#define NUMO_OPTIMIZE_LBFGSB_H_
+
+#include <float.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "common.h"
+
+#define TRUE_ (1)
+#define FALSE_ (0)
+
+extern void setulb_(F77_int* n, F77_int* m, double* x, double* l, double* u, F77_int* nbd, double* f, double* g, double* factr,
+                    double* pgtol, double* wa, F77_int* iwa, char* task, F77_int* iprint, char* csave, F77_int* lsave, F77_int* isave,
+                    double* dsave);
+
+extern void mainlb_(F77_int* n, F77_int* m, double* x, double* l, double* u, F77_int* nbd, double* f, double* g, double* factr,
+                    double* pgtol, double* ws, double* wy, double* sy, double* ss, double* wt, double* wn, double* snd,
+                    double* z__, double* r__, double* d__, double* t, double* xp, double* wa, F77_int* index, F77_int* iwhere,
+                    F77_int* indx2, char* task, F77_int* iprint, char* csave, F77_int* lsave, F77_int* isave, double* dsave);
+
+extern void active_(F77_int* n, double* l, double* u, F77_int* nbd, double* x, F77_int* iwhere, F77_int* iprint, F77_int* prjctd, F77_int* cnstnd,
+                    F77_int* boxed);
+
+extern void bmv_(F77_int* m, double* sy, double* wt, F77_int* col, double* v, double* p, F77_int* info);
+
+extern void cauchy_(F77_int* n, double* x, double* l, double* u, F77_int* nbd, double* g, F77_int* iorder, F77_int* iwhere, double* t,
+                    double* d__, double* xcp, F77_int* m, double* wy, double* ws, double* sy, double* wt, double* theta, F77_int* col,
+                    F77_int* head, double* p, double* c__, double* wbp, double* v, F77_int* nseg, F77_int* iprint, double* sbgnrm,
+                    F77_int* info, double* epsmch);
+
+extern void cmprlb_(F77_int* n, F77_int* m, double* x, double* g, double* ws, double* wy, double* sy, double* wt, double* z__,
+                    double* r__, double* wa, F77_int* index, double* theta, F77_int* col, F77_int* head, F77_int* nfree, F77_int* cnstnd,
+                    F77_int* info);
+
+extern void errclb_(F77_int* n, F77_int* m, double* factr, double* l, double* u, F77_int* nbd, char* task, F77_int* info, F77_int* k);
+
+extern void formk_(F77_int* n, F77_int* nsub, F77_int* ind, F77_int* nenter, F77_int* ileave, F77_int* indx2, F77_int* iupdat, F77_int* updatd,
+                   double* wn, double* wn1, F77_int* m, double* ws, double* wy, double* sy, double* theta, F77_int* col, F77_int* head,
+                   F77_int* info);
+
+extern void formt_(F77_int* m, double* wt, double* sy, double* ss, F77_int* col, double* theta, F77_int* info);
+
+extern void freev_(F77_int* n, F77_int* nfree, F77_int* index, F77_int* nenter, F77_int* ileave, F77_int* indx2, F77_int* iwhere, F77_int* wrk,
+                   F77_int* updatd, F77_int* cnstnd, F77_int* iprint, F77_int* iter);
+
+extern void hpsolb_(F77_int* n, double* t, F77_int* iorder, F77_int* iheap);
+
+extern void lnsrlb_(F77_int* n, double* l, double* u, F77_int* nbd, double* x, double* f, double* fold, double* gd, double* gdold,
+                    double* g, double* d__, double* r__, double* t, double* z__, double* stp, double* dnorm, double* dtd,
+                    double* xstep, double* stpmx, F77_int* iter, F77_int* ifun, F77_int* iback, F77_int* nfgv, F77_int* info, char* task,
+                    F77_int* boxed, F77_int* cnstnd, char* csave, F77_int* isave, double* dsave);
+
+extern void matupd_(F77_int* n, F77_int* m, double* ws, double* wy, double* sy, double* ss, double* d__, double* r__, F77_int* itail,
+                    F77_int* iupdat, F77_int* col, F77_int* head, double* theta, double* rr, double* dr, double* stp, double* dtd);
+
+extern void prn1lb_(F77_int* n, F77_int* m, double* l, double* u, double* x, F77_int* iprint, F77_int* itfile, double* epsmch);
+
+extern void prn2lb_(F77_int* n, double* x, double* f, double* g, F77_int* iprint, F77_int* itfile, F77_int* iter, F77_int* nfgv, F77_int* nact,
+                    double* sbgnrm, F77_int* nseg, char* word, F77_int* iword, F77_int* iback, double* stp, double* xstep);
+
+extern void prn3lb_(F77_int* n, double* x, double* f, char* task, F77_int* iprint, F77_int* info, F77_int* itfile, F77_int* iter, F77_int* nfgv,
+                    F77_int* nintol, F77_int* nskip, F77_int* nact, double* sbgnrm, double* time, F77_int* nseg, char* word, F77_int* iback,
+                    double* stp, double* xstep, F77_int* k, double* cachyt, double* sbtime, double* lnscht);
+
+extern void projgr_(F77_int* n, double* l, double* u, F77_int* nbd, double* x, double* g, double* sbgnrm);
+
+extern void subsm_(F77_int* n, F77_int* m, F77_int* nsub, F77_int* ind, double* l, double* u, F77_int* nbd, double* x, double* d__, double* xp,
+                   double* ws, double* wy, double* theta, double* xx, double* gg, F77_int* col, F77_int* head, F77_int* iword, double* wv,
+                   double* wn, F77_int* iprint, F77_int* info);
+
+extern void dcsrch_(double* f, double* g, double* stp, double* ftol, double* gtol, double* xtol, double* stpmin, double* stpmax,
+                    char* task, F77_int* isave, double* dsave);
+
+extern void dcstep_(double* stx, double* fx, double* dx, double* sty, double* fy, double* dy, double* stp, double* fp,
+                    double* dp, F77_int* brackt, double* stpmin, double* stpmax);
+
+extern void timer_(double* ttime);
+
+#endif /* NUMO_OPTIMIZE_LBFGSB_H_ */

data/ext/numo/optimize/src/linpack.c

@@ -0,0 +1,237 @@
+/**
+ * L-BFGS-B is released under the “New BSD License” (aka “Modified BSD License”
+ * or “3-clause license”)
+ *  Please read attached file License.txt
+ */
+#include "linpack.h"
+#include "blas.h"
+
+static F77_int c__1 = 1;
+
+/**
+ *     dpofa factors a double precision symmetric positive definite
+ *     matrix.
+ *
+ *     dpofa is usually called by dpoco, but it can be called
+ *     directly with a saving in time if  rcond  is not needed.
+ *     (time for dpoco) = (1 + 18/n)*(time for dpofa) .
+ *
+ *     on entry
+ *
+ *        a       double precision(lda, n)
+ *                the symmetric matrix to be factored.  only the
+ *                diagonal and upper triangle are used.
+ *
+ *        lda     integer
+ *                the leading dimension of the array  a .
+ *
+ *        n       integer
+ *                the order of the matrix  a .
+ *
+ *     on return
+ *
+ *        a       an upper triangular matrix  r  so that  a = trans(r)*r
+ *                where  trans(r)  is the transpose.
+ *                the strict lower triangle is unaltered.
+ *                if  info .ne. 0 , the factorization is not complete.
+ *
+ *        info    integer
+ *                = 0  for normal return.
+ *                = k  signals an error condition.  the leading minor
+ *                     of order  k  is not positive definite.
+ *
+ *     linpack.  this version dated 08/14/78 .
+ *     cleve moler, university of new mexico, argonne national lab.
+ */
+void dpofa_(double* a, F77_int* lda, F77_int* n, F77_int* info) {
+  F77_int a_dim1, a_offset, i__1, i__2, i__3;
+  static F77_int j, k;
+  static double s, t;
+  static F77_int jm1;
+
+  a_dim1 = *lda;
+  a_offset = 1 + a_dim1;
+  a -= a_offset;
+
+  i__1 = *n;
+  for (j = 1; j <= i__1; ++j) {
+    *info = j;
+    s = 0.;
+    jm1 = j - 1;
+    if (jm1 < 1) {
+      goto L20;
+    }
+    i__2 = jm1;
+    for (k = 1; k <= i__2; ++k) {
+      i__3 = k - 1;
+      t = a[k + j * a_dim1] - ddot_(&i__3, &a[k * a_dim1 + 1], &c__1, &a[j * a_dim1 + 1], &c__1);
+      t /= a[k + k * a_dim1];
+      a[k + j * a_dim1] = t;
+      s += t * t;
+    }
+  L20:
+    s = a[j + j * a_dim1] - s;
+    /* ......exit */
+    if (s <= 0.) {
+      goto L40;
+    }
+    a[j + j * a_dim1] = sqrt(s);
+  }
+  *info = 0;
+L40:
+  return;
+}
+
+/**
+ *     dtrsl solves systems of the form
+ *
+ *                   t * x = b
+ *     or
+ *                   trans(t) * x = b
+ *
+ *     where t is a triangular matrix of order n. here trans(t)
+ *     denotes the transpose of the matrix t.
+ *
+ *     on entry
+ *
+ *         t         double precision(ldt,n)
+ *                   t contains the matrix of the system. the zero
+ *                   elements of the matrix are not referenced, and
+ *                   the corresponding elements of the array can be
+ *                   used to store other information.
+ *
+ *         ldt       integer
+ *                   ldt is the leading dimension of the array t.
+ *
+ *         n         integer
+ *                   n is the order of the system.
+ *
+ *         b         double precision(n).
+ *                   b contains the right hand side of the system.
+ *
+ *         job       integer
+ *                   job specifies what kind of system is to be solved.
+ *                   if job is
+ *
+ *                        00   solve t*x=b, t lower triangular,
+ *                        01   solve t*x=b, t upper triangular,
+ *                        10   solve trans(t)*x=b, t lower triangular,
+ *                        11   solve trans(t)*x=b, t upper triangular.
+ *
+ *     on return
+ *
+ *         b         b contains the solution, if info .eq. 0.
+ *                   otherwise b is unaltered.
+ *
+ *         info      integer
+ *                   info contains zero if the system is nonsingular.
+ *                   otherwise info contains the index of
+ *                   the first zero diagonal element of t.
+ *
+ *     linpack. this version dated 08/14/78 .
+ *     g. w. stewart, university of maryland, argonne national lab.
+ */
+void dtrsl_(double* t, F77_int* ldt, F77_int* n, double* b, F77_int* job, F77_int* info) {
+  F77_int t_dim1, t_offset, i__1, i__2;
+  static F77_int j, jj, case__;
+  static double temp;
+
+  /* check for zero diagonal elements. */
+  t_dim1 = *ldt;
+  t_offset = 1 + t_dim1;
+  t -= t_offset;
+  --b;
+
+  i__1 = *n;
+  for (*info = 1; *info <= i__1; ++(*info)) {
+    /* ......exit */
+    if (t[*info + *info * t_dim1] == 0.) {
+      goto L150;
+    }
+  }
+  *info = 0;
+
+  /* determine the task and go to it. */
+  case__ = 1;
+  if (*job % 10 != 0) {
+    case__ = 2;
+  }
+  if (*job % 100 / 10 != 0) {
+    case__ += 2;
+  }
+  switch (case__) {
+  case 1:
+    goto L20;
+  case 2:
+    goto L50;
+  case 3:
+    goto L80;
+  case 4:
+    goto L110;
+  }
+
+  /* solve t*x=b for t lower triangular */
+L20:
+  b[1] /= t[t_dim1 + 1];
+  if (*n < 2) {
+    goto L40;
+  }
+  i__1 = *n;
+  for (j = 2; j <= i__1; ++j) {
+    temp = -b[j - 1];
+    i__2 = *n - j + 1;
+    daxpy_(&i__2, &temp, &t[j + (j - 1) * t_dim1], &c__1, &b[j], &c__1);
+    b[j] /= t[j + j * t_dim1];
+  }
+L40:
+  goto L140;
+
+  /* solve t*x=b for t upper triangular. */
+L50:
+  b[*n] /= t[*n + *n * t_dim1];
+  if (*n < 2) {
+    goto L70;
+  }
+  i__1 = *n;
+  for (jj = 2; jj <= i__1; ++jj) {
+    j = *n - jj + 1;
+    temp = -b[j + 1];
+    daxpy_(&j, &temp, &t[(j + 1) * t_dim1 + 1], &c__1, &b[1], &c__1);
+    b[j] /= t[j + j * t_dim1];
+  }
+L70:
+  goto L140;
+
+  /* solve trans(t)*x=b for t lower triangular. */
+L80:
+  b[*n] /= t[*n + *n * t_dim1];
+  if (*n < 2) {
+    goto L100;
+  }
+  i__1 = *n;
+  for (jj = 2; jj <= i__1; ++jj) {
+    j = *n - jj + 1;
+    i__2 = jj - 1;
+    b[j] -= ddot_(&i__2, &t[j + 1 + j * t_dim1], &c__1, &b[j + 1], &c__1);
+    b[j] /= t[j + j * t_dim1];
+  }
+L100:
+  goto L140;
+
+  /* solve trans(t)*x=b for t upper triangular. */
+L110:
+  b[1] /= t[t_dim1 + 1];
+  if (*n < 2) {
+    goto L130;
+  }
+  i__1 = *n;
+  for (j = 2; j <= i__1; ++j) {
+    i__2 = j - 1;
+    b[j] -= ddot_(&i__2, &t[j * t_dim1 + 1], &c__1, &b[1], &c__1);
+    b[j] /= t[j + j * t_dim1];
+  }
+L130:
+L140:
+L150:
+  return;
+}

data/ext/numo/optimize/src/linpack.h

@@ -0,0 +1,9 @@
+#ifndef NUMO_OPTIMIZE_LINPACK_H_
+#define NUMO_OPTIMIZE_LINPACK_H_
+
+#include "common.h"
+
+extern void dpofa_(double* a, F77_int* lda, F77_int* n, F77_int* info);
+extern void dtrsl_(double* t, F77_int* ldt, F77_int* n, double* b, F77_int* job, F77_int* info);
+
+#endif /* NUMO_OPTIMIZE_LINPACK_H_ */

data/lib/numo/optimize/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Ruby/Numo (NUmerical MOdules)
+module Numo
+  # Numo::Optimize provides functions for minimizing objective functions.
+  module Optimize
+    # The version of numo-optimize you install.
+    VERSION = '0.1.0'
+  end
+end

data/lib/numo/optimize.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'numo/narray'
+
+require_relative 'optimize/version'
+require_relative 'optimize/optimize'
+
+# 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.
+    #
+    # @param fnc [Method/Proc] Method for calculating the function to be minimized.
+    # @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 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.
+    # @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.
+    # @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.
+    # @param maxiter [Integer] The maximum number of iterations.
+    # @param verbose [Integer/Nil] If negative value or nil is given, no display output is generated.
+    # @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.
+    #   - n_jev [Integer] Number of calls of the jacobian.
+    #   - n_iter [Integer] Number of iterations.
+    #   - fnc [Float] Value of the objective function.
+    #   - 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
+
+      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
+
+      Numo::Optimize::Lbfgsb.fmin(fnc, x_init.dup, jcb, args, l, u, nbd, maxcor,
+                                  factr, pgtol, maxiter, verbose)
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: numo-optimize
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- yoshoku
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: numo-narray-alt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+description: Numo::Optimize provides functions for minimizing objective functions.
+email:
+- yoshoku@outlook.com
+executables: []
+extensions:
+- ext/numo/optimize/extconf.rb
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/numo/optimize/extconf.rb
+- ext/numo/optimize/optimize.c
+- ext/numo/optimize/optimize.h
+- ext/numo/optimize/src/License.txt
+- ext/numo/optimize/src/blas.c
+- ext/numo/optimize/src/blas.h
+- ext/numo/optimize/src/common.h
+- ext/numo/optimize/src/lbfgsb.c
+- ext/numo/optimize/src/lbfgsb.h
+- ext/numo/optimize/src/linpack.c
+- ext/numo/optimize/src/linpack.h
+- lib/numo/optimize.rb
+- lib/numo/optimize/version.rb
+homepage: https://github.com/yoshoku/numo-optimize
+licenses:
+- BSD-3-Clause
+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/
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Numo::Optimize provides functions for minimizing objective functions.
+test_files: []