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

NAME

6       Bigarray.Array1 - One-dimensional arrays.
7

Module

9       Module   Bigarray.Array1
10

Documentation

12       Module Array1
13        : sig end
14
15
16       One-dimensional  arrays. The Array1 structure provides operations simi‐
17       lar to those of Bigarray.Genarray , but  specialized  to  the  case  of
18       one-dimensional   arrays.   (The  Bigarray.Array2  and  Bigarray.Array3
19       structures  below  provide  operations   specialized   for   two-   and
20       three-dimensional arrays.)  Statically knowing the number of dimensions
21       of  the  array  allows  faster  operations,  and  more  precise  static
22       type-checking.
23
24
25
26
27
28       type ('a, 'b, 'c) t
29
30
31       The  type  of one-dimensional big arrays whose elements have OCaml type
32       'a , representation kind 'b , and memory layout 'c .
33
34
35
36       val create : ('a, 'b) Bigarray.kind -> 'c  Bigarray.layout  ->  int  ->
37       ('a, 'b, 'c) t
38
39
40       Array1.create  kind layout dim returns a new bigarray of one dimension,
41       whose size is dim .  kind and layout determine the array  element  kind
42       and the array layout as described for Bigarray.Genarray.create .
43
44
45
46       val dim : ('a, 'b, 'c) t -> int
47
48       Return the size (dimension) of the given one-dimensional big array.
49
50
51
52       val kind : ('a, 'b, 'c) t -> ('a, 'b) Bigarray.kind
53
54       Return the kind of the given big array.
55
56
57
58       val layout : ('a, 'b, 'c) t -> 'c Bigarray.layout
59
60       Return the layout of the given big array.
61
62
63
64       val  change_layout  :  ('a, 'b, 'c) t -> 'd Bigarray.layout -> ('a, 'b,
65       'd) t
66
67
68       Array1.change_layout a layout returns a  bigarray  with  the  specified
69       layout  ,  sharing the data with a (and hence having the same dimension
70       as a ). No copying of elements is involved: the new array and the orig‐
71       inal array share the same storage space.
72
73
74       Since 4.06.0
75
76
77
78       val size_in_bytes : ('a, 'b, 'c) t -> int
79
80
81       size_in_bytes  a  is  the  number  of  elements in a multiplied by a 's
82       Bigarray.kind_size_in_bytes .
83
84
85       Since 4.03.0
86
87
88
89       val get : ('a, 'b, 'c) t -> int -> 'a
90
91
92       Array1.get a x , or alternatively a.{x} , returns the element of  a  at
93       index  x  .   x  must be greater or equal than 0 and strictly less than
94       Array1.dim a if a has C layout.  If a has Fortran  layout,  x  must  be
95       greater  or  equal than 1 and less or equal than Array1.dim a .  Other‐
96       wise, Invalid_argument is raised.
97
98
99
100       val set : ('a, 'b, 'c) t -> int -> 'a -> unit
101
102
103       Array1.set a x v , also written a.{x} <- v ,  stores  the  value  v  at
104       index x in a .  x must be inside the bounds of a as described in Bigar‐
105       ray.Array1.get ; otherwise, Invalid_argument is raised.
106
107
108
109       val sub : ('a, 'b, 'c) t -> int -> int -> ('a, 'b, 'c) t
110
111       Extract a sub-array of the given one-dimensional big array.  See Bigar‐
112       ray.Genarray.sub_left for more details.
113
114
115
116       val slice : ('a, 'b, 'c) t -> int -> ('a, 'b, 'c) Bigarray.Array0.t
117
118       Extract  a scalar (zero-dimensional slice) of the given one-dimensional
119       big array.  The integer  parameter  is  the  index  of  the  scalar  to
120       extract.     See   Bigarray.Genarray.slice_left   and   Bigarray.Genar‐
121       ray.slice_right for more details.
122
123
124       Since 4.05.0
125
126
127
128       val blit : ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit
129
130       Copy the first big array to the second big array.  See  Bigarray.Genar‐
131       ray.blit for more details.
132
133
134
135       val fill : ('a, 'b, 'c) t -> 'a -> unit
136
137       Fill  the  given  big  array with the given value.  See Bigarray.Genar‐
138       ray.fill for more details.
139
140
141
142       val of_array : ('a, 'b) Bigarray.kind -> 'c Bigarray.layout -> 'a array
143       -> ('a, 'b, 'c) t
144
145       Build a one-dimensional big array initialized from the given array.
146
147
148
149       val unsafe_get : ('a, 'b, 'c) t -> int -> 'a
150
151       Like Bigarray.Array1.get , but bounds checking is not always performed.
152       Use with caution and only when the program logic  guarantees  that  the
153       access is within bounds.
154
155
156
157       val unsafe_set : ('a, 'b, 'c) t -> int -> 'a -> unit
158
159       Like Bigarray.Array1.set , but bounds checking is not always performed.
160       Use with caution and only when the program logic  guarantees  that  the
161       access is within bounds.
162
163
164
165
166
167OCamldoc                          2019-02-02                Bigarray.Array1(3)
Impressum