carray 1.3.6 → 1.3.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,1115 +0,0 @@
1
-
2
- class CArray
3
- end
4
- class CScalar
5
- end
6
- module CA
7
- end
8
- class CABitField < CAVirtual # :nodoc:
9
- end
10
-
11
- class CArray
12
- def bitfield (range, type)
13
- end
14
- end
15
-
16
- class CAShift < CAVirtual # :nodoc:
17
- end
18
-
19
- class CArray
20
- def shifted
21
- end
22
- end
23
-
24
- class CArray::DataTypeError # :nodoc:
25
- end
26
-
27
- class CArray
28
- VERSION = nil # :nodoc:
29
- VERSION_CODE = nil # :nodoc:
30
- VERSION_MAJOR = nil # :nodoc:
31
- VERSION_MINOR = nil # :nodoc:
32
- VERSION_TEENY = nil # :nodoc:
33
- VERSION_DATE = nil # :nodoc:
34
- end
35
-
36
- class CAIterator
37
- def rank
38
- end
39
- end
40
-
41
- class CAIterator
42
- def dim
43
- end
44
- end
45
-
46
- class CAIterator
47
- def elements
48
- end
49
- end
50
-
51
- class CAIterator
52
- def reference
53
- end
54
- end
55
-
56
- class CAIterator
57
- def kernel_at_addr
58
- end
59
- end
60
-
61
- class CAIterator
62
- def kernel_at_index
63
- end
64
- end
65
-
66
- class CAIterator
67
- def kernel_move_to_addr
68
- end
69
- end
70
-
71
- class CAIterator
72
- def kernel_move_to_index
73
- end
74
- end
75
-
76
- class CAIterator
77
- def prepare_output
78
- end
79
- end
80
-
81
- class CAIterator
82
- def calculate
83
- end
84
- end
85
-
86
- class CAIterator
87
- def filter
88
- end
89
- end
90
-
91
- class CAIterator
92
- def evaluate
93
- end
94
- end
95
-
96
- class CArray
97
- def fill
98
- end
99
- def fill_copy
100
- end
101
- end
102
-
103
- def CArray.guess_array_shape (arg)
104
- end
105
-
106
- class CArray
107
- def [] (*spec)
108
- end
109
- end
110
-
111
- class CArray
112
- def []= (*spec)
113
- end
114
- end
115
-
116
- def CArray.scan_index(dim, idx)
117
- end
118
-
119
- class CArray
120
- def normalize_index (idx)
121
- end
122
- end
123
-
124
- class CArray
125
- # converts addr to index
126
- def addr2index (addr)
127
- end
128
- end
129
-
130
- class CArray
131
- def index2addr (*index)
132
- end
133
- end
134
-
135
- class CAGrid < CAVirtual # :nodoc:
136
- end
137
-
138
- class CArray
139
- def grid
140
- end
141
- end
142
-
143
- class CASelect < CAVirtual # :nodoc:
144
- end
145
-
146
- class CArray
147
- # call-seq:
148
- # ca.boolean
149
- # ca.int8
150
- # ca.uint8
151
- # ca.int16
152
- # ca.uint16
153
- # ca.int32
154
- # ca.uint32
155
- # ca.int64
156
- # ca.uint64
157
- # ca.float32
158
- # ca.float64
159
- # ca.float128
160
- # ca.cmplx64
161
- # ca.cmplx128
162
- # ca.cmplx256
163
- # ca.object
164
- # ca.fixlen
165
- # ca.byte
166
- # ca.short
167
- # ca.int
168
- # ca.float
169
- # ca.double
170
- # ca.complex
171
- # ca.dcomplex
172
- #
173
- # Convert to given data_type with copying values
174
- def to_type
175
- end
176
- end
177
-
178
- class CArray
179
- # call-seq:
180
- # ca.as_int8
181
- # ca.as_uint8
182
- # ca.as_int16
183
- # ca.as_uint16
184
- # ca.as_int32
185
- # ca.as_uint32
186
- # ca.as_int64
187
- # ca.as_uint64
188
- # ca.as_float32
189
- # ca.as_float64
190
- # ca.as_float128
191
- # ca.as_cmplx64
192
- # ca.as_cmplx128
193
- # ca.as_cmplx256
194
- # ca.as_object
195
- # ca.as_byte
196
- # ca.as_short
197
- # ca.as_int
198
- # ca.as_float
199
- # ca.as_double
200
- # ca.as_complex
201
- # ca.as_dcomplex
202
- #
203
- # Fakes data_type
204
- def as_type
205
- end
206
- end
207
-
208
- def CArray.wrap_writable
209
- end
210
-
211
- def CArray.wrap_readonly
212
- end
213
-
214
- class CABlock < CAVirtual # :nodoc:
215
- end
216
-
217
- class CABlock
218
- def size0
219
- end
220
- def start
221
- end
222
- def step
223
- end
224
- def count
225
- end
226
- def offset
227
- end
228
- end
229
-
230
- class CABlock
231
- def idx2addr0 (idx)
232
- end
233
- end
234
-
235
- class CABlock
236
- def addr2addr0 (addr)
237
- end
238
- end
239
-
240
- class CABlock
241
- def move (*index)
242
- end
243
- end
244
-
245
- # Iterates with the multi-dimensional indeces for the given
246
- # dimension numbers.
247
- #
248
- # CArray.each_index(3,2){|i,j| print "(#{i} #{j}) " }
249
- #
250
- # produces:
251
- #
252
- # (0 0) (0 1) (1 0) (1 1) (2 0) (2 1) (3 0) (3 1)
253
- #
254
- def CArray.each_index(*argv) # :yields: i0, i1, ...
255
- end
256
-
257
- class CArray
258
- #
259
- def each # :yields: v
260
- end
261
- end
262
-
263
- class CArray
264
- #
265
- def each_with_addr # :yields: v, addr
266
- end
267
- end
268
-
269
- class CArray
270
- #
271
- def each_addr() # :yields: addr
272
- end
273
- end
274
-
275
- class CArray
276
- # Iterates with the multi-dimensional indeces for the dimension of <i>ca</i>.
277
- #
278
- # CArray.int(3,2).each_index(){|i,j| print "(#{i} #{j}) " }
279
- #
280
- # <em>produces:</em>
281
- #
282
- # (0 0) (0 1) (1 0) (1 1) (2 0) (2 1) (3 0) (3 1)
283
- #
284
- def each_index # :yields: i0, i1, ...
285
- end
286
- end
287
-
288
- class CArray
289
- #
290
- def map! # :yields: v
291
- end
292
- end
293
-
294
- class CArray
295
- #
296
- def each_with_index # :yields: v, idx
297
- end
298
- end
299
-
300
- class CArray
301
- #
302
- def map_with_index! # :yields: v, idx
303
- end
304
- end
305
-
306
- class CArray
307
- #
308
- def map_index! # :yields: i0, i1, ...
309
- end
310
- end
311
-
312
- class CArray
313
- #
314
- def map_with_addr! # :yields: v, addr
315
- end
316
- end
317
-
318
- class CArray
319
- #
320
- def map_addr! # :yields: addr
321
- end
322
- end
323
-
324
- class CArray
325
- # returns the number of elements
326
- def elements
327
- end
328
-
329
- # alias of `CArray#elements`
330
- alias length elements
331
-
332
- # alias of `CArray#elements`
333
- alias size elements
334
- end
335
-
336
- class CArray
337
- # use CArray#shape instead of this method after carray-1.3.0
338
- # returns the Array object contains the dimensional shape of array
339
- # (e.g. [2,3] for 2D 2x3 array, ...).
340
- def dim
341
- end
342
-
343
- # returns the Array object contains the dimensional shape of array
344
- # (e.g. [2,3] for 2D 2x3 array, ...).
345
- def shape
346
- end
347
-
348
- # short-hand for dim[0]
349
- def dim0
350
- end
351
-
352
- # short-hand for dim[1]
353
- def dim1
354
- end
355
-
356
- # short-hand for dim[2]
357
- def dim2
358
- end
359
-
360
- # short-hand for dim[3]
361
- def dim3
362
- end
363
- end
364
-
365
- class CArray
366
- # returns the string representaion of the data_type (e.g. "int32", "fixlen")
367
- def data_type_name
368
- end
369
- end
370
-
371
- class CArray
372
- # returns true if `self` is a CScalar object
373
- def scalar?
374
- end
375
- end
376
-
377
- class CArray
378
- # returns true if `self` is an entity array (not a virtual array).
379
- def entity?
380
- end
381
-
382
- # returns true if `self` is a virtural array (not an entity array).
383
- def virtual?
384
- end
385
- end
386
-
387
- def CArray.guess_type_and_bytes (type, bytes=0)
388
- end
389
-
390
- class CAFake < CAVirtual # :nodoc:
391
- end
392
-
393
- class CArray
394
- def fake (data_type, options={:bytes=>0})
395
- end
396
- end
397
-
398
- class CArray
399
- end
400
- class CAWrap < CArray # :nodoc:
401
- end
402
- class CScalar < CArray
403
- end
404
- class CAVirtual < CArray # :nodoc:
405
- end
406
-
407
- # returns the threshold of incremented memory (MB) used by carray object
408
- # until start GC.
409
- def CArray.gc_interval ()
410
- end
411
- # set the threshold of incremented memory (MB) used by carray object
412
- # until start GC.
413
- def CArray.gc_interval= (val)
414
- end
415
- # reset the counter for the GC start when the incremented memory
416
- # get larger than `CArray.gc_interval`.
417
- def CArray.reset_gc_interval ()
418
- end
419
-
420
- # call-seq:
421
- # CArray.new(data_type, dim, bytes=0) { ... }
422
- #
423
- # Constructs a new CArray object of <i>data_type</i>, which has the
424
- # rank and the dimensions specified by an <code>Array</code> of
425
- # <code>Integer</code> or an argument list of <code>Integer</code>.
426
- # The byte size of each element for the fixed length data type
427
- # (<code>data_type == CA_FIXLEN</code>) is specified optional argument
428
- # <i>bytes</i>. Otherwise, this optional argument has no
429
- # effect. If the block is given, the new CArray
430
- # object will be initialized by the value returned from the block.
431
- def CArray.new(data_type, dim, bytes=0)
432
- end
433
-
434
- def CArray.wrap (data_type, dim, bytes=0) # { wrapped_object }
435
- end
436
-
437
- # call-seq:
438
- # CScalar.new(data_type, bytes=0) { ... }
439
- #
440
- # Constructs a new CScalar object of <i>data_type</i>.
441
- # The byte size of each element for the fixed length data type
442
- # (<code>data_type == CA_FIXLEN</code>) is specified optional argument
443
- # <i>bytes</i>. Otherwise, this optional argument has no
444
- # effect. If the block is given, the new CScalar
445
- # object will be initialized by the value returned from the block.
446
- def CScalar.new(data_type,bytes=0)
447
- end
448
-
449
- # call-seq:
450
- # CArray.boolean(...) { init_value }
451
- # CArray.int8(...) { init_value }
452
- # CArray.uint8(...) { init_value }
453
- # CArray.int16(...) { init_value }
454
- # CArray.uint16(...) { init_value }
455
- # CArray.int32(...) { init_value }
456
- # CArray.uint32(...) { init_value }
457
- # CArray.int64(...) { init_value }
458
- # CArray.uint64(...) { init_value }
459
- # CArray.float32(...) { init_value }
460
- # CArray.float64(...) { init_value }
461
- # CArray.float128(...) { init_value }
462
- # CArray.cmplx64(...) { init_value }
463
- # CArray.cmplx128(...) { init_value }
464
- # CArray.cmplx256(...) { init_value }
465
- # CArray.fixlen(...) { init_value }
466
- # CArray.object(...) { init_value }
467
- # CArray.byte(...) { init_value }
468
- # CArray.short(...) { init_value }
469
- # CArray.int(...) { init_value }
470
- # CArray.float(...) { init_value }
471
- # CArray.double(...) { init_value }
472
- # CArray.complex(...) { init_value }
473
- # CArray.dcomplex(...) { init_value }
474
- #
475
- def CArray.type
476
- end
477
-
478
- # call-seq:
479
- # CScalar.boolean { init_value }
480
- # CScalar.int8 { init_value }
481
- # CScalar.uint8 { init_value }
482
- # CScalar.int16 { init_value }
483
- # CScalar.uint16 { init_value }
484
- # CScalar.int32 { init_value }
485
- # CScalar.uint32 { init_value }
486
- # CScalar.int64 { init_value }
487
- # CScalar.uint64 { init_value }
488
- # CScalar.float32 { init_value }
489
- # CScalar.float64 { init_value }
490
- # CScalar.float128 { init_value }
491
- # CScalar.cmplx64 { init_value }
492
- # CScalar.cmplx128 { init_value }
493
- # CScalar.cmplx256 { init_value }
494
- # CScalar.fixlen { init_value }
495
- # CScalar.object { init_value }
496
- # CScalar.byte { init_value }
497
- # CScalar.short { init_value }
498
- # CScalar.int { init_value }
499
- # CScalar.float { init_value }
500
- # CScalar.double { init_value }
501
- # CScalar.complex { init_value }
502
- # CScalar.dcomplex { init_value }
503
- #
504
- def CScalar.type
505
- end
506
-
507
- class CArray
508
- # Sets true at the given index for the boolean array and returns self.
509
- # It accept the arguments same as for CArray#[].
510
- def set (*argv)
511
- end
512
- # Sets false at the given index for the boolean array and returns self.
513
- # It accept the arguments same as for CArray#[].
514
- def unset (*argv)
515
- end
516
- end
517
-
518
- class CArray
519
- # Returns the 1d index array for non-zero elements of self
520
- def where
521
- end
522
- end
523
-
524
- class CArray
525
- # call-seq:
526
- # seq (init_val=0, step=1)
527
- # seq (init_val=0, step=1) {|x| ... }
528
- # seq (init_val=0, step=A_symbol) ### for object array
529
- # seq (init_val=0, step=A_symbol) {|x| ...} ### for object array
530
- #
531
- # Generates sequential data with initial value `init_val`
532
- # and step value `step`. For object array, if the second argument
533
- # is Symbol object, it will be interpreted as stepping method and
534
- # it is called for the last element in each step.
535
- #
536
- def seq (init_val=0, step=1)
537
- end
538
- #
539
- def seq! (init_val=0, step=1)
540
- end
541
- end
542
-
543
- class CArray
544
- # Swaps the byte order of each element.
545
- def swap_bytes
546
- end
547
- #
548
- def swap_bytes!
549
- end
550
- end
551
-
552
- class CArray
553
- # trims the data into the range between min and max. If `fill_value`
554
- # is given, the element out of the range between min and max is filled
555
- # by `fill_value`
556
- def trim (min, max, fill_value=nil)
557
- end
558
- #
559
- def trim! (min, max, fill_value=nil)
560
- end
561
- end
562
-
563
- # returns index table for index sort
564
- #
565
- # idx = CA.sort_addr(a, b, c) ### priority a > b > c
566
- # a[idx]
567
- # b[idx]
568
- # c[idx]
569
-
570
- def CA.sort_addr (*args)
571
- end
572
-
573
- class CArray
574
- # returns index table for index sort
575
- # This method same as,
576
- #
577
- # idx = CA.sort_addr(self, *args)
578
- def sort_addr (*args)
579
- end
580
- end
581
-
582
- class CAWindowIterator < CAIterator # :nodoc:
583
- end
584
-
585
- class CAUnboundRepeat < CArray
586
- end
587
-
588
- class CAUnboundRepeat
589
- def bind_with(other)
590
- end
591
- end
592
-
593
- class CAUnboundRepeat
594
- def bind(*index)
595
- end
596
- end
597
-
598
- class CAObject < CAVirtual # :nodoc:
599
- end
600
-
601
- class CAObjectMask < CAVirtual # :nodoc:
602
- end
603
-
604
- class CATranspose < CAVirtual # :nodoc:
605
- end
606
-
607
- class CArray
608
- def transposed
609
- end
610
- end
611
-
612
- class CArray
613
- def random! (max=1.0)
614
- end
615
- end
616
-
617
- class CArray
618
- # create CArray object from `self` with same contents includes mask state.
619
- def to_ca
620
- end
621
- end
622
-
623
- class CArray
624
- # returns CArray object with same dimension with `self`
625
- # The data type of the new carray object can be specified by `data_type`.
626
- # For fixlen data type, the option `:bytes` is used to specified the
627
- # data length.
628
- def template(data_type=self.data_type, options={:bytes=>0})
629
- end
630
- end
631
-
632
- class CArray
633
- # pastes `ary` to `self` at the index `idx`.
634
- # `idx` should be Array object with the length same as `self.rank`.
635
- # `ary` should have same shape with `self`.
636
- def paste (idx, ary)
637
- end
638
- end
639
-
640
- class CArray
641
- # clips the data at `idx` from `self` to `ary`.
642
- def clip (idx, ary)
643
- end
644
- end
645
-
646
- class CABlockIterator < CAIterator # :nodoc:
647
- end
648
-
649
- class CArray
650
- # Create block iterator.
651
- def blocks (*args)
652
- end
653
- end
654
-
655
- class CAReduce < CAVirtual # :nodoc:
656
- end
657
-
658
- class CAFArray < CAVirtual # :nodoc:
659
- end
660
-
661
- class CArray
662
- # create the virtual transposed array which dimension order is reversed.
663
- def t
664
- end
665
- end
666
-
667
- class CArray
668
- # Returns true if self has the mask array.
669
- def has_mask?()
670
- end
671
- end
672
-
673
- class CArray
674
- # Returns true if self has at least one masked element.
675
- def any_masked?
676
- end
677
- end
678
-
679
- class CArray
680
- # Returns true if all elements of self are masked.
681
- def all_masked?
682
- end
683
- end
684
-
685
- class CArray
686
- private
687
- def create_mask
688
- end
689
- end
690
-
691
- class CArray
692
- private
693
- def update_mask
694
- end
695
- end
696
-
697
- class CArray
698
- # Returns new array which refers the data of <code>self</code>.
699
- # The data of masked elements of <code>self</code> can be accessed
700
- # via the returned array. The value array can't be set mask.
701
- def value ()
702
- end
703
- end
704
-
705
- class CArray
706
- # Returns new array which refers the mask state of <code>self</code>.
707
- # The mask array can't be set mask.
708
- def mask ()
709
- end
710
- end
711
-
712
- class CArray
713
- # Asigns <code>new_mask</code> to the mask array of <code>self</code>.
714
- # If <code>self</code> doesn't have a mask array, it will be created
715
- # before asignment.
716
- def mask= (new_mask)
717
- end
718
- end
719
-
720
- class CArray
721
- # Returns new boolean type array of same shape with <code>self</code>.
722
- # The returned array has 1 for the masked elements and
723
- # 0 for not-masked elements.
724
- def is_masked ()
725
- end
726
- end
727
-
728
- class CArray
729
- # Returns new boolean type array of same shape with <code>self</code>.
730
- # The returned array has 0 for the masked elements and
731
- # 1 for not-masked elements.
732
- def is_not_masked ()
733
- end
734
- end
735
-
736
- class CArray
737
- # Returns the number of masked elements.
738
- def count_masked ()
739
- end
740
- end
741
-
742
- class CArray
743
- # Returns the number of not-masked elements.
744
- def count_not_masked ()
745
- end
746
- end
747
-
748
- class CArray
749
- # Returns new unmasked array.
750
- # If the optional argument <code>fill_value</code> is given,
751
- # the masked elements are filled by <code>fill_value</code>.
752
- # The returned array doesn't have the mask array.
753
- def unmask_copy (fill_value=nil)
754
- end
755
- end
756
-
757
- class CArray
758
- # Sets the mask array of <code>self</code> by the logical sum of
759
- # the mask states of <code>self</code> and arrays given in arguments.
760
- def inherit_mask (*argv)
761
- end
762
- end
763
-
764
- class CArray
765
- # Sets the mask array of <code>self</code> by the logical sum of
766
- # the mask states of arrays given in arguments.
767
- def inherit_mask_replace (*argv)
768
- end
769
- end
770
-
771
- # returns the machine endianness.
772
- # CArray.endian #=> 0 (CA_LITTLE_ENDIAN)
773
- # CArray.endian #=> 1 (CA_BIG_ENDIAN)
774
-
775
- def CArray.endian
776
- end
777
-
778
- # returns true if the byte order of the architecture is
779
- # big endian.
780
-
781
- def CArray.big_endian?
782
- end
783
-
784
- # returns true if the byte order of the architecture is
785
- # little endian.
786
-
787
- def CArray.little_endian?
788
- end
789
-
790
- # Returns the byte length of an element of the given data type.
791
- # Retruns <code>0</code> if data_type is equal to CA_FIXLEN.
792
- # CArray.sizeof(CA_INT32) #=> 4
793
- # CArray.sizeof(CA_DOUBLE) #=> 8
794
- # CArray.sizeof(CA_FIXLEN) #=> 0
795
-
796
- def CArray.sizeof (data_type)
797
- end
798
-
799
- # Returns true if the given data_type indicate the valid data_type.
800
-
801
- def CArray.data_type?(data_type)
802
- end
803
-
804
- # Returns string representaion of the data_type specifier.
805
-
806
- def CArray.data_type_name(data_type)
807
- end
808
-
809
- class CArray
810
- def coerce (other)
811
- end
812
- end
813
-
814
- def CArray.attach(*argv) # :nodoc:
815
- yield
816
- end
817
-
818
- def CArray.attach!(*argv) # :nodoc:
819
- yield
820
- end
821
-
822
- class CArray
823
- def attach () # :nodoc:
824
- yield
825
- end
826
- end
827
-
828
- class CArray
829
- def attach! () # :nodoc:
830
- yield
831
- end
832
- end
833
-
834
- class CArray
835
- # Returns data class member names
836
- def members
837
- end
838
- end
839
-
840
- class CArray
841
- # Returns an array of data class members (fields)
842
- def fields
843
- end
844
- end
845
-
846
- class CArray
847
- # Returns an array of data class members (fields) with names specified
848
- def fields_at (*names)
849
- end
850
- end
851
-
852
- class CArray
853
- def project (idx,lval=nil,uval=nil)
854
- end
855
- end
856
-
857
- class CArray
858
- # Reverses the elements of +ca+ in place.
859
- def reverse!
860
- end
861
- end
862
-
863
- class CArray
864
- # Returns a new CArray object containing <i>ca</i>'s elements in
865
- # reverse order.
866
- def reverse
867
- end
868
- end
869
-
870
- class CArray
871
- # Sorts <i>ca</i>'s elements in place.
872
- def sort!
873
- end
874
- end
875
-
876
- class CArray
877
- # Returns a new CArray object containing <i>ca</i>'s elements sorted.
878
- def sort
879
- end
880
- end
881
-
882
- class CArray
883
- # shuffles the elements.
884
- # If `self` has mask, the masked elements are also moved by shuffling.
885
- def shuffle!
886
- end
887
- end
888
-
889
- class CArray
890
- def shuffle
891
- end
892
- end
893
-
894
- class CArray
895
- def bsearch
896
- end
897
- end
898
-
899
- class CArray
900
- def bsearch_index
901
- end
902
- end
903
-
904
- class CArray
905
- def search
906
- end
907
- end
908
-
909
- class CArray
910
- def search_index
911
- end
912
- end
913
-
914
- class CArray
915
- def search_nearest
916
- end
917
- end
918
-
919
- class CAWindow < CAVirtual # :nodoc:
920
- end
921
-
922
- class CArray
923
- def window (*argv)
924
- end
925
- end
926
-
927
- class CAWindow
928
- def index2addr0 (idx)
929
- end
930
- end
931
-
932
- class CAWindow
933
- def addr2addr0 (addr)
934
- end
935
- end
936
-
937
- class CAWindow
938
- def fill_value
939
- end
940
- def fill_value= (val)
941
- end
942
- end
943
-
944
- class CAWindow
945
- def size0
946
- end
947
- def start
948
- end
949
- def step
950
- end
951
- def count
952
- end
953
- def offset
954
- end
955
- end
956
-
957
- class CAMapping < CAVirtual # :nodoc:
958
- end
959
-
960
- class CADimensionIterator < CAIterator # :nodoc:
961
- end
962
-
963
- class CADimensionIterator
964
- def sym2dim (sym)
965
- end
966
- end
967
-
968
- class CARepeat < CAVirtual # :nodoc:
969
- end
970
-
971
- class CArray
972
- def valid_index? (*index)
973
- end
974
- end
975
-
976
- class CArray
977
- def valid_addr? (addr)
978
- end
979
- end
980
-
981
- class CArray
982
- def has_same_shape? (other)
983
- end
984
- end
985
-
986
- class CArray
987
- def == (other)
988
- end
989
- alias eql? ==
990
- end
991
-
992
- class CArray
993
- def hash
994
- end
995
- end
996
-
997
- class CAField < CAVirtual # :nodoc:
998
- end
999
-
1000
- class CArray
1001
- # call-seq:
1002
- # CArray#field(offset, data_type[, :bytes=>bytes])
1003
- # CArray#field(offset, data_class)
1004
- # CArray#field(offset, template)
1005
- #
1006
- def field (offset, data_type)
1007
- end
1008
- end
1009
-
1010
- class CArray
1011
- def elem_swap
1012
- end
1013
- end
1014
-
1015
- class CArray
1016
- def elem_copy
1017
- end
1018
- end
1019
-
1020
- class CArray
1021
- def elem_store
1022
- end
1023
- end
1024
-
1025
- class CArray
1026
- def elem_fetch
1027
- end
1028
- end
1029
-
1030
- class CArray
1031
- def elem_incr
1032
- end
1033
- end
1034
-
1035
- class CArray
1036
- def elem_decr
1037
- end
1038
- end
1039
-
1040
- class CArray
1041
- def elem_masked?
1042
- end
1043
- end
1044
-
1045
- class CArray
1046
- # used in CAHistogram.
1047
- def incr_addr
1048
- end
1049
- end
1050
-
1051
- class CABitArray < CAVirtual # :nodoc:
1052
- end
1053
-
1054
- class CArray
1055
- def bits
1056
- end
1057
- alias bitarray bits
1058
- end
1059
-
1060
- class CArray
1061
- # Converts the array to Ruby's array. For higher dimension,
1062
- # the array is nested rank-1 times.
1063
- def to_a
1064
- end
1065
- end
1066
-
1067
- class CArray
1068
- # Convert the
1069
- def convert (data_type=nil, dim=nil)
1070
- yield
1071
- end
1072
- end
1073
-
1074
- class CArray
1075
- # dumps the value array to the given IO stream
1076
- def dump_binary(io)
1077
- end
1078
- end
1079
-
1080
- class CArray
1081
- # dumps the value array to a string.
1082
- def to_s
1083
- end
1084
- end
1085
-
1086
- class CArray
1087
- # loads the value array from the given IO stream
1088
- def load_binary (io)
1089
- end
1090
- end
1091
-
1092
- class CArray
1093
- # Convert the
1094
- def convert (data_type=nil, dim=nil)
1095
- yield
1096
- end
1097
- end
1098
-
1099
- class CARefer < CAVirtual # :nodoc:
1100
- end
1101
-
1102
- class CArray
1103
- # call-seq:
1104
- # CArray.refer()
1105
- # CArray.refer(data_type, dim[, :bytes=>bytes, :offset=>offset])
1106
- # CArray.refer(data_class, dim)
1107
- #
1108
- # Returns CARefer object which refers self.
1109
- # In second form, `data_type` can be different data_type of self,
1110
- # as long as the total byte length of new array is smaller than
1111
- # that of self.
1112
- def refer (*argv)
1113
- end
1114
- end
1115
-