netcdf 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81d6a201281ded6b844b92d6d66413b81aa9c89c3b2faff4c76d783fdefea7d3
-  data.tar.gz: bbe34f91b073bfb82daa5825dd1826c19b6d02cfce585e8df919170207749ea6
+  metadata.gz: ede50e0a5d1f1fca85a4210bc6012277979828fbe02a3a47803d3189568bc7c5
+  data.tar.gz: d6041661c7e95d520d816ebe2f4384095502d96600b174a35ddef06e20fee968
 SHA512:
-  metadata.gz: 3fdb1a510287e5f1b886ae66cadf6864a5efaa896452f4f9aa158bb88ccef40b6fef6a0c8dff536cef464b6db7360bc800b64a7656d6c53f8d47223c0ffccee1
-  data.tar.gz: 3dd9e164eefbec8f3868deac541ace703b831fa67bd390319be2073af12bf31937622ef24342fc5344a302e2df7607f5978597e393363a9d45347eb500f51c85
+  metadata.gz: d0819e52979e171112c2eaddb0cee8354155c14dd6131355f2a1ab1202918e3d056e2aab38ef24e8f9013046c5fe9ea387e80e0558f5c3e9b312652f4da87fbb
+  data.tar.gz: 9d2d0520db997082134630cbe1a94b8e7b09e026dad206668f2455d77735b14abd486d6c9113abbd591d7b61784c521a99518c8f3e4bc7588d963095f25f84a7

data/CHANGELOG.md

@@ -29,6 +29,45 @@ version you have and a newer one.
      libnetcdf a release needs is said in extconf.rb, and an entry says
      so only when the answer changes. -->
 
+## 0.2.0
+
+- New: the `NC_64BIT_DATA` creation flag, and its alias `NC_CDF5`, for
+  `nc_create` to write a CDF-5 file. Defined only when libnetcdf has
+  them (4.4 or later); `NC_FORMAT_64BIT_DATA` was already there.
+
+- New: calls for the compression filters szip, zstandard, bzip2 and
+  blosc: `nc_def_var_szip` / `nc_inq_var_szip`, and the same pair for
+  `zstandard`, `bzip2` and `blosc` (libnetcdf 4.9 or later). New constants
+  give the filter ids (`H5Z_FILTER_*`) and the szip and blosc options.
+  When libnetcdf has no such filter, the def calls raise
+  `NetCDF::Error` (`NC_ENOFILTER`) instead of writing uncompressed data.
+  For szip this check needs libnetcdf 4.7 or later.
+
+- New: `NetCDF.nc_copy_var(src_ncid, varid, dst_ncid)` copies one variable
+  -- its definition, attributes and data -- to another file. The
+  destination needs dimensions with the same names.
+
+- New: `NetCDF.nc_set_default_format(format)` sets the format that
+  `nc_create` uses when the mode names none, and returns the old one.
+  The setting is for the whole process, not for one file.
+
+- New: `NetCDF.nc_inq_type_equal(ncid1, typeid1, ncid2, typeid2)` returns
+  `true` if the two types are the same, also when they are in different
+  files or groups. A user-defined type can be compared only after
+  `nc_enddef`; in define mode the call raises `NetCDF::Error`.
+
+- New: `NetCDF.nc_inq_unlimdims(ncid)` returns the ids of all unlimited
+  dimensions as an Array, or `[]` if there are none. A NetCDF-4 file can
+  have more than one unlimited dimension; `nc_inq_unlimdim` still returns
+  only one of them.
+
+- Fix: an attribute of enum type, such as the `_FillValue` netCDF4-python
+  writes for an enum variable, is read as Integers of the enum's base
+  type by `nc_get_att` and by the base type's typed getter, instead of
+  raising `NotImplementedError`. `nc_def_var_fill` and `nc_inq_var_fill`
+  accept an enum variable in the same way. Writing an enum attribute
+  other than `_FillValue` is still not supported.
+
 ## 0.1.0
 
 First release.

data/README.md

@@ -1,20 +1,25 @@
 # netcdf
 
-A Ruby binding to the [NetCDF](https://www.unidata.ucar.edu/software/netcdf/) C library that passes data through Ruby's MemoryView protocol.  An array library's own memory is handed to libnetcdf, which reads or writes it where it lies: nothing is copied, and no Ruby Array stands in between.
+A Ruby binding to the [NetCDF](https://www.unidata.ucar.edu/software/netcdf/) C library that passes data through Ruby's MemoryView protocol.
 
-The binding is nearly one to one, for code that wants to be written the way NetCDF itself is written; [Unidata's C documentation](https://docs.unidata.ucar.edu/netcdf-c/current/) reads as documentation for it.
+The binding is nearly one to one, each C function corresponding to a Ruby method of the same name, so [Unidata's C documentation](https://docs.unidata.ucar.edu/netcdf-c/current/) reads as documentation for it.
 
 ## Features
 
-* Programs are written the way NetCDF's own are: every `nc_*` function under its own name, taking its arguments in its own order, so a call in a C example is written here as it stands
-* Any MemoryView producer is a buffer, with no adapter written for it, and libnetcdf reads or writes its memory where it lies
-* Array I/O releases the GVL, so other threads keep running through a long read or write; netCDF calls themselves are serialized, since libnetcdf is not thread-safe
-
-What libnetcdf offers is bound and covered by the test suite, apart from a handful of features listed at the end of the [reference](docs/03_reference.md#not-yet-implemented).
+* Provides the same `nc_*` functions as the NetCDF C library, with their arguments in the same order as the originals
+* Variable data is read and written with any buffer object that supports MemoryView
+* Ruby's GVL (Global VM Lock) is released while variable data is read or written
+* NetCDF calls from different threads run one at a time (libnetcdf is not thread-safe)
 
 ## Install
 
-Install libnetcdf and its headers first, then the gem:
+Requires:
+
+- Ruby >= 3.1
+- libnetcdf >= 4.1, with its headers (`nc-config` or `pkg-config` on PATH)
+- A C compiler
+
+With those in place, install the gem:
 
 ```
 gem install netcdf
@@ -26,19 +31,13 @@ Or add it to your `Gemfile`:
 gem "netcdf"
 ```
 
-Requires:
-
-- Ruby >= 3.1
-- libnetcdf >= 4.1, with its headers (`nc-config` or `pkg-config` on PATH)
-- A C compiler
-
 ## Example
 
-Arrays are passed to and from this gem through [MemoryView](https://github.com/ruby/ruby/blob/master/include/ruby/memory_view.h), the protocol Ruby 3.0 added for sharing an array's memory between libraries.  An array library that implements it works here as it is, with no adapter written on either side; the gem itself depends on no array library.  The example below takes [CArray](https://github.com/himotoyoshi/carray) as one such library: it writes a 3 × 4 variable with two attributes, and reads it back.
+Variable data is read and written through the [MemoryView](https://github.com/ruby/ruby/blob/master/include/ruby/memory_view.h) protocol, so any buffer object that supports MemoryView can be the other end of the binary I/O.  The example below uses [CArray](https://github.com/himotoyoshi/carray) to show a NetCDF variable being written and read back.
 
 ```ruby
 require "netcdf"
-require "carray"   # a MemoryView producer/consumer
+require "carray"                                    # an array library that supports MemoryView
 
 ncid = NetCDF.nc_create("out.nc", NetCDF::NC_CLOBBER | NetCDF::NC_NETCDF4)
 
@@ -60,18 +59,16 @@ NetCDF.nc_get_vara(ncid, v, [0, 0], [3, 4], dst)
 NetCDF.nc_close(ncid)
 ```
 
-libnetcdf reads and writes the array's own memory, with nothing copied in between.
-
 ## Documentation
 
-* [Introduction](docs/00_introduction.md) — what this gem is, what it leaves to a layer above, and what is not implemented
+* [Introduction](docs/00_introduction.md) — what the netcdf gem is, what it leaves to libraries built on it, and what is not implemented
 * [Getting started](docs/01_getting_started.md) — install, the shape of the API, writing and reading your first file
 * [Buffers and MemoryView](docs/02_buffers.md) — how data actually moves: what a buffer must satisfy, format strings, and handing an array library's memory straight over
-* [Reference](docs/03_reference.md) — every function, grouped by subsystem, plus every constant
+* [Reference](docs/03_reference.md) — every function, grouped by subsystem, and every constant
 
 ## Contributing
 
-Bug reports, feature requests and pull requests are welcome.
+Bug reports, feature requests and pull requests are welcome on [GitHub](https://github.com/himotoyoshi/netcdf/issues).
 
 ## Credits
 
@@ -79,4 +76,4 @@ netcdf was designed and reviewed by a human developer; the implementation was pr
 
 ## License
 
-MIT
+[MIT](LICENSE)

data/docs/00_introduction.md

@@ -1,28 +1,28 @@
 # Introduction
 
-netcdf is a Ruby binding to the [NetCDF](https://www.unidata.ucar.edu/software/netcdf/) C library.  It takes NetCDF itself as known: what this guide has to explain is the Ruby side of the boundary — how a `nc_*` function reads as a Ruby call, what it returns, what it raises, and how bulk data crosses without being copied.
+The netcdf gem is a Ruby binding to the [NetCDF](https://www.unidata.ucar.edu/software/netcdf/) C library.  This guide covers the Ruby side of the boundary: how a `nc_*` function reads as a Ruby call, what it returns, what it raises, and how variable data crosses without being copied.
 
 ## A literal translation of libnetcdf
 
-The gem translates libnetcdf into Ruby word for word.  Each `nc_*` function is a `NetCDF.nc_*` method with the same name, the same arguments in the same order, and the same meaning.  Only the grammar changes: what C returns through a pointer argument comes back as a Ruby value, and what C reports as a non-zero status is raised.  The vocabulary does not — nothing is grouped, renamed, or given a friendlier spelling — so a call you read in C documentation, in an example, or in someone's Fortran-shaped code is written here as it stands.  The few places where a Ruby call does more than its C counterpart — `nc_put_att` taking the type from the value, an `NC_STRING` read returning Ruby Strings — are marked in the [reference](03_reference.md) where they occur.
+The gem translates libnetcdf into Ruby word for word.  Each `nc_*` function in the NetCDF C library is a `NetCDF.nc_*` method with the same name and the same arguments in the same order.  Only the grammar changes: what C returns through a pointer argument comes back as a Ruby value, and what C reports as a non-zero status is raised as a `NetCDF::Error`.  The vocabulary does not, so a call you read in C documentation or in an example is written here as it stands.  The few places where a Ruby call differs from its C counterpart — `nc_put_att` taking the type from the value, an `NC_STRING` read returning Ruby Strings, a lookup that finds nothing returning `nil` — are marked in the [reference](03_reference.md) where they occur.
 
 Translating rather than redesigning settles three things:
 
-- **Ids stay the integers libnetcdf uses.**  `ncid`, `dimid`, `varid` and `grpid` are passed to you and back unchanged, so a file's identity is the same value on both sides of the boundary and yours to keep wherever you like.
-- **Data stays where your array library holds it.**  A buffer here is a block of memory the library reads or writes in place; element access, arithmetic, slicing and type coercion stay with the array class that owns the data.
-- **Attributes are stored and returned verbatim.**  `_FillValue`, `scale_factor`, `add_offset` and CF time come back exactly as they were written — a convention is yours to apply, at the point where you know which one the file follows.
+- **Ids stay the integers libnetcdf uses.**  `ncid`, `dimid`, `varid` and `grpid` are plain Integers, passed to you and back unchanged, with no Ruby object wrapped around them.
+- **Data stays where your array library holds it.**  libnetcdf reads or writes its memory in place; element access, arithmetic, slicing and type coercion stay with the array class that owns the data.
+- **Attributes are stored and returned verbatim.**  `_FillValue`, `scale_factor`, `add_offset` and CF time come back exactly as they were written — a convention is yours to apply.
 
-A translation this close can be checked against the C API function by function, and it never stands between you and a feature it was not designed for.  The conveniences — an object-oriented surface, masks, CF/COARDS decoding — belong to a layer written above this one.
+A translation this close can be checked against the C API function by function.  The conveniences — an object-oriented API, masks, CF/COARDS decoding — belong in a separate library built on this gem.
 
-The practical consequence is that [Unidata's C documentation](https://docs.unidata.ucar.edu/netcdf-c/current/) is documentation for this gem.  When you want to know what `nc_def_var_chunking` does to a file, that is where the answer is; what this guide covers is what the Ruby call returns, what it raises, and how the buffer works.
+The practical consequence is that [Unidata's C documentation](https://docs.unidata.ucar.edu/netcdf-c/current/) is documentation for this gem.  When you want to know what `nc_def_var_chunking` does to a file, that is where the answer is.
 
 ## Passing data through the MemoryView protocol
 
-Metadata crosses as ordinary Ruby values: names are Strings, ids and lengths are Integers, an attribute goes in as a Ruby value and comes back as one.  Bulk numeric data does not — it is handed over through Ruby's MemoryView protocol, which is what lets a whole array cross the boundary as memory rather than as a converted Ruby object.
+Metadata crosses as ordinary Ruby values: names are Strings, ids and lengths are Integers, an attribute goes in as a Ruby value and comes back as one.  Variable data does not — it is handed over through the MemoryView protocol, which is what lets a whole array cross the boundary as memory rather than as a converted Ruby object.
 
-A buffer, in this gem, is any object that exposes MemoryView: the gem asks it for the pointer, checks that the memory is row-major contiguous and that its format agrees with the variable, and lets libnetcdf read or write it where it lies.  The gem copies nothing in either direction — what libnetcdf does with the bytes after that, type conversion included, is libnetcdf's business — and the call runs with the GVL released.  An array class that exposes the protocol is therefore usable as a buffer with no adapter written for it.
+A buffer, in this gem, is any object that supports MemoryView: the gem asks it for the pointer, checks that the memory is row-major contiguous and that its format is one the gem can read, and lets libnetcdf read or write it where it lies.  The gem copies nothing in either direction — what libnetcdf does with the bytes after that, type conversion included, is libnetcdf's business.
 
-The gem allocates no buffers of its own: a `get` reads into memory you hand it, as a `put` writes from it.  The gem depends on no array library; this guide's examples take CArray as one that implements MemoryView.
+The gem allocates no buffers of its own: a `get` reads into memory you hand it, as a `put` writes from it.  The gem depends on no array library; this guide's examples take [CArray](https://github.com/himotoyoshi/carray) as one that supports MemoryView.  What a buffer must satisfy is in [Buffers and MemoryView](02_buffers.md).
 
 ## What is not implemented
 

data/docs/01_getting_started.md

@@ -1,6 +1,6 @@
 # Getting started
 
-This page goes from an empty directory to a NetCDF file written and read back.  NetCDF itself is taken as known; what is shown is how a `nc_*` call is written in Ruby, and which of its edges are Ruby's rather than C's.
+This page goes from an empty directory to a NetCDF file written and read back, showing how a `nc_*` call is written in Ruby and where it differs from C.
 
 ## Install
 
@@ -17,7 +17,7 @@ require "netcdf"
 NetCDF.nc_inq_libvers      # => "4.9.2 of Mar 15 2024 ..."
 ```
 
-The examples below use [CArray](https://github.com/himotoyoshi/carray), a multi-dimensional array library that can be both a producer and a consumer of MemoryView:
+The examples below use [CArray](https://github.com/himotoyoshi/carray), a multi-dimensional array library that supports MemoryView, so its arrays can be both written from and read into:
 
 ```
 gem install carray
@@ -25,30 +25,27 @@ gem install carray
 
 ## What is Ruby rather than C
 
-`NetCDF.nc_open`, `NetCDF.nc_def_var`, `NetCDF.nc_put_vara`: the names and the argument order are the ones you already know.  Four things are spelled Ruby's way instead of C's.
+`NetCDF.nc_open`, `NetCDF.nc_def_var`, `NetCDF.nc_put_vara`: the names and the argument order are those of the C library.  Three things differ from C:
 
 - **Status codes are exceptions.**  A call that fails raises `NetCDF::Error`; there is no return value to check.
 - **Output parameters are return values.**  `nc_inq_var` hands back its five values as an Array instead of filling five pointers.
-- **A lookup that finds nothing returns `nil`.**  `nc_inq_varid` on a name that is not in the file, for one — absence is not an error.
-- **Bulk data moves through MemoryView.**  A buffer is memory libnetcdf reads or writes where it lies, so an array library's own storage is handed over as it stands.
+- **A lookup that finds nothing returns `nil`.**  `nc_inq_varid` on a name that is not in the file returns `nil` rather than raising.
 
 ## Define mode and data mode
 
-`nc_enddef` and `nc_redef` are here as they are in C, and the gem does nothing to hide the two phases — but how strictly they are enforced depends on the format, which is worth seeing before the first example.  A classic (NetCDF-3) file refuses a write before `nc_enddef`:
+`nc_enddef` and `nc_redef` are here as they are in C, and the gem does nothing to hide the two phases — but how strictly they are enforced depends on the file format.  A classic (NetCDF-3) file refuses a write before `nc_enddef`:
 
 ```
 NetCDF::Error: NetCDF: Operation not allowed in define mode   # status -39
 ```
 
-A NetCDF-4 file does not — libnetcdf switches modes for you there, and the write goes through.  Call `nc_enddef` anyway, at the point where the schema is complete: it is what makes the same code work against both formats, and it marks the boundary for a reader.
-
-Opening an existing file skips all of this — the file is already in data mode.
+A NetCDF-4 file does not — libnetcdf switches modes for you there, and the write goes through.  Call `nc_enddef` anyway, at the point where the schema is complete: it is what makes the same code work against both file formats.
 
 ## Writing a file
 
 ```ruby
 require "netcdf"
-require "carray"   # a MemoryView producer/consumer
+require "carray"   # an array library that supports MemoryView
 
 ncid = NetCDF.nc_create("temp.nc", NetCDF::NC_CLOBBER | NetCDF::NC_NETCDF4)
 
@@ -65,7 +62,7 @@ NetCDF.nc_put_att(ncid, NetCDF::NC_GLOBAL, "title", "example field")
 NetCDF.nc_enddef(ncid)
 
 # --- data mode ---
-values = CArray.double(3, 4).seq(271.0)
+values = CArray.double(3, 4).seq(271.0)          # 271.0, 272.0, ..., 282.0
 NetCDF.nc_put_var(ncid, v, values)
 
 NetCDF.nc_close(ncid)
@@ -75,14 +72,14 @@ Four things in there are worth naming:
 
 - Creation flags are OR-ed together as in C: `NC_CLOBBER | NC_NETCDF4` here.  A constant is `NetCDF::NC_*`, and every one libnetcdf defines is in the [reference](03_reference.md).
 - Dimension ids come back from `nc_def_dim` and go into `nc_def_var` as an Array, in the order the variable is indexed.
-- `nc_put_att` picks the on-disk type from the Ruby value — `String` becomes `NC_CHAR`, `Float` becomes `NC_DOUBLE`, an Array of Floats becomes an `NC_DOUBLE` vector.  When you need to pin the type down, the typed calls (`nc_put_att_float` and friends) are in the [reference](03_reference.md#typed-putget).
-- The data goes in as a `CArray`, not a Ruby Array: libnetcdf reads the array's own memory.  Any other MemoryView producer would do; that is the subject of the [next page](02_buffers.md).
+- `nc_put_att` picks the on-disk type from the Ruby value — `String` becomes `NC_CHAR`, `Integer` becomes `NC_INT`, `Float` becomes `NC_DOUBLE`, an Array of Floats becomes an `NC_DOUBLE` vector.  When you need to pin the type down, the typed calls (`nc_put_att_float` and friends) are in the [reference](03_reference.md#typed-putget).
+- The data goes in as a `CArray`; a Ruby Array is not a buffer and raises `TypeError`.  Any other object that supports MemoryView would do; that is the subject of the [next page](02_buffers.md).
 
 ## Reading it back
 
 ```ruby
 require "netcdf"
-require "carray"   # a MemoryView producer/consumer
+require "carray"   # an array library that supports MemoryView
 
 ncid = NetCDF.nc_open("temp.nc", NetCDF::NC_NOWRITE)
 
@@ -95,29 +92,34 @@ NetCDF.nc_get_att(ncid, varid, "units") # => "K"
 
 buf = CArray.double(*shape)
 NetCDF.nc_get_var(ncid, varid, buf)     # => buf, filled
-buf[0, nil].to_a                        # => [271.0, 272.0, 273.0, 274.0]
+buf[0, nil].to_a                        # => [271.0, 272.0, 273.0, 274.0]  (row 0, every x)
 
 NetCDF.nc_close(ncid)
 ```
 
-A `get` reads into the buffer you pass, as a `put` writes from it, and returns that buffer.  The gem allocates none of its own: the shape comes from the dimensions, and the element type is yours to choose — libnetcdf converts from the variable's type to it.  The one exception is an `NC_STRING` variable, which comes back as Ruby Strings and takes no buffer.
+`nc_get_var` returns the buffer it filled.  The shape comes from the dimensions, and the element type is yours to choose — libnetcdf converts from the variable's type to it.  The one case that differs is an `NC_STRING` variable, which comes back as Ruby Strings and takes no buffer.
 
 ## Reading part of a variable
 
-`nc_get_vara` takes a corner and a shape as Ruby Arrays, zero-based as in C:
+`nc_get_vara` takes `start` and `count` as Ruby Arrays, zero-based as in C:
 
 ```ruby
+ncid = NetCDF.nc_open("temp.nc", NetCDF::NC_NOWRITE)
+varid = NetCDF.nc_inq_varid(ncid, "temperature")
+
 rows = CArray.double(2, 4)
 NetCDF.nc_get_vara(ncid, varid, [1, 0], [2, 4], rows)   # last two rows
+
+NetCDF.nc_close(ncid)
 ```
 
-`nc_get_vars` adds a stride, and `nc_get_varm` a mapping vector for transposing on the way out.  Each has a `put` twin taking the same arguments plus the buffer.
+`nc_get_vars` adds a stride, and `nc_get_varm` a mapping vector for transposing on the way out.  Each has a `put` twin taking the same arguments.
 
 ## When something fails
 
 ```ruby
 begin
-  NetCDF.nc_open("missing.nc")
+  NetCDF.nc_open("missing.nc", NetCDF::NC_NOWRITE)
 rescue NetCDF::Error => e
   e.message      # => "No such file or directory" — libnetcdf's own text
   e.status       # => 2   the raw libnetcdf status
@@ -125,3 +127,5 @@ end
 ```
 
 `#status` is what to match on when you care about a specific failure rather than any failure.  NetCDF's own conditions are negative (`-39` is "operation not allowed in define mode"); a positive status is an errno the C library passed through, as above.
+
+Next, [Buffers and MemoryView](02_buffers.md) covers what a buffer must satisfy, and the [reference](03_reference.md) lists every function and constant.

data/docs/02_buffers.md

@@ -1,27 +1,27 @@
 # Buffers and MemoryView
 
-Every numeric value this gem reads or writes passes through a buffer, and a buffer is any object implementing Ruby's MemoryView protocol.  That is the whole interop story: an array library that exposes MemoryView hands libnetcdf its own memory, and the gem copies nothing on the way in or out.
+Variable data passes through a buffer, and a buffer is any object that supports the MemoryView protocol.  The gem passes the buffer's memory straight to libnetcdf, which reads or writes it in place; nothing is copied on the way in or out.
 
-This page is that surface: what a buffer has to satisfy, what to pass when you have no array library, how a format string is read, and where an array library fits.
+This page covers what a buffer has to satisfy, what to pass when you have no array library, how a format string is read, and where an array library fits.
 
-The gem allocates no buffers itself.  A `get` reads into the buffer you pass and returns it, just as a `put` writes from one; leaving the buffer off raises `ArgumentError: buffer is required`.  `NC_STRING` variables are the exception (see [the end of this page](#types-that-are-not-buffers)).
+Leaving the buffer off raises `ArgumentError: buffer is required`, except for `NC_STRING` variables, which take none (see [below](#types-that-are-not-buffers)).
 
 ## A buffer is a block of memory
 
-Not a collection.  A Ruby `Array` of Floats is a list of boxed objects; there is nothing in it to hand to a C function that wants twelve contiguous 8-byte values, and packing one is a copy plus a per-element conversion — work that belongs to whatever owns the data, not to this boundary.
+A Ruby `Array` of Floats is a list of Ruby objects, not a block of memory, so it is not a buffer.  Put the values in an array library's array, or pack them into a `Fiddle::Pointer` ([below](#without-an-array-library)).
 
-A `String` *is* a block of bytes, but it carries no shape, no element type, and no writability guarantee, so the array I/O surface does not take one.  Hand the bytes over through a producer instead — an array library's array, or a `Fiddle::Pointer` ([below](#without-an-array-library)).
+A `String` is a block of bytes, but it does not support MemoryView, so it is not a buffer either; copy the bytes into a `Fiddle::Pointer` instead.
 
-Strings do appear elsewhere — `NC_CHAR` and `NC_STRING` values, opaque scalars, attribute text — because there the data really is text or an opaque blob.  It is only the numeric array surface that refuses them.
+Strings are taken elsewhere — attribute text, `NC_STRING` values, and a single `NC_CHAR` or opaque element through `nc_put_var1` — because there the data really is text or an opaque blob.  Only array I/O refuses them.
 
 ## What a buffer has to satisfy
 
-- **A MemoryView producer.**  Anything else raises `TypeError: buffer must provide a MemoryView`.  Note that a library's view objects are often not producers even when its arrays are — a `CArray` is one, `CArray#transpose` is not.
-- **Row-major (C-contiguous).**  libnetcdf reads and writes a flat run of elements, so a strided or column-major view has no meaning at this boundary.  A producer that hands over a strided view — including a 1-D one that gives strides without a shape — is refused with `ArgumentError: buffer must be row-major (C-contiguous)` rather than read wrongly.  Make a contiguous copy first — `CArray#copy`, for a CArray view.
-- **Large enough.**  The element count implied by `count` (or by the whole variable) must fit, or `ArgumentError: buffer too small` says how many bytes were expected.
-- **Writable, on a `get`.**  A producer that refuses a writable view raises `TypeError: buffer must provide a writable MemoryView`.  One that hands back a view marked read-only anyway — `rb_memory_view_get` does not hold a producer to the request — raises `TypeError: buffer is read-only`, rather than being written into.  `Fiddle::Pointer` is one up to fiddle 1.1.8: it marks every view read-only, so it serves as the source of a `put` but not as the destination of a `get`.  fiddle 1.1.9 hands out a writable view when asked.
+- **Supports MemoryView.**  Anything else raises `TypeError: buffer must provide a MemoryView`.  A library's derived arrays may not support it even when its plain arrays do: a `CArray` does, but the array `CArray#transpose` returns does not — pass its `#copy`.
+- **Row-major (C-contiguous).**  libnetcdf reads and writes a flat run of elements, so strided or column-major memory is refused with `ArgumentError: buffer must be row-major (C-contiguous)` rather than read wrongly.  Make a contiguous copy first (`CArray#copy`, for a CArray).
+- **Large enough.**  The element count implied by `count` (or by the whole variable) must fit, or `ArgumentError: buffer too small` says how many bytes were expected.  Only the size is checked, not the shape: a 4 × 3 buffer serves a 3 × 4 read.
+- **Writable, on a `get`.**  A buffer that cannot be written raises `TypeError` (`buffer must provide a writable MemoryView`, or `buffer is read-only`).  `Fiddle::Pointer` is read-only, so it serves as the source of a `put` but not as the destination of a `get`.
 
-The element *type* need not match the variable's: libnetcdf converts.  Writing a `"f"` buffer into an `NC_DOUBLE` variable widens on the way in, and reading that variable into a `"f"` buffer narrows on the way out.  What the buffer's format decides is how libnetcdf interprets your memory, not what ends up on disk.
+The element *type* need not match the variable's: libnetcdf converts.  Writing a float (`"f"`) buffer into an `NC_DOUBLE` variable widens on the way in, and reading that variable into a `"f"` buffer narrows on the way out.  What the buffer's format decides is how libnetcdf interprets your memory, not what ends up on disk.  A value that does not fit the type it is converted to raises `NetCDF::Error: NetCDF: Numeric conversion not representable`.
 
 ## Without an array library
 
@@ -35,11 +35,11 @@ src[0, 12 * 8] = (1..12).map(&:to_f).pack("d*")
 NetCDF.nc_put_vara(ncid, varid, [0, 0], [3, 4], src)
 ```
 
-It serves as the source of a `put`.  It can be read into only from fiddle 1.1.9 on (see [what a buffer has to satisfy](#what-a-buffer-has-to-satisfy)); `#to_str(nbytes)` then copies the bytes out.
+Nothing checks that the bytes are of the variable's type, so pack them as that type: doubles written into an `NC_FLOAT` variable are stored wrong, with no error.  It serves as the source of a `put`; it cannot be read into (see [what a buffer has to satisfy](#what-a-buffer-has-to-satisfy)).
 
 ## Format strings
 
-A buffer describes its element type with a MemoryView `format` string.  The vocabulary is the one `ruby/memory_view.h` specifies — pack-template specifiers — and this gem expects it:
+A buffer describes its element type with a MemoryView `format` string.  The vocabulary is the one `ruby/memory_view.h` specifies — pack-template specifiers:
 
 | format | NetCDF type |
 |--------|-------------|
@@ -50,23 +50,23 @@ A buffer describes its element type with a MemoryView `format` string.  The voca
 | `f` | `NC_FLOAT` |
 | `d` | `NC_DOUBLE` |
 
-`l` / `L` are read as the 32-bit integers they are in that vocabulary, and `e` / `E` / `g` / `G` as the floats that carry their own byte order (below).  PEP 3118's `b` / `B` and `h` / `H` are accepted too, for producers that spell the 1- and 2-byte integers PEP's way.
+`l` / `L` are read as the 32-bit integers they are in that vocabulary, and `e` / `E` / `g` / `G` as the floats that carry their own byte order (below).  The `b` / `B` and `h` / `H` of PEP 3118 (Python's buffer format) are accepted too, for buffers that spell the 1- and 2-byte integers that way.
 
-A format that disagrees with the buffer's own `item_size` — numpy's 64-bit `l` arriving untranslated, say — raises `ArgumentError` rather than being misread.
+A format that disagrees with the buffer's element size — Python's 64-bit `l`, say — raises `ArgumentError` rather than being misread.
 
-A format may name a byte order.  Ruby spells it as a suffix on an integer (`q<`, `s>`) and as a letter of its own on a float (`e` / `E` little-endian single / double, `g` / `G` big-endian); a suffix on a float (`d<`) is not Ruby's and is refused as unsupported.  PEP 3118 spells it as a prefix on the whole string (`<d`, plus the order-neutral `=` `@` `|` `^`).  All of these are read.  One naming the *foreign* order raises `ArgumentError: buffer format "..." is not native-endian` — libnetcdf transfers the buffer as native memory, so byte-swapping is the producer's job.
+A format may name a byte order, in Ruby's spelling (`q<`, `s>`, and `e` / `E` / `g` / `G` for floats) or PEP 3118's (`<d`).  Native order is accepted; the foreign order raises `ArgumentError: buffer format "..." is not native-endian`, so swap the bytes before passing them.
 
-Only a single numeric element is accepted.  Repeat counts, records (`T{...}`), and mixed formats (`dd`) have no netCDF counterpart and are rejected.
+Only a single numeric element is accepted.  Repeat counts, records (`T{...}`), and mixed formats (`dd`) have no NetCDF counterpart and raise `ArgumentError: unsupported buffer format`.
 
-A buffer with no format at all is passed through as raw bytes of the variable's own type.  So is any buffer for an opaque variable, whose element size netCDF already knows and whose data has no element type for a format to name — see [opaque I/O](03_reference.md#opaque-fixed-size-raw-bytes).  An enum variable moves its base type whatever the buffer holds, so a formatted buffer for one must name that base type; another raises `ArgumentError` rather than being reinterpreted.  An `NC_CHAR` buffer moves bytes, so its format, when it has one, must name a 1-byte element.
+A buffer with no format at all is passed through as raw bytes of the variable's own type.  So is any buffer for an opaque variable, whose element size NetCDF already knows and whose data has no element type for a format to name — see [opaque I/O](03_reference.md#opaque-fixed-size-raw-bytes).  An enum variable is read and written as its base type whatever the buffer holds, so a formatted buffer for one must name that base type; another raises `ArgumentError` rather than being reinterpreted.  An `NC_CHAR` buffer holds bytes, so its format, when it has one, must name a 1-byte element.
 
 ## Array libraries
 
-An array class that exposes MemoryView natively is a buffer here with no adapter written for it and nothing copied on the way through.  Pass the array where a buffer goes; the example takes CArray as one such class:
+An array class that supports MemoryView is a buffer here.  Pass the array where a buffer goes; the example takes CArray as one such class:
 
 ```ruby
 require "netcdf"
-require "carray"   # a MemoryView producer/consumer
+require "carray"   # an array library that supports MemoryView
 
 src = CArray.double(3, 4).seq(1.0)
 NetCDF.nc_put_vara(ncid, varid, [0, 0], [3, 4], src)
@@ -75,9 +75,7 @@ dst = CArray.double(3, 4)
 NetCDF.nc_get_vara(ncid, varid, [0, 0], [3, 4], dst)     # filled in place
 ```
 
-An array class that does not expose it has its data copied into one that does, once in each direction.
-
-The gem's own code names no library: which of the two paths yours takes is decided by the protocol alone, and it moves to the first the moment it grows a MemoryView entry.
+An array class that does not support it cannot be passed: copy its data into one that does before a `put`, and out of it after a `get`.
 
 ## Types that are not buffers
 
@@ -86,10 +84,10 @@ Two of NetCDF's types do not fit into a single block of memory, and the gem hand
 - **`NC_STRING`** — each element is a separately allocated C string, so a `get` takes no buffer and returns a `String` or a nested `Array<String>`, and a `put` accepts the same.  See [NC_STRING variables](03_reference.md#nc_string-variables).
 - **Vlen** — a variable-length sequence per element.  Type definition works; data I/O is not wired through yet.
 
-## The GVL
+## Threads and the GVL
 
-Array I/O releases the GVL around the libnetcdf call, so a large read or write does not block other Ruby threads.  The buffer must not be touched from another thread while the call is in flight — the gem holds a raw pointer into it for the duration.
+Ruby's GVL (Global VM Lock) lets only one thread run Ruby code at a time, and a C call that holds it on the way through stops every other thread until it returns.  Array I/O releases the GVL around the libnetcdf call, so while a large read or write waits on the disk or decompresses chunks, other Ruby threads keep running — one serving requests, one reporting progress, one working on data already read.  The buffer must not be touched from another thread while the call is in flight — the gem holds a raw pointer into it for the duration.
 
-libnetcdf, and the HDF5 under it, are not thread-safe: two threads inside them at once corrupt process-wide state, even when they work on different files.  So every `NetCDF` call — array I/O, and inquiry, definition, open and close alike — takes one process-wide lock.  A thread that calls into NetCDF while another is in the middle of a read waits for it, with the GVL released; threads doing anything else keep running.  Threads therefore do not speed up netCDF I/O itself, only the Ruby work around it.  The lock covers one call at a time: a sequence of calls that must not interleave with another thread's — define, then write, say — still needs a lock of your own.
+libnetcdf, and the HDF5 under it, are not thread-safe: two threads inside them at once corrupt process-wide state, even when they work on different files.  So every `NetCDF` call — array I/O, and inquiry, definition, open and close alike — takes one process-wide lock.  A thread that calls into NetCDF while another is in the middle of a read waits for it, with the GVL released; threads doing anything else keep running.  Threads therefore do not speed up NetCDF I/O itself, only the Ruby work around it.  The lock covers one call at a time: a sequence of calls that must not interleave with another thread's — define, then write, say — still needs a lock of your own.
 
-`NetCDF` can be called only from the main Ractor.  A call from any other Ractor raises an error.  For netCDF I/O that runs in parallel, use separate processes.
+`NetCDF` can be called only from the main Ractor.  A call from any other Ractor raises an error.  For NetCDF I/O that runs in parallel, use separate processes.

data/docs/03_reference.md

@@ -24,9 +24,9 @@ Every function this gem defines, grouped by subsystem.  [Getting started](01_get
 - `ncid`, `dimid`, `varid`, `attnum`, `grpid` are the integers libnetcdf uses, passed to and from these calls unchanged.
 - Functions that take an `Array` of indices (`start`, `count`, `stride`, etc.) expect a Ruby `Array` of `Integer` whose length equals the variable's rank.
 - Smart-typing generics (`nc_put_att`, `nc_get_att`, `nc_put_var1`, `nc_get_var1`, `nc_put_var{,a,s,m}`, `nc_get_var{,a,s,m}`) dispatch on the Ruby value type or the variable's `nc_type`. There are no typed Ruby variants for variables — Ruby's type system already covers the relevant cases. Attributes do expose typed variants because the put-call itself determines the on-disk attribute type.
-- Buffer arguments for array I/O are MemoryView producers. A raw Ruby `String` is *not* accepted there; see [Buffers and MemoryView](02_buffers.md).
+- Buffer arguments for array I/O are objects that support MemoryView. A raw Ruby `String` is *not* accepted there; see [Buffers and MemoryView](02_buffers.md).
 - `get` calls read into the buffer passed and return it; the gem allocates none of its own, and omitting the buffer raises `ArgumentError`.  `NC_STRING` variables are the exception: they take no buffer and return a nested Ruby `Array<String>` (`char**` does not map to MemoryView).
-- Array I/O releases the GVL around the underlying libnetcdf call.  Every call is serialized on one process-wide lock, because libnetcdf is not thread-safe; see [the GVL](02_buffers.md#the-gvl).
+- Array I/O releases the GVL around the underlying libnetcdf call.  Every call is serialized on one process-wide lock, because libnetcdf is not thread-safe; see [Threads and the GVL](02_buffers.md#threads-and-the-gvl).
 
 ## File
 
@@ -44,8 +44,10 @@ NetCDF.nc_inq_ndims(ncid)      # => Integer
 NetCDF.nc_inq_nvars(ncid)      # => Integer
 NetCDF.nc_inq_natts(ncid)      # => Integer
 NetCDF.nc_inq_unlimdim(ncid)   # => Integer | nil
+NetCDF.nc_inq_unlimdims(ncid)  # => [Integer, ...] (every unlimited dim; [] if none)
 
 oldmode = NetCDF.nc_set_fill(ncid, mode)
+oldfmt  = NetCDF.nc_set_default_format(fmt)   # fmt: NC_FORMAT_*; for every later nc_create in the process
 
 path  = NetCDF.nc_inq_path(ncid)            # libnetcdf >= 4.1.2, => String
 fmt   = NetCDF.nc_inq_format(ncid)          # => NC_FORMAT_*
@@ -128,8 +130,11 @@ NetCDF.nc_inq_varndims(ncid, varid)
 NetCDF.nc_inq_vardimid(ncid, varid)
 NetCDF.nc_inq_varnatts(ncid, varid)
 NetCDF.nc_rename_var(ncid, varid, newname)
+NetCDF.nc_copy_var(src_ncid, varid, dst_ncid)     # => nil
 ```
 
+`nc_copy_var` copies the definition, the attributes and the data of one variable to another file. The destination must already have dimensions with the same names. It may be in define mode or in data mode. A variable of the same name already there raises `NetCDF::Error`. To find the new variable, use `nc_inq_varid` with its name.
+
 ### Variable scalar I/O
 
 ```
@@ -153,7 +158,7 @@ NetCDF.nc_get_vars(ncid, varid, start, count, stride[, buffer])
 NetCDF.nc_get_varm(ncid, varid, start, count, stride, imap[, buffer])
 ```
 
-`buffer` is any object that implements the Ruby MemoryView protocol.  It must be sized to hold the requested elements, must be writable on `get` calls, and must be row-major C-contiguous; [Buffers and MemoryView](02_buffers.md) has the rules and the errors they raise.
+`buffer` is any object that supports MemoryView.  It must be sized to hold the requested elements, must be writable on `get` calls, and must be row-major C-contiguous; [Buffers and MemoryView](02_buffers.md) has the rules and the errors they raise.
 
 On `get`, the read fills `buffer` and returns it.  The argument is written as optional only because `NC_STRING` variables take none and return a nested `Array<String>` instead (see below); for any other type, omitting it raises `ArgumentError: buffer is required`.
 
@@ -192,6 +197,16 @@ NetCDF.nc_inq_var_filter_info(ncid, varid, filter_id)             # libnetcdf >=
 NetCDF.nc_inq_var_filter_ids(ncid, varid)                         # libnetcdf >= 4.7, => Array<Integer>
 NetCDF.nc_inq_filter_avail(ncid, filter_id)                       # libnetcdf >= 4.7, => true | false
 
+NetCDF.nc_def_var_szip(ncid, varid, options_mask, pixels_per_block)   # options_mask: NC_SZIP_NN or NC_SZIP_EC
+NetCDF.nc_inq_var_szip(ncid, varid)                               # => [options_mask, pixels_per_block]
+NetCDF.nc_def_var_zstandard(ncid, varid, level)                   # libnetcdf >= 4.9
+NetCDF.nc_inq_var_zstandard(ncid, varid)                          # libnetcdf >= 4.9, => [has_filter, level]
+NetCDF.nc_def_var_bzip2(ncid, varid, level)                       # libnetcdf >= 4.9
+NetCDF.nc_inq_var_bzip2(ncid, varid)                              # libnetcdf >= 4.9, => [has_filter, level]
+NetCDF.nc_def_var_blosc(ncid, varid, subcompressor, level, blocksize, shuffle)   # libnetcdf >= 4.9
+NetCDF.nc_inq_var_blosc(ncid, varid)                              # libnetcdf >= 4.9,
+                                                                  #   => [has_filter, subcompressor, level, blocksize, shuffle]
+
 NetCDF.nc_def_var_quantize(ncid, varid, mode, nsd)                # libnetcdf >= 4.9
 NetCDF.nc_inq_var_quantize(ncid, varid)                           # libnetcdf >= 4.9, => [mode, nsd]
 
@@ -199,6 +214,13 @@ NetCDF.nc_set_var_chunk_cache(ncid, varid, size, nelems, preemption)
 NetCDF.nc_get_var_chunk_cache(ncid, varid)       # => [size, nelems, preemption]
 ```
 
+The calls for szip, zstandard, bzip2 and blosc are there even when libnetcdf was built without the filter. To check whether a filter can be used, call `nc_inq_filter_avail` with its `H5Z_FILTER_*` id. When the filter is missing:
+
+- The four def calls raise `NetCDF::Error` with status `NC_ENOFILTER` (-136). The gem checks this itself, because a libnetcdf without blosc returns no error from `nc_def_var_blosc` and writes the data uncompressed. For szip the check needs libnetcdf 4.7 or later.
+- The `nc_inq_var_*` calls report that the variable does not have the filter.
+
+A filter needs chunked storage (`nc_def_var_chunking` with `NC_CHUNKED`). A classic-format file has no filters.
+
 Global chunk cache (process-wide HDF5 cache parameters):
 
 ```
@@ -286,10 +308,13 @@ Strings read back — `NC_CHAR` and `NC_STRING` attributes, and `NC_CHAR` and `N
 name, size, base_type, nfields, klass = NetCDF.nc_inq_user_type(ncid, typeid)
 typeid = NetCDF.nc_inq_typeid(ncid, name)   # => Integer | nil
 NetCDF.nc_inq_typeids(ncid)                  # => Array<Integer>
+NetCDF.nc_inq_type_equal(ncid1, typeid1, ncid2, typeid2)   # => true | false
 ```
 
 `klass` is one of `NC_VLEN`, `NC_OPAQUE`, `NC_ENUM`, `NC_COMPOUND`.
 
+`nc_inq_type_equal` compares a user-defined type only after `nc_enddef` on its file. In define mode it raises `NetCDF::Error` ("HDF error"), even when both arguments name the same type.
+
 ### Opaque (fixed-size raw bytes)
 
 ```
@@ -314,7 +339,7 @@ NetCDF.nc_get_vara(ncid, v, [0], [3], out)
 out.to_s                                              # => "ABCDEFGHIJKL"
 ```
 
-Raw Ruby Strings are not accepted on the array I/O surface, the same as for any other type.
+Raw Ruby Strings are not accepted by array I/O, the same as for any other type.
 
 ### Vlen (variable-length sequence)
 
@@ -339,6 +364,8 @@ NetCDF.nc_inq_enum_ident(ncid, typeid, value)   # => String | nil
 
 Variables of enum type are read and written as plain Integers — internally the gem uses libnetcdf's untyped scalar/array I/O to satisfy the enum type check.  That I/O moves elements of the base type with no conversion, so an array buffer for an enum variable holds the base type: a formatted buffer must name it (`"i"` for an `NC_INT` base), and one naming another type raises `ArgumentError`.  A formatless buffer is read as the base type.
 
+Attributes of enum type are read the same way. libnetcdf's typed getters refuse one, but here `nc_get_att` returns its values as Integers of the base type, and the typed getter for the base type (`nc_get_att_uchar` for an `NC_UBYTE` base) reads it too; any other typed getter raises `NetCDF::Error`. The usual case is a `_FillValue` on an enum variable, which netCDF4-python writes with the enum's type. `nc_def_var_fill` and `nc_inq_var_fill` on an enum variable take and return the fill value as an Integer of the base type, and the default fill is the base type's. There is no call yet to write an enum attribute other than through `nc_def_var_fill`.
+
 ## Group (NetCDF-4 only)
 
 ```
@@ -359,7 +386,7 @@ A group's `ncid` is interchangeable with the file's `ncid` for almost all calls
 
 ## Constants
 
-Open / create modes: `NC_NOWRITE`, `NC_WRITE`, `NC_CLOBBER`, `NC_NOCLOBBER`, `NC_SHARE`, `NC_NETCDF4`, `NC_CLASSIC_MODEL`, `NC_64BIT_OFFSET`.
+Open / create modes: `NC_NOWRITE`, `NC_WRITE`, `NC_CLOBBER`, `NC_NOCLOBBER`, `NC_SHARE`, `NC_NETCDF4`, `NC_CLASSIC_MODEL`, `NC_64BIT_OFFSET`, `NC_64BIT_DATA` (alias `NC_CDF5`; CDF-5, defined only when the linked libnetcdf provides it).
 
 Diskless / in-memory modes (defined only when the linked libnetcdf provides them): `NC_DISKLESS`, `NC_PERSIST`, `NC_MMAP`, `NC_INMEMORY`.
 
@@ -381,6 +408,12 @@ Endian: `NC_ENDIAN_NATIVE`, `NC_ENDIAN_LITTLE`, `NC_ENDIAN_BIG`.
 
 Quantize modes: `NC_NOQUANTIZE`, `NC_QUANTIZE_BITGROOM`, `NC_QUANTIZE_GRANULARBR`, `NC_QUANTIZE_BITROUND`.
 
+Filter ids (for `nc_inq_filter_avail` and `nc_inq_var_filter_ids`): `H5Z_FILTER_DEFLATE`, `H5Z_FILTER_SHUFFLE`, `H5Z_FILTER_FLETCHER32`, `H5Z_FILTER_SZIP`, `H5Z_FILTER_ZSTD`, `H5Z_FILTER_BZIP2`, `H5Z_FILTER_BLOSC`.
+
+Szip options: `NC_SZIP_NN`, `NC_SZIP_EC`.
+
+Blosc subcompressors: `BLOSC_LZ`, `BLOSC_LZ4`, `BLOSC_LZ4HC`, `BLOSC_SNAPPY`, `BLOSC_ZLIB`, `BLOSC_ZSTD`. Blosc shuffle: `BLOSC_NOSHUFFLE`, `BLOSC_SHUFFLE`, `BLOSC_BITSHUFFLE`. (libnetcdf >= 4.9)
+
 Limits: `NC_MAX_NAME`, `NC_MAX_VAR_DIMS`.
 
 ## Buffers

data/ext/netcdf/extconf.rb

@@ -45,6 +45,14 @@ have_func("nc_def_var_filter",      filter_hdrs)  # 4.6+
 have_func("nc_inq_var_filter_info", filter_hdrs)  # 4.6+
 have_func("nc_inq_var_filter_ids",  filter_hdrs)  # 4.6+
 have_func("nc_inq_filter_avail",    filter_hdrs)  # 4.7+
+have_func("nc_def_var_szip",        "netcdf.h")
+have_func("nc_inq_var_szip",        "netcdf.h")
+have_func("nc_def_var_zstandard",   filter_hdrs)  # 4.9+
+have_func("nc_inq_var_zstandard",   filter_hdrs)  # 4.9+
+have_func("nc_def_var_bzip2",       filter_hdrs)  # 4.9+
+have_func("nc_inq_var_bzip2",       filter_hdrs)  # 4.9+
+have_func("nc_def_var_blosc",       filter_hdrs)  # 4.9+
+have_func("nc_inq_var_blosc",       filter_hdrs)  # 4.9+
 
 # In-memory file APIs.  nc_open_mem arrived in 4.4; nc_create_mem and
 # nc_close_memio (with NC_memio) arrived in 4.6.2.  netcdf_mem.h needs

data/ext/netcdf/internal.h

@@ -15,7 +15,10 @@
 #if defined(HAVE_NC_DEF_VAR_FILTER)      || \
     defined(HAVE_NC_INQ_VAR_FILTER_INFO) || \
     defined(HAVE_NC_INQ_VAR_FILTER_IDS)  || \
-    defined(HAVE_NC_INQ_FILTER_AVAIL)
+    defined(HAVE_NC_INQ_FILTER_AVAIL)    || \
+    defined(HAVE_NC_DEF_VAR_ZSTANDARD)   || \
+    defined(HAVE_NC_DEF_VAR_BZIP2)       || \
+    defined(HAVE_NC_DEF_VAR_BLOSC)
 # include <netcdf_filter.h>
 #endif
 #ifdef HAVE_NETCDF_MEM_H
@@ -41,6 +44,7 @@ void nc_raise(int status) __attribute__((noreturn));
 void    ary_to_sizet(VALUE ary, int ndims, const char *role, size_t *out);
 bool    ary_to_ptrdiff(VALUE ary, int ndims, const char *role, ptrdiff_t *out);
 ssize_t nc_xtype_size(nc_type xt);
+nc_type resolve_enum_base(int ncid, nc_type xt);
 void    indices_to_c(int ncid, int varid, VALUE index_ary, size_t *out);
 
 /* Range-checked integer conversions (defined in netcdf.c); each raises

data/ext/netcdf/nc_att.c

@@ -119,9 +119,39 @@ rb_nc_get_att_text (VALUE self, VALUE rncid, VALUE rvarid, VALUE rname)
   return out;
 }
 
+/* libnetcdf refuses to read an enum attribute through a typed getter
+   (NC_EBADTYPE).  Its values are stored as the enum's base type, so when
+   that base type is `memtype` read the raw elements with nc_get_att;
+   otherwise keep NC_EBADTYPE.  Returns a status rather than raising so
+   that the caller can free its buffer first. */
+static int
+get_att_enum_as (int ncid, int varid, const char *name, nc_type memtype, void *buf)
+{
+  nc_type xt, base;
+  int klass, st;
+
+  st = nc_inq_atttype(ncid, varid, name, &xt);
+  if ( st != NC_NOERR ) {
+    return st;
+  }
+  if ( xt < NC_FIRSTUSERTYPEID ) {
+    return NC_EBADTYPE;
+  }
+  st = nc_inq_user_type(ncid, xt, NULL, NULL, &base, NULL, &klass);
+  if ( st != NC_NOERR ) {
+    return st;
+  }
+  if ( klass != NC_ENUM || base != memtype ) {
+    return NC_EBADTYPE;
+  }
+  return nc_get_att(ncid, varid, name, buf);
+}
+
 /* As in C, `xtype` is the attribute's type on disk and the suffix names
-   the type of the values in memory; libnetcdf converts between them. */
-#define DEFINE_ATT_NUM(suffix, ctype, num2c, c2num)                     \
+   the type of the values in memory; libnetcdf converts between them.
+   The getter also reads an enum attribute whose base type is the
+   suffix's type (`memtype`). */
+#define DEFINE_ATT_NUM(suffix, ctype, memtype, num2c, c2num)            \
   static VALUE                                                          \
   rb_nc_put_att_##suffix (VALUE self, VALUE rncid, VALUE rvarid,        \
                           VALUE rname, VALUE rxtype, VALUE rvalue)      \
@@ -161,6 +191,10 @@ rb_nc_get_att_text (VALUE self, VALUE rncid, VALUE rvarid, VALUE rname)
     buf = ALLOC_N(ctype, (len > 0 ? len : 1));                          \
     st = nc_get_att_##suffix(NUM2INT(rncid), NUM2INT(rvarid),           \
                              StringValueCStr(rname), buf);              \
+    if ( st == NC_EBADTYPE ) {                                          \
+      st = get_att_enum_as(NUM2INT(rncid), NUM2INT(rvarid),             \
+                           StringValueCStr(rname), memtype, buf);       \
+    }                                                                   \
     if ( st != NC_NOERR ) {                                             \
       xfree(buf);                                                       \
       nc_raise(st);                                                     \
@@ -173,16 +207,16 @@ rb_nc_get_att_text (VALUE self, VALUE rncid, VALUE rvarid, VALUE rname)
     return out;                                                         \
   }
 
-DEFINE_ATT_NUM(schar,     signed char,        num_to_schar,     INT2NUM)
-DEFINE_ATT_NUM(uchar,     unsigned char,      num_to_uchar,     UINT2NUM)
-DEFINE_ATT_NUM(short,     short,              num_to_short,     INT2NUM)
-DEFINE_ATT_NUM(ushort,    unsigned short,     num_to_ushort,    UINT2NUM)
-DEFINE_ATT_NUM(int,       int,                NUM2INT,          INT2NUM)
-DEFINE_ATT_NUM(uint,      unsigned int,       num_to_uint,      UINT2NUM)
-DEFINE_ATT_NUM(longlong,  long long,          NUM2LL,           LL2NUM)
-DEFINE_ATT_NUM(ulonglong, unsigned long long, num_to_ulonglong, ULL2NUM)
-DEFINE_ATT_NUM(float,     float,              NUM2DBL,          DBL2NUM)
-DEFINE_ATT_NUM(double,    double,             NUM2DBL,          DBL2NUM)
+DEFINE_ATT_NUM(schar,     signed char,        NC_BYTE,   num_to_schar,     INT2NUM)
+DEFINE_ATT_NUM(uchar,     unsigned char,      NC_UBYTE,  num_to_uchar,     UINT2NUM)
+DEFINE_ATT_NUM(short,     short,              NC_SHORT,  num_to_short,     INT2NUM)
+DEFINE_ATT_NUM(ushort,    unsigned short,     NC_USHORT, num_to_ushort,    UINT2NUM)
+DEFINE_ATT_NUM(int,       int,                NC_INT,    NUM2INT,          INT2NUM)
+DEFINE_ATT_NUM(uint,      unsigned int,       NC_UINT,   num_to_uint,      UINT2NUM)
+DEFINE_ATT_NUM(longlong,  long long,          NC_INT64,  NUM2LL,           LL2NUM)
+DEFINE_ATT_NUM(ulonglong, unsigned long long, NC_UINT64, num_to_ulonglong, ULL2NUM)
+DEFINE_ATT_NUM(float,     float,              NC_FLOAT,  NUM2DBL,          DBL2NUM)
+DEFINE_ATT_NUM(double,    double,             NC_DOUBLE, NUM2DBL,          DBL2NUM)
 
 static VALUE
 rb_nc_put_att_string (VALUE self, VALUE rncid, VALUE rvarid, VALUE rname, VALUE rvalue)
@@ -369,6 +403,9 @@ rb_nc_get_att (VALUE self, VALUE rncid, VALUE rvarid, VALUE rname)
     return out;
   }
 
+  /* an enum attribute is read as its base type, which the typed getters
+     below accept */
+  xt = resolve_enum_base(NUM2INT(rncid), xt);
   switch ( xt ) {
   case NC_BYTE:   out = rb_nc_get_att_schar(self, rncid, rvarid, rname);     break;
   case NC_UBYTE:  out = rb_nc_get_att_uchar(self, rncid, rvarid, rname);     break;

data/ext/netcdf/nc_file.c

@@ -230,6 +230,28 @@ rb_nc_inq_unlimdim (VALUE self, VALUE rncid)
   return ( d < 0 ) ? Qnil : INT2NUM(d);
 }
 
+static VALUE
+rb_nc_inq_unlimdims (VALUE self, VALUE rncid)
+{
+  VALUE out;
+  int n, st, i;
+  int *ids;
+
+  NC_CHECK(nc_inq_unlimdims(NUM2INT(rncid), &n, NULL));
+  ids = ALLOC_N(int, n > 0 ? n : 1);
+  st = nc_inq_unlimdims(NUM2INT(rncid), NULL, ids);
+  if ( st != NC_NOERR ) {
+    xfree(ids);
+    nc_raise(st);
+  }
+  out = rb_ary_new_capa(n);
+  for (i=0; i<n; i++) {
+    rb_ary_push(out, INT2NUM(ids[i]));
+  }
+  xfree(ids);
+  return out;
+}
+
 #ifdef HAVE_NC_INQ_PATH
 static VALUE
 rb_nc_inq_path (VALUE self, VALUE rncid)
@@ -290,6 +312,16 @@ rb_nc_set_fill (VALUE self, VALUE rncid, VALUE rmode)
   return INT2NUM(old);
 }
 
+/* Process-global format used by nc_create when the mode names none. */
+static VALUE
+rb_nc_set_default_format (VALUE self, VALUE rformat)
+{
+  int old;
+
+  NC_CHECK(nc_set_default_format(NUM2INT(rformat), &old));
+  return INT2NUM(old);
+}
+
 /* Process-global HDF5 chunk cache parameters. */
 static VALUE
 rb_nc_set_chunk_cache (VALUE self, VALUE rsize, VALUE rnelems, VALUE rpreemption)
@@ -334,6 +366,7 @@ init_nc_file (void)
   rb_define_module_function(mNetCDF, "nc_inq_nvars",           rb_nc_inq_nvars,            1);
   rb_define_module_function(mNetCDF, "nc_inq_natts",           rb_nc_inq_natts,            1);
   rb_define_module_function(mNetCDF, "nc_inq_unlimdim",        rb_nc_inq_unlimdim,         1);
+  rb_define_module_function(mNetCDF, "nc_inq_unlimdims",       rb_nc_inq_unlimdims,        1);
 #ifdef HAVE_NC_INQ_PATH
   rb_define_module_function(mNetCDF, "nc_inq_path",            rb_nc_inq_path,             1);
 #endif
@@ -344,6 +377,7 @@ init_nc_file (void)
   rb_define_module_function(mNetCDF, "nc_inq_libvers",         rb_nc_inq_libvers,          0);
   rb_define_module_function(mNetCDF, "nc_inq_type",            rb_nc_inq_type,             2);
   rb_define_module_function(mNetCDF, "nc_set_fill",            rb_nc_set_fill,             2);
+  rb_define_module_function(mNetCDF, "nc_set_default_format",  rb_nc_set_default_format,   1);
   rb_define_module_function(mNetCDF, "nc_set_chunk_cache",     rb_nc_set_chunk_cache,      3);
   rb_define_module_function(mNetCDF, "nc_get_chunk_cache",     rb_nc_get_chunk_cache,      0);
 }

data/ext/netcdf/nc_io.c

@@ -1267,6 +1267,45 @@ rb_nc_get_var (int argc, VALUE *argv, VALUE self)
   return rb_nc_var_io(rncid, rvarid, rbuf, false);
 }
 
+/* ---------------------------------------------------------- */
+/* Whole-variable copy between files                           */
+/* ---------------------------------------------------------- */
+
+typedef struct {
+  int ncid_in, varid, ncid_out;
+  int status;
+} copy_var_args_t;
+
+static void *
+nogvl_copy_var (void *p)
+{
+  copy_var_args_t *a;
+
+  a = (copy_var_args_t *) p;
+  a->status = nc_copy_var(a->ncid_in, a->varid, a->ncid_out);
+  return NULL;
+}
+
+/* Copies the definition, the attributes and the data.  Nothing is held
+   across the call, so an interrupt that kept it from running is raised,
+   or the copy tried again, with nothing to clean up first. */
+static VALUE
+rb_nc_copy_var (VALUE self, VALUE rncid_in, VALUE rvarid, VALUE rncid_out)
+{
+  copy_var_args_t a;
+
+  a.ncid_in  = NUM2INT(rncid_in);
+  a.varid    = NUM2INT(rvarid);
+  a.ncid_out = NUM2INT(rncid_out);
+  a.status   = NC_NOERR;
+  while ( ! call_without_gvl(nogvl_copy_var, &a) ) {
+    rb_thread_check_ints();
+  }
+  rb_thread_check_ints();
+  NC_CHECK(a.status);
+  return Qnil;
+}
+
 void
 init_nc_io (void)
 {
@@ -1281,4 +1320,6 @@ init_nc_io (void)
   rb_define_module_function(mNetCDF, "nc_get_vars", rb_nc_get_vars, -1);
   rb_define_module_function(mNetCDF, "nc_put_varm", rb_nc_put_varm,  7);
   rb_define_module_function(mNetCDF, "nc_get_varm", rb_nc_get_varm, -1);
+
+  rb_define_module_function(mNetCDF, "nc_copy_var", rb_nc_copy_var,  3);
 }

data/ext/netcdf/nc_types.c

@@ -67,6 +67,17 @@ rb_nc_inq_typeids (VALUE self, VALUE rncid)
   return out;
 }
 
+/* The two types may live in different files or groups. */
+static VALUE
+rb_nc_inq_type_equal (VALUE self, VALUE rncid1, VALUE rtypeid1, VALUE rncid2, VALUE rtypeid2)
+{
+  int equal;
+
+  NC_CHECK(nc_inq_type_equal(NUM2INT(rncid1), NUM2INT(rtypeid1),
+                             NUM2INT(rncid2), NUM2INT(rtypeid2), &equal));
+  return equal ? Qtrue : Qfalse;
+}
+
 /* ---------------------------------------------------------- */
 /* Opaque (fixed-size byte type)                               */
 /* ---------------------------------------------------------- */
@@ -263,6 +274,7 @@ init_nc_types (void)
   rb_define_module_function(mNetCDF, "nc_inq_user_type",     rb_nc_inq_user_type,     2);
   rb_define_module_function(mNetCDF, "nc_inq_typeid",        rb_nc_inq_typeid,        2);
   rb_define_module_function(mNetCDF, "nc_inq_typeids",       rb_nc_inq_typeids,       1);
+  rb_define_module_function(mNetCDF, "nc_inq_type_equal",    rb_nc_inq_type_equal,    4);
 
   rb_define_module_function(mNetCDF, "nc_def_opaque",        rb_nc_def_opaque,        3);
   rb_define_module_function(mNetCDF, "nc_inq_opaque",        rb_nc_inq_opaque,        2);

data/ext/netcdf/nc_var.c

@@ -150,6 +150,8 @@ rb_nc_def_var_fill (VALUE self, VALUE rncid, VALUE rvarid, VALUE rno_fill, VALUE
   no_fill = RTEST(rno_fill) ? 1 : 0;
 
   NC_CHECK(nc_inq_vartype(ncid, varid, &xt));
+  /* an enum variable's fill value is an element of its base type */
+  xt = resolve_enum_base(ncid, xt);
 
   if ( NIL_P(rfill) ) {
     NC_CHECK(nc_def_var_fill(ncid, varid, no_fill, NULL));
@@ -201,6 +203,7 @@ rb_nc_inq_var_fill (VALUE self, VALUE rncid, VALUE rvarid)
   varid = NUM2INT(rvarid);
 
   NC_CHECK(nc_inq_vartype(ncid, varid, &xt));
+  xt = resolve_enum_base(ncid, xt);
   /* libnetcdf writes a whole element of the variable's type into `v`,
      so refuse any type the union below cannot hold before asking --
      an opaque's element can be any size. */
@@ -451,6 +454,137 @@ rb_nc_inq_filter_avail (VALUE self, VALUE rncid, VALUE rid)
 }
 #endif
 
+/* ---------------------------------------------------------- */
+/* Compression filters with their own calls                    */
+/* ---------------------------------------------------------- */
+
+/* Whether the filter can be used depends on how libnetcdf was built,
+   but the calls are there either way.  A libnetcdf built without blosc
+   returns NC_NOERR from both blosc calls and sets nothing, so every inq
+   here starts its outputs at 0: a variable without the filter then
+   reads back as not having it.
+
+   Each def call here first asks whether the filter is there, and
+   raises NC_ENOFILTER when it is not: the blosc def would otherwise
+   return without adding the filter, and the data would be written
+   uncompressed.  The check needs nc_inq_filter_avail (4.7+); the szip
+   def in an older libnetcdf goes without it. */
+
+#ifdef HAVE_NC_INQ_FILTER_AVAIL
+static void
+check_filter_available (int ncid, unsigned id)
+{
+  NC_CHECK(nc_inq_filter_avail(ncid, id));
+}
+#endif
+
+#ifdef HAVE_NC_DEF_VAR_SZIP
+static VALUE
+rb_nc_def_var_szip (VALUE self, VALUE rncid, VALUE rvarid,
+                    VALUE roptions_mask, VALUE rpixels_per_block)
+{
+#ifdef HAVE_NC_INQ_FILTER_AVAIL
+  check_filter_available(NUM2INT(rncid), H5Z_FILTER_SZIP);
+#endif
+  NC_CHECK(nc_def_var_szip(NUM2INT(rncid), NUM2INT(rvarid),
+                           NUM2INT(roptions_mask), NUM2INT(rpixels_per_block)));
+  return Qnil;
+}
+#endif
+
+#ifdef HAVE_NC_INQ_VAR_SZIP
+static VALUE
+rb_nc_inq_var_szip (VALUE self, VALUE rncid, VALUE rvarid)
+{
+  int options_mask, pixels_per_block;
+
+  options_mask     = 0;
+  pixels_per_block = 0;
+  NC_CHECK(nc_inq_var_szip(NUM2INT(rncid), NUM2INT(rvarid),
+                           &options_mask, &pixels_per_block));
+  return rb_ary_new_from_args(2, INT2NUM(options_mask), INT2NUM(pixels_per_block));
+}
+#endif
+
+#ifdef HAVE_NC_DEF_VAR_ZSTANDARD
+static VALUE
+rb_nc_def_var_zstandard (VALUE self, VALUE rncid, VALUE rvarid, VALUE rlevel)
+{
+  check_filter_available(NUM2INT(rncid), H5Z_FILTER_ZSTD);
+  NC_CHECK(nc_def_var_zstandard(NUM2INT(rncid), NUM2INT(rvarid), NUM2INT(rlevel)));
+  return Qnil;
+}
+#endif
+
+#ifdef HAVE_NC_INQ_VAR_ZSTANDARD
+static VALUE
+rb_nc_inq_var_zstandard (VALUE self, VALUE rncid, VALUE rvarid)
+{
+  int has, level;
+
+  has   = 0;
+  level = 0;
+  NC_CHECK(nc_inq_var_zstandard(NUM2INT(rncid), NUM2INT(rvarid), &has, &level));
+  return rb_ary_new_from_args(2, has ? Qtrue : Qfalse, INT2NUM(level));
+}
+#endif
+
+#ifdef HAVE_NC_DEF_VAR_BZIP2
+static VALUE
+rb_nc_def_var_bzip2 (VALUE self, VALUE rncid, VALUE rvarid, VALUE rlevel)
+{
+  check_filter_available(NUM2INT(rncid), H5Z_FILTER_BZIP2);
+  NC_CHECK(nc_def_var_bzip2(NUM2INT(rncid), NUM2INT(rvarid), NUM2INT(rlevel)));
+  return Qnil;
+}
+#endif
+
+#ifdef HAVE_NC_INQ_VAR_BZIP2
+static VALUE
+rb_nc_inq_var_bzip2 (VALUE self, VALUE rncid, VALUE rvarid)
+{
+  int has, level;
+
+  has   = 0;
+  level = 0;
+  NC_CHECK(nc_inq_var_bzip2(NUM2INT(rncid), NUM2INT(rvarid), &has, &level));
+  return rb_ary_new_from_args(2, has ? Qtrue : Qfalse, INT2NUM(level));
+}
+#endif
+
+#ifdef HAVE_NC_DEF_VAR_BLOSC
+static VALUE
+rb_nc_def_var_blosc (VALUE self, VALUE rncid, VALUE rvarid, VALUE rsubcompressor,
+                     VALUE rlevel, VALUE rblocksize, VALUE raddshuffle)
+{
+  check_filter_available(NUM2INT(rncid), H5Z_FILTER_BLOSC);
+  NC_CHECK(nc_def_var_blosc(NUM2INT(rncid), NUM2INT(rvarid),
+                            NUM2UINT(rsubcompressor), NUM2UINT(rlevel),
+                            NUM2UINT(rblocksize), NUM2UINT(raddshuffle)));
+  return Qnil;
+}
+#endif
+
+#ifdef HAVE_NC_INQ_VAR_BLOSC
+static VALUE
+rb_nc_inq_var_blosc (VALUE self, VALUE rncid, VALUE rvarid)
+{
+  int has;
+  unsigned subcompressor, level, blocksize, addshuffle;
+
+  has           = 0;
+  subcompressor = 0;
+  level         = 0;
+  blocksize     = 0;
+  addshuffle    = 0;
+  NC_CHECK(nc_inq_var_blosc(NUM2INT(rncid), NUM2INT(rvarid), &has,
+                            &subcompressor, &level, &blocksize, &addshuffle));
+  return rb_ary_new_from_args(5, has ? Qtrue : Qfalse,
+                              UINT2NUM(subcompressor), UINT2NUM(level),
+                              UINT2NUM(blocksize), UINT2NUM(addshuffle));
+}
+#endif
+
 /* ---------------------------------------------------------- */
 /* Quantize (lossy bit-grooming for floating-point data)       */
 /* ---------------------------------------------------------- */
@@ -539,6 +673,31 @@ init_nc_var (void)
   rb_define_module_function(mNetCDF, "nc_inq_filter_avail",    rb_nc_inq_filter_avail,    2);
 #endif
 
+#ifdef HAVE_NC_DEF_VAR_SZIP
+  rb_define_module_function(mNetCDF, "nc_def_var_szip",        rb_nc_def_var_szip,        4);
+#endif
+#ifdef HAVE_NC_INQ_VAR_SZIP
+  rb_define_module_function(mNetCDF, "nc_inq_var_szip",        rb_nc_inq_var_szip,        2);
+#endif
+#ifdef HAVE_NC_DEF_VAR_ZSTANDARD
+  rb_define_module_function(mNetCDF, "nc_def_var_zstandard",   rb_nc_def_var_zstandard,   3);
+#endif
+#ifdef HAVE_NC_INQ_VAR_ZSTANDARD
+  rb_define_module_function(mNetCDF, "nc_inq_var_zstandard",   rb_nc_inq_var_zstandard,   2);
+#endif
+#ifdef HAVE_NC_DEF_VAR_BZIP2
+  rb_define_module_function(mNetCDF, "nc_def_var_bzip2",       rb_nc_def_var_bzip2,       3);
+#endif
+#ifdef HAVE_NC_INQ_VAR_BZIP2
+  rb_define_module_function(mNetCDF, "nc_inq_var_bzip2",       rb_nc_inq_var_bzip2,       2);
+#endif
+#ifdef HAVE_NC_DEF_VAR_BLOSC
+  rb_define_module_function(mNetCDF, "nc_def_var_blosc",       rb_nc_def_var_blosc,       6);
+#endif
+#ifdef HAVE_NC_INQ_VAR_BLOSC
+  rb_define_module_function(mNetCDF, "nc_inq_var_blosc",       rb_nc_inq_var_blosc,       2);
+#endif
+
 #ifdef HAVE_NC_DEF_VAR_QUANTIZE
   rb_define_module_function(mNetCDF, "nc_def_var_quantize",    rb_nc_def_var_quantize,    4);
 #endif

data/ext/netcdf/netcdf.c

@@ -73,6 +73,25 @@ nc_xtype_size (nc_type xt)
   }
 }
 
+/* The base type of the enum type `xt`, or `xt` itself for any other type.
+   An enum value is stored as its base type, so code that reads or writes
+   one element can treat it as that integer type. */
+nc_type
+resolve_enum_base (int ncid, nc_type xt)
+{
+  nc_type base;
+  int klass;
+
+  if ( xt < NC_FIRSTUSERTYPEID ) {
+    return xt;
+  }
+  NC_CHECK(nc_inq_user_type(ncid, xt, NULL, NULL, &base, NULL, &klass));
+  if ( klass != NC_ENUM ) {
+    return xt;
+  }
+  return base;
+}
+
 /* Integer conversions that refuse a value the C type cannot hold.  A cast
    would store 300 as NC_BYTE 44, and Ruby's own NUM2UINT / NUM2ULL wrap a
    negative value around rather than raise, so -1 would be stored as the
@@ -173,6 +192,12 @@ Init_netcdf (void)
   DEF_CONST(NC_NETCDF4);
   DEF_CONST(NC_CLASSIC_MODEL);
   DEF_CONST(NC_64BIT_OFFSET);
+#ifdef NC_64BIT_DATA
+  DEF_CONST(NC_64BIT_DATA);            /* CDF-5; libnetcdf 4.4+ */
+#endif
+#ifdef NC_CDF5
+  DEF_CONST(NC_CDF5);                  /* alias of NC_64BIT_DATA */
+#endif
 #ifdef NC_DISKLESS
   DEF_CONST(NC_DISKLESS);
 #endif
@@ -279,6 +304,51 @@ Init_netcdf (void)
   DEF_CONST(NC_QUANTIZE_BITROUND);
 #endif
 
+  /* Filter ids, for nc_inq_filter_avail and nc_inq_var_filter_ids */
+#ifdef H5Z_FILTER_DEFLATE
+  DEF_CONST(H5Z_FILTER_DEFLATE);
+#endif
+#ifdef H5Z_FILTER_SHUFFLE
+  DEF_CONST(H5Z_FILTER_SHUFFLE);
+#endif
+#ifdef H5Z_FILTER_FLETCHER32
+  DEF_CONST(H5Z_FILTER_FLETCHER32);
+#endif
+#ifdef H5Z_FILTER_SZIP
+  DEF_CONST(H5Z_FILTER_SZIP);
+#endif
+#ifdef H5Z_FILTER_ZSTD
+  DEF_CONST(H5Z_FILTER_ZSTD);
+#endif
+#ifdef H5Z_FILTER_BZIP2
+  DEF_CONST(H5Z_FILTER_BZIP2);
+#endif
+#ifdef H5Z_FILTER_BLOSC
+  DEF_CONST(H5Z_FILTER_BLOSC);
+#endif
+
+  /* szip options_mask */
+#ifdef NC_SZIP_EC
+  DEF_CONST(NC_SZIP_EC);
+#endif
+#ifdef NC_SZIP_NN
+  DEF_CONST(NC_SZIP_NN);
+#endif
+
+  /* Blosc subcompressors and shuffle modes.  These are enum members,
+     not macros, so they are gated on the call that takes them. */
+#ifdef HAVE_NC_DEF_VAR_BLOSC
+  DEF_CONST(BLOSC_LZ);
+  DEF_CONST(BLOSC_LZ4);
+  DEF_CONST(BLOSC_LZ4HC);
+  DEF_CONST(BLOSC_SNAPPY);
+  DEF_CONST(BLOSC_ZLIB);
+  DEF_CONST(BLOSC_ZSTD);
+  DEF_CONST(BLOSC_NOSHUFFLE);
+  DEF_CONST(BLOSC_SHUFFLE);
+  DEF_CONST(BLOSC_BITSHUFFLE);
+#endif
+
   /* User-defined type classes (returned by nc_inq_user_type) */
   DEF_CONST(NC_VLEN);
   DEF_CONST(NC_OPAQUE);

data/lib/netcdf/version.rb

@@ -1,3 +1,3 @@
 module NetCDF
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: netcdf
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - himotoyoshi