Gradient magnitude calculator
Turn two partial derivatives into one steepness number: with ∂f/∂x of 3 and ∂f/∂y of 4, the gradient magnitude is 5 and its square is 25. Both partials at zero are flagged as a critical point. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Fx
- 3
- Fy
- 4
- Gradient
- 3, 4
- Magnitude
- 5
- Squared magnitude
- 25
The gradient of a scalar function of two variables is the vector of first partial derivatives, and its magnitude is the steepest rate of increase of that function at the evaluation point. Multivariable calculus courses, optimization notebooks, and engineering surface models constantly need ||∇f|| once fx and fy are already known from symbolic differentiation, finite differences, or sensor slopes. This gradient magnitude calculator accepts the two finite partial derivatives, forms the Euclidean length of the gradient vector, and returns cleaned components, the magnitude, the squared magnitude, and a flag that marks critical points where both partials vanish.
What the gradient magnitude measures and how it is computed
For a real-valued function f of two real variables x and y, the gradient at a point is the ordered pair of first partial derivatives evaluated there: ∇f equals the vector (∂f/∂x, ∂f/∂y), often written (fx, fy). Geometrically that vector points in the direction of steepest ascent on the surface z equals f(x, y), and its Euclidean length is exactly the steepest slope you would experience if you walked along that direction. Algebraically the length is the familiar two-dimensional L2 norm: the square root of fx squared plus fy squared.
When the partials are nonzero the magnitude is strictly positive and grows with steeper slopes. The implementation never differentiates a symbolic expression for you: you supply already-computed numerical partials, which is the contract that matches finite-difference pipelines, automatic-differentiation traces, and textbook exercises that already state fx and fy.
Where gradient magnitude calculators show up in real work
Secondary-school and college multivariable calculus courses assign steepest-ascent and critical-point drills that start from known partial derivatives; a single trusted oracle that returns the cleaned magnitude speeds grading and demo setup without pulling a full computer-algebra system. Physics and engineering surface models convert measured or simulated slopes into a single steepness number for slope maps, heat-transfer interfaces, and terrain analysis, often after finite differences already produced fx and fy on a grid.
If you later need the full unit gradient direction, directional derivatives along an arbitrary unit vector, or higher-order Hessian tests for max-min classification, treat those as separate search intents and landings rather than overloading this gradient magnitude calculator page.
What you can do with it
Multivariable calculus homework checks
Verify ||∇f|| from textbook partials fx and fy, including the zero-gradient critical-point case, with a deterministic ordered response.
Optimization and gradient-norm stopping rules
Convert automatic-differentiation or finite-difference partials into a stable L2 gradient norm for solver exit criteria.
Surface steepness from measured slopes
Combine two orthogonal slope readings into a single steepest-ascent magnitude for terrain, heat, or pressure surfaces.
FAQ
How is the gradient magnitude computed?
Send finite numbers fx = ∂f/∂x and fy = ∂f/∂y.
Do I need to provide the point (x, y)?
No. The calculator assumes you already evaluated the partial derivatives at the point of interest. Only the two numerical partials are required.
Are negative partial derivatives allowed?
Yes. Negative values are valid slopes; they enter the formula through squares, so sign does not change the non-negative magnitude.
What does it cost?
The browser tool is free and runs locally.
What is the gradient magnitude if ∂f/∂x is 3 and ∂f/∂y is 4?
It is 5. The calculator squares both partial derivatives, adds them to get 25 and takes the square root. That number is the steepest rate of increase of the function at your point.
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/calculus/gradient-magnitude \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"fx":3,"fy":4}'const res = await fetch("https://api.kit.forhosting.com/calculus/gradient-magnitude", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"fx": 3,
"fy": 4
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/calculus/gradient-magnitude",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"fx": 3,
"fy": 4
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/calculus/gradient-magnitude", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"fx":3,"fy":4}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"fx":3,"fy":4}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/calculus/gradient-magnitude", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"fx": 3,
"fy": 4
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "calculus.gradient_magnitude",
"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.
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
Validation failures such as missing fields or non-finite values raise invalid_input and are not billed, keeping classroom demos and prepaid automation safe at the published $0.002 base price per successful item.
What the gradient magnitude measures and how it is computed
When both partial derivatives are zero, the magnitude is zero and the point is a critical point of f—a local maximum, minimum, or saddle—so this calculator reports is_zero true and magnitude zero without inventing a direction. The pipeline is fully deterministic: no random seeds, no wall-clock timestamps, no network calls, and no model drift, so identical partials always produce identical JSON. Missing fields, empty strings, NaN, and Infinity fail with invalid_input naming the field and are not charged.
Input contract, response shape, and error behaviour
Negative partials are allowed and contribute through squares, so a descending slope on one axis still increases the magnitude correctly. POST a JSON body with two required finite numbers: fx, the partial derivative of f with respect to x at the point of interest, and fy, the partial with respect to y at the same point. Each field may arrive as a JSON number or as a numeric string; non-finite values, missing fields, and empty strings fail with invalid_input that names the field. On success the body echoes the cleaned fx and fy, the two-component gradient array, magnitude as the Euclidean length, squared_magnitude for callers that want to avoid a square root or compare slopes without nested radicals, is_zero as a boolean flag for critical-point detection, and a short formula string restating the identity. Classic textbook check: fx equals three and fy equals four yields magnitude five, the same 3-4-5 right triangle that appears in every vector-magnitude drill, with squared_magnitude twenty-five and is_zero false. The zero-gradient check: fx equals zero and fy equals zero yields magnitude zero, squared_magnitude zero, and is_zero true, which is the numerical signature of a stationary point. Pair the response with your own contour plot or level-set code if you need a sketch; this endpoint only combines the two given slopes into a scalar length and does not emit plots, symbolic steps, or second-derivative Hessian data. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance.
Where gradient magnitude calculators show up in real work
Curriculum authors building interactive lessons want the same JSON shape in the free tool and the API so offline worksheets and online auto-graders stay aligned on edge cases such as the zero gradient. Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance.
Technical questions
What if both partial derivatives are zero?
The magnitude is zero and is_zero is true. That marks a critical point of f; the request succeeds rather than failing, because a zero gradient is a valid mathematical result.