index

Functions
index
Complete List of ArrayFire Functions ArrayFire Functions by Category » Functions to create and modify Arrays » | Assignment & Indexing operation on arrays

lookup values on array based on sequences and/or arrays More...

## Functions
AFAPI array | lookup (const array &in, const array &idx, const int dim=-1)
| Lookup the values of input array based on index. More...
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. More...
AFAPI af_err | af_index (af_array *out, const af_array in, const unsigned ndims, const af_seq *const index)
| Lookup the values of input array based on sequences. More...
AFAPI af_err | af_lookup (af_array *out, const af_array in, const af_array indices, const unsigned dim)
| Lookup the values of input array based on index. More...
AFAPI af_err | af_index_gen (af_array *out, const af_array in, const dim_t ndims, const af_index_t *indices)
| Indexing an array using af_seq, or af_array. More...
AFAPI af_err | af_create_indexers (af_index_t **indexers)
| Create an quadruple of af_index_t array. More...
AFAPI af_err | af_set_array_indexer (af_index_t *indexer, const af_array idx, const dim_t dim)
| set `dim` to given indexer af_array `idx` More...
AFAPI af_err | af_set_seq_indexer (af_index_t *indexer, const af_seq *idx, const dim_t dim, const bool is_batch)
| set `dim` to given indexer af_array `idx` More...
AFAPI af_err | af_set_seq_param_indexer (af_index_t *indexer, const double begin, const double end, const double step, const dim_t dim, const bool is_batch)
| set `dim` to given indexer af_array `idx` More...
AFAPI af_err | af_release_indexers (af_index_t *indexers)
| Release's the memory resource used by the quadruple af_index_t array. More...

## Detailed Description

lookup values on array based on sequences and/or arrays

## Function Documentation

## § af_create_indexers()

AFAPI af_err af_create_indexers | ( | af_index_t ** | indexers | ) |

Create an quadruple of af_index_t array.

af_index_t* indexers = 0;
af_err err = af_create_indexers(&indexers); // Memory is allocated on heap by the callee
// by default all the indexers span all the elements along the given dimension
//Create array
af_array a;
unsigned ndims = 2;
dim_t dim[] = {10,10};
af_randu(&a, ndims, dim, f32);
//Create index array
af_array idx;
unsigned n = 1;
dim_t d[] = {5};
af_range(&idx, n, d, 0, s32);
af_print_array(a);
af_print_array(idx);
//create array indexer
err = af_set_array_indexer(indexers, idx, 1);
//index with indexers
af_array out;
af_index_gen(&out, a, 2, indexers); // number of indexers should be two since
// we have set only second af_index_t
if (err != AF_SUCCESS) {
printf("Failed in af_index_gen: %d\n", err);
throw;
}
af_print_array(out);
af_release_array(out);
af_seq zeroIndices = af_make_seq(0.0, 9.0, 2.0);
err = af_set_seq_indexer(indexers, &zeroIndices, 0, false);
err = af_index_gen(&out, a, 2, indexers);
if (err != AF_SUCCESS) {
printf("Failed in af_index_gen: %d\n", err);
throw;
}
af_print_array(out);
af_release_indexers(indexers);
af_release_array(a);
af_release_array(idx);
af_release_array(out);

Parameters

  [out] | indexers | pointer to location where quadruple af_index_t array is created

Returns
  af_err error code

## § af_index()

AFAPI af_err af_index | ( | af_array * | out,
|  | const af_array | in,
|  | const unsigned | ndims,
|  | const af_seq *const | index
| ) |  |

Lookup the values of input array based on sequences.

Parameters

  [out] | out | output array containing values indexed by the sequences
  [in] | in | is the input array
  [in] | ndims | is the number of sequences provided
  [in] | index | is an array of sequences

## § af_index_gen()

AFAPI af_err af_index_gen | ( | af_array * | out,
|  | const af_array | in,
|  | const dim_t | ndims,
|  | const af_index_t * | indices
| ) |  |

Indexing an array using af_seq, or af_array.

Generalized indexing function that accepts either af_array or af_seq along a dimension to index the input array and create the corresponding output array

Parameters

  [out] | out | output array containing values at indexed by the sequences
  [in] | in | is the input array
  [in] | ndims | is the number of af_index_t provided
  [in] | indices | is an array of af_index_t objects

## § af_lookup()

AFAPI af_err af_lookup | ( | af_array * | out,
|  | const af_array | in,
|  | const af_array | indices,
|  | const unsigned | dim
| ) |  |

Lookup the values of input array based on index.

Parameters

  [out] | out | output array containing values at locations specified by `index`
  [in] | in | is input lookup array
  [in] | indices | is lookup indices
  [in] | dim | specifies the dimension for indexing

## § af_release_indexers()

AFAPI af_err af_release_indexers | ( | af_index_t * | indexers | ) |

Release's the memory resource used by the quadruple af_index_t array.

af_index_t* indexers = 0;
af_err err = af_create_indexers(&indexers); // Memory is allocated on heap by the callee
// by default all the indexers span all the elements along the given dimension
//Create array
af_array a;
unsigned ndims = 2;
dim_t dim[] = {10,10};
af_randu(&a, ndims, dim, f32);
//Create index array
af_array idx;
unsigned n = 1;
dim_t d[] = {5};
af_range(&idx, n, d, 0, s32);
af_print_array(a);
af_print_array(idx);
//create array indexer
err = af_set_array_indexer(indexers, idx, 1);
//index with indexers
af_array out;
af_index_gen(&out, a, 2, indexers); // number of indexers should be two since
// we have set only second af_index_t
if (err != AF_SUCCESS) {
printf("Failed in af_index_gen: %d\n", err);
throw;
}
af_print_array(out);
af_release_array(out);
af_seq zeroIndices = af_make_seq(0.0, 9.0, 2.0);
err = af_set_seq_indexer(indexers, &zeroIndices, 0, false);
err = af_index_gen(&out, a, 2, indexers);
if (err != AF_SUCCESS) {
printf("Failed in af_index_gen: %d\n", err);
throw;
}
af_print_array(out);
af_release_indexers(indexers);
af_release_array(a);
af_release_array(idx);
af_release_array(out);

Parameters

  [in] | indexers | is pointer to location where quadruple af_index_t array is created

## § af_set_array_indexer()

AFAPI af_err af_set_array_indexer | ( | af_index_t * | indexer,
|  | const af_array | idx,
|  | const dim_t | dim
| ) |  |

set `dim` to given indexer af_array `idx`

af_index_t* indexers = 0;
af_err err = af_create_indexers(&indexers); // Memory is allocated on heap by the callee
// by default all the indexers span all the elements along the given dimension
//Create array
af_array a;
unsigned ndims = 2;
dim_t dim[] = {10,10};
af_randu(&a, ndims, dim, f32);
//Create index array
af_array idx;
unsigned n = 1;
dim_t d[] = {5};
af_range(&idx, n, d, 0, s32);
af_print_array(a);
af_print_array(idx);
//create array indexer
err = af_set_array_indexer(indexers, idx, 1);
//index with indexers
af_array out;
af_index_gen(&out, a, 2, indexers); // number of indexers should be two since
// we have set only second af_index_t
if (err != AF_SUCCESS) {
printf("Failed in af_index_gen: %d\n", err);
throw;
}
af_print_array(out);
af_release_array(out);
af_seq zeroIndices = af_make_seq(0.0, 9.0, 2.0);
err = af_set_seq_indexer(indexers, &zeroIndices, 0, false);
err = af_index_gen(&out, a, 2, indexers);
if (err != AF_SUCCESS) {
printf("Failed in af_index_gen: %d\n", err);
throw;
}
af_print_array(out);
af_release_indexers(indexers);
af_release_array(a);
af_release_array(idx);
af_release_array(out);

Parameters

  [in] | indexer | pointer to location where quadruple af_index_t array was created
  [in] | idx | is the af_array indexer for given dimension `dim`
  [in] | dim | is the dimension to be indexed

Returns
  af_err error code

## § af_set_seq_indexer()

AFAPI af_err af_set_seq_indexer | ( | af_index_t * | indexer,
|  | const af_seq * | idx,
|  | const dim_t | dim,
|  | const bool | is_batch
| ) |  |

set `dim` to given indexer af_array `idx`

This function is similar to af_set_array_indexer in terms of functionality except that this version accepts object of type af_seq instead of af_array.

af_index_t* indexers = 0;
af_err err = af_create_indexers(&indexers); // Memory is allocated on heap by the callee
// by default all the indexers span all the elements along the given dimension
//Create array
af_array a;
unsigned ndims = 2;
dim_t dim[] = {10,10};
af_randu(&a, ndims, dim, f32);
//Create index array
af_array idx;
unsigned n = 1;
dim_t d[] = {5};
af_range(&idx, n, d, 0, s32);
af_print_array(a);
af_print_array(idx);
//create array indexer
err = af_set_array_indexer(indexers, idx, 1);
//index with indexers
af_array out;
af_index_gen(&out, a, 2, indexers); // number of indexers should be two since
// we have set only second af_index_t
if (err != AF_SUCCESS) {
printf("Failed in af_index_gen: %d\n", err);
throw;
}
af_print_array(out);
af_release_array(out);
af_seq zeroIndices = af_make_seq(0.0, 9.0, 2.0);
err = af_set_seq_indexer(indexers, &zeroIndices, 0, false);
err = af_index_gen(&out, a, 2, indexers);
if (err != AF_SUCCESS) {
printf("Failed in af_index_gen: %d\n", err);
throw;
}
af_print_array(out);
af_release_indexers(indexers);
af_release_array(a);
af_release_array(idx);
af_release_array(out);

Parameters

  [in] | indexer | pointer to location where quadruple af_index_t array was created
  [in] | idx | is the af_seq indexer for given dimension `dim`
  [in] | dim | is the dimension to be indexed
  [in] | is_batch | indicates if the sequence based indexing is inside a batch operation

## § af_set_seq_param_indexer()

AFAPI af_err af_set_seq_param_indexer | ( | af_index_t * | indexer,
|  | const double | begin,
|  | const double | end,
|  | const double | step,
|  | const dim_t | dim,
|  | const bool | is_batch
| ) |  |

set `dim` to given indexer af_array `idx`

This function is alternative to af_set_seq_indexer where instead of passing in an already prepared af_seq object, you pass the arguments necessary for creating an af_seq directly.

Parameters

  [in] | indexer | pointer to location where quadruple af_index_t array was created
  [in] | begin | is the beginning index of along dimension `dim`
  [in] | end | is the beginning index of along dimension `dim`
  [in] | step | size along dimension `dim`
  [in] | dim | is the dimension to be indexed
  [in] | is_batch | indicates if the sequence based indexing is inside a batch operation

Returns
  af_err error code

## § copy()

AFAPI void af::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.

Parameters

  [out] | dst | The destination array
  [in] | src | The source array
  [in] | idx0 | The first index
  [in] | idx1 | The second index (defaults to af::span)
  [in] | idx2 | The third index (defaults to af::span)
  [in] | idx3 | The fourth index (defaults to af::span)

## § lookup()

AFAPI array af::lookup | ( | const array & | in,
|  | const array & | idx,
|  | const int | dim = `-1`
| ) |  |

Lookup the values of input array based on index.

Parameters

  [in] | in | is input lookup array
  [in] | idx | is lookup indices
  [in] | dim | specifies the dimension for indexing

Returns
  an array containing values at locations specified by `index`

Examples:
  machine_learning/bagging.cpp, and machine_learning/naive_bayes.cpp.