Impulse on bouncing ball calculator
A 0.5 kg ball that hits the floor at 4 m/s and rebounds at 3 m/s receives an impulse of 3.5 N·s, because its velocity changes by 7 m/s. Enter the mass and both speeds to get the floor impulse and the change in momentum. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Mass
- 0.5
- V in
- 4
- V out
- 3
- Impulse
- 3.5
- Delta momentum
- 3.5
- Delta velocity
- 7
When a ball hits a floor and rebounds, the floor delivers an upward impulse that reverses the normal component of momentum. Students, coaches, and simulation authors often know the mass and the approach and leave speeds from a bounce meter, high-speed video, or a worksheet—and need the impulse those speeds imply without first inventing a contact force and a contact time.
What floor impulse means for a ball that reverses direction
In classical mechanics the net impulse on a body equals its change in linear momentum. For a vertical bounce against a rigid floor, the important unknown is usually the impulse the floor exerts on the ball during the short contact window—not the average force itself, and not a free-flight trajectory. Choose upward as the positive direction.
Just before impact the velocity is the negative of the incoming speed, and just after impact it is the positive outgoing speed. The change in velocity is therefore the outgoing speed plus the incoming speed, and the floor impulse is mass times that sum: J equals m times open parenthesis v out plus v in close parenthesis.
Search intent clusters around phrases such as impulse on bouncing ball calculator, floor impulse from bounce speeds, change in momentum of a rebound, ball hits ground impulse, and J equals m delta v bounce. People want a numeric answer they can check against a lab, embed in a game collision constant, or feed into a pipeline—not only a reminder that impulse equals change in momentum.
Units stay consistent with whatever mass and speed basis you chose: kilograms with metres per second yield newton-seconds, which match kilogram metres per second for momentum change.
Practical use, limits, pricing, and delivery channels
Use the browser tool when you want an immediate floor-impulse check while grading bounce homework, verifying a force-plate impact against measured approach and leave speeds, sanity-checking a game rebound constant, or sketching how hard a sports ball pushes on a surface during a bounce. Choose units consistently—if mass is in kilograms and speeds are in metres per second, impulse and change in momentum come out in newton-seconds.
There is no language model, no external physics service, and no randomness, so the capacity is safe to pin in continuous-integration checks and reproducible lesson materials. For average force times contact time instead of bounce speeds, use the separate impulse calculator that multiplies force by duration.
What you can do with it
Homework and lab bounce impulse drills
Students and graders confirm floor impulse and change in momentum from mass and measured approach and leave speeds, with clear rejection when mass is zero or a speed is negative.
Game, sports, and impact sanity checks
Quick structured numbers for rebound impulse under known mass and bounce speeds without standing up a full contact-dynamics stack.
FAQ
What happens if mass is zero?
Zero mass cannot define a classical momentum change or floor impulse; those calls are not charged.
Is the bouncing ball impulse calculator free?
The browser tool runs free on your device.
Why are the two speeds added instead of subtracted?
Because the ball reverses direction. Taking upward as positive, it arrives at minus the incoming speed and leaves at plus the outgoing speed, so the change in velocity is their sum: 4 m/s down and 3 m/s up make 7 m/s.
Should I enter the speeds with a minus sign?
No. Enter both as positive speeds; the calculator applies the change of direction itself. Negative speeds are rejected, so you never have to remember which way counts as positive.
Does it give the average force the floor exerts?
No. It returns the impulse and the change in momentum from the mass and the two speeds alone, without needing a contact force or a contact time. To work from an average force and its duration, use the separate impulse calculator.
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/mech/impulse-bouncing-ball \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"mass":0.5,"v_in":4,"v_out":3}'const res = await fetch("https://api.kit.forhosting.com/mech/impulse-bouncing-ball", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"mass": 0.5,
"v_in": 4,
"v_out": 3
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/mech/impulse-bouncing-ball",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"mass": 0.5,
"v_in": 4,
"v_out": 3
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/mech/impulse-bouncing-ball", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"mass":0.5,"v_in":4,"v_out":3}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"mass":0.5,"v_in":4,"v_out":3}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/mech/impulse-bouncing-ball", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"mass": 0.5,
"v_in": 4,
"v_out": 3
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "mech.impulse_bouncing_ball",
"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
This impulse on bouncing ball calculator accepts a positive mass and two non-negative speeds, applies the impulse–momentum theorem with upward positive so the ball approaches at negative velocity and leaves at positive velocity, and returns structured JSON with impulse, change in momentum, change in velocity, and a short formula string. Zero mass and negative speeds fail with invalid_input before any result is returned.
What floor impulse means for a ball that reverses direction
Delivering mass, speeds, impulse, delta_momentum, delta_velocity, formula, and method as JSON makes the result easy to paste into notes, diff in automated tests, or reuse across languages without reimplementing the sign convention.
How this calculator validates input and applies J = m · (v_out + v_in)
Numeric strings that parse to finite numbers are accepted so forms and CSV-style pipelines can pass values without an extra cast. Mass must be strictly positive; zero mass is rejected because classical momentum change is undefined without mass, and negative mass is rejected as non-physical in this model. Incoming and outgoing values are speeds: each must be non-negative, because the reverse-direction convention is applied inside the solver rather than asking callers to remember signed velocities. There is no force–time product, no coefficient of restitution inference beyond what your speeds already encode, and no multi-axis contact; this is ideal one-dimensional floor impulse from mass and two speeds. Send a JSON body with mass, v_in, and v_out. All three fields are required and must be finite: missing any field, empty strings, non-numeric text, NaN, and Infinity all fail immediately with invalid_input before any result is returned, and failed validation is not charged. After validation, delta_velocity is formed as v_out plus v_in, impulse is mass times that sum, and delta_momentum is set equal to the impulse by the impulse–momentum theorem. Results are rounded to a stable decimal precision so the same input always yields the same JSON across JavaScript engines. The same pure function powers the free in-browser tool and the API path.
Practical use, limits, pricing, and delivery channels
Each successful request is one billable item at $0.002; failed validation does not consume balance. Results are fully deterministic: the same mass, v_in, and v_out always yield the same impulse and the same delta_momentum. Wire the endpoint into mechanics drills, contest answer checkers, bounce worksheets, or preprocessing steps where you already prefer explicit domain errors—such as rejecting zero mass—over opaque black-box widgets that cannot explain why a bad input was refused.
Integration use cases
Deterministic fixtures for physics tests
Pipelines that seed unit tests or interactive bounce demos can call a pure J=m·(v_out+v_in) oracle instead of reimplementing the signed reverse-direction convention in every language.
Technical questions
How do I compute the floor impulse on a bouncing ball with this API?
Send a JSON body with mass, v_in, and v_out to mech.impulse_bouncing_ball. The response returns mass, speeds, impulse, delta_momentum, delta_velocity, formula, and method.
Which formula does the impulse on bouncing ball calculator use?
Upward positive with speeds as non-negative magnitudes: v_before = −v_in, v_after = +v_out, so J = m·(v_out + v_in) and Δp = J by the impulse–momentum theorem.
Are v_in and v_out signed velocities or speeds?
They are non-negative speeds. The solver applies the reverse-direction convention internally so callers do not need to remember which velocity component is negative.