ForHosting KIT · Math

Bessel function calculator

J₀(1), the Bessel function of the first kind of order 0 at 1, is about 0.765197686558. Enter a whole-number order from 0 up and a real value, and get Jn(x) for wave, drum-membrane or radio sideband problems. 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

Order: 0
X: 1

You get

Value: 0.7651976866
Expression: J_0(1)

The Bessel function of the first kind appears in wave problems, circular membranes, frequency-modulation sidebands, and heat flow in a cylinder. Students, engineers, and exam writers need J_n(x) at a given integer order and a real argument without installing a full special-functions library. This capability evaluates that value with the classical power series, using a term-to-term recurrence so standalone factorials never overflow. You send a non-negative integer order and a finite real x; you receive the function value together with the series formula and a compact expression such as J_0(1).

What J_n(x) is and how the power series is summed

The Bessel function of the first kind of integer order n, written J_n(x), is a canonical solution of Bessel's differential equation x squared y double prime plus x y prime plus (x squared minus n squared) y equals zero.

For each fixed non-negative integer n it is an entire function of the real argument x: even in x when n is even, odd in x when n is odd, and it oscillates at large absolute x with an amplitude that slowly decays like the square root of two over pi times x.

The textbook power series used here is J_n(x) equals the infinite sum over k of minus one to the k, divided by k factorial times (k plus n) factorial, times (x over two) to the power two k plus n. The first term is (x over two) to the n over n factorial, and every later term is the previous one multiplied by minus (x over two) squared over (k plus one) times (k plus n plus one).

Building terms by that ratio never materialises a standalone factorial, so intermediate overflow is avoided inside the published order and absolute-x limits. At x equals zero the series collapses to one when n is zero and to zero when n is a positive integer, matching the well-known identities J_0(0) equals one and J_n(0) equals zero for n greater than zero.

Negative orders are out of scope for this integer first-kind evaluator: the task fails validation rather than applying the reflection identity J of minus n equals minus one to the n times J_n, so the public contract stays a single non-negative order. The same recurrence is what a student writes by hand for the first few terms of J_0(x) or J_1(x), which makes the numeric result easy to check against a textbook expansion.

Where Bessel functions come up

Waveguides, circular drum eigenmodes, frequency-modulation sidebands, and Kirchhoff diffraction integrals all evaluate J_n at a real argument. Classrooms use a Bessel function calculator so learners can check J_0(1), J_1(2), or J_2(5) without opening a computer-algebra session. Exam generators need a deterministic oracle that rejects a negative order instead of silently applying a reflection formula the syllabus has not introduced.

Signal-processing notebooks that expand a periodic phase modulation into Bessel sidebands can call this parse path instead of vendoring a special-functions package on every edge worker. Keep order and absolute x inside the published limits so the power series stays well-conditioned in double precision; for huge arguments prefer an asymptotic expansion from a dedicated library. Pin the rounded value field in tests so a later tweak of the loop bound cannot silently change the public contract.

Sibling landings cover other elementary functions; this page is specifically for people searching for a Bessel function calculator of the first kind.

What you can do with it

Classroom checks of J_0 and J_1

Let students submit integer order n and a finite x and verify J_n(x) against the textbook series, including the identities J_0(0)=1 and J_n(0)=0 for n>0.

FM sideband amplitudes

Read carrier and sideband strengths in a phase-modulated tone as J_n(β) without vendoring a special-functions package in every notebook or edge worker.

Circular membranes and cylindrical waves

Evaluate J_n at a real radial argument when sketching drum modes, waveguide cutoffs, or Kirchhoff diffraction profiles from a measured or assigned x.

FAQ

Is this J_n, Y_n, or a modified Bessel function?

Only J_n, the Bessel function of the first kind of integer order. Second-kind Y_n and modified I_n/K_n are out of scope.

What happens if the order is negative?

The calculator refuses it. It handles whole-number orders from 0 upward only, so a negative order is rejected with a message rather than converted through the reflection rule that some textbooks apply.

What is the value of the Bessel function at zero?

At x of zero the series collapses: J₀(0) is exactly 1, and the function is 0 for every positive order. These are the classic identities, and the calculator returns them directly.

Where are Bessel functions of the first kind used?

Wherever waves or heat meet a round shape: the vibration modes of a circular drum, waves in a waveguide, the sidebands of frequency modulation, diffraction patterns and heat flow in a cylinder.

Can it find the zeros of a Bessel function or draw its graph?

No. It returns the value of Jn at the single point you enter. It does not list the zeros, plot the curve or compute the second-kind companion, so you would evaluate several points yourself to sketch it.

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/math/bessel-function

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

const res = await fetch("https://api.kit.forhosting.com/math/bessel-function", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "order": 0,
    "x": 1
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/math/bessel-function",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "order": 0,
    "x": 1
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/bessel-function", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"order":0,"x":1}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"order":0,"x":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/bessel-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

{
  "order": 0,
  "x": 1
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "math.bessel_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

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`max_order`	40
`max_abs_x`	50

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

Negative orders and non-finite x fail with invalid_input and are not billed.

Input contract, response shape, and error behaviour

Failed validation is not billed. The canonical example order zero and x one yields J_0(1) near zero point seven six five. POST a JSON object with two required fields. order is a non-negative integer, also accepted under the alias n, between zero and the published max_order inclusive; fractions, infinities, empty strings, and negative integers fail with invalid_input naming the field. x is a finite real number whose absolute value is at most the published max_abs_x; NaN, plus Infinity, minus Infinity, and a missing x fail with invalid_input stating that x must be a finite number. Numeric strings that parse as ordinary decimal or scientific JSON numbers are accepted so form posts and spreadsheet exports work without a pre-cast. Rounding is a presentation contract, not a change of mathematics: internally the sum runs until a term no longer changes the floating-point accumulator or falls below a tiny relative bound, with a hard cap on the number of terms so a Worker isolate cannot loop forever. Pair the scalar with your own plot of the cylinder-function graph if you need a sketch; this endpoint returns the function value only and does not emit zeros, plots, or a second-kind Y_n companion. Keep both fields inside the published limits so IEEE-754 double precision remains well-conditioned for the power series.

Where a Bessel J_n(x) API earns its keep

Heat-flow and membrane labs that compare measured nodal circles against J_0 zeros still need the function value at nearby x to sketch the profile, and this endpoint covers that evaluation. Invalid_input never consumes prepaid balance, which keeps exploratory scripts cheap when someone types a negative order while learning the contract.

Technical questions

How do I evaluate the Bessel function of the first kind J_n(x)?

Send a non-negative integer order (alias n) and a finite real x. The API returns value = J_n(x) from the power series, plus formula and an expression such as J_0(1).