Involute function
Enter a pressure angle in radians and get its involute, tan(a) minus a: 20 degrees, which is 0.3490658503988659 radians, gives 0.014904383867. It is the starting value for profile shift and tooth thickness work on involute gears. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Angle
- 0.3490658504
- Involute
- 0.0149043839
The involute function appears wherever involute gear geometry appears: given a pressure angle in radians, it returns tan(angle) minus the angle itself, the value that links a gear's base circle to its operating pitch circle. Gear designers, machinists and students use it to convert between pressure angles, verify tooth thickness at a new diameter, and solve for the angle at which an involute profile reaches a given radius. This capability does that single computation exactly and deterministically: you send one angle, you get the involute back, with a clear error when the angle is not a finite number.
What the involute function is and why it matters
Nearly every modern gear tooth is an involute of a circle: the curve traced by the end of a taut string unwinding from the gear's base circle. That choice is what lets gears mesh smoothly even when the center distance is slightly off. The involute function, written inv(a), is the angular coordinate of that curve at pressure angle a, and it equals tan(a) - a with the angle in radians.
It looks trivial, but it is the hinge of gear mathematics: the relationship between the pressure angle at one diameter and the pressure angle at another is exactly a difference of involutes. When a designer says a pinion runs at a 24 degree operating pressure angle on a 20 degree standard gear, the number that carries the profile shift behind that statement is an involute difference.
Because the function is monotonic and smooth on the useful interval from 0 to pi over 2, it is also safely invertible, which is how operating pressure angles are recovered from measured tooth thickness. Getting this value right, to full floating point precision, is the first step of any serious gear calculation.
How to call it and what you get back
Send a single field, angle, holding the pressure angle in radians. Degrees are not accepted on purpose: every textbook formula that uses the involute assumes radians, and silently accepting degrees is how spreadsheets produce gears that do not mesh. If your angle is in degrees, multiply by pi and divide by 180 before calling; the common 20 degree pressure angle is 0.3490658503988659 radians, whose involute is the familiar 0.0149043838673367.
There is no state, no randomness and no clock in the computation, so repeated calls with the same angle always return the same value.
Where it fits in a gear workflow
In practice the involute is rarely the final answer; it is the primitive everything else is built from. Profile shift calculations need the involute at the standard and operating pressure angles. Over-pin measurement conversions invert it to recover an angle from a measured span.
Backlash checks compare involute differences across toleranced tooth thicknesses. Teams wire it into design automation as a microservice step, into QA tooling that verifies a drawing against measured geometry, and into teaching material where students check hand calculations against a reference implementation.
What you can do with it
Profile shift verification
Compute the involute at the standard and operating pressure angles to check the profile shift of an existing gear pair against the drawing.
Tooth thickness at a new diameter
Use the involute difference between the pitch and target diameters to find the tooth thickness anywhere along the flank.
FAQ
Are degrees accepted?
No. The angle must be in radians, as every involute formula assumes. Convert degrees by multiplying by pi/180 first.
What exactly is returned?
An object echoing your angle and the involute value, inv(a) = tan(a) - a, rounded to twelve decimals for cross-machine stability.
Can it invert the involute, returning the angle from a value?
No. This capability computes the forward function only; inversion requires an iterative solver, which is a separate capability.
Is the result deterministic?
Yes. There is no network, randomness or clock involved, and the output is rounded so the same angle yields byte-identical output everywhere.
Where is the involute function used in gear design?
In almost every involute gear calculation. Profile shift needs the involute at the standard and at the operating pressure angle, and over-pin measurements invert it to recover the operating angle from a measured tooth thickness.
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/involute-function \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"angle":0.3490658503988659}'const res = await fetch("https://api.kit.forhosting.com/math/involute-function", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"angle": 0.3490658503988659
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/involute-function",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"angle": 0.3490658503988659
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/involute-function", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"angle":0.3490658503988659}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"angle":0.3490658503988659}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/involute-function", 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": 0.3490658503988659
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.involute_function",
"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
How to call it and what you get back
The response echoes the angle you sent and adds involute, the computed value, rounded to twelve decimals so the same input produces byte-identical output on any machine. Strings containing a plain number are coerced, and the aliases pressure_angle and alpha are accepted for convenience. Anything else — a missing field, null, true, an array, NaN, Infinity, or an angle sitting exactly on an odd multiple of pi over 2 where the tangent blows up — is rejected with an invalid_input error and is never billed.
Where it fits in a gear workflow
Because each of those steps trusts the involute value completely, this endpoint is built to be boring: one tangent, one subtraction, deterministic rounding, and a strict validation layer that refuses anything that is not a finite radian angle. The same code runs free in your browser on this page, so you can sanity-check a value by pasting one number and only pay, $0.002 per request, when you automate the call inside a larger pipeline.
Integration use cases
Reference value for gear software tests
Pin a known involute value, such as inv(20 deg), as a fixture in the test suite of a larger gear design application.
Technical questions
What does it cost?
$0.002 per request via the API. It is also free to run in your browser on this page.
What happens with invalid input?
A missing, non-numeric or non-finite angle (NaN, Infinity) is rejected with an invalid_input error and is not billed.