carray-calculus 1.0.0

data/ext/carray_interp.c

@@ -0,0 +1,357 @@
+/* ---------------------------------------------------------------------------
+
+  carray/carray_interp.c
+
+  This file is part of Ruby/CArray extension library.
+  You can redistribute it and/or modify it under the terms of
+  the Ruby Licence.
+
+  Copyright (C) 2005 Hiroki Motoyoshi
+
+---------------------------------------------------------------------------- */
+
+#include "ruby.h"
+#include "carray.h"
+#include <math.h>
+
+static int
+find_index (ca_size_t n, double *y, double yy, ca_size_t *major, double *frac)
+{
+  ca_size_t  a, b, c, x1;
+  double ya, yb, yc;
+  double y1, y2;
+
+  if ( yy <= y[0] ) {
+    x1 = 0;
+    goto label;
+  }
+
+  if ( yy >= y[n-1] ) {
+    x1 = n-2;
+    goto label;
+  }
+
+  /* check for equally spaced scale */
+
+  a = (ca_size_t)((yy-y[0])/(y[n-1]-y[0])*(n-1));
+
+  if ( a >= 0 && a < n-1 ) {
+    if ( (y[a] - yy) * (y[a+1] - yy) <= 0 ) {
+      x1 = a;
+      goto label;
+    }
+  }
+
+  /* binary section method */
+
+  a = 0;
+  b = n-1;
+
+  ya = y[a];
+  yb = y[b];
+
+  if ( ya > yb ) {
+    return -1; /* input scale array should have accending order */
+  }
+
+  while ( (b - a) >= 1 ) {
+    c  = (a + b)/2;
+    yc = y[c];
+    if ( a == c ) {
+      break;
+    }
+
+    if ( yc == yy ) {
+      a = c;
+      break;
+    }
+    else if ( (ya - yy) * (yc - yy) <= 0 ) {
+      b = c;
+      yb = yc;
+    }
+    else {
+      a = c;
+      ya = yc;
+    }
+
+    if ( ya > yb ) {
+      return -1; /* input scale array should have accending order */
+    }
+  }
+
+  x1 = a;
+
+ label:
+
+  y1 = y[x1];
+  y2 = y[x1+1];
+
+  *major = x1;
+  
+  if ( y2 - y1 == 0 ) {
+    *frac = 0.0;
+  }
+  else {
+    *frac = (yy-y1)/(y2-y1);
+  }
+
+  return 0;
+}
+
+
+/*
+
+  n-dimensional linear interpolation
+
+  y[i+fi, j+fj, ..., n+fn]
+
+          1     1         1
+     =  Sigma Sigma ... Sigma  wi[si]*wj[sj]*...*wn[sn]*y[i+si,j+sj,...,n+sn]
+         si=0  sj=0      sn=0
+
+  i ,  j, ...,  n : major integer value
+  fi, fj, ..., fn : fractional value
+
+  wi[0] = 1-fi, wj[0] = 1-fj, ..., wn[0] = 1-fn
+  wi[1] = fi,   wj[1] = fj,   ..., wn[1] = fn
+
+*/
+
+static int
+linear_interp_loop (CArray *ca, ca_size_t *major, double *frac,
+                    int level, ca_size_t *idx, double wt, double *valp)
+{
+  double tmp;
+
+  if ( level == ca->ndim-1 ) {
+
+    idx[level] = major[level];
+    ca_fetch_index(ca, idx, &tmp);
+    *valp += (1.0 - frac[level]) * wt * tmp;
+
+    idx[level] = major[level] + 1;
+    ca_fetch_index(ca, idx, &tmp);
+    *valp += frac[level] * wt * tmp;
+
+  }
+  else {
+
+    if ( frac[level] != 1.0 ) {   /* condition for performance issue */
+      idx[level] = major[level];
+      linear_interp_loop(ca, major, frac,
+                         level+1, idx, (1.0 - frac[level])*wt, valp);
+    }
+
+    if ( frac[level] != 0.0 ) {   /* condition for performance issue */
+      idx[level] = major[level] + 1;
+      linear_interp_loop(ca, major, frac,
+                         level+1, idx, frac[level]*wt, valp);
+    }
+
+  }
+
+  return 0;
+}
+
+static double
+linear_interp (CArray *ca, ca_size_t *major, double *frac)
+{
+  ca_size_t idx[CA_RANK_MAX];
+  double value = 0;
+  linear_interp_loop(ca, major, frac, 0, idx, 1, &value);
+  return value;
+}
+
+/*
+
+If value[n] is NaN, the interpolation will be made for each index of the dimension n. So you must prepare the buffer sufficient to store these values.
+
+*/
+
+static int
+ca_interpolate_loop (CArray *ca, double **scale,
+                     CArray **value,
+                     ca_size_t *major, double *frac,
+                     int level, double **dstp)
+{
+  double val, frc;
+  ca_size_t maj;
+  ca_size_t i;
+  
+  if ( level == ca->ndim-1 ) {
+    if ( ! value[level] ) {
+      for (i=0; i<ca->dim[level]; i++) {
+        major[level] = i;
+        frac[level]  = 0.0;
+        **dstp = linear_interp(ca, major, frac);
+        *dstp += 1;
+      }
+    }
+    else {
+      for (i=0; i<value[level]->elements; i++) {
+        ca_fetch_addr(value[level], i, &val);
+        find_index(ca->dim[level], scale[level], val, &maj, &frc);
+        major[level] = maj;
+        frac[level]  = frc;
+        **dstp = linear_interp(ca, major, frac);
+        *dstp += 1;
+      }
+    }
+  }
+  else {
+    if ( ! value[level] ) {
+      for (i=0; i<ca->dim[level]; i++) {
+        major[level] = i;
+        frac[level]  = 0.0;
+        ca_interpolate_loop(ca, scale, value, major, frac, level+1, dstp);
+      }
+    }
+    else {
+      for (i=0; i<value[level]->elements; i++) {
+        ca_fetch_addr(value[level], i, &val);
+        find_index(ca->dim[level], scale[level], val, &maj, &frc);
+        major[level] = maj;
+        frac[level]  = frc;
+        ca_interpolate_loop(ca, scale, value, major, frac, level+1, dstp);
+      }
+    }
+  }
+  return 0; /* normal exit */
+}
+
+int
+ca_interpolate (CArray *ca, double **scale, CArray **value, double *outp)
+{
+  ca_size_t major[CA_RANK_MAX];
+  double frac[CA_RANK_MAX];
+  int status;
+
+  status = ca_interpolate_loop(ca, scale, value, major, frac, 0, &outp);
+
+  return status;
+}
+
+
+static VALUE
+rb_ca_interpolate_bilinear (int argc, VALUE *argv, volatile VALUE self)
+{
+  volatile VALUE vscales, vvalues, vs, out;
+  CArray *ca, *co, *cs;
+  double *scales[CA_RANK_MAX];
+  CArray *values[CA_RANK_MAX];
+  CArray *scales_ca[CA_RANK_MAX];
+  int8_t out_ndim;
+  ca_size_t out_dim[CA_RANK_MAX];
+  int i;
+
+  rb_scan_args(argc, argv, "2", &vscales, &vvalues);
+
+  Check_Type(vscales, T_ARRAY);
+  Check_Type(vvalues, T_ARRAY);
+
+  if ( RARRAY_LEN(vscales) != RARRAY_LEN(vvalues) ) {
+    rb_raise(rb_eArgError, "invalid number of values or scales");
+  }
+
+  ca = ca_wrap_readonly(self, CA_DOUBLE);
+
+  if ( ca->ndim != RARRAY_LEN(vvalues) ) {
+    rb_raise(rb_eArgError, "invalid number of values");
+  }
+
+  for (i=0; i<ca->ndim; i++) {
+    vs = rb_ary_entry(vscales, i);
+    if ( NIL_P(vs) ) {
+      scales[i] = NULL;
+    }
+    else {
+      cs = ca_wrap_readonly(vs, CA_DOUBLE);
+      scales_ca[i] = cs;
+      ca_attach(cs);
+      scales[i] = (double *) cs->ptr;
+      rb_ary_store(vscales, i, vs);
+    }
+  }
+
+  out_ndim = 0;
+  for (i=0; i<ca->ndim; i++) {
+    vs = rb_ary_entry(vvalues, i);
+    if ( NIL_P(vs) ) {
+      out_dim[out_ndim++] = ca->dim[i];
+      values[i] = NULL;
+    }
+    else {
+      values[i] = ca_wrap_readonly(vs, CA_DOUBLE);
+      if ( values[i]->obj_type != CA_OBJ_SCALAR ) {
+        out_dim[out_ndim++] = values[i]->elements;
+      }
+      rb_ary_store(vvalues, i, vs);
+    }
+  }
+
+  if ( out_ndim == 0 ) {
+    out = rb_cscalar_new(CA_DOUBLE, 0, NULL);
+  }
+  else {
+    out = rb_carray_new(CA_DOUBLE, out_ndim, out_dim, 0, NULL);
+  }
+
+  Data_Get_Struct(out, CArray, co);
+
+  for (i=0; i<ca->ndim; i++) {
+    if ( values[i] ) {
+      ca_attach(values[i]);
+    }
+  }
+
+  ca_attach(ca);
+  ca_interpolate(ca, scales, values, (double*) co->ptr);
+  ca_detach(ca);
+
+  for (i=0; i<ca->ndim; i++) {
+    if ( values[i] ) {
+      ca_detach(values[i]);
+    }
+    if ( scales[i] ) {
+      ca_detach(scales_ca[i]);
+    }
+  }
+
+  if ( out_ndim == 0 ) {
+    return rb_ca_fetch_addr(out, 0);
+  }
+  else {
+    return out;
+  }
+}
+
+void
+Init_carray_interpolate ()
+{
+  rb_define_method(rb_cCArray, "interp_nd_linear",
+                                rb_ca_interpolate_bilinear, -1);
+}
+
+/*
+
+  scales = [nil, nil, sza, vza, saz]
+  values = [nil, nil,  60,  60, 120]
+  brdf.interp_linear_nd(scales, values)
+
+  interp_1d_linear
+  interp_1d_parabolic
+  interp_1d_cubic
+  interp_1d_akima
+  interp_1d_akima2
+  interp_1d_curv
+
+  interp_2d_natgrid
+  interp_2d_fitpack
+  interp_nd_linear
+
+  gridding_2d_natgrid
+
+
+*/
+
+

data/ext/extconf.rb

@@ -0,0 +1,7 @@
+require "mkmf"
+require "carray/mkmf"
+
+if have_carray()
+  create_makefile("carray_calculus")
+end
+

data/ext/mkmf.log

@@ -0,0 +1,24 @@
+have_header: checking for carray.h... -------------------- yes
+
+"clang -o conftest -I/Users/himotoyoshi/.rbenv/versions/2.4.2/include/ruby-2.4.0/x86_64-darwin16 -I/Users/himotoyoshi/.rbenv/versions/2.4.2/include/ruby-2.4.0/ruby/backward -I/Users/himotoyoshi/.rbenv/versions/2.4.2/include/ruby-2.4.0 -I. -I/Users/himotoyoshi/.rbenv/versions/2.4.2/lib/ruby/gems/2.4.0/gems/carray-1.5.0/lib -I/Users/himotoyoshi/.rbenv/versions/2.4.2/include -I/usr/local/opt/qt/include: -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE -D_DARWIN_UNLIMITED_SELECT -D_REENTRANT   -O3 -fno-fast-math -ggdb3 -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wno-tautological-compare -Wno-parentheses-equality -Wno-constant-logical-operand -Wno-self-assign -Wunused-variable -Wimplicit-int -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wshorten-64-to-32 -Wimplicit-function-declaration -Wdivision-by-zero -Wdeprecated-declarations -Wextra-tokens  -pipe conftest.c  -L. -L/Users/himotoyoshi/.rbenv/versions/2.4.2/lib -L/Users/himotoyoshi/.rbenv/versions/2.4.2/lib/ruby/gems/2.4.0/gems/carray-1.5.0/lib -L. -L/Users/himotoyoshi/.rbenv/versions/2.4.2/lib -L/usr/local/opt/qt/lib: -fstack-protector -L/usr/local/lib     -lruby-static -framework CoreFoundation  -lpthread -lgmp -ldl -lobjc "
+ld: warning: directory not found for option '-L/usr/local/opt/qt/lib:'
+checked program was:
+/* begin */
+1: #include "ruby.h"
+2: 
+3: int main(int argc, char **argv)
+4: {
+5:   return 0;
+6: }
+/* end */
+
+"clang -E -I/Users/himotoyoshi/.rbenv/versions/2.4.2/include/ruby-2.4.0/x86_64-darwin16 -I/Users/himotoyoshi/.rbenv/versions/2.4.2/include/ruby-2.4.0/ruby/backward -I/Users/himotoyoshi/.rbenv/versions/2.4.2/include/ruby-2.4.0 -I. -I/Users/himotoyoshi/.rbenv/versions/2.4.2/lib/ruby/gems/2.4.0/gems/carray-1.5.0/lib -I/Users/himotoyoshi/.rbenv/versions/2.4.2/include -I/usr/local/opt/qt/include: -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE -D_DARWIN_UNLIMITED_SELECT -D_REENTRANT   -O3 -fno-fast-math -ggdb3 -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wno-tautological-compare -Wno-parentheses-equality -Wno-constant-logical-operand -Wno-self-assign -Wunused-variable -Wimplicit-int -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wshorten-64-to-32 -Wimplicit-function-declaration -Wdivision-by-zero -Wdeprecated-declarations -Wextra-tokens  -pipe  conftest.c -o conftest.i"
+checked program was:
+/* begin */
+1: #include "ruby.h"
+2: 
+3: #include <carray.h>
+/* end */
+
+--------------------
+

data/lib/carray-calculus.rb

@@ -0,0 +1,3 @@
+require "carray"
+require "carray_calculus"
+require "carray-calculus/core"

data/lib/carray-calculus/core.rb

@@ -0,0 +1,119 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/base/calculus.rb
+#
+#  This file is part of Ruby/CArray extension library.
+#  You can redistribute it and/or modify it under the terms of
+#  the Ruby Licence.
+#
+#  Copyright (C) 2005 Hiroki Motoyoshi
+#
+# ----------------------------------------------------------------------------
+
+class CArray
+
+  def normalize (scale = nil)
+    if scale
+      return self / self.integrate(scale)
+    else
+      return self / self.sum
+    end
+  end
+
+  def normalize! (scale = nil)
+    self[] = normalize(scale)
+    return self
+  end
+
+  def solve (sc, val, type: "cubic", eps: 100 * Float::EPSILON)
+    func = self - val
+    list, output = [], []
+    (0...dim0-1).each do |i|
+      if func[i] == UNDEF
+      elsif func[i].abs < eps and not list.include?(i-1)
+        output.push(sc[i])
+      elsif func[i+1] == UNDEF
+      elsif i < dim0 - 1 and func[i]*func[i+1] < 0
+        list.push(i)
+      end
+    end
+    list.each do |i|
+      sx = CArray.double(4)
+      sy = CArray.double(4)
+      sx[0], sx[3] = sc[i], sc[i+1]
+      sy[0], sy[3] = func[i], func[i+1]
+      sx[1], sx[2] = (2.0*sx[0]+sx[3])/3.0, (sx[0]+2.0*sx[3])/3.0
+      sy[1], sy[2] = func.interpolate(sc, sx[1], type: type), func.interpolate(sc, sx[2], type: type)
+      output.push(sx.interpolate(sy, 0, type: type))
+    end
+    return output.uniq
+  end
+
+  def solve2 (sc, eps: 100 * Float::EPSILON)
+    retvals = []
+    self.dim1.times do |j|
+      func = self[nil,j].to_ca
+      list, output = [], []
+      (0...dim0-1).each do |i|
+        if func[i] == UNDEF
+        elsif func[i].abs < eps and not list.include?(i-1)
+          output.push(sc[i])
+        elsif func[i+1] == UNDEF
+        elsif i < dim0 - 1 and func[i]*func[i+1] < 0
+          list.push(i)
+        end
+      end
+      list.each do |i|
+        sx = CArray.double(4)
+        sy = CArray.double(4)
+        sx[0], sx[3] = sc[i], sc[i+1]
+        sy[0], sy[3] = func[i], func[i+1]
+        sx[1], sx[2] = (2*sx[0]+sx[3])/3, (sx[0]+2*sx[3])/3
+        sy[1], sy[2] = func.interpolate(sc, sx[1], :type=>"linear"), func.interpolate(sc, sx[2], :type=>"linear")
+        output.push(sx.interpolate(sy, 0))
+      end
+      retvals << output.uniq
+    end
+    retvals = retvals.map{|s| s.empty? ? [nil] : s}
+    return retvals
+  end
+
+  private
+
+  def _interpolate2 (x, y, x0, y0)
+    case x.size
+    when 1
+      return self[0, nil].interpolate(y, y0)
+    when 2, 3
+      return self[:i,nil].interpolate(y, y0).interpolate(x, x0)
+    end
+    ri = x.section(x0)
+    i0 = ri.floor - 1
+    if i0 < 0
+      i0 = 0
+    elsif i0 + 3 > x.size - 1
+      i0 = x.size - 4
+    end
+    return self[i0..i0+3,nil][:i,nil].interpolate(y, y0).
+                                         interpolate(x[i0..i0+3],x0)
+  end
+
+  public
+
+  def interpolate2 (x, y, x0, y0)
+    if x0.is_a?(Numeric) and y0.is_a?(Numeric)
+      return _interpolate2(x, y, x0, y0)
+    else
+      x0 = CArray.wrap_readonly(x0)
+      y0 = CArray.wrap_readonly(y0)
+      out = CArray.double(x0.size, y0.size)
+      x0.each_with_index do |xi, i|
+        y0.each_with_index do |yj, j|
+          out[i,j] = _interpolate2(x, y, xi, yj)
+        end
+      end
+      return out.compact
+    end
+  end
+
+end