47             struct array_proxy_impl;    
 
   48             array_proxy_impl *impl;     
 
   53 #if __cplusplus > 199711L 
   60             operator array() 
const;
 
   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);  \ 
   87 #if AF_API_VERSION >= 32 
   89             array_proxy& operator OP(const short &a);               \ 
   90             array_proxy& operator OP(const unsigned short &a);      \ 
  103             dim_t elements() 
const;
 
  104             template<
typename T> T* host() 
const;
 
  105             void host(
void *ptr) 
const;
 
  108             dim_t dims(
unsigned dim) 
const;
 
  109             unsigned numdims() 
const;
 
  110             size_t bytes() 
const;
 
  112             bool isempty() 
const;
 
  113             bool isscalar() 
const;
 
  114             bool isvector() 
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;
 
  129             template<
typename T> T scalar() 
const;
 
  130             template<
typename T> T* device() 
const;
 
  132 #if AF_API_VERSION >= 31 
  540         dim_t elements() 
const;
 
  545         template<
typename T> T* host() 
const;
 
  550         void host(
void *ptr) 
const;
 
  555         template<
typename T> 
void write(
const T *ptr, 
const size_t bytes, 
af::source src = 
afHost);
 
  570         dim_t dims(
unsigned dim) 
const;
 
  575         unsigned numdims() 
const;
 
  580         size_t bytes() 
const;
 
  590         bool isempty() 
const;
 
  595         bool isscalar() 
const;
 
  600         bool isvector() 
const;
 
  610         bool iscolumn() 
const;
 
  615         bool iscomplex() 
const;
 
  620         inline bool isreal()
 const { 
return !iscomplex(); }
 
  625         bool isdouble() 
const;
 
  630         bool issingle() 
const;
 
  635         bool isrealfloating() 
const;
 
  640         bool isfloating() 
const;
 
  645         bool isinteger() 
const;
 
  662         template<
typename T> T scalar() 
const;
 
  678         template<
typename T> T* device() 
const;
 
  829 #define ASSIGN_(OP)                                                                     \ 
  830         array& OP(const array &val);                                                    \ 
  831         array& OP(const double &val);                \ 
  832         array& OP(const cdouble &val);               \ 
  833         array& OP(const cfloat &val);                \ 
  834         array& OP(const float &val);                 \ 
  835         array& OP(const int &val);                   \ 
  836         array& OP(const unsigned &val);              \ 
  837         array& OP(const bool &val);                  \ 
  838         array& OP(const char &val);                  \ 
  839         array& OP(const unsigned char &val);         \ 
  840         array& OP(const long  &val);                 \ 
  841         array& OP(const unsigned long &val);         \ 
  842         array& OP(const long long  &val);            \ 
  843         array& OP(const unsigned long long &val);    \ 
  845 #if AF_API_VERSION >= 32 
  848         array& OP(const short  &val);                \ 
  849         array& OP(const unsigned short &val);        \ 
  852 #define ASSIGN(OP) ASSIGN_(OP) 
  933         array operator !() 
const;
 
  939         int nonzeros() 
const;
 
  958 #define BIN_OP_(OP)                                                                                                      \ 
  959     AFAPI array OP (const array& lhs, const array& rhs);                                                                 \ 
  960     AFAPI array OP (const bool& lhs, const array& rhs);                  \ 
  961     AFAPI array OP (const int& lhs, const array& rhs);                   \ 
  962     AFAPI array OP (const unsigned& lhs, const array& rhs);              \ 
  963     AFAPI array OP (const char& lhs, const array& rhs);                  \ 
  964     AFAPI array OP (const unsigned char& lhs, const array& rhs);         \ 
  965     AFAPI array OP (const long& lhs, const array& rhs);                  \ 
  966     AFAPI array OP (const unsigned long& lhs, const array& rhs);         \ 
  967     AFAPI array OP (const long long& lhs, const array& rhs);             \ 
  968     AFAPI array OP (const unsigned long long& lhs, const array& rhs);    \ 
  969     AFAPI array OP (const double& lhs, const array& rhs);                \ 
  970     AFAPI array OP (const float& lhs, const array& rhs);                 \ 
  971     AFAPI array OP (const cfloat& lhs, const array& rhs);                \ 
  972     AFAPI array OP (const cdouble& lhs, const array& rhs);               \ 
  973     AFAPI array OP (const array& lhs, const bool& rhs);                  \ 
  974     AFAPI array OP (const array& lhs, const int& rhs);                   \ 
  975     AFAPI array OP (const array& lhs, const unsigned& rhs);              \ 
  976     AFAPI array OP (const array& lhs, const char& rhs);                  \ 
  977     AFAPI array OP (const array& lhs, const unsigned char& rhs);         \ 
  978     AFAPI array OP (const array& lhs, const long& rhs);                  \ 
  979     AFAPI array OP (const array& lhs, const unsigned long& rhs);         \ 
  980     AFAPI array OP (const array& lhs, const long long& rhs);             \ 
  981     AFAPI array OP (const array& lhs, const unsigned long long& rhs);    \ 
  982     AFAPI array OP (const array& lhs, const double& rhs);                \ 
  983     AFAPI array OP (const array& lhs, const float& rhs);                 \ 
  984     AFAPI array OP (const array& lhs, const cfloat& rhs);                \ 
  985     AFAPI array OP (const array& lhs, const cdouble& rhs);               \ 
  987 #if AF_API_VERSION >= 32 
  990         AFAPI array OP (const short& lhs, const array& rhs);             \ 
  991         AFAPI array OP (const unsigned short& lhs, const array& rhs);    \ 
  992         AFAPI array OP (const array& lhs, const short& rhs);             \ 
  993         AFAPI array OP (const array& lhs, const unsigned short& rhs);    \ 
  996 #define BIN_OP(OP) BIN_OP_(OP) 
 1308 #if AF_API_VERSION >= 31 
#define ASSIGN(OP)                                                                                                
(const array &) 
Definition: array.h:862
AFAPI af_err af_is_row(bool *result, const af_array arr)
Check if an array is row vector. 
AFAPI af_err af_is_real(bool *result, const af_array arr)
Check if an array is real type. 
Definition: algorithm.h:14
AFAPI af_err af_is_realfloating(bool *result, const af_array arr)
Check if an array is real floating point type. 
#define BIN_OP(OP)                                                                                                                                                                                                          
(const array&, const array&) 
Definition: array.h:1019
AFAPI af_err af_copy_array(af_array *arr, const af_array in)
Deep copy an array to another. 
AFAPI af_err af_get_data_ptr(void *data, const af_array arr)
Copy data from an af_array to a C pointer. 
AFAPI af_err af_is_complex(bool *result, const af_array arr)
Check if an array is complex type. 
void eval() const 
Evaluate any JIT expressions to generate data for the array. 
A multi dimensional data container. 
Definition: array.h:27
AFAPI af_err af_is_bool(bool *result, const af_array arr)
Check if an array is bool type. 
AFAPI af_err af_is_double(bool *result, const af_array arr)
Check if an array is double precision type. 
AFAPI af_err af_is_vector(bool *result, const af_array arr)
Check if an array is a vector. 
AFAPI af_err af_is_integer(bool *result, const af_array arr)
Check if an array is integer type. 
array & eval(array &a)
Evaluate an expression (nonblocking). 
Definition: array.h:1263
Struct used while indexing af_array. 
Definition: index.h:23
af_err
Definition: defines.h:67
bool isreal() const 
Returns true if the array type is neither c32 nor c64. 
Definition: array.h:620
af_source
Definition: defines.h:211
AFAPI af_err af_get_type(af_dtype *type, const af_array arr)
Gets the type of an array. 
long long dim_t
Definition: defines.h:50
bool isreal() const 
Definition: array.h:118
AFAPI af_err af_is_single(bool *result, const af_array arr)
Check if an array is single precision type. 
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. 
Wrapper for af_index. 
Definition: index.h:52
#define AFAPI
Definition: defines.h:31
AFAPI af_err af_is_scalar(bool *result, const af_array arr)
Check if an array is scalar, ie. 
AFAPI af_err af_get_elements(dim_t *elems, const af_array arr)
Gets the number of elements in an array. 
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. 
AFAPI af_err af_get_numdims(unsigned *result, const af_array arr)
Gets the number of dimensions of an array. 
AFAPI af_err af_is_empty(bool *result, const af_array arr)
Check if an array is empty. 
AFAPI af_err af_release_array(af_array arr)
Reduce the reference count of the af_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. 
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:161
AFAPI af_err af_is_column(bool *result, const af_array arr)
Check if an array is a column vector. 
AFAPI af_err af_retain_array(af_array *out, const af_array in)
Increments an af_array reference count. 
void * af_array
Definition: defines.h:219
AFAPI array operator-(const array &lhs, const array &rhs)
Subtracts two arrays or an array and a value. 
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. 
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. 
32-bit floating point values 
Definition: defines.h:193
AFAPI af_err af_get_data_ref_count(int *use_count, const af_array in)
Get the use count of af_array 
Intermediate data class. 
Definition: array.h:45
Host pointer. 
Definition: defines.h:213
AFAPI af_err af_is_floating(bool *result, const af_array arr)
Check if an array is floating precision type. 
af_dtype
Definition: defines.h:192
AFAPI af_err af_eval(af_array in)
Evaluate any expressions in the Array.