Polynomial standard form calculator
A polynomial is in standard form when like terms have been combined and the remaining terms appear from the highest exponent down to the constant.
Run — free
This calculator performs both steps on a univariate expression and returns one normalized result. It accepts implicit coefficients, integer or decimal values, exact fractions, optional multiplication signs, and nonnegative integer powers. The result also reports the polynomial degree and a structured term list, making it useful for checking homework, preparing later algebraic operations, or normalizing expressions in an automated workflow.
Enter a polynomial as ordinary signed terms
Provide one polynomial containing a single variable, such as 3x^2 + 4x - 7 + 2x^3 - x^2. Spaces are optional, and an asterisk between a coefficient and the variable is accepted, so 3*x^2 and 3x^2 mean the same thing. A missing coefficient means one: x^4 is treated as 1x^4, while -x is treated as -1x. Coefficients may be integers, decimals, or fractions such as 5/8. Exponents must be nonnegative whole numbers. The parser deliberately rejects parentheses, products of polynomial expressions, negative exponents, multiple variables, and scientific notation because those forms require expansion or represent a different algebraic object. Keeping the accepted grammar explicit makes the normalized answer predictable. If the expression uses a letter other than x, that letter is preserved in the output. Constants alone are also valid polynomials and receive degree zero unless their combined value is zero.
Understand how like terms are combined
Terms are like terms when they contain the same variable raised to the same power. The calculator reads every signed term, groups coefficients by exponent, and adds those coefficients exactly. For example, 3x^2 and -x^2 contribute coefficients three and negative one to the degree-two group, producing 2x^2. Fraction and terminating-decimal coefficients are represented internally as exact rational values, so a calculation such as 0.1x + 0.2x becomes 3/10x rather than inheriting a floating-point rounding artifact. Any group whose coefficient becomes zero is removed. This cancellation can lower the degree of the polynomial, and complete cancellation produces the zero polynomial. The response uses degree -1 for that special zero result, a common computational convention because the zero polynomial has no highest nonzero power. The structured terms array lists each surviving degree and its reduced coefficient, which is helpful when another program needs the coefficients without parsing the displayed expression again.
Read and use the standard-form result
After combining coefficients, the calculator sorts surviving terms from the greatest exponent to the smallest. It prints signs between terms, suppresses a coefficient of one on variable terms, omits an exponent of one, and reduces fractional coefficients. The primary normalized_expression field is ready to copy into a worksheet or use as a canonical display value. The degree field identifies the greatest exponent that remains after cancellation, while variable records the symbol used by the input. Standard form is especially useful before comparing two polynomials, identifying leading terms, applying long division, differentiating, or checking whether an expression has the expected degree. This capability normalizes rather than expands: it does not distribute multiplication over parentheses or evaluate the polynomial at a chosen value. Through the API, each expression costs $0.002; the same deterministic core can run in the browser. Identical valid input therefore produces identical normalized output without network access, random choices, or time-dependent behavior.
What you can do with it
Check an algebra exercise
Combine repeated powers and verify that the final polynomial is ordered from its leading term to its constant.
Normalize stored expressions
Convert equivalent textual polynomials into a consistent display form before saving, comparing, or indexing them.
Prepare a later calculation
Produce an ordered term list and degree before polynomial division, differentiation, or coefficient-based processing.
FAQ
What is polynomial standard form?
It is a polynomial with like terms combined and its nonzero terms ordered from the highest degree to the lowest degree.
Can I use a variable other than x?
Yes. Any single English letter is accepted and preserved, but one expression cannot mix different variables.
Are fractions and decimals supported?
Yes. Integer, terminating-decimal, and fractional coefficients are combined using exact rational arithmetic and fractions are reduced.
Does the calculator expand parentheses?
No. Enter a sum or difference of individual monomial terms. Products and parenthesized expressions must be expanded first.
Why is the degree of zero reported as -1?
After every term cancels, there is no highest nonzero exponent. The response uses -1 as a practical computational convention for that case.
What does an API request cost?
Each request costs $0.002. Browser execution on this page is free.
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/polynomial-standard-form \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"3x^2 + 4x - 7 + 2x^3 - x^2 + 5 - 4x"}'const res = await fetch("https://api.kit.forhosting.com/algebra/polynomial-standard-form", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "3x^2 + 4x - 7 + 2x^3 - x^2 + 5 - 4x"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/algebra/polynomial-standard-form",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "3x^2 + 4x - 7 + 2x^3 - x^2 + 5 - 4x"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/algebra/polynomial-standard-form", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"3x^2 + 4x - 7 + 2x^3 - x^2 + 5 - 4x"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"3x^2 + 4x - 7 + 2x^3 - x^2 + 5 - 4x"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/algebra/polynomial-standard-form", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "3x^2 + 4x - 7 + 2x^3 - x^2 + 5 - 4x"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "algebra.polynomial_standard_form",
"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_chars | 20000 |
max_degree | 10000 |
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. |