netcdflib 0.9.0

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,7 @@
1
+ ---
2
+ SHA256:
3
+ metadata.gz: 6844c84377eaed5f48a15bbb9fa363fa9c0761f10cea5d1a368f582e83006012
4
+ data.tar.gz: e2823b1fad6be468d7b394d9d6f354675714733f7fe9a8060f531b2de1478b86
5
+ SHA512:
6
+ metadata.gz: 811f0be988b352fefa5aeed84991ead360f6eeb581f1f1c99071f4dfa7835e7245746e19215ec11492b7f48e0e1c27516a365630cbdd9e7175f7636f4400f295
7
+ data.tar.gz: d07f6a47d68578af24e914b436f5ef260af12fb34d8444e0a8acecc5a9423f4b15ee3dd31930c9ca83d5988dd91465b25da80a415de033d28117db05e1bed65e
data/API.md ADDED
@@ -0,0 +1,158 @@
1
+ CArray/NetCDF library API document
2
+ ==================================
3
+
4
+ 1. Loading library
5
+ ------------------
6
+
7
+ gem install carray-netcdf
8
+
9
+ require "carray-netcdf"
10
+
11
+ 2. Methods
12
+ ----------
13
+
14
+ This API provides the way of calling functions
15
+
16
+ include NC
17
+ nc_funcname(...)
18
+
19
+ NC.funcname(...)
20
+
21
+ ### 2.1. Data types
22
+
23
+ data_type = NC.ca_type(xtype)
24
+ xtype = NC.nc_type(data_type)
25
+
26
+ ### 2.2. NetCDF File
27
+
28
+ fd = nc_create(FILENAME[, mode=NC_CLOBBER])
29
+
30
+ mode : NC_CLOBBER - permit overwrite
31
+ NC_NOCLOBBER - inhibit overwrite
32
+ NC_SHARE - no buffering
33
+
34
+ fd = nc_open(FILENAME[, mode=NC_NOWRITE])
35
+
36
+ mode : NC_NOWRITE - readonly
37
+ NC_WRTIE - writable
38
+ NC_SHARE - no buffering
39
+
40
+ nc_close(fd)
41
+
42
+ nc_redef(fd)
43
+ nc_enddef(fd)
44
+
45
+ nc_sync(fd)
46
+
47
+ ndims = nc_inq_ndims(fd)
48
+ nvars = nc_inq_nvars(fd)
49
+ natts = nc_inq_natts(fd)
50
+ unlimdim = nc_inq_unlimdim(fd)
51
+
52
+ oldmode = nc_set_fill(mode)
53
+
54
+ mode : NC_FILL
55
+ NC_NOFILL
56
+
57
+ ### 2.3. NetCDF Dimension
58
+
59
+ dimid = nc_def_dim(fd, dimname, len)
60
+ dimid = nc_inq_dimid(fd, dimname) => Integer | nil
61
+
62
+ dimname = nc_inq_dimname(fd, dimid)
63
+ dimlen = nc_inq_dimlen(fd, dimid)
64
+
65
+ nc_rename_dim(fd, dimid, newname)
66
+
67
+ ### 2.4. NetCDF Variable
68
+
69
+ varid = nc_def_var(fd, varname, type, dim)
70
+ varid = nc_inq_varid(fd, varname) => Integer | nil
71
+
72
+ vartype = nc_inq_vartype(fd, varid)
73
+ varndims = nc_inq_varndims(fd, varid)
74
+ vardimid = nc_inq_varndimid(fd, varid) => Array of dimids
75
+
76
+ nc_put_var1(fd, varid, [i,j,..], val)
77
+ nc_put_var(fd, varid, ca)
78
+ nc_put_vara(fd, varid, start, count, ca)
79
+ nc_put_vars(fd, varid, start, count, stride, ca)
80
+ nc_put_varm(fd, varid, start, count, stride, imap, ca)
81
+
82
+ + with data_type conversion
83
+
84
+ val = nc_get_var1(fd, varid, [i,j,..])
85
+ ca = nc_get_var(fd, varid) [useful]
86
+ ca = nc_get_vara(fd, varid, start, count) [useful]
87
+ ca = nc_get_vars(fd, varid, start, count, stride) [useful]
88
+ ca = nc_get_varm(fd, varid, start, count, stride, imap) [useful]
89
+
90
+ + no data_type conversion
91
+
92
+ nc_get_var(fd, varid, ca) [pedantic]
93
+ nc_get_vara(fd, varid, start, count, ca) [pedantic]
94
+ nc_get_vars(fd, varid, start, count, stride, ca) [pedantic]
95
+ nc_get_varm(fd, varid, start, count, stride, imap, ca) [pedantic]
96
+
97
+ + with data_type conversion.
98
+
99
+ nc_rename_var(fd, varid, newname)
100
+
101
+ ### 2.5. NetCDF Attribute
102
+
103
+ varnatts = nc_inq_varnatts(fd, varid)
104
+ attid = nc_inq_attid(fd, varid, attname)
105
+
106
+ attname = nc_inq_attname(fd, varid, attid)
107
+ atttype = nc_inq_atttype(fd, varid, attname)
108
+ attlen = nc_inq_attlen(fd, varid, attname)
109
+
110
+ nc_put_att(fd, varid, attname, val)
111
+
112
+ varid : NC_GLOBAL for global att
113
+ val : String -> NC_CHAR
114
+ Integer -> NC_INT
115
+ Float -> NC_DOUBLE
116
+ CArray -> NC.nc_type(val.data_type)
117
+
118
+
119
+ val = nc_get_att(fd, varid, attname) => String | Numeric | CArray | nil
120
+
121
+ varid : NC_GLOBAL for global att
122
+
123
+ nc_get_att(fd, varid, attname, ca) [pedantic]
124
+
125
+ nc_rename_att(fd, varid, attname, newname)
126
+ nc_del_att(fd, varid, attname)
127
+
128
+ nc_copy_att(fd1, varid1, attname, fd2, varid2)
129
+
130
+ ### 2.6 Constants
131
+
132
+ NC_NAT
133
+ NC_BYTE
134
+ NC_SHORT
135
+ NC_INT
136
+ NC_FLOAT
137
+ NC_DOUBLE
138
+
139
+ NC_NOERR - status of API routines
140
+
141
+ NC_CLOBBER - permit overwrite [nc_create]
142
+ NC_NOCLOBBER - inhibit overwrite [nc_create]
143
+ NC_NOWRITE - readonly [nc_open]
144
+ NC_WRITE - writable [nc_open]
145
+ NC_SHARE - no buffering [nc_create, nc_open]
146
+
147
+ NC_GLOBAL - varid for global attributes
148
+
149
+ NC_NOFILL - nc_set_fill(fd, varid, NC_NOFILL)
150
+ NC_FILL - nc_set_fill(fd, varid, NC_FILL)
151
+
152
+ NC_MAX_NAME
153
+ NC_MAX_VAR_DIMS
154
+ NC_MAX_DIMS
155
+
156
+ NC_LOCK - ???
157
+ NC_SIZEHINT_DEFAULT - ???
158
+
data/LICENSE ADDED
@@ -0,0 +1,22 @@
1
+ Copyright (c) 2020 Hiroki Motoyoshi.
2
+
3
+ Permission is hereby granted, free of charge, to any person
4
+ obtaining a copy of this software and associated documentation
5
+ files (the "Software"), to deal in the Software without
6
+ restriction, including without limitation the rights to use,
7
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
8
+ copies of the Software, and to permit persons to whom the
9
+ Software is furnished to do so, subject to the following
10
+ conditions:
11
+
12
+ The above copyright notice and this permission notice shall be
13
+ included in all copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
17
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
19
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22
+ OTHER DEALINGS IN THE SOFTWARE.
File without changes
@@ -0,0 +1,8 @@
1
+ GEMSPEC = "netcdflib.gemspec"
2
+
3
+ task :install do
4
+ spec = eval File.read(GEMSPEC)
5
+ system %{
6
+ gem build #{GEMSPEC}; gem install #{spec.full_name}.gem
7
+ }
8
+ end
@@ -0,0 +1,11 @@
1
+ require "mkmf"
2
+ require "carray/mkmf"
3
+
4
+ $CFLAGS += " -Wall"
5
+
6
+ dir_config("netcdf", possible_includes("netcdf","netcdf3","netcdf-3"), possible_libs)
7
+
8
+ if have_carray() and have_header("netcdf.h") and have_library("netcdf")
9
+ create_makefile("netcdflib")
10
+ end
11
+
@@ -0,0 +1,2716 @@
1
+ #include "ruby.h"
2
+ #include "carray.h"
3
+ #include <netcdf.h>
4
+
5
+ #define CHECK_ARGC(n) \
6
+ if ( argc != n ) \
7
+ rb_raise(rb_eRuntimeError, "invalid # of argumnet (%i for %i)", argc, n)
8
+
9
+ #define CHECK_TYPE_STRING(val) \
10
+ if ( TYPE(val) != T_STRING ) \
11
+ rb_raise(rb_eRuntimeError, "string type arg required")
12
+
13
+ #define CHECK_TYPE_STRING_OR_NIL(val) \
14
+ if ( TYPE(val) != T_STRING && !NIL_P(val)) \
15
+ rb_raise(rb_eRuntimeError, "string type arg required")
16
+
17
+ #define CHECK_TYPE_ARRAY(val) \
18
+ if ( TYPE(val) != T_ARRAY ) \
19
+ rb_raise(rb_eRuntimeError, "array type arg required")
20
+
21
+ #define CHECK_TYPE_ARRAY_OR_NIL(val) \
22
+ if ( TYPE(val) != T_ARRAY && ! NIL_P(val) ) \
23
+ rb_raise(rb_eRuntimeError, "array type arg or nil required")
24
+
25
+ #define CHECK_TYPE_INT(val) \
26
+ if ( ! rb_obj_is_kind_of(val, rb_cInteger) ) \
27
+ rb_raise(rb_eRuntimeError, "int type arg required")
28
+
29
+ #define CHECK_TYPE_NUMERIC(val) \
30
+ if ( ! rb_obj_is_kind_of(val, rb_cNumeric) ) \
31
+ rb_raise(rb_eRuntimeError, "int type arg required")
32
+
33
+ #define CHECK_TYPE_ID(val) \
34
+ if ( ! rb_obj_is_kind_of(val, rb_cInteger) ) \
35
+ rb_raise(rb_eRuntimeError, "id must be an integer")
36
+
37
+ #define CHECK_TYPE_DATA(val) \
38
+ if ( ! rb_obj_is_kind_of(val, rb_cCArray) ) \
39
+ rb_raise(rb_eRuntimeError, "CArray type arg required")
40
+
41
+ #define CHECK_STATUS(status) \
42
+ if ( (status) != NC_NOERR ) \
43
+ rb_raise(rb_eRuntimeError, "%s (STATUS=%i)", nc_strerror(status), status)
44
+
45
+ static VALUE mNetCDF;
46
+ static VALUE NC_converter = Qnil;
47
+ static ID NC_converter_id;
48
+
49
+ static int
50
+ rb_nc_typemap (nc_type nc_type)
51
+ {
52
+ switch ( nc_type ) {
53
+ case NC_CHAR:
54
+ return CA_UINT8;
55
+ case NC_BYTE:
56
+ return CA_INT8;
57
+ case NC_UBYTE:
58
+ return CA_UINT8;
59
+ case NC_SHORT:
60
+ return CA_INT16;
61
+ case NC_USHORT:
62
+ return CA_UINT16;
63
+ case NC_INT:
64
+ return CA_INT32;
65
+ case NC_UINT:
66
+ return CA_UINT32;
67
+ case NC_INT64:
68
+ return CA_INT64;
69
+ case NC_UINT64:
70
+ return CA_UINT64;
71
+ case NC_FLOAT:
72
+ return CA_FLOAT32;
73
+ case NC_DOUBLE:
74
+ return CA_FLOAT64;
75
+ default:
76
+ rb_raise(rb_eRuntimeError, "invalid NC_TYPE");
77
+ }
78
+ }
79
+
80
+ static nc_type
81
+ rb_nc_rtypemap (int ca_type)
82
+ {
83
+ switch ( ca_type ) {
84
+ case CA_INT8:
85
+ return NC_BYTE;
86
+ case CA_UINT8:
87
+ return NC_UBYTE;
88
+ case CA_INT16:
89
+ return NC_SHORT;
90
+ case CA_UINT16:
91
+ return NC_USHORT;
92
+ case CA_INT32:
93
+ return NC_INT;
94
+ case CA_UINT32:
95
+ return NC_UINT;
96
+ case CA_INT64:
97
+ return NC_INT64;
98
+ case CA_UINT64:
99
+ return NC_UINT64;
100
+ case CA_FLOAT32:
101
+ return NC_FLOAT;
102
+ case CA_FLOAT64:
103
+ return NC_DOUBLE;
104
+ case CA_FIXLEN:
105
+ return NC_STRING;
106
+ default:
107
+ rb_raise(rb_eRuntimeError, "invalid CA_TYPE");
108
+ }
109
+ }
110
+
111
+ static VALUE
112
+ rb_nc_ca_type (int argc, VALUE *argv, VALUE mod)
113
+ {
114
+ int type;
115
+
116
+ CHECK_ARGC(1);
117
+ CHECK_TYPE_INT(argv[0]);
118
+
119
+ type = rb_nc_typemap(NUM2INT(argv[0]));
120
+
121
+ return LONG2NUM(type);
122
+ }
123
+
124
+ static VALUE
125
+ rb_nc_nc_type (int argc, VALUE *argv, VALUE mod)
126
+ {
127
+ nc_type type;
128
+
129
+ CHECK_ARGC(1);
130
+ CHECK_TYPE_INT(argv[0]);
131
+
132
+ type = rb_nc_rtypemap(NUM2INT(argv[0]));
133
+
134
+ return LONG2NUM(type);
135
+ }
136
+
137
+ static VALUE
138
+ rb_nc_create (int argc, VALUE *argv, VALUE mod)
139
+ {
140
+ int status, nc_id;
141
+
142
+ if ( argc == 1 ) {
143
+ CHECK_TYPE_STRING(argv[0]);
144
+ status = nc_create(StringValuePtr(argv[0]), NC_CLOBBER, &nc_id);
145
+ CHECK_STATUS(status);
146
+ }
147
+ else if ( argc == 2 ) {
148
+ CHECK_TYPE_STRING(argv[0]);
149
+ CHECK_TYPE_INT(argv[1]);
150
+ status = nc_create(StringValuePtr(argv[0]), NUM2INT(argv[1]), &nc_id);
151
+ CHECK_STATUS(status);
152
+ }
153
+ else {
154
+ rb_raise(rb_eArgError, "invalid # of arguments");
155
+ }
156
+
157
+ return LONG2NUM(nc_id);
158
+ }
159
+
160
+ /*
161
+ static VALUE
162
+ rb_nc_create_mem (int argc, VALUE *argv, VALUE mod)
163
+ {
164
+ int status, nc_id;
165
+ if ( argc < 1 ) {
166
+ rb_raise(rb_eArgError, "invalid # of arguments");
167
+ }
168
+
169
+ CHECK_TYPE_STRING(argv[0]);
170
+
171
+ if ( argc == 1 ) {
172
+ status = nc_create_mem(StringValuePtr(argv[0]), NC_CLOBBER, NC_SIZEHINT_DEFAULT, &nc_id);
173
+ }
174
+ else if ( argc == 2 ) {
175
+ CHECK_TYPE_INT(argv[1]);
176
+ status = nc_create_mem(StringValuePtr(argv[0]),
177
+ NUM2INT(argv[1]),
178
+ NC_SIZEHINT_DEFAULT,
179
+ &nc_id);
180
+ }
181
+ else if ( argc == 3 ) {
182
+ CHECK_TYPE_INT(argv[1]);
183
+ CHECK_TYPE_INT(argv[2]);
184
+ status = nc_create_mem(StringValuePtr(argv[0]),
185
+ NUM2INT(argv[1]),
186
+ NUM2INT(argv[2]),
187
+ &nc_id);
188
+ }
189
+ else {
190
+ rb_raise(rb_eArgError, "too many argument");
191
+ }
192
+
193
+ CHECK_STATUS(status);
194
+
195
+ return LONG2NUM(nc_id);
196
+ }
197
+ */
198
+
199
+ static VALUE
200
+ rb_nc_set_converter (VALUE mod, VALUE rconv)
201
+ {
202
+ if ( ! NIL_P(rconv) ) {
203
+ Check_Type(rconv, T_SYMBOL);
204
+ }
205
+ NC_converter = rconv;
206
+ NC_converter_id = SYM2ID(NC_converter);
207
+ return NC_converter;
208
+ }
209
+
210
+ static VALUE
211
+ rb_nc_get_converter (VALUE mod)
212
+ {
213
+ return NC_converter;
214
+ }
215
+
216
+ static VALUE
217
+ rb_nc_output (VALUE vout)
218
+ {
219
+ if ( NIL_P(NC_converter) ) {
220
+ return vout;
221
+ }
222
+ else {
223
+ return rb_funcall(vout, NC_converter_id, 0);
224
+ }
225
+ }
226
+
227
+ static VALUE
228
+ rb_nc_open (int argc, VALUE *argv, VALUE mod)
229
+ {
230
+ int status, nc_id;
231
+
232
+ if ( argc == 1 ) {
233
+ CHECK_TYPE_STRING(argv[0]);
234
+ status = nc_open(StringValuePtr(argv[0]), NC_NOWRITE, &nc_id);
235
+ CHECK_STATUS(status);
236
+ }
237
+ else if ( argc == 2 ) {
238
+ CHECK_TYPE_STRING(argv[0]);
239
+ CHECK_TYPE_INT(argv[1]);
240
+ status = nc_open(StringValuePtr(argv[0]), NUM2INT(argv[1]), &nc_id);
241
+ CHECK_STATUS(status);
242
+ }
243
+ else {
244
+ rb_raise(rb_eArgError, "invalid # of arguments");
245
+ }
246
+
247
+ return LONG2NUM(nc_id);
248
+ }
249
+
250
+ static VALUE
251
+ rb_nc_close (int argc, VALUE *argv, VALUE mod)
252
+ {
253
+ int status;
254
+
255
+ CHECK_ARGC(1);
256
+ CHECK_TYPE_ID(argv[0]);
257
+
258
+ status = nc_close(NUM2INT(argv[0]));
259
+
260
+ CHECK_STATUS(status);
261
+
262
+ return LONG2NUM(status);
263
+ }
264
+
265
+ static VALUE
266
+ rb_nc_redef (int argc, VALUE *argv, VALUE mod)
267
+ {
268
+ int status;
269
+
270
+ CHECK_ARGC(1);
271
+ CHECK_TYPE_ID(argv[0]);
272
+
273
+ status = nc_redef(NUM2INT(argv[0]));
274
+
275
+ CHECK_STATUS(status);
276
+
277
+ return LONG2NUM(status);
278
+ }
279
+
280
+ static VALUE
281
+ rb_nc_enddef (int argc, VALUE *argv, VALUE mod)
282
+ {
283
+ int status;
284
+
285
+ CHECK_ARGC(1);
286
+ CHECK_TYPE_ID(argv[0]);
287
+
288
+ status = nc_enddef(NUM2INT(argv[0]));
289
+
290
+ CHECK_STATUS(status);
291
+
292
+ return LONG2NUM(status);
293
+ }
294
+
295
+ static VALUE
296
+ rb_nc_sync (int argc, VALUE *argv, VALUE mod)
297
+ {
298
+ int status;
299
+
300
+ CHECK_ARGC(1);
301
+ CHECK_TYPE_ID(argv[0]);
302
+
303
+ status = nc_sync(NUM2INT(argv[0]));
304
+
305
+ CHECK_STATUS(status);
306
+
307
+ return LONG2NUM(status);
308
+ }
309
+
310
+ static VALUE
311
+ rb_nc_inq_ndims (int argc, VALUE *argv, VALUE mod)
312
+ {
313
+ int status, ndims;
314
+
315
+ CHECK_ARGC(1);
316
+ CHECK_TYPE_ID(argv[0]);
317
+
318
+ status = nc_inq_ndims(NUM2INT(argv[0]), &ndims);
319
+
320
+ CHECK_STATUS(status);
321
+
322
+ return LONG2NUM(ndims);
323
+ }
324
+
325
+ static VALUE
326
+ rb_nc_inq_nvars (int argc, VALUE *argv, VALUE mod)
327
+ {
328
+ int status, nvars;
329
+
330
+ CHECK_ARGC(1);
331
+ CHECK_TYPE_ID(argv[0]);
332
+
333
+ status = nc_inq_nvars(NUM2INT(argv[0]), &nvars);
334
+
335
+ CHECK_STATUS(status);
336
+
337
+ return LONG2NUM(nvars);
338
+ }
339
+
340
+ static VALUE
341
+ rb_nc_inq_natts (int argc, VALUE *argv, VALUE mod)
342
+ {
343
+ int status, natts;
344
+
345
+ CHECK_ARGC(1);
346
+ CHECK_TYPE_ID(argv[0]);
347
+
348
+ status = nc_inq_natts(NUM2INT(argv[0]), &natts);
349
+
350
+ CHECK_STATUS(status);
351
+
352
+ return LONG2NUM(natts);
353
+ }
354
+
355
+ static VALUE
356
+ rb_nc_inq_unlimdim (int argc, VALUE *argv, VALUE mod)
357
+ {
358
+ int status, uldim;
359
+
360
+ CHECK_ARGC(1);
361
+ CHECK_TYPE_ID(argv[0]);
362
+
363
+ status = nc_inq_unlimdim(NUM2INT(argv[0]), &uldim);
364
+
365
+ CHECK_STATUS(status);
366
+
367
+ return LONG2NUM(uldim);
368
+ }
369
+
370
+ static VALUE
371
+ rb_nc_inq_dimid (int argc, VALUE *argv, VALUE mod)
372
+ {
373
+ int status, dimid;
374
+
375
+ CHECK_ARGC(2);
376
+ CHECK_TYPE_ID(argv[0]);
377
+ CHECK_TYPE_STRING(argv[1]);
378
+
379
+ status = nc_inq_dimid(NUM2INT(argv[0]), StringValuePtr(argv[1]), &dimid);
380
+
381
+ return ( status != NC_NOERR ) ? Qnil : LONG2NUM(dimid);
382
+ }
383
+
384
+ static VALUE
385
+ rb_nc_inq_varid (int argc, VALUE *argv, VALUE mod)
386
+ {
387
+ int status, varid;
388
+
389
+ CHECK_ARGC(2);
390
+ CHECK_TYPE_ID(argv[0]);
391
+ CHECK_TYPE_STRING(argv[1]);
392
+
393
+ status = nc_inq_varid(NUM2INT(argv[0]), StringValuePtr(argv[1]), &varid);
394
+
395
+ return ( status != NC_NOERR ) ? Qnil : LONG2NUM(varid);
396
+ }
397
+
398
+ static VALUE
399
+ rb_nc_inq_attid (int argc, VALUE *argv, VALUE mod)
400
+ {
401
+ int status, attid;
402
+
403
+ CHECK_ARGC(3);
404
+ CHECK_TYPE_ID(argv[0]);
405
+ CHECK_TYPE_ID(argv[1]);
406
+ CHECK_TYPE_STRING(argv[2]);
407
+
408
+ status = nc_inq_attid(NUM2INT(argv[0]), NUM2INT(argv[1]),
409
+ StringValuePtr(argv[2]), &attid);
410
+
411
+ return ( status != NC_NOERR ) ? Qnil : LONG2NUM(attid);
412
+ }
413
+
414
+ static VALUE
415
+ rb_nc_inq_dimlen (int argc, VALUE *argv, VALUE mod)
416
+ {
417
+ size_t dimlen;
418
+ int status;
419
+
420
+ CHECK_ARGC(2);
421
+ CHECK_TYPE_ID(argv[0]);
422
+ CHECK_TYPE_ID(argv[1]);
423
+
424
+ status = nc_inq_dimlen(NUM2INT(argv[0]), NUM2INT(argv[1]), &dimlen);
425
+
426
+ CHECK_STATUS(status);
427
+
428
+ return ULONG2NUM(dimlen);
429
+ }
430
+
431
+ static VALUE
432
+ rb_nc_inq_dimname (int argc, VALUE *argv, VALUE mod)
433
+ {
434
+ int status;
435
+ char dimname[NC_MAX_NAME];
436
+
437
+ CHECK_ARGC(2);
438
+ CHECK_TYPE_ID(argv[0]);
439
+ CHECK_TYPE_ID(argv[1]);
440
+
441
+ status = nc_inq_dimname(NUM2INT(argv[0]), NUM2INT(argv[1]), dimname);
442
+
443
+ CHECK_STATUS(status);
444
+
445
+ return rb_str_new2(dimname);
446
+ }
447
+
448
+ static VALUE
449
+ rb_nc_inq_varname (int argc, VALUE *argv, VALUE mod)
450
+ {
451
+ int status;
452
+ char varname[NC_MAX_NAME];
453
+
454
+ CHECK_ARGC(2);
455
+ CHECK_TYPE_ID(argv[0]);
456
+ CHECK_TYPE_ID(argv[1]);
457
+
458
+ status = nc_inq_varname(NUM2INT(argv[0]), NUM2INT(argv[1]), varname);
459
+
460
+ CHECK_STATUS(status);
461
+
462
+ return rb_str_new2(varname);
463
+ }
464
+
465
+ static VALUE
466
+ rb_nc_inq_vartype (int argc, VALUE *argv, VALUE mod)
467
+ {
468
+ int status;
469
+ nc_type type;
470
+
471
+ CHECK_ARGC(2);
472
+ CHECK_TYPE_ID(argv[0]);
473
+ CHECK_TYPE_ID(argv[1]);
474
+
475
+ status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
476
+
477
+ CHECK_STATUS(status);
478
+
479
+ return LONG2NUM(type);
480
+ }
481
+
482
+ static VALUE
483
+ rb_nc_inq_varndims (int argc, VALUE *argv, VALUE mod)
484
+ {
485
+ int status, ndims;
486
+
487
+ CHECK_ARGC(2);
488
+ CHECK_TYPE_ID(argv[0]);
489
+ CHECK_TYPE_ID(argv[1]);
490
+
491
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
492
+
493
+ CHECK_STATUS(status);
494
+
495
+ return LONG2NUM(ndims);
496
+ }
497
+
498
+ static VALUE
499
+ rb_nc_inq_vardimid (int argc, VALUE *argv, VALUE mod)
500
+ {
501
+ volatile VALUE rdim;
502
+ int dimid[NC_MAX_DIMS];
503
+ int ndims;
504
+ int status;
505
+ int i;
506
+
507
+ CHECK_ARGC(2);
508
+ CHECK_TYPE_ID(argv[0]); /* nc_id */
509
+ CHECK_TYPE_ID(argv[1]); /* var_id */
510
+
511
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
512
+
513
+ CHECK_STATUS(status);
514
+
515
+ status = nc_inq_vardimid(NUM2INT(argv[0]), NUM2INT(argv[1]), dimid);
516
+
517
+ CHECK_STATUS(status);
518
+
519
+ rdim = rb_ary_new();
520
+ for (i=0; i<ndims; i++) {
521
+ rb_ary_store(rdim, i, ULONG2NUM(dimid[i]));
522
+ }
523
+
524
+ return rdim;
525
+ }
526
+
527
+ static VALUE
528
+ rb_nc_inq_varnatts (int argc, VALUE *argv, VALUE mod)
529
+ {
530
+ int status, natts;
531
+
532
+ CHECK_ARGC(2);
533
+ CHECK_TYPE_ID(argv[0]);
534
+ CHECK_TYPE_ID(argv[1]);
535
+
536
+ status = nc_inq_varnatts(NUM2INT(argv[0]), NUM2INT(argv[1]), &natts);
537
+
538
+ CHECK_STATUS(status);
539
+
540
+ return LONG2NUM(natts);
541
+ }
542
+
543
+
544
+ static VALUE
545
+ rb_nc_inq_attname (int argc, VALUE *argv, VALUE mod)
546
+ {
547
+ int status;
548
+ char attname[NC_MAX_NAME];
549
+
550
+ CHECK_ARGC(3);
551
+ CHECK_TYPE_ID(argv[0]);
552
+ CHECK_TYPE_ID(argv[1]);
553
+ CHECK_TYPE_ID(argv[2]);
554
+
555
+ status = nc_inq_attname(NUM2INT(argv[0]), NUM2INT(argv[1]),
556
+ NUM2INT(argv[2]), attname);
557
+
558
+ CHECK_STATUS(status);
559
+
560
+ return rb_str_new2(attname);
561
+ }
562
+
563
+ static VALUE
564
+ rb_nc_inq_atttype (int argc, VALUE *argv, VALUE mod)
565
+ {
566
+ int status;
567
+ nc_type type;
568
+
569
+ CHECK_ARGC(3);
570
+ CHECK_TYPE_ID(argv[0]);
571
+ CHECK_TYPE_ID(argv[1]);
572
+ CHECK_TYPE_STRING(argv[2]);
573
+
574
+ status = nc_inq_atttype(NUM2INT(argv[0]), NUM2INT(argv[1]),
575
+ StringValuePtr(argv[2]), &type);
576
+
577
+ CHECK_STATUS(status);
578
+
579
+ return LONG2NUM(type);
580
+ }
581
+
582
+ static VALUE
583
+ rb_nc_inq_attlen (int argc, VALUE *argv, VALUE mod)
584
+ {
585
+ size_t len;
586
+ int status;
587
+
588
+ CHECK_ARGC(3);
589
+ CHECK_TYPE_ID(argv[0]);
590
+ CHECK_TYPE_ID(argv[1]);
591
+ CHECK_TYPE_STRING(argv[2]);
592
+
593
+ status = nc_inq_attlen(NUM2INT(argv[0]), NUM2INT(argv[1]),
594
+ StringValuePtr(argv[2]), &len);
595
+
596
+ CHECK_STATUS(status);
597
+
598
+ return LONG2NUM(len);
599
+ }
600
+
601
+ static VALUE
602
+ rb_nc_def_dim (int argc, VALUE *argv, VALUE mod)
603
+ {
604
+ int status, dimid;
605
+
606
+ CHECK_ARGC(3);
607
+ CHECK_TYPE_ID(argv[0]);
608
+ CHECK_TYPE_STRING(argv[1]);
609
+ CHECK_TYPE_INT(argv[2]);
610
+
611
+ status = nc_def_dim(NUM2INT(argv[0]), StringValuePtr(argv[1]),
612
+ NUM2INT(argv[2]), &dimid);
613
+
614
+ CHECK_STATUS(status);
615
+
616
+ return LONG2NUM(dimid);
617
+ }
618
+
619
+ static VALUE
620
+ rb_nc_def_grp (int argc, VALUE *argv, VALUE mod)
621
+ {
622
+ int status, grpid;
623
+
624
+ CHECK_ARGC(2);
625
+ CHECK_TYPE_ID(argv[0]);
626
+ CHECK_TYPE_STRING(argv[1]);
627
+
628
+ status = nc_def_grp(NUM2INT(argv[0]), StringValuePtr(argv[1]),
629
+ &grpid);
630
+
631
+ CHECK_STATUS(status);
632
+
633
+ return LONG2NUM(grpid);
634
+ }
635
+
636
+ static VALUE
637
+ rb_nc_inq_ncid (int argc, VALUE *argv, VALUE mod)
638
+ {
639
+ int status, ncid;
640
+
641
+ CHECK_ARGC(2);
642
+ CHECK_TYPE_ID(argv[0]);
643
+ CHECK_TYPE_STRING(argv[1]);
644
+
645
+ status = nc_inq_ncid(NUM2INT(argv[0]), StringValuePtr(argv[1]),
646
+ &ncid);
647
+
648
+ CHECK_STATUS(status);
649
+
650
+ return LONG2NUM(ncid);
651
+ }
652
+
653
+
654
+ static VALUE
655
+ rb_nc_inq_grp_full_ncid (int argc, VALUE *argv, VALUE mod)
656
+ {
657
+ int status, ncid;
658
+
659
+ CHECK_ARGC(2);
660
+ CHECK_TYPE_ID(argv[0]);
661
+ CHECK_TYPE_STRING(argv[1]);
662
+
663
+ status = nc_inq_grp_full_ncid(NUM2INT(argv[0]), StringValuePtr(argv[1]),
664
+ &ncid);
665
+
666
+ CHECK_STATUS(status);
667
+
668
+ return LONG2NUM(ncid);
669
+ }
670
+
671
+
672
+ static VALUE
673
+ rb_nc_inq_grp_ncid (int argc, VALUE *argv, VALUE mod)
674
+ {
675
+ int status, ncid;
676
+
677
+ CHECK_ARGC(2);
678
+ CHECK_TYPE_ID(argv[0]);
679
+ CHECK_TYPE_STRING(argv[1]);
680
+
681
+ status = nc_inq_grp_ncid(NUM2INT(argv[0]), StringValuePtr(argv[1]),
682
+ &ncid);
683
+
684
+ CHECK_STATUS(status);
685
+
686
+ return LONG2NUM(ncid);
687
+ }
688
+
689
+ static VALUE
690
+ rb_nc_inq_grp_parent (int argc, VALUE *argv, VALUE mod)
691
+ {
692
+ int parent;
693
+ int status;
694
+
695
+ CHECK_ARGC(1);
696
+ CHECK_TYPE_ID(argv[0]);
697
+
698
+ status = nc_inq_grp_parent(NUM2INT(argv[0]), &parent);
699
+
700
+ CHECK_STATUS(status);
701
+
702
+ return ULONG2NUM(parent);
703
+ }
704
+
705
+ static VALUE
706
+ rb_nc_inq_grpname (int argc, VALUE *argv, VALUE mod)
707
+ {
708
+ int status;
709
+ char grpname[NC_MAX_NAME];
710
+
711
+ CHECK_ARGC(1);
712
+ CHECK_TYPE_ID(argv[0]);
713
+
714
+ status = nc_inq_grpname(NUM2INT(argv[0]), grpname);
715
+
716
+ CHECK_STATUS(status);
717
+
718
+ return rb_str_new2(grpname);
719
+ }
720
+
721
+ static VALUE
722
+ rb_nc_inq_grpname_full (int argc, VALUE *argv, VALUE mod)
723
+ {
724
+ int status;
725
+ size_t len;
726
+ char grpname[NC_MAX_NAME];
727
+
728
+ CHECK_ARGC(1);
729
+ CHECK_TYPE_ID(argv[0]);
730
+
731
+ status = nc_inq_grpname_full(NUM2INT(argv[0]), &len, grpname);
732
+
733
+ CHECK_STATUS(status);
734
+
735
+ return rb_str_new2(grpname);
736
+ }
737
+
738
+ static VALUE
739
+ rb_nc_inq_grpname_len (int argc, VALUE *argv, VALUE mod)
740
+ {
741
+ int status;
742
+ size_t len;
743
+
744
+ CHECK_ARGC(2);
745
+ CHECK_TYPE_ID(argv[0]);
746
+ CHECK_TYPE_STRING(argv[1]);
747
+
748
+ status = nc_inq_grpname_len(NUM2INT(argv[0]), &len);
749
+
750
+ CHECK_STATUS(status);
751
+
752
+ return LONG2NUM(len);
753
+ }
754
+
755
+ static VALUE
756
+ rb_nc_inq_grps (int argc, VALUE *argv, VALUE mod)
757
+ {
758
+ volatile VALUE rgrps;
759
+ int grps[NC_MAX_DIMS];
760
+ int i, ngrps;
761
+ int status;
762
+
763
+ CHECK_ARGC(1);
764
+ CHECK_TYPE_ID(argv[0]); /* nc_id */
765
+
766
+ status = nc_inq_grps(NUM2INT(argv[0]),
767
+ &ngrps,
768
+ grps);
769
+
770
+ CHECK_STATUS(status);
771
+
772
+ rgrps = rb_ary_new();
773
+ for (i=0; i<ngrps; i++) {
774
+ rb_ary_store(rgrps, i, ULONG2NUM(grps[i]));
775
+ }
776
+
777
+ return rgrps;
778
+ }
779
+
780
+
781
+ static VALUE
782
+ rb_nc_inq_dimids (int argc, VALUE *argv, VALUE mod)
783
+ {
784
+ volatile VALUE rdimids;
785
+ int dimids[NC_MAX_DIMS];
786
+ int i, ndims;
787
+ int status;
788
+
789
+ CHECK_ARGC(2);
790
+ CHECK_TYPE_ID(argv[0]); /* nc_id */
791
+ CHECK_TYPE_ID(argv[1]); /* nc_id */
792
+
793
+ status = nc_inq_dimids(NUM2INT(argv[0]),
794
+ &ndims,
795
+ dimids,
796
+ NUM2INT(argv[1]));
797
+
798
+ CHECK_STATUS(status);
799
+
800
+ rdimids = rb_ary_new();
801
+ for (i=0; i<ndims; i++) {
802
+ rb_ary_store(rdimids, i, ULONG2NUM(dimids[i]));
803
+ }
804
+
805
+ return rdimids;
806
+ }
807
+
808
+ static VALUE
809
+ rb_nc_inq_varids (int argc, VALUE *argv, VALUE mod)
810
+ {
811
+ volatile VALUE rvarids;
812
+ int varids[NC_MAX_DIMS];
813
+ int i, nvars;
814
+ int status;
815
+
816
+ CHECK_ARGC(1);
817
+ CHECK_TYPE_ID(argv[0]); /* nc_id */
818
+
819
+ status = nc_inq_varids(NUM2INT(argv[0]),
820
+ &nvars,
821
+ varids);
822
+
823
+ CHECK_STATUS(status);
824
+
825
+ rvarids = rb_ary_new();
826
+ for (i=0; i<nvars; i++) {
827
+ rb_ary_store(rvarids, i, ULONG2NUM(varids[i]));
828
+ }
829
+
830
+ return rvarids;
831
+ }
832
+
833
+ static VALUE
834
+ rb_nc_inq_typeids (int argc, VALUE *argv, VALUE mod)
835
+ {
836
+ volatile VALUE rtypeids;
837
+ int typeids[NC_MAX_DIMS];
838
+ int i, ntypes;
839
+ int status;
840
+
841
+ CHECK_ARGC(1);
842
+ CHECK_TYPE_ID(argv[0]); /* nc_id */
843
+
844
+ status = nc_inq_typeids(NUM2INT(argv[0]),
845
+ &ntypes,
846
+ typeids);
847
+
848
+ CHECK_STATUS(status);
849
+
850
+ rtypeids = rb_ary_new();
851
+ for (i=0; i<ntypes; i++) {
852
+ rb_ary_store(rtypeids, i, ULONG2NUM(typeids[i]));
853
+ }
854
+
855
+ return rtypeids;
856
+ }
857
+
858
+ static VALUE
859
+ rb_nc_show_metadata (int argc, VALUE *argv, VALUE mod)
860
+ {
861
+ int status;
862
+
863
+ CHECK_ARGC(1);
864
+ CHECK_TYPE_ID(argv[0]); /* nc_id */
865
+
866
+ status = nc_show_metadata(NUM2INT(argv[0]));
867
+
868
+ CHECK_STATUS(status);
869
+
870
+ return Qnil;
871
+ }
872
+
873
+ static VALUE
874
+ rb_nc_def_var (int argc, VALUE *argv, VALUE mod)
875
+ {
876
+ volatile VALUE vdim;
877
+ int status, varid;
878
+ int ndims;
879
+ int dimids[NC_MAX_DIMS];
880
+ int i;
881
+
882
+ CHECK_ARGC(4);
883
+ CHECK_TYPE_ID(argv[0]);
884
+ CHECK_TYPE_STRING(argv[1]);
885
+ CHECK_TYPE_INT(argv[2]);
886
+ CHECK_TYPE_ARRAY(argv[3]);
887
+
888
+ vdim = argv[3];
889
+
890
+ ndims = (int) RARRAY_LEN(vdim);
891
+ for (i=0; i<ndims; i++) {
892
+ dimids[i] = NUM2INT(RARRAY_PTR(vdim)[i]);
893
+ }
894
+
895
+ status = nc_def_var(NUM2INT(argv[0]), StringValuePtr(argv[1]),
896
+ NUM2INT(argv[2]), ndims, dimids, &varid);
897
+
898
+ CHECK_STATUS(status);
899
+
900
+ return LONG2NUM(varid);
901
+ }
902
+
903
+ static VALUE
904
+ rb_nc_def_var_chunking (int argc, VALUE *argv, VALUE mod)
905
+ {
906
+ volatile VALUE vdim;
907
+ int status;
908
+ int ndims;
909
+ size_t chunksizes[NC_MAX_DIMS];
910
+ int i;
911
+
912
+ CHECK_ARGC(4);
913
+ CHECK_TYPE_ID(argv[0]);
914
+ CHECK_TYPE_ID(argv[1]);
915
+ CHECK_TYPE_INT(argv[2]);
916
+ CHECK_TYPE_ARRAY(argv[3]);
917
+
918
+ vdim = argv[3];
919
+
920
+ ndims = (int) RARRAY_LEN(vdim);
921
+ for (i=0; i<ndims; i++) {
922
+ chunksizes[i] = NUM2INT(RARRAY_PTR(vdim)[i]);
923
+ }
924
+
925
+ status = nc_def_var_chunking(NUM2INT(argv[0]),
926
+ NUM2INT(argv[1]),
927
+ NUM2INT(argv[2]),
928
+ chunksizes);
929
+
930
+ CHECK_STATUS(status);
931
+
932
+ return Qnil;
933
+ }
934
+
935
+ static VALUE
936
+ rb_nc_inq_var_chunking (int argc, VALUE *argv, VALUE mod)
937
+ {
938
+ volatile VALUE retval;
939
+ volatile VALUE rchunksize;
940
+ int storage;
941
+ size_t chunksizes[NC_MAX_DIMS];
942
+ int i, ndims;
943
+ int status;
944
+
945
+ CHECK_ARGC(2);
946
+ CHECK_TYPE_ID(argv[0]); /* nc_id */
947
+ CHECK_TYPE_ID(argv[1]); /* var_id */
948
+
949
+ status = nc_inq_var_chunking(NUM2INT(argv[0]),
950
+ NUM2INT(argv[1]),
951
+ &storage,
952
+ chunksizes);
953
+
954
+ CHECK_STATUS(status);
955
+
956
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
957
+
958
+ CHECK_STATUS(status);
959
+
960
+ rchunksize = rb_ary_new();
961
+ for (i=0; i<ndims; i++) {
962
+ rb_ary_store(rchunksize, i, ULONG2NUM(chunksizes[i]));
963
+ }
964
+
965
+ retval = rb_ary_new();
966
+ rb_ary_store(retval, 0, ULONG2NUM(storage));
967
+ rb_ary_store(retval, 1, rchunksize);
968
+
969
+ return retval;
970
+ }
971
+
972
+ static VALUE
973
+ rb_nc_def_var_deflate (int argc, VALUE *argv, VALUE mod)
974
+ {
975
+ int status;
976
+
977
+ CHECK_ARGC(5);
978
+ CHECK_TYPE_ID(argv[0]);
979
+ CHECK_TYPE_ID(argv[1]);
980
+ CHECK_TYPE_INT(argv[2]);
981
+ CHECK_TYPE_INT(argv[3]);
982
+ CHECK_TYPE_INT(argv[4]);
983
+
984
+ status = nc_def_var_deflate(NUM2INT(argv[0]), NUM2INT(argv[1]),
985
+ NUM2INT(argv[2]), NUM2INT(argv[3]), NUM2INT(argv[4]));
986
+
987
+
988
+ CHECK_STATUS(status);
989
+
990
+ return Qnil;
991
+ }
992
+
993
+ static VALUE
994
+ rb_nc_inq_var_deflate (int argc, VALUE *argv, VALUE mod)
995
+ {
996
+ volatile VALUE retval;
997
+ int shuffle, deflate, deflate_level;
998
+ int status;
999
+
1000
+ CHECK_ARGC(2);
1001
+ CHECK_TYPE_ID(argv[0]); /* nc_id */
1002
+ CHECK_TYPE_ID(argv[1]); /* var_id */
1003
+
1004
+ status = nc_inq_var_deflate(NUM2INT(argv[0]), NUM2INT(argv[1]),
1005
+ &shuffle, &deflate, &deflate_level);
1006
+
1007
+ CHECK_STATUS(status);
1008
+
1009
+ retval = rb_ary_new();
1010
+ rb_ary_store(retval, 0, ULONG2NUM(shuffle));
1011
+ rb_ary_store(retval, 1, ULONG2NUM(deflate));
1012
+ rb_ary_store(retval, 2, ULONG2NUM(deflate_level));
1013
+
1014
+ return retval;
1015
+ }
1016
+
1017
+
1018
+ static VALUE
1019
+ rb_nc_del_att (int argc, VALUE *argv, VALUE mod)
1020
+ {
1021
+ int status;
1022
+
1023
+ CHECK_ARGC(3);
1024
+ CHECK_TYPE_ID(argv[0]);
1025
+ CHECK_TYPE_ID(argv[1]);
1026
+ CHECK_TYPE_STRING(argv[2]);
1027
+
1028
+ status = nc_del_att(NUM2INT(argv[0]), NUM2INT(argv[1]), StringValuePtr(argv[2]));
1029
+
1030
+ CHECK_STATUS(status);
1031
+
1032
+ return LONG2NUM(status);
1033
+ }
1034
+
1035
+ static int
1036
+ nc_get_att_numeric (int ncid, int varid, const char name[],
1037
+ nc_type type, void *value)
1038
+ {
1039
+ switch (type) {
1040
+ case NC_BYTE:
1041
+ return nc_get_att_schar(ncid, varid, name, value);
1042
+ case NC_UBYTE:
1043
+ return nc_get_att_ubyte(ncid, varid, name, value);
1044
+ case NC_CHAR:
1045
+ return nc_get_att_uchar(ncid, varid, name, value);
1046
+ case NC_SHORT:
1047
+ return nc_get_att_short(ncid, varid, name, value);
1048
+ case NC_USHORT:
1049
+ return nc_get_att_ushort(ncid, varid, name, value);
1050
+ case NC_INT:
1051
+ return nc_get_att_int(ncid, varid, name, value);
1052
+ case NC_UINT:
1053
+ return nc_get_att_uint(ncid, varid, name, value);
1054
+ case NC_INT64:
1055
+ return nc_get_att_longlong(ncid, varid, name, value);
1056
+ case NC_UINT64:
1057
+ return nc_get_att_ulonglong(ncid, varid, name, value);
1058
+ case NC_FLOAT:
1059
+ return nc_get_att_float(ncid, varid, name, value);
1060
+ case NC_DOUBLE:
1061
+ return nc_get_att_double(ncid, varid, name, value);
1062
+ default:
1063
+ return NC_EBADTYPE;
1064
+ }
1065
+ }
1066
+
1067
+ static int
1068
+ nc_put_att_numeric (int ncid, int varid, const char name[],
1069
+ nc_type type, nc_type xtype, size_t len, void *value)
1070
+ {
1071
+ switch (type) {
1072
+ case NC_BYTE:
1073
+ return nc_put_att_schar(ncid, varid, name, xtype, len, value);
1074
+ case NC_UBYTE:
1075
+ return nc_put_att_ubyte(ncid, varid, name, xtype, len, value);
1076
+ case NC_CHAR:
1077
+ return nc_put_att_uchar(ncid, varid, name, xtype, len, value);
1078
+ case NC_SHORT:
1079
+ return nc_put_att_short(ncid, varid, name, xtype, len, value);
1080
+ case NC_USHORT:
1081
+ return nc_put_att_ushort(ncid, varid, name, xtype, len, value);
1082
+ case NC_INT:
1083
+ return nc_put_att_int(ncid, varid, name, xtype, len, value);
1084
+ case NC_UINT:
1085
+ return nc_put_att_uint(ncid, varid, name, xtype, len, value);
1086
+ case NC_INT64:
1087
+ return nc_put_att_longlong(ncid, varid, name, xtype, len, value);
1088
+ case NC_UINT64:
1089
+ return nc_put_att_longlong(ncid, varid, name, xtype, len, value);
1090
+ case NC_FLOAT:
1091
+ return nc_put_att_float(ncid, varid, name, xtype, len, value);
1092
+ case NC_DOUBLE:
1093
+ return nc_put_att_double(ncid, varid, name, xtype, len, value);
1094
+ default:
1095
+ return NC_EBADTYPE;
1096
+ }
1097
+ }
1098
+
1099
+ static VALUE
1100
+ rb_nc_get_att (int argc, VALUE *argv, VALUE mod)
1101
+ {
1102
+ nc_type type;
1103
+ size_t len;
1104
+ int status;
1105
+
1106
+ CHECK_TYPE_ID(argv[0]);
1107
+ CHECK_TYPE_ID(argv[1]);
1108
+ CHECK_TYPE_STRING(argv[2]);
1109
+
1110
+ status = nc_inq_atttype(NUM2INT(argv[0]), NUM2INT(argv[1]),
1111
+ StringValuePtr(argv[2]), &type);
1112
+
1113
+ if ( status != NC_NOERR) {
1114
+ return Qnil;
1115
+ }
1116
+
1117
+ status = nc_inq_attlen(NUM2INT(argv[0]), NUM2INT(argv[1]),
1118
+ StringValuePtr(argv[2]), &len);
1119
+ CHECK_STATUS(status);
1120
+
1121
+ if ( argc == 3 ) {
1122
+
1123
+ if ( type == NC_CHAR ) {
1124
+ volatile VALUE text = rb_str_new(NULL, len);
1125
+ status = nc_get_att_text(NUM2INT(argv[0]), NUM2INT(argv[1]),
1126
+ StringValuePtr(argv[2]),
1127
+ StringValuePtr(text));
1128
+ return text;
1129
+ }
1130
+ else if ( len == 1 ) {
1131
+ switch ( type ) {
1132
+ case NC_BYTE: {
1133
+ int8_t val;
1134
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1135
+ StringValuePtr(argv[2]), type, &val);
1136
+ CHECK_STATUS(status);
1137
+ return INT2NUM(val);
1138
+ }
1139
+ case NC_UBYTE: {
1140
+ uint8_t val;
1141
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1142
+ StringValuePtr(argv[2]), type, &val);
1143
+ CHECK_STATUS(status);
1144
+ return INT2NUM(val);
1145
+ }
1146
+ case NC_SHORT: {
1147
+ int16_t val;
1148
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1149
+ StringValuePtr(argv[2]), type, &val);
1150
+ CHECK_STATUS(status);
1151
+ return INT2NUM(val);
1152
+ }
1153
+ case NC_USHORT: {
1154
+ uint16_t val;
1155
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1156
+ StringValuePtr(argv[2]), type, &val);
1157
+ CHECK_STATUS(status);
1158
+ return INT2NUM(val);
1159
+ }
1160
+ case NC_INT: {
1161
+ int32_t val;
1162
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1163
+ StringValuePtr(argv[2]), type, &val);
1164
+ CHECK_STATUS(status);
1165
+ return INT2NUM(val);
1166
+ }
1167
+ case NC_UINT: {
1168
+ uint32_t val;
1169
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1170
+ StringValuePtr(argv[2]), type, &val);
1171
+ CHECK_STATUS(status);
1172
+ return INT2NUM(val);
1173
+ }
1174
+ case NC_INT64: {
1175
+ int64_t val;
1176
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1177
+ StringValuePtr(argv[2]), type, &val);
1178
+ CHECK_STATUS(status);
1179
+ return INT2NUM(val);
1180
+ }
1181
+ case NC_UINT64: {
1182
+ uint64_t val;
1183
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1184
+ StringValuePtr(argv[2]), type, &val);
1185
+ CHECK_STATUS(status);
1186
+ return INT2NUM(val);
1187
+ }
1188
+ case NC_FLOAT: {
1189
+ float32_t val;
1190
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1191
+ StringValuePtr(argv[2]), type, &val);
1192
+ CHECK_STATUS(status);
1193
+ return rb_float_new(val);
1194
+ }
1195
+ case NC_DOUBLE: {
1196
+ float64_t val;
1197
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1198
+ StringValuePtr(argv[2]), type, &val);
1199
+ CHECK_STATUS(status);
1200
+ return rb_float_new(val);
1201
+ }
1202
+ default:
1203
+ rb_raise(rb_eRuntimeError, "unknown att nc_type");
1204
+ }
1205
+ }
1206
+ else {
1207
+ volatile VALUE out;
1208
+ CArray *ca;
1209
+ int8_t data_type;
1210
+ ca_size_t dim0 = len;
1211
+
1212
+ data_type = rb_nc_typemap (type);
1213
+ out = rb_carray_new(data_type, 1, &dim0, 0, NULL);
1214
+
1215
+ Data_Get_Struct(out, CArray, ca);
1216
+
1217
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1218
+ StringValuePtr(argv[2]), type, ca->ptr);
1219
+
1220
+ CHECK_STATUS(status);
1221
+
1222
+ return rb_nc_output(out);
1223
+ }
1224
+ }
1225
+ else {
1226
+
1227
+ CHECK_ARGC(4);
1228
+
1229
+ if ( type == NC_CHAR ) {
1230
+ volatile VALUE text = argv[3];
1231
+ rb_str_resize(text, len);
1232
+ status = nc_get_att_text(NUM2INT(argv[0]), NUM2INT(argv[1]),
1233
+ StringValuePtr(argv[2]),
1234
+ StringValuePtr(text));
1235
+ }
1236
+ else {
1237
+ volatile VALUE data = rb_ca_wrap_writable(argv[3], Qnil);
1238
+ CArray *ca;
1239
+ nc_type xtype;
1240
+ Data_Get_Struct(data, CArray, ca);
1241
+ xtype = rb_nc_rtypemap(ca->data_type);
1242
+ ca_attach(ca);
1243
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1244
+ StringValuePtr(argv[2]), type, ca->ptr);
1245
+ ca_sync(ca);
1246
+ ca_detach(ca);
1247
+ }
1248
+
1249
+ CHECK_STATUS(status);
1250
+
1251
+ return LONG2NUM(status);
1252
+ }
1253
+ }
1254
+
1255
+ static VALUE
1256
+ rb_nc_put_att (int argc, VALUE *argv, VALUE mod)
1257
+ {
1258
+ int status;
1259
+
1260
+ CHECK_ARGC(4);
1261
+
1262
+ if ( TYPE(argv[3]) == T_STRING ) {
1263
+ volatile VALUE text = argv[3];
1264
+ status = nc_put_att_text(NUM2INT(argv[0]), NUM2INT(argv[1]),
1265
+ StringValuePtr(argv[2]),
1266
+ strlen(StringValuePtr(text)), StringValuePtr(text));
1267
+ }
1268
+ else if ( rb_obj_is_kind_of(argv[3], rb_cInteger) ) {
1269
+ int32_t val = NUM2INT(argv[3]);
1270
+ status = nc_put_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1271
+ StringValuePtr(argv[2]),
1272
+ NC_INT, NC_INT, 1, &val);
1273
+ }
1274
+ else if ( rb_obj_is_kind_of(argv[3], rb_cFloat) ) {
1275
+ float64_t val = NUM2DBL(argv[3]);
1276
+ status = nc_put_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1277
+ StringValuePtr(argv[2]),
1278
+ NC_DOUBLE, NC_DOUBLE, 1, &val);
1279
+ }
1280
+ else {
1281
+ volatile VALUE data = rb_ca_wrap_readonly(argv[3], Qnil);
1282
+ CArray *ca;
1283
+ nc_type xtype;
1284
+ Data_Get_Struct(data, CArray, ca);
1285
+ xtype = rb_nc_rtypemap(ca->data_type);
1286
+ ca_attach(ca);
1287
+ status = nc_put_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1288
+ StringValuePtr(argv[2]),
1289
+ xtype, xtype, ca->elements, ca->ptr);
1290
+ ca_detach(ca);
1291
+ }
1292
+
1293
+ CHECK_STATUS(status);
1294
+
1295
+ return LONG2NUM(status);
1296
+ }
1297
+
1298
+
1299
+ static int
1300
+ nc_get_var1_numeric (int ncid, int varid,
1301
+ nc_type type, size_t index[], void *value)
1302
+ {
1303
+ switch (type) {
1304
+ case NC_BYTE:
1305
+ return nc_get_var1_schar(ncid, varid, index, value);
1306
+ case NC_UBYTE:
1307
+ return nc_get_var1_ubyte(ncid, varid, index, value);
1308
+ case NC_CHAR:
1309
+ return nc_get_var1_uchar(ncid, varid, index, value);
1310
+ case NC_SHORT:
1311
+ return nc_get_var1_short(ncid, varid, index, value);
1312
+ case NC_USHORT:
1313
+ return nc_get_var1_ushort(ncid, varid, index, value);
1314
+ case NC_INT:
1315
+ return nc_get_var1_int(ncid, varid, index, value);
1316
+ case NC_UINT:
1317
+ return nc_get_var1_uint(ncid, varid, index, value);
1318
+ case NC_INT64:
1319
+ return nc_get_var1_longlong(ncid, varid, index, value);
1320
+ case NC_UINT64:
1321
+ return nc_get_var1_ulonglong(ncid, varid, index, value);
1322
+ case NC_FLOAT:
1323
+ return nc_get_var1_float(ncid, varid, index, value);
1324
+ case NC_DOUBLE:
1325
+ return nc_get_var1_double(ncid, varid, index, value);
1326
+ default:
1327
+ return NC_EBADTYPE;
1328
+ }
1329
+ }
1330
+
1331
+ static int
1332
+ nc_put_var1_numeric (int ncid, int varid,
1333
+ nc_type type, size_t index[], void *value)
1334
+ {
1335
+ switch (type) {
1336
+ case NC_BYTE:
1337
+ return nc_put_var1_schar(ncid, varid, index, value);
1338
+ case NC_UBYTE:
1339
+ return nc_put_var1_ubyte(ncid, varid, index, value);
1340
+ case NC_CHAR:
1341
+ return nc_put_var1_uchar(ncid, varid, index, value);
1342
+ case NC_SHORT:
1343
+ return nc_put_var1_short(ncid, varid, index, value);
1344
+ case NC_USHORT:
1345
+ return nc_put_var1_ushort(ncid, varid, index, value);
1346
+ case NC_INT:
1347
+ return nc_put_var1_int(ncid, varid, index, value);
1348
+ case NC_UINT:
1349
+ return nc_put_var1_uint(ncid, varid, index, value);
1350
+ case NC_INT64:
1351
+ return nc_put_var1_longlong(ncid, varid, index, value);
1352
+ case NC_UINT64:
1353
+ return nc_put_var1_ulonglong(ncid, varid, index, value);
1354
+ case NC_FLOAT:
1355
+ return nc_put_var1_float(ncid, varid, index, value);
1356
+ case NC_DOUBLE:
1357
+ return nc_put_var1_double(ncid, varid, index, value);
1358
+ default:
1359
+ return NC_EBADTYPE;
1360
+ }
1361
+ }
1362
+
1363
+ static int
1364
+ nc_get_var_numeric (int ncid, int varid, nc_type type, void *value)
1365
+ {
1366
+ switch (type) {
1367
+ case NC_BYTE:
1368
+ return nc_get_var_schar(ncid, varid, value);
1369
+ case NC_UBYTE:
1370
+ return nc_get_var_ubyte(ncid, varid, value);
1371
+ case NC_CHAR:
1372
+ return nc_get_var_uchar(ncid, varid, value);
1373
+ case NC_SHORT:
1374
+ return nc_get_var_short(ncid, varid, value);
1375
+ case NC_USHORT:
1376
+ return nc_get_var_ushort(ncid, varid, value);
1377
+ case NC_INT:
1378
+ return nc_get_var_int(ncid, varid, value);
1379
+ case NC_UINT:
1380
+ return nc_get_var_uint(ncid, varid, value);
1381
+ case NC_INT64:
1382
+ return nc_get_var_longlong(ncid, varid, value);
1383
+ case NC_UINT64:
1384
+ return nc_get_var_ulonglong(ncid, varid, value);
1385
+ case NC_FLOAT:
1386
+ return nc_get_var_float(ncid, varid, value);
1387
+ case NC_DOUBLE:
1388
+ return nc_get_var_double(ncid, varid, value);
1389
+ default:
1390
+ return NC_EBADTYPE;
1391
+ }
1392
+ }
1393
+
1394
+ static int
1395
+ nc_put_var_numeric (int ncid, int varid, nc_type type, void *value)
1396
+ {
1397
+ switch (type) {
1398
+ case NC_BYTE:
1399
+ return nc_put_var_schar(ncid, varid, value);
1400
+ case NC_UBYTE:
1401
+ return nc_put_var_ubyte(ncid, varid, value);
1402
+ case NC_CHAR:
1403
+ return nc_put_var_uchar(ncid, varid, value);
1404
+ case NC_SHORT:
1405
+ return nc_put_var_short(ncid, varid, value);
1406
+ case NC_USHORT:
1407
+ return nc_put_var_ushort(ncid, varid, value);
1408
+ case NC_INT:
1409
+ return nc_put_var_int(ncid, varid, value);
1410
+ case NC_UINT:
1411
+ return nc_put_var_uint(ncid, varid, value);
1412
+ case NC_INT64:
1413
+ return nc_put_var_longlong(ncid, varid, value);
1414
+ case NC_UINT64:
1415
+ return nc_put_var_ulonglong(ncid, varid, value);
1416
+ case NC_FLOAT:
1417
+ return nc_put_var_float(ncid, varid, value);
1418
+ case NC_DOUBLE:
1419
+ return nc_put_var_double(ncid, varid, value);
1420
+ default:
1421
+ return NC_EBADTYPE;
1422
+ }
1423
+ }
1424
+
1425
+ static int
1426
+ nc_get_vara_numeric (int ncid, int varid, nc_type type,
1427
+ const size_t start[], const size_t count[],
1428
+ void *value)
1429
+ {
1430
+ switch (type) {
1431
+ case NC_BYTE:
1432
+ return nc_get_vara_schar(ncid, varid, start, count, value);
1433
+ case NC_UBYTE:
1434
+ return nc_get_vara_ubyte(ncid, varid, start, count, value);
1435
+ case NC_CHAR:
1436
+ return nc_get_vara_uchar(ncid, varid, start, count, value);
1437
+ case NC_SHORT:
1438
+ return nc_get_vara_short(ncid, varid, start, count, value);
1439
+ case NC_USHORT:
1440
+ return nc_get_vara_ushort(ncid, varid, start, count, value);
1441
+ case NC_INT:
1442
+ return nc_get_vara_int(ncid, varid, start, count, value);
1443
+ case NC_UINT:
1444
+ return nc_get_vara_uint(ncid, varid, start, count, value);
1445
+ case NC_INT64:
1446
+ return nc_get_vara_longlong(ncid, varid, start, count, value);
1447
+ case NC_UINT64:
1448
+ return nc_get_vara_ulonglong(ncid, varid, start, count, value);
1449
+ case NC_FLOAT:
1450
+ return nc_get_vara_float(ncid, varid, start, count, value);
1451
+ case NC_DOUBLE:
1452
+ return nc_get_vara_double(ncid, varid, start, count, value);
1453
+ default:
1454
+ return NC_EBADTYPE;
1455
+ }
1456
+ }
1457
+
1458
+ static int
1459
+ nc_put_vara_numeric (int ncid, int varid, nc_type type,
1460
+ const size_t start[], const size_t count[],
1461
+ void *value)
1462
+ {
1463
+ switch (type) {
1464
+ case NC_BYTE:
1465
+ return nc_put_vara_schar(ncid, varid, start, count, value);
1466
+ case NC_UBYTE:
1467
+ return nc_put_vara_ubyte(ncid, varid, start, count, value);
1468
+ case NC_CHAR:
1469
+ return nc_put_vara_uchar(ncid, varid, start, count, value);
1470
+ case NC_SHORT:
1471
+ return nc_put_vara_short(ncid, varid, start, count, value);
1472
+ case NC_USHORT:
1473
+ return nc_put_vara_ushort(ncid, varid, start, count, value);
1474
+ case NC_INT:
1475
+ return nc_put_vara_int(ncid, varid, start, count, value);
1476
+ case NC_UINT:
1477
+ return nc_put_vara_uint(ncid, varid, start, count, value);
1478
+ case NC_INT64:
1479
+ return nc_put_vara_longlong(ncid, varid, start, count, value);
1480
+ case NC_UINT64:
1481
+ return nc_put_vara_ulonglong(ncid, varid, start, count, value);
1482
+ case NC_FLOAT:
1483
+ return nc_put_vara_float(ncid, varid, start, count, value);
1484
+ case NC_DOUBLE:
1485
+ return nc_put_vara_double(ncid, varid, start, count, value);
1486
+ default:
1487
+ return NC_EBADTYPE;
1488
+ }
1489
+ }
1490
+
1491
+ static int
1492
+ nc_get_vars_numeric (int ncid, int varid, nc_type type,
1493
+ const size_t start[], const size_t count[],
1494
+ const ptrdiff_t stride[],
1495
+ void *value)
1496
+ {
1497
+ switch (type) {
1498
+ case NC_BYTE:
1499
+ return nc_get_vars_schar(ncid, varid, start, count, stride, value);
1500
+ case NC_UBYTE:
1501
+ return nc_get_vars_ubyte(ncid, varid, start, count, stride, value);
1502
+ case NC_CHAR:
1503
+ return nc_get_vars_uchar(ncid, varid, start, count, stride, value);
1504
+ case NC_SHORT:
1505
+ return nc_get_vars_short(ncid, varid, start, count, stride, value);
1506
+ case NC_USHORT:
1507
+ return nc_get_vars_ushort(ncid, varid, start, count, stride, value);
1508
+ case NC_INT:
1509
+ return nc_get_vars_int(ncid, varid, start, count, stride, value);
1510
+ case NC_UINT:
1511
+ return nc_get_vars_uint(ncid, varid, start, count, stride, value);
1512
+ case NC_INT64:
1513
+ return nc_get_vars_longlong(ncid, varid, start, count, stride, value);
1514
+ case NC_UINT64:
1515
+ return nc_get_vars_ulonglong(ncid, varid, start, count, stride, value);
1516
+ case NC_FLOAT:
1517
+ return nc_get_vars_float(ncid, varid, start, count, stride, value);
1518
+ case NC_DOUBLE:
1519
+ return nc_get_vars_double(ncid, varid, start, count, stride, value);
1520
+ default:
1521
+ return NC_EBADTYPE;
1522
+ }
1523
+ }
1524
+
1525
+ static int
1526
+ nc_put_vars_numeric (int ncid, int varid, nc_type type,
1527
+ const size_t start[], const size_t count[],
1528
+ const ptrdiff_t stride[],
1529
+ void *value)
1530
+ {
1531
+ switch (type) {
1532
+ case NC_BYTE:
1533
+ return nc_put_vars_schar(ncid, varid, start, count, stride, value);
1534
+ case NC_UBYTE:
1535
+ return nc_put_vars_ubyte(ncid, varid, start, count, stride, value);
1536
+ case NC_CHAR:
1537
+ return nc_put_vars_uchar(ncid, varid, start, count, stride, value);
1538
+ case NC_SHORT:
1539
+ return nc_put_vars_short(ncid, varid, start, count, stride, value);
1540
+ case NC_USHORT:
1541
+ return nc_put_vars_ushort(ncid, varid, start, count, stride, value);
1542
+ case NC_INT:
1543
+ return nc_put_vars_int(ncid, varid, start, count, stride, value);
1544
+ case NC_UINT:
1545
+ return nc_put_vars_uint(ncid, varid, start, count, stride, value);
1546
+ case NC_INT64:
1547
+ return nc_put_vars_longlong(ncid, varid, start, count, stride, value);
1548
+ case NC_UINT64:
1549
+ return nc_put_vars_ulonglong(ncid, varid, start, count, stride, value);
1550
+ case NC_FLOAT:
1551
+ return nc_put_vars_float(ncid, varid, start, count, stride, value);
1552
+ case NC_DOUBLE:
1553
+ return nc_put_vars_double(ncid, varid, start, count, stride, value);
1554
+ default:
1555
+ return NC_EBADTYPE;
1556
+ }
1557
+ }
1558
+
1559
+ static int
1560
+ nc_get_varm_numeric (int ncid, int varid, nc_type type,
1561
+ const size_t start[], const size_t count[],
1562
+ const ptrdiff_t stride[], const ptrdiff_t imap[],
1563
+ void *value)
1564
+ {
1565
+ switch (type) {
1566
+ case NC_BYTE:
1567
+ return nc_get_varm_schar(ncid, varid, start, count, stride, imap, value);
1568
+ case NC_UBYTE:
1569
+ return nc_get_varm_ubyte(ncid, varid, start, count, stride, imap, value);
1570
+ case NC_CHAR:
1571
+ return nc_get_varm_uchar(ncid, varid, start, count, stride, imap, value);
1572
+ case NC_SHORT:
1573
+ return nc_get_varm_short(ncid, varid, start, count, stride, imap, value);
1574
+ case NC_USHORT:
1575
+ return nc_get_varm_ushort(ncid, varid, start, count, stride, imap, value);
1576
+ case NC_INT:
1577
+ return nc_get_varm_int(ncid, varid, start, count, stride, imap, value);
1578
+ case NC_UINT:
1579
+ return nc_get_varm_uint(ncid, varid, start, count, stride, imap, value);
1580
+ case NC_INT64:
1581
+ return nc_get_varm_longlong(ncid, varid, start, count, stride, imap, value);
1582
+ case NC_UINT64:
1583
+ return nc_get_varm_ulonglong(ncid, varid, start, count, stride, imap, value);
1584
+ case NC_FLOAT:
1585
+ return nc_get_varm_float(ncid, varid, start, count, stride, imap, value);
1586
+ case NC_DOUBLE:
1587
+ return nc_get_varm_double(ncid, varid, start, count, stride, imap, value);
1588
+ default:
1589
+ return NC_EBADTYPE;
1590
+ }
1591
+ }
1592
+
1593
+ static int
1594
+ nc_put_varm_numeric (int ncid, int varid, nc_type type,
1595
+ const size_t start[], const size_t count[],
1596
+ const ptrdiff_t stride[], const ptrdiff_t imap[],
1597
+ void *value)
1598
+ {
1599
+ switch (type) {
1600
+ case NC_BYTE:
1601
+ return nc_put_varm_schar(ncid, varid, start, count, stride, imap, value);
1602
+ case NC_UBYTE:
1603
+ return nc_put_varm_ubyte(ncid, varid, start, count, stride, imap, value);
1604
+ case NC_CHAR:
1605
+ return nc_put_varm_uchar(ncid, varid, start, count, stride, imap, value);
1606
+ case NC_SHORT:
1607
+ return nc_put_varm_short(ncid, varid, start, count, stride, imap, value);
1608
+ case NC_USHORT:
1609
+ return nc_put_varm_ushort(ncid, varid, start, count, stride, imap, value);
1610
+ case NC_INT:
1611
+ return nc_put_varm_int(ncid, varid, start, count, stride, imap, value);
1612
+ case NC_UINT:
1613
+ return nc_put_varm_uint(ncid, varid, start, count, stride, imap, value);
1614
+ case NC_INT64:
1615
+ return nc_put_varm_longlong(ncid, varid, start, count, stride, imap, value);
1616
+ case NC_UINT64:
1617
+ return nc_put_varm_ulonglong(ncid, varid, start, count, stride, imap, value);
1618
+ case NC_FLOAT:
1619
+ return nc_put_varm_float(ncid, varid, start, count, stride, imap, value);
1620
+ case NC_DOUBLE:
1621
+ return nc_put_varm_double(ncid, varid, start, count, stride, imap, value);
1622
+ default:
1623
+ return NC_EBADTYPE;
1624
+ }
1625
+ }
1626
+
1627
+ static VALUE
1628
+ rb_nc_get_var1 (int argc, VALUE *argv, VALUE mod)
1629
+ {
1630
+ int status;
1631
+ nc_type type;
1632
+ int ndims;
1633
+ size_t index[NC_MAX_DIMS];
1634
+ int i;
1635
+
1636
+ if ( argc < 3 ) {
1637
+ rb_raise(rb_eArgError, "invalid # of arguments");
1638
+ }
1639
+
1640
+ status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
1641
+
1642
+ CHECK_STATUS(status);
1643
+
1644
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
1645
+
1646
+ CHECK_STATUS(status);
1647
+
1648
+ Check_Type(argv[2], T_ARRAY);
1649
+ for (i=0; i<ndims; i++) {
1650
+ index[i] = NUM2ULONG(RARRAY_PTR(argv[2])[i]);
1651
+ }
1652
+
1653
+ if ( argc == 3 ) {
1654
+ switch ( type ) {
1655
+ case NC_BYTE: {
1656
+ int8_t val;
1657
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1658
+ type, index, &val);
1659
+ CHECK_STATUS(status);
1660
+ return INT2NUM(val);
1661
+ }
1662
+ case NC_UBYTE: {
1663
+ uint8_t val;
1664
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1665
+ type, index, &val);
1666
+ CHECK_STATUS(status);
1667
+ return INT2NUM(val);
1668
+ }
1669
+ case NC_SHORT: {
1670
+ int16_t val;
1671
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1672
+ type, index, &val);
1673
+ CHECK_STATUS(status);
1674
+ return INT2NUM(val);
1675
+ }
1676
+ case NC_USHORT: {
1677
+ uint16_t val;
1678
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1679
+ type, index, &val);
1680
+ CHECK_STATUS(status);
1681
+ return INT2NUM(val);
1682
+ }
1683
+ case NC_INT: {
1684
+ int32_t val;
1685
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1686
+ type, index, &val);
1687
+ CHECK_STATUS(status);
1688
+ return INT2NUM(val);
1689
+ }
1690
+ case NC_UINT: {
1691
+ uint32_t val;
1692
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1693
+ type, index, &val);
1694
+ CHECK_STATUS(status);
1695
+ return INT2NUM(val);
1696
+ }
1697
+ case NC_INT64: {
1698
+ int64_t val;
1699
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1700
+ type, index, &val);
1701
+ CHECK_STATUS(status);
1702
+ return INT2NUM(val);
1703
+ }
1704
+ case NC_UINT64: {
1705
+ uint64_t val;
1706
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1707
+ type, index, &val);
1708
+ CHECK_STATUS(status);
1709
+ return INT2NUM(val);
1710
+ }
1711
+ case NC_FLOAT: {
1712
+ float32_t val;
1713
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1714
+ type, index, &val);
1715
+ CHECK_STATUS(status);
1716
+ return rb_float_new(val);
1717
+ }
1718
+ case NC_DOUBLE: {
1719
+ float64_t val;
1720
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1721
+ type, index, &val);
1722
+ CHECK_STATUS(status);
1723
+ return rb_float_new(val);
1724
+ }
1725
+ default:
1726
+ rb_raise(rb_eRuntimeError, "unknown att nc_type");
1727
+ }
1728
+ }
1729
+ else {
1730
+ volatile VALUE data = rb_ca_wrap_writable(argv[3], Qnil);
1731
+ CArray *ca;
1732
+
1733
+ Data_Get_Struct(data, CArray, ca);
1734
+
1735
+ type = rb_nc_rtypemap(ca->data_type);
1736
+
1737
+ ca_attach(ca);
1738
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1739
+ type, index, ca->ptr);
1740
+
1741
+ ca_sync(ca);
1742
+ ca_detach(ca);
1743
+
1744
+ CHECK_STATUS(status);
1745
+
1746
+ return LONG2NUM(status);
1747
+ }
1748
+
1749
+ }
1750
+
1751
+ static VALUE
1752
+ rb_nc_put_var1 (int argc, VALUE *argv, VALUE mod)
1753
+ {
1754
+ volatile VALUE data;
1755
+ int status;
1756
+ nc_type type;
1757
+ size_t index[NC_MAX_DIMS];
1758
+ int ndims;
1759
+ CArray *ca;
1760
+ int i;
1761
+
1762
+ CHECK_ARGC(4);
1763
+
1764
+ status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
1765
+
1766
+ CHECK_STATUS(status);
1767
+
1768
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
1769
+
1770
+ CHECK_STATUS(status);
1771
+
1772
+ Check_Type(argv[2], T_ARRAY);
1773
+
1774
+ for (i=0; i<ndims; i++) {
1775
+ index[i] = NUM2ULONG(RARRAY_PTR(argv[2])[i]);
1776
+ }
1777
+
1778
+ if ( rb_obj_is_kind_of(argv[3], rb_cNumeric) ) {
1779
+ data = argv[3];
1780
+ switch ( type ) {
1781
+ case NC_BYTE: {
1782
+ int8_t val = NUM2INT(data);
1783
+ status = nc_put_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1784
+ type, index, &val);
1785
+ }
1786
+ case NC_UBYTE: {
1787
+ uint8_t val = NUM2UINT(data);
1788
+ status = nc_put_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1789
+ type, index, &val);
1790
+ }
1791
+ case NC_SHORT: {
1792
+ int16_t val = NUM2INT(data);
1793
+ status = nc_put_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1794
+ type, index, &val);
1795
+ }
1796
+ case NC_USHORT: {
1797
+ uint16_t val = NUM2UINT(data);
1798
+ status = nc_put_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1799
+ type, index, &val);
1800
+ }
1801
+ case NC_INT: {
1802
+ int32_t val = NUM2INT(data);
1803
+ status = nc_put_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1804
+ type, index, &val);
1805
+ }
1806
+ case NC_UINT: {
1807
+ uint32_t val = NUM2UINT(data);
1808
+ status = nc_put_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1809
+ type, index, &val);
1810
+ }
1811
+ case NC_INT64: {
1812
+ int64_t val = NUM2INT(data);
1813
+ status = nc_put_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1814
+ type, index, &val);
1815
+ }
1816
+ case NC_UINT64: {
1817
+ uint64_t val = NUM2UINT(data);
1818
+ status = nc_put_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1819
+ type, index, &val);
1820
+ }
1821
+ case NC_FLOAT: {
1822
+ float32_t val = NUM2DBL(data);
1823
+ status = nc_put_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1824
+ type, index, &val);
1825
+ }
1826
+ case NC_DOUBLE: {
1827
+ float64_t val = NUM2DBL(data);
1828
+ status = nc_put_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1829
+ type, index, &val);
1830
+ }
1831
+ default:
1832
+ rb_raise(rb_eRuntimeError, "unknown nc_type");
1833
+ }
1834
+ }
1835
+ else {
1836
+ data = rb_ca_wrap_readonly(argv[3], Qnil);
1837
+ Data_Get_Struct(data, CArray, ca);
1838
+ type = rb_nc_rtypemap(ca->data_type);
1839
+ ca_attach(ca);
1840
+ status = nc_put_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1841
+ type, index, ca->ptr);
1842
+ ca_detach(ca);
1843
+ }
1844
+
1845
+ CHECK_STATUS(status);
1846
+
1847
+ return LONG2NUM(status);
1848
+ }
1849
+
1850
+ static VALUE
1851
+ rb_nc_get_var (int argc, VALUE *argv, VALUE mod)
1852
+ {
1853
+ int status;
1854
+ int ndims;
1855
+ int dimid[NC_MAX_DIMS];
1856
+ nc_type type;
1857
+
1858
+ if ( argc < 2 ) {
1859
+ rb_raise(rb_eArgError, "invalid # of arguments");
1860
+ }
1861
+
1862
+ status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
1863
+
1864
+ CHECK_STATUS(status);
1865
+
1866
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
1867
+
1868
+ CHECK_STATUS(status);
1869
+
1870
+ status = nc_inq_vardimid(NUM2INT(argv[0]), NUM2INT(argv[1]), dimid);
1871
+
1872
+ CHECK_STATUS(status);
1873
+
1874
+ if ( argc == 2 ) {
1875
+ volatile VALUE out;
1876
+ CArray *ca;
1877
+ int8_t ndim, data_type;
1878
+ ca_size_t dim[CA_DIM_MAX];
1879
+ size_t len;
1880
+ int i;
1881
+
1882
+ data_type = rb_nc_typemap (type);
1883
+ ndim = ndims;
1884
+ for (i=0; i<ndim; i++) {
1885
+ status = nc_inq_dimlen(NUM2INT(argv[0]), dimid[i], &len);
1886
+ CHECK_STATUS(status);
1887
+ dim[i] = len;
1888
+ }
1889
+
1890
+ out = rb_carray_new(data_type, ndim, dim, 0, NULL);
1891
+ Data_Get_Struct(out, CArray, ca);
1892
+
1893
+ status = nc_get_var_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1894
+ type, ca->ptr);
1895
+
1896
+ CHECK_STATUS(status);
1897
+
1898
+ return rb_nc_output(out);
1899
+ }
1900
+ else {
1901
+ CArray *ca;
1902
+ volatile VALUE data = rb_ca_wrap_writable(argv[2], Qnil);
1903
+
1904
+ Data_Get_Struct(data, CArray, ca);
1905
+
1906
+ type = rb_nc_rtypemap(ca->data_type);
1907
+
1908
+ ca_attach(ca);
1909
+ status = nc_get_var_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1910
+ type, ca->ptr);
1911
+ ca_sync(ca);
1912
+ ca_detach(ca);
1913
+
1914
+ CHECK_STATUS(status);
1915
+
1916
+ return LONG2NUM(status);
1917
+ }
1918
+ }
1919
+
1920
+ static VALUE
1921
+ rb_nc_put_var (int argc, VALUE *argv, VALUE mod)
1922
+ {
1923
+ volatile VALUE data;
1924
+ int status;
1925
+ nc_type type;
1926
+ CArray *ca;
1927
+
1928
+ CHECK_ARGC(3);
1929
+
1930
+ status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
1931
+
1932
+ CHECK_STATUS(status);
1933
+
1934
+ data = rb_ca_wrap_readonly(argv[2], Qnil);
1935
+
1936
+ Data_Get_Struct(data, CArray, ca);
1937
+
1938
+ type = rb_nc_rtypemap(ca->data_type);
1939
+ ca_attach(ca);
1940
+ status = nc_put_var_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1941
+ type, ca->ptr);
1942
+ ca_detach(ca);
1943
+
1944
+ CHECK_STATUS(status);
1945
+
1946
+ return LONG2NUM(status);
1947
+ }
1948
+
1949
+ static VALUE
1950
+ rb_nc_get_vara (int argc, VALUE *argv, VALUE mod)
1951
+ {
1952
+ int status;
1953
+ nc_type type;
1954
+ int ndims;
1955
+ int dimid[NC_MAX_DIMS];
1956
+ size_t start[NC_MAX_DIMS], count[NC_MAX_DIMS];
1957
+ int i;
1958
+
1959
+ if ( argc < 4 ) {
1960
+ rb_raise(rb_eArgError, "invalid # of arguments");
1961
+ }
1962
+
1963
+ status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
1964
+
1965
+ CHECK_STATUS(status);
1966
+
1967
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
1968
+
1969
+ CHECK_STATUS(status);
1970
+
1971
+ status = nc_inq_vardimid(NUM2INT(argv[0]), NUM2INT(argv[1]), dimid);
1972
+
1973
+ CHECK_STATUS(status);
1974
+
1975
+ Check_Type(argv[2], T_ARRAY);
1976
+ Check_Type(argv[3], T_ARRAY);
1977
+
1978
+ for (i=0; i<ndims; i++) {
1979
+ start[i] = NUM2ULONG(RARRAY_PTR(argv[2])[i]);
1980
+ count[i] = NUM2ULONG(RARRAY_PTR(argv[3])[i]);
1981
+ }
1982
+
1983
+ if ( argc == 4 ) {
1984
+ volatile VALUE out;
1985
+ CArray *ca;
1986
+ int8_t ndim, data_type;
1987
+ ca_size_t dim[CA_DIM_MAX];
1988
+ int i;
1989
+
1990
+ data_type = rb_nc_typemap (type);
1991
+ ndim = ndims;
1992
+ for (i=0; i<ndim; i++) {
1993
+ dim[i] = count[i];
1994
+ }
1995
+
1996
+ out = rb_carray_new(data_type, ndim, dim, 0, NULL);
1997
+ Data_Get_Struct(out, CArray, ca);
1998
+
1999
+ status = nc_get_vara_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
2000
+ type, start, count, ca->ptr);
2001
+
2002
+ CHECK_STATUS(status);
2003
+
2004
+ return rb_nc_output(out);
2005
+ }
2006
+ else {
2007
+ volatile VALUE data = rb_ca_wrap_writable(argv[4], Qnil);
2008
+ CArray *ca;
2009
+
2010
+ Data_Get_Struct(data, CArray, ca);
2011
+
2012
+ if ( ca->ndim != ndims ) {
2013
+ rb_raise(rb_eRuntimeError, "dimension mismatch");
2014
+ }
2015
+
2016
+ for (i=0; i<ca->ndim; i++) {
2017
+ if ( ca->dim[i] != (ca_size_t) count[i] ) {
2018
+ rb_raise(rb_eRuntimeError, "dim[%i] mismatch", i);
2019
+ }
2020
+ }
2021
+
2022
+ type = rb_nc_rtypemap(ca->data_type);
2023
+
2024
+ ca_attach(ca);
2025
+ status = nc_get_vara_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
2026
+ type, start, count, ca->ptr);
2027
+ ca_sync(ca);
2028
+ ca_detach(ca);
2029
+
2030
+ CHECK_STATUS(status);
2031
+
2032
+ return LONG2NUM(status);
2033
+ }
2034
+ }
2035
+
2036
+ static VALUE
2037
+ rb_nc_put_vara (int argc, VALUE *argv, VALUE mod)
2038
+ {
2039
+ volatile VALUE data;
2040
+ int status;
2041
+ nc_type type;
2042
+ int ndims;
2043
+ size_t start[NC_MAX_DIMS], count[NC_MAX_DIMS];
2044
+ CArray *ca;
2045
+ int i;
2046
+
2047
+ CHECK_ARGC(5);
2048
+
2049
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
2050
+
2051
+ CHECK_STATUS(status);
2052
+
2053
+ Check_Type(argv[2], T_ARRAY);
2054
+ Check_Type(argv[3], T_ARRAY);
2055
+
2056
+ for (i=0; i<ndims; i++) {
2057
+ start[i] = NUM2ULONG(RARRAY_PTR(argv[2])[i]);
2058
+ count[i] = NUM2ULONG(RARRAY_PTR(argv[3])[i]);
2059
+ }
2060
+
2061
+ data = rb_ca_wrap_readonly(argv[4], Qnil);
2062
+
2063
+ Data_Get_Struct(data, CArray, ca);
2064
+
2065
+ type = rb_nc_rtypemap(ca->data_type);
2066
+
2067
+ ca_attach(ca);
2068
+ status = nc_put_vara_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
2069
+ type, start, count, ca->ptr);
2070
+ ca_detach(ca);
2071
+
2072
+ CHECK_STATUS(status);
2073
+
2074
+ return LONG2NUM(status);
2075
+ }
2076
+
2077
+ static VALUE
2078
+ rb_nc_get_vars (int argc, VALUE *argv, VALUE mod)
2079
+ {
2080
+ int status;
2081
+ nc_type type;
2082
+ int ndims;
2083
+ int dimid[NC_MAX_DIMS];
2084
+ size_t start[NC_MAX_DIMS], count[NC_MAX_DIMS];
2085
+ ptrdiff_t stride[NC_MAX_DIMS];
2086
+ CArray *ca;
2087
+ int i;
2088
+
2089
+ if ( argc < 5 ) {
2090
+ rb_raise(rb_eArgError, "invalid # of arguments");
2091
+ }
2092
+
2093
+ status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
2094
+
2095
+ CHECK_STATUS(status);
2096
+
2097
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
2098
+
2099
+ CHECK_STATUS(status);
2100
+
2101
+ status = nc_inq_vardimid(NUM2INT(argv[0]), NUM2INT(argv[1]), dimid);
2102
+
2103
+ CHECK_STATUS(status);
2104
+
2105
+ Check_Type(argv[2], T_ARRAY);
2106
+ Check_Type(argv[3], T_ARRAY);
2107
+ Check_Type(argv[4], T_ARRAY);
2108
+
2109
+ for (i=0; i<ndims; i++) {
2110
+ start[i] = NUM2ULONG(RARRAY_PTR(argv[2])[i]);
2111
+ count[i] = NUM2ULONG(RARRAY_PTR(argv[3])[i]);
2112
+ stride[i] = NUM2ULONG(RARRAY_PTR(argv[4])[i]);
2113
+ }
2114
+
2115
+ if ( argc == 5 ) {
2116
+ volatile VALUE out;
2117
+ CArray *ca;
2118
+ int8_t ndim, data_type;
2119
+ ca_size_t dim[CA_DIM_MAX];
2120
+ int i;
2121
+
2122
+ data_type = rb_nc_typemap (type);
2123
+ ndim = ndims;
2124
+ for (i=0; i<ndim; i++) {
2125
+ dim[i] = count[i];
2126
+ }
2127
+
2128
+ out = rb_carray_new(data_type, ndim, dim, 0, NULL);
2129
+ Data_Get_Struct(out, CArray, ca);
2130
+
2131
+ status = nc_get_vars_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
2132
+ type, start, count, stride, ca->ptr);
2133
+
2134
+ CHECK_STATUS(status);
2135
+
2136
+ return rb_nc_output(out);
2137
+ }
2138
+ else {
2139
+ volatile VALUE data = rb_ca_wrap_writable(argv[5], Qnil);
2140
+ int i;
2141
+
2142
+ Data_Get_Struct(data, CArray, ca);
2143
+
2144
+ if ( ca->ndim != ndims ) {
2145
+ rb_raise(rb_eRuntimeError, "dimension mismatch");
2146
+ }
2147
+
2148
+ for (i=0; i<ca->ndim; i++) {
2149
+ if ( ca->dim[i] != (ca_size_t) count[i] ) {
2150
+ rb_raise(rb_eRuntimeError, "dim[%i] mismatch", i);
2151
+ }
2152
+ }
2153
+
2154
+ type = rb_nc_rtypemap(ca->data_type);
2155
+
2156
+ ca_attach(ca);
2157
+ status = nc_get_vars_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
2158
+ type, start, count, stride, ca->ptr);
2159
+ ca_sync(ca);
2160
+ ca_detach(ca);
2161
+
2162
+ CHECK_STATUS(status);
2163
+
2164
+ return LONG2NUM(status);
2165
+ }
2166
+ }
2167
+
2168
+ static VALUE
2169
+ rb_nc_put_vars (int argc, VALUE *argv, VALUE mod)
2170
+ {
2171
+ volatile VALUE data;
2172
+ int status;
2173
+ nc_type type;
2174
+ int ndims;
2175
+ size_t start[NC_MAX_DIMS], count[NC_MAX_DIMS];
2176
+ ptrdiff_t stride[NC_MAX_DIMS];
2177
+ CArray *ca;
2178
+ int i;
2179
+
2180
+ CHECK_ARGC(6);
2181
+
2182
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
2183
+
2184
+ CHECK_STATUS(status);
2185
+
2186
+ Check_Type(argv[2], T_ARRAY);
2187
+ Check_Type(argv[3], T_ARRAY);
2188
+ Check_Type(argv[4], T_ARRAY);
2189
+
2190
+ for (i=0; i<ndims; i++) {
2191
+ start[i] = NUM2ULONG(RARRAY_PTR(argv[2])[i]);
2192
+ count[i] = NUM2ULONG(RARRAY_PTR(argv[3])[i]);
2193
+ stride[i] = NUM2ULONG(RARRAY_PTR(argv[4])[i]);
2194
+ }
2195
+
2196
+ data = rb_ca_wrap_readonly(argv[5], Qnil);
2197
+
2198
+ Data_Get_Struct(data, CArray, ca);
2199
+
2200
+ type = rb_nc_rtypemap(ca->data_type);
2201
+
2202
+ ca_attach(ca);
2203
+ status = nc_put_vars_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
2204
+ type, start, count, stride, ca->ptr);
2205
+ ca_detach(ca);
2206
+
2207
+ CHECK_STATUS(status);
2208
+
2209
+ return LONG2NUM(status);
2210
+ }
2211
+
2212
+ static VALUE
2213
+ rb_nc_get_varm (int argc, VALUE *argv, VALUE mod)
2214
+ {
2215
+ int status;
2216
+ nc_type type;
2217
+ int ndims;
2218
+ int dimid[NC_MAX_DIMS];
2219
+ size_t start[NC_MAX_DIMS], count[NC_MAX_DIMS];
2220
+ ptrdiff_t stride[NC_MAX_DIMS], imap[NC_MAX_DIMS];
2221
+ CArray *ca;
2222
+ int i;
2223
+
2224
+ if ( argc < 6 ) {
2225
+ rb_raise(rb_eArgError, "invalid # of arguments");
2226
+ }
2227
+
2228
+ status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
2229
+
2230
+ CHECK_STATUS(status);
2231
+
2232
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
2233
+
2234
+ CHECK_STATUS(status);
2235
+
2236
+ status = nc_inq_vardimid(NUM2INT(argv[0]), NUM2INT(argv[1]), dimid);
2237
+
2238
+ CHECK_STATUS(status);
2239
+
2240
+ Check_Type(argv[2], T_ARRAY);
2241
+ Check_Type(argv[3], T_ARRAY);
2242
+ Check_Type(argv[4], T_ARRAY);
2243
+ Check_Type(argv[5], T_ARRAY);
2244
+
2245
+ for (i=0; i<ndims; i++) {
2246
+ start[i] = NUM2ULONG(RARRAY_PTR(argv[2])[i]);
2247
+ count[i] = NUM2ULONG(RARRAY_PTR(argv[3])[i]);
2248
+ stride[i] = NUM2ULONG(RARRAY_PTR(argv[4])[i]);
2249
+ imap[i] = NUM2ULONG(RARRAY_PTR(argv[5])[i]);
2250
+ }
2251
+
2252
+ if ( argc == 6 ) {
2253
+ volatile VALUE out;
2254
+ CArray *ca;
2255
+ int8_t ndim, data_type;
2256
+ ca_size_t dim[CA_DIM_MAX];
2257
+ int i;
2258
+
2259
+ data_type = rb_nc_typemap (type);
2260
+ ndim = ndims;
2261
+ for (i=0; i<ndim; i++) {
2262
+ dim[i] = count[i];
2263
+ }
2264
+
2265
+ out = rb_carray_new(data_type, ndim, dim, 0, NULL);
2266
+ Data_Get_Struct(out, CArray, ca);
2267
+
2268
+ status = nc_get_varm_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
2269
+ type, start, count, stride, imap, ca->ptr);
2270
+
2271
+ CHECK_STATUS(status);
2272
+
2273
+ return rb_nc_output(out);
2274
+ }
2275
+ else {
2276
+ volatile VALUE data = rb_ca_wrap_writable(argv[6], Qnil);
2277
+ int i;
2278
+
2279
+ Data_Get_Struct(data, CArray, ca);
2280
+
2281
+ if ( ca->ndim != ndims ) {
2282
+ rb_raise(rb_eRuntimeError, "dimension mismatch");
2283
+ }
2284
+
2285
+ for (i=0; i<ca->ndim; i++) {
2286
+ if ( ca->dim[i] != (ca_size_t) count[i] ) {
2287
+ rb_raise(rb_eRuntimeError, "dim[%i] mismatch", i);
2288
+ }
2289
+ }
2290
+
2291
+ type = rb_nc_rtypemap(ca->data_type);
2292
+
2293
+ ca_attach(ca);
2294
+ status = nc_get_varm_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
2295
+ type, start, count, stride, imap, ca->ptr);
2296
+ ca_sync(ca);
2297
+ ca_detach(ca);
2298
+
2299
+ CHECK_STATUS(status);
2300
+
2301
+ return LONG2NUM(status);
2302
+ }
2303
+ }
2304
+
2305
+ static VALUE
2306
+ rb_nc_put_varm (int argc, VALUE *argv, VALUE mod)
2307
+ {
2308
+ volatile VALUE data;
2309
+ int status;
2310
+ nc_type type;
2311
+ int ndims;
2312
+ size_t start[NC_MAX_DIMS], count[NC_MAX_DIMS];
2313
+ ptrdiff_t stride[NC_MAX_DIMS], imap[NC_MAX_DIMS];
2314
+ CArray *ca;
2315
+ int i;
2316
+
2317
+ CHECK_ARGC(7);
2318
+
2319
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
2320
+
2321
+ CHECK_STATUS(status);
2322
+
2323
+ Check_Type(argv[2], T_ARRAY);
2324
+ Check_Type(argv[3], T_ARRAY);
2325
+ Check_Type(argv[4], T_ARRAY);
2326
+ Check_Type(argv[5], T_ARRAY);
2327
+
2328
+ for (i=0; i<ndims; i++) {
2329
+ start[i] = NUM2ULONG(RARRAY_PTR(argv[2])[i]);
2330
+ count[i] = NUM2ULONG(RARRAY_PTR(argv[3])[i]);
2331
+ stride[i] = NUM2ULONG(RARRAY_PTR(argv[4])[i]);
2332
+ imap[i] = NUM2ULONG(RARRAY_PTR(argv[5])[i]);
2333
+ }
2334
+
2335
+ data = rb_ca_wrap_readonly(argv[6], Qnil);
2336
+
2337
+ Data_Get_Struct(data, CArray, ca);
2338
+
2339
+ type = rb_nc_rtypemap(ca->data_type);
2340
+
2341
+ ca_attach(ca);
2342
+ status = nc_put_varm_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
2343
+ type, start, count, stride, imap, ca->ptr);
2344
+ ca_detach(ca);
2345
+
2346
+ CHECK_STATUS(status);
2347
+
2348
+ return LONG2NUM(status);
2349
+ }
2350
+
2351
+ static VALUE
2352
+ rb_nc_rename_dim (int argc, VALUE *argv, VALUE mod)
2353
+ {
2354
+ int status;
2355
+
2356
+ CHECK_ARGC(3);
2357
+ CHECK_TYPE_ID(argv[0]);
2358
+ CHECK_TYPE_ID(argv[1]);
2359
+ CHECK_TYPE_STRING(argv[2]);
2360
+
2361
+ status = nc_rename_dim(NUM2INT(argv[0]), NUM2INT(argv[1]),
2362
+ StringValuePtr(argv[2]));
2363
+
2364
+ CHECK_STATUS(status);
2365
+
2366
+ return LONG2NUM(status);
2367
+ }
2368
+
2369
+ static VALUE
2370
+ rb_nc_rename_grp (int argc, VALUE *argv, VALUE mod)
2371
+ {
2372
+ int status;
2373
+
2374
+ CHECK_ARGC(2);
2375
+ CHECK_TYPE_ID(argv[0]);
2376
+ CHECK_TYPE_STRING(argv[1]);
2377
+
2378
+ status = nc_rename_grp(NUM2INT(argv[0]), StringValuePtr(argv[1]));
2379
+
2380
+ CHECK_STATUS(status);
2381
+
2382
+ return LONG2NUM(status);
2383
+ }
2384
+
2385
+ static VALUE
2386
+ rb_nc_rename_var (int argc, VALUE *argv, VALUE mod)
2387
+ {
2388
+ int status;
2389
+
2390
+ CHECK_ARGC(3);
2391
+ CHECK_TYPE_ID(argv[0]);
2392
+ CHECK_TYPE_ID(argv[1]);
2393
+ CHECK_TYPE_STRING(argv[2]);
2394
+
2395
+ status = nc_rename_var(NUM2INT(argv[0]), NUM2INT(argv[1]),
2396
+ StringValuePtr(argv[2]));
2397
+
2398
+ CHECK_STATUS(status);
2399
+
2400
+ return LONG2NUM(status);
2401
+ }
2402
+
2403
+ static VALUE
2404
+ rb_nc_rename_att (int argc, VALUE *argv, VALUE mod)
2405
+ {
2406
+ int status;
2407
+
2408
+ CHECK_ARGC(4);
2409
+ CHECK_TYPE_ID(argv[0]);
2410
+ CHECK_TYPE_ID(argv[1]);
2411
+ CHECK_TYPE_STRING(argv[2]);
2412
+ CHECK_TYPE_STRING(argv[3]);
2413
+
2414
+ status = nc_rename_att(NUM2INT(argv[0]), NUM2INT(argv[1]),
2415
+ StringValuePtr(argv[2]), StringValuePtr(argv[3]));
2416
+
2417
+ CHECK_STATUS(status);
2418
+
2419
+ return LONG2NUM(status);
2420
+ }
2421
+
2422
+ static VALUE
2423
+ rb_nc_set_fill (int argc, VALUE *argv, VALUE mod)
2424
+ {
2425
+ int status;
2426
+ int old_fillmode;
2427
+
2428
+ CHECK_ARGC(2);
2429
+ CHECK_TYPE_ID(argv[0]);
2430
+ CHECK_TYPE_INT(argv[1]);
2431
+
2432
+ status = nc_set_fill(NUM2INT(argv[0]), NUM2INT(argv[1]), &old_fillmode);
2433
+
2434
+ CHECK_STATUS(status);
2435
+
2436
+ return LONG2NUM(old_fillmode);
2437
+ }
2438
+
2439
+ static VALUE
2440
+ rb_nc_copy_att (int argc, VALUE *argv, VALUE mod)
2441
+ {
2442
+ int status;
2443
+
2444
+ CHECK_ARGC(5);
2445
+ CHECK_TYPE_ID(argv[0]);
2446
+ CHECK_TYPE_ID(argv[1]);
2447
+ CHECK_TYPE_STRING(argv[2]);
2448
+ CHECK_TYPE_ID(argv[3]);
2449
+ CHECK_TYPE_ID(argv[4]);
2450
+
2451
+ status = nc_copy_att(NUM2INT(argv[0]), NUM2INT(argv[1]),
2452
+ StringValuePtr(argv[2]), NUM2INT(argv[3]), NUM2INT(argv[4]));
2453
+
2454
+ CHECK_STATUS(status);
2455
+
2456
+ return LONG2NUM(status);
2457
+ }
2458
+
2459
+ void
2460
+ Init_netcdflib ()
2461
+ {
2462
+
2463
+ mNetCDF = rb_define_module("NC");
2464
+
2465
+ rb_define_singleton_method(mNetCDF, "ca_type", rb_nc_ca_type, -1);
2466
+ rb_define_singleton_method(mNetCDF, "nc_type", rb_nc_nc_type, -1);
2467
+
2468
+ rb_define_singleton_method(mNetCDF, "converter", rb_nc_get_converter, 0);
2469
+ rb_define_singleton_method(mNetCDF, "converter=", rb_nc_set_converter, 1);
2470
+
2471
+ rb_define_module_function(mNetCDF, "nc_create", rb_nc_create, -1);
2472
+ rb_define_singleton_method(mNetCDF, "create", rb_nc_create, -1);
2473
+ rb_define_module_function(mNetCDF, "nc_open", rb_nc_open, -1);
2474
+ rb_define_singleton_method(mNetCDF, "open", rb_nc_open, -1);
2475
+ rb_define_module_function(mNetCDF, "nc_close", rb_nc_close, -1);
2476
+ rb_define_singleton_method(mNetCDF, "close", rb_nc_close, -1);
2477
+ rb_define_module_function(mNetCDF, "nc_redef", rb_nc_redef, -1);
2478
+ rb_define_singleton_method(mNetCDF, "redef", rb_nc_redef, -1);
2479
+ rb_define_module_function(mNetCDF, "nc_enddef", rb_nc_enddef, -1);
2480
+ rb_define_singleton_method(mNetCDF, "enddef", rb_nc_enddef, -1);
2481
+ rb_define_module_function(mNetCDF, "nc_sync", rb_nc_sync, -1);
2482
+ rb_define_singleton_method(mNetCDF, "sync", rb_nc_sync, -1);
2483
+ rb_define_module_function(mNetCDF, "nc_set_fill", rb_nc_set_fill, -1);
2484
+ rb_define_singleton_method(mNetCDF, "set_fill", rb_nc_set_fill, -1);
2485
+
2486
+ rb_define_module_function(mNetCDF, "nc_def_dim", rb_nc_def_dim, -1);
2487
+ rb_define_singleton_method(mNetCDF, "def_dim", rb_nc_def_dim, -1);
2488
+ // nc_inq_dim is not defined
2489
+ rb_define_module_function(mNetCDF, "nc_inq_dimid", rb_nc_inq_dimid, -1);
2490
+ rb_define_singleton_method(mNetCDF, "inq_dimid", rb_nc_inq_dimid, -1);
2491
+ rb_define_module_function(mNetCDF, "nc_inq_dimlen", rb_nc_inq_dimlen, -1);
2492
+ rb_define_singleton_method(mNetCDF, "inq_dimlen", rb_nc_inq_dimlen, -1);
2493
+ rb_define_module_function(mNetCDF, "nc_inq_dimname", rb_nc_inq_dimname, -1);
2494
+ rb_define_singleton_method(mNetCDF, "inq_dimname", rb_nc_inq_dimname, -1);
2495
+ rb_define_module_function(mNetCDF, "nc_inq_ndims", rb_nc_inq_ndims, -1);
2496
+ rb_define_singleton_method(mNetCDF, "inq_ndims", rb_nc_inq_ndims, -1);
2497
+ rb_define_module_function(mNetCDF, "nc_inq_unlimdim", rb_nc_inq_unlimdim, -1);
2498
+ rb_define_singleton_method(mNetCDF, "inq_unlimdim", rb_nc_inq_unlimdim, -1);
2499
+ rb_define_module_function(mNetCDF, "nc_rename_dim", rb_nc_rename_dim, -1);
2500
+ rb_define_singleton_method(mNetCDF, "rename_dim", rb_nc_rename_dim, -1);
2501
+
2502
+ rb_define_module_function(mNetCDF, "nc_def_var", rb_nc_def_var, -1);
2503
+ rb_define_singleton_method(mNetCDF, "def_var", rb_nc_def_var, -1);
2504
+ rb_define_module_function(mNetCDF, "nc_def_var_chunking", rb_nc_def_var_chunking, -1);
2505
+ rb_define_singleton_method(mNetCDF, "def_var_chunking", rb_nc_def_var_chunking, -1);
2506
+ rb_define_module_function(mNetCDF, "nc_def_var_deflate", rb_nc_def_var_deflate, -1);
2507
+ rb_define_singleton_method(mNetCDF, "def_var_deflate", rb_nc_def_var_deflate, -1);
2508
+ // nc_def_var_endian
2509
+ // nc_def_var_fill
2510
+ // nc_def_var_fletcher32
2511
+ // nc_free_string
2512
+ rb_define_module_function(mNetCDF, "nc_get_var1", rb_nc_get_var1, -1);
2513
+ rb_define_singleton_method(mNetCDF, "get_var1", rb_nc_get_var1, -1);
2514
+ rb_define_module_function(mNetCDF, "nc_get_var", rb_nc_get_var, -1);
2515
+ rb_define_singleton_method(mNetCDF, "get_var", rb_nc_get_var, -1);
2516
+ rb_define_module_function(mNetCDF, "nc_get_vara", rb_nc_get_vara, -1);
2517
+ rb_define_singleton_method(mNetCDF, "get_vara", rb_nc_get_vara, -1);
2518
+ rb_define_module_function(mNetCDF, "nc_get_vars", rb_nc_get_vars, -1);
2519
+ rb_define_singleton_method(mNetCDF, "get_vars", rb_nc_get_vars, -1);
2520
+ rb_define_module_function(mNetCDF, "nc_get_varm", rb_nc_get_varm, -1);
2521
+ rb_define_singleton_method(mNetCDF, "get_varm", rb_nc_get_varm, -1);
2522
+ //nc_inq_var
2523
+ rb_define_module_function(mNetCDF, "nc_inq_var_chunking", rb_nc_inq_var_chunking, -1);
2524
+ rb_define_singleton_method(mNetCDF, "inq_var_chunking", rb_nc_inq_var_chunking, -1);
2525
+ rb_define_module_function(mNetCDF, "nc_inq_var_deflate", rb_nc_inq_var_deflate, -1);
2526
+ rb_define_singleton_method(mNetCDF, "inq_var_deflate", rb_nc_inq_var_deflate, -1);
2527
+ //nc_inq_var_endian
2528
+ //nc_inq_var_fill
2529
+ //nc_inq_var_filter
2530
+ //nc_inq_var_fletcher32
2531
+ //nc_inq_var_szip
2532
+ rb_define_module_function(mNetCDF, "nc_inq_vardimid", rb_nc_inq_vardimid, -1);
2533
+ rb_define_singleton_method(mNetCDF, "inq_vardimid", rb_nc_inq_vardimid, -1);
2534
+ rb_define_module_function(mNetCDF, "nc_inq_varid", rb_nc_inq_varid, -1);
2535
+ rb_define_singleton_method(mNetCDF, "inq_varid", rb_nc_inq_varid, -1);
2536
+ rb_define_module_function(mNetCDF, "nc_inq_varname", rb_nc_inq_varname, -1);
2537
+ rb_define_singleton_method(mNetCDF, "inq_varname", rb_nc_inq_varname, -1);
2538
+ rb_define_module_function(mNetCDF, "nc_inq_varnatts", rb_nc_inq_varnatts, -1);
2539
+ rb_define_singleton_method(mNetCDF, "inq_varnatts", rb_nc_inq_varnatts, -1);
2540
+ rb_define_module_function(mNetCDF, "nc_inq_varndims", rb_nc_inq_varndims, -1);
2541
+ rb_define_singleton_method(mNetCDF, "inq_varndims", rb_nc_inq_varndims, -1);
2542
+ rb_define_module_function(mNetCDF, "nc_inq_vartype", rb_nc_inq_vartype, -1);
2543
+ rb_define_singleton_method(mNetCDF, "inq_vartype", rb_nc_inq_vartype, -1);
2544
+ rb_define_module_function(mNetCDF, "nc_put_var1", rb_nc_put_var1, -1);
2545
+ rb_define_singleton_method(mNetCDF, "put_var1", rb_nc_put_var1, -1);
2546
+ rb_define_module_function(mNetCDF, "nc_put_var", rb_nc_put_var, -1);
2547
+ rb_define_singleton_method(mNetCDF, "put_var", rb_nc_put_var, -1);
2548
+ rb_define_module_function(mNetCDF, "nc_put_vara", rb_nc_put_vara, -1);
2549
+ rb_define_singleton_method(mNetCDF, "put_vara", rb_nc_put_vara, -1);
2550
+ rb_define_module_function(mNetCDF, "nc_put_vars", rb_nc_put_vars, -1);
2551
+ rb_define_singleton_method(mNetCDF, "put_vars", rb_nc_put_vars, -1);
2552
+ rb_define_module_function(mNetCDF, "nc_put_varm", rb_nc_put_varm, -1);
2553
+ rb_define_singleton_method(mNetCDF, "put_varm", rb_nc_put_varm, -1);
2554
+ rb_define_module_function(mNetCDF, "nc_rename_var", rb_nc_rename_var, -1);
2555
+ rb_define_singleton_method(mNetCDF, "rename_var", rb_nc_rename_var, -1);
2556
+ // nc_set_var_chunk_cache
2557
+
2558
+ rb_define_module_function(mNetCDF, "nc_del_att", rb_nc_del_att, -1);
2559
+ rb_define_singleton_method(mNetCDF, "del_att", rb_nc_del_att, -1);
2560
+ rb_define_module_function(mNetCDF, "nc_get_att", rb_nc_get_att, -1);
2561
+ rb_define_singleton_method(mNetCDF, "get_att", rb_nc_get_att, -1);
2562
+ // nc_inq_att
2563
+ rb_define_module_function(mNetCDF, "nc_inq_attid", rb_nc_inq_attid, -1);
2564
+ rb_define_singleton_method(mNetCDF, "inq_attid", rb_nc_inq_attid, -1);
2565
+ rb_define_module_function(mNetCDF, "nc_inq_attlen", rb_nc_inq_attlen, -1);
2566
+ rb_define_singleton_method(mNetCDF, "inq_attlen", rb_nc_inq_attlen, -1);
2567
+ rb_define_module_function(mNetCDF, "nc_inq_attname", rb_nc_inq_attname, -1);
2568
+ rb_define_singleton_method(mNetCDF, "inq_attname", rb_nc_inq_attname, -1);
2569
+ rb_define_module_function(mNetCDF, "nc_inq_atttype", rb_nc_inq_atttype, -1);
2570
+ rb_define_singleton_method(mNetCDF, "inq_atttype", rb_nc_inq_atttype, -1);
2571
+ rb_define_module_function(mNetCDF, "nc_inq_natts", rb_nc_inq_natts, -1);
2572
+ rb_define_singleton_method(mNetCDF, "inq_natts", rb_nc_inq_natts, -1);
2573
+ rb_define_module_function(mNetCDF, "nc_put_att", rb_nc_put_att, -1);
2574
+ rb_define_singleton_method(mNetCDF, "put_att", rb_nc_put_att, -1);
2575
+ rb_define_module_function(mNetCDF, "nc_rename_att", rb_nc_rename_att, -1);
2576
+ rb_define_singleton_method(mNetCDF, "rename_att", rb_nc_rename_att, -1);
2577
+
2578
+ rb_define_module_function(mNetCDF, "nc_def_grp", rb_nc_def_grp, -1);
2579
+ rb_define_singleton_method(mNetCDF, "def_grp", rb_nc_def_grp, -1);
2580
+ rb_define_module_function(mNetCDF, "nc_inq_dimids", rb_nc_inq_dimids, -1);
2581
+ rb_define_singleton_method(mNetCDF, "inq_dimids", rb_nc_inq_dimids, -1);
2582
+ rb_define_module_function(mNetCDF, "nc_inq_grp_full_ncid", rb_nc_inq_grp_full_ncid, -1);
2583
+ rb_define_singleton_method(mNetCDF, "inq_grp_full_ncid", rb_nc_inq_grp_full_ncid, -1);
2584
+ rb_define_module_function(mNetCDF, "nc_inq_grp_ncid", rb_nc_inq_grp_ncid, -1);
2585
+ rb_define_singleton_method(mNetCDF, "inq_grp_ncid", rb_nc_inq_grp_ncid, -1);
2586
+ rb_define_module_function(mNetCDF, "nc_inq_grp_parent", rb_nc_inq_grp_parent, -1);
2587
+ rb_define_singleton_method(mNetCDF, "inq_grp_parent", rb_nc_inq_grp_parent, -1);
2588
+ rb_define_module_function(mNetCDF, "nc_inq_grpname", rb_nc_inq_grpname, -1);
2589
+ rb_define_singleton_method(mNetCDF, "inq_grpname", rb_nc_inq_grpname, -1);
2590
+ rb_define_module_function(mNetCDF, "nc_inq_grpname_full", rb_nc_inq_grpname_full, -1);
2591
+ rb_define_singleton_method(mNetCDF, "inq_grpname_full", rb_nc_inq_grpname_full, -1);
2592
+ rb_define_module_function(mNetCDF, "nc_inq_grpname_len", rb_nc_inq_grpname_len, -1);
2593
+ rb_define_singleton_method(mNetCDF, "inq_grpname_len", rb_nc_inq_grpname_len, -1);
2594
+ rb_define_module_function(mNetCDF, "nc_inq_grps", rb_nc_inq_grps, -1);
2595
+ rb_define_singleton_method(mNetCDF, "inq_grps", rb_nc_inq_grps, -1);
2596
+ rb_define_module_function(mNetCDF, "nc_inq_ncid", rb_nc_inq_ncid, -1);
2597
+ rb_define_singleton_method(mNetCDF, "inq_ncid", rb_nc_inq_ncid, -1);
2598
+ rb_define_module_function(mNetCDF, "nc_inq_typeids", rb_nc_inq_typeids, -1);
2599
+ rb_define_singleton_method(mNetCDF, "inq_typeids", rb_nc_inq_typeids, -1);
2600
+ rb_define_module_function(mNetCDF, "nc_inq_varids", rb_nc_inq_varids, -1);
2601
+ rb_define_singleton_method(mNetCDF, "inq_varids", rb_nc_inq_varids, -1);
2602
+ rb_define_module_function(mNetCDF, "nc_rename_grp", rb_nc_rename_grp, -1);
2603
+ rb_define_singleton_method(mNetCDF, "rename_grp", rb_nc_rename_grp, -1);
2604
+ rb_define_module_function(mNetCDF, "nc_show_metadata", rb_nc_show_metadata, -1);
2605
+ rb_define_singleton_method(mNetCDF, "show_metadata", rb_nc_show_metadata, -1);
2606
+
2607
+
2608
+ rb_define_module_function(mNetCDF, "nc_copy_att", rb_nc_copy_att, -1);
2609
+ rb_define_singleton_method(mNetCDF, "copy_att", rb_nc_copy_att, -1);
2610
+
2611
+ rb_define_module_function(mNetCDF, "nc_inq_nvars", rb_nc_inq_nvars, -1);
2612
+ rb_define_singleton_method(mNetCDF, "inq_nvars", rb_nc_inq_nvars, -1);
2613
+
2614
+ rb_define_const(mNetCDF, "NC_NOERR", INT2NUM(NC_NOERR));
2615
+
2616
+ rb_define_const(mNetCDF, "NC_NOWRITE", INT2NUM(NC_NOWRITE));
2617
+ rb_define_const(mNetCDF, "NC_WRITE", INT2NUM(NC_WRITE));
2618
+ rb_define_const(mNetCDF, "NC_CLOBBER", INT2NUM(NC_CLOBBER));
2619
+ rb_define_const(mNetCDF, "NC_NOCLOBBER", INT2NUM(NC_NOCLOBBER));
2620
+ rb_define_const(mNetCDF, "NC_DISKLESS", INT2NUM(NC_DISKLESS));
2621
+ rb_define_const(mNetCDF, "NC_MMAP", INT2NUM(NC_MMAP));
2622
+ #if defined(NC_64BIT_DATA)
2623
+ rb_define_const(mNetCDF, "NC_64BIT_DATA", INT2NUM(NC_64BIT_DATA));
2624
+ #endif
2625
+ #if defined(NC_CDF5)
2626
+ rb_define_const(mNetCDF, "NC_CDF5", INT2NUM(NC_CDF5));
2627
+ #endif
2628
+ rb_define_const(mNetCDF, "NC_CLASSIC_MODEL", INT2NUM(NC_CLASSIC_MODEL));
2629
+ rb_define_const(mNetCDF, "NC_LOCK", INT2NUM(NC_LOCK));
2630
+ rb_define_const(mNetCDF, "NC_SHARE", INT2NUM(NC_SHARE));
2631
+ rb_define_const(mNetCDF, "NC_NETCDF4", INT2NUM(NC_NETCDF4));
2632
+ rb_define_const(mNetCDF, "NC_MPIIO", INT2NUM(NC_MPIIO));
2633
+ #if defined(NC_INMEMORY)
2634
+ rb_define_const(mNetCDF, "NC_INMEMORY", INT2NUM(NC_INMEMORY));
2635
+ #endif
2636
+ rb_define_const(mNetCDF, "NC_PNETCDF", INT2NUM(NC_PNETCDF));
2637
+
2638
+ rb_define_const(mNetCDF, "NC_FORMAT_CLASSIC", INT2NUM(NC_FORMAT_CLASSIC));
2639
+ #if defined(NC_FORMAT_64BIT_OFFSET)
2640
+ rb_define_const(mNetCDF, "NC_FORMAT_64BIT_OFFSET", INT2NUM(NC_FORMAT_64BIT_OFFSET));
2641
+ #endif
2642
+ rb_define_const(mNetCDF, "NC_FORMAT_64BIT", INT2NUM(NC_FORMAT_64BIT));
2643
+ rb_define_const(mNetCDF, "NC_FORMAT_NETCDF4", INT2NUM(NC_FORMAT_NETCDF4));
2644
+ rb_define_const(mNetCDF, "NC_FORMAT_NETCDF4_CLASSIC", INT2NUM(NC_FORMAT_NETCDF4_CLASSIC));
2645
+ #if defined(NC_FORMAT_64BIT_DATA)
2646
+ rb_define_const(mNetCDF, "NC_FORMAT_64BIT_DATA", INT2NUM(NC_FORMAT_64BIT_DATA));
2647
+ #endif
2648
+ #if defined(NC_FORMAT_CDF5)
2649
+ rb_define_const(mNetCDF, "NC_FORMAT_CDF5", INT2NUM(NC_FORMAT_CDF5));
2650
+ #endif
2651
+
2652
+ rb_define_const(mNetCDF, "NC_SIZEHINT_DEFAULT", INT2NUM(NC_SIZEHINT_DEFAULT));
2653
+
2654
+ rb_define_const(mNetCDF, "NC_ALIGN_CHUNK", INT2NUM(NC_ALIGN_CHUNK));
2655
+ rb_define_const(mNetCDF, "NC_UNLIMITED", INT2NUM(NC_UNLIMITED));
2656
+
2657
+ rb_define_const(mNetCDF, "NC_GLOBAL", INT2NUM(NC_GLOBAL));
2658
+ rb_define_const(mNetCDF, "NC_MAX_DIMS", INT2NUM(NC_MAX_DIMS));
2659
+ rb_define_const(mNetCDF, "NC_MAX_ATTRS", INT2NUM(NC_MAX_ATTRS));
2660
+ rb_define_const(mNetCDF, "NC_MAX_VARS", INT2NUM(NC_MAX_VARS));
2661
+ rb_define_const(mNetCDF, "NC_MAX_NAME", INT2NUM(NC_MAX_NAME));
2662
+ rb_define_const(mNetCDF, "NC_MAX_VAR_DIMS", INT2NUM(NC_MAX_VAR_DIMS));
2663
+ rb_define_const(mNetCDF, "NC_FILL", INT2NUM(NC_FILL));
2664
+ rb_define_const(mNetCDF, "NC_NOFILL", INT2NUM(NC_NOFILL));
2665
+
2666
+ rb_define_const(mNetCDF, "NC_ENDIAN_NATIVE", INT2NUM(NC_ENDIAN_NATIVE));
2667
+ rb_define_const(mNetCDF, "NC_ENDIAN_LITTLE", INT2NUM(NC_ENDIAN_LITTLE));
2668
+ rb_define_const(mNetCDF, "NC_ENDIAN_BIG", INT2NUM(NC_ENDIAN_BIG));
2669
+
2670
+ rb_define_const(mNetCDF, "NC_CHUNKED", INT2NUM(NC_CHUNKED));
2671
+ rb_define_const(mNetCDF, "NC_CONTIGUOUS", INT2NUM(NC_CONTIGUOUS));
2672
+
2673
+ rb_define_const(mNetCDF, "NC_NOCHECKSUM", INT2NUM(NC_NOCHECKSUM));
2674
+ rb_define_const(mNetCDF, "NC_FLETCHER32", INT2NUM(NC_FLETCHER32));
2675
+
2676
+ rb_define_const(mNetCDF, "NC_NOSHUFFLE", INT2NUM(NC_NOSHUFFLE));
2677
+ rb_define_const(mNetCDF, "NC_SHUFFLE", INT2NUM(NC_SHUFFLE));
2678
+
2679
+
2680
+ rb_define_const(mNetCDF, "NC_NAT", INT2NUM(NC_NAT));
2681
+ rb_define_const(mNetCDF, "NC_BYTE", INT2NUM(NC_BYTE));
2682
+ rb_define_const(mNetCDF, "NC_UBYTE", INT2NUM(NC_UBYTE));
2683
+ rb_define_const(mNetCDF, "NC_CHAR", INT2NUM(NC_CHAR));
2684
+ rb_define_const(mNetCDF, "NC_SHORT", INT2NUM(NC_SHORT));
2685
+ rb_define_const(mNetCDF, "NC_USHORT", INT2NUM(NC_USHORT));
2686
+ rb_define_const(mNetCDF, "NC_INT", INT2NUM(NC_INT));
2687
+ rb_define_const(mNetCDF, "NC_LONG", INT2NUM(NC_LONG));
2688
+ rb_define_const(mNetCDF, "NC_UINT", INT2NUM(NC_UINT));
2689
+ rb_define_const(mNetCDF, "NC_INT64", INT2NUM(NC_INT64));
2690
+ rb_define_const(mNetCDF, "NC_UINT64", INT2NUM(NC_UINT64));
2691
+ rb_define_const(mNetCDF, "NC_FLOAT", INT2NUM(NC_FLOAT));
2692
+ rb_define_const(mNetCDF, "NC_DOUBLE", INT2NUM(NC_DOUBLE));
2693
+ rb_define_const(mNetCDF, "NC_STRING", INT2NUM(NC_STRING));
2694
+
2695
+ // rb_define_const(mNetCDF, "NC_", INT2NUM(NC_));
2696
+
2697
+ rb_define_const(mNetCDF, "NC_VLEN", INT2NUM(NC_VLEN));
2698
+ rb_define_const(mNetCDF, "NC_OPAQUE", INT2NUM(NC_OPAQUE));
2699
+ rb_define_const(mNetCDF, "NC_ENUM", INT2NUM(NC_ENUM));
2700
+ rb_define_const(mNetCDF, "NC_COMPOUND", INT2NUM(NC_COMPOUND));
2701
+
2702
+
2703
+ rb_define_const(mNetCDF, "NC_FILL_BYTE", INT2NUM(NC_FILL_BYTE));
2704
+ rb_define_const(mNetCDF, "NC_FILL_CHAR", INT2NUM(NC_FILL_CHAR));
2705
+ rb_define_const(mNetCDF, "NC_FILL_SHORT", INT2NUM(NC_FILL_SHORT));
2706
+ rb_define_const(mNetCDF, "NC_FILL_INT", INT2NUM(NC_FILL_INT));
2707
+ rb_define_const(mNetCDF, "NC_FILL_FLOAT", rb_float_new(NC_FILL_FLOAT));
2708
+ rb_define_const(mNetCDF, "NC_FILL_DOUBLE", rb_float_new(NC_FILL_DOUBLE));
2709
+ rb_define_const(mNetCDF, "NC_FILL_UBYTE", UINT2NUM(NC_FILL_UBYTE));
2710
+ rb_define_const(mNetCDF, "NC_FILL_USHORT", UINT2NUM(NC_FILL_USHORT));
2711
+ rb_define_const(mNetCDF, "NC_FILL_UINT", UINT2NUM(NC_FILL_UINT));
2712
+ rb_define_const(mNetCDF, "NC_FILL_IN64", LL2NUM(NC_FILL_INT64));
2713
+ rb_define_const(mNetCDF, "NC_FILL_UIN64", ULL2NUM(NC_FILL_INT64));
2714
+ rb_define_const(mNetCDF, "NC_FILL_STRING", rb_str_new2(NC_FILL_STRING));
2715
+
2716
+ }