<jupyter_start><jupyter_text>DALI binary arithmetic operators - type promotionsIn this example, we will describe the rules regarding type promotions for binary arithmetic operators in DALI. Details on using arithmetic operators in DALI can be found in "DALI expressions and arithmetic operators" notebook.  Prepare the test pipelineFirst, we will prepare the helper code, so we can easily manipulate the types and values that will appear as tensors in the DALI pipeline.We will be using numpy as source for the custom provided data and we also need to import several things from DALI, needed to create Pipeline and use ExternalSource Operator.<jupyter_code>import numpy as np
from nvidia.dali.pipeline import Pipeline
import nvidia.dali.ops as ops            
import nvidia.dali.types as types
from nvidia.dali.types import Constant

batch_size = 1<jupyter_output><empty_output><jupyter_text>Defining the dataAs we are dealing with binary operators, we need two inputs. We will create a simple helper function that returns two numpy arrays of given numpy types with arbitrary selected values. It is to make the manipulation of types easy. In an actual scenario the data processed by DALI arithmetic operators would be tensors produced by other Operator containing some images, video sequences or other data.Keep in mind that shapes of both inputs need to match as those will be element-wise operations.<jupyter_code>left_magic_values = [42, 8]
right_magic_values = [9, 2]

def get_data(left_type, right_type):
    return ([left_type(left_magic_values)], [right_type(right_magic_values)])

batch_size = 1<jupyter_output><empty_output><jupyter_text>Defining the pipelineThe next step is to define the Pipeline. We override `Pipeline.iter_setup`, a method called by the pipeline before every `Pipeline.run`. It is meant to feed the data into `ExternalSource()` operators indicated by `self.left` and `self.right`.The data will be obtained from `get_data` function to which we pass the left and right types. Note, that we do not need to instantiate any additional operators, we can use regular Python arithmetic expressions on the results of other operators in the `define_graph` step.For convenience, we'll wrap the usage of arithmetic operations in a lambda called `operation`, specified when creating the pipeline.`define_graph` will return both our data inputs and the result of applying `operation` to them.<jupyter_code>class ArithmeticPipeline(Pipeline):                   
    def __init__(self, operation, left_type, right_type, batch_size, num_threads, device_id):
        super(ArithmeticPipeline, self).__init__(batch_size, num_threads, device_id, seed=12)
        self.left_source = ops.ExternalSource()
        self.right_source = ops.ExternalSource()
        self.operation = operation
        self.left_type = left_type
        self.right_type = right_type

    def define_graph(self):                                                                
        self.left = self.left_source()
        self.right = self.right_source()
        return self.left, self.right, self.operation(self.left, self.right)

    def iter_setup(self):
        (l, r) = get_data(self.left_type, self.right_type)
        self.feed_input(self.left, l)
        self.feed_input(self.right, r)<jupyter_output><empty_output><jupyter_text>Type promotion rulesType promotions for binary operators are described below. The type promotion rules are commutative. They apply to `+`, `-`, `*`, and `//`. The `/` always returns a float32 for integer inputs, and applies the rules below when at least one of the inputs is a floating point number.| Operand Type | Operand Type | Result Type | Additional Conditions ||:------------:|:------------:|:-----------:| --------------------- || T      | T      | T                |                        || floatX | T      | floatX           | where T is not a float || floatX | floatY | float(max(X, Y)) |                        || intX   | intY   | int(max(X, Y))   |                        || uintX  | uintY  | uint(max(X, Y))  |                        || intX   | uintY  | int2Y            | if X <= Y              || intX   | uintY  | intX             | if X > Y               |`bool` type is considered the smallest unsigned integer type and is treated as `uint1` with respect to the table above.The bitwise binary  `|`, `&`, and `^` operations abide by the same type promotion rules as arithmetic binary operations, but their inputs are restricted to integral types (bool included).Only multiplication `*` and bitwise operations `|`, `&`, `^` can accept two `bool` inputs.  Using the PipelineLet's create a Pipeline that adds two tensors of type `uint8`, run it and see the results.<jupyter_code>def build_and_run(pipe, op_name):
    pipe.build()                                                        
    pipe_out = pipe.run()
    l = pipe_out[0].as_array()
    r = pipe_out[1].as_array()
    out = pipe_out[2].as_array()
    print("{} {} {} = {}; \n\twith types {} {} {} -> {}\n".format(l, op_name, r, out, l.dtype, op_name, r.dtype, out.dtype))
    
pipe = ArithmeticPipeline((lambda x, y: x + y), np.uint8, np.uint8, batch_size = batch_size, num_threads = 2, device_id = 0)
build_and_run(pipe, "+")<jupyter_output>[[42  8]] + [[9 2]] = [[51 10]]; 
	with types uint8 + uint8 -> uint8<jupyter_text>Let's see how all of the operators behave with different type combinations by generalizing the example above.You can use the `np_types` or `np_int_types` in the loops to see all possible type combinations. To reduce the output we limit ourselves to only few of them. We also set some additional printing options for numpy to make the output more aligned.<jupyter_code>np.set_printoptions(precision=2)
arithmetic_operations = [((lambda x, y: x + y) , "+"), ((lambda x, y: x - y) , "-"),
                         ((lambda x, y: x * y) , "*"), ((lambda x, y: x / y) , "/"),
                         ((lambda x, y: x // y) , "//")]

bitwise_operations = [((lambda x, y: x | y) , "|"), ((lambda x, y: x & y) , "&"),
                      ((lambda x, y: x ^ y) , "^")]

np_types = [np.int8, np.int16, np.int32, np.int64, 
            np.uint8, np.uint16, np.uint32, np.uint64,
            np.float32, np.float64]

for (op, op_name) in arithmetic_operations:
    for left_type in [np.uint8]:
        for right_type in [np.uint8, np.int32, np.float32]:
            pipe = ArithmeticPipeline(op, left_type, right_type, batch_size=batch_size, num_threads=2, device_id = 0)
            build_and_run(pipe, op_name)
        
for (op, op_name) in bitwise_operations:
    for left_type in [np.uint8]:
        for right_type in [np.uint8, np.int32]:
            pipe = ArithmeticPipeline(op, left_type, right_type, batch_size=batch_size, num_threads=2, device_id = 0)
            build_and_run(pipe, op_name)<jupyter_output>[[42  8]] + [[9 2]] = [[51 10]]; 
	with types uint8 + uint8 -> uint8

[[42  8]] + [[9 2]] = [[51 10]]; 
	with types uint8 + int32 -> int32

[[42  8]] + [[9. 2.]] = [[51. 10.]]; 
	with types uint8 + float32 -> float32

[[42  8]] - [[9 2]] = [[33  6]]; 
	with types uint8 - uint8 -> uint8

[[42  8]] - [[9 2]] = [[33  6]]; 
	with types uint8 - int32 -> int32

[[42  8]] - [[9. 2.]] = [[33.  6.]]; 
	with types uint8 - float32 -> float32

[[42  8]] * [[9 2]] = [[122  16]]; 
	with types uint8 * uint8 -> uint8

[[42  8]] * [[9 2]] = [[378  16]]; 
	with types uint8 * int32 -> int32

[[42  8]] * [[9. 2.]] = [[378.  16.]]; 
	with types uint8 * float32 -> float32

[[42  8]] / [[9 2]] = [[4.67 4.  ]]; 
	with types uint8 / uint8 -> float32

[[42  8]] / [[9 2]] = [[4.67 4.  ]]; 
	with types uint8 / int32 -> float32

[[42  8]] / [[9. 2.]] = [[4.67 4.  ]]; 
	with types uint8 / float32 -> float32

[[42  8]] // [[9 2]] = [[4 4]]; 
	with types uint8 // uint8 -> uint8

[[42  8]] // [[9 2]] = [[4 4]]; 
	with[...]<jupyter_text>Using ConstantsInstead of operating only on Tensor data, DALI expressions can also work with constants. Those can be either values of Python `int` and `float` types used directly, or those values wrapped in `nvidia.dali.types.Constant`. Operation between tensor and constant results in the constant being broadcasted to all elements of the tensor. The same costant is used with all samples in the batch.*Note: Currently all values of integral constants are passed to DALI as int32 and all values of floating point constants are passed to DALI as float32.*The Python `int` values will be treated as `int32` and the `float` as `float32` in regard to type promotions.The DALI `Constant` can be used to indicate other types. It accepts `DALIDataType` enum values as second argument and has convenience member functions like `.uint8()` or `.float32()` that can be used for conversions.As our expressions will consist of a tensor and a constant, we will adjust our previous pipeline and the helper functions - they only need to generate one tensor.<jupyter_code>class ArithmeticConstantsPipeline(Pipeline):                   
    def __init__(self, operation, tensor_data_type,batch_size, num_threads, device_id):
        super(ArithmeticConstantsPipeline, self).__init__(batch_size, num_threads, device_id, seed=12)
        self.tensor_source = ops.ExternalSource()
        self.operation = operation
        self.tensor_data_type = tensor_data_type

    def define_graph(self):                                                                
        self.tensor = self.tensor_source()
        return self.tensor, self.operation(self.tensor)

    def iter_setup(self):
        (t, _) = get_data(self.tensor_data_type, self.tensor_data_type)
        self.feed_input(self.tensor, t)
        
def build_and_run_with_const(pipe, op_name, constant, is_const_left = False):
    pipe.build()                                                        
    pipe_out = pipe.run()
    t_in = pipe_out[0].as_array()
    t_out = pipe_out[1].as_array()
    if is_const_left:
        print("{} {} {} = \n{}; \n\twith types {} {} {} -> {}\n".format(constant, op_name, t_in, t_out, type(constant), op_name, t_in.dtype, t_out.dtype))
    else:
        print("{} {} {} = \n{}; \n\twith types {} {} {} -> {}\n".format(t_in, op_name, constant, t_out, t_in.dtype, op_name, type(constant), t_out.dtype))<jupyter_output><empty_output><jupyter_text>Now, the `ArithmeticConstantsPipeline` can be parametrized with a function taking the only tensor and returning the result of arithmetic operation between that tensor and a constant.We also adjusted our print message.Now we will check all the examples we mentioned at the beginning: `int`, `float` constants and `nvidia.dali.types.Constant`.<jupyter_code>constant = 10
pipe = ArithmeticConstantsPipeline((lambda x: x + constant), np.uint8, batch_size = batch_size, num_threads = 2, device_id = 0)
build_and_run_with_const(pipe, "+", constant)

constant = 10
pipe = ArithmeticConstantsPipeline((lambda x: x + constant), np.float32, batch_size = batch_size, num_threads = 2, device_id = 0)
build_and_run_with_const(pipe, "+", constant)


constant = 42.3
pipe = ArithmeticConstantsPipeline((lambda x: x + constant), np.uint8, batch_size = batch_size, num_threads = 2, device_id = 0)
build_and_run_with_const(pipe, "+", constant)

constant = 42.3
pipe = ArithmeticConstantsPipeline((lambda x: x + constant), np.float32, batch_size = batch_size, num_threads = 2, device_id = 0)
build_and_run_with_const(pipe, "+", constant)<jupyter_output>[[42  8]] + 10 = 
[[52 18]]; 
	with types uint8 + <class 'int'> -> int32

[[42.  8.]] + 10 = 
[[52. 18.]]; 
	with types float32 + <class 'int'> -> float32

[[42  8]] + 42.3 = 
[[84.3 50.3]]; 
	with types uint8 + <class 'float'> -> float32

[[42.  8.]] + 42.3 = 
[[84.3 50.3]]; 
	with types float32 + <class 'float'> -> float32<jupyter_text>As we can see the value of the constant is applied to all the elements of the tensor to which it is added.Now let's check how to use the DALI Constant wrapper.Passing an `int` or `float` to DALI Constant marks it as `int32` or `float32` respectively<jupyter_code>constant = Constant(10)
pipe = ArithmeticConstantsPipeline((lambda x: x * constant), np.uint8, batch_size = batch_size, num_threads = 2, device_id = 0)
build_and_run_with_const(pipe, "*", constant)


constant = Constant(10.0)
pipe = ArithmeticConstantsPipeline((lambda x: constant * x), np.uint8, batch_size = batch_size, num_threads = 2, device_id = 0)
build_and_run_with_const(pipe, "*", constant, True)<jupyter_output>[[42  8]] * 10:DALIDataType.INT32 = 
[[420  80]]; 
	with types uint8 * <class 'nvidia.dali.types.Constant'> -> int32

10.0:DALIDataType.FLOAT * [[42  8]] = 
[[420.  80.]]; 
	with types <class 'nvidia.dali.types.Constant'> * uint8 -> float32<jupyter_text>We can either explicitly specify the type as a second argument, or use convenience conversion member functions.<jupyter_code>constant = Constant(10, types.DALIDataType.UINT8)
pipe = ArithmeticConstantsPipeline((lambda x: x * constant), np.uint8, batch_size = batch_size, num_threads = 2, device_id = 0)
build_and_run_with_const(pipe, "*", constant)


constant = Constant(10.0, types.DALIDataType.UINT8)
pipe = ArithmeticConstantsPipeline((lambda x: constant * x), np.uint8, batch_size = batch_size, num_threads = 2, device_id = 0)
build_and_run_with_const(pipe, "*", constant, True)


constant = Constant(10).uint8()
pipe = ArithmeticConstantsPipeline((lambda x: constant * x), np.uint8, batch_size = batch_size, num_threads = 2, device_id = 0)
build_and_run_with_const(pipe, "*", constant, True)<jupyter_output>[[42  8]] * 10:DALIDataType.UINT8 = 
[[164  80]]; 
	with types uint8 * <class 'nvidia.dali.types.Constant'> -> uint8

10:DALIDataType.UINT8 * [[42  8]] = 
[[164  80]]; 
	with types <class 'nvidia.dali.types.Constant'> * uint8 -> uint8

10:DALIDataType.UINT8 * [[42  8]] = 
[[164  80]]; 
	with types <class 'nvidia.dali.types.Constant'> * uint8 -> uint8
{'fraction_non_alphanumeric': 0.12255362172311692, 'fraction_numerical': 0.03184805373004983, 'mean_word_length': 3.3629489603024574, 'pattern_counts': {'":': 0, '<': 42, '<?xml version=': 0, '>': 68, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 11, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '9', 'dir': 'jupyter-structured-clean-dedup', 'id': '505562', 'license': 'ECL-2.0', 'n_tokens_mistral': 4575, 'n_tokens_neox': 4218, 'n_words': 1472, 'path': 'docs/examples/general/expressions/expr_type_promotions.ipynb', 'repo_name': 'a-sansanwal/DALI', 'size': '13847'}