carray-netcdf 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 42bc2741ed1cb9934d9920bb3c27ae63a67d64cc
-  data.tar.gz: cb002d9c44eeb1ae1b21a82676e23994a99744d5
+SHA256:
+  metadata.gz: d5cff7f2cb0bb02ab816789ac1e1a6e068f0aea38d0769badc5da009716f47bc
+  data.tar.gz: c157b4c60c74ce53571340ee9c6f933f518aba41e3aabb3d333c0861fddd78e5
 SHA512:
-  metadata.gz: 5835fce18272746e19bed82b402f541c9051269b1f7162e5a0742235e1a652165ef0c1cf6899b16b3e8caf315f2f9af739cc2d7f59df3f98ab1e75eb558a7e98
-  data.tar.gz: 0e597194080519c77cbc8906feeb6f11db456e3d04c65595ab266003c92019453519aebd90e1afbb072c9374ce46c054a0e5afaa5a6091218ad422c9ed39baf3
+  metadata.gz: 8843d604eb32cd7e89e206ff4fdc08881172a8e1d5cf1b31b2cf4724c9ef5f41dd4b7cad5de631a80945670d757dd27b68b700dccb6e9ee491fc7d478956978a
+  data.tar.gz: f97a3893d3399ae4f23e61ae22e2536570ee87aa731bc40a6e39e827ff9a3fa572517ddf870234872c68cc88c58b33466e59c4ca6b3efe33398983b7882e8580

data/API.md

@@ -5,7 +5,7 @@ CArray/NetCDF library API document
 ------------------
 
     gem install carray-netcdf
-
+    
     require "carray-netcdf"
 
 2. Methods 
@@ -15,7 +15,7 @@ This API provides the way of calling functions
 
     include NC
     nc_funcname(...)
-
+    
     NC.funcname(...)
 
 ### 2.1. Data types
@@ -30,27 +30,27 @@ This API provides the way of calling functions
        mode : NC_CLOBBER   - permit overwrite 
               NC_NOCLOBBER - inhibit overwrite
               NC_SHARE     - no buffering
-
+    
     fd = nc_open(FILENAME[, mode=NC_NOWRITE])
        
        mode : NC_NOWRITE   - readonly
               NC_WRTIE     - writable
               NC_SHARE     - no buffering
-
+    
     nc_close(fd)
-
+    
     nc_redef(fd)
     nc_enddef(fd)
-
+    
     nc_sync(fd)
-
+    
     ndims    = nc_inq_ndims(fd)
     nvars    = nc_inq_nvars(fd)
     natts    = nc_inq_natts(fd)
     unlimdim = nc_inq_unlimdim(fd)
-
+    
     oldmode  = nc_set_fill(mode)
-
+    
        mode : NC_FILL
               NC_NOFILL
 
@@ -58,73 +58,73 @@ This API provides the way of calling functions
 
     dimid    = nc_def_dim(fd, dimname, len)
     dimid    = nc_inq_dimid(fd, dimname)    => Integer | nil
-
+    
     dimname  = nc_inq_dimname(fd, dimid)
     dimlen   = nc_inq_dimlen(fd, dimid)
-
+    
     nc_rename_dim(fd, dimid, newname)
 
 ### 2.4. NetCDF Variable
 
     varid    = nc_def_var(fd, varname, type, dim)
     varid    = nc_inq_varid(fd, varname)    => Integer | nil
-
+    
     vartype  = nc_inq_vartype(fd, varid)
     varndims = nc_inq_varndims(fd, varid)
     vardimid = nc_inq_varndimid(fd, varid)  => Array of dimids
-
+    
     nc_put_var1(fd, varid, [i,j,..], val)
     nc_put_var(fd, varid, ca)
     nc_put_vara(fd, varid, start, count, ca)
     nc_put_vars(fd, varid, start, count, stride, ca)
     nc_put_varm(fd, varid, start, count, stride, imap, ca)
-
+    
       + with data_type conversion
-
+    
     val = nc_get_var1(fd, varid, [i,j,..])
     ca = nc_get_var(fd, varid)                              [useful]
     ca = nc_get_vara(fd, varid, start, count)               [useful]
     ca = nc_get_vars(fd, varid, start, count, stride)       [useful]
     ca = nc_get_varm(fd, varid, start, count, stride, imap) [useful]
-
+    
       + no data_type conversion
-
+    
     nc_get_var(fd, varid, ca)                               [pedantic]
     nc_get_vara(fd, varid, start, count, ca)                [pedantic]
     nc_get_vars(fd, varid, start, count, stride, ca)        [pedantic]
     nc_get_varm(fd, varid, start, count, stride, imap, ca)  [pedantic]
-
+    
       + with data_type conversion.
-
+    
     nc_rename_var(fd, varid, newname)
 
 ### 2.5. NetCDF Attribute
 
     varnatts = nc_inq_varnatts(fd, varid)
     attid    = nc_inq_attid(fd, varid, attname)
-
+    
     attname  = nc_inq_attname(fd, varid, attid)
     atttype  = nc_inq_atttype(fd, varid, attname)
     attlen   = nc_inq_attlen(fd, varid, attname)
-
+    
     nc_put_att(fd, varid, attname, val)
-
+    
       varid : NC_GLOBAL for global att
       val   : String  -> NC_CHAR
               Integer -> NC_INT
               Float   -> NC_DOUBLE
               CArray  -> NC.nc_type(val.data_type)
-
-
+    
+    
     val = nc_get_att(fd, varid, attname)  => String | Numeric | CArray | nil
-
+    
       varid : NC_GLOBAL for global att
-
+    
     nc_get_att(fd, varid, attname, ca)                 [pedantic]
-
+    
     nc_rename_att(fd, varid, attname, newname)
     nc_del_att(fd, varid, attname)
-
+    
     nc_copy_att(fd1, varid1, attname, fd2, varid2)
 
 ### 2.6 Constants
@@ -135,24 +135,24 @@ This API provides the way of calling functions
     NC_INT
     NC_FLOAT
     NC_DOUBLE
-
+    
     NC_NOERR        - status of API routines
-
+    
     NC_CLOBBER      - permit overwrite  [nc_create]
     NC_NOCLOBBER    - inhibit overwrite [nc_create]
     NC_NOWRITE      - readonly [nc_open]
     NC_WRITE        - writable [nc_open]
     NC_SHARE        - no buffering [nc_create, nc_open]
-
+    
     NC_GLOBAL       - varid for global attributes
-
+    
     NC_NOFILL       - nc_set_fill(fd, varid, NC_NOFILL)
     NC_FILL         - nc_set_fill(fd, varid, NC_FILL)
-
+    
     NC_MAX_NAME
     NC_MAX_VAR_DIMS
     NC_MAX_DIMS
-
+    
     NC_LOCK         - ???
     NC_SIZEHINT_DEFAULT - ???
 
@@ -164,7 +164,7 @@ NCFile interface provides the way of *READ-ONLY* access to the netcdf file.
 ### 3.1. NCFile 
 
     nc = NCFile.open(FILENAME)
-
+    
     nc = NCFile.new(file_id)
            file_id: return value of nc_open in read-only mode
 
@@ -172,7 +172,7 @@ NCFile interface provides the way of *READ-ONLY* access to the netcdf file.
 
     nc.has_dim?(DIMNAME)
     nc.dims               - Array of dimension
-
+    
     dim = nc.dim(DIMNAME) - NCDim object or nil
     dim.to_i              - size of dimension
     dim.to_ca             
@@ -181,14 +181,14 @@ NCFile interface provides the way of *READ-ONLY* access to the netcdf file.
 
     nc.has_var?(VARNAME)
     nc.vars               - Array of variables
-
+    
     var = nc.var(VARNAME) - NCVar object or nil
     var.is_dim?           - true if dimension variable
     var.to_ca             - get array as CArray object
     var[...]              - Cooked value array with CArray-like indexing
     var.get!(...)         - same as [...]
     var.get(...)          - Non-cooked value array with CArray-like indexing
-
+    
     var.get_var1(...)     - interface to original get function 
     var.get_var()
     var.get_vara(start, count)
@@ -207,7 +207,7 @@ All attributes are already read in initializing process of NCFile object.
     nc.attributes           - Hash
     dim.attributes          
     var.attributes          
-
+    
     nc.attribute(ATTNAME)   - accessor
     dim.attribute(ATTNAME)
     var.attribute(ATTNAME)
@@ -230,41 +230,34 @@ It provides simple interface to create netcdf file.
 If you want the detailed controling to create netcdf, use nc_function API.
 
     out = NCFileWrite.new("test.nc")
-
+    
     out.define(
-      dims: {                            ### dimension
-        lon: 230,                              name: Integer
+      dimensions: {                      ### dimension
+        lon: 230,                        ###   name: Integer
         lat: 120,
         time: 24
       },
-      vars: {                            ### variables
+      variables: {                            ### variables
         temp: {                                name: definition
-          type: NC::NC_FLOAT,                    type: Integer
-          dims: ["time", "lat", "lon"],          dims: Array of dim names
-          attributes: {                          attributes: Hash
-            long_name: "air temperature",
-            units: "degC"
-          }
+          type: int,                           type: Integer or string (default NC::NC_FLOAT)
+                                                  one of byte,short,int,float,double
+          dim: ["time", "lat", "lon"],         dim: Array of dim names
+          long_name: "air temperature",        attributes for variable are parallel with type, dim
+          units: "degC"
+          param1: { float: 1.2 }
+          param2: { int: 10 }
         }
       },
-      attributes: {                      ### global attributes (Hash)
-        creator: "foobar"
+      attributes: {
+        creator: "foobar"                  ### global attributes (Hash)
       }
     )
-
+    
     out["lon"]  = lon
     out["lat"]  = lat
     out["time"] = time
     out["temp"][nil] = temp                  ### CArray index can be used
     out.write                            ### call nc_close 
-
-
+    
     nc = NCFile.open("test.nc")
     nc.definition                        ### return definition Hash 
-
-
-
-
-
-
-

data/carray-netcdf.gemspec

@@ -1,6 +1,6 @@
 
 Gem::Specification::new do |s|
-  version = "1.0.1"
+  version = "1.0.2"
 
   files = Dir.glob("**/*") - [ 
                                Dir.glob("carray-*.gem"), 

data/examples/test.rb

@@ -1 +1,41 @@
-require "carray-netcdf"
+require "carray"
+require "time"
+require "yaml"
+require "carray-netcdf"
+
+metadata = YAML.load %{
+dimensions:
+  time: 1440
+variables:
+  time: 
+    type: float
+    dim: [time]  
+    standard_name: time
+    long_name: time
+    units: minutes since 2018-01-01 00:00:00 +09:00
+}
+
+out = NCFileWriter.new("test.nc", compression: 1)
+out.define metadata
+
+out["time"] = CArray.float(1440).seq(1)
+
+out.close
+
+nc = NCFile.open("test.nc")
+
+time = nc["time"].to_time
+
+p time[0].to_s
+
+y = CArray.float(1440).seq(0,4*Math::PI/1440).sin
+
+#timezone = "UTC"
+timezone = ""
+
+CA.gnuplot {
+  plot [time(time,"UTC"), y],
+       xtime: true,
+       x: ["Time (UTC)", nil, "%H:%M"]
+}
+

data/examples/time.rb

@@ -0,0 +1,11 @@
+require "time"
+require "date"
+
+t1 = Time.parse("2018-01-01 00:00:00 +08")
+t2 = Time.parse("2018-01-01 00:00:00 UTC")
+t3 = DateTime.parse("2018-01-01 00:00:00 ADT")
+
+p t1.zone
+p t2
+p t3.to_time.gmt_offset
+

data/lib/io/netcdf.rb

@@ -54,6 +54,25 @@ class NCObject
     end
     return attrs.freeze
   end
+
+  def get_attributes! (file_id, var_id)
+    attrs = {}
+    varnatts = nc_inq_varnatts(file_id, var_id)
+    varnatts.times do |i|
+      attname = nc_inq_attname(file_id, var_id, i)
+      type    = nc_inq_atttype(file_id, var_id, attname)
+      case type
+      when NC_CHAR
+        value = nc_get_att(file_id, var_id, attname) 
+      else
+        len   = nc_inq_attlen(file_id, var_id, attname)
+        value = CArray.new(NC.ca_type(type), [len])
+        nc_get_att(file_id, var_id, attname, value)         
+      end
+      attrs[attname] = value
+    end
+    return attrs.freeze
+  end
   
   def attribute (name)
     return @attributes[name]
@@ -67,6 +86,15 @@ class NCVar < NCObject
   
   include NC
   
+  TYPENAME = {
+    NC_CHAR   => "char",
+    NC_BYTE   => "byte",
+    NC_SHORT  => "short",
+    NC_INT    => "int",
+    NC_FLOAT  => "float",
+    NC_DOUBLE => "double",
+  }
+  
   def initialize (ncfile, var_id)
     @ncfile     = ncfile
     @file_id    = ncfile.file_id
@@ -79,14 +107,20 @@ class NCVar < NCObject
     @dims.freeze
     @shape.freeze
   end
-  
+
   attr_reader :name, :dims
 
   def definition
-    {
-      type: @vartype,
-      dim: dims.map{|x| x.name }
-    }.update(@attributes)
+    defs = { "type" => TYPENAME[@vartype] }
+    if not dims.empty?
+      defs["dim"] = dims.map{|x| x.name }
+    end
+    atts = {}
+    get_attributes!(@file_id, @var_id).each do |k,v|
+      atts[k] = NCFile.convert_attribute_value(v)
+    end
+    defs.update(atts)
+    return defs
   end
 
   def inspect
@@ -139,6 +173,40 @@ class NCVar < NCObject
     return self[]
   end
 
+  TIME_UNITS = {
+    "day"     => 86400,
+    "days"    => 86400,
+    "d"       => 86400,
+    "hour"    => 3600,
+    "hours"   => 3600,
+    "hr"      => 3600,
+    "h"       => 3600,
+    "minute"  => 60,
+    "minutes" => 60,
+    "min"     => 60,
+    "second"  => 1,
+    "seconds" => 1,
+    "sec"     => 1,
+    "s"       => 1,
+  }  
+  
+  def to_time
+
+    if not @attributes.has_key?("units")
+      raise "variable #{@name} has no attribute 'units'"
+    elsif @attributes["units"] =~ /\A(.+?)\s+since\s+(.+)\Z/
+      interval = TIME_UNITS[$1]
+      basetime = Time.parse($2)
+      if interval
+        return self[].convert(:object) {|x| basetime + interval*x }
+      else
+        raise "#{$1} is invalid for time units"        
+      end
+    else
+      raise "format of #{@name}:units is not valid for time"
+    end
+  end
+
   def [] (*argv)
     return get!(*argv)
   end
@@ -327,11 +395,54 @@ class NCFile < NCObject
     @name2var.freeze
   end
 
+  def self.convert_attribute_value (value)
+    case value
+    when CArray
+      if value.length == 1
+        case value.data_type
+        when CA_UINT8
+          value = { "char" => value[0] }
+        when CA_BYTE
+          value = { "byte" => value[0] }
+        when CA_SHORT
+          value = { "short" => value[0] }
+        when CA_INT
+          value = { "int" => value[0] }
+        when CA_FLOAT
+          value = { "float" => value[0] }
+        when CA_DOUBLE
+          value = { "double" => value[0] }
+        end        
+      else
+        case value.data_type
+        when CA_UINT8
+          value = { "char" => value.to_a }
+        when CA_BYTE
+          value = { "byte" => value.to_a }
+        when CA_SHORT
+          value = { "short" => value.to_a }
+        when CA_INT
+          value = { "int" => value.to_a }
+        when CA_FLOAT
+          value = { "float" => value.to_a }
+        when CA_DOUBLE
+          value = { "double" => value.to_a }
+        end
+      end
+    end
+    return value
+  end
+
   def definition
+    atts = {}
+    get_attributes!(@file_id, NC_GLOBAL).each do |k,v|
+      atts[k] = NCFile.convert_attribute_value(v)
+    end
     {
-      dimensions: @dims.map{|x| [x.name, x.definition] }.to_h,
-      variables: @vars.map{|x| [x.name, x.definition] }.to_h
-    }.update(@attributes)    
+      "dimensions" => @dims.map{|x| [x.name, x.definition] }.to_h,
+      "variables" => @vars.map{|x| [x.name, x.definition] }.to_h,
+      "attributes" => atts
+    }
   end
 
   def [] (name)
@@ -360,20 +471,48 @@ class NCFileWriter
 
     include NC
 
-    def initialize (ncfile, name, definition)
+    TYPEMAP = {
+      "char"   => NC_CHAR,
+      "byte"   => NC_BYTE,
+      "short"  => NC_SHORT,
+      "int"    => NC_INT,
+      "float"  => NC_FLOAT,
+      "double" => NC_DOUBLE,
+    }
+
+    def initialize (ncfile, name, definition, compression = 0)
       @ncfile  = ncfile
       @file_id = ncfile.file_id
       @name    = name
       @type    = definition["type"] || NC_FLOAT
+      if @type.is_a?(String)
+        if TYPEMAP.include?(@type)
+          @type = TYPEMAP[@type]
+        else
+          raise "invalid variable data type"
+        end
+      end
       @dims    = definition["dim"]
-      @shape   = @dims.map{|key| @ncfile.dim(key).to_i }
-      dim_ids  = @dims.map{|key| @ncfile.dim(key).dim_id }
+      if @dims
+        @shape   = @dims.map{|key| @ncfile.dim(key).to_i }
+        dim_ids  = @dims.map{|key| @ncfile.dim(key).dim_id }
+      else
+        dim_ids  = []
+      end
       @var_id  = nc_def_var(@file_id, @name, @type, dim_ids)
+      if compression != 0
+        nc_def_var_deflate(@file_id, @var_id, 1, 1, compression)
+      end
       @attributes = definition.dup
       @attributes.delete("type")
       @attributes.delete("dim")
       @attributes.each do |name, value|
-        nc_put_att(@file_id, @var_id, name, value)
+        value = NCFileWriter.convert_attribute_value(value)
+        begin
+          nc_put_att(@file_id, @var_id, name, value)
+        rescue => e
+          raise(e.class, e.message + " {#{name}: #{value}}")
+        end
       end
       @attributes.freeze
     end
@@ -471,17 +610,32 @@ class NCFileWriter
     
   end
   
-  def initialize (file)
-    @file_id  = nc_create(file)
+  TYPEMAP = {
+    "char" => NC_CHAR,
+    "byte" => NC_BYTE,
+    "short" => NC_SHORT,
+    "int" => NC_INT,
+    "float" => NC_FLOAT,
+    "double" => NC_DOUBLE,
+  }
+  
+  def initialize (file, mode = 0, compression: 0)
+    if compression > 0
+      @file_id  = nc_create(file, mode|NC_NETCDF4)
+    else
+      @file_id  = nc_create(file, mode)
+    end
     @dims     = []
     @name2dim = {}
     @vars     = []
     @name2var = {}
+    @compression = compression
     @attributes = nil
   end
   
   attr_reader :file_id
   
+  # key of Hash in definition should be String 
   def normalize_definition (definition)
     out = {}
     definition.each do |key, value|
@@ -492,43 +646,99 @@ class NCFileWriter
     end
     return out
   end
-  
+
+  def check_definition (definition)
+    if definition.has_key?("dimensions")
+      dim_keys = definition["dimensions"].keys
+    else
+      raise "NetCDF definition shoud have 'dimensions' entry"
+    end
+    if definition.has_key?("variables")
+      definition["variables"].each do |name, var_def|
+        unless var_def.has_key?("type")
+          warn "NetCDF Variable '#{name}' does not have 'type' entry in definition"
+        else
+          unless ["char","byte","short","int","float","double"].include?(var_def["type"])
+            raise "invalid type of NetCDF Variable '#{name}'"
+          end          
+        end 
+        unless var_def.has_key?("dim") 
+          warn "NetCDF Variable '#{name}' does not have 'dim' entry in definition"
+        else
+          unless var_def["dim"].is_a?(Array)
+            raise "'dim' of NetCDF Variable '#{name}' should be an Array"
+          else
+            var_def["dim"].each do |dim|
+              unless dim_keys.include?(dim)
+                raise "invalid dimension '#{dim}' for NetCDF Variable '#{name}'"
+              end
+            end
+          end
+        end 
+        var_def.each do |k, v|
+          case v
+          when Hash
+            if v.size > 1 or not ["byte","short","int","float","double"].include?(v.keys[0])
+              raise "invalid specification in attribute '#{k}' for NetCDF Variable '#{name}'"
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def self.convert_attribute_value (value)
+    case value
+    when Hash
+      type, value = *value.first
+      case type
+      when "char"
+        value = CA_UINT8(value)
+      when "byte"
+        value = CA_BYTE(value)
+      when "short"
+        value = CA_SHORT(value)
+      when "int"
+        value = CA_INT(value)
+      when "float"
+        value = CA_FLOAT(value)
+      when "double"
+        value = CA_DOUBLE(value)
+      end
+    end
+    return value
+  end
+
   def define (definition)
     definition = normalize_definition(definition)
+    check_definition(definition)
     definition["dimensions"].each do |name, len|
       dim = Dim.new(self, name, len.to_i)
       @dims.push dim
       @name2dim[name] = dim
     end
     definition["variables"].each do |name, info|
-      var = Var.new(self, name, info)
+      var = Var.new(self, name, info, @compression)
       @vars.push var
       @name2var[name] = var
     end
-    @attributes = definition.dup
-    @attributes.delete("dimensions")
-    @attributes.delete("variables")
-    @attributes.each do |name, value|
-      nc_put_att(@file_id, NC_GLOBAL, name, value)
-    end
-    @attributes.freeze
-    nc_enddef(@file_id)    
-  end
-  
-  def copy_dims (nc, name = nil)
-    if name
-      if @name2dim.has_key?(name) and @name2var.has_key?(name)
-        @name2var[name].put(nc[name].get)
-      end
-    else
-      nc.dims.each do |dim|
-        if @name2dim.has_key?(dim.name) and @name2var.has_key?(dim.name)
-          @name2var[dim.name].put(nc[dim.name].get)
+    if definition.has_key?("attributes")
+      @attributes = definition["attributes"]
+      @attributes.each do |name, value|
+        value = NCFileWriter.convert_attribute_value(value)
+        begin
+          nc_put_att(@file_id, NC_GLOBAL, name, value)
+        rescue => e
+          raise(e.class, e.error_message + " {#{name}: #{value}}")
         end
       end
+      @attributes.freeze
+    else
+      @attributes = {}.freeze
     end
+    nc_enddef(@file_id)
   end
-  
+    
   def dim (name)
     return @name2dim[name]
   end
@@ -545,4 +755,36 @@ class NCFileWriter
     nc_close(@file_id)
   end
   
-end
+end
+
+class NCFileWriter
+  
+  def self.scaled_integer (type, value)
+    min, max = value.min, value.max
+    case type
+    when :short
+      short_max = (0x7fff-1).to_f
+      fillvalue = CA_SHORT(0x7fff+1)[0]
+      scale_factor = (max - min)/short_max
+      add_offset = min + short_max*scale_factor
+      packed = ((value - add_offset)/scale_factor).short
+    when :int
+      int_max = (0x7fffffff-1).to_f
+      fillvalue = CA_INT(0x7fffffff+1)[0]
+      scale_factor = (max - min)/int_max
+      add_offset = min + int_max*scale_factor
+      packed = ((value - add_offset)/scale_factor).int
+    else
+      raise
+    end
+    packed.attribute["scale_factor"] = scale_factor
+    packed.attribute["add_offset"] = add_offset
+    if value.has_mask?
+      packed[:is_masked] = fillvalue
+      packed.attribute["_FillValue"] = fillvalue
+    end
+    return packed
+  end
+  
+end
+

data/rb_netcdflib.c

@@ -559,6 +559,51 @@ rb_nc_def_var (int argc, VALUE *argv, VALUE mod)
   return LONG2NUM(varid);
 }
 
+static VALUE
+rb_nc_def_var_deflate (int argc, VALUE *argv, VALUE mod)
+{
+  int status;
+  
+  CHECK_ARGC(5);
+  CHECK_TYPE_ID(argv[0]);
+  CHECK_TYPE_ID(argv[1]);
+  CHECK_TYPE_INT(argv[2]);
+  CHECK_TYPE_INT(argv[3]);
+  CHECK_TYPE_INT(argv[4]);
+  
+  status = nc_def_var_deflate(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
+                              NUM2LONG(argv[2]), NUM2LONG(argv[3]), NUM2LONG(argv[4]));
+
+
+  CHECK_STATUS(status);
+
+  return Qnil;
+}
+
+static VALUE
+rb_nc_inq_var_deflate (int argc, VALUE *argv, VALUE mod)
+{
+  volatile VALUE retval;
+  int shuffle, deflate, deflate_level;
+  int status;
+
+  CHECK_ARGC(2);
+  CHECK_TYPE_ID(argv[0]); /* nc_id */
+  CHECK_TYPE_ID(argv[1]); /* var_id */
+
+  status = nc_inq_var_deflate(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
+                              &shuffle, &deflate, &deflate_level);
+
+  CHECK_STATUS(status);
+
+  retval = rb_ary_new();
+  rb_ary_store(retval, 0, ULONG2NUM(shuffle));
+  rb_ary_store(retval, 1, ULONG2NUM(deflate));
+  rb_ary_store(retval, 2, ULONG2NUM(deflate_level));
+
+  return retval;
+}
+
 
 static VALUE
 rb_nc_del_att (int argc, VALUE *argv, VALUE mod)
@@ -1847,6 +1892,12 @@ Init_netcdflib ()
   rb_define_singleton_method(mNetCDF,   "def_dim",  rb_nc_def_dim, -1);
   rb_define_module_function(mNetCDF, "nc_def_var",  rb_nc_def_var, -1);
   rb_define_singleton_method(mNetCDF,   "def_var",  rb_nc_def_var, -1);
+
+  rb_define_module_function(mNetCDF, "nc_def_var_deflate",  rb_nc_def_var_deflate, -1);
+  rb_define_singleton_method(mNetCDF,   "def_var_deflate",  rb_nc_def_var_deflate, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_var_deflate",  rb_nc_inq_var_deflate, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_var_deflate",  rb_nc_inq_var_deflate, -1);
+
   rb_define_module_function(mNetCDF, "nc_rename_dim",  rb_nc_rename_dim, -1);
   rb_define_singleton_method(mNetCDF,   "rename_dim",  rb_nc_rename_dim, -1);
   rb_define_module_function(mNetCDF, "nc_rename_var",  rb_nc_rename_var, -1);
@@ -1894,6 +1945,8 @@ Init_netcdflib ()
   rb_define_const(mNetCDF, "NC_LOCK",      INT2FIX(NC_LOCK));
   rb_define_const(mNetCDF, "NC_CLOBBER",   INT2FIX(NC_CLOBBER));
   rb_define_const(mNetCDF, "NC_NOCLOBBER", INT2FIX(NC_NOCLOBBER));
+  rb_define_const(mNetCDF, "NC_NETCDF4", INT2FIX(NC_NETCDF4));
+  rb_define_const(mNetCDF, "NC_CLASSIC_MODEL", INT2FIX(NC_CLASSIC_MODEL));
   rb_define_const(mNetCDF, "NC_SIZEHINT_DEFAULT", INT2FIX(NC_SIZEHINT_DEFAULT));
 
   rb_define_const(mNetCDF, "NC_GLOBAL",       INT2FIX(NC_GLOBAL));

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: carray-netcdf
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Hiroki Motoyoshi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-04 00:00:00.000000000 Z
+date: 2018-11-27 00:00:00.000000000 Z
 dependencies: []
 description: "    Extension for manipulating NetCDF3 file with CArray\n"
 email: ''
@@ -17,13 +17,12 @@ extensions:
 - extconf.rb
 extra_rdoc_files: []
 files:
-- API.html
 - API.md
 - README.md
 - carray-netcdf.gemspec
 - examples/test.nc
 - examples/test.rb
-- examples/write.rb
+- examples/time.rb
 - extconf.rb
 - lib/carray-netcdf.rb
 - lib/io/netcdf.rb
@@ -47,7 +46,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Extension for manipulating NetCDF3 file with CArray

data/API.html

@@ -1,238 +0,0 @@
-
-<html>
-  <head><title>API.md</title></head>
-  <body>
-<h1>CArray/NetCDF library API document</h1>
-
-<h2>1. Loading library</h2>
-
-<pre><code>gem install carray-netcdf
-
-require "carray-netcdf"
-</code></pre>
-
-<h2>2. Methods </h2>
-
-<p>This API provides the way of calling functions</p>
-
-<pre><code>include NC
-nc_funcname(...)
-
-NC.funcname(...)
-</code></pre>
-
-<h3>2.1. Data types</h3>
-
-<pre><code>data_type = NC.ca_type(xtype)
-xtype     = NC.nc_type(data_type)
-</code></pre>
-
-<h3>2.2. NetCDF File</h3>
-
-<pre><code>fd = nc_create(FILENAME[, mode=NC_CLOBBER])
-
-   mode : NC_CLOBBER   - permit overwrite 
-          NC_NOCLOBBER - inhibit overwrite
-          NC_SHARE     - no buffering
-
-fd = nc_open(FILENAME[, mode=NC_NOWRITE])
-
-   mode : NC_NOWRITE   - readonly
-          NC_WRTIE     - writable
-          NC_SHARE     - no buffering
-
-nc_close(fd)
-
-nc_redef(fd)
-nc_enddef(fd)
-
-nc_sync(fd)
-
-ndims    = nc_inq_ndims(fd)
-nvars    = nc_inq_nvars(fd)
-natts    = nc_inq_natts(fd)
-unlimdim = nc_inq_unlimdim(fd)
-
-oldmode  = nc_set_fill(mode)
-
-   mode : NC_FILL
-          NC_NOFILL
-</code></pre>
-
-<h3>2.3. NetCDF Dimension</h3>
-
-<pre><code>dimid    = nc_def_dim(fd, dimname, len)
-dimid    = nc_inq_dimid(fd, dimname)    =&gt; Integer | nil
-
-dimname  = nc_inq_dimname(fd, dimid)
-dimlen   = nc_inq_dimlen(fd, dimid)
-
-nc_rename_dim(fd, dimid, newname)
-</code></pre>
-
-<h3>2.4. NetCDF Variable</h3>
-
-<pre><code>varid    = nc_def_var(fd, varname, type, dim)
-varid    = nc_inq_varid(fd, varname)    =&gt; Integer | nil
-
-vartype  = nc_inq_vartype(fd, varid)
-varndims = nc_inq_varndims(fd, varid)
-vardimid = nc_inq_varndimid(fd, varid)  =&gt; Array of dimids
-
-nc_put_var1(fd, varid, [i,j,..], val)
-nc_put_var(fd, varid, ca)
-nc_put_vara(fd, varid, start, count, ca)
-nc_put_vars(fd, varid, start, count, stride, ca)
-nc_put_varm(fd, varid, start, count, stride, imap, ca)
-
-  + with data_type conversion
-
-val = nc_get_var1(fd, varid, [i,j,..])
-ca = nc_get_var(fd, varid)                              [useful]
-ca = nc_get_vara(fd, varid, start, count)               [useful]
-ca = nc_get_vars(fd, varid, start, count, stride)       [useful]
-ca = nc_get_varm(fd, varid, start, count, stride, imap) [useful]
-
-  + no data_type conversion
-
-nc_get_var(fd, varid, ca)                               [pedantic]
-nc_get_vara(fd, varid, start, count, ca)                [pedantic]
-nc_get_vars(fd, varid, start, count, stride, ca)        [pedantic]
-nc_get_varm(fd, varid, start, count, stride, imap, ca)  [pedantic]
-
-  + with data_type conversion.
-
-nc_rename_var(fd, varid, newname)
-</code></pre>
-
-<h3>2.5. NetCDF Attribute</h3>
-
-<pre><code>varnatts = nc_inq_varnatts(fd, varid)
-attid    = nc_inq_attid(fd, varid, attname)
-
-attname  = nc_inq_attname(fd, varid, attid)
-atttype  = nc_inq_atttype(fd, varid, attname)
-attlen   = nc_inq_attlen(fd, varid, attname)
-
-nc_put_att(fd, varid, attname, val)
-
-  varid : NC_GLOBAL for global att
-  val   : String  -&gt; NC_CHAR
-          Integer -&gt; NC_INT
-          Float   -&gt; NC_DOUBLE
-          CArray  -&gt; NC.nc_type(val.data_type)
-
-
-val = nc_get_att(fd, varid, attname)  =&gt; String | Numeric | CArray | nil
-
-  varid : NC_GLOBAL for global att
-
-nc_get_att(fd, varid, attname, ca)                 [pedantic]
-
-nc_rename_att(fd, varid, attname, newname)
-nc_del_att(fd, varid, attname)
-
-nc_copy_att(fd1, varid1, attname, fd2, varid2)
-</code></pre>
-
-<h3>2.6 Constants</h3>
-
-<pre><code>NC_NAT 
-NC_BYTE
-NC_SHORT
-NC_INT
-NC_FLOAT
-NC_DOUBLE
-
-NC_NOERR        - status of API routines
-
-NC_CLOBBER      - permit overwrite  [nc_create]
-NC_NOCLOBBER    - inhibit overwrite [nc_create]
-NC_NOWRITE      - readonly [nc_open]
-NC_WRITE        - writable [nc_open]
-NC_SHARE        - no buffering [nc_create, nc_open]
-
-NC_GLOBAL       - varid for global attributes
-
-NC_NOFILL       - nc_set_fill(fd, varid, NC_NOFILL)
-NC_FILL         - nc_set_fill(fd, varid, NC_FILL)
-
-NC_MAX_NAME
-NC_MAX_VAR_DIMS
-NC_MAX_DIMS
-
-NC_LOCK         - ???
-NC_SIZEHINT_DEFAULT - ???
-</code></pre>
-
-<h2>3. NCFile interface</h2>
-
-<p>NCFile interface provides the way of <em>READ-ONLY</em> access to the netcdf file.</p>
-
-<h3>3.1. NCFile</h3>
-
-<pre><code>nc = NCFile.open(FILENAME)
-
-nc = NCFile.new(file_id)
-       file_id: return value of nc_open in read-only mode
-</code></pre>
-
-<h3>3.2. Dimensions</h3>
-
-<pre><code>nc.has_dim?(DIMNAME)
-nc.dims               - Array of dimension
-
-dim = nc.dim(DIMNAME) - NCDim object or nil
-dim.to_i              - size of dimension
-dim.to_ca             
-</code></pre>
-
-<h3>3.3. Variables</h3>
-
-<pre><code>nc.has_var?(VARNAME)
-nc.vars               - Array of variables
-
-var = nc[VARNAME]     - NCVar object or nil
-var.is_dim?           - true if dimension variable
-var.to_ca             - get array as CArray object
-var[...]              - Cooked value array with CArray-like indexing
-var.get!(...)         - same as [...]
-var.get(...)          - Non-cooked value array with CArray-like indexing
-
-var.get_var1(...)     - interface to original get function 
-var.get_var()
-var.get_vara(start, count)
-var.get_vars(start, count, stride)
-var.get_varm(start, count, stride, imap)
-var.get_var1!(...)
-var.get_var!()
-var.get_vara!(start, count)
-var.get_vars!(start, count, stride)
-var.get_varm!(start, count, stride, imap)
-</code></pre>
-
-<h3>3.4. Attributes</h3>
-
-<p>All attributes are already read in initializing process of NCFile object.</p>
-
-<pre><code>nc.attributes           - Hash
-dim.attributes          
-var.attributes          
-
-nc.attribute(ATTNAME)   - accessor
-dim.attribute(ATTNAME)
-var.attribute(ATTNAME)
-</code></pre>
-
-<h3>3.5. Iteration</h3>
-
-<p>No iteration methods is provided, but accessor methods for dims, vars, attributes can be used.</p>
-
-<pre><code>ex)
-
-  nc.attributes.each {|key, value| ... }
-  nc.dims.each {|dim| ... }
-  nc.vars.each {|var| ... }
-</code></pre>
-  </body>
-</html>

data/examples/write.rb

@@ -1,47 +0,0 @@
-require "pp"
-require "carray-netcdf"
-include NC
-
-=begin
-definition = {
-  dims: {
-    time: 24
-  },
-  vars: {
-    time: {
-      dims: ["time"],
-      long_name: "time from 00UT"
-    },
-    temp: {
-      dims: ["time"],
-    }
-  }
-}
-=end
-
-require "yaml"
-
-definition = YAML.load %{
-dimensions:
-  time: 24
-variables:
-  time:
-    dim: ["time"]
-    long_name: "time from 00UT"
-  temp:
-    type: #{NC_DOUBLE}
-    dim: ["time"]
-creator: "foobar"
-}
-
-pp definition
-
-out = NCFileWriter.new("test.nc")
-out.define definition
-out["time"] = CArray.int(24).seq
-out["temp"] = CArray.float(24).random
-out.close
-
-nc = NCFile.open("test.nc")
-
-pp nc.definition