package owl-base

  1. Overview
  2. Docs
package owl-base
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Source file owl_types_ndarray_basic.ml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
# 1 "src/base/types/owl_types_ndarray_basic.ml"
(*
 * OWL - OCaml Scientific Computing
 * Copyright (c) 2016-2022 Liang Wang <liang@ocaml.xyz>
 *)

open Owl_types_common

module type Sig = sig
  (* types and constants *)

  type arr

  type elt

  val number : number

  (* creation and operation functions *)

  val empty : int array -> arr

  val zeros : int array -> arr

  val ones : int array -> arr

  val create : int array -> elt -> arr

  val sequential : ?a:elt -> ?step:elt -> int array -> arr

  val uniform : ?a:elt -> ?b:elt -> int array -> arr

  val gaussian : ?mu:elt -> ?sigma:elt -> int array -> arr

  val bernoulli : ?p:elt -> int array -> arr

  val init : int array -> (int -> elt) -> arr

  val init_nd : int array -> (int array -> elt) -> arr

  val shape : arr -> int array

  val numel : arr -> int

  val get : arr -> int array -> elt

  val set : arr -> int array -> elt -> unit

  val get_slice : int list list -> arr -> arr

  val set_slice : int list list -> arr -> arr -> unit

  val get_fancy : index list -> arr -> arr

  val set_fancy : index list -> arr -> arr -> unit

  val copy : arr -> arr

  val copy_ : out:arr -> arr -> unit (* FIXME: move to mutable? *)

  val reset : arr -> unit

  val reshape : arr -> int array -> arr

  val reverse : arr -> arr

  val tile : arr -> int array -> arr

  val repeat : arr -> int array -> arr

  val concatenate : ?axis:int -> arr array -> arr

  val stack : ?axis:int -> arr array -> arr

  val split : ?axis:int -> int array -> arr -> arr array

  val expand : ?hi:bool -> arr -> int -> arr

  val squeeze : ?axis:int array -> arr -> arr

  val draw : ?axis:int -> arr -> int -> arr * int array

  val map : (elt -> elt) -> arr -> arr

  val fold : ?axis:int -> (elt -> elt -> elt) -> elt -> arr -> arr

  val scan : ?axis:int -> (elt -> elt -> elt) -> arr -> arr

  val one_hot : int -> arr -> arr

  val pad : ?v:elt -> int list list -> arr -> arr

  val print
    :  ?max_row:int
    -> ?max_col:int
    -> ?header:bool
    -> ?fmt:(elt -> string)
    -> arr
    -> unit

  (* mathematical functions *)

  val abs : arr -> arr

  val neg : arr -> arr

  val floor : arr -> arr

  val ceil : arr -> arr

  val round : arr -> arr

  val sqr : arr -> arr

  val sqrt : arr -> arr

  val log : arr -> arr

  val log2 : arr -> arr

  val log10 : arr -> arr

  val exp : arr -> arr

  val sin : arr -> arr

  val cos : arr -> arr

  val tan : arr -> arr

  val sinh : arr -> arr

  val cosh : arr -> arr

  val tanh : arr -> arr

  val asin : arr -> arr

  val acos : arr -> arr

  val atan : arr -> arr

  val asinh : arr -> arr

  val acosh : arr -> arr

  val atanh : arr -> arr

  val min : ?axis:int -> ?keep_dims:bool -> arr -> arr

  val max : ?axis:int -> ?keep_dims:bool -> arr -> arr

  val sum : ?axis:int -> ?keep_dims:bool -> arr -> arr

  val sum_reduce : ?axis:int array -> arr -> arr

  val signum : arr -> arr

  val sigmoid : arr -> arr

  val relu : arr -> arr

  val dawsn : arr -> arr

  val min' : arr -> elt

  val max' : arr -> elt

  val sum' : arr -> elt

  val log_sum_exp' : arr -> elt

  val log_sum_exp : ?axis:int -> ?keep_dims:bool -> arr -> arr

  val l1norm' : arr -> elt

  val l2norm' : arr -> elt

  val l2norm_sqr' : arr -> elt

  val clip_by_value : ?amin:elt -> ?amax:elt -> arr -> arr

  val clip_by_l2norm : elt -> arr -> arr

  val pow : arr -> arr -> arr

  val scalar_pow : elt -> arr -> arr

  val pow_scalar : arr -> elt -> arr

  val atan2 : arr -> arr -> arr

  val scalar_atan2 : elt -> arr -> arr

  val atan2_scalar : arr -> elt -> arr

  val add : arr -> arr -> arr

  val sub : arr -> arr -> arr

  val mul : arr -> arr -> arr

  val div : arr -> arr -> arr

  val add_scalar : arr -> elt -> arr

  val sub_scalar : arr -> elt -> arr

  val mul_scalar : arr -> elt -> arr

  val div_scalar : arr -> elt -> arr

  val scalar_add : elt -> arr -> arr

  val scalar_sub : elt -> arr -> arr

  val scalar_mul : elt -> arr -> arr

  val scalar_div : elt -> arr -> arr

  val fma : arr -> arr -> arr -> arr

  (* Neural network related functions *)

  val conv1d : ?padding:padding -> arr -> arr -> int array -> arr

  val conv2d : ?padding:padding -> arr -> arr -> int array -> arr

  val conv3d : ?padding:padding -> arr -> arr -> int array -> arr

  val dilated_conv1d : ?padding:padding -> arr -> arr -> int array -> int array -> arr

  val dilated_conv2d : ?padding:padding -> arr -> arr -> int array -> int array -> arr

  val dilated_conv3d : ?padding:padding -> arr -> arr -> int array -> int array -> arr

  val transpose_conv1d : ?padding:padding -> arr -> arr -> int array -> arr

  val transpose_conv2d : ?padding:padding -> arr -> arr -> int array -> arr

  val transpose_conv3d : ?padding:padding -> arr -> arr -> int array -> arr

  val max_pool1d : ?padding:padding -> arr -> int array -> int array -> arr

  val max_pool2d : ?padding:padding -> arr -> int array -> int array -> arr

  val max_pool3d : ?padding:padding -> arr -> int array -> int array -> arr

  val avg_pool1d : ?padding:padding -> arr -> int array -> int array -> arr

  val avg_pool2d : ?padding:padding -> arr -> int array -> int array -> arr

  val avg_pool3d : ?padding:padding -> arr -> int array -> int array -> arr

  val upsampling2d : arr -> int array -> arr

  val conv1d_backward_input : arr -> arr -> int array -> arr -> arr

  val conv1d_backward_kernel : arr -> arr -> int array -> arr -> arr

  val conv2d_backward_input : arr -> arr -> int array -> arr -> arr

  val conv2d_backward_kernel : arr -> arr -> int array -> arr -> arr

  val conv3d_backward_input : arr -> arr -> int array -> arr -> arr

  val conv3d_backward_kernel : arr -> arr -> int array -> arr -> arr

  val dilated_conv1d_backward_input : arr -> arr -> int array -> int array -> arr -> arr

  val dilated_conv1d_backward_kernel : arr -> arr -> int array -> int array -> arr -> arr

  val dilated_conv2d_backward_input : arr -> arr -> int array -> int array -> arr -> arr

  val dilated_conv2d_backward_kernel : arr -> arr -> int array -> int array -> arr -> arr

  val dilated_conv3d_backward_input : arr -> arr -> int array -> int array -> arr -> arr

  val dilated_conv3d_backward_kernel : arr -> arr -> int array -> int array -> arr -> arr

  val transpose_conv1d_backward_input : arr -> arr -> int array -> arr -> arr

  val transpose_conv1d_backward_kernel : arr -> arr -> int array -> arr -> arr

  val transpose_conv2d_backward_input : arr -> arr -> int array -> arr -> arr

  val transpose_conv2d_backward_kernel : arr -> arr -> int array -> arr -> arr

  val transpose_conv3d_backward_input : arr -> arr -> int array -> arr -> arr

  val transpose_conv3d_backward_kernel : arr -> arr -> int array -> arr -> arr

  val max_pool1d_backward : padding -> arr -> int array -> int array -> arr -> arr

  val max_pool2d_backward : padding -> arr -> int array -> int array -> arr -> arr

  val max_pool3d_backward : padding -> arr -> int array -> int array -> arr -> arr

  val avg_pool1d_backward : padding -> arr -> int array -> int array -> arr -> arr

  val avg_pool2d_backward : padding -> arr -> int array -> int array -> arr -> arr

  val avg_pool3d_backward : padding -> arr -> int array -> int array -> arr -> arr

  val upsampling2d_backward : arr -> int array -> arr -> arr

  (* matrix functions *)

  val row_num : arr -> int

  val col_num : arr -> int

  val row : arr -> int -> arr

  val rows : arr -> int array -> arr

  val copy_row_to : arr -> arr -> int -> unit

  val copy_col_to : arr -> arr -> int -> unit

  val dot : arr -> arr -> arr

  val diag : ?k:int -> arr -> arr

  val trace : arr -> elt

  val transpose : ?axis:int array -> arr -> arr

  val to_rows : arr -> arr array

  val of_rows : arr array -> arr

  val to_cols : arr -> arr array

  val of_cols : arr array -> arr

  val of_array : elt array -> int array -> arr

  val of_arrays : elt array array -> arr

  (* helper functions *)

  val float_to_elt : float -> elt

  val elt_to_float : elt -> float
end