This document enumerates arrayfire API equivalent in Matlab, Python (numpy, scipy).
They are grouped into the following sections.
| ArrayFire (C++) | Matlab | Python (numpy, scipy) |
|---|
| Identity matrix | identity(rows, cols) | eye(rows, cols) | np.identity(rows, 'float32') |
| Array filled with constant n | constant(n, rows, cols) | ones(rows, cols).n | np.ones((rows, cols), 'float32').n |
| Random filled array | randu(rows, cols) | rand(rows, cols) | rand(rows, cols) |
| Diagonal vector to matrix | diag(A) | diag(A) | np.diag(A) |
| AarrayFire (C++) | Matlab | Python (numpy, scipy) |
|---|
| array A(rows, cols, f64) | | |
| Vector size | A.elements() | length(A) | A.size |
| Number of dimensions | A.ndims() | ndims(A) | len(x.shape) |
| shape of matrix | A.dims() | size（A） | A.shape |
| number of rows | A.dims(0) | size(A, 1) | A.shape.[0] |
| number of columns | A.dims(1) | size(A, 2) | A.shape.[1] |
| number of elements | A.elements() | numel(A) | A.size |
| ArrayFire (C++) | Matlab | Python (numpy, scipy) |
|---|
| Sequences | af::seq(low,high,step) | (low:step:high)'->columnvector | |
| Vector | | | |
| i+1 element | A(i) | A(i+1) | A[i] |
| last element | A(end) | A(end) | |
| A(-1) | A(end) | A[-1] |
| 1 to i elements | A(seq(i)) | A(1:i) | A[:i] |
| i+1 to END elements | A(seq(i, end)) | A(i+1:end) | A[i:] |
| i1+1 to i2+1 elements | A(seq(i1, i2)) | A(i1+1:i2+1) | A[i1:i2+1] |
| i1+1 to i2+1 elements by step | A(seq(i1, i2, step)) | A(i1+1:step:i2+1) | A[i1:i2+1:step] |
| Matrix | | | |
| i+1 element | A(i) | A(i+1) | A[i] |
| last element | A(end) | A(end) | |
| A(-1) | A(end) | A[-1] |
| Element(i+1, j+1) | A(i, j) | A(i+1, j+1) | A[i, j] |
| i+1 row | A(i, span) | A(i+1, :) | A[i, :] |
| i+1 column | A(span, i) | A(:, i+1) | A[:, i] |
| A(seq(i, end), seq(j, end)) | A(i+1:end, j+1:end) | |
| A(seq(i, end), span) | A(i+1:end, :) | A[i:, :] |
| A(seq(i1, i2), seq(j1, j2)) | A(i1+1:12+1, j1+1:j2+1) | A[i1:i2+1, j1:j2+1] |
| A(seq(i1, i2, step1), seq(j1, j2, step2)) | A(i1+1:step1:12+1, j1+1:step2:j2+1) | A[i1:i2+1:step1, j1:j2+1:step2] |
| i+1 row | A.row(i) | A(i+1, :) | A[i, :] |
| i+1 to j+1 rows | A.rows(i, j) | A(i+1:j+1, :) | A[i:j+1, :] |
| i+1 column | A.col(i) | A(:, i+1) | A[:, i] |
| i+1 to j+1 columns | R.cols(i, j) | A(:, i+1:j+1) | A[:, i:j+1] |
| i+1 slice | A.slice(i) | A(:, :, i+1) | A[:, :, i] |
| i+1 to j+1 slices | A.slices(i, j) | A(:, :, i+1:j+1) | A[:, :, i:j+1] |
| ArrayFire (C++) | Matlab | Python (numpy, scipy) |
|---|
| Flatten to vector | flat(R) | R(:) | R.flatten() |
| Reshaping | moddims(R, rows, cols) | reshape(R, [rows, cols]) | np.reshape(R, (rows, cols)) |
| Conjugate Transposition | R.H() | R' | R.conj().T |
| Non-conjugate transpose | R.T() | R.' | R.T |
| Conjugate of array values | conjg(R) | conj(R) | np.conj |
| Flip left-right | flip(R, 1) | fliplr(R) | np.fliplr(R) |
| Flip up-down | flip(R, 0) | flipud(R) | np.flipud(R) |
| Repeat matrix | tile(R, i, j) | repmat(R, i, j) | np.tile(R, (i, j)) |
| Swap axis | reorder(R, 1, 0) | permute(R, [2, 1]) | arr.transpose(2, 1, 0) arr.swapaxes(2, 1) |
| Bind columns | join(1, A1, A2) | [A1;A2] vertcat(A1, A2) | vstack((a, b)) concatenate((a, b), axis=0) |
| Bind rows | join(0, A1, A2) | [A1A2] horzcat(A1, A2) | hstack((a, b)) concatenate((a, b), axis=1) |
| Shift | shift(A, 1) | circshift(A, 1) | np.roll(R, 1) |
| Rotate | rotate(A, 3) | rot90(A) | np.rot90(a) |
| ArrayFire (C++) | Matlab | Python (numpy, scipy) |
|---|
| Lower Triangular | lower(R) | tril(R) | np.tril(R) |
| Upper Triangular | upper(R) | triu(R) | np.triu(R) |
| Rank | rank(R) | rank(R) | rank(a) |
| Determinant | det<float>(R) | det(R) | la.det(a) |
| Euclid norm | norm(R) | norm(R) | la.norm(R) |
| L1 norm | norm(R,AF_NORM_VECTOR_1) | norm(R,1) | la.norm(R,1) |
| L2 norm | norm(R,AF_NORM_VECTOR_2) | norm(R,2) | la.norm(R,2) |
| L4 norm | norm(R,AF_NORM_VECTOR_P,4) | norm(R,4) | |
| L_inf norm | norm(R,AF_NORM_VECTOR_INF) | norm(R,Inf) | np.linalg.norm(R,np.Inf) |
| Addition | A1+A2 | A1+A2 | A1+A2 |
| Subtraction | A1-A2 | A1-A2 | A1-A2 |
| Multiplication | A1*A2 | A1.*A2 | np.multiply(A1,A2) |
| | | A1*A2 |
| Division | R=R/Q | R = P / Q | R=R/Q |
| Matrix Multiplication | matmul(A1,A2) | A1*A2 | np.matmul(A1,A2) |
| | | np.dot(A1,A2) |
| | | A1@A2 |
| Dot Product(vector) | dot(x1,x2) | dot(x1,x2) | dot(x1,x2) |
| solve equation | solve(A,B) | X=A\B | la.solve(a,B) |
| Inverse | inverse(A) | inv(A) | la.inv(a) |
| LU | L,U,P=lu(A) | [L,U,P]=lu(A) | p,l,u=la.lu(a) |
| Cholesky factorization | cholesky(R,A,true) | R=chol(A1) | R=la.cholesky(A) |
| QR | qr(Q,R,tau,A) | [Q,R]=qr(A) | Q,R=la.qr(A) |
| Singular values | svd(U,s,Vt,A) | [U,S,V]=svd(A) | U,s,Vt=la.svd(A) |
| ArrayFire (C++) | Matlab | Python (numpy, scipy) |
|---|
| Sums of columns | sum(A1) | sum(A1) sum(A1, 1) | np.sum(A1, 0) |
| Sums of rows | sum(A1, 1) | sum(A1, 2) | np.sum(A1, 1) |
| Sums of all elem. | sum<float>(A1) | sum(A1, 'all') | np.sum(A1) |
| Products of columns | product(A1) | prod(A1) prod(A1, 1) | np.prod(A1, 0) |
| Products of rows | product(A1, 1) | prod(A1, 2) | np.prod(A1, 1) |
| Products of all elem. | product<float>(A1) | prod(A1, 'all') | np.prod(a) |
| Averages of columns | mean(A1) | mean(A1) mean(A1, 1) | np.mean(A1, 0) |
| Averages of rows | mean(A1, 1) | mean(A1, 2) | np.mean(A1, 1) |
| Averages of all elem. | mean<float>(A1) | mean(A1, 'all') | np.mean(A1) |
| Maximum of columns | max(A1) | max(A1) max(A1, 1) | np.max(A1, 0) |
| Maximum of rows | max(A1, 1) | max(A1, 2) | np.max(A1, 1) |
| Maximum of all elem. | max<float>(A1) | max(A1, 'all') | np.max(A1) |
| Minimum of columns | min(A1) | min(A1) min(A1, 1) | np.min(A1, 0) |
| Minimum of rows | min(A1, 1) | min(A1, 2) | np.min(A1, 1) |
| Minimum of all elem. | min<float>(A1) | min(A1, 'all') | np.min(A1) |
| Variance of columns | var(A1, 1, 0) | var(A1) var(A1, 0, 1) | |
| Variance of rows | var(A1, 1, 1) | var(A1, 0, 2) | |
| Variance s of all elem. | var<float>(A1) | var(A1, 0, 'all') | np.var(x) |
| Stand. deviations of columns | stdev(A1) | std(A1, 1, 1) | |
| Stand. deviations of rows | stdev(A1, 1) | std(A1, 1, 2) | |
| Stand. deviations of all elem. | stdev<float>(A1) | std(A1, 1, 'all') | np.std(x) |
| ArrayFire (C++) | Matlab | Python (numpy, scipy) |
|---|
| Exponential | exp(A1) | exp(A1) | np.exp(A1) |
| Element-wise power | pow(A,2) | A.^2 | np.power(A,2) |
| pow(A,4) | A.^4 | |
| Round | round(A) | round(A) | np.around(A) |
| Round down | floor(A) | floor(A) | np.floor(A) |
| Round up | ceil(A) | ceil(A) | np.ceil(A) |
| ArrayFire (C++) | Matlab | Python (numpy, scipy) |
|---|
| FFT1D (each column) | fft(A) | fft(A) | np.fft.fft(A,0) |
| FFT1D (each row) | fft(A.T).T | fft(A,2) | np.fft.fft(A) np.fft.fft(A,1) |