Gudermannian function calculator
gd(1) is about 0.8657694832396585 radians, or 49.6049374208547°, the angle whose tangent equals sinh(1). The Gudermannian function turns any real number into an ordinary angle, with no complex numbers involved. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- X
- 1
- Gudermannian radians
- 0.8657694832
- Gudermannian degrees
- 49.6049374209
The Gudermannian function connects hyperbolic functions to ordinary circular trigonometry without introducing complex numbers. Give the calculator a finite real value x and it returns gd(x) as both radians and degrees. The resulting angle is characterized by tan(gd(x)) = sinh(x), while equivalent identities connect its sine and cosine to tanh(x) and sech(x). This makes the function useful for checking formulas, studying special functions, and converting between hyperbolic and angular descriptions in a clear, deterministic calculation.
Understand what the Gudermannian function represents
The Gudermannian, commonly written gd(x), maps every real number to an angle strictly between minus pi over two and plus pi over two. Its defining connection can be read as tan(gd(x)) = sinh(x), so the output is the principal real angle whose tangent equals the hyperbolic sine of the input. Several equivalent identities reveal why the function is a bridge: sin(gd(x)) = tanh(x), cos(gd(x)) = sech(x), and gd(x) = atan(sinh(x)).
None of these relationships requires a complex argument. That feature distinguishes the Gudermannian from many other links between circular and hyperbolic trigonometry, which are often introduced through imaginary inputs. The function is odd, meaning gd(-x) = -gd(x), and it passes through the origin because gd(0) = 0.
As x grows positively, the result approaches ninety degrees without reaching it; as x becomes increasingly negative, it approaches minus ninety degrees. The response supplies radians for mathematical and software work and degrees for immediate angular interpretation, together with the normalized input and the stable formula used for evaluation.
Enter a real value and interpret the returned angle
Send one finite real number in the x field. The calculator evaluates gd(x) with the identity 2 atan(tanh(x/2)). This form is mathematically equivalent to atan(sinh(x)), but it remains numerically useful for very large finite inputs where a direct hyperbolic sine can overflow the range of ordinary double-precision arithmetic.
For a positive input both values are positive; for a negative input their signs reverse. Values near zero are close to x because the derivative of gd at zero is one. Large magnitudes flatten toward the limiting angles, so increasingly large changes in x produce only tiny angular changes.
The formula field makes the chosen evaluation route explicit for audits, lessons, and reproducible tests.
Use the result in mathematics, education, and software
The calculator is useful wherever a hyperbolic quantity must be expressed as an ordinary real angle. Students can verify special-function exercises by comparing the returned angle with atan(sinh(x)) for moderate x, or by checking that its sine agrees with tanh(x). Teachers can generate deterministic examples that show odd symmetry, the horizontal limits, and the relationship among tangent, hyperbolic sine, and the principal angular range.
The implementation uses no network calls, random values, clock, stored state, language model, or external numerical service. The same finite input therefore produces the same fields through every supported channel. Results use JavaScript double-precision arithmetic, so callers should compare floating-point values with an appropriate tolerance rather than requiring symbolic equality.
This capability evaluates the real Gudermannian only; it does not return complex extensions, arbitrary-precision decimals, symbolic simplifications, derivatives, or inverse-Gudermannian values.
What you can do with it
Check a special-functions exercise
Evaluate gd(x) in radians and degrees, then verify its connection to sinh, tanh, or the principal tangent angle.
Connect hyperbolic values to angles
Convert a real hyperbolic parameter into its corresponding circular angle without introducing complex-number arithmetic.
FAQ
What is the Gudermannian function?
It is a real function connecting hyperbolic and circular trigonometry. In particular, tan(gd(x)) = sinh(x).
Why use 2 atan(tanh(x/2)) instead of atan(sinh(x))?
The formulas are equivalent for real x, but the tanh form avoids overflow when a large finite input would make sinh(x) infinite in double-precision arithmetic.
What inputs are accepted?
Missing, empty, nonnumeric, and non-finite values are rejected.
What is gd(1)?
About 0.8657694832396585 radians, or 49.6049374208547 degrees. It is the angle whose tangent equals the hyperbolic sine of 1, and its sine equals the hyperbolic tangent of 1.
What values can the Gudermannian function take?
Every result lies strictly between minus and plus a right angle. Large positive inputs approach ninety degrees without reaching it, large negative ones approach minus ninety, and gd(0) is 0.
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/gudermannian \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"x":1}'const res = await fetch("https://api.kit.forhosting.com/trig/gudermannian", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"x": 1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/trig/gudermannian",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"x": 1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/trig/gudermannian", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"x":1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"x":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/trig/gudermannian", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"x": 1
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "trig.gudermannian",
"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
Enter a real value and interpret the returned angle
Numeric strings are accepted after surrounding whitespace is removed, and the declared value and argument aliases work through the API as well. Empty text, nonnumeric text, NaN, infinity, arrays, and missing values are rejected with an invalid_input error instead of producing misleading JSON. Read gudermannian_radians as the principal angle in radians and gudermannian_degrees as the same angle converted by multiplying by 180/pi.
Use the result in mathematics, education, and software
Developers can call the API when a numerical pipeline, geometry tool, mapping experiment, or test suite needs structured JSON rather than a one-off calculator display. Each successful API request is billed at $0.002; the browser execution is suited to interactive checks.
Integration use cases
Build deterministic numerical tests
Use stable structured results as fixtures when testing a mathematical library or an implementation of the Gudermannian identity.
Technical questions
Does the calculator return radians or degrees?
It returns both gudermannian_radians and gudermannian_degrees in every successful response.
How much does an API calculation cost?
Each successful API request costs $0.002. You can also run the calculator interactively in the browser.