Negative-angle identity calculator
Get the sign right when an angle flips: sin(30°) is 0.5, so sin(−30°) is −0.5, because sine is odd. You see the rule used, the value at both angles and the parity label. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Fn
- Sin
- Angle
- 30
- Negative angle
- -30 deg
- Parity
- odd
- Identity
- sin(-θ) = -sin(θ)
- Value at angle
- 0.5
Even and odd identities are the parity rules that connect a trigonometric value at a positive angle to the same function at the opposite direction: sine, tangent, cosecant, and cotangent flip sign under negation, while cosine and secant stay the same. Students meet these rules as soon as they graph the unit circle or simplify expressions such as sin(−30°) and cos(−π/3). Contests, homework keys, and animation code need a reliable numeric answer for f(−θ) without re-deriving the graph each time.
What even and odd trig identities mean for negative angles
A real function is even when f of negative x equals f of x for every x in the domain, and odd when f of negative x equals the negative of f of x. Among the six standard trigonometric functions, cosine and secant are even, so their graphs are mirror-symmetric about the vertical axis; sine, tangent, cosecant, and cotangent are odd, so their graphs have origin symmetry and reverse sign when the angle is reflected through zero.
Written as formulas, the identities students memorize are sin of negative theta equals negative sin of theta, cos of negative theta equals cos of theta, tan of negative theta equals negative tan of theta, and the same pattern for cosecant, secant, and cotangent. Search intent clusters around negative angle identity calculator, even odd identity trig, sin of negative angle, cos negative theta formula, and evaluate f of negative x online.
Learners want a number they can check against a textbook key plus a clear statement of which parity rule was applied, not only a symbolic rewrite. Reporting the identity string, the parity label, both f of theta and f of negative theta, and the negated measure itself makes the answer self-documenting for graders and for anyone debugging a sign error in a homework pipeline or a graphics rotation step.
How this calculator validates input, applies parity, and shapes the response
Unit defaults to deg; set unit to rad when the measure is already in radians. Internally the angle is converted to radians only for Math.sin and Math.cos, the selected function is evaluated at theta, and the engine then applies parity: for even functions the value at the negative angle equals the value at the positive angle, and for odd functions it equals the negation of that value.
Domain checks reject tan and sec when cosine of theta is zero, and csc and cot when sine of theta is zero, with an explicit message rather than NaN or infinity. A typical success path is fn equal to sin and angle equal to thirty degrees: value at angle is one half, value at negative is negative one half, parity is odd, and identity is sin of negative theta equals negative sin of theta. Cosine of thirty degrees returns the same positive square-root-of-three-over-two on both sides because cosine is even.
What you can do with it
Homework even/odd drills with domain checks
Students and graders confirm f(−θ) for sin, cos, tan, and reciprocals in degrees or radians, with clear rejection when the function is undefined at θ.
FAQ
Which trig functions are even and which are odd?
Cosine and secant are even: f(−θ) = f(θ). Sine, tangent, cosecant, and cotangent are odd: f(−θ) = −f(θ).
When is the value undefined?
Tan and sec fail when cos(θ) is zero (odd multiples of π/2). Csc and cot fail when sin(θ) is zero (integer multiples of π).
Is the negative-angle identity calculator free?
The browser tool runs free on your device.
Can I use radians instead of degrees?
Yes. Set unit to rad so the input angle is interpreted in radians. Omit unit or set deg for degrees.
What is sin(−30°)?
It is −0.5. Sine is an odd function, so sin(−θ) equals −sin(θ), and since sin(30°) is 0.5 the value at −30° simply changes sign.
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/trig/negative-angle-identity \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"fn":"sin","angle":30}'const res = await fetch("https://api.kit.forhosting.com/trig/negative-angle-identity", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"fn": "sin",
"angle": 30
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/trig/negative-angle-identity",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"fn": "sin",
"angle": 30
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/trig/negative-angle-identity", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"fn":"sin","angle":30}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"fn":"sin","angle":30}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/trig/negative-angle-identity", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"fn": "sin",
"angle": 30
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "trig.negative_angle_identity",
"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
This capacity accepts a function name, a finite angle in degrees or radians, evaluates f(θ), then applies the matching parity identity to return f(−θ) as structured JSON. Domain failures—tan or sec at odd multiples of ninety degrees, csc or cot at integer multiples of one hundred eighty degrees—fail with invalid_input and are not charged. The same pure algorithm powers the free browser tool and the prepaid API path.
How this calculator validates input, applies parity, and shapes the response
Send a JSON body with required fields fn and angle, plus optional unit. The field fn must be one of sin, cos, tan, csc, sec, or cot—common aliases such as sine, cosine, and cotangent are accepted and normalized. Angle must be a finite number; JSON numbers and numeric strings work, while words, empty strings, null, infinity, and NaN fail with invalid_input so those failed calls are not charged. Results are rounded to a stable ten-decimal precision so the same input always yields the same JSON, including for radian measures that cannot be represented exactly in binary floating point. The response echoes fn, angle, negative_angle, unit, parity, identity, value_at_angle, value_at_negative, and tags method as even_odd_identity so pipelines can assert provenance without re-deriving which formula family was used.
Practical use, limits, pricing, and delivery channels
Use the browser tool when you want an immediate parity check while simplifying homework, verifying a unit-circle sketch, or confirming a sign flip in a rotation without installing a computer-algebra system. Results are fully deterministic: the same fn, angle, and unit always yield the same pair of trig values and the same parity label. There is no language model, no external geometry service, and no randomness, so the capacity is safe to pin in continuous-integration checks and reproducible lesson materials. Each successful request is one billable item at $0.002; failed validation—including undefined tan, sec, csc, or cot at the given angle—does not consume balance. Accepted input is any finite real measure in degrees or radians for a supported function whose value is defined at that angle; the response returns both the value at the angle and the value at its negative via even or odd identity. Wire the endpoint into even-odd drills, contest answer checkers, animation helpers that need f of a reflected heading, or floating pipelines where you already prefer explicit domain errors for non-numeric or asymptotic payloads over opaque black-box widgets that cannot show which parity rule applied or why a reciprocal function failed to evaluate.
Integration use cases
Deterministic fixtures for trigonometry tests
Pipelines that seed unit tests or interactive unit-circle demos can call a pure parity oracle instead of reimplementing even/odd rules and asymptote checks in every language.
Sign-correct rotation and reflection helpers
Scripts that reflect a heading or phase through zero recover stable f(−θ) values as structured JSON for logs, shaders, or UI without a computer-algebra dependency.
Technical questions
How do I evaluate a trig function at a negative angle with this API?
Send fn (sin, cos, tan, csc, sec, or cot), required angle, and optional unit deg or rad to trig.negative_angle_identity. The response returns value_at_angle, value_at_negative via even/odd parity, and the identity string.