## NumPy Broadcasting

**What is NumPy Broadcasting?**

When performing arithmetic operations on arrays of different forms, NumPy refers to this as broadcasting. These array operations are frequently carried out on the respective elements. If two arrays have the same shape, it can be done on them with ease. Even though this concept is useful, broadcasting is not always recommended because it can result in inefficient memory usage that slows down the computation. NumPy operations are often performed on array pairs that are broken down element by element.

**Rules of Broadcasting**

A particular set of guidelines must be followed when broadcasting. These are described below:

- The lower rank array shape is important to be prepended with 1s until both shapes of the arrays share the same length if two arrays are not having the same rank.
- Two arrays are considered to be compatible if they have the same dimension size or if one of them has the dimension size set to 1.
- The arrays can only be broadcasted together if their sizes and dimensions match.
- Once broadcasting is complete, every array acts as though its form matches that of the largest element in the shapes of the two input arrays.
- One of the arrays behaves as though it were replicated with that dimension if the other array has a dimension greater than 1 and the first array has a dimension of 1.

Now, let’s discuss some examples of implementing the concept of broadcasting.

**Example 1: **

On pairs of arrays, NumPy operations are typically carried out element-by-element. The two arrays must, in the most straightforward scenario, have the same shape, as in the example below:

one_arr = numpy.array([2.0, 3.0, 1.0])

two_arr = numpy.array([3.0, 3.0, 3.0])

print(one_arr * two_arr)

As you can see from the code above, we have two arrays: ‘one_arr’ and ‘two_ arr’. Each of which has a separate set of values. The values in ‘one_arr’ are [2.0,3.0,1.0] and ‘two _arr’ are [3.0,3.0,3.0]. You can then see that the result of calculating the product of these two arrays is as follows:

When certain requirements are met by the arrays’ forms, NumPy’s broadcasting rule lowers this restriction. When an array and a scalar value are joined in an operation, broadcasting is demonstrated in its most basic form. As you can see, 3 is contained in the variable named ‘two_arr.’

one_arr = numpy.array([2.0, 3.0, 1.0])

two_arr = 3.0

print(one_arr * two_arr)

The above code produces the following result.

In the preceding example, where ‘two_arr’ was an array, the outcome is equivalent. We may picture the scalar ‘two_arr’ being expanded during the arithmetic process into an array having the same shape as ‘one _arr.’ The array ‘two_arr’ contains new elements that are merely duplicates of the first scalar. The stretching comparison is merely hypothetical. To make broadcasting operations as memory and computationally economical as feasible, NumPy is smart enough to use the original scalar value rather than producing copies.

**Example 2: **

Here is another simple Python program that performs broadcasting. Once again, two arrays are created containing different values. It is necessary to reshape ‘first_arr’ into a column vector with a 3×1 shape to calculate an outer product. Following this, the broadcast is performed against ‘second_arr’ to provide a result of size 3×2, known as the outer product of ‘first_arr’ and ‘second_arr.’ Broadcasting to 2×3 is possible since ‘result_arr’ has the shape 2×3 as well as the shape (3,).

After following all of the above-mentioned steps, a vector must be included in every column of the matrices which are ’result_arr’ and ‘second_arr.’ These have dimensions of 2×3 and (2, ). Transposing ‘result_arr’ will yield a shape of 3×2, which can then be broadcast against ‘second_arr’ to get the same form. Typically, transposing this yields a final product in the shape 2×3.

first_arr = numpy.array([12, 24, 14])

second_arr = numpy.array([15, 22])

print(numpy.reshape( first_arr, (3, 1) ) * second_arr )

result_arr = numpy.array([[12, 22, 31], [15, 22, 45]])

print(result_arr + first_arr)

print((result_arr.T + second_arr ).T)

print(result_arr + numpy.reshape(second_arr, (2, 1 ) ) )

print(result_arr * 2)

You can view the output below.

**Example 3: **

A three-dimensional array can be broadcast using the following Python program. In this example, two arrays named ‘first_arr’ and ‘second_arr’ have been generated. The array ‘first_arr’ contains [4,13,26,12] values and ‘second_arr’ contains [32,67,45,17] values. The initial array’s 2-dimensions make a difference. The first and second array’s sum will be shown below after the code has been executed. You can see that we have three print statements in the code, each of which displays the text ‘First array:’, ‘Second array’, and ‘Third array:’ in turn. The sum of these two newly generated arrays is then shown.

first_arr = numpy.array( [ [ 4 , 13, 26, 12] , [ 32, 67, 45, 17] ])

second_arr = numpy.array([24,45,66,87])

print("\n First array: ")

print(first_arr)

print("\n Second array: ")

print(second_arr)

print("\nSum of first and second array: ")

sum_result = first_arr + second_arr;

print(sum_result)

Here is the output screenshot of the given code.

**Example 4:**

The last Python program that broadcasts a three-dimensional array is given here. Two arrays are specified in this program, the first of which has three dimensions. The first and second array’s sum will be shown as shown above after the code has been executed. Although the values in these arrays vary, the remaining code is the same as that used in the example program above.

first_arr = numpy.array( [ [ 12 , 45, 22, 13] , [ 22, 54, 25, 12] , [50 ,40 ,18 ,26]])

second_arr = numpy.array([12,44,22,12])

print("\n First array: ")

print(first_arr)

print("\n Second array: ")

print(second_arr)

print("\nSum of first and second array: ")

sum_result = first_arr + second_arr;

print(sum_result)

You can see in the figure below that a 3-dimensional array from the first array is presented, followed by a 2-dimensional array from the second array and the result of these two employing the broadcasting principle.

**Conclusion **

This article discussed broadcasting, a crucial Python concept. In NumPy, the term ‘broadcasting’ refers to the capacity to handle arrays of various shapes while carrying out arithmetic operations that are frequently performed. The aforementioned subject has been thoroughly covered with a variety of examples. This article used the mentioned example programs to demonstrate how to broadcast on 1-D, 2-D, and 3-D arrays, respectively. You can try to run these examples on your system and view the results to better comprehend how everything functions in general.

Source: linuxhint.com