ForHosting KIT · Math

Hyperbolic tangent calculator

tanh(1) is 0.761594155956: enter a real number and get its hyperbolic tangent together with the sinh and cosh that produce it, even for huge values where the answer settles at 1 or −1. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

X: 1

You get

Sinh: 1.1752011936
Cosh: 1.5430806348
Tanh: 0.761594156

The hyperbolic tangent maps every real number into the open interval between minus one and one, approaching those bounds only as the argument grows without bound. It is defined as the ratio of hyperbolic sine to hyperbolic cosine, written tanh(x) equals sinh(x) over cosh(x), and it appears in neural-network activations, special relativity rapidity, heat transfer, and every calculus course that introduces hyperbolic identities. This hyperbolic tangent calculator accepts a finite real x, evaluates sinh and cosh, divides them, and returns the rounded tanh value together with the intermediate hyperbolic sine and cosine so you can check the identity by hand. Extreme magnitudes where floating-point sinh or cosh would overflow still return the correct asymptotic limit of plus or minus one.

What tanh(x) means and how sinh over cosh produces it

Hyperbolic sine and hyperbolic cosine are the odd and even parts of the exponential: sinh(x) equals (e to the x minus e to the minus x) over two, and cosh(x) equals (e to the x plus e to the minus x) over two. Their ratio is the hyperbolic tangent. Because cosh(x) is always at least one for real x, the division is defined everywhere on the real line and never hits a vertical asymptote the way ordinary tangent does at odd multiples of pi over two.

The graph of y equals tanh(x) is an odd function: tanh of negative x equals the negative of tanh of x, it passes through the origin with slope one, and it flattens toward horizontal asymptotes y equals one and y equals negative one. Those asymptotes are why tanh is popular as a squashing activation in machine learning and as a smooth soft clip in signal processing.

This capability implements the definition literally: it computes Math.sinh(x) and Math.cosh(x), divides them, and rounds the triple to twelve decimal places for stable goldens across runtimes. You always get x echoed, sinh, cosh, tanh, and the formula string tanh(x)=sinh(x)/cosh(x) for display next to the answer.

Where a hyperbolic tangent calculator earns its keep

Machine-learning notebooks and interview prep constantly need a trusted tanh reference when students reimplement activations by hand or when libraries disagree on edge values near overflow. Physics and engineering coursework uses hyperbolic tangent for rapidity in special relativity, for certain analytic solutions of the heat equation, and for smooth approximations to step functions in control models—having a one-call oracle beats pasting values from a printed table.

Exam generators and LMS plugins can mark student answers against rounded twelve-decimal goldens without standing up a full computer-algebra system for a single elementary function. Keep requests small, pin tanh and the intermediates in tests, and you get reproducible values for homework, edge workers, and batch pipelines without pulling a heavyweight math stack of your own.

What you can do with it

ML activation and interview checks

Verify tanh(x) = sinh(x)/cosh(x) against a trusted rounded oracle when reimplementing activations or debugging soft-clip layers.

Classroom hyperbolic identities

Let students submit any real x and confirm tanh, sinh, and cosh match textbook tables, including the oddness tanh(−x)=−tanh(x).

Physics and signal soft limits

Evaluate hyperbolic tangent for rapidity, heat-equation solutions, or smooth saturation curves in scripts without a CAS dependency.

FAQ

How is hyperbolic tangent defined?

tanh(x) is the ratio sinh(x)/cosh(x). This calculator evaluates that definition for any finite real x and returns tanh together with the intermediate sinh and cosh values.

What range of values can tanh return?

For every finite real x, tanh(x) lies strictly between −1 and 1, approaching ±1 only as |x| grows without bound.

Why return sinh and cosh as well as tanh?

So you can verify the definition tanh = sinh/cosh by hand or in tests, and so teaching UIs can show the intermediate hyperbolic functions next to the result.

What is tanh(1)?

tanh(1) is 0.761594155956. It comes from dividing sinh(1), which is 1.175201193644, by cosh(1), which is 1.543080634815, and the calculator shows all three values so you can verify the division.

What happens with very large inputs like 100?

For an input of 100 the result is exactly 1, the limit the curve approaches. Even where sinh and cosh would grow too large to compute directly, the calculator still returns the correct limit of 1 or −1.

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

POSThttps://api.kit.forhosting.com/trig/tanh

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/tanh \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"x":1}'

const res = await fetch("https://api.kit.forhosting.com/trig/tanh", {
  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/tanh",
    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/tanh", 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/tanh", 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.tanh",
  "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

Per request$0.002

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

Input contract, response fields, and error behaviour

On success the body includes the normalized x, the intermediate sinh and cosh used in the ratio, the resulting tanh in the closed interval from minus one to one, and a fixed formula string restating the definition. Example checks you can pin in tests: x equals zero yields tanh zero with sinh zero and cosh one; x equals one yields tanh approximately zero point seven six one five nine four one five five nine five six; x equals negative one yields the negated value by oddness; a very large positive x such as one hundred yields tanh one at the asymptotic limit. POST a JSON body with a required finite number under the field x. Aliases value and number are accepted for the same real argument so short form clients and scripts stay flexible. The value may arrive as a JSON number or as a numeric string; missing fields, empty strings, NaN, and Infinity fail with invalid_input naming what went wrong, and those failures are not billed. Pair the numbers with your own plotting code if you need a sketch of the sigmoid-shaped curve; this endpoint evaluates a single real and does not emit graphs or step-by-step LaTeX beyond the formula field. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance.

Technical questions

What input do I send?

Send a finite number in field x (aliases value or number). Missing, non-numeric, or non-finite inputs fail with invalid_input and are not charged.

What does the hyperbolic tangent calculator cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free