Matrix norm calculator
Sum up a matrix in one number: for the rows 1, −2, 3 and 4, 0, −1, the infinity norm is 6 and the one norm is 5. Choose Frobenius, one or infinity; any other name is refused so a typo cannot switch formulas. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Runs in your browser. Free, unlimited — your data never leaves this page.
A matrix norm condenses the size of an entire matrix into one nonnegative number, but different norms measure that size in different ways. This calculator accepts a rectangular matrix of finite real entries and computes whichever standard choice you request: the Frobenius norm, the induced one norm, or the induced infinity norm.
Choose the norm that matches your question
The word norm does not identify a single matrix formula, so begin by deciding what kind of size matters for your problem. The Frobenius norm treats every entry together: square each absolute entry, add those squares, and take the square root. It is often the most intuitive choice when a matrix is viewed as one long vector, and it is common when measuring total error between two arrays.
The induced one norm instead adds absolute values down each column and returns the largest column sum. It therefore emphasizes the column with the greatest total magnitude. The induced infinity norm adds absolute values across each row and returns the largest row sum, emphasizing the most substantial row.
These last two definitions are induced operator norms, not simply alternative spellings of the Frobenius formula. The capability intentionally rejects every other label, including ambiguous abbreviations, so a typing mistake cannot silently trigger the wrong mathematical definition. For example, a matrix whose rows are one, minus two, three and four, zero, minus one has absolute row sums six and five, making its infinity norm six.
Its absolute column sums are five, two, and four, making its one norm five. Its Frobenius norm is the square root of thirty-one. Comparing those results shows why naming the desired norm is part of the mathematical input rather than a display preference.
Prepare and validate the matrix entries
Each row must itself be a non-empty array, and every row must contain exactly the same number of entries. Square matrices are accepted, but they are not required: all three supported norms are defined for rectangular matrices. Strict validation matters because silent coercion can turn a malformed data export into a plausible but incorrect result.
The current bounded browser and parse path accepts up to sixty-four rows and sixty-four columns. Once validation succeeds, the one and infinity calculations use absolute sums along columns or rows. Frobenius calculation uses a scaled sum-of-squares procedure.
That procedure is algebraically equivalent to taking the square root of the sum of squared entries, while avoiding some unnecessary intermediate overflow when values vary greatly in magnitude. No matrix is modified, padded, transposed, or normalized as a side effect.
Use the result in calculations and automated checks
Matrix norms are useful wherever a larger structure needs a single comparable magnitude. In numerical linear algebra, a one or infinity norm can help establish conditioning bounds, stopping rules, and rough growth estimates. In machine learning and statistics, the Frobenius norm commonly measures the total discrepancy between coefficient matrices, embeddings, covariance estimates, or image-like arrays.
A norm of zero means every entry in the accepted matrix is zero; any nonzero finite matrix produces a positive result. Multiplying all entries by a scalar multiplies each supported norm by the absolute value of that scalar, which provides a convenient sanity check. Identical valid input therefore produces identical structured output.
Validation failures identify the unsupported norm, irregular row, non-finite entry, or exceeded size instead of returning a misleading number.
What you can do with it
Compare model parameter matrices
Use the Frobenius norm of a difference matrix as one scalar measure of total coefficient drift between model versions.
Check numerical-analysis exercises
Verify hand-calculated maximum column sums and maximum row sums for one-norm and infinity-norm assignments.
FAQ
Can the matrix be rectangular?
Yes. Every row must have the same nonzero length, but the number of rows does not need to equal the number of columns.
How is the Frobenius norm calculated?
It is the square root of the sum of the squares of all matrix entries. A scaled accumulation reduces avoidable intermediate overflow and underflow.
What is the difference between one and infinity norms?
The one norm is the largest absolute column sum. The infinity norm is the largest absolute row sum.
Which matrix norm should I choose?
Pick Frobenius when you treat the matrix as one long list of numbers, for example to measure the total error between two tables. Pick the one norm to stress the heaviest column and the infinity norm to stress the heaviest row.
How large a matrix can I enter?
Up to 64 rows and 64 columns of finite real numbers. Every row must hold the same number of entries, and the matrix is never padded, transposed or rescaled to make it fit.
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/math/matrix-norm \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"matrix":[[1,-2,3],[4,0,-1]],"norm_type":"frobenius"}'const res = await fetch("https://api.kit.forhosting.com/math/matrix-norm", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"matrix": [
[
1,
-2,
3
],
[
4,
0,
-1
]
],
"norm_type": "frobenius"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/matrix-norm",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"matrix": [
[
1,
-2,
3
],
[
4,
0,
-1
]
],
"norm_type": "frobenius"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/matrix-norm", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"matrix":[[1,-2,3],[4,0,-1]],"norm_type":"frobenius"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"matrix":[[1,-2,3],[4,0,-1]],"norm_type":"frobenius"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/matrix-norm", 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,
3
],
[
4,
0,
-1
]
],
"norm_type": "frobenius"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.matrix_norm",
"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 | 64 |
max_cols | 64 |
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
It validates the matrix shape and every entry before calculating, then returns the selected norm type and a deterministic numeric value suitable for homework checks, software tests, numerical-analysis pipelines, and repeatable API automation.
Choose the norm that matches your question
Select `frobenius`, `one`, or `infinity` in the norm_type field.
Prepare and validate the matrix entries
Send matrix as a non-empty JSON array of rows. Every entry must be a JSON number for which JavaScript reports a finite value. If even the final norm lies outside the finite numeric range, the request returns an input error rather than emitting invalid JSON. The successful response is deliberately compact: norm_type repeats the accepted canonical choice, and value contains the computed scalar rounded to stable significant precision.
Use the result in calculations and automated checks
The API is also useful for validating calculations performed in spreadsheets, teaching tools, or systems written in another programming language. Interpret the value together with norm_type, because values computed by different norm definitions should not be compared as if they came from the same formula. Browser use is free, while a successful API item uses the published base price of $0.002.
Integration use cases
Build matrix-library regression tests
Generate deterministic expected values for rectangular, signed, sparse, and zero-matrix fixtures.
Technical questions
Which matrix norms are supported?
The supported norm_type values are `frobenius`, `one`, and `infinity`. Other values return invalid_input.
What does an API request cost?
A successful API item costs $0.002. The browser calculator is free, and invalid input is not charged.