Applies the binary operation on the input value and the operand and returns the result (or a sequence of results if the input and the operand are sequences).

## Details¶

Addition is a binary operation, i.e. it needs two arguments to give a result.

The `Math.Add` shard takes in the Input and the parameter `:Operand` to produce the Output.

Both Input and `:Operand` can be an integer, a float, or a sequence of such entities (but both value types should match for a given operation). The Output is generally of the same type as the Input provided to the shard.

## Binary operations on sequences¶

Taking `Math.Add` operator as an example.

If sequences are passed as arguments, the operator takes pairs of correspondingly placed elements from these sequences and computes the result for each pair. This gives rise to different scenarios.

1. Input and `:Operand` sequence sizes are equal

Since each element in Input sequence has a corresponding element in `:Operand` sequence, the Output sequence also has the same number of resultant elements and hence the same size as the argument sequences.

Entity Sequence Seq. Size
Input [a b c] 3
`:Operand` [1 2 3] 3
Output [(a+1) (b+2) (c+3)] 3
2. Input sequence size < `:Operand` sequence size

Here a few `:Operand` elements (`:Operand` sequence size - Input sequence size) will have no Input elements to pair off with. These `:Operand` elements are ignored in the final Output. Hence the Output sequence size here will the same as the Input sequence size.

Entity Sequence Seq. Size
Input [a b] 2
`:Operand` [1 2 3] 3
Output [(a+1) (b+2) (_+3)] => [(a+1) (b+2)] 2
3. Input sequence size > `:Operand` sequence size

Once all the `:Operand` elements have been paired off and computed with the corresponding Input elements, the remaining Input elements (Input sequence size - `:Operand` sequence size) will continue looping over the `:Operand` sequence till all of the Input sequence elements have been used. As a result the Output sequence will again be the same size as the Input sequence.

Entity Sequence Seq. Size
Input [a b c d e] 5
`:Operand` [1 2] 2
Output [(a+1) (b+2) (c+1) (d+2) (e+1)] 5

Note

Such sequence operations are useful in transforming and translating 2D/3D grid values (a frequent requirement in graphics rendering). This is done by passing the transform inputs as an Input sequence (to be applied to every row/line for a 2D grid or to every 2D-matrix/plane for a 3D grid) of the 2D matrix and the `:Operand` sequence as the set of 2D/3D coordinates (represented linearly) that is to be transformed.

## Examples¶

 ```1 2 3 4 5 6 7``` ``````;; Add integers (int 5) ;; :Input (Log) ;; prints input => 5 (Math.Add 2) ;; :Operand (Log) ;; prints input + operand => 7 (Assert.Is 7 true) ;; expect: (5 + 2) => 7 ``````
``````[info] [shards/Math/Add/1.edn] 5
``````

 ```1 2 3 4 5 6 7``` ``````;; Add floats (float 5.3) ;; :Input (Log) ;; prints input => 5.3 (Math.Add 2.1) ;; :Operand (Log) ;; prints input + operand => 7.4 (Assert.Is 7.4 true) ;; expect: (5.3 + 2.1) => 7.4 ``````
``````[info] [shards/Math/Add/2.edn] 5.3
``````

 ```1 2 3 4 5 6 7 8``` ``````;; Add equal-sized sequences [4 5.1 6.4] ;; :Input (Log) ;; prints input => [4 5.1 6.4] (Math.Add [3 4.0 2.2]) ;; :Operand ;; input seq elements compute with corresponding operand seq elements (Log) ;; prints input + operand => [7 9.1 8.6] (Assert.IsAlmost [7 9.1 8.6] true) ;; expect: [(4 + 3) (5.1 + 4.0) (6.4 + 2.2)] => [7 9.1 8.6] ``````
``````[info] [shards/Math/Add/3.edn] [4 5.1 6.4]
``````

 ```1 2 3 4 5 6 7 8 9``` ``````;; Add unequal-sized sequences (input size < operand size) [4.0] ;; :Input (Log) ;; prints input => [4.0] (Math.Add [3.0 4.0 2.2]) ;; :Operand ;; input seq elements compute with corresponding operand seq elements ;; since input size < operand size, remaining operand seq elements ignored (Log) ;; prints input + operand => [7.0] (Assert.Is [7.0] true) ;; expect: [(4.0 + 3.0) ... ... ] => [7.0] ``````
``````[info] [shards/Math/Add/4.edn] [4]
 ```1 2 3 4 5 6 7 8 9``` ``````;; Add unequal-sized sequences (input size > operand size) [4 2 1 5 8] ;; :Input (Log) ;; prints input => [4 2 1 5 8] (Math.Add [6 4]) ;; :Operand ;; input seq elements compute with corresponding operand seq elements ;; for (input size > operand size): remaining input seq elements continually loop over operand seq elements (Log) ;; prints input + operand => [10 6 7 9 14] (Assert.Is [10 6 7 9 14] true) ;; expect: [(4 + 6) (2 + 4) (1 + 6) (5 + 4) (8 + 6)] => [10 6 7 9 14] ``````
``````[info] [shards/Math/Add/5.edn] [4 2 1 5 8]