Module Owl_dense_ndarray_generic

empty Bigarray.Float64 [|3;4;5|] creates a three diemensional array of type Bigarray.Float64. Each dimension has the following size: 3, 4, and 5. The elements in the array are not initialised, they can be any value. empty is faster than zeros to create a ndarray.

The module only supports the following four types of ndarray: Bigarray.Float32, Bigarray.Float64, Bigarray.Complex32, and Bigarray.Complex64.

create Bigarray.Float64 [|3;4;5|] 2. creates a three-diemensional array of type Bigarray.Float64. Each dimension has the following size: 3, 4, and 5. The elements in the array are initialised to 2.

init Bigarray.Float64 d f creates a ndarray x of shape d, then using f to initialise the elements in x. The input of f is 1-dimensional index of the ndarray. You need to explicitly convert it if you need N-dimensional index. The function index_1d_nd can help you.

init_nd is almost the same as init but f receives n-dimensional index as input. It is more convenient since you don't have to convert the index by yourself, but this also means init_nd is slower than init.

zeros Bigarray.Complex32 [|3;4;5|] creates a three-diemensional array of type Bigarray.Complex32. Each dimension has the following size: 3, 4, and 5. The elements in the array are initialised to "zero". Depending on the kind, zero can be 0. or Complex.zero.

ones Bigarray.Complex32 [|3;4;5|] creates a three-diemensional array of type Bigarray.Complex32. Each dimension has the following size: 3, 4, and 5. The elements in the array are initialised to "one". Depending on the kind, one can be 1. or Complex.one.

uniform Bigarray.Float64 [|3;4;5|] creates a three-diemensional array of type Bigarray.Float64. Each dimension has the following size: 3, 4, and 5. The elements in the array follow a uniform distribution 0,1.

gaussian Float64 [|3;4;5|] ...

sequential Bigarray.Float64 [|3;4;5|] 2. creates a three-diemensional array of type Bigarray.Float64. Each dimension has the following size: 3, 4, and 5. The elements in the array are assigned sequential values.

?a specifies the starting value and the default value is zero; whilst ?step specifies the step size with default value one.

linspace k 0. 9. 10 ...

logspace k 0. 9. 10 ...

bernoulli k ~p:0.3 [|2;3;4|]

complex re im constructs a complex ndarray/matrix from re and im. re and im contain the real and imaginary part of x respectively.

Note that both re and im can be complex but must have same type. The real part of re will be the real part of x and the imaginary part of im will be the imaginary part of x.

complex rho theta constructs a complex ndarray/matrix from polar coordinates rho and theta. rho contains the magnitudes and theta contains phase angles. Note that the behaviour is undefined if rho has negative elelments or theta has infinity elelments.

shape x returns the shape of ndarray x.

num_dims x returns the number of dimensions of ndarray x.

nth_dim x returns the size of the nth dimension of x.

numel x returns the number of elements in x.

nnz x returns the number of non-zero elements in x.

density x returns the percentage of non-zero elements in x.

size_in_bytes x returns the size of x in bytes in memory.

same_shape x y checks whether x and y has the same shape or not.

kind x returns the type of ndarray x. It is one of the four possible values: Bigarray.Float32, Bigarray.Float64, Bigarray.Complex32, and Bigarray.Complex64.

strides x calcuates the strides of x. E.g., if x is of shape [|3;4;5|], the returned strides will be [|20;5;1|].

slice_size calculates the slice size in each dimension, E.g., if x is of shape [|3;4;5|], the returned slice size will be |60; 20; 5|.

index_1d_nd i stride converts one-dimensional index i to n-dimensional index according to the passed in stride.

NOTE: you need to pass in stride, not the shape of x!

index_nd_1d i shp converts n-dimensional index i to one-dimensional index according to the passed in stride.

NOTE: you need to pass in stride, not the shape of x!

get x i returns the value at i in x. E.g., get x [|0;2;1|] returns the value at [|0;2;1|] in x.

set x i a sets the value at i to a in x.

get_index i x returns an array of element values specified by the indices i. The length of array i equals the number of dimensions of x. The arrays in i must have the same length, and each represents the indices in that dimension.

E.g., [| [|1;2|]; [|3;4|] |] returns the value of elements at position (1,3) and (2,4) respectively.

set_index i x a sets the value of elements in x according to the indices specified by i. The length of array i equals the number of dimensions of x. The arrays in i must have the same length, and each represents the indices in that dimension.

If the length of a equals to the length of i, then each element will be assigned by the value in the corresponding position in x. If the length of a equals to one, then all the elements will be assigned the same value.

slice s x returns a copy of the slice in x. The slice is defined by a which is an int option array. E.g., for a ndarray x of dimension [|2; 2; 3|], slice [0] x takes the following slices of index \(0,*,*\), i.e., [|0;0;0|], [|0;0;1|], [|0;0;2|] ... Also note that if the length of s is less than the number of dimensions of x, slice function will append slice definition to higher diemensions by assuming all the elements in missing dimensions will be taken.

Basically, slice function offers very much the same semantic as that in numpy, i.e., start:stop:step grammar, so if you how to index and slice ndarray in numpy, you should not find it difficult to use this function. Please just refer to numpy documentation or my tutorial.

There are two differences between slice_left and slice: slice_left does not make a copy but simply moving the pointer; slice_left can only make a slice from left-most axis whereas slice is much more flexible and can work on arbitrary axis which need not start from left-most side.

set_slice axis x y set the slice defined by axis in x according to the values in y. y must have the same shape as the one defined by axis.

About the slice definition of axis, please refer to slice function.

get_slice_simple axis x aims to provide a simpler version of get_slice. This function assumes that every list element in the passed in in list list represents a range, i.e., R constructor.

E.g., [[];[0;3];[0]] is equivalent to [R []; R [0;3]; R [0]] .

set_slice_simple axis x y aims to provide a simpler version of set_slice. This function assumes that every list element in the passed in in list list represents a range, i.e., R constructor.

E.g., [[];[0;3];[0]] is equivalent to [R []; R [0;3]; R [0]] .

Some as Bigarray.sub_left, please refer to Bigarray documentation.

Same as Bigarray.slice_left, please refer to Bigarray documentation.

copy src dst copies the data from ndarray src to dst.

reset x resets all the elements in x to zero.

fill x a assigns the value a to the elements in x.

clone x makes a copy of x.

resize ~head x d resizes the ndarray x. If there are less number of elelments in the new shape than the old one, the new ndarray shares part of the memeory with the old x. head indicates the alignment between the new and old data, either from head or from tail. Note the data is flattened before the operation.

If there are more elements in the new shape d. Then new memeory space will be allocated and the content of x will be copied to the new memory. The rest of the allocated space will be filled with zeros.

reshape x d transforms x into a new shape definted by d. Note the reshape function will not make a copy of x, the returned ndarray shares the same memory with the original x.

flatten x transforms x into a one-dimsonal array without making a copy. Therefore the returned value shares the same memory space with original x.

reverse x reverse the order of all elements in the flattened x and returns the results in a new ndarray. The original x remains intact.

flip ~axis x flips a matrix/ndarray along axis. By default axis = 0. The result is returned in a new matrix/ndarray, so the original x remains intact.

rotate x d rotates x clockwise d degrees. d must be multiple times of 90, otherwise the function will fail. If x is an n-dimensional array, then the function rotates the plane formed by the first and second dimensions.

transpose ~axis x makes a copy of x, then transpose it according to ~axis. ~axis must be a valid permutation of x dimension indices. E.g., for a three-dimensional ndarray, it can be 2;1;0, 0;2;1, 1;2;0, and etc.

swap i j x makes a copy of x, then swaps the data on axis i and j.

tile x a tiles the data in x according the repitition specified by a. This function provides the exact behaviour as numpy.tile, please refer to the numpy's online documentation for details.

repeat ~axis x a repeats the elements along axis for a times. The default value of ?axis is the highest dimension of x. This function is similar to numpy.repeat except that a is an integer instead of an array.

concatenate ~axis:2 x concatenates an array of ndarrays along the third dimension. For the ndarrays in x, they must have the same shape except the dimension specified by axis. The default value of axis is 0, i.e., the lowest dimension of a matrix/ndarray.

split ~axis parts x

squeeze ~axis x removes single-dimensional entries from the shape of x.

expand x d reshapes x by increasing its rank from num_dims x to d. The opposite operation is squeeze x.

pad ~v:0. [[1;1]] x

dropout ~rate:0.3 x drops out 30% of the elements in x, in other words, by setting their values to zeros.

top x n returns the indices of n greatest values of x. The indices are arranged according to the corresponding elelment values, from the greatest one to the smallest one.

bottom x n returns the indices of n smallest values of x. The indices are arranged according to the corresponding elelment values, from the smallest one to the greatest one.

sort x performs in-place quicksort of the elelments in x.

mmap fd kind layout shared dims ...

iteri ~axis f x applies function f to each element in a slice defined by ~axis. If ~axis is not passed in, then iteri simply iterates all the elements in x.

iter ~axis f x is similar to iteri ~axis f x, excpet the index i of an element is not passed in f. Note that iter is much faster than iteri.

mapi ~axis f x makes a copy of x, then applies f to each element in a slice defined by ~axis. If ~axis is not passed in, then mapi simply iterates all the elements in x.

map ~axis f x is similar to mapi ~axis f x except the index of the current element is not passed to the function f. Note that map is much faster than mapi.

map2i ~axis f x y applies f to two elements of the same position in a slice defined by ~axis in both x and y. If ~axis is not passed in, then map2i simply iterates all the elements in x and y. The two matrices mush have the same shape.

map2 ~axis f x y is similar to map2i ~axis f x y except the index of the index of the current element is not passed to the function f.

filteri ~axis f x uses f to filter out certain elements in a slice defined by ~axis. An element will be included if f returns true. The returned result is a list of indices of the selected elements.

Similar to filteri, but the indices of the elements are not passed to f.

foldi ~axis f a x folds all the elements in a slice defined by ~axis with the function f. If ~axis is not passed in, then foldi simply folds all the elements in x.

Similar to foldi, except that the index of an element is not passed to f.

iteri_slice s f x iterates the slices along the passed in axis indices s, and applies the function f to each of them. The order of iterating slices is based on the order of axis in s.

E.g., for a three-dimensional ndarray of shape [|2;2;2|], iteri_slice [|1;0|] f x will access the slices in the following order: [ [0]; [0]; [] ], [ [1]; [0]; [] ], [ [1]; [1]; [] ]. Also note the slice passed in f is a copy of the original data.

Similar to iteri_slice, except that the index of a slice is not passed to f.

Similar to iteri but applies to two N-dimensional arrays x and y. Both x and y must have the same shape.

Similar to iter2i, except that the index of a slice is not passed to f.

exists f x checks all the elements in x using f. If at least one element satisfies f then the function returns true otherwise false.

not_exists f x checks all the elements in x, the function returns true only if all the elements fail to satisfy f : float -> bool.

for_all f x checks all the elements in x, the function returns true if and only if all the elements pass the check of function f.

is_zero x returns true if all the elements in x are zeros.

is_positive x returns true if all the elements in x are positive.

is_negative x returns true if all the elements in x are negative.

is_nonpositive returns true if all the elements in x are non-positive.

is_nonnegative returns true if all the elements in x are non-negative.

is_normal x returns true if all the elelments in x are normal float numbers, i.e., not NaN, not INF, not SUBNORMAL. Please refer to

https://www.gnu.org/software/libc/manual/html_node/Floating-Point-Classes.html https://www.gnu.org/software/libc/manual/html_node/Infinity-and-NaN.html#Infinity-and-NaN

not_nan x returns false if there is any NaN element in x. Otherwise, the function returns true indicating all the numbers in x are not NaN.

not_inf x returns false if there is any positive or negative INF element in x. Otherwise, the function returns true.

equal x y returns true if two ('a, 'b) trices x and y are equal.

not_equal x y returns true if there is at least one element in x is not equal to that in y.

greater x y returns true if all the elements in x are greater than the corresponding elements in y.

less x y returns true if all the elements in x are smaller than the corresponding elements in y.

greater_equal x y returns true if all the elements in x are not smaller than the corresponding elements in y.

less_equal x y returns true if all the elements in x are not greater than the corresponding elements in y.

elt_equal x y performs element-wise = comparison of x and y. Assume that a is from x and b is the corresponding element of a from y of the same position. The function returns another binary (0 and 1) ndarray/matrix wherein 1 indicates a = b.

elt_not_equal x y performs element-wise != comparison of x and y. Assume that a is from x and b is the corresponding element of a from y of the same position. The function returns another binary (0 and 1) ndarray/matrix wherein 1 indicates a <> b.

elt_less x y performs element-wise < comparison of x and y. Assume that a is from x and b is the corresponding element of a from y of the same position. The function returns another binary (0 and 1) ndarray/matrix wherein 1 indicates a < b.

elt_greater x y performs element-wise > comparison of x and y. Assume that a is from x and b is the corresponding element of a from y of the same position. The function returns another binary (0 and 1) ndarray/matrix wherein 1 indicates a > b.

elt_less_equal x y performs element-wise <= comparison of x and y. Assume that a is from x and b is the corresponding element of a from y of the same position. The function returns another binary (0 and 1) ndarray/matrix wherein 1 indicates a <= b.

elt_greater_equal x y performs element-wise >= comparison of x and y. Assume that a is from x and b is the corresponding element of a from y of the same position. The function returns another binary (0 and 1) ndarray/matrix wherein 1 indicates a >= b.

equal_scalar x a checks if all the elements in x are equal to a. The function returns true iff for every element b in x, b = a.

not_equal_scalar x a checks if all the elements in x are not equal to a. The function returns true iff for every element b in x, b <> a.

less_scalar x a checks if all the elements in x are less than a. The function returns true iff for every element b in x, b < a.

greater_scalar x a checks if all the elements in x are greater than a. The function returns true iff for every element b in x, b > a.

less_equal_scalar x a checks if all the elements in x are less or equal to a. The function returns true iff for every element b in x, b <= a.

greater_equal_scalar x a checks if all the elements in x are greater or equal to a. The function returns true iff for every element b in x, b >= a.

elt_equal_scalar x a performs element-wise = comparison of x and a. Assume that b is one element from x The function returns another binary (0 and 1) ndarray/matrix wherein 1 of the corresponding position indicates a = b, otherwise 0.

elt_not_equal_scalar x a performs element-wise != comparison of x and a. Assume that b is one element from x The function returns another binary (0 and 1) ndarray/matrix wherein 1 of the corresponding position indicates a <> b, otherwise 0.

elt_less_scalar x a performs element-wise < comparison of x and a. Assume that b is one element from x The function returns another binary (0 and 1) ndarray/matrix wherein 1 of the corresponding position indicates a < b, otherwise 0.

elt_greater_scalar x a performs element-wise > comparison of x and a. Assume that b is one element from x The function returns another binary (0 and 1) ndarray/matrix wherein 1 of the corresponding position indicates a > b, otherwise 0.

elt_less_equal_scalar x a performs element-wise <= comparison of x and a. Assume that b is one element from x The function returns another binary (0 and 1) ndarray/matrix wherein 1 of the corresponding position indicates a <= b, otherwise 0.

elt_greater_equal_scalar x a performs element-wise >= comparison of x and a. Assume that b is one element from x The function returns another binary (0 and 1) ndarray/matrix wherein 1 of the corresponding position indicates a >= b, otherwise 0.

approx_equal ~eps x y returns true if x and y are approximately equal, i.e., for any two elements a from x and b from y, we have abs (a - b) < eps. For complex numbers, the eps applies to both real and imaginary part.

Note: the threshold check is exclusive for passed in eps, i.e., the threshold interval is (a-eps, a+eps).

approx_equal_scalar ~eps x a returns true all the elements in x are approximately equal to a, i.e., abs (x - a) < eps. For complex numbers, the eps applies to both real and imaginary part.

Note: the threshold check is exclusive for the passed in eps.

approx_elt_equal ~eps x y compares the element-wise equality of x and y, then returns another binary (i.e., 0 and 1) ndarray/matrix wherein 1 indicates that two corresponding elements a from x and b from y are considered as approximately equal, namely abs (a - b) < eps.

approx_elt_equal_scalar ~eps x a compares all the elements of x to a scalar value a, then returns another binary (i.e., 0 and 1) ndarray/matrix wherein 1 indicates that the element b from x is considered as approximately equal to a, namely abs (a - b) < eps.

of_array k x d takes an array x and converts it into an ndarray of type k and shape d.

to_array x converts an ndarray x to OCaml's array type. Note that the ndarray x is flattened before convertion.

print x prints all the elements in x as well as their indices. max_row and max_col specify the maximum number of rows and columns to display. header specifies whether or not to print out the headers. fmt is the function to format every element into string.

pp_dsnda x prints x in OCaml toplevel. If the ndarray is too long, pp_dsnda only prints out parts of the ndarray.

save x s serialises a ndarray x to a file of name s.

load k s loads previously serialised ndarray from file s into memory. It is necesssary to specify the type of the ndarray with paramater k.

re_c2s x returns all the real components of x in a new ndarray of same shape.

re_d2z x returns all the real components of x in a new ndarray of same shape.

im_c2s x returns all the imaginary components of x in a new ndarray of same shape.

im_d2z x returns all the imaginary components of x in a new ndarray of same shape.

sum x returns the sumtion of all elements in x.

sum_ axis x sums the elements in x along specified axis.

prod x returns the product of all elements in x along passed in axises.

min x returns the minimum of all elements in x. For two complex numbers, the one with the smaller magnitude will be selected. If two magnitudes are the same, the one with the smaller phase will be selected.

max x returns the maximum of all elements in x. For two complex numbers, the one with the greater magnitude will be selected. If two magnitudes are the same, the one with the greater phase will be selected.

minmax x returns (min_v, max_v), min_v is the minimum value in x while max_v is the maximum.

min_i x returns the minimum of all elements in x as well as its index.

max_i x returns the maximum of all elements in x as well as its index.

minmax_i x returns ((min_v,min_i), (max_v,max_i)) where (min_v,min_i) is the minimum value in x along with its index while (max_v,max_i) is the maximum value along its index.

abs x returns the absolute value of all elements in x in a new ndarray.

abs_c2s x is similar to abs but takes complex32 as input.

abs_z2d x is similar to abs but takes complex64 as input.

abs2 x returns the square of absolute value of all elements in x in a new ndarray.

abs2_c2s x is similar to abs2 but takes complex32 as input.

abs2_z2d x is similar to abs2 but takes complex64 as input.

conj x returns the conjugate of the complex x.

neg x negates the elements in x and returns the result in a new ndarray.

reci x computes the reciprocal of every elements in x and returns the result in a new ndarray.

reci_tol ~tol x computes the reciprocal of every element in x. Different from reci, reci_tol sets the elements whose abs value smaller than tol to zeros. If tol is not specified, the defautl Owl_utils.eps Float32 will be used. For complex numbers, refer to Owl's doc to see how to compare.

signum computes the sign value (-1 for negative numbers, 0 (or -0) for zero, 1 for positive numbers, nan for nan).

sqr x computes the square of the elements in x and returns the result in a new ndarray.

sqrt x computes the square root of the elements in x and returns the result in a new ndarray.

cbrt x computes the cubic root of the elements in x and returns the result in a new ndarray.

exp x computes the exponential of the elements in x and returns the result in a new ndarray.

exp2 x computes the base-2 exponential of the elements in x and returns the result in a new ndarray.

exp10 x computes the base-10 exponential of the elements in x and returns the result in a new ndarray.

expm1 x computes exp x -. 1. of the elements in x and returns the result in a new ndarray.

log x computes the logarithm of the elements in x and returns the result in a new ndarray.

log10 x computes the base-10 logarithm of the elements in x and returns the result in a new ndarray.

log2 x computes the base-2 logarithm of the elements in x and returns the result in a new ndarray.

log1p x computes log (1 + x) of the elements in x and returns the result in a new ndarray.

sin x computes the sine of the elements in x and returns the result in a new ndarray.

cos x computes the cosine of the elements in x and returns the result in a new ndarray.

tan x computes the tangent of the elements in x and returns the result in a new ndarray.

asin x computes the arc sine of the elements in x and returns the result in a new ndarray.

acos x computes the arc cosine of the elements in x and returns the result in a new ndarray.

atan x computes the arc tangent of the elements in x and returns the result in a new ndarray.

sinh x computes the hyperbolic sine of the elements in x and returns the result in a new ndarray.

cosh x computes the hyperbolic cosine of the elements in x and returns the result in a new ndarray.

tanh x computes the hyperbolic tangent of the elements in x and returns the result in a new ndarray.

asinh x computes the hyperbolic arc sine of the elements in x and returns the result in a new ndarray.

acosh x computes the hyperbolic arc cosine of the elements in x and returns the result in a new ndarray.

atanh x computes the hyperbolic arc tangent of the elements in x and returns the result in a new ndarray.

floor x computes the floor of the elements in x and returns the result in a new ndarray.

ceil x computes the ceiling of the elements in x and returns the result in a new ndarray.

round x rounds the elements in x and returns the result in a new ndarray.

trunc x computes the truncation of the elements in x and returns the result in a new ndarray.

fix x rounds each element of x to the nearest integer toward zero. For positive elements, the behavior is the same as floor. For negative ones, the behavior is the same as ceil.

modf x performs modf over all the elements in x, the fractal part is saved in the first element of the returned tuple whereas the integer part is saved in the second element.

erf x computes the error function of the elements in x and returns the result in a new ndarray.

erfc x computes the complementary error function of the elements in x and returns the result in a new ndarray.

logistic x computes the logistic function 1/(1 + exp(-a) of the elements in x and returns the result in a new ndarray.

relu x computes the rectified linear unit function max(x, 0) of the elements in x and returns the result in a new ndarray.

elu alpha x computes the exponential linear unit function x >= 0. ? x : (alpha * (exp(x) - 1)) of the elements in x and returns the result in a new ndarray.

leaky_relu alpha x computes the leaky rectified linear unit function x >= 0. ? x : (alpha * x) of the elements in x and returns the result in a new ndarray.

softplus x computes the softplus function log(1 + exp(x) of the elements in x and returns the result in a new ndarray.

softsign x computes the softsign function x / (1 + abs(x)) of the elements in x and returns the result in a new ndarray.

softmax x computes the softmax functions (exp x) / (sum (exp x)) of all the elements in x and returns the result in a new array.

sigmoid x computes the sigmoid function 1 / (1 + exp (-x)) for each element in x.

log_sum_exp x computes the logarithm of the sum of exponentials of all the elements in x.

l1norm x calculates the l1-norm of all the element in x.

l2norm x calculates the l2-norm of all the element in x.

l2norm_sqr x calculates the square of l2-norm (or l2norm, Euclidean norm) of all elements in x. The function uses conjugate transpose in the product, hence it always returns a float number.

cumsum ~axis x : performs cumulative sum of the elements along the given axis ~axis. If ~axis is None, then the cumsum is performed along the lowest dimension. The returned result however always remains the same shape.

cumprod ~axis x : similar to cumsum but performs cumulative product of the elements along the given ~axis.

cummin ~axis x : performs cumulative min along axis dimension.

cummax ~axis x : performs cumulative max along axis dimension.

angle x calculates the phase angle of all complex numbers in x.

proj x computes the projection on Riemann sphere of all elelments in x.

add x y adds all the elements in x and y elementwise, and returns the result in a new ndarray.

General broadcast operation is automatically applied to add/sub/mul/div, etc. The function compares the dimension element-wise from the highest to the lowest with the following broadcast rules (same as numpy): 1. equal; 2. either is 1.

sub x y subtracts all the elements in x and y elementwise, and returns the result in a new ndarray.

mul x y multiplies all the elements in x and y elementwise, and returns the result in a new ndarray.

div x y divides all the elements in x and y elementwise, and returns the result in a new ndarray.

add_scalar x a adds a scalar value a to each element in x, and returns the result in a new ndarray.

sub_scalar x a subtracts a scalar value a from each element in x, and returns the result in a new ndarray.

mul_scalar x a multiplies each element in x by a scalar value a, and returns the result in a new ndarray.

div_scalar x a divides each element in x by a scalar value a, and returns the result in a new ndarray.

scalar_add a x adds a scalar value a to each element in x, and returns the result in a new ndarray.

scalar_sub a x subtracts each element in x from a scalar value a, and returns the result in a new ndarray.

scalar_mul a x multiplies each element in x by a scalar value a, and returns the result in a new ndarray.

scalar_div a x divides a scalar value a by each element in x, and returns the result in a new ndarray.

pow x y computes pow(a, b) of all the elements in x and y elementwise, and returns the result in a new ndarray.

scalar_pow a x computes the power value of a scalar value a using the elements in a ndarray x.

pow_scalar x a computes each element in x power to a.

atan2 x y computes atan2(a, b) of all the elements in x and y elementwise, and returns the result in a new ndarray.

scalar_atan2 a x

scalar_atan2 x a

hypot x y computes sqrt(x*x + y*y) of all the elements in x and y elementwise, and returns the result in a new ndarray.

min2 x y computes the minimum of all the elements in x and y elementwise, and returns the result in a new ndarray.

max2 x y computes the maximum of all the elements in x and y elementwise, and returns the result in a new ndarray.

fmod x y performs float mod division.

fmod_scalar x a performs mod division between x and scalar a.

scalar_fmod x a performs mod division between scalar a and x.

ssqr x a computes the sum of squared differences of all the elements in x from constant a. This function only computes the square of each element rather than the conjugate transpose as l2norm_sqr does.

ssqr_diff x y computes the sum of squared differences of every elements in x and its corresponding element in y.

cross_entropy x y calculates the cross entropy between x and y using base e.

clip_by_value ~amin ~amax x clips the elements in x based on amin and amax. The elements smaller than amin will be set to amin, and the elements greater than amax will be set to amax.

clip_by_l2norm t x clips the x according to the threshold set by t.

cast_s2d x casts x from float32 to float64.

cast_d2s x casts x from float64 to float32.

cast_c2z x casts x from complex32 to complex64.

cast_z2c x casts x from complex64 to complex32.

cast_s2c x casts x from float32 to complex32.

cast_d2z x casts x from float64 to complex64.

cast_s2z x casts x from float32 to complex64.

cast_d2c x casts x from float64 to complex32.

print_element kind a prints the value of a single element.

print_index i prints out the index of an element.

_check_transpose_axis a d checks whether a is a legiti('a, 'b) te transpose index.

sum_slices ~axis:2 x for x of |2;3;4;5|, it returns an ndarray of shape |4;5|. Currently, the operation is done using gemm, fast but uses more memory.