Resultant of two vectors calculator
Combine two forces or velocities into one: 3 at 0° plus 4 at 90° gives a resultant of 5 pointing at about 53.13°. You see each vector’s horizontal and vertical parts on the way. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Magnitude a
- 3
- Angle a
- 0
- Magnitude b
- 4
- Angle b
- 90
- Angle unit
- Degrees
- Component ax
- 3
- Component ay
- 0
- Component bx
- 0
When two forces, displacements, or velocities act at once, physics and engineering textbooks ask for a single equivalent vector: the resultant. Students and automation scripts usually receive each contribution as a magnitude and a direction angle, not as ready-made x and y. This resultant of two vectors calculator accepts both polar pairs, resolves each vector into horizontal and vertical components, adds those components, and returns the combined magnitude plus the direction of the sum using the same hypot and atan2 path used in polar conversion. You get the intermediate components as well as the final polar form, so homework checks, LMS grading, and edge workers can all agree on one deterministic contract without pulling a computer-algebra system for a four-number problem.
What the resultant of two polar vectors means
A free vector in the plane can be written either as rectangular components (x, y) or as polar form (magnitude m and direction angle θ). Classroom and exam problems almost always state the two contributing vectors in polar form because that is how measurements and force diagrams are drawn: a length along a marked angle from a reference axis. The resultant is the single vector that replaces both, equal to their tip-to-tail geometric sum.
Algebraically that sum is easiest in rectangular form: for each vector, the horizontal component is m times cos(θ) and the vertical component is m times sin(θ), with θ converted to radians when the trigonometric functions of the runtime require radians. Adding the two x components and the two y components yields the rectangular resultant (Rx, Ry).
The magnitude of the resultant is the Euclidean length hypot(Rx, Ry), and the direction is the two-argument arctangent atan2(Ry, Rx), which places the angle in the correct quadrant instead of the principal half-range of a naïve arctan of Ry over Rx. Magnitudes are required to be non-negative because a signed length would already encode direction and would contradict the polar convention used in most introductory courses.
Angles may be any finite real number in degrees or radians; they are not reduced to a principal interval on input, so a full-turn equivalent such as three hundred sixty degrees behaves like zero degrees after conversion.
Where adding two vectors comes up
Introductory physics and statics courses assign dozens of two-force resultant drills every term; a live calculator that returns both magnitude and quadrant-correct direction lets learners check work without flipping cosine signs by hand. Exam generators and LMS plugins need a deterministic oracle that rejects negative magnitudes instead of silently treating them as opposite directions under another convention. Navigation and robotics demos often add two planar velocity or displacement vectors stated as speed and heading; the same hypot and atan2 path produces a single ground-track result.
Content sites that rank for resultant of two vectors calculator benefit from a free browser path that matches the paid automation path on the identical pure module. Failed validation does not consume balance. Keep requests small, pin the rounded fields in tests, and you get reproducible resultants for homework, calibration scripts, and edge workers without standing up vector libraries of your own.
What you can do with it
Physics homework and lab checks
Students enter two force or displacement vectors as magnitude and angle and verify the textbook resultant magnitude and direction against the ordered component sum.
LMS and exam auto-grading
Mark polar-vector addition items with a deterministic oracle that rejects negative magnitudes and returns a stable twelve-decimal magnitude and atan2 angle.
Engineering notebooks and concurrent loads
Combine two concurrent planar loads given in polar form inside scripts without pulling a computer-algebra or graphics package for a four-number sum.
FAQ
Why must magnitudes be non-negative?
In polar form the length is non-negative and direction lives in the angle.
What if the two vectors cancel completely?
The resultant magnitude is zero and the reported direction is zero (radians and degrees). That keeps the response finite for equal-and-opposite pairs.
What is the resultant of a vector of 3 at 0° and one of 4 at 90°?
The parts are (3, 0) and (0, 4), so the sum is (3, 4). Its length is 5 and its direction is about 53.13° from the reference axis, the classic 3-4-5 right triangle.
How do I add two vectors given by size and angle?
Split each one into a horizontal part, size times the cosine of its angle, and a vertical part, size times the sine. Add the parts, then turn the sum back into a length and a direction.
Can I enter the angles in radians?
Yes. Degrees are the default, and you can switch both angles to radians at once. The direction of the result is always reported in both degrees and radians.
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/resultant-two-vectors \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"magnitude_a":3,"angle_a":0,"magnitude_b":4,"angle_b":90}'const res = await fetch("https://api.kit.forhosting.com/trig/resultant-two-vectors", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"magnitude_a": 3,
"angle_a": 0,
"magnitude_b": 4,
"angle_b": 90
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/trig/resultant-two-vectors",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"magnitude_a": 3,
"angle_a": 0,
"magnitude_b": 4,
"angle_b": 90
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/trig/resultant-two-vectors", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"magnitude_a":3,"angle_a":0,"magnitude_b":4,"angle_b":90}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"magnitude_a":3,"angle_a":0,"magnitude_b":4,"angle_b":90}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/trig/resultant-two-vectors", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"magnitude_a": 3,
"angle_a": 0,
"magnitude_b": 4,
"angle_b": 90
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "trig.resultant_two_vectors",
"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
What the resultant of two polar vectors means
When the two vectors cancel completely, Rx and Ry are both zero, the magnitude is zero, and this endpoint reports the direction as zero radians (and zero degrees) so clients always receive a finite polar pair.
Input contract, response fields, and validation
A negative magnitude fails with a clear message that vector length cannot be negative; those validation failures are not billed. Absolute values larger than one trillion are rejected as out of published bounds. A short formula string restates the component-sum identity for display next to the answer. POST a JSON body with four required finite numbers: magnitude_a and angle_a for the first vector, magnitude_b and angle_b for the second. Optionally set angle_unit to degrees (the default) or radians so that both input angles and the primary reported direction use the same unit. Missing fields, empty strings, and non-finite values fail with invalid_input naming the field. On success the body echoes the four inputs and the resolved angle_unit, then lists the four rectangular components component_ax, component_ay, component_bx, and component_by, the summed resultant_x and resultant_y, the resultant magnitude, the primary angle in the caller's unit, and both angle_degrees and angle_radians for convenience. Example: magnitude_a equals three at angle zero degrees and magnitude_b equals four at ninety degrees yields components (3, 0) and (0, 4), resultant (3, 4), magnitude five, and direction arctangent of four over three, about fifty-three point one three degrees. Pair the JSON with your own diagram if you need a head-to-tail sketch; this endpoint solves polar addition only and does not emit plots.
Where a two-vector resultant API earns its keep
Mechanical engineering notebooks combine two concurrent loads given as polar forces before feeding a free-body diagram; calling a tiny parse API avoids importing a full symbolic package for four numbers.
Technical questions
How do I find the resultant of two vectors given by magnitude and angle?
Send magnitude_a, angle_a, magnitude_b, and angle_b (and optionally angle_unit). The API resolves each vector to x and y, sums the components, and returns R = hypot(Rx,Ry) with θ = atan2(Ry,Rx).
Are angles in degrees or radians?
Degrees by default. Set angle_unit to radians if your inputs are in radians. The response includes angle in your unit plus both angle_degrees and angle_radians.
What does the resultant of two vectors calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.