Tan inverse calculator
Turn a tangent ratio back into its angle: the tan inverse of 1 is 45°, or 0.785398163397 radians, and you always get both units, inside the principal range between −90° and 90°. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 1
- Angle
- 0.7853981634 radians
- Radians
- 0.7853981634
- Degrees
- 45
- Range
- (−π/2, π/2) radians (−90° to 90°)
Tan inverse is the classroom name for the inverse tangent: given a real slope or opposite-over-adjacent ratio, it recovers the unique principal angle whose tangent equals that number. Students write tan inverse of x or tan to the minus one of x; programmers call the same map atan or arctan. This calculator accepts any finite real, returns the principal angle in both radians and degrees, and lets you choose which unit fills the primary angle field.
What tan inverse means and why the result stays inside a right angle
Tan inverse, also written arctangent or atan, is the inverse of the tangent function on its principal branch. Tangent sends an angle to a signed slope: opposite over adjacent in a right triangle, or sine over cosine on the unit circle. That map is one-to-one only after you restrict the angle to an open interval of length pi, conventionally from minus one half pi to plus one half pi, which is minus ninety degrees to plus ninety degrees.
On that interval every real slope appears exactly once, so for each finite number x there is exactly one principal angle theta such that the tangent of theta equals x. That theta is the tan inverse of x. The ends of the interval are never reached by a finite input: as x grows without bound the angle approaches ninety degrees but never lands on it, and as x dives toward negative infinity the angle approaches minus ninety degrees.
That is why this calculator insists on a finite number and never returns plus or minus ninety degrees for a real input. Textbook snaps that students expect without a trail of nines are built in: tan inverse of zero is zero, tan inverse of one is forty-five degrees or pi over four radians, and tan inverse of minus one is minus forty-five degrees. Negative inputs produce negative angles because tangent is an odd function, so its inverse is odd as well.
Search phrases such as tan inverse calculator, tan to the minus one, arctan of a number, and atan in degrees all point at this single-argument map. Two-argument atan2, which recovers a full-plane heading from a pair of Cartesian components, is a different job with a different landing. Here the contract is the scalar tan inverse of one finite real, returned as a structured angle in radians or degrees.
The ratio you enter and the angle you get
An optional unit selects which measure fills the primary angle field: radians, the default and the native range of atan, or degrees for classroom answers. If unit is present it must be one of those two published tokens; any other string fails. On success the body echoes the cleaned value and the resolved unit, returns angle in that unit as the primary result, and always includes both radians and degrees so callers never have to convert again.
Example: value one in the default radian unit yields angle pi over four, degrees forty-five, and expression tan inverse of one. Example: value zero yields angle zero in either unit. Example: value one with unit degrees yields angle forty-five.
Example: a missing value, the token Infinity, or the text abc fails because the input is not a finite number.
Where a tan inverse calculator earns its keep
Classrooms and tutoring platforms use a tan inverse calculator so learners can check tan to the minus one of an arbitrary slope without mixing calculator modes they cannot see. Exam generators need a deterministic oracle that marks NaN and Infinity as invalid instead of silently returning a half-pi that a buggy grader might treat as a number. Failed validation does not consume balance.
Keep requests small, pin the rounded angle in tests, and you get a reproducible tan inverse for homework, LMS plugins, and edge workers without standing up symbolic math infrastructure of your own.
Related searches such as atan2 of two components, the forward tangent of an angle, or hyperbolic tangent are different problems and are served by other pages; this contract stays on the scalar inverse of one finite real so the landing matches what a student actually types when the question is simply tan inverse of this number in radians or degrees.
What you can do with it
Classroom and homework checks
Let students submit a finite slope and verify tan inverse in degrees or radians, including tan inverse of 0, 1, and −1 against textbook special values.
Exam and LMS auto-grading
Mark tan-inverse items with a deterministic oracle that rejects non-finite tokens and never invents ±90° as a successful finite answer.
Slope to elevation in scripts
Convert a rise-over-run ratio to an elevation angle in surveying, roof layout, robotics, or game code without importing a computer-algebra library.
FAQ
How do I compute the tan inverse of a number?
Optionally set unit to radians (the default) or degrees.
What range does tan inverse use?
The principal branch is the open interval (−π/2, π/2), which is (−90°, 90°). A finite input never lands on ±90°, because tangent never attains a finite value there.
What happens if the input is not a finite number?
Missing values, empty strings, NaN, and Infinity are rejected and are not billed.
Is this the same as atan2?
No. This calculator is the single-argument tan inverse of one real. Recovering a full-plane heading from two Cartesian components is a different capability.
How do I turn a slope into an angle?
Divide the rise by the run and enter that ratio, not an angle. A slope of 1, one unit up for every unit across, gives 45°, and a negative slope gives a negative angle of the same size.
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/tan-inverse \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":1}'const res = await fetch("https://api.kit.forhosting.com/math/tan-inverse", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/tan-inverse",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/tan-inverse", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/tan-inverse", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"value": 1
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.tan_inverse",
"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
Non-finite tokens such as NaN or Infinity are rejected with invalid_input instead of a silent half-pi stand-in.
Input contract, response shape, and error behaviour
POST a JSON body with the required field value, a finite real number that is the tangent ratio, not an angle. The field may arrive as a JSON number or as a numeric string in decimal or scientific notation; aliases x, n, number, and tan are accepted when value is omitted. Missing fields, empty strings, non-numeric text, NaN, and Infinity fail with invalid_input naming the field and are not billed. A range string restates the open interval from minus half pi to plus half pi, a formula string restates theta equals arctan of value, a compact expression such as tan inverse of one, and a one-line message complete the payload. Magnitudes above one quadrillion are refused so the isolate never evaluates a pathological payload. Pair the payload with your own labels; this endpoint does not emit plots, a two-argument heading, or a step-by-step lesson beyond the formula field.
Where a tan inverse calculator earns its keep
Surveying, robotics, roof-pitch, and game scripts store a rise-over-run ratio and still need the matching elevation or heading in degrees; calling a tiny parse API avoids pulling a computer-algebra system for one inverse and one unit conversion.
Technical questions
What does the tan inverse calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.