carray 1.3.6 → 1.5.3

data/ext/calculus/carray_interp.c

@@ -1,358 +0,0 @@
-/* ---------------------------------------------------------------------------
-
-  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->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, 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->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)
-{
-  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_rank;
-  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->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

@@ -1,12 +0,0 @@
-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

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

data/ext/calculus/lib/math/calculus.rb

@@ -1,119 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  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