5 Best Ways to Calculate the Sum of the Left Diagonal of a Matrix in Python

by

💡 Problem Formulation: Calculating the sum of the left (or primary) diagonal of a square matrix is a common operation in various fields including computer science, mathematics, and engineering. The left diagonal refers to the diagonal that stretches from the top-left corner of the matrix to the bottom-right corner. Given a square matrix, the goal is to sum the elements of this diagonal. For instance, given a matrix [[1, 2], [3, 4]], the sum of the left diagonal would be 1 + 4 = 5.

Method 1: Traditional Loop

An intuitive approach to calculate the sum of the left diagonal of a matrix is to use a simple for-loop. This method iterates over the range of the square matrix’s size, summing the elements where the row and column indices are equal, as these indices correspond to the left diagonal of the matrix.

Here’s an example:

def sum_left_diagonal(matrix):
    sum_diagonal = 0
    for i in range(len(matrix)):
        sum_diagonal += matrix[i][i]
    return sum_diagonal

# Example usage:
matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]
print(sum_left_diagonal(matrix))

Output: 15

This code snippet defines a function sum_left_diagonal() that takes a square matrix as an argument. It initializes a variable to store the sum, then iterates through each row of the matrix, summing up the diagonal elements by accessing matrix[i][i]. The function then returns the computed sum.

Method 2: Using List Comprehension

Python’s list comprehension feature can be used to produce a more concise and potentially more readable solution to sum the left diagonal of a matrix. This method consists of a single line of code that iterates over the indices and sums the corresponding diagonal elements.

Here’s an example:

def sum_left_diagonal(matrix):
    return sum(matrix[i][i] for i in range(len(matrix)))

# Example usage:
matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]
print(sum_left_diagonal(matrix))

Output: 15

This compact code snippet employs list comprehension, where it generates a list of the diagonal elements using matrix[i][i] for each i in the range of the matrix size and then calculates the sum with the sum() function.

Method 3: Using NumPy Library

For those working in numerical computing, the NumPy library offers powerful array operations. The trace() function provided by NumPy can directly return the sum of the left diagonal elements of a two-dimensional array.

Here’s an example:

import numpy as np

def sum_left_diagonal(matrix):
    return np.trace(matrix)

# Example usage:
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])
print(sum_left_diagonal(matrix))

Output: 15

In this snippet, the matrix is a NumPy array upon which the np.trace() function computes the sum of elements along the left diagonal in an efficient and optimized manner.

Method 4: Using the map() Function

The map() function can be applied to perform an operation across the diagonal of the matrix. Coupled with the enumerate() function, it can sum the left diagonal by processing the enumerated tuples of row indices and rows in parallel.

Here’s an example:

def sum_left_diagonal(matrix):
    return sum(map(lambda x: x[1][x[0]], enumerate(matrix)))

# Example usage:
matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]
print(sum_left_diagonal(matrix))

Output: 15

The map() function is used with a lambda function that takes indexed tuples from enumerate(matrix), where x[0] is the index and x[1] is the actual row. The lambda function extracts the diagonal element of each row to sum them up.

Bonus One-Liner Method 5: Zip and Sum

A creative one-liner approach in Python would involve the use of the zip() function to pair up the elements of each row and then sum up the first element of each resulting tuple.

Here’s an example:

matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]
print(sum(a for a, *_ in zip(*matrix)))

Output: 15

This single line of code uses a generator expression to sum up the first element of each tuple, which corresponds to the left diagonal element, produced by the zip function applied to the unpacked rows of the matrix (*matrix).

Summary/Discussion

  • Method 1: Traditional Loop. Straightforward logic, easy for beginners to understand. Performance can be suboptimal for very large matrices.
  • Method 2: List Comprehension. Compact and pythonic. Still not the fastest for larger data sets.
  • Method 3: Using NumPy Library. Highly efficient for large matrices and optimal for mathematical computations. Requires NumPy to be installed.
  • Method 4: Using the map() Function. Functional programming approach, can be less readable for those unfamiliar with the concept. Moderate performance.
  • Method 5: Zip and Sum. Clever one-liner, but might be hard to read for those not proficient in Python. Not obvious at a glance what it does.