Half-angle formulas
Enter an angle in degrees and get the sine, cosine and tangent of half of it, with the right signs: 90° gives 45°, where sine and cosine are √2/2 and the tangent is 1, while 270° lands at 135° with a negative cosine. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Angle
- 90
- Half angle
- 45
- Sin half
- 0.7071067812
- Cos half
- 0.7071067812
- Tan half
- 1
Half-angle formulas appear whenever you already know an angle in degrees and need the sine, cosine, and tangent of half that angle—textbook identities, CAD reductions, phasor arithmetic, and firmware audits all hit the same three values. This calculator takes a single finite number θ in degrees, converts it to radians internally, and applies the classical identities sin(θ/2) = ±√((1 − cos θ)/2), cos(θ/2) = ±√((1 + cos θ)/2), and tan(θ/2) = sin θ / (1 + cos θ). Algebraic signs follow the quadrant of θ/2 so a 270° input yields the second-quadrant pair at 135°, not a pair of unsigned radicals.
What the half-angle identities compute
The half-angle identities are closed-form expressions for the trigonometric functions of θ/2 written in terms of the cosine and sine of the full angle θ. In every algebra and precalculus textbook they appear as sin(θ/2) equals plus or minus the square root of (1 minus cos θ) over two, cos(θ/2) equals plus or minus the square root of (1 plus cos θ) over two, and tan(θ/2) equals sin θ divided by (1 plus cos θ), or equivalently (1 minus cos θ) divided by sin θ.
Those square roots always produce a non-negative magnitude, so the algebraic sign is a separate decision: it must match the quadrant where the geometric half-angle actually sits. If θ is two hundred seventy degrees, then θ/2 is one hundred thirty-five degrees, which lies in the second quadrant; sine is positive, cosine is negative, and tangent is therefore negative. A tool that only returns the positive radical will match first-quadrant homework and fail as soon as the half-angle crosses an axis.
This calculator converts the incoming degree measure to radians, evaluates cosine and sine of the full angle, takes the identity magnitudes with a clamp so tiny negative rounding errors under the square root become zero, and then multiplies by the sign of sine and cosine of θ/2 itself. The tangent formula carries its own sign in almost every case; when the half-angle lands on an odd multiple of ninety degrees, cosine of the half-angle is zero and the tangent field is omitted rather than forged as a huge float.
What you can do with it
Homework and textbook half-angle checks
Students enter 60°, 90°, or 270° and confirm signed sin(θ/2), cos(θ/2), and tan(θ/2) against hand work that uses the radical identities.
Engineering reductions and firmware audits
Scripts verify that half-angle reductions in control law or CAD code match closed-form identities before shipping a numeric change.
FAQ
Which half-angle formulas does this calculator use?
sin(θ/2) = ±√((1 − cos θ)/2), cos(θ/2) = ±√((1 + cos θ)/2), and tan(θ/2) = sin θ/(1 + cos θ) (with the companion form when needed). Signs follow the quadrant of θ/2. The input is degrees only.
What happens if the angle is not a finite number?
Only finite numeric angles (or digit strings that parse to finite numbers) are accepted. Infinity, NaN, missing fields, and objects are rejected and not billed.
When is tan of the half-angle omitted?
When θ/2 is an odd multiple of 90° (for example θ = 180°), cosine of the half-angle is zero.
Why is the cosine negative for a 270° angle?
Half of 270° is 135°, which lies in the second quadrant, where sine is positive and cosine is negative. Each value takes the sign of the quadrant where the half-angle actually sits, not just the positive square root.
Can I enter the angle in radians?
No, the angle is always read in degrees. Type a textbook angle such as 60, 90 or 270 degrees; the switch to radians happens inside the calculation, so you never convert by hand.
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/math/half-angle \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"angle":90}'const res = await fetch("https://api.kit.forhosting.com/math/half-angle", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"angle": 90
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/half-angle",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"angle": 90
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/half-angle", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"angle":90}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"angle":90}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/half-angle", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"angle": 90
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.half_angle",
"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
Missing, infinite, or otherwise non-numeric angles fail with invalid_input and are never billed.
What the half-angle identities compute
Using identities rather than a lone library call on θ/2 lets students compare the JSON with the radicals they wrote by hand, while still receiving engineering-correct signed values for vectors, phasors, and geometric constructions that depend on which side of an axis the half-turn occupies.
How to call the calculator and read the three results
There is no unit switch on this landing: the contract is degrees only, which matches the search intent of students who type a textbook angle such as sixty, ninety, or two hundred seventy and expect half-angle sine, cosine, and tangent back. Send a JSON body with a single required field named angle, a finite number of degrees. Aliases theta and value are accepted so forms, spreadsheets, and query strings can reuse one contract. Digit strings that parse to finite numbers are allowed; missing fields, empty strings, NaN, Infinity, objects, arrays, and other non-numeric types fail with invalid_input naming the problem, and those failures are not billed. On success the JSON echoes the input angle, reports half_angle as θ/2 in degrees, and returns sin_half, cos_half, and—when defined—tan_half, plus a tan_defined boolean so clients do not treat an omitted tangent as zero. A typical call with angle ninety yields half_angle forty-five and the familiar pair √2/2, √2/2, tangent one. A call with angle two hundred seventy yields half_angle one hundred thirty-five, positive sine, negative cosine, and tangent minus one, which is the signed second-quadrant check that unsigned-radical homework keys often miss. Pair the response with your own unit-circle sketch if you need a drawing; this endpoint returns the three numeric half-angle values and does not emit plots or step-by-step prose. Pricing for a successful API call is a flat $0.002 under the item unit.
Signs, undefined tangent, precision, and where this API fits
Sign selection is driven by the true half-angle in radians: sine of θ/2 is non-negative in the upper half-plane and cosine of θ/2 is non-negative in the right half-plane, matching standard unit-circle conventions. Magnitudes still come from the half-angle radicals so floating-point paths stay consistent with textbook identities even when intermediate cos θ is slightly outside the closed interval from minus one to one because of rounding—values under the square root are clamped at zero. Near-zero noise below one times ten to the minus fourteen is flushed to zero before the twelve-decimal round, which keeps 0, 1, and minus 1 looking like the exact special angles they are. When cos θ is nearly minus one and sin θ is nearly zero, tan(θ/2) is reported as undefined: tan_defined is false and tan_half is omitted, because θ/2 is an odd multiple of ninety degrees and an infinite slope must not look like a finite answer. Related search intents such as double-angle formulas, a full sin/cos/tan of an angle without halving, or polar conversions are separate landings; this page is dedicated to half-angle sine, cosine, and tangent from a single finite angle in degrees.
Integration use cases
CI fixtures for trigonometry libraries
Pipelines freeze JSON golden outputs for positive and negative half-angles so a future refactor cannot flip signs silently.
Technical questions
How do I compute sin, cos, and tan of half an angle in degrees?
POST a finite number in the angle field (aliases theta and value are accepted), or use the free browser form. The response includes sin_half, cos_half, and tan_half with quadrant-correct signs.
Is the browser half-angle formula tool free?
Yes. The in-browser runner uses the same library as the API and costs nothing. The API charges $0.002 per successful request from your prepaid KIT balance; invalid input is not billed.