Horner method calculator
Evaluate 2x³ − 6x² + 2x − 1 at x equals 3 and get 5, with every intermediate step (2, 0, 2, 5) shown so you can compare it with a handwritten Horner table. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Coefficients
- 2, -6, 2, -1
- X
- 3
- Value
- 5
- Synthetic coefficients
- 2, 0, 2, 5
- Degree
- 3
The Horner method calculator evaluates a polynomial from its coefficients without expanding powers separately. Enter coefficients in descending-power order and choose the point x. The result includes the final polynomial value and every intermediate synthetic coefficient created by nested multiplication. Those intermediate values make the calculation easy to inspect, teach, reproduce, or verify in another system. The implementation uses deterministic finite-number arithmetic, performs no network requests, and applies the same algorithm for a constant polynomial, a classroom cubic, or a much longer dense coefficient list.
Represent the polynomial as a complete coefficient list
Start by writing the polynomial in descending powers of x. For a polynomial such as 2x cubed minus 6x squared plus 2x minus 1, submit the coefficient list [2, -6, 2, -1]. Position carries the meaning, so include a zero whenever a power is missing.
For example, x cubed plus 5 is [1, 0, 0, 5], not [1, 5]. The first item represents the highest power and the last item is always the constant term. A one-item list is valid and represents a constant polynomial of degree zero.
The list is deliberately bounded so work remains predictable, although the algorithm itself scales linearly and needs only one multiply-add step for each coefficient after the first. Once the ordering is correct, no equation parser or variable syntax is needed, which avoids ambiguity about exponents, multiplication signs, and unary minus.
Follow the nested multiplication and synthetic coefficients
Horner's scheme rewrites a polynomial so powers do not need to be calculated independently. Bring down the leading coefficient as the first accumulator. Multiply that accumulator by x, add the next coefficient, and store the result.
Repeat the same multiply-and-add operation until the constant coefficient has been consumed. Its final entry is the value of the polynomial, also returned separately as value for convenient consumption. The sequence has exactly the same length as the input coefficient list, making each response position easy to align with one step of a handwritten tableau.
What you can do with it
Check algebra homework
Compare a student's Horner tableau with the returned accumulator sequence and verify the final polynomial value.
Build step-by-step tutoring
Reveal synthetic coefficients one at a time so learners can locate the exact multiply-add step where an error occurred.
FAQ
What order should the coefficients use?
Use descending-power order, from the leading coefficient to the constant term, and include zeros for missing powers.
What are the synthetic coefficients?
They are the successive Horner accumulators. The first is the leading coefficient, and each following entry is the previous accumulator times x plus the next coefficient.
Why does the last synthetic coefficient equal the value?
After the final multiply-add consumes the constant term, the nested expression is complete, so that accumulator is p(x).
Can this evaluate a constant polynomial?
Yes. A one-item coefficient list has degree zero, and its only synthetic coefficient is also its value at every finite x.
What do I enter when a power of x is missing?
Enter a zero in its place, because each position stands for one power. For x³ + 5, type the coefficients 1, 0, 0, 5, not 1, 5; otherwise the calculator would read a different polynomial.
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/horner-method \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"coefficients":[2,-6,2,-1],"x":3}'const res = await fetch("https://api.kit.forhosting.com/algebra/horner-method", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"coefficients": [
2,
-6,
2,
-1
],
"x": 3
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/algebra/horner-method",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"coefficients": [
2,
-6,
2,
-1
],
"x": 3
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/algebra/horner-method", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"coefficients":[2,-6,2,-1],"x":3}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"coefficients":[2,-6,2,-1],"x":3}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/algebra/horner-method", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"coefficients": [
2,
-6,
2,
-1
],
"x": 3
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "algebra.horner_method",
"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
Represent the polynomial as a complete coefficient list
Every coefficient and the evaluation point must be a finite JSON number; blank strings, numeric-looking text, infinity, and nonnumeric values are rejected instead of being coerced. You may use the documented coeffs alias for coefficients and point or value for x, but canonical names make integrations easier to read.
Follow the nested multiplication and synthetic coefficients
For [2, -6, 2, -1] at x = 3, the accumulator sequence begins with 2, continues with 2 times 3 minus 6, and then uses each new result in the following step. The response calls this complete sequence synthetic_coefficients. This is closely related to synthetic division by x minus the chosen point: all entries except the last can be read as quotient coefficients, while the final entry is the remainder and therefore p(x). This capability focuses on evaluation and exposes the trace; it does not claim to perform general polynomial division, symbolically factor the polynomial, or search for roots.
Use the result safely in lessons and software
For a quick calculation, run the browser tool and compare the returned trace with a handwritten Horner table. Results use JavaScript double-precision arithmetic. That is appropriate for ordinary classroom, scientific, and engineering inputs, but very large magnitudes or ill-conditioned polynomials can amplify rounding error. For sensitive numerical work, scale inputs or use an arbitrary-precision system and treat this calculator as an independent check. For automation, send the same coefficient array and point through the API; each successful item costs $0.002. The response includes value, synthetic_coefficients, degree, x, and a method marker, so a caller can store both the answer and enough intermediate evidence to explain how it was obtained. If an operation overflows to a non-finite result, the request fails clearly instead of emitting JSON that cannot represent the number.
Integration use cases
Evaluate coefficients in software
Use a deterministic JSON response for polynomial evaluation without adding a symbolic algebra dependency.
Technical questions
How much does an API calculation cost?
Each successful API item costs $0.002. The calculator can also run free in the browser.