carray-calculus 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e00ee8dc33750df8eb85835a3d3752789c1ba9c7d109de0f4879080eb091aa20
+  data.tar.gz: 604d60ac2d8e239af4d94da05bfbd7de80a53d8740ceb8a76f40357a3d79d965
+SHA512:
+  metadata.gz: 1a13531450e20471ec60f6163c8b9fcd6050dd15dfb79784d2a44050d5a98c121ccd325089246171474448d3c9f8cf3cc026d415314211eb2fd394fe4061fc96
+  data.tar.gz: 2e9919c89518d1468ec6a1a8d193cf907b96f4f3ae7265b117456074d3d0b7b6c44ae0294c00cea7719a787a8c7e97e544a82090f3f1b36523adb1b301b83835

data/Rakefile

@@ -0,0 +1,11 @@
+GEMSPEC = "carray-calculus.gemspec"
+
+task :install do
+  spec = eval File.read(GEMSPEC)
+  system %{
+    gem build #{GEMSPEC}; gem install #{spec.full_name}.gem
+  }
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new

data/carray-calculus.gemspec

@@ -0,0 +1,25 @@
+Gem::Specification::new do |s|
+  version = "1.0.0"
+  files = Dir.glob("**/*") - [ 
+                               Dir.glob("carray-calculus-*.gem"), 
+                               Dir.glob("test/**/*"),
+                               Dir.glob("work/**/*"),
+                             ].flatten
+
+  s.platform    = Gem::Platform::RUBY
+  s.name        = "carray-calculus"
+  s.summary     = "CArray methods on basic calculus"
+  s.description = <<-HERE
+    CArray methods on basic calculus
+  HERE
+  s.version     = version
+  s.licenses    = ['MIT']
+  s.author      = "Hiroki Motoyoshi"
+  s.email       = ""
+  s.homepage    = 'https://github.com/himotoyoshi/carray-calculus'
+  s.files       = files
+  s.extensions  = [ "ext/extconf.rb" ]
+  s.required_ruby_version = ">= 2.4.0"
+  s.add_runtime_dependency 'carray', '~> 1.5', ">= 1.5"
+end
+

data/ext/Makefile

@@ -0,0 +1,264 @@
+
+SHELL = /bin/sh
+
+# V=0 quiet, V=1 verbose.  other values don't work.
+V = 0
+Q1 = $(V:1=)
+Q = $(Q1:0=@)
+ECHO1 = $(V:1=@ :)
+ECHO = $(ECHO1:0=@ echo)
+NULLCMD = :
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /Users/himotoyoshi/.rbenv/versions/2.4.2/include/ruby-2.4.0
+hdrdir = $(topdir)
+arch_hdrdir = /Users/himotoyoshi/.rbenv/versions/2.4.2/include/ruby-2.4.0/x86_64-darwin16
+PATH_SEPARATOR = :
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+prefix = $(DESTDIR)/Users/himotoyoshi/.rbenv/versions/2.4.2
+rubysitearchprefix = $(rubylibprefix)/$(sitearch)
+rubyarchprefix = $(rubylibprefix)/$(arch)
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+exec_prefix = $(prefix)
+vendorarchhdrdir = $(vendorhdrdir)/$(sitearch)
+sitearchhdrdir = $(sitehdrdir)/$(sitearch)
+rubyarchhdrdir = $(rubyhdrdir)/$(arch)
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+sitehdrdir = $(rubyhdrdir)/site_ruby
+rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendordir = $(rubylibprefix)/vendor_ruby
+sitearchdir = $(sitelibdir)/$(sitearch)
+sitelibdir = $(sitedir)/$(ruby_version)
+sitedir = $(rubylibprefix)/site_ruby
+rubyarchdir = $(rubylibdir)/$(arch)
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+sitearchincludedir = $(includedir)/$(sitearch)
+archincludedir = $(includedir)/$(arch)
+sitearchlibdir = $(libdir)/$(sitearch)
+archlibdir = $(libdir)/$(arch)
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+mandir = $(datarootdir)/man
+localedir = $(datarootdir)/locale
+libdir = $(exec_prefix)/lib
+psdir = $(docdir)
+pdfdir = $(docdir)
+dvidir = $(docdir)
+htmldir = $(docdir)
+infodir = $(datarootdir)/info
+docdir = $(datarootdir)/doc/$(PACKAGE)
+oldincludedir = $(SDKROOT)/usr/include
+includedir = $(prefix)/include
+localstatedir = $(prefix)/var
+sharedstatedir = $(prefix)/com
+sysconfdir = $(prefix)/etc
+datadir = $(datarootdir)
+datarootdir = $(prefix)/share
+libexecdir = $(exec_prefix)/libexec
+sbindir = $(exec_prefix)/sbin
+bindir = $(exec_prefix)/bin
+archdir = $(rubyarchdir)
+
+
+CC = clang
+CXX = clang++
+LIBRUBY = $(LIBRUBY_A)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = 
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static -framework CoreFoundation
+empty =
+OUTFLAG = -o $(empty)
+COUTFLAG = -o $(empty)
+CSRCFLAG = $(empty)
+
+RUBY_EXTCONF_H = 
+cflags   = $(optflags) $(debugflags) $(warnflags)
+cxxflags = $(optflags) $(debugflags) $(warnflags)
+optflags = -O3 -fno-fast-math
+debugflags = -ggdb3
+warnflags = -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
+CCDLFLAGS = -fno-common
+CFLAGS   = $(CCDLFLAGS) $(cflags)  -pipe $(ARCH_FLAG)
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS = -DHAVE_CARRAY_H -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 $(DEFS) $(cppflags)
+CXXFLAGS = $(CCDLFLAGS) $(cxxflags) $(ARCH_FLAG)
+ldflags  = -L. -L/Users/himotoyoshi/.rbenv/versions/2.4.2/lib -L/usr/local/opt/qt/lib: -fstack-protector -L/usr/local/lib
+dldflags = -L/Users/himotoyoshi/.rbenv/versions/2.4.2/lib -L/usr/local/opt/qt/lib: -Wl,-undefined,dynamic_lookup -Wl,-multiply_defined,suppress 
+ARCH_FLAG = 
+DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
+LDSHARED = $(CC) -dynamic -bundle
+LDSHAREDXX = $(CXX) -dynamic -bundle
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = $(RUBY_BASE_NAME)
+RUBY_SO_NAME = ruby
+RUBYW_INSTALL_NAME = 
+RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version)
+RUBYW_BASE_NAME = rubyw
+RUBY_BASE_NAME = ruby
+
+arch = x86_64-darwin16
+sitearch = $(arch)
+ruby_version = 2.4.0
+ruby = $(bindir)/$(RUBY_BASE_NAME)
+RUBY = $(ruby)
+ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/backward.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h
+
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = rmdir -p
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+TOUCH = exit >
+
+#### End of system configuration section. ####
+
+preload = 
+libpath = . $(libdir) /Users/himotoyoshi/.rbenv/versions/2.4.2/lib/ruby/gems/2.4.0/gems/carray-1.5.0/lib
+LIBPATH =  -L. -L$(libdir) -L/Users/himotoyoshi/.rbenv/versions/2.4.2/lib/ruby/gems/2.4.0/gems/carray-1.5.0/lib
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS =   -lpthread -lgmp -ldl -lobjc 
+ORIG_SRCS = carray_calculus.c carray_interp.c
+SRCS = $(ORIG_SRCS) 
+OBJS = carray_calculus.o carray_interp.o
+HDRS = 
+LOCAL_HDRS = 
+TARGET = carray_calculus
+TARGET_NAME = carray_calculus
+TARGET_ENTRY = Init_$(TARGET_NAME)
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+TIMESTAMP_DIR = .
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
+ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
+TARGET_SO_DIR =
+TARGET_SO     = $(TARGET_SO_DIR)$(DLLIB)
+CLEANLIBS     = $(TARGET_SO) 
+CLEANOBJS     = *.o  *.bak
+
+all:    $(DLLIB)
+static: $(STATIC_LIB)
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-static clean-rb
+
+clean-static::
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-static clean-rb-default clean-rb
+		-$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean-static::
+distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb
+		-$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		-$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+		-$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(DLLIB) $(TIMESTAMP_DIR)/.sitearchdir.time
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+clean-static::
+	-$(Q)$(RM) $(STATIC_LIB)
+install-rb: pre-install-rb do-install-rb install-rb-default
+install-rb-default: pre-install-rb-default do-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+do-install-rb:
+do-install-rb-default:
+pre-install-rb-default:
+	@$(NULLCMD)
+$(TIMESTAMP_DIR)/.sitearchdir.time:
+	$(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
+	$(Q) $(TOUCH) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .mm .cxx .cpp .o .S
+
+.cc.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cc.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.mm.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.mm.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.cxx.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cxx.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.cpp.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cpp.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.c.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.c.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.m.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.m.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+$(TARGET_SO): $(OBJS) Makefile
+	$(ECHO) linking shared-object $(DLLIB)
+	-$(Q)$(RM) $(@)
+	$(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+	$(Q) $(POSTLINK)
+
+
+
+$(OBJS): $(HDRS) $(ruby_headers)

data/ext/carray_calculus.c

@@ -0,0 +1,864 @@
+/* ---------------------------------------------------------------------------
+
+  carray/carray_calculus.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>
+#include <float.h>
+
+/* ----------------------------------------------------------------- */
+
+static double
+simpson (double *x, double *y, ca_size_t n)
+{
+  double s;
+
+  if ( n < 2 ) {
+    return 0.0/0.0;
+  }
+  else if ( n == 2 ) {
+    s = (x[1]-x[0])*(y[1]+y[0])*0.5;
+    return s;
+  }
+  else if ( n % 2 == 0 ) {
+    double x0, x1, x2, x3;
+    double h, m, a1, a2, c0, c1, c2, c3;
+    x0 = x[0];
+    x1 = x[1];
+    x2 = x[2];
+    x3 = x[3];
+    h  = x3 - x0;
+    m  = (x3 + x0)/2;
+    a1 = x1 - m;
+    a2 = x2 - m;
+    c0 = 1.0 + 2.0*a1*a2/((x0-x1)*(x0-x2));
+    c1 =       h*h*a2/((x1-x2)*(x1-x0)*(x1-x3));
+    c2 =       h*h*a1/((x2-x1)*(x2-x0)*(x2-x3));
+    c3 = 1.0 + 2.0*a1*a2/((x3-x1)*(x3-x2));
+    s  = (c0*y[0]+c1*y[1]+c2*y[2]+c3*y[3])*h/6.0;
+    if ( n > 4 ) {
+      s += simpson(x+3, y+3, n-3);
+    }
+    return s;
+  }
+  else {
+    double x0, x1, x2;
+    double h, m, c0, c1, c2;
+    ca_size_t i;
+    s = 0.0;
+    for (i=0; i<n-2; i+=2) {
+      x0 = x[i];
+      x1 = x[i+1];
+      x2 = x[i+2];
+      h = x2-x0;
+      m = 0.5*(x2+x0);
+      c0 = 3.0 - h/(x1-x0);
+      c1 =       h*(x2-x0)/((x2-x1)*(x1-x0));
+      c2 = 3.0 - h/(x2-x1);
+      s += (c0*y[i]+c1*y[i+1]+c2*y[i+2])*h/6.0;
+    }
+    return s;
+  }
+}
+
+static VALUE
+rb_ca_integrate (volatile VALUE self, volatile VALUE vsc)
+{
+  CArray *sc, *ca;
+  double ans;
+
+  ca = ca_wrap_readonly(self, CA_DOUBLE);
+  sc = ca_wrap_readonly(vsc, CA_DOUBLE);
+
+  if ( ca->elements != sc->elements ) {
+    rb_raise(rb_eRuntimeError, "data num mismatch");
+  }
+
+  if ( ca_is_any_masked(ca) || ca_is_any_masked(sc) ) {
+    rb_raise(rb_eRuntimeError,
+             "can't calculate integrattion when masked elements exist");
+  }
+
+  ca_attach_n(2, ca, sc);
+
+  ans = simpson((double*)sc->ptr, (double*)ca->ptr, ca->elements);
+
+  ca_detach_n(2, ca, sc);
+
+  return rb_float_new(ans);
+}
+
+
+/* ----------------------------------------------------------------- */
+
+static ca_size_t
+linear_index (ca_size_t n, double *y, double yy, double *idx)
+{
+  ca_size_t a, b, c, x1;
+  double ya, yb, yc;
+  double y1, y2;
+  double rest;
+
+  if ( yy <= y[0] ) {
+    x1 = 0;
+    goto found;
+  }
+
+  if ( yy >= y[n-1] ) {
+    x1 = n-2;
+    goto found;
+  }
+
+  /* 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 ) { /* lucky case */
+      x1 = a;
+      goto found; 
+    }
+  }
+
+  /* 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;
+
+ found:
+
+  y1 = y[x1];
+  y2 = y[x1+1];
+  rest = (yy-y1)/(y2-y1);
+
+  if ( fabs(y2-yy)/fabs(y2) < DBL_EPSILON*100 ) {
+    *idx = (double) (x1 + 1);
+  }
+  else if ( fabs(y1-yy)/fabs(y1) < DBL_EPSILON*100 ) {
+    *idx = (double) x1;
+  }
+  else {
+    *idx = rest + (double) x1;
+  }
+
+  return 0;
+}
+
+static double
+interp_lin (double *x, double *y, double xx)
+{
+  double a, b;
+  double xa, xb;
+  double ab;
+  double fa, fb;
+  a = x[0];
+  b = x[1];
+  fa = y[0];
+  fb = y[1];
+  xa = xx - a;
+  xb = xx - b;
+  ab = a - b;
+  return -xa*fb/ab + xb*fa/ab;
+}
+
+static double
+deriv_lin (double *x, double *y, double xx)
+{
+  double a, b;
+  double ab;
+  double fa, fb;
+  a = x[0];
+  b = x[1];
+  fa = y[0];
+  fb = y[1];
+  ab = a - b;
+  return -fb/ab + fa/ab;
+}
+
+static double
+interp_qual (double *x, double *y, double xx)
+{
+  double a, b, c;
+  double xa, xb, xc;
+  double ab, bc, ca;
+  double fa, fb, fc;
+  a  = x[0];
+  b  = x[1];
+  c  = x[2];
+  fa = y[0];
+  fb = y[1];
+  fc = y[2];
+  xa = xx - a;
+  xb = xx - b;
+  xc = xx - c;
+  ab = a - b;
+  bc = b - c;
+  ca = c - a;
+  return -(xa*xb*fc/ca/bc + xb*xc*fa/ab/ca + xc*xa*fb/bc/ab);
+}
+
+static double
+deriv_qual (double *x, double *y, double xx)
+{
+  double a, b, c;
+  double xa, xb, xc;
+  double ab, bc, ca;
+  double fa, fb, fc;
+  a  = x[0];
+  b  = x[1];
+  c  = x[2];
+  fa = y[0];
+  fb = y[1];
+  fc = y[2];
+  xa = xx - a;
+  xb = xx - b;
+  xc = xx - c;
+  ab = a - b;
+  bc = b - c;
+  ca = c - a;
+  return - (xa+xb)*fc/ca/bc
+         - (xb+xc)*fa/ab/ca
+         - (xc+xa)*fb/bc/ab;
+}
+
+static double
+interp_cubic (double *x, double *y, double xx)
+{
+  double a, b, c, d;
+  double xa, xb, xc, xd;
+  double ab, bc, cd, da, db, ac;
+  double fa, fb, fc, fd;
+  a  = x[0];
+  b  = x[1];
+  c  = x[2];
+  d  = x[3];
+  fa = y[0];
+  fb = y[1];
+  fc = y[2];
+  fd = y[3];
+  xa = xx - a;
+  xb = xx - b;
+  xc = xx - c;
+  xd = xx - d;
+  ab = a - b;
+  bc = b - c;
+  cd = c - d;
+  da = d - a;
+  db = d - b;
+  ac = a - c;
+  return -xa*xb*xc*fd/da/db/cd - xb*xc*xd*fa/ab/ac/da +
+      xc*xd*xa*fb/bc/db/ab + xd*xa*xb*fc/cd/ac/bc;
+}
+
+static double
+deriv_cubic (double *x, double *y, double xx)
+{
+  double a, b, c, d;
+  double xa, xb, xc, xd;
+  double ab, bc, cd, da, db, ac;
+  double fa, fb, fc, fd;
+  a  = x[0];
+  b  = x[1];
+  c  = x[2];
+  d  = x[3];
+  fa = y[0];
+  fb = y[1];
+  fc = y[2];
+  fd = y[3];
+  xa = xx - a;
+  xb = xx - b;
+  xc = xx - c;
+  xd = xx - d;
+  ab = a - b;
+  bc = b - c;
+  cd = c - d;
+  da = d - a;
+  db = d - b;
+  ac = a - c;
+  return - (xb*xc+xa*xc+xa*xb)*fd/da/db/cd
+         - (xc*xd+xb*xd+xb*xc)*fa/ab/ac/da
+         + (xd*xa+xc*xa+xc*xd)*fb/bc/db/ab
+         + (xa*xb+xd*xb+xd*xa)*fc/cd/ac/bc;
+}
+
+static double
+interp_penta (double *x, double *y, double xx)
+{
+  double a, b, c, d, e, f;
+  double xa, xb, xc, xd, xe, xf;
+  double ya, yb, yc, yd, ye, yf;
+  double ab, ac, ad, ae, af;
+  double     bc, bd, be, bf;
+  double         cd, ce, cf;
+  double             de, df;
+  double                 ef;
+  a  = x[0];
+  b  = x[1];
+  c  = x[2];
+  d  = x[3];
+  e  = x[4];
+  f  = x[5];
+  ya = y[0];
+  yb = y[1];
+  yc = y[2];
+  yd = y[3];
+  ye = y[4];
+  yf = y[5];
+  xa = xx - a;
+  xb = xx - b;
+  xc = xx - c;
+  xd = xx - d;
+  xe = xx - e;
+  xf = xx - f;
+  ab = a - b;
+  ac = a - c;
+  ad = a - d;  
+  ae = a - e;  
+  af = a - f;  
+  bc = b - c;
+  bd = b - d;
+  be = b - e;
+  bf = b - f;
+  cd = c - d;
+  ce = c - e;
+  cf = c - f;
+  de = d - e;
+  df = d - f;
+  ef = e - f;
+  return   ya*xb*xc*xd*xe*xf/(ab*ac*ad*ae*af)
+         - xa*yb*xc*xd*xe*xf/(ab*bc*bd*be*bf)   
+         + xa*xb*yc*xd*xe*xf/(ac*bc*cd*ce*cf) 
+         - xa*xb*xc*yd*xe*xf/(ad*bd*cd*de*df) 
+         + xa*xb*xc*xd*ye*xf/(ae*be*ce*de*ef)        
+         - xa*xb*xc*xd*xe*yf/(af*bf*cf*df*ef);        
+}
+
+
+static double
+deriv_penta (double *x, double *y, double xx)
+{
+  double a, b, c, d, e, f;
+  double xa, xb, xc, xd, xe, xf;
+  double ya, yb, yc, yd, ye, yf;
+  double ab, ac, ad, ae, af;
+  double     bc, bd, be, bf;
+  double         cd, ce, cf;
+  double             de, df;
+  double                 ef;
+  a  = x[0];
+  b  = x[1];
+  c  = x[2];
+  d  = x[3];
+  e  = x[4];
+  f  = x[5];
+  ya = y[0];
+  yb = y[1];
+  yc = y[2];
+  yd = y[3];
+  ye = y[4];
+  yf = y[5];
+  xa = xx - a;
+  xb = xx - b;
+  xc = xx - c;
+  xd = xx - d;
+  xe = xx - e;
+  xf = xx - f;
+  ab = a - b;
+  ac = a - c;
+  ad = a - d;  
+  ae = a - e;  
+  af = a - f;  
+  bc = b - c;
+  bd = b - d;
+  be = b - e;
+  bf = b - f;
+  cd = c - d;
+  ce = c - e;
+  cf = c - f;
+  de = d - e;
+  df = d - f;
+  ef = e - f;
+  return   (xc*xd*xe*xf+xb*xd*xe*xf+xb*xc*xe*xf+xb*xc*xd*xf+xb*xc*xd*xe)*ya/(ab*ac*ad*ae*af)
+         - (xc*xd*xe*xf+xa*xd*xe*xf+xa*xc*xe*xf+xa*xc*xd*xf+xa*xc*xd*xe)*yb/(ab*bc*bd*be*bf)   
+         + (xb*xd*xe*xf+xa*xd*xe*xf+xa*xb*xe*xf+xa*xb*xd*xf+xa*xb*xd*xe)*yc/(ac*bc*cd*ce*cf) 
+         - (xb*xc*xe*xf+xa*xc*xe*xf+xa*xb*xe*xf+xa*xb*xc*xf+xa*xb*xc*xe)*yd/(ad*bd*cd*de*df) 
+         + (xb*xc*xd*xf+xa*xc*xd*xf+xa*xb*xd*xf+xa*xb*xc*xf+xa*xb*xc*xd)*ye/(ae*be*ce*de*ef)        
+         - (xb*xc*xd*xe+xa*xc*xd*xe+xa*xb*xd*xe+xa*xb*xc*xe+xa*xb*xc*xd)*yf/(af*bf*cf*df*ef);        
+}
+
+static double
+interpolate_linear (double *x, double *y, ca_size_t n, double xx)
+{
+  double xt[2];
+  double ri;
+  ca_size_t i0;
+  if ( n == 1) {
+    return y[0];
+  }
+  if ( x != NULL ) {
+    if ( xx == x[0] ) {
+      return y[0];
+    }
+    if ( xx == x[1] ) {
+      return y[1];
+    }
+    if ( n == 2 ) {
+      return interp_lin(x, y, xx);
+    }
+    linear_index(n, x, xx, &ri);
+    i0 = floor(ri);
+    if ( i0 <= 0 ) {
+      i0 = 0;
+    }
+    else if ( i0 + 1 >= n - 1 ) {
+      i0 = n - 2;
+    }
+    return interp_lin(&x[i0], &y[i0], xx);
+  }
+  else {
+    if ( xx == 0 ) {
+      return y[0];
+    }
+    if ( xx == 1 ) {
+      return y[1];
+    }
+    if ( n == 2 ) {
+      xt[0] = 0.0;
+      xt[1] = 1.0;
+      return interp_lin(xt, y, xx);
+    }
+    i0 = floor(xx);
+    if ( i0 <= 0 ) {
+      i0 = 0;
+    }
+    else if ( i0 + 1 >= n - 1 ) {
+      i0 = n - 2;
+    }
+    xt[0] = i0;
+    xt[1] = i0+1;
+    return interp_lin(xt, &y[i0], xx);
+  }
+}
+
+static double
+interpolate_cubic (double *x, double *y, ca_size_t n, double xx)
+{
+  static double xt[4];
+  double ri;
+  ca_size_t i0;
+  if ( n == 1) {
+    return y[0];
+  }
+  if ( x != NULL ) {
+    if ( xx == x[0] ) {
+      return y[0];
+    }
+    if ( xx == x[1] ) {
+      return y[1];
+    }
+    if ( xx == x[2] ) {
+      return y[2];
+    }
+    if ( n == 2 ) {
+      return interp_lin(x, y, xx);
+    }
+    if ( n == 3 ) {
+      return interp_qual(x, y, xx);
+    }
+    linear_index(n, x, xx, &ri);
+    i0 = floor(ri) - 1;
+    if ( i0 <= 0 ) {
+      i0 = 0;
+    }
+    else if ( i0 + 3 >= n - 1 ) {
+      i0 = n - 4;
+    }
+    return interp_cubic(&x[i0], &y[i0], xx);
+  }
+  else {    
+    if ( xx == 0 ) {
+      return y[0];
+    }
+    if ( xx == 1 ) {
+      return y[1];
+    }
+    if ( xx == 2 ) {
+      return y[2];
+    }    
+    if ( n == 2 ) {
+      xt[0] = 0.0;
+      xt[1] = 1.0;
+      return interp_lin(xt, y, xx);
+    }
+    if ( n == 3 ) {
+      xt[0] = 0.0;
+      xt[1] = 1.0;
+      xt[2] = 2.0;
+      return interp_qual(xt, y, xx);
+    }
+    ri = xx;
+    i0 = floor(ri) - 1;
+    if ( i0 <= 0 ) {
+      i0 = 0;
+    }
+    else if ( i0 + 3 >= n - 1 ) {
+      i0 = n - 4;
+    }
+    xt[0] = i0;
+    xt[1] = i0+1;
+    xt[2] = i0+2;
+    xt[3] = i0+3;
+    return interp_cubic(xt, &y[i0], xx);
+  }
+}
+
+static double
+differentiate (double *x, double *y, ca_size_t n, double xx)
+{
+  double ri;
+  ca_size_t i0;
+  switch ( n ) {
+  case 1:
+    return 0.0/0.0;
+  case 2:    
+    return deriv_lin(x, y, xx);
+  case 3:
+    return deriv_qual(x, y, xx);    
+  case 4:
+    return deriv_cubic(x, y, xx);    
+  }
+  linear_index(n, x, xx, &ri);
+  i0 = floor(ri) - 1;
+  if ( i0 <= 0 ) {
+    i0 = 0;
+  }
+  else if ( n == 5 && i0 + 4 > n - 1 ) {
+    i0 = n - 5;
+  }
+  else if ( i0 + 5 > n - 1 ) {
+    i0 = n - 6;
+  }
+  if ( n == 5 ) {
+    return deriv_cubic(&x[i0], &y[i0], xx);
+  }
+  else {
+    return deriv_penta(&x[i0], &y[i0], xx);    
+  }
+}
+
+static VALUE
+rb_ca_interpolate (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE rval = self;
+  volatile VALUE vsc, vx, ropt, rtype = Qnil, out0, out;
+  CArray *ca, *sc, *cv, *cx, *co0, *co;
+  char *typename = NULL;
+  int type = 0;
+  double *px, *po;
+  ca_size_t i;
+
+  Data_Get_Struct(self, CArray, ca);
+
+  rb_scan_args(argc, argv, "21", &vsc, &vx, &ropt);
+  rb_scan_options(ropt, "type", &rtype);
+
+  if ( ! NIL_P(rtype) ) {
+    Check_Type(rtype, T_STRING);
+    typename = StringValuePtr(rtype);
+  }
+
+  if ( typename == NULL || ! strncmp("cubic", typename, 5) ) {
+    type = 3;
+  }
+  else if ( ! strncmp("linear", typename, 6) ) {
+    type = 1;
+  }
+  else {
+    volatile VALUE inspect = rb_inspect(rtype);
+    rb_raise(rb_eRuntimeError, 
+             "invalid interpolation type <%s>", StringValuePtr(inspect));
+  }
+
+  if ( ! NIL_P(vsc) ) {
+
+    cv = ca_wrap_readonly(rval, CA_DOUBLE);
+    sc = ca_wrap_readonly(vsc,  CA_DOUBLE);
+
+    if ( ca_is_any_masked(cv) || ca_is_any_masked(sc) ) {
+      rb_raise(rb_eRuntimeError,
+               "can't calculate interpolation when masked elements exist");
+    }
+
+    if ( cv->elements != sc->elements ) {
+      rb_raise(rb_eRuntimeError, "data num mismatch with scale");
+    }
+
+    cx = ca_wrap_readonly(vx,   CA_DOUBLE);
+
+    co0 = carray_new(ca->data_type, cx->ndim, cx->dim, 0, NULL);
+    out = out0 = ca_wrap_struct(co0);
+    co = ca_wrap_writable(out, CA_DOUBLE);
+
+    ca_attach_n(4, cv, sc, cx, co);
+
+    px = (double*) cx->ptr;
+    po = (double*) co->ptr;
+
+    ca_update_mask(cx);
+    if ( cx->mask ) {
+      boolean8_t *mx, *mo;
+      ca_create_mask(co);
+      mx = (boolean8_t *) cx->mask->ptr;
+      mo = (boolean8_t *) co->mask->ptr;
+      if ( type == 3 ) {
+        for (i=0; i<cx->elements; i++) {
+          if ( ! *mx ) {
+            *po = interpolate_cubic((double*)sc->ptr, (double*)cv->ptr, 
+                                    cv->elements, *px);
+          }
+          else {
+            *mo = 1;
+          }
+          mx++; mo++; po++; px++;
+        }
+      }
+      else {
+        for (i=0; i<cx->elements; i++) {
+          if ( ! *mx ) {
+            *po = interpolate_linear((double*)sc->ptr, (double*)cv->ptr, 
+                                     cv->elements, *px);
+          }
+          else {
+            *mo = 1;
+          }
+          mx++; mo++; po++; px++;
+        }
+      }
+    }
+    else {
+      if ( type == 3 ) {
+        for (i=0; i<cx->elements; i++) {
+          *po++ = interpolate_cubic((double*)sc->ptr, (double*)cv->ptr, 
+                                    cv->elements, *px++);
+        }
+      }
+      else {
+        for (i=0; i<cx->elements; i++) {
+          *po++ = interpolate_linear((double*)sc->ptr, (double*)cv->ptr, 
+                                     cv->elements, *px++);
+        }
+      }
+    }
+
+    ca_sync(co);
+    ca_detach_n(4, cv, sc, cx, co);
+
+  }
+  else {
+
+    
+    cv = ca_wrap_readonly(rval, CA_DOUBLE);
+
+
+    if ( ca_is_any_masked(cv) ) {
+      rb_raise(rb_eRuntimeError,
+               "can't calculate interpolation when masked elements exist");
+    }
+
+    cx = ca_wrap_readonly(vx,   CA_DOUBLE);
+
+    co0 = carray_new(ca->data_type, cx->ndim, cx->dim, 0, NULL);
+    out = out0 = ca_wrap_struct(co0);
+    co = ca_wrap_writable(out, CA_DOUBLE);
+
+    ca_attach_n(3, cv, cx, co);
+
+    px = (double*) cx->ptr;
+    po = (double*) co->ptr;
+
+    ca_update_mask(cx);
+    if ( cx->mask ) {
+      boolean8_t *mx, *mo;
+      ca_create_mask(co);
+      mx = (boolean8_t *) cx->mask->ptr;
+      mo = (boolean8_t *) co->mask->ptr;
+      if ( type == 3 ) {
+        for (i=0; i<cx->elements; i++) {
+          if ( ! *mx ) {
+            *po = interpolate_cubic(NULL, (double*)cv->ptr, 
+                                    cv->elements, *px);
+          }
+          else {
+            *mo = 1;
+          }
+          mx++; mo++; po++; px++;
+        }
+      }
+      else {
+        for (i=0; i<cx->elements; i++) {
+          if ( ! *mx ) {
+            *po = interpolate_linear(NULL, (double*)cv->ptr, 
+                                     cv->elements, *px);
+          }
+          else {
+            *mo = 1;
+          }
+          mx++; mo++; po++; px++;
+        }
+      }
+    }
+    else {
+      if ( type == 3 ) {
+        for (i=0; i<cx->elements; i++) {
+          *po++ = interpolate_cubic(NULL, (double*)cv->ptr, 
+                                    cv->elements, *px++);
+        }
+      }
+      else {
+        for (i=0; i<cx->elements; i++) {
+          *po++ = interpolate_linear(NULL, (double*)cv->ptr, 
+                                     cv->elements, *px++);
+        }
+      }
+    }
+
+    ca_sync(co);
+    ca_detach_n(3, cv, cx, co);    
+    
+  }
+
+  if ( rb_ca_is_scalar(vx) ) {
+    return rb_funcall(out0, rb_intern("[]"), 1, INT2NUM(0));
+  }
+  else {
+    return out0;
+  }
+}
+
+static VALUE
+rb_ca_differentiate (volatile VALUE self,
+                     volatile VALUE vsc, volatile VALUE vx)
+{
+  volatile VALUE rval = self;
+  volatile VALUE out0, out;
+  CArray *ca, *cv, *sc, *cx, *co0, *co;
+  double *px, *po;
+  ca_size_t i;
+
+  Data_Get_Struct(self, CArray, ca);
+
+  sc = ca_wrap_readonly(vsc,  CA_DOUBLE);
+
+  if ( ca_is_any_masked(ca) || ca_is_any_masked(sc) ) {
+    rb_raise(rb_eRuntimeError,
+             "can't calculate differentiation when masked elements exist");
+  }
+
+  if ( ca->elements != sc->elements ) {
+    rb_raise(rb_eRuntimeError, "data num mismatch with scale");
+  }
+
+  cv = ca_wrap_readonly(rval, CA_DOUBLE);
+  cx = ca_wrap_readonly(vx,   CA_DOUBLE);
+
+  co0 = carray_new(ca->data_type, cx->ndim, cx->dim, 0, NULL);
+  out = out0 = ca_wrap_struct(co0);
+  co = ca_wrap_writable(out, CA_DOUBLE);
+
+  ca_attach_n(4, cv, sc, cx, co);
+
+  px = (double*) cx->ptr;
+  po = (double*) co->ptr;
+
+  ca_update_mask(cx);
+  if ( cx->mask ) {
+    boolean8_t *mx, *mo;
+    ca_create_mask(co);
+    mx = (boolean8_t *) cx->mask->ptr;
+    mo = (boolean8_t *) co->mask->ptr;
+    for (i=0; i<cx->elements; i++) {
+      if ( ! *mx ) {
+        *po = differentiate((double*)sc->ptr, (double*)cv->ptr, 
+                            cv->elements, *px);
+      }
+      else {
+        *mo = 1;
+      }
+      mx++; mo++; px++, po++;
+    }
+  }
+  else {
+    for (i=0; i<cx->elements; i++) {
+      *po = differentiate((double*)sc->ptr, (double*)cv->ptr, 
+                          cv->elements, *px);
+      px++, po++;
+    }
+  }
+
+  ca_sync(co);
+  ca_detach_n(4, cv, sc, cx, co);
+
+  if ( rb_ca_is_scalar(vx) ) {
+    return rb_funcall(out0, rb_intern("[]"), 1, INT2NUM(0));
+  }
+  else {
+    return out0;
+  }
+}
+
+void
+Init_carray_interpolate ();
+
+void
+Init_carray_calculus ()
+{
+  rb_define_method(rb_cCArray,  "integrate",    rb_ca_integrate, 1);
+  rb_define_method(rb_cCArray,  "interpolate",  rb_ca_interpolate, -1);
+  rb_define_method(rb_cCArray,  "differentiate", rb_ca_differentiate, 2);
+
+  Init_carray_interpolate();
+}