# How to Add and Subtract Vectors in Python

Adding and subtracting vectors are essential operations that allow us to manipulate vectors for various applications, from physics to computer graphics. These vector operations, central to traditional linear algebra, require strict adherence to certain rules regarding the vectors involved:

• Same Number of Elements (Dimension): Both vectors must have the same number of elements to ensure each component corresponds directly to a component in the other vector.
• Same Orientation: Vectors must either all be row vectors or all be column vectors to ensure the operations are well-defined.

A row vector in Python is defined as a single row of elements, while a column vector is defined as a single column. Here’s a quick guide on how to create each using numpy:

```import numpy as np

# Creating a row vector
row_vector = np.array([1, 2, 3])
print("Row Vector:", row_vector)

# Creating a column vector
column_vector = np.array([[1], [2], [3]])
print("Column Vector:\n", column_vector)
```

In Python, this is how they are represented:

```Row Vector: [1 2 3]

Column Vector:
[[1]
[2]
[3]]
```

Once you have defined row or column vectors, you can easily add or subtract them using numpy’s array operations, which handle these calculations element-wise:

```import numpy as np

# Creating row vectors
row_vector1 = np.array([3, 5, 7])
row_vector2 = np.array([2, 4, 6])

row_vector_sum = row_vector1 + row_vector2
print("Sum of row vectors:", row_vector_sum)

# Subtracting row vectors
row_vector_difference = row_vector1 - row_vector2
print("Difference of row vectors:", row_vector_difference)

# Creating column vectors
column_vector1 = np.array([[1], [3], [5]])
column_vector2 = np.array([[2], [4], [6]])

column_vector_sum = column_vector1 + column_vector2
print("Sum of column vectors:\n", column_vector_sum)

# Subtracting column vectors
column_vector_difference = column_vector1 - column_vector2
print("Difference of column vectors:\n", column_vector_difference)
```

This code will output:

```Sum of row vectors: [ 5  9 13]

Difference of row vectors: [1 1 1]

Sum of column vectors:
[[ 3]
[ 7]
[11]]

Difference of column vectors:
[[-1]
[-1]
[-1]]
```

Here is what happens when the dimensions do not match:

```import numpy as np

# Vectors with different dimensions
vector_a = np.array([1, 2, 3])
vector_b = np.array([4, 5])  # Shorter vector

try:
print("Attempting to add vectors with different dimensions:")
print(vector_a + vector_b)
except ValueError as e:
print("Error:", e)
```

This will output an error message indicating that the shapes are not aligned, as numpy cannot perform element-wise addition on arrays of different lengths.

```Attempting to add vectors with different dimensions:
Error: operands could not be broadcast together with shapes (3,) (2,)
```

When vectors with mismatched orientations, such as a row vector and a column vector, are operated on in Python using numpy, the operation does not automatically yield an error. Instead, numpy attempts to “broadcast” the vectors to make their shapes compatible if possible. Broadcasting allows numpy to perform element-wise operations by expanding the smaller array across the dimension of the larger one without duplicating data physically.

For instance, adding a row vector to a column vector leads to broadcasting, where each element of the row vector is added to each element of the column vector, creating a matrix-like result. While broadcasting is a powerful tool, it changes the nature of the operation from simple vector addition to producing a matrix, which may not be intended in strict vector arithmetic contexts. This behavior underscores the importance of understanding and verifying the orientation and dimensions of vectors before performing operations to ensure they align with your mathematical intentions.

Here is an example demonstrating this with a row vector and a column vector:

```import numpy as np

# Row vector and column vector
row_vector = np.array([1, 2, 3])
column_vector = np.array([[1], [2], [3]])

print("Result of adding a row vector with a column vector:")
print(row_vector + column_vector)
```

This operation results in:

```Result of adding a row vector with a column vector:
[[2 3 4]
[3 4 5]
[4 5 6]]
```

This output illustrates how each element of the row vector is added to each element of the column vector, creating a matrix. While this might be useful in some contexts, it’s crucial to understand that this is not typical vector addition but a different operation enabled by numpy’s broadcasting capabilities. Always ensure that vectors are properly aligned in both orientation and dimension to perform true vector arithmetic.