Fixed-point iteration single-step calculator
One fixed-point step, exactly as a homework table needs it: with g(x) = 0.5x + 1 and a current estimate of 0, the next estimate is 1 and the change is 1. You decide when to stop. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- X n
- 0
- Coefficients
- 0.5, 1
- X next
- 1
- Iteration function
- 0.5x+1
- Delta
- 1
- Abs delta
- 1
apply g once to x_n
What a single fixed-point step computes
A fixed point of a function g is a number L such that L equals g(L). Under mild conditions — for example when g is continuously differentiable near L and the absolute value of g prime of L is strictly less than one — the sequence converges to L from a suitable neighborhood of the root. In textbooks the method is often introduced before Newton’s method because the update rule is simply “evaluate g,” with no derivative required on each step.
This capability deliberately performs only one application of g. Here g is restricted to a univariate polynomial given by coefficients in highest-degree-first order, the same convention used by sibling calculus tools for Riemann sums and related polynomial work. Quadratic and higher polynomials are accepted up to a published degree cap, evaluated with Horner’s method so intermediate rounding stays well behaved for ordinary homework magnitudes.
When checking a single step helps
Classrooms and tutoring platforms use a single-step fixed-point calculator so learners can verify each line of an iteration table without recomputing an entire sequence or trusting a black-box “solve” button that hides intermediate values. Exam-prep generators and LMS auto-graders need a deterministic oracle that marks one step correct or incorrect against published coefficient encodings, including the case where the iterate is already a fixed point and the delta must be exactly zero.
Content sites that rank for fixed point iteration single step calculator benefit from a live tool whose free browser path matches the paid automation path on the same pure module. Failed validation does not consume balance.
FAQ
How do I encode the iteration function g?
Example: g(x) = 0.5x + 1 is [0.5, 1].
Does this run the iteration until convergence?
No. It applies g exactly once. Use repeated calls (or your own loop) if you need a full sequence or a root approximation.
What is the next estimate for g(x) = 0.5x + 1 starting from 0?
It is 1. Enter 0 as the current estimate and the coefficients 0.5 and 1, highest power first. The calculator evaluates g once, so the change from the previous estimate is 1 and its absolute size is also 1.
When does fixed-point iteration converge?
Usually when g is continuously differentiable near the fixed point and the absolute value of its derivative there is less than one, provided you start close enough. For g(x) = 0.5x + 1 the slope is 0.5, so the sequence approaches 2.
What does a change of exactly zero mean?
The current estimate is already a fixed point, so applying g returns the same number. For g(x) = 0.5x + 1 that happens at 2, because half of 2 plus 1 gives 2 again.
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/fixed-point-single-step \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"x_n":0,"coefficients":[0.5,1]}'const res = await fetch("https://api.kit.forhosting.com/calculus/fixed-point-single-step", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"x_n": 0,
"coefficients": [
0.5,
1
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/calculus/fixed-point-single-step",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"x_n": 0,
"coefficients": [
0.5,
1
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/calculus/fixed-point-single-step", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"x_n":0,"coefficients":[0.5,1]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"x_n":0,"coefficients":[0.5,1]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/calculus/fixed-point-single-step", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"x_n": 0,
"coefficients": [
0.5,
1
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "calculus.fixed_point_single_step",
"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
Fixed-point iteration is the elementary numerical scheme that seeks a number L equal to g(L) by repeatedly applying an iteration function: start from a guess x_0 and set each next value to g of the previous one. Students, tutors, and automation scripts often need exactly one step of that map — not a full convergence loop — so they can check a homework line, compare a hand calculation, or drive an external stopping rule that inspects |x_{n+1} − x_n|. This fixed-point iteration single-step calculator accepts the current estimate x_n and the coefficients of a univariate polynomial g (highest degree first), evaluates x_next equals g of x_n with a stable Horner scheme, and returns the next estimate together with the signed delta and absolute progress.
What a single fixed-point step computes
Fixed-point iteration turns that algebraic statement into a recurrence: choose an initial estimate x_0, then define x_{n+1} equals g of x_n for n equals 0, 1, 2, and so on. That design matches how homework and exam problems are phrased: “starting from x_n equals …, compute the next iterate.” It also matches pipeline use cases where an outer controller decides whether to stop, re-scale, or switch methods after inspecting the size of the step. A linear map such as g of x equals one half x plus one has the closed fixed point L equals two; starting from x_n equals zero yields x_next equals one in a single transparent step.
Input contract, response shape, and error behaviour
Overflow that produces non-finite Horner results is rejected rather than returned as Infinity. POST a JSON body with two required pieces of data. First, x_n: the current finite estimate (aliases current, x0, and estimate are accepted). Second, coefficients: a non-empty array of finite numbers [c_d, c_{d-1}, …, c_0] for g of x equals c_d x to the d plus lower powers (aliases coeffs, g, and poly). Missing fields, empty strings, non-finite numbers, and empty coefficient arrays fail with invalid_input naming the problem; those failures are not billed. On success the body echoes a cleaned x_n, the next value x_next, the coefficient list, a compact iteration_function string in standard form suitable for display next to the answer, the signed delta equal to x_next minus x_n, the absolute progress abs_delta, and a short formula reminder that x_{n+1} equals g of x_n for one fixed-point step. A second example with coefficients [0.25, 0, 1] and x_n equals 2 yields g of 2 equals 0.25 times 4 plus 1 equals 2, so the step is already at a fixed point and both delta and abs_delta are zero — a useful check that your encoding of g is correct before you iterate further.
Where a one-step fixed-point API earns its keep
Numerical notebooks and edge workers often rearrange nonlinear equations into x equals g of x form and then advance the map under their own convergence tests; calling a tiny parse API for each step avoids embedding ad-hoc polynomial evaluation in every script. Keep requests small, pin the rounded x_next and abs_delta in tests, and you get reproducible one-step iterates for homework, plugins, and workers without standing up a full nonlinear-solver stack of your own.
Integration use cases
Homework iteration tables
Check one line of a fixed-point table: given x_n and polynomial g, verify x_{n+1} and the absolute step size against textbook arithmetic.
LMS and exam auto-grading
Score single-step fixed-point items with a deterministic oracle that returns the same x_next and delta every time for the same coefficients.
External convergence loops
Drive your own stopping rule by calling the API once per iterate and inspecting abs_delta until it falls under a tolerance you choose.
Technical questions
What does one fixed-point iteration step compute?
It evaluates x_next = g(x_n) for your current estimate and polynomial iteration function g, and also returns the signed delta and |x_next − x_n|.
What if g(x_n) is already equal to x_n?
Then x_next equals x_n and both delta and abs_delta are zero — you are already at a fixed point of that polynomial encoding.
What does the fixed-point single-step calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.