lbfgsb 0.1.0

data/ext/lbfgsb/src/lbfgsb.h

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

data/ext/lbfgsb/src/linpack.c

@@ -0,0 +1,236 @@
+/**
+ * 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 "blas.h"
+#include "linpack.h"
+
+static long 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     long
+ *                the leading dimension of the array  a .
+ *
+ *        n       long
+ *                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    long
+ *                = 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.
+ */
+int dpofa_(double *a, long *lda, long *n, long *info)
+{
+  long a_dim1, a_offset, i__1, i__2, i__3;
+  static long j, k;
+  static double s, t;
+  static long 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 0;
+}
+
+/**
+ *     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       long
+ *                   ldt is the leading dimension of the array t.
+ *
+ *         n         long
+ *                   n is the order of the system.
+ *
+ *         b         double precision(n).
+ *                   b contains the right hand side of the system.
+ *
+ *         job       long
+ *                   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      long
+ *                   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.
+ */
+int dtrsl_(double *t, long *ldt, long *n, double *b, long *job, long *info)
+{
+  long t_dim1, t_offset, i__1, i__2;
+  static long 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 0;
+}

data/ext/lbfgsb/src/linpack.h

@@ -0,0 +1,9 @@
+#ifndef LBFGSB_RB_LINPACK_H_
+#define LBFGSB_RB_LINPACK_H_
+
+#include <math.h>
+
+extern int dpofa_(double *a, long *lda, long *n, long *info);
+extern int dtrsl_(double *t, long *ldt, long *n, double *b, long *job, long *info);
+
+#endif /* LBFGSB_RB_LINPACK_H_ */

data/lbfgsb.gemspec

@@ -0,0 +1,29 @@
+require_relative 'lib/lbfgsb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lbfgsb'
+  spec.version       = Lbfgsb::VERSION
+  spec.authors       = ['yoshoku']
+  spec.email         = ['yoshoku@outlook.com']
+
+  spec.summary       = 'Lbfgsb.rb is a Ruby binding for L-BFGS-B'
+  spec.description   = 'Lbfgsb.rb is a Ruby binding for L-BFGS-B'
+  spec.homepage      = 'https://github.com/yoshoku/lbfgsb.rb'
+  spec.license       = 'BSD-3-Clause'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/yoshoku/lbfgsb.rb'
+  spec.metadata['changelog_uri'] = 'https://github.com/yoshoku/lbfgsb.rb/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.extensions    = ['ext/lbfgsb/extconf.rb']
+
+  spec.add_runtime_dependency 'numo-narray', '>= 0.9.1'
+end

data/lib/lbfgsb.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'numo/narray'
+
+require 'lbfgsb/version'
+require 'lbfgsb/lbfgsbext'
+
+module Lbfgsb
+  module_function
+
+  # Minimize a function using the L-BFGS-B algorithm.
+  #
+  # @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] Method for calculating the gradient vector.
+  # @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.
+  def minimize(fnc:, x_init:, jcb:, args: nil, bounds: nil, factr: 1e7, pgtol: 1e-5, 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 = Numo::Int64.zeros(n_elements)
+
+    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
+
+    min_l_bfgs_b(fnc, x_init, jcb, args, l, u, nbd, maxcor, factr, pgtol, maxiter, verbose)
+  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
+
+  # @!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, :min_l_bfgs_b
+end