array.h
Go to the documentation of this file.
1 /*******************************************************
2  * Copyright (c) 2014, ArrayFire
3  * All rights reserved.
4  *
5  * This file is distributed under 3-clause BSD license.
6  * The complete license agreement can be obtained at:
7  * http://arrayfire.com/licenses/BSD-3-Clause
8  ********************************************************/
9 
10 #pragma once
11 #include <af/defines.h>
12 #include <af/seq.h>
13 #include <af/util.h>
14 #include <af/index.h>
15 
16 #ifdef __cplusplus
17 #include <af/traits.hpp>
18 #include <vector>
19 namespace af
20 {
21 
22  class dim4;
23 
27  class AFAPI array {
28  af_array arr;
29 
30 
31  public:
38  void set(af_array tmp);
39 
45  class AFAPI array_proxy
46  {
47  struct array_proxy_impl; //forward declaration
48  array_proxy_impl *impl; // implementation
49 
50  public:
51  array_proxy(array& par, af_index_t *ssss, bool linear = false);
52  array_proxy(const array_proxy &other);
53 #if __cplusplus > 199711L
54  array_proxy(array_proxy &&other);
55  array_proxy & operator=(array_proxy &&other);
56 #endif
57  ~array_proxy();
58 
59  // Implicit conversion operators
60  operator array() const;
61  operator array();
62 
63 #define ASSIGN(OP) \
64  array_proxy& operator OP(const array_proxy &a); \
65  array_proxy& operator OP(const array &a); \
66  array_proxy& operator OP(const double &a); \
67  array_proxy& operator OP(const cdouble &a); \
68  array_proxy& operator OP(const cfloat &a); \
69  array_proxy& operator OP(const float &a); \
70  array_proxy& operator OP(const int &a); \
71  array_proxy& operator OP(const unsigned &a); \
72  array_proxy& operator OP(const bool &a); \
73  array_proxy& operator OP(const char &a); \
74  array_proxy& operator OP(const unsigned char &a); \
75  array_proxy& operator OP(const long &a); \
76  array_proxy& operator OP(const unsigned long &a); \
77  array_proxy& operator OP(const long long &a); \
78  array_proxy& operator OP(const unsigned long long &a); \
79 
80  ASSIGN(=)
81  ASSIGN(+=)
82  ASSIGN(-=)
83  ASSIGN(*=)
84  ASSIGN(/=)
85 #undef ASSIGN
86 
87 #if AF_API_VERSION >= 32
88 #define ASSIGN(OP) \
89  array_proxy& operator OP(const short &a); \
90  array_proxy& operator OP(const unsigned short &a); \
91 
92  ASSIGN(=)
93  ASSIGN(+=)
94  ASSIGN(-=)
95  ASSIGN(*=)
96  ASSIGN(/=)
97 #undef ASSIGN
98 #endif
99 
100  // af::array member functions. same behavior as those below
101  af_array get();
102  af_array get() const;
103  dim_t elements() const;
104  template<typename T> T* host() const;
105  void host(void *ptr) const;
106  dtype type() const;
107  dim4 dims() const;
108  dim_t dims(unsigned dim) const;
109  unsigned numdims() const;
110  size_t bytes() const;
111  array copy() const;
112  bool isempty() const;
113  bool isscalar() const;
114  bool isvector() const;
115  bool isrow() const;
116  bool iscolumn() const;
117  bool iscomplex() const;
118  inline bool isreal() const { return !iscomplex(); }
119  bool isdouble() const;
120  bool issingle() const;
121  bool isrealfloating() const;
122  bool isfloating() const;
123  bool isinteger() const;
124  bool isbool() const;
125  void eval() const;
126  array as(dtype type) const;
127  array T() const;
128  array H() const;
129  template<typename T> T scalar() const;
130  template<typename T> T* device() const;
131  void unlock() const;
132 #if AF_API_VERSION >= 31
133  void lock() const;
134 #endif
135 
136  array::array_proxy row(int index);
137  const array::array_proxy row(int index) const;
138 
139  array::array_proxy rows(int first, int last);
140  const array::array_proxy rows(int first, int last) const;
141 
142  array::array_proxy col(int index);
143  const array::array_proxy col(int index) const;
144  array::array_proxy cols(int first, int last);
145  const array::array_proxy cols(int first, int last) const;
146 
147  array::array_proxy slice(int index);
148  const array::array_proxy slice(int index) const;
149 
150  array::array_proxy slices(int first, int last);
151  const array::array_proxy slices(int first, int last) const;
152  };
153 
154  //array(af_array in, const array *par, af_index_t seqs[4]);
166  array();
167 
172  explicit
173  array(const af_array handle);
174 
180  array(const array& in);
181 
204  array(dim_t dim0, dtype ty = f32);
205 
229  array(dim_t dim0, dim_t dim1, dtype ty = f32);
230 
255  array(dim_t dim0, dim_t dim1, dim_t dim2, dtype ty = f32);
256 
282  array(dim_t dim0, dim_t dim1, dim_t dim2, dim_t dim3, dtype ty = f32);
283 
309  explicit
310  array(const dim4& dims, dtype ty = f32);
311 
336  template<typename T>
337  array(dim_t dim0,
338  const T *pointer, af::source src=afHost);
339 
340 
359  template<typename T>
360  array(dim_t dim0, dim_t dim1,
361  const T *pointer, af::source src=afHost);
362 
363 
385  template<typename T>
386  array(dim_t dim0, dim_t dim1, dim_t dim2,
387  const T *pointer, af::source src=afHost);
388 
389 
412  template<typename T>
413  array(dim_t dim0, dim_t dim1, dim_t dim2, dim_t dim3,
414  const T *pointer, af::source src=afHost);
415 
449  template<typename T>
450  explicit
451  array(const dim4& dims,
452  const T *pointer, af::source src=afHost);
453 
481  array(const array& input, const dim4& dims);
482 
514  array( const array& input,
515  const dim_t dim0, const dim_t dim1 = 1,
516  const dim_t dim2 = 1, const dim_t dim3 = 1);
517 
530  af_array get();
531 
535  af_array get() const;
536 
540  dim_t elements() const;
541 
545  template<typename T> T* host() const;
546 
550  void host(void *ptr) const;
551 
555  template<typename T> void write(const T *ptr, const size_t bytes, af::source src = afHost);
556 
560  dtype type() const;
561 
565  dim4 dims() const;
566 
570  dim_t dims(unsigned dim) const;
571 
575  unsigned numdims() const;
576 
580  size_t bytes() const;
581 
585  array copy() const;
586 
590  bool isempty() const;
591 
595  bool isscalar() const;
596 
600  bool isvector() const;
601 
605  bool isrow() const;
606 
610  bool iscolumn() const;
611 
615  bool iscomplex() const;
616 
620  inline bool isreal() const { return !iscomplex(); }
621 
625  bool isdouble() const;
626 
630  bool issingle() const;
631 
635  bool isrealfloating() const;
636 
640  bool isfloating() const;
641 
645  bool isinteger() const;
646 
650  bool isbool() const;
651 
655  void eval() const;
656 
662  template<typename T> T scalar() const;
663 
680  template<typename T> T* device() const;
685  // INDEXING
686  // Single arguments
687 
705  array::array_proxy operator()(const index &s0);
706 
712  const array::array_proxy operator()(const index &s0) const;
713 
714 
732  array::array_proxy operator()(const index &s0,
733  const index &s1,
734  const index &s2 = span,
735  const index &s3 = span);
736 
742  const array::array_proxy operator()(const index &s0,
743  const index &s1,
744  const index &s2 = span,
745  const index &s3 = span) const;
746 
747 
759  array::array_proxy row(int index);
760  const array::array_proxy row(int index) const;
761 
771  array::array_proxy rows(int first, int last);
772  const array::array_proxy rows(int first, int last) const;
773 
786  array::array_proxy col(int index);
787  const array::array_proxy col(int index) const;
788 
798  array::array_proxy cols(int first, int last);
799  const array::array_proxy cols(int first, int last) const;
800 
813  array::array_proxy slice(int index);
814  const array::array_proxy slice(int index) const;
815 
824  array::array_proxy slices(int first, int last);
825  const array::array_proxy slices(int first, int last) const;
826 
833  const array as(dtype type) const;
834 
835 
836  ~array();
837 
842  array T() const;
847  array H() const;
848 
849 #define ASSIGN_(OP) \
850  array& OP(const array &val); \
851  array& OP(const double &val); \
852  array& OP(const cdouble &val); \
853  array& OP(const cfloat &val); \
854  array& OP(const float &val); \
855  array& OP(const int &val); \
856  array& OP(const unsigned &val); \
857  array& OP(const bool &val); \
858  array& OP(const char &val); \
859  array& OP(const unsigned char &val); \
860  array& OP(const long &val); \
861  array& OP(const unsigned long &val); \
862  array& OP(const long long &val); \
863  array& OP(const unsigned long long &val); \
864 
865 #if AF_API_VERSION >= 32
866 #define ASSIGN(OP) \
867  ASSIGN_(OP) \
868  array& OP(const short &val); \
869  array& OP(const unsigned short &val); \
870 
871 #else
872 #define ASSIGN(OP) ASSIGN_(OP)
873 #endif
874 
875 
885  ASSIGN(operator=)
887 
897  ASSIGN(operator+=)
899 
909  ASSIGN(operator-=)
911 
921  ASSIGN(operator*=)
923 
934  ASSIGN(operator/=)
936 
937 
938 #undef ASSIGN
939 #undef ASSIGN_
940 
946  array operator -() const;
947 
953  array operator !() const;
954 
959  int nonzeros() const;
960 
961 
967  void lock() const;
968 
974  void unlock() const;
975  };
976  // end of class array
977 
978 #define BIN_OP_(OP) \
979  AFAPI array OP (const array& lhs, const array& rhs); \
980  AFAPI array OP (const bool& lhs, const array& rhs); \
981  AFAPI array OP (const int& lhs, const array& rhs); \
982  AFAPI array OP (const unsigned& lhs, const array& rhs); \
983  AFAPI array OP (const char& lhs, const array& rhs); \
984  AFAPI array OP (const unsigned char& lhs, const array& rhs); \
985  AFAPI array OP (const long& lhs, const array& rhs); \
986  AFAPI array OP (const unsigned long& lhs, const array& rhs); \
987  AFAPI array OP (const long long& lhs, const array& rhs); \
988  AFAPI array OP (const unsigned long long& lhs, const array& rhs); \
989  AFAPI array OP (const double& lhs, const array& rhs); \
990  AFAPI array OP (const float& lhs, const array& rhs); \
991  AFAPI array OP (const cfloat& lhs, const array& rhs); \
992  AFAPI array OP (const cdouble& lhs, const array& rhs); \
993  AFAPI array OP (const array& lhs, const bool& rhs); \
994  AFAPI array OP (const array& lhs, const int& rhs); \
995  AFAPI array OP (const array& lhs, const unsigned& rhs); \
996  AFAPI array OP (const array& lhs, const char& rhs); \
997  AFAPI array OP (const array& lhs, const unsigned char& rhs); \
998  AFAPI array OP (const array& lhs, const long& rhs); \
999  AFAPI array OP (const array& lhs, const unsigned long& rhs); \
1000  AFAPI array OP (const array& lhs, const long long& rhs); \
1001  AFAPI array OP (const array& lhs, const unsigned long long& rhs); \
1002  AFAPI array OP (const array& lhs, const double& rhs); \
1003  AFAPI array OP (const array& lhs, const float& rhs); \
1004  AFAPI array OP (const array& lhs, const cfloat& rhs); \
1005  AFAPI array OP (const array& lhs, const cdouble& rhs); \
1006 
1007 #if AF_API_VERSION >= 32
1008 #define BIN_OP(OP) \
1009  BIN_OP_(OP) \
1010  AFAPI array OP (const short& lhs, const array& rhs); \
1011  AFAPI array OP (const unsigned short& lhs, const array& rhs); \
1012  AFAPI array OP (const array& lhs, const short& rhs); \
1013  AFAPI array OP (const array& lhs, const unsigned short& rhs); \
1014 
1015 #else
1016 #define BIN_OP(OP) BIN_OP_(OP)
1017 #endif
1018 
1027  BIN_OP(operator+ )
1029 
1038  BIN_OP(operator- )
1040 
1049  BIN_OP(operator* )
1051 
1060  BIN_OP(operator/ )
1062 
1071  BIN_OP(operator==)
1073 
1083  BIN_OP(operator!=)
1085 
1095  BIN_OP(operator< )
1097 
1107  BIN_OP(operator<=)
1109 
1119  BIN_OP(operator> )
1121 
1131  BIN_OP(operator>=)
1133 
1144  BIN_OP(operator&&)
1146 
1157  BIN_OP(operator||)
1159 
1169  BIN_OP(operator% )
1171 
1182  BIN_OP(operator& )
1184 
1195  BIN_OP(operator| )
1197 
1208  BIN_OP(operator^ )
1210 
1221  BIN_OP(operator<<)
1223 
1234  BIN_OP(operator>>)
1236 
1237 #undef BIN_OP
1238 #undef BIN_OP_
1239 
1241 
1245  inline array &eval(array &a) { a.eval(); return a; }
1246  inline void eval(array &a, array &b) { eval(a); b.eval(); }
1247  inline void eval(array &a, array &b, array &c) { eval(a, b); c.eval(); }
1248  inline void eval(array &a, array &b, array &c, array &d) { eval(a, b, c); d.eval(); }
1249  inline void eval(array &a, array &b, array &c, array &d, array &e) { eval(a, b, c, d); e.eval(); }
1250  inline void eval(array &a, array &b, array &c, array &d, array &e, array &f) { eval(a, b, c, d, e); f.eval(); }
1255 }
1256 #endif
1257 
1258 #ifdef __cplusplus
1259 extern "C" {
1260 #endif
1261 
1280  AFAPI af_err af_create_array(af_array *arr, const void * const data, const unsigned ndims, const dim_t * const dims, const af_dtype type);
1281 
1292  AFAPI af_err af_create_handle(af_array *arr, const unsigned ndims, const dim_t * const dims, const af_dtype type);
1293 
1304  AFAPI af_err af_copy_array(af_array *arr, const af_array in);
1305 
1309  AFAPI af_err af_write_array(af_array arr, const void *data, const size_t bytes, af_source src);
1310 
1316  AFAPI af_err af_get_data_ptr(void *data, const af_array arr);
1317 
1321  AFAPI af_err af_release_array(af_array arr);
1322 
1326  AFAPI af_err af_retain_array(af_array *out, const af_array in);
1327 
1328 #if AF_API_VERSION >= 31
1329 
1335  AFAPI af_err af_get_data_ref_count(int *use_count, const af_array in);
1336 #endif
1337 
1338 
1342  AFAPI af_err af_eval(af_array in);
1343 
1360  AFAPI af_err af_get_elements(dim_t *elems, const af_array arr);
1361 
1370  AFAPI af_err af_get_type(af_dtype *type, const af_array arr);
1371 
1383  AFAPI af_err af_get_dims(dim_t *d0, dim_t *d1, dim_t *d2, dim_t *d3,
1384  const af_array arr);
1385 
1394  AFAPI af_err af_get_numdims(unsigned *result, const af_array arr);
1395 
1404  AFAPI af_err af_is_empty (bool *result, const af_array arr);
1405 
1414  AFAPI af_err af_is_scalar (bool *result, const af_array arr);
1415 
1424  AFAPI af_err af_is_row (bool *result, const af_array arr);
1425 
1434  AFAPI af_err af_is_column (bool *result, const af_array arr);
1435 
1446  AFAPI af_err af_is_vector (bool *result, const af_array arr);
1447 
1456  AFAPI af_err af_is_complex (bool *result, const af_array arr);
1457 
1468  AFAPI af_err af_is_real (bool *result, const af_array arr);
1469 
1478  AFAPI af_err af_is_double (bool *result, const af_array arr);
1479 
1488  AFAPI af_err af_is_single (bool *result, const af_array arr);
1489 
1498  AFAPI af_err af_is_realfloating (bool *result, const af_array arr);
1499 
1510  AFAPI af_err af_is_floating (bool *result, const af_array arr);
1511 
1520  AFAPI af_err af_is_integer (bool *result, const af_array arr);
1521 
1530  AFAPI af_err af_is_bool (bool *result, const af_array arr);
1535 #ifdef __cplusplus
1536 }
1537 #endif
af_is_row
AFAPI af_err af_is_row(bool *result, const af_array arr)
Check if an array is row vector.
af_is_real
AFAPI af_err af_is_real(bool *result, const af_array arr)
Check if an array is real type.
af
Definition: algorithm.h:14
af_is_realfloating
AFAPI af_err af_is_realfloating(bool *result, const af_array arr)
Check if an array is real floating point type.
af_copy_array
AFAPI af_err af_copy_array(af_array *arr, const af_array in)
Deep copy an array to another.
af_get_data_ptr
AFAPI af_err af_get_data_ptr(void *data, const af_array arr)
Copy data from an af_array to a C pointer.
ASSIGN
#define ASSIGN(OP)
(const array &)
Definition: array.h:882
af_is_complex
AFAPI af_err af_is_complex(bool *result, const af_array arr)
Check if an array is complex type.
af::array::eval
void eval() const
Evaluate any JIT expressions to generate data for the array.
af::array
A multi dimensional data container.
Definition: array.h:27
af_is_bool
AFAPI af_err af_is_bool(bool *result, const af_array arr)
Check if an array is bool type.
af_is_double
AFAPI af_err af_is_double(bool *result, const af_array arr)
Check if an array is double precision type.
af_is_vector
AFAPI af_err af_is_vector(bool *result, const af_array arr)
Check if an array is a vector.
af_is_integer
AFAPI af_err af_is_integer(bool *result, const af_array arr)
Check if an array is integer type.
afcl::array
static af::array array(af::dim4 idims, cl_mem buf, af::dtype type, bool retain=false)
Create an af::array object from an OpenCL cl_mem buffer.
Definition: opencl.h:329
af::eval
array & eval(array &a)
Evaluate an expression (nonblocking).
Definition: array.h:1283
af_index_t
Struct used while indexing af_array.
Definition: index.h:23
af_err
af_err
Definition: defines.h:63
af::span
AFAPI seq span
af::array::isreal
bool isreal() const
Returns true if the array type is neither c32 nor c64.
Definition: array.h:620
af_source
af_source
Definition: defines.h:214
af_get_type
AFAPI af_err af_get_type(af_dtype *type, const af_array arr)
Gets the type of an array.
dim_t
long long dim_t
Definition: defines.h:50
BIN_OP
#define BIN_OP(OP)
(const array&, const array&)
Definition: array.h:1039
af::array::array_proxy::isreal
bool isreal() const
Definition: array.h:118
af_is_single
AFAPI af_err af_is_single(bool *result, const af_array arr)
Check if an array is single precision type.
af_get_dims
AFAPI af_err af_get_dims(dim_t *d0, dim_t *d1, dim_t *d2, dim_t *d3, const af_array arr)
Gets the dimseions of an array.
af::index
Wrapper for af_index.
Definition: index.h:52
AFAPI
#define AFAPI
Definition: defines.h:31
af_is_scalar
AFAPI af_err af_is_scalar(bool *result, const af_array arr)
Check if an array is scalar, ie.
af_get_elements
AFAPI af_err af_get_elements(dim_t *elems, const af_array arr)
Gets the number of elements in an array.
af::copy
AFAPI void copy(array &dst, const array &src, const index &idx0, const index &idx1=span, const index &idx2=span, const index &idx3=span)
Copy the values of an input array based on index.
af_get_numdims
AFAPI af_err af_get_numdims(unsigned *result, const af_array arr)
Gets the number of dimensions of an array.
af_is_empty
AFAPI af_err af_is_empty(bool *result, const af_array arr)
Check if an array is empty.
af_release_array
AFAPI af_err af_release_array(af_array arr)
Reduce the reference count of the af_array.
af_create_array
AFAPI af_err af_create_array(af_array *arr, const void *const data, const unsigned ndims, const dim_t *const dims, const af_dtype type)
Create an af_array handle initialized with user defined data.
af_is_column
AFAPI af_err af_is_column(bool *result, const af_array arr)
Check if an array is a column vector.
af_retain_array
AFAPI af_err af_retain_array(af_array *out, const af_array in)
Increments an af_array reference count.
af_array
void * af_array
Definition: defines.h:222
af::operator-
AFAPI array operator-(const array &lhs, const array &rhs)
Subtracts two arrays or an array and a value.
af_write_array
AFAPI af_err af_write_array(af_array arr, const void *data, const size_t bytes, af_source src)
Copy data from a C pointer (host/device) to an existing array.
af_create_handle
AFAPI af_err af_create_handle(af_array *arr, const unsigned ndims, const dim_t *const dims, const af_dtype type)
Create af_array handle.
f32
32-bit floating point values
Definition: defines.h:196
af::dim4
Definition: dim4.hpp:26
af_get_data_ref_count
AFAPI af_err af_get_data_ref_count(int *use_count, const af_array in)
Get the use count of af_array
af::array::array_proxy
Intermediate data class.
Definition: array.h:45
afHost
Host pointer.
Definition: defines.h:216
af_is_floating
AFAPI af_err af_is_floating(bool *result, const af_array arr)
Check if an array is floating precision type.
af_dtype
af_dtype
Definition: defines.h:195
af_eval
AFAPI af_err af_eval(af_array in)
Evaluate any expressions in the Array.