AbstractOperation (neureka 1.0.1 API)

java.lang.Object
- neureka.backend.api.template.operations.AbstractOperation

All Implemented Interfaces:

Operation

Direct Known Subclasses:

Absolute, Addition, AssignLeft, Cat, Cbrt, Convolution, Cosinus, DimFit, DimTrim, Division, DotProduct, Exp, GaSU, GaTU, Gaussian, GaussianFast, GeLU, Identity, Log10, Logarithm, MatMul, Max, Min, Modulo, Multiplication, Permute, Power, Product, Quadratic, Randomization, ReLayout, ReLU, Reshape, SeLU, Sigmoid, SiLU, Sinus, Slice, Softplus, Softsign, Sqrt, Subtraction, Sum, Summation, Tanh, TanhFast, XConvLeft, XConvRight
```
public abstract class AbstractOperation
extends java.lang.Object
implements Operation
```
This abstract Operation implementation is a useful template for creating new operations. It provides a partial implementation which consists of a simple component system for hosting Algorithm instances as well as a set of properties which Operation implementations are expected to have.
Therefore, the number of properties this class needs to receive is rather large. In order to instantiate it one has to pass OperationBuilder instance to the constructor. Using the factory will make the property configuration as readable as possible.

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`_arity` Arity is the number of arguments or operands that this function or operation takes.
`protected java.lang.String`	`_function` An operation may have two ways in which it can describe itself as String within a Function AST.
`protected boolean`	`_isDifferentiable` Certain operations are not differentiable, meaning they cannot participate in neither forward nor reverse mode differentiation.
`protected boolean`	`_isIndexer` This flag determines if this operation is auto-indexing passed input arguments.
`protected boolean`	`_isInline` Inline operations are operations which change the state of the arguments passed to them.
`protected boolean`	`_isOperator`
`protected java.lang.String`	`_operator` An operation may have two ways in which it can describe itself as String within a Function AST.

Constructor Summary

Constructors
Constructor and Description

AbstractOperation(OperationBuilder builder)

Constructors
Constructor and Description
`AbstractOperation(OperationBuilder builder)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`java.lang.String`	`asDerivative(Function[] children, int derivationIndex)` `Operation` implementations and `Function` implementations are in a tight relationship where the `Function` describes an abstract syntax tree based on the syntactic information provided by the `Operation` (through methods like `Operation.getOperator()` or `Operation.getIdentifier()`).
`<T extends Algorithm> T`	`getAlgorithm(java.lang.Class<T> type)` `Operation` implementations embody a component system hosting unique `Algorithm` instances.
`Algorithm`	`getAlgorithmFor(ExecutionCall<?> call)` Alongside a component system made up of `Algorithm` instances, implementations of this interface also ought to express a routing mechanism which finds the best `Algorithm` for a given `ExecutionCall` instance.
`Algorithm[]`	`getAllAlgorithms()`
`int`	`getArity()` Arity is the number of arguments or operands that this function or operation takes.
`FallbackAlgorithm`	`getDefaultAlgorithm()`
`java.lang.String`	`getIdentifier()` Concrete `Operation` types ought to be representable by a function name.
`java.lang.String`	`getOperator()`
`boolean`	`isDifferentiable()`
`boolean`	`isIndexer()` This boolean property tell the `Function` implementations that this `Operation` ought to be viewed as something to be indexed.
`boolean`	`isInline()` This flag indicates that the implementation of this `Operation` performs an operation which modifies the inputs to that operation.
`boolean`	`isOperator()` An operator is an alternative to a function like "sum()" or "prod()".
`protected java.lang.String`	`operationName()` Override this if you want your operation to have a string representation with a custom prefix which is something other than the simple class name!
`<T extends Algorithm> Operation`	`setAlgorithm(java.lang.Class<T> type, T instance)` `Operation` implementations embody a component system hosting unique `Algorithm` instances.
`java.lang.String`	`stringify(java.lang.String[] children)`
`<T extends Algorithm> boolean`	`supports(java.lang.Class<T> implementation)`
`<T extends Algorithm> boolean`	`supportsAlgorithm(java.lang.Class<T> type)` This method checks if this `Operation` contains an instance of the `Algorithm` implementation specified via its type class.
`java.lang.String`	`toString()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface neureka.backend.api.Operation
builder, calculate, execute, setAlgorithm

- Field Detail
  - _function
```
protected final java.lang.String _function
```
    An operation may have two ways in which it can describe itself as String within a Function AST. The first one is an operator style of representation and the second one a classical function. So for the 'Addition' operation the following two representations exist:
    - Operator: '+'; Example: 'I[0] + 3 + 5 * I[1]'
    - Function: 'add'; Example: 'add( I[0], 3, 5*I[1] )'
    The following String is the latter way of representing the operation, namely: a functional way.
  - _operator
```
protected final java.lang.String _operator
```
    An operation may have two ways in which it can describe itself as String within a Function AST. The first one is an operator style of representation and the second one a classical function. So for the 'Addition' operation the following two representations exist:
    - Operator: '+'; Example: 'I[0] + 3 + 5 * I[1]'
    - Function: 'add'; Example: 'add( I[0], 3, 5*I[1] )'
    The following String is the primary way of representing the operation, namely: as an operator.
  - _arity
```
protected final int _arity
```
    Arity is the number of arguments or operands that this function or operation takes.
  - _isIndexer
```
protected final boolean _isIndexer
```
    This flag determines if this operation is auto-indexing passed input arguments. Auto-indexing inputs means that for a given array of input arguments the wrapping Function instance will call its child nodes targeted via an index incrementally. The variable 'j' in a Functions expressions containing 'I[j]' will then be resolved to an actual input for a given indexer...
  - _isDifferentiable
```
protected final boolean _isDifferentiable
```
    Certain operations are not differentiable, meaning they cannot participate in neither forward nor reverse mode differentiation. In order to avoid error-prone behaviour trying to involve non- differentiable operations will yield proper exceptions.
  - _isInline
```
protected final boolean _isInline
```
    Inline operations are operations which change the state of the arguments passed to them.
  - _isOperator
```
protected final boolean _isOperator
```
- Constructor Detail
  - AbstractOperation
```
public AbstractOperation(OperationBuilder builder)
```
- Method Detail
  - getAllAlgorithms
```
public final Algorithm[] getAllAlgorithms()
```
    Specified by:
    
    getAllAlgorithms in interface Operation
  - getAlgorithm
```
public final <T extends Algorithm> T getAlgorithm(java.lang.Class<T> type)
```
    Operation implementations embody a component system hosting unique Algorithm instances. For a given class implementing the Algorithm class, there can only be a single instance of it referenced (aka supported) by a given Operation instance. This method ensures this in terms of read access by returning only a single instance or null based on the provided class instance whose type extends the Algorithm interface.
    
    Specified by:
    
    getAlgorithm in interface Operation
    
    Type Parameters:
    
    T - The type parameter of the Algorithm type class.
    
    Parameters:
    
    type - The class of the type which implements Algorithm as a key to get an existing instance.
    
    Returns:
    
    The instance of the specified type if any exists within this Operation.
  - supportsAlgorithm
```
public final <T extends Algorithm> boolean supportsAlgorithm(java.lang.Class<T> type)
```
    This method checks if this Operation contains an instance of the Algorithm implementation specified via its type class.
    
    Specified by:
    
    supportsAlgorithm in interface Operation
    
    Type Parameters:
    
    T - The type parameter of the Algorithm type class.
    
    Parameters:
    
    type - The class of the type which implements Algorithm.
    
    Returns:
    
    The truth value determining if this Operation contains an instance of the specified Algorithm type.
  - setAlgorithm
```
public final <T extends Algorithm> Operation setAlgorithm(java.lang.Class<T> type,
                                                          T instance)
```
    Operation implementations embody a component system hosting unique Algorithm instances. For a given class implementing the Algorithm class, there can only be a single instance of it referenced (aka supported) by a given Operation instance. This method enables the registration of Algorithm types in the component system of this Operation.
    
    Specified by:
    
    setAlgorithm in interface Operation
    
    Type Parameters:
    
    T - The type parameter of the Algorithm type class.
    
    Parameters:
    
    type - The class of the type which implements Algorithm as key for the provided instance.
    
    instance - The instance of the provided type class which ought to be referenced (supported) by this Operation.
    
    Returns:
    
    This very Operation instance to enable method chaining on it.
  - getAlgorithmFor
```
public final Algorithm getAlgorithmFor(ExecutionCall<?> call)
```
    Description copied from interface: Operation
    
    Alongside a component system made up of Algorithm instances, implementations of this interface also ought to express a routing mechanism which finds the best Algorithm for a given ExecutionCall instance. This method signature describes this requirement.
    
    Specified by:
    
    getAlgorithmFor in interface Operation
    
    Parameters:
    
    call - The ExecutionCall instance which needs the best Algorithm for execution.
    
    Returns:
    
    The chosen Algorithm which ought to be fir for execution the provided call.
  - supports
```
public final <T extends Algorithm> boolean supports(java.lang.Class<T> implementation)
```
    Specified by:
    
    supports in interface Operation
  - isOperator
```
public final boolean isOperator()
```
    Description copied from interface: Operation
    
    An operator is an alternative to a function like "sum()" or "prod()".
    Examples would be "+, -, * ..."!
    
    Specified by:
    
    isOperator in interface Operation
    
    Returns:
    
    If this operation can be represented as operator like "+, -, * ..."!
  - getIdentifier
```
public java.lang.String getIdentifier()
```
    Description copied from interface: Operation
    
    Concrete Operation types ought to be representable by a function name. The following ensures that this contract is met when overriding the method.
    
    Specified by:
    
    getIdentifier in interface Operation
    
    Returns:
    
    the function name which serves as identifier when parsing Function instances.
  - getOperator
```
public final java.lang.String getOperator()
```
    Specified by:
    
    getOperator in interface Operation
  - getArity
```
public final int getArity()
```
    Description copied from interface: Operation
    
    Arity is the number of arguments or operands that this function or operation takes.
    
    Specified by:
    
    getArity in interface Operation
    
    Returns:
    
    The number of arguments expected by this operation, or -1 if an arbitrary number is accepted.
  - isIndexer
```
public final boolean isIndexer()
```
    Description copied from interface: Operation
    
    This boolean property tell the Function implementations that this Operation ought to be viewed as something to be indexed. The Function will use this information to iterate over all the provided inputs and then execute the function wile also passing the index to the function AST. The resulting array will then be available to this Operation as argument list. This feature works alongside the Function implementation found in FunctionVariable, which represents an input indexed by the identifier 'j'!
    
    Specified by:
    
    isIndexer in interface Operation
    
    Returns:
    
    If this operation is an indexer.
  - isDifferentiable
```
public final boolean isDifferentiable()
```
    Specified by:
    
    isDifferentiable in interface Operation
  - isInline
```
public boolean isInline()
```
    Description copied from interface: Operation
    
    This flag indicates that the implementation of this Operation performs an operation which modifies the inputs to that operation. An example of this would be an assignment operation which copies the contents of one nd-array / tensor into another tensor. This second tensor will then have changed its state. This can be dangerous when auto-differentiation is involved.
    
    Specified by:
    
    isInline in interface Operation
    
    Returns:
    
    The truth value determining if this Operation changes the contents of inputs.
  - getDefaultAlgorithm
```
public final FallbackAlgorithm getDefaultAlgorithm()
```
  - asDerivative
```
public java.lang.String asDerivative(Function[] children,
                                     int derivationIndex)
```
    Operation implementations and Function implementations are in a tight relationship where the Function describes an abstract syntax tree based on the syntactic information provided by the Operation (through methods like Operation.getOperator() or Operation.getIdentifier()). One important feature of the Function is the ability to create derivatives by calling the Function.getDerivative(int) method. Implementations of this Function method ought to call the method defined below in order to form the derivation based on the child nodes of the abstract syntax tree of the given Function node.
    
    Specified by:
    
    asDerivative in interface Operation
    
    Parameters:
    
    children - The child nodes of a AST node referencing this operation.
    
    derivationIndex - The index of the input node which ought to be derived.
    
    Returns:
    
    The derivative as a String which should be parsable into yet another AST.
  - stringify
```
public java.lang.String stringify(java.lang.String[] children)
```
    Specified by:
    
    stringify in interface Operation
  - toString
```
public final java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - operationName
```
protected java.lang.String operationName()
```
    Override this if you want your operation to have a string representation with a custom prefix which is something other than the simple class name!
    
    Returns:
    
    The simple class name, or something else if overridden.

Class AbstractOperation

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface neureka.backend.api.Operation

Field Detail

_function

_operator

_arity

_isIndexer

_isDifferentiable

_isInline

_isOperator

Constructor Detail

AbstractOperation

Method Detail

getAllAlgorithms

getAlgorithm

supportsAlgorithm

setAlgorithm

getAlgorithmFor

supports

isOperator

getIdentifier

getOperator

getArity

isIndexer

isDifferentiable

isInline

getDefaultAlgorithm

asDerivative

stringify

toString

operationName