org.nd4j.linalg.api.ops

Interface IndexAccumulation

All Superinterfaces:

Op

All Known Implementing Classes:

BaseIndexAccumulation, IAMax, IAMin, IMax, IMin

public interface IndexAccumulation
extends Op

An index accumulation is an operation that returns an index within a NDArray.
Examples of IndexAccumulation operations include finding the index of the minimim value, index of the maximum value, index of the first element equal to value y, index of the maximum pair-wise difference between two NDArrays X and Y etc.
Index accumulation is similar to Accumulation in that both are accumulation/reduction operations, however index accumulation returns an integer corresponding to an index, rather than a real (or complex) value.
Index accumulation operations generally have 3 inputs:
x -> the origin ndarray
y -> the pairwise ndarray (frequently null/not applicable)
n -> the number of times to accumulate
Note that IndexAccumulation op implementations should be stateless (other than the final result and x/y/n arguments) and hence threadsafe, such that they may be parallelized using the update, combineSubResults and set/getFinalResults methods.

Nested Class Summary

Nested classes/interfaces inherited from interface org.nd4j.linalg.api.ops.Op

Op.Type

Method Summary

Modifier and Type	Method and Description
int	combineSubResults(double first, int idxFirst, double second, int idxSecond) Combine sub-results, when the index accumulation is split and executed in parallel.
int	combineSubResults(float first, int idxFirst, float second, int idxSecond)
org.apache.commons.math3.util.Pair<Double,Integer>	combineSubResults(org.apache.commons.math3.util.Pair<Double,Integer> first, org.apache.commons.math3.util.Pair<Double,Integer> second)
int	getFinalResult() Get the final result of the IndexAccumulation
void	setFinalResult(int idx) Set the final index/result of the accumulation.
int	update(double accum, int accumIdx, double x, double y, int idx) Do one accumulation update for a pair-wise (2 input) index accumulation
int	update(double accum, int accumIdx, double x, int xIdx) Do one accumulation update.
int	update(float accum, int accumIdx, float x, float y, int idx)
int	update(float accum, int accumIdx, float x, int xIdx)
int	update(IComplexNumber accum, int accumIdx, double x, double y, int idx) Accumulation update for pairswise (2 input) complex numbers.
int	update(IComplexNumber accum, int accumIdx, double x, int idx) Accumulation update for complex numbers.
int	update(IComplexNumber accum, int accumIdx, IComplexNumber x, IComplexNumber y, int idx) Accumulation update for pairswise (2 input) complex numbers.
int	update(IComplexNumber accum, int accumIdx, IComplexNumber x, int xIdx) Accumulation update for complex numbers.
IComplexNumber	zeroComplex() Complex initial value
double	zeroDouble() Initial value for the index accumulation
float	zeroFloat() Initial value for the index accumulation.
org.apache.commons.math3.util.Pair<Double,Integer>	zeroPair() The initial value and initial index to use for the accumulation

Methods inherited from interface org.nd4j.linalg.api.ops.Op

exec, exec, extraArgs, extraArgsBuff, extraArgsDataBuff, init, isExecSpecial, isPassThrough, n, name, numProcessed, op, op, op, op, op, op, op, op, opForDimension, opForDimension, opNum, setN, setX, setY, setZ, x, y, z

Method Detail

update

int update(double accum,
           int accumIdx,
           double x,
           int xIdx)

Do one accumulation update. Given the current accumulation value (for example, maximum value found so far in an 'index of maximum value' operation) and another value and its index (x/xIdx), update the accumulation index.
If the accumulation value is required in addition to its index, use the Op.op(...) methods.

Parameters:

accum - The value at the accumulation index

accumIdx - The accumulation index

x - A value to be processed/accumulated

xIdx - The index of the value to be processed/accumulated

Returns:

The new accumulation index

update

int update(float accum,
           int accumIdx,
           float x,
           int xIdx)

See Also:

update(double, int, double, int)

update

int update(double accum,
           int accumIdx,
           double x,
           double y,
           int idx)

Do one accumulation update for a pair-wise (2 input) index accumulation

See Also:

update(double, int, double, int)

update

int update(float accum,
           int accumIdx,
           float x,
           float y,
           int idx)

See Also:

update(double, int, double, double, int)

update

int update(IComplexNumber accum,
           int accumIdx,
           IComplexNumber x,
           int xIdx)

Accumulation update for complex numbers.

See Also:

update(double, int, double, int)

update

int update(IComplexNumber accum,
           int accumIdx,
           double x,
           int idx)

Accumulation update for complex numbers.

See Also:

update(double, int, double, int)

update

int update(IComplexNumber accum,
           int accumIdx,
           double x,
           double y,
           int idx)

Accumulation update for pairswise (2 input) complex numbers.

See Also:

update(double, int, double, int)

update

int update(IComplexNumber accum,
           int accumIdx,
           IComplexNumber x,
           IComplexNumber y,
           int idx)

Accumulation update for pairswise (2 input) complex numbers.

See Also:

update(double, int, double, int)

combineSubResults

int combineSubResults(double first,
                      int idxFirst,
                      double second,
                      int idxSecond)

Combine sub-results, when the index accumulation is split and executed in parallel. Often this is the same as the update operations (i.e., when finding index of maximum value for example), but sometimes not.
Generally used internally by OpExecutors etc.

Parameters:

first - Value of one sub-accumulation (i.e., partial from one thread)

idxFirst - Index of the first value

second - Value of another sub-accumulation (i.e., partial accumulation from another thread)

idxSecond - Index of the second value

Returns:

Combined/accumulated index

combineSubResults

int combineSubResults(float first,
                      int idxFirst,
                      float second,
                      int idxSecond)

See Also:

combineSubResults(double, int, double, int)

combineSubResults

org.apache.commons.math3.util.Pair<Double,Integer> combineSubResults(org.apache.commons.math3.util.Pair<Double,Integer> first,
                                                                     org.apache.commons.math3.util.Pair<Double,Integer> second)

See Also:

combineSubResults(double, int, double, int)

setFinalResult

void setFinalResult(int idx)

Set the final index/result of the accumulation.

getFinalResult

int getFinalResult()

Get the final result of the IndexAccumulation

zeroDouble

double zeroDouble()

Initial value for the index accumulation

Returns:

the initial value

zeroFloat

float zeroFloat()

Initial value for the index accumulation.

Returns:

the initial value

zeroPair

org.apache.commons.math3.util.Pair<Double,Integer> zeroPair()

The initial value and initial index to use for the accumulation

Returns:

zeroComplex

IComplexNumber zeroComplex()

Complex initial value

Returns:

the complex initial value