How to Calculate Revenues Using Matrix Multiplication in Python

Introduction
What Is Revenue Calculation via Matrix Multiplication?
Real-World Scenario: Dynamic Pricing in Online Retail
Array Initialization for Business Matrices
Complete Implementation with Test Cases
Best Practices and Performance Tips
Conclusion

Introduction

Matrix multiplication isn’t just for physicists and engineers—it’s quietly powering revenue engines in today’s biggest e-commerce platforms. When you see a “Recommended for You” section with personalized prices or bundled offers, there’s a high chance that matrix math is calculating potential revenue in real time. In this article, we’ll show how to use matrix multiplication to compute total revenues across products and customer segments, using only Python lists—no external libraries. We’ll ground it in a compelling real-world use case from AI-driven retail, and provide clean, tested, and production-ready code.

What Is Revenue Calculation via Matrix Multiplication?

Imagine you have:

A quantity matrix showing how many units of each product customers in different segments are likely to buy.
A price vector (or matrix) listing the selling price per product.

By multiplying these, you get a revenue matrix that predicts income per segment—enabling smarter inventory, marketing, and pricing decisions.

For example, if Q is a 3×3 matrix (3 customer segments × 3 products) and P is a 3×1 price vector, then R = Q × P gives a 3×1 revenue prediction per segment.

This scales elegantly and runs fast—even on modest hardware.

Real-World Scenario: Dynamic Pricing in Online Retail

A fashion e-commerce startup uses AI models to predict how many units of each item (e.g., sneakers, jackets, hats) three key customer groups—students, professionals, and luxury shoppers—will buy at current prices.

Their data looks like this:

Quantities
- Students: [50 sneakers, 20 jackets, 10 hats]
- Professionals: [30, 40, 15]
- Luxury: [10, 60, 25]
Prices
- Sneakers: $80
- Jackets: $120
- Hats: $40

Instead of looping through rows manually, they use matrix multiplication to instantly compute:

Student revenue: 50×80 + 20×120 + 10×40 = $7,200
Professional revenue: $8,400
Luxury revenue: $9,000

This insight helps them allocate ad spend, adjust stock, and even offer segment-specific discounts—all in real time.

Array Initialization for Business Matrices

To represent this in Python, we use 2D lists. Crucially, we initialize them safely to avoid reference bugs:

Correct

quantities = [[0 for _ in range(3)] for _ in range(3)]
prices = [[0] for _ in range(3)]  # Column vector

Incorrect

quantities = [[0] * 3] * 3  # All rows are the same object!

We’ll multiply a 3×3 quantity matrix by a 3×1 price matrix to get a 3×1 revenue vector.

Complete Implementation with Test Cases

from typing import List
import unittest

def multiply_matrices(A: List[List[float]], B: List[List[float]]) -> List[List[float]]:
    """
    Multiplies two matrices A and B.
    A: m x n, B: n x p → Result: m x p
    """
    if not A or not B or not A[0] or not B[0]:
        raise ValueError("Matrices cannot be empty.")
    
    # Get dimensions
    rows_A, cols_A = len(A), len(A[0])
    rows_B, cols_B = len(B), len(B[0])
    
    # Check compatibility
    if cols_A != rows_B:
        raise ValueError("Number of columns in A must equal rows in B.")
    
    # Initialize result matrix (m x p)
    result = [[0.0 for _ in range(cols_B)] for _ in range(rows_A)]
    
    # Perform multiplication
    # result[i][j] = sum(A[i][k] * B[k][j]) for k from 0 to n-1
    for i in range(rows_A):
        for j in range(cols_B):
            for k in range(cols_A): # This is the shared dimension 'n'
                result[i][j] += A[i][k] * B[k][j]
    
    return result


def calculate_revenue(quantities: List[List[float]], prices: List[float]) -> List[float]:
    """
    Calculates revenue per customer segment.
    quantities: 3x3 matrix (segments x products)
    prices: list of 3 product prices
    Returns: list of 3 total revenues (one per segment)
    """
    # Convert prices to column vector (3x1)
    price_matrix = [[p] for p in prices]
    
    # Multiply: (3x3) x (3x1) = (3x1) revenue matrix
    revenue_matrix = multiply_matrices(quantities, price_matrix)
    
    # Flatten to list
    return [row[0] for row in revenue_matrix]


class TestRevenueCalculation(unittest.TestCase):
    def test_basic_revenue(self):
        quantities = [
            [50, 20, 10],   # Students
            [30, 40, 15],   # Professionals
            [10, 60, 25]    # Luxury
        ]
        prices = [80, 120, 40]
        
        # CORRECTED EXPECTED VALUE:
        # Students: (50*80) + (20*120) + (10*40) = 4000 + 2400 + 400 = 6800.0
        # Professionals: (30*80) + (40*120) + (15*40) = 2400 + 4800 + 600 = 7800.0
        # Luxury: (10*80) + (60*120) + (25*40) = 800 + 7200 + 1000 = 9000.0
        expected = [6800.0, 7800.0, 9000.0]
        
        result = calculate_revenue(quantities, prices)
        self.assertEqual(result, expected)

    def test_zero_quantities(self):
        quantities = [[0, 0, 0]] * 3
        prices = [10, 20, 30]
        result = calculate_revenue(quantities, prices)
        self.assertEqual(result, [0.0, 0.0, 0.0])

    def test_invalid_dimensions(self):
        with self.assertRaises(ValueError):
            # Mismatched size: 1x2 matrix x 3x1 vector
            calculate_revenue([[1, 2]], [10, 20, 30])


if __name__ == "__main__":
    # Real e-commerce example
    customer_segments = ["Students", "Professionals", "Luxury Shoppers"]
    quantities = [
        [50, 20, 10],
        [30, 40, 15],
        [10, 60, 25]
    ]
    product_prices = [80, 120, 40]  # Sneakers, Jackets, Hats
    
    revenues = calculate_revenue(quantities, product_prices)
    
    print("Predicted Daily Revenue by Segment:")
    for segment, revenue in zip(customer_segments, revenues):
        print(f"{segment}: ${revenue:,.2f}")
    
    print("\nRunning unit tests...")
    # Using verbosity=0 to clean up the output after the fix
    unittest.main(argv=[''], exit=False, verbosity=2)

This lets the business instantly see which segment drives the most value—and adjust strategy accordingly.

Best Practices and Performance Tips

Validate matrix dimensions—mismatched sizes are a common source of silent errors.
Use floats for prices to handle cents accurately.
For large-scale systems (1000+ products), consider NumPy, but for small business matrices, native Python is fast and dependency-free.
Always initialize 2D arrays with nested comprehensions to prevent shared references.
Document what each row and column represents—business logic matters as much as math.

Conclusion

Calculating revenue with matrix multiplication transforms raw sales data into strategic insight. In e-commerce, this technique powers everything from dynamic pricing to AI-driven inventory planning.

By mastering this pattern, you’re not just doing math—you’re building the intelligence layer behind billion-dollar retail decisions. Write clean, validated, and well-tested code, and you’ll turn numbers into narratives that drive real business growth.

Table of Contents