C# Matrix Division Program

Beginner
6 min read
Updated: Oct 2026
2 programs
Live preview
Definition

What Is Matrix Division?

Here matrix division means element-wise division: C[i, j] = A[i, j] / B[i, j]. Both matrices need the same shape, and no cell in B may be zero.

Remember
A ÷ B (entrywise) is defined when shapes match and B has no zeros

  [ 8  6 ]   [ 2  3 ]   [ 4.0  2.0 ]
  [ 9  4 ] ÷ [ 3  2 ] = [ 3.0  2.0 ]

Rule: (A ÷ B)[i, j] = A[i, j] / B[i, j]

Note: this is not A × B⁻¹ from linear algebra.
PositionABA / B
[0, 0]824.0
[0, 1]632.0
[1, 0]933.0
[1, 1]422.0
Approach

How to Divide Matrices in C#

Four clear steps — same nested loops as addition, plus a zero guard.

  1. Confirm both matrices have the same rows and columns.
  2. Reject any zero in B before dividing.
  3. Create a double[,] result of that size.
  4. Set result[i, j] = (double)A[i, j] / B[i, j] for every cell.
MethodIdeaTimeBest for
Nested loopsDivide matching cells into double[,]O(m × n)Interviews, teaching
Safe divideValidate shape + no zeros in BO(m × n)Safer production-style code

Pseudocode

Pseudocode
function DivideMatrices(A, B):
    rows = rows of A
    cols = cols of A

    if rows != rows of B or cols != cols of B:
        error "shapes must match"

    C = new double matrix[rows][cols]
    for i from 0 to rows - 1:
        for j from 0 to cols - 1:
            if B[i][j] == 0:
                error "division by zero"
            C[i][j] = A[i][j] / B[i][j]

    return C
Reference

Cheat Sheet

Keep these facts handy while writing the program.

TopicDetail
RuleC[i, j] = A[i, j] / B[i, j]
RequirementSame shape; B[i, j] ≠ 0
Result typePrefer double[,] for decimals
Cast(double)a / b avoids integer truncation
Not inverseThis is not A × B⁻¹
Classic check[[8,6],[9,4]] ÷ [[2,3],[3,2]] = [[4,2],[3,2]]
Try it

Live Preview

Pick a sample pair to see matrices A, B, and A ÷ B (entrywise).

Tap a chip to run. All samples use nonzero divisors.

Result
A =
8  6
9  4

B =
2  3
3  2

A ÷ B =
4.00  2.00
3.00  2.00
Trace

Worked Walkthrough — 2×2

Visit every index once and divide the matching cells.

Calculation
A = [8 6]    B = [2 3]
    [9 4]        [3 2]

i=0, j=0 → 8 / 2 = 4.0
i=0, j=1 → 6 / 3 = 2.0
i=1, j=0 → 9 / 3 = 3.0
i=1, j=1 → 4 / 2 = 2.0

Result = [4.0  2.0]
         [3.0  2.0]
Code

C# Programs

Start with a clear nested-loop divider using double[,]. Then add shape and zero checks for safer code.

Example 1 — Nested Loops

Divide two same-sized matrices cell by cell into a double[,] result.

C#
using System;

class Program
{
    static double[,] DivideMatrices(int[,] a, int[,] b)
    {
        int rows = a.GetLength(0);
        int cols = a.GetLength(1);
        double[,] result = new double[rows, cols];

        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                result[i, j] = (double)a[i, j] / b[i, j];
            }
        }
        return result;
    }

    static void Print(double[,] m)
    {
        for (int i = 0; i < m.GetLength(0); i++)
        {
            for (int j = 0; j < m.GetLength(1); j++)
            {
                Console.Write(m[i, j].ToString("F2") + " ");
            }
            Console.WriteLine();
        }
    }

    static void Main()
    {
        int[,] a = { { 8, 6 }, { 9, 4 } };
        int[,] b = { { 2, 3 }, { 3, 2 } };
        Print(DivideMatrices(a, b));
    }
}

How It Works

  1. Read rows and columns with GetLength(0) and GetLength(1).
  2. Allocate a double[,] so results can hold decimals.
  3. Outer loop chooses row i; inner loop chooses column j.
  4. Cast a[i, j] to double before / so integer division does not truncate.
  5. Print with ToString("F2") for two decimal places.

Example 2 — Shape & Zero Safe

Validate matching dimensions and reject any zero divisor before dividing.

C#
using System;

class Program
{
    static double[,] DivideMatrices(int[,] a, int[,] b)
    {
        int rows = a.GetLength(0);
        int cols = a.GetLength(1);

        if (b.GetLength(0) != rows || b.GetLength(1) != cols)
        {
            throw new ArgumentException("Matrices must have the same dimensions.");
        }

        double[,] result = new double[rows, cols];
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                if (b[i, j] == 0)
                {
                    throw new DivideByZeroException(
                        "B[" + i + ", " + j + "] is zero.");
                }
                result[i, j] = (double)a[i, j] / b[i, j];
            }
        }
        return result;
    }

    static void Main()
    {
        int[,] a = { { 10, 9, 8 }, { 6, 5, 4 } };
        int[,] b = { { 2, 3, 4 }, { 2, 1, 2 } };
        double[,] q = DivideMatrices(a, b);

        for (int i = 0; i < q.GetLength(0); i++)
        {
            for (int j = 0; j < q.GetLength(1); j++)
            {
                Console.Write(q[i, j].ToString("F2") + " ");
            }
            Console.WriteLine();
        }
    }
}

How It Works

  1. Compare both dimensions; throw if shapes differ.
  2. Before each division, check b[i, j] == 0.
  3. Throw DivideByZeroException with the failing index.
  4. Otherwise store (double)a[i, j] / b[i, j].
  5. Mention both checks in interviews — shape and zero are the two traps.

Edge Cases & Pitfalls

Check these before calling the solution done.

Zero in B

Never divide

Guard every B[i, j] before using /.

int / int

Cast to double

Without a cast, 5 / 2 becomes 2, not 2.5.

Shape

Must match

Different sizes cannot be divided entrywise.

Inverse

Different topic

True matrix division via B⁻¹ is not this algorithm.

Analysis

Time and Space Complexity

ProgramTimeExtra space
Nested loopsO(m × n)O(1) besides result
Shape & zero safeO(m × n)O(1) besides result

Every cell is touched exactly once. The result matrix needs O(m × n) space.

Remember

Key Takeaways

  • Rule: divide matching cells; shapes must match.
  • Guard: never divide by a zero in B.
  • Type: use double[,] and cast before /.
  • Test: [[8,6],[9,4]] ÷ [[2,3],[3,2]] → [[4,2],[3,2]].

One line: same shape, nonzero B — then C[i, j] = A[i, j] / B[i, j].

Frequently Asked Questions

Element-wise division: result[i, j] = A[i, j] / B[i, j]. Both matrices must have the same shape, and B must not contain zeros.
Usually not. In higher math, matrix division often means multiplying by an inverse. This page uses simpler cell-by-cell division.
Division often produces decimals (for example 5 / 2 = 2.5). A double[,] result keeps fractional values visible.
Division by zero is invalid. Check B first and throw (or skip) before dividing.
For an m × n matrix, each cell is visited once, so time is O(m × n).

Next: Matrix Multiplication

Multiply matrices with row-column dot products.

Matrix multiplication tutorial →

About the author

Mari Selvan M P
Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

  • Experience 12 years building web and cloud systems
  • Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

7 people found this page helpful

C# Matrix Addition Program C# Matrix Multiplication Program