carray 1.3.5 → 1.5.1

data/ext/imagemap/test/test.rb

@@ -1,23 +0,0 @@
-require 'carray'
-
-#sc = ImageMap::ColorScale.pm3d(13,10,14,256,:interpolation => false)
-#sc = ImageMap::ColorScale.GMT("GMT_globe.cpt")
-#sc.set_range(0..Math::PI)
-#sc.set_upper_color(127,127,127)
-#sc.set_lower_color(127,127,127)
-#sc.set_mask_color( 127,127,127)
-
-ca = CArray.float(640, 480)
-ca[:i,nil].scale!(-0.1, Math::PI+0.1)
-ca.mask = 0
-ca.mask[90..110,90..110] = 1
-
-if true
-  im = ImageMap.create(ca, sc)
-  require 'carray/RMagick'
-  il = Magick::Image.new_from_ca(im)
-  il.display
-else
-  im = ImageMap.display(ca, sc)
-end
-

data/ext/imagemap/test/test_image.rb

@@ -1,42 +0,0 @@
-require 'carray'
-require 'carray/image_map'
-require 'benchmark'
-
-lon = CArray.float(37).span!(-90..180)
-lat = CArray.float(12).span!(0..90)
-
-u = lon[:%,lat.dim0]
-v = lat[lon.dim0,:%]
-val = u.rad.sin! + v.rad 
-
-image = ImageMap.new(CA_DOUBLE, [600, 600]) { -9999 }
-
-image.set_xrange(-103..103)
-image.set_yrange(-103..103)
-
-Benchmark.bm do |o|
-  o.report {
-    image.warp(val, u, v, :grid=>"point", :gradation => true) {
-      |_u,_v,_x,_y|
-      _x[] = (100 - _v/3) * _u.rad.cos!
-      _y[] = (100 - _v/3) * _u.rad.sin!
-    }
-  }
-end
-
-#image.draw_line(0, 0, 0, 90, 0)
-image.line(0, 0, 0, 90, 0)
-
-poly = CArray.float(4,2) {[[-90,90],[0,0],[45,45],[0,90]]}
-
-image.polyline(poly[nil,1],poly[nil,0], 0)
-
-image[:lt, -9998] = UNDEF
-
-#sc = nil
-#sc = ImageMap::ColorScale.pm3d(11,7,22,12)
-sc = ColorScale.GMT("GMT_polar.cpt")
-#sc.set_mask_color(64,64,64)
-sc.set_range(nil, nil)
-
-ImageMap.display(image, sc)

data/ext/imagemap/test/test_line.rb

@@ -1,14 +0,0 @@
-require 'carray'
-require 'carray/image_map'
-
-p img = ImageMap.new(CA_INT8, [200,200]) {0}
-p img.class
-
-gx = CArray.float(2,2) { [[10,30],
-                          [10,30]] }
-gy = CArray.float(2,2) { [[10,10],
-                          [80,50]] }
-
-img.fill_rectangle(gy, gx, 255)
-
-img.display_by_magick

data/ext/imagemap/test/test_rotate.rb

@@ -1,17 +0,0 @@
-require "carray"
-
-img = ImageMap.new(:int16, [300, 300]) {0}
-img.set_xrange 0...300
-img.set_yrange 0...300
-
-data = CArray.int16(16,16).seq!
-
-x = CArray.float(16).seq![16,:%]
-y = CArray.float(16).seq!.reverse![:%,16]
-
-img.warp(data, x, y, :grid=>"area0", :gradation=>false) {|gx,gy,ix,iy|
-  ix[] = 8*(gy+gx) + 24
-  iy[] = 8*(gy-gx) + 150
-}
-
-img.as_uint8.display_by_magick

data/ext/imagemap/test/test_triangle.rb

@@ -1,20 +0,0 @@
-require 'carray'
-
-image  = CArray.float(200, 200) { nan }
-
-y = CArray.float(2,2){[50,50, 65,100]}
-x = CArray.float(2,2){[70,100,50,90]}
-z = CArray.float(2,2){[30,40, 50,20]}
-ImageMap::Image.draw_rectangle_gradation(image, y, x, z)
-
-#image.draw_line(y[0], x[0], y[1], x[1])
-#image.draw_line(y[1], x[1], y[2], x[2])
-#image.draw_line(y[2], x[2], y[0], x[0])
-#image.draw_line(y[2], x[2], y[0], x[0])
-
-image.mask = image.is_nan
-
-sc = ImageMap::ColorScale.pm3d(13,6,10)
-
-ImageMap.display(image, sc)
-

data/ext/imagemap/test/test_warp.rb

@@ -1,26 +0,0 @@
-require 'carray'
-
-lon = CArray.float(121).span!(-180..180)
-lat = CArray.float(12).span!(0..90)
-p val = CArray.uint16(121,12).seq!.quantize(256)
-
-img = ImageMap.uint16(600,600) { 9999 }
-
-img.warp(val, lon[:%,lat.dim0], lat[lon.dim0,:%], 
-         :grid=>"area0", :gradation=>false) { |u,v,x,y|
-  x[] = (100 - v/2) * u.rad.cos!
-  y[] = (100 - v/2) * u.rad.sin!
-  x.mul!(2).add!(300)
-  y.mul!(2).add!(300)
-}
-
-img[:eq,9999] = UNDEF
-
-RGB = CA.struct{ uint8 :r,:g,:b }
-rgb = CArray.new(RGB, [255,3])
-rgb["r"].seq!
-
-out = rgb.project(img)
-
-out.display_by_magick("rgb")
-

data/ext/mathfunc/extconf.rb

@@ -1,18 +0,0 @@
-require "mkmf"
-
-dir_config("carray", "../..", "../..")
-
-have_header("carray.h")
-
-if /cygwin|mingw/ =~ RUBY_PLATFORM
-  have_library("carray")
-end
-
-have_header("tgmath.h")
-
-have_func("atan2",  "math.h")
-have_func("hypot",  "math.h")
-have_func("lgamma", "math.h")
-have_func("expm1",  "math.h")
-
-create_makefile("carray/carray_mathfunc")

data/ext/mathfunc/lib/autoload/autoload_math_mathfunc.rb

@@ -1 +0,0 @@
-require "carray/math/mathfunc"

data/ext/mathfunc/lib/math/mathfunc.rb

@@ -1,15 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  lib/carray/graphics/imagemap.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
-#
-# ----------------------------------------------------------------------------
-
-require "carray/carray_mathfunc"
-
-

data/ext/mathfunc/test/test_hypot.rb

@@ -1,5 +0,0 @@
-require 'carray'
-
-p x = CArray.object(101).span(0..1)
-
-p CAMath.hypot(x[:*,nil], x[nil,:*])

data/ext/mathfunc/test/test_j0.rb

@@ -1,22 +0,0 @@
-require 'carray'
-
-x = CArray.float(101).span(0..10)
-
-CA.gnuplot { |g|
-  g.plot2d(
-           [x, x.erf],
-           [x, x.erfc]
-           )
-  g.plot2d(
-           [x, x.j0],
-           [x, x.j1],
-           [x, x.jn(2)],
-           [x, x.jn(3)],
-           [x, x.jn(4)],
-           [x, x.jn(5)]
-           )
-  g.plot2d(
-           [x, x.y0],
-           [x, x.y1]
-           )
-}

data/ext/mathfunc/test/test_jn.rb

@@ -1,8 +0,0 @@
-require "carray"
-
-p x = CAMath.yn(1, CA_FLOAT(0..100))
-
-CA.gnuplot { |g|
-  g.plot2d([x], :with=>"lines")
-}
-

data/ext/mathfunc/test/test_sph.rb

@@ -1,9 +0,0 @@
-require "carray"
-
-r = CA_DOUBLE(1)
-theta = CA_DOUBLE(30).rad
-phi = CA_DOUBLE(45).rad
-
-x,y,z = CAMath.spherical_to_xyz(r, theta, phi)
-p CAMath.xyz_to_spherical(x,y,z)
-p [r, theta, phi]

data/ext/narray/README

@@ -1,22 +0,0 @@
-
-This directory contains the plugin library used as the interface to NArray
-and NArrayMiss library from Ruby/CArray. 
-
----
-NArray Library (http://narray.rubyforge.org/) by Masahiro Tanaka.
-
-  NArray is an Numerical N-dimensional Array class. Supported element types 
-  are 1/2/4-byte Integer, single/double-precision Real/Complex, and Ruby 
-  Object. This extension library incorporates fast calculation and easy
-  manipulation of large numerical arrays into the Ruby language. NArray 
-  has features similar to NumPy, but NArray has vector and matrix subclasses.
-
-  (License: Ruby License)
-
----
-NArrayMiss Library (http://ruby.gfd-dennou.org/index.htm) by Seiya Nishizawa.
-
-  NArrayMiss is a additional class processing of missing value with to NArray
-  for Ruby.
-
-  (License: GNU Lesser General Public License (LGPL) version 2.)

data/ext/narray/ca_wrap_narray.c

@@ -1,500 +0,0 @@
-/* ---------------------------------------------------------------------------
-
-  carray/ca_wrap_narray.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 "narray_config.h"
-#ifndef HAVE_U_INT8_T
-#define HAVE_U_INT8_T
-#endif
-#ifndef HAVE_INT16_T
-#define HAVE_INT16_T
-#endif
-#ifndef HAVE_INT16_T
-#define HAVE_INT32_T
-#endif
-#ifndef HAVE_U_INT32_T
-#define HAVE_U_INT32_T
-#endif
-#include "narray.h"
-
-#include <math.h>
-
-extern VALUE cNMatrix, cNVector, cNMatrixLU;
-
-static char EMPTY_ARRAY_PTR;
-
-/* -------------------------------------------------------------------- */
-
-static int8_t
-na_typecode_to_ca_data_type (int typecode)
-{
-  int8_t data_type;
-  
-  switch ( typecode ) {
-  case NA_BYTE:
-    data_type = CA_UINT8; break;
-  case NA_SINT:
-    data_type = CA_INT16; break;
-  case NA_LINT:
-    data_type = CA_INT32; break;
-  case NA_SFLOAT:
-    data_type = CA_FLOAT32; break;
-  case NA_DFLOAT:
-    data_type = CA_FLOAT64; break;
-#ifdef HAVE_COMPLEX_H
-  case NA_SCOMPLEX:
-    data_type = CA_CMPLX64; break;
-  case NA_DCOMPLEX:
-    data_type = CA_CMPLX128; break;
-#endif
-  case NA_ROBJ:
-    data_type = CA_OBJECT; break;
-  default:
-    rb_raise(rb_eCADataTypeError, 
-             "unknown NArray typecode <%i>", typecode);
-  }
-  return data_type;
-}
-
-static int
-ca_data_type_to_na_typecode(int8_t data_type)
-{
-  int typecode;
-
-  switch ( data_type ) {
-  case CA_BOOLEAN:
-  case CA_UINT8:
-    typecode = NA_BYTE; break;
-  case CA_INT16:
-    typecode = NA_SINT; break;
-  case CA_INT32:
-    typecode = NA_LINT; break;
-  case CA_FLOAT32:
-    typecode = NA_SFLOAT; break;
-  case CA_FLOAT64:
-    typecode = NA_DFLOAT; break;
-#ifdef HAVE_COMPLEX_H
-  case CA_CMPLX64:
-    typecode = NA_SCOMPLEX; break;
-  case CA_CMPLX128:
-    typecode = NA_DCOMPLEX; break;
-#endif
-  case CA_OBJECT:
-    typecode = NA_ROBJ; break;
-  default:
-    rb_raise(rb_eRuntimeError, 
-             "no corresponding NArray typecode for CArray data type <%s>",
-             ca_type_name[data_type]);
-  }
-
-  return typecode;
-}
-
-/* -------------------------------------------------------------------- */
-
-static void
-cary_na_ref_free (struct NARRAY *ary)
-{
-  xfree(ary->shape);
-  xfree(ary);
-}
-
-static void
-cary_na_ref_mark (struct NARRAY *ary)
-{
-  rb_gc_mark( ary->ref );
-}
-
-/* -------------------------------------------------------------------- */
-
-static VALUE
-rb_cary_na_ref_new_i (int argc, VALUE *argv, VALUE self, VALUE klass)
-{
-  CArray *orig;
-  struct NARRAY *ary;
-  int8_t i;
-
-  Data_Get_Struct(self, CArray, orig);
-
-  if ( ! ca_is_attached(orig) ) {
-    rb_raise(rb_eRuntimeError,
-             "cannot create NArray reference for not attached CArray");
-  }
-
-  ary = ALLOC(struct NARRAY);
-  if ( !ary ) {
-    rb_raise(rb_eRuntimeError, "cannot allocate NArray");
-  }
-
-  if ( orig->elements == 0 ) {
-    ary->rank = 0;
-    ary->shape = NULL;
-    ary->total = 0;
-    ary->ptr   = NULL;
-  }
-  else if ( argc == 0 ) {
-    ary->rank = orig->rank;
-    ary->shape = ALLOC_N(int, ary->rank);
-    for (i=0; i<ary->rank; i++) {
-      ary->shape[i] = (int) orig->dim[ary->rank-1-i];
-    }
-    ary->total = (int) orig->elements;
-    ary->ptr   = orig->ptr;
-  }
-  else {
-    ca_size_t elements = 1;
-    ary->rank = argc;
-    ary->shape = ALLOC_N(int, ary->rank);
-    for (i=0; i<ary->rank; i++) {
-      ary->shape[i] = NUM2INT(argv[i]);
-      elements *= ary->shape[i];
-    }
-    ary->total = (int) elements;
-    ary->ptr   = orig->ptr;
-    if ( elements != orig->elements ) {
-      free(ary->shape);
-      rb_raise(rb_eRuntimeError, "elements mismatch");
-    }
-  }
-
-  ary->type = ca_data_type_to_na_typecode(orig->data_type);
-  ary->ref  = self;
-
-  return Data_Wrap_Struct(klass, cary_na_ref_mark, cary_na_ref_free, ary);
-}
-
-/* rdoc:
-  class CArray
-    def na
-    end
-    def nv
-    end
-    def nm
-    end
-  end
-*/
-
-static VALUE
-rb_cary_na_ref_new (int argc, VALUE *argv, VALUE self)
-{
-  return rb_cary_na_ref_new_i(argc, argv, self, cNArray);
-}
-
-static VALUE
-rb_cary_nv_ref_new (int argc, VALUE *argv, VALUE self)
-{
-  return rb_cary_na_ref_new_i(argc, argv, self, cNVector);
-}
-
-static VALUE
-rb_cary_nm_ref_new (int argc, VALUE *argv, VALUE self)
-{
-  return rb_cary_na_ref_new_i(argc, argv, self, cNMatrix);
-}
-
-/* -------------------------------------------------------------------- */
-
-static VALUE
-rb_cary_to_na_bang_i (VALUE self, VALUE klass)
-{
-  volatile VALUE obj, fary;
-  CArray *ca;
-  struct NARRAY *na;
-  int type;
-
-  Data_Get_Struct(self, CArray, ca);
-
-  type = ca_data_type_to_na_typecode(ca->data_type);
-
-  if ( ca->elements == 0 ) {
-    obj = na_make_empty(type, klass);
-  }
-  else {
-    int shape[127];
-    int i;
-
-    for (i=0; i<ca->rank; i++) {
-      shape[i] = (int) ca->dim[ca->rank-i-1];
-    }
-
-    obj = na_make_object(type, ca->rank, shape, klass);
-    GetNArray(obj, na);
-
-    fary = rb_ca_farray(self);
-    Data_Get_Struct(fary, CArray, ca);
-
-    ca_copy_data(ca, na->ptr);
-  }
-
-  return obj;
-}
-
-/* rdoc:
-  class CArray
-    def to_na!
-    end
-    def to_nv!
-    end
-    def to_nm!
-    end
-  end
-*/
-
-static VALUE
-rb_cary_to_na_bang (VALUE self)
-{
-  return rb_cary_to_na_bang_i(self, cNArray);
-}
-
-static VALUE
-rb_cary_to_nv_bang (VALUE self)
-{
-  return rb_cary_to_na_bang_i(self, cNVector);
-}
-
-static VALUE
-rb_cary_to_nm_bang (VALUE self)
-{
-  return rb_cary_to_na_bang_i(self, cNMatrix);
-}
-
-/* -------------------------------------------------------------------- */
-
-static VALUE
-rb_cary_to_na_i (VALUE self, VALUE klass)
-{
-  volatile VALUE obj;
-  CArray *ca;
-  struct NARRAY *na;
-  int type;
-  int i;
-
-  Data_Get_Struct(self, CArray, ca);
-
-  type = ca_data_type_to_na_typecode(ca->data_type);
-
-  if ( ca->elements == 0 ) {
-    obj = na_make_empty(type, klass);
-  }
-  else {
-    int shape[127];
-    
-    for (i=0; i<ca->rank; i++) {
-      shape[i] = (int) ca->dim[ca->rank-i-1];
-    }
-
-    obj = na_make_object(type, ca->rank, shape, klass);
-    GetNArray(obj, na);
-
-    ca_copy_data(ca, na->ptr);
-  }
-
-  return obj;
-}
-
-/* rdoc:
-  class CArray
-    def to_na
-    end
-    def to_nv
-    end
-    def to_nm
-    end
-  end
-*/
-
-static VALUE
-rb_cary_to_na (VALUE self, VALUE klass)
-{
-  return rb_cary_to_na_i(self, cNArray);
-}
-
-static VALUE
-rb_cary_to_nv (VALUE self, VALUE klass)
-{
-  return rb_cary_to_na_i(self, cNVector);
-}
-
-static VALUE
-rb_cary_to_nm (VALUE self, VALUE klass)
-{
-  return rb_cary_to_na_i(self, cNMatrix);
-}
-
-/* -------------------------------------------------------------------- */
-
-/* rdoc:
-  class NArray
-    def ca
-    end
-  end
-*/
-
-static VALUE
-rb_na_ca_ref_new (int argc, VALUE *argv, VALUE self)
-{
-  volatile VALUE obj;
-  struct NARRAY *na;
-  ca_size_t dim[CA_RANK_MAX];
-  int8_t data_type;
-  int i;
-
-  GetNArray(self, na);
-
-  data_type = na_typecode_to_ca_data_type(na->type);
-
-  if ( na->total == 0 ) {
-    ca_size_t zero = 0;
-    obj = rb_carray_wrap_ptr(data_type, 1, &zero, 0, NULL,
-                             &EMPTY_ARRAY_PTR, self); /* avoid ca->ptr == NULL */
-  }
-  else {
-    if ( argc == 0 ) {
-      CA_CHECK_RANK(na->rank);
-      for (i=0; i<na->rank; i++) {
-        dim[i] = na->shape[na->rank-i-1];
-      }
-      obj = rb_carray_wrap_ptr(data_type,
-                               na->rank, dim, 0, NULL, na->ptr, self);
-    }
-    else {
-      CA_CHECK_RANK(argc);
-      for (i=0; i<argc; i++) {
-        dim[i] = NUM2INT(argv[i]);
-      }
-      obj = rb_carray_wrap_ptr(data_type, argc, dim, 0, NULL, na->ptr, self);
-    }
-  }
-
-  return obj;
-}
-
-/* -------------------------------------------------------------------- */
-
-/* rdoc:
-  class NArray
-    def to_ca
-    end
-  end
-*/
-
-
-static VALUE
-rb_na_to_ca (VALUE self)
-{
-  volatile VALUE obj;
-  CArray *ca;
-  struct NARRAY *na;
-  ca_size_t dim[CA_RANK_MAX];
-  ca_size_t data_type;
-  ca_size_t i;
-
-  GetNArray(self, na);
-
-  data_type = na_typecode_to_ca_data_type(na->type);
-
-  if ( na->total == 0 ) {
-    ca_size_t zero = 0;
-    obj = rb_carray_new(data_type, 1, &zero, 0, NULL);
-  }
-  else {
-    CA_CHECK_RANK(na->rank);
-
-    for (i=0; i<na->rank; i++) {
-      dim[i] = na->shape[na->rank-i-1];
-    }
-
-    obj = rb_carray_new(data_type, na->rank, dim, 0, NULL);
-    Data_Get_Struct(obj, CArray, ca);
-
-    ca_sync_data(ca, na->ptr);
-  }
-
-  return obj;
-}
-
-/* -------------------------------------------------------------------- */
-
-/* rdoc:
-  class NArray
-    def to_ca!
-    end
-  end
-*/
-
-static VALUE
-rb_na_to_ca_bang (VALUE self)
-{
-  volatile VALUE obj, fary;
-  CArray *ca;
-  struct NARRAY *na;
-  ca_size_t dim[CA_RANK_MAX];
-  ca_size_t data_type;
-  ca_size_t i;
-
-  GetNArray(self, na);
-
-  data_type = na_typecode_to_ca_data_type(na->type);
-
-  if ( na->total == 0 ) {
-    ca_size_t zero = 0;
-    obj = rb_carray_new(data_type, 1, &zero, 0, NULL);
-  }
-  else {
-    CA_CHECK_RANK(na->rank);
-
-    for (i=0; i<na->rank; i++) {
-      dim[i] = na->shape[na->rank-i-1];
-    }
-
-    obj = rb_carray_new(data_type, na->rank, dim, 0, NULL);
-    fary = rb_ca_farray(obj);
-    Data_Get_Struct(fary, CArray, ca);
-
-    ca_sync_data(ca, na->ptr);
-  }
-
-  return obj;
-}
-
-/* -------------------------------------------------------------------- */
-
-void
-Init_ca_wrap_narray ()
-{
-  /* rb_require("narray"); */ /* "narray" should be loaded in config.rb */
-
-  rb_define_const(rb_cCArray, "HAVE_NARRAY", Qtrue);
-
-  /* CArray -> NArray */
-  rb_define_method(rb_cCArray, "na",     rb_cary_na_ref_new, -1);
-  rb_define_method(rb_cCArray, "to_na",  rb_cary_to_na, 0);
-  rb_define_method(rb_cCArray, "to_na!", rb_cary_to_na_bang, 0);
-
-  /* CArray -> NVector */
-  rb_define_method(rb_cCArray, "nv",     rb_cary_nv_ref_new, -1);
-  rb_define_method(rb_cCArray, "to_nv",  rb_cary_to_nv, 0);
-  rb_define_method(rb_cCArray, "to_nv!", rb_cary_to_nv_bang, 0);
-
-  /* CArray -> NMatrix */
-  rb_define_method(rb_cCArray, "nm",     rb_cary_nm_ref_new, -1);
-  rb_define_method(rb_cCArray, "to_nm",  rb_cary_to_nm, 0);
-  rb_define_method(rb_cCArray, "to_nm!", rb_cary_to_nm_bang, 0);
-
-  /* NArray -> CArray */
-  rb_define_method(cNArray,    "ca",     rb_na_ca_ref_new, -1);
-  rb_define_method(cNArray,    "to_ca",  rb_na_to_ca, 0);
-  rb_define_method(cNArray,    "to_ca!", rb_na_to_ca_bang, 0);
-}
-