1Bigarray.Array2(3)               OCaml library              Bigarray.Array2(3)
2
3
4

NAME

6       Bigarray.Array2 - Two-dimensional arrays.
7

Module

9       Module   Bigarray.Array2
10

Documentation

12       Module Array2
13        : sig end
14
15
16       Two-dimensional  arrays. The Array2 structure provides operations simi‐
17       lar to those of Bigarray.Genarray , but  specialized  to  the  case  of
18       two-dimensional arrays.
19
20
21
22
23
24       type ('a, 'b, 'c) t
25
26
27       The  type  of two-dimensional big arrays whose elements have OCaml type
28       'a , representation kind 'b , and memory layout 'c .
29
30
31
32       val create : ('a, 'b) Bigarray.kind -> 'c Bigarray.layout -> int -> int
33       -> ('a, 'b, 'c) t
34
35
36       Array2.create  kind  layout  dim1  dim2  returns  a new bigarray of two
37       dimension, whose size is dim1 in the first dimension and  dim2  in  the
38       second dimension.  kind and layout determine the array element kind and
39       the array layout as described for Bigarray.Genarray.create .
40
41
42
43       val dim1 : ('a, 'b, 'c) t -> int
44
45       Return the first dimension of the given two-dimensional big array.
46
47
48
49       val dim2 : ('a, 'b, 'c) t -> int
50
51       Return the second dimension of the given two-dimensional big array.
52
53
54
55       val kind : ('a, 'b, 'c) t -> ('a, 'b) Bigarray.kind
56
57       Return the kind of the given big array.
58
59
60
61       val layout : ('a, 'b, 'c) t -> 'c Bigarray.layout
62
63       Return the layout of the given big array.
64
65
66
67       val change_layout : ('a, 'b, 'c) t -> 'd Bigarray.layout  ->  ('a,  'b,
68       'd) t
69
70
71       Array2.change_layout  a  layout  returns  a bigarray with the specified
72       layout , sharing the data with a (and hence having the same  dimensions
73       as a ). No copying of elements is involved: the new array and the orig‐
74       inal array share the same storage space.  The dimensions are  reversed,
75       such  that get v [| a; b |] in C layout becomes get v [| b+1; a+1 |] in
76       Fortran layout.
77
78
79       Since 4.06.0
80
81
82
83       val size_in_bytes : ('a, 'b, 'c) t -> int
84
85
86       size_in_bytes a is the number of elements  in  a  multiplied  by  a  's
87       Bigarray.kind_size_in_bytes .
88
89
90       Since 4.03.0
91
92
93
94       val get : ('a, 'b, 'c) t -> int -> int -> 'a
95
96
97       Array2.get  a  x y , also written a.{x,y} , returns the element of a at
98       coordinates ( x , y ).  x and y must be within the bounds  of  a  ,  as
99       described  for  Bigarray.Genarray.get  ; otherwise, Invalid_argument is
100       raised.
101
102
103
104       val set : ('a, 'b, 'c) t -> int -> int -> 'a -> unit
105
106
107       Array2.set a x y v , or alternatively a.{x,y} <- v , stores the value v
108       at coordinates ( x , y ) in a .  x and y must be within the bounds of a
109       , as described for Bigarray.Genarray.set ; otherwise,  Invalid_argument
110       is raised.
111
112
113
114       val  sub_left : ('a, 'b, Bigarray.c_layout) t -> int -> int -> ('a, 'b,
115       Bigarray.c_layout) t
116
117       Extract a two-dimensional sub-array of the  given  two-dimensional  big
118       array   by   restricting  the  first  dimension.   See  Bigarray.Genar‐
119       ray.sub_left for more details.  Array2.sub_left applies only to  arrays
120       with C layout.
121
122
123
124       val  sub_right  :  ('a, 'b, Bigarray.fortran_layout) t -> int -> int ->
125       ('a, 'b, Bigarray.fortran_layout) t
126
127       Extract a two-dimensional sub-array of the  given  two-dimensional  big
128       array   by  restricting  the  second  dimension.   See  Bigarray.Genar‐
129       ray.sub_right for  more  details.   Array2.sub_right  applies  only  to
130       arrays with Fortran layout.
131
132
133
134       val  slice_left  :  ('a,  'b,  Bigarray.c_layout)  t -> int -> ('a, 'b,
135       Bigarray.c_layout) Bigarray.Array1.t
136
137       Extract a row (one-dimensional slice) of the given two-dimensional  big
138       array.   The integer parameter is the index of the row to extract.  See
139       Bigarray.Genarray.slice_left  for  more   details.    Array2.slice_left
140       applies only to arrays with C layout.
141
142
143
144       val  slice_right  :  ('a, 'b, Bigarray.fortran_layout) t -> int -> ('a,
145       'b, Bigarray.fortran_layout) Bigarray.Array1.t
146
147       Extract a column (one-dimensional slice) of the  given  two-dimensional
148       big  array.   The  integer  parameter  is  the  index  of the column to
149       extract.    See   Bigarray.Genarray.slice_right   for   more   details.
150       Array2.slice_right applies only to arrays with Fortran layout.
151
152
153
154       val blit : ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit
155
156       Copy  the first big array to the second big array.  See Bigarray.Genar‐
157       ray.blit for more details.
158
159
160
161       val fill : ('a, 'b, 'c) t -> 'a -> unit
162
163       Fill the given big array with the  given  value.   See  Bigarray.Genar‐
164       ray.fill for more details.
165
166
167
168       val of_array : ('a, 'b) Bigarray.kind -> 'c Bigarray.layout -> 'a array
169       array -> ('a, 'b, 'c) t
170
171       Build a two-dimensional big array initialized from the given  array  of
172       arrays.
173
174
175
176       val unsafe_get : ('a, 'b, 'c) t -> int -> int -> 'a
177
178       Like Bigarray.Array2.get , but bounds checking is not always performed.
179
180
181
182       val unsafe_set : ('a, 'b, 'c) t -> int -> int -> 'a -> unit
183
184       Like Bigarray.Array2.set , but bounds checking is not always performed.
185
186
187
188
189
190OCamldoc                          2019-02-02                Bigarray.Array2(3)
Impressum