carray 1.1.4 → 1.1.5

data/ext/calculus/carray_interp.c

@@ -0,0 +1,355 @@
+/* ---------------------------------------------------------------------------
+
+  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 (int n, double *y, double yy, int *major, double *frac)
+{
+  int   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 = (int)((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, int *major, double *frac,
+                    int level, int32_t *idx, double wt, double *valp)
+{
+  double tmp;
+
+  if ( level == ca->rank-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, int *major, double *frac)
+{
+  int32_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,
+                     int *major, double *frac,
+                     int level, double **dstp)
+{
+  double val, frc;
+  int maj;
+  int i;
+  if ( level == ca->rank-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)
+{
+  int 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];
+  int32_t out_rank, 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->rank != RARRAY_LEN(vvalues) ) {
+    rb_raise(rb_eArgError, "invalid number of values");
+  }
+
+  for (i=0; i<ca->rank; 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_rank = 0;
+  for (i=0; i<ca->rank; i++) {
+    vs = rb_ary_entry(vvalues, i);
+    if ( NIL_P(vs) ) {
+      out_dim[out_rank++] = 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_rank++] = values[i]->elements;
+      }
+      rb_ary_store(vvalues, i, vs);
+    }
+  }
+
+  if ( out_rank == 0 ) {
+    out = rb_cscalar_new(CA_DOUBLE, 0, NULL);
+  }
+  else {
+    out = rb_carray_new(CA_DOUBLE, out_rank, out_dim, 0, NULL);
+  }
+
+  Data_Get_Struct(out, CArray, co);
+
+  for (i=0; i<ca->rank; 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->rank; i++) {
+    if ( values[i] ) {
+      ca_detach(values[i]);
+    }
+    if ( scales[i] ) {
+      ca_detach(scales_ca[i]);
+    }
+  }
+
+  if ( out_rank == 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/calculus/extconf.rb

@@ -0,0 +1,12 @@
+require "mkmf"
+
+dir_config("carray", "../..", "../..")
+
+have_header("carray.h")
+
+if /cygwin|mingw/ =~ RUBY_PLATFORM
+  have_library("carray")
+end
+
+create_makefile("carray/carray_calculus")
+

data/ext/calculus/lib/autoload/autoload_math_calculus.rb

@@ -0,0 +1,2 @@
+require "carray/carray_calculus"
+require "carray/math/calculus"

data/ext/calculus/lib/math/calculus.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, 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=>"linear"), func.interpolate(sc, sx[2], :type=>"linear")
+      output.push(sx.interpolate(sy, 0))
+    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