Row echelon form calculator
Enter rows 1, 2, 1; 2, 1, −1; −1, 1, 2 and get a staircase with two pivots and a final row of zeros, so the rank is 2. Entries above the pivots are left as they are. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Precision
- 6
- Rank
- 2
- Rows
- 3
- Columns
- 3
This row echelon form calculator applies forward Gaussian elimination to any supported rectangular matrix of finite real numbers. It returns the resulting upper staircase matrix, every pivot position, and the rank implied by those pivots. Unlike a reduced row echelon form calculator, it stops after clearing entries below each pivot: it does not clear above pivots or force every pivot to one.
What row echelon form shows
Row echelon form, often abbreviated REF, arranges the nonzero rows of a matrix into a staircase. The leading nonzero entry in each successive row appears farther to the right, every entry below a leading entry is zero, and any completely zero rows fall at the bottom. Those leading entries are pivots.
Their positions reveal the structurally important columns, and their count is the matrix rank. This calculator reports each pivot as an object with zero-based row and column indices, so a pivot at the upper-left corner appears as row zero, column zero. It also returns the row and column counts, precision, method name, and rank.
The resulting matrix is commonly called upper triangular when the input is square and has a pivot in every row, although REF also applies to rectangular and rank-deficient matrices. Elementary row operations preserve the solution set of an augmented linear system and preserve rank, making the output useful for analyzing dependencies without changing the underlying linear relationships. The result is not necessarily unique because different valid row swaps or pivot scaling choices can produce different echelon matrices.
How forward Gaussian elimination works
The algorithm begins at the first row and first column, then searches downward in the active column for the entry with the largest absolute value. If every candidate is effectively zero, that column has no pivot and the search moves right. Otherwise, the selected row swaps into the active position.
The chosen entry becomes the pivot, and a multiple of the pivot row is subtracted from every row beneath it to make the entries below that pivot zero. The active row then advances, and the same process continues in later columns until there are no rows or columns left. Selecting the largest available magnitude is partial pivoting; it reduces avoidable floating-point error compared with always accepting the first nonzero candidate.
Values within the fixed numerical tolerance are cleaned to exact zero, and response entries are rounded to the requested number of decimal places. Precision controls presentation rather than changing which forward operations run. The calculator deliberately stops at this point.
It does not perform backward elimination, clear entries above pivots, or divide every pivot row to create leading ones. Those additional steps belong to Gauss-Jordan elimination and reduced row echelon form. Stopping after the forward phase is exactly what many courses require before back substitution, determinant reasoning, or a separate discussion of RREF.
Preparing input and interpreting output
A square coefficient matrix, a wide augmented matrix, and a tall data matrix are all acceptable within the fifty-row and fifty-column limits. Optional precision is an integer from zero through twelve and defaults to ten. Use more displayed decimals when comparing a floating-point derivation, or fewer when preparing a compact classroom answer.
Rank equals the length of that list. A missing pivot in a column indicates a free column at that stage; fewer pivots than the smaller matrix dimension means the matrix is rank deficient. Do not compare its REF entry-for-entry with a source that normalizes each pivot: both matrices may be valid row echelon forms.
Instead, check the staircase conditions, zeros below pivots, pivot columns, and rank.
What you can do with it
Check Gaussian elimination homework
Compare a hand-derived forward-elimination matrix, its staircase pattern, pivot locations, and rank before starting back substitution.
Inspect linear independence
Count pivots after forward elimination to identify rank and reveal dependent rows or columns in a small numeric matrix.
FAQ
Is row echelon form the same as reduced row echelon form?
No. REF clears entries below pivots. RREF also clears above pivots and makes every pivot equal to one.
Are pivot positions zero-based?
Yes. The first matrix entry is at row 0, col 0, matching normal array indexing in JavaScript and many APIs.
Does the matrix need to be square?
No. Rectangular matrices are supported as long as all rows have the same positive number of columns and remain within the limits.
Why can my answer differ from another valid REF?
REF is not unique. Row swaps and pivot scaling can change its entries. This calculator uses partial pivoting and leaves pivot rows unnormalized for reproducibility.
What do the pivots tell me?
Each pivot marks a column that carries independent information, and their count is the rank. In the example with rows 1, 2, 1; 2, 1, −1; −1, 1, 2, there are two pivots and a zero row, so the rank is 2.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/algebra/matrix-row-echelon \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"matrix":[[1,2,1],[2,1,-1],[-1,1,2]]}'const res = await fetch("https://api.kit.forhosting.com/algebra/matrix-row-echelon", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"matrix": [
[
1,
2,
1
],
[
2,
1,
-1
],
[
-1,
1,
2
]
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/algebra/matrix-row-echelon",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"matrix": [
[
1,
2,
1
],
[
2,
1,
-1
],
[
-1,
1,
2
]
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/algebra/matrix-row-echelon", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"matrix":[[1,2,1],[2,1,-1],[-1,1,2]]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"matrix":[[1,2,1],[2,1,-1],[-1,1,2]]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/algebra/matrix-row-echelon", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"matrix": [
[
1,
2,
1
],
[
2,
1,
-1
],
[
-1,
1,
2
]
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "algebra.matrix_row_echelon",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_rows | 50 |
max_cols | 50 |
max_abs_entry | 1000000000000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
Partial pivoting improves numerical behavior, fixed rounding keeps JSON output stable, and strict validation rejects ragged matrices instead of guessing missing values.
What row echelon form shows
This implementation makes its choice reproducible through partial pivoting and does not scale pivot rows, so repeated calls with the same input always return the same JSON.
Preparing input and interpreting output
Send matrix as a nested JSON array, with one inner array per row. Every row must contain the same number of entries, and every entry must be a finite JSON number within the published magnitude limit. The response field row_echelon contains the transformed matrix, while pivots lists positions in the order they were chosen. For an augmented system, a row whose coefficient portion is all zero but whose augmented entry is nonzero signals inconsistency, though this endpoint leaves that interpretation to the caller because it does not know which column is augmented. Invalid input returns a clear invalid_input error, preventing silent padding, numeric coercion, or accidental acceptance of NaN and infinity.
Integration use cases
Build deterministic test fixtures
Generate stable REF matrices and explicit zero-based pivots for unit tests covering square, rectangular, and rank-deficient inputs.
Technical questions
What does one API request cost?
A successful API request costs $0.002. The same deterministic calculation is available free in the browser runner.