## A guide to all the available operator transformations on Alumio

**Addition**

As the name indicates the transformer performs addition operations on two fields (can also be with itself), and the result is dumped into the destination path of your choice.

An example implementation of this transformation is as shown below.

**Subtraction**

As the name indicates the transformer performs subtraction operations on two fields (can also be with itself), and the result is dumped into the destination path of your choice.

An example implementation of this transformation is as shown below.

**Multiplication**

Arithmetic operator to perform multiplications using 2 fields (self-reference allowed). The result will be stored in the destination path specified.

=

**Division**

Arithmetic operator to perform division using 2 fields (self-reference allowed). The result will be stored in the destination path specified.

**Array difference [Set operation A-B]**

Set operation A minus B, which is to retain the elements of Set A that is not present in B.

Example: **A = {1, 2, 3}** and **B = {2, 4}** then **A-B = {1,3}**, the element {4} is discarded as it not an element of Set A.

**Array Key Diff**

Unlike the array difference where values are matched, here the difference between index positions is determined.

Example: If **A = {1, 2, 3}** and **B = {2, 3}**; then their indexes would be

**Aindex = {1, 2, 3}** and **Bindex ={1, 2}**; **Aindex - Bindex = {3}**.

**Array Intersect**

Set operation A ∩ B, where the common elements between A and B are retained.

**Array Intersect keys**

Similar to array intersect operation, but here the indexes are returned.

TODO: Improve explaination

**Array Merge or Union**

Set operation A ∪ B, the resulting set will contain all the elements contained within A and B.

**Bitwise AND**

Bitwise AND operation that retains bits that are common in the Left and Right numbers.

Example:

0101(decimal 5)

AND 0011(decimal 3)

= 0001(decimal 1)

**Bitwise OR**

Bitwise OR operation that retains the bits if either one of the Left and Right numbers displays a high(1).

Example:

0101(decimal 5)

OR 0011(decimal 3)

= 0111(decimal 7)

### Bitwise Shift left

Shifts the "Data container **left** path" bits left to the count mentioned in the "Data container right path".

**Bitwise shift right**

Shifts the "Data container left path" bits **right** to the count mentioned in the "Data container right path".

**Bitwise XOR**

BitwiseXOR operation that retains the bits if 1-0 and 0-1 patterns are observed between the two numbers.

Example:

0101 (decimal 5)

XOR 0011 (decimal 3)

= 0110 (decimal 6)

**Concatenation**

Concatenates the Left and Right Data containers by implicitly converting them to string type.

**Logical AND**

Logical AND operator

A |
B |
A ^ B |

T | T | T |

T | F | F |

F | T | F |

F | F | F |

**Logical OR**

Logical OR operator

A |
B |
A v B |

T | T | T |

T | F | T |

F | T | T |

F | F | F |

**Logical XOR**

Logical XOR operator

A |
B |
A xor B |

T | T | F |

T | F | T |

F | T | T |

F | F | F |

**Max**

Determine the max value between the Left and Right coefficient. If Left and Right are array type, then the array with the max element will be returned.

**Min**

Determine the min value between the Left and Right coefficient. If Left and Right are array type, then the array with the min element will be returned.

**Mod**

Modulous operator, the **Left mod Right** operation is performed and the resulting remainder is returned.

**Pow**

The exponential power of the Left to the power Right (Left^Right) is performed.

**String: Replace**

Replaces the Substring or String of the Left string with empty if there is an exact match with the Right string.