Calculate unknown sides or angles of a right-angled triangle.
Two Sides (to find the third)
One Side and One Acute Angle (to find others)
Side A
Side B
Hypotenuse C
Understanding the Pythagorean Theorem
The Pythagorean Theorem is a fundamental concept in Euclidean geometry that describes the relationship between the three sides of a right-angled triangle. A right-angled triangle is a triangle in which one of the angles is exactly 90 degrees.
The Theorem:
The theorem states that the square of the length of the hypotenuse (the side opposite the right angle, which is always the longest side) is equal to the sum of the squares of the lengths of the other two sides (called the legs or cathetus).
Mathematically, if we denote the lengths of the legs as a and b, and the length of the hypotenuse as c, the theorem is expressed as:
a² + b² = c²
Calculating Sides:
Given two sides of a right-angled triangle, you can find the third using variations of the Pythagorean Theorem:
To find the hypotenuse (c), given legs a and b: c = √(a² + b²)
To find a leg (a), given the other leg (b) and hypotenuse (c): a = √(c² - b²)
To find a leg (b), given the other leg (a) and hypotenuse (c): b = √(c² - a²)
Our calculator handles finding any one of the three sides if the other two are provided.
Beyond Basic Sides: Using Trigonometry
While the Pythagorean Theorem directly relates the side lengths, trigonometry allows us to relate the angles and side lengths of a right-angled triangle. For an acute angle θ in a right-angled triangle:
Sine (sin θ) = Opposite / Hypotenuse
Cosine (cos θ) = Adjacent / Hypotenuse
Tangent (tan θ) = Opposite / Adjacent
Using these, along with the inverse trigonometric functions (arcsin, arccos, arctan), we can find unknown angles if we know a side and an angle, or two sides. Our calculator can assist in finding unknown sides and angles when one side and one acute angle are known.
Use Cases:
Construction and Architecture: Ensuring corners are perfectly square (90 degrees).
Navigation: Calculating distances and positions.
Engineering: Designing structures and components.
Computer Graphics: Calculating distances between points in 2D or 3D space.
Physics: Analyzing vectors and forces.
Everyday Measurements: Determining the diagonal length of a screen or room.
Example Calculation (Sides):
Imagine a right-angled triangle where Side A is 3 units and Side B is 4 units. We want to find the hypotenuse (Side C).
Using the formula: c = √(a² + b²)
c = √(3² + 4²)
c = √(9 + 16)
c = √25
c = 5
So, the hypotenuse is 5 units long.
Example Calculation (Side and Angle):
Consider a right-angled triangle where we know Side A (adjacent) is 10 units and the angle opposite to Side B (let's call it Angle A) is 30 degrees.
We want to find Side B (opposite) and the Hypotenuse (C).
Using Tangent: tan(A) = Opposite / Adjacent = B / A
B = A * tan(A) = 10 * tan(30°)
B ≈ 10 * 0.577
B ≈ 5.77 units.
Now using Sine: sin(A) = Opposite / Hypotenuse = B / C
C = B / sin(A) = 5.77 / sin(30°)
C ≈ 5.77 / 0.5
C ≈ 11.54 units.
This calculator can perform these types of calculations efficiently.
function toggleInputs() {
var calculationType = document.getElementById("calculationType").value;
var sidesInputElements = document.querySelectorAll("#sidesInput");
var hypotenuseInput = document.getElementById("hypotenuseInput");
var sideAngleInput1 = document.getElementById("sideAngleInput1");
var sideAngleInput2 = document.getElementById("sideAngleInput2");
var sideAngleInput3 = document.getElementById("sideAngleInput3");
// Hide all specific input groups first
for (var i = 0; i < sidesInputElements.length; i++) {
sidesInputElements[i].style.display = "none";
}
hypotenuseInput.style.display = "none";
sideAngleInput1.style.display = "none";
sideAngleInput2.style.display = "none";
sideAngleInput3.style.display = "none";
document.getElementById("result").innerHTML = ""; // Clear result
if (calculationType === "sides") {
// Show inputs for calculating sides
sidesInputElements[0].style.display = "flex"; // Side A
sidesInputElements[1].style.display = "flex"; // Side B
hypotenuseInput.style.display = "flex"; // Hypotenuse C
} else if (calculationType === "sideAndAngle") {
// Show inputs for calculating with a side and angle
sideAngleInput1.style.display = "flex"; // Known Side Selector
sideAngleInput2.style.display = "flex"; // Known Side Value
sideAngleInput3.style.display = "flex"; // Known Angle
}
}
function calculatePythagorean() {
var calculationType = document.getElementById("calculationType").value;
var resultDiv = document.getElementById("result");
resultDiv.innerHTML = ""; // Clear previous result
if (calculationType === "sides") {
var sideA = parseFloat(document.getElementById("sideA").value);
var sideB = parseFloat(document.getElementById("sideB").value);
var sideC = parseFloat(document.getElementById("sideC").value);
var unknownSide = null;
var calculatedValue = null;
var unit = "units"; // Default unit
if (isNaN(sideA) && !isNaN(sideB) && !isNaN(sideC)) {
// Calculate side A
if (sideC <= sideB) {
resultDiv.innerHTML = "Error: Hypotenuse must be longer than a leg.";
return;
}
calculatedValue = Math.sqrt(Math.pow(sideC, 2) – Math.pow(sideB, 2));
unknownSide = "Side A";
} else if (isNaN(sideB) && !isNaN(sideA) && !isNaN(sideC)) {
// Calculate side B
if (sideC <= sideA) {
resultDiv.innerHTML = "Error: Hypotenuse must be longer than a leg.";
return;
}
calculatedValue = Math.sqrt(Math.pow(sideC, 2) – Math.pow(sideA, 2));
unknownSide = "Side B";
} else if (isNaN(sideC) && !isNaN(sideA) && !isNaN(sideB)) {
// Calculate side C (hypotenuse)
calculatedValue = Math.sqrt(Math.pow(sideA, 2) + Math.pow(sideB, 2));
unknownSide = "Hypotenuse C";
} else {
resultDiv.innerHTML = "Please provide exactly two side lengths.";
return;
}
if (calculatedValue !== null && !isNaN(calculatedValue)) {
resultDiv.innerHTML = `Calculated ${unknownSide}: ${calculatedValue.toFixed(4)} ${unit}`;
} else {
resultDiv.innerHTML = "Calculation resulted in an invalid number. Please check your inputs.";
}
} else if (calculationType === "sideAndAngle") {
var knownSideType = document.getElementById("knownSide").value;
var knownSideValue = parseFloat(document.getElementById("knownSideValue").value);
var knownAngleDeg = parseFloat(document.getElementById("knownAngle").value);
if (isNaN(knownSideValue) || isNaN(knownAngleDeg)) {
resultDiv.innerHTML = "Please enter valid values for the known side and angle.";
return;
}
if (knownAngleDeg = 90) {
resultDiv.innerHTML = "Acute angles must be between 0 and 90 degrees.";
return;
}
var knownAngleRad = knownAngleDeg * (Math.PI / 180); // Convert degrees to radians
var sideA = null, sideB = null, sideC = null;
var calculatedSide = null;
var calculatedAngle = null;
var unit = "units";
var angleUnit = "degrees";
if (knownSideType === "A") {
sideA = knownSideValue;
// Angle opposite Side A is Angle A (our knownAngle)
// Angle opposite Side B is Angle B
// Angle opposite Side C is Angle C (90 degrees)
// We know sideA and AngleA, let's find sideB and sideC
// tan(AngleA) = sideB / sideA => sideB = sideA * tan(AngleA)
sideB = sideA * Math.tan(knownAngleRad);
// sin(AngleA) = sideA / sideC => sideC = sideA / sin(AngleA)
sideC = sideA / Math.sin(knownAngleRad);
calculatedSide = `Side B: ${sideB.toFixed(4)} ${unit}, Hypotenuse C: ${sideC.toFixed(4)} ${unit}`;
// Calculate the other acute angle: AngleB = 90 – AngleA
calculatedAngle = `Other Acute Angle: ${(90 – knownAngleDeg).toFixed(2)} ${angleUnit}`;
} else if (knownSideType === "B") {
sideB = knownSideValue;
// Angle opposite Side B is Angle B
// Angle opposite Side A is Angle A
// We know sideB and AngleB, let's find sideA and sideC
// tan(AngleB) = sideA / sideB => sideA = sideB * tan(AngleB)
// We need AngleB. If knownAngle is AngleA, then AngleB = 90 – knownAngle
// If knownAngle is AngleB, then AngleA = 90 – knownAngle
// The prompt implies knownAngle is the angle associated with the *calculation*, let's assume it's the angle opposite the side we are *not* given.
// Let's rephrase: "Known Side" and "Known Angle" refers to *one* known side and *one* known acute angle.
// If we know Side A (adjacent) and Angle B (opposite Side B), find Side B and Hypotenuse C.
// tan(B) = sideB / sideA => sideB = sideA * tan(B)
// sin(B) = sideB / sideC => sideC = sideB / sin(B)
// If we know Side B (adjacent) and Angle A (opposite Side A), find Side A and Hypotenuse C.
// tan(A) = sideA / sideB => sideA = sideB * tan(A)
// sin(A) = sideA / sideC => sideC = sideA / sin(A)
// Let's simplify: The known angle is the angle opposite the *other* leg.
// If knownSide is 'A', knownAngle is opposite 'B'. So knownAngle = AngleB. AngleA = 90 – AngleB.
// If knownSide is 'B', knownAngle is opposite 'A'. So knownAngle = AngleA. AngleB = 90 – AngleA.
// If knownSide is 'C', knownAngle can be either AngleA or AngleB. Let's assume it's the angle we use directly.
// Let's stick to the input labels: Known Side Value, Known Angle (degrees)
// Assume Known Angle is either Angle A or Angle B.
// If knownSideType is A, we are given sideA and an angle.
// If knownAngle is the angle *opposite* sideB, then it's Angle B. sideB = sideA * tan(AngleB)
// If knownAngle is the angle *opposite* sideA, then it's Angle A. sideA = sideB * tan(AngleA)
// This is getting confusing with implicit relationships.
// Let's refine the logic:
// The calculator asks for a "Known Side" and a "Known Angle".
// Case 1: Known Side is A, Known Angle is Angle B. Find Side B, Hypotenuse C. Angle A = 90 – Angle B.
// tan(B) = sideB / sideA => sideB = sideA * tan(B)
// sin(B) = sideB / sideC => sideC = sideB / sin(B)
// Case 2: Known Side is B, Known Angle is Angle A. Find Side A, Hypotenuse C. Angle B = 90 – Angle A.
// tan(A) = sideA / sideB => sideA = sideB * tan(A)
// sin(A) = sideA / sideC => sideC = sideA / sin(A)
// Case 3: Known Side is C (Hypotenuse), Known Angle is Angle A. Find Side A, Side B. Angle B = 90 – Angle A.
// sin(A) = sideA / sideC => sideA = sideC * sin(A)
// cos(A) = sideB / sideC => sideB = sideC * cos(A)
// Case 4: Known Side is C (Hypotenuse), Known Angle is Angle B. Find Side A, Side B. Angle A = 90 – Angle B.
// sin(B) = sideB / sideC => sideB = sideC * sin(B)
// cos(B) = sideA / sideC => sideA = sideC * cos(B)
// The prompt selected "Known Side" and "Known Angle". Let's assume the known angle is adjacent to the known side if it's a leg, or opposite if it's the hypotenuse.
// This is still ambiguous. Let's use the most common setup:
// If you know Side A and Angle B (opposite Side B), you can find Side B and Hypotenuse C.
// If you know Side B and Angle A (opposite Side A), you can find Side A and Hypotenuse C.
// If you know Hypotenuse C and Angle A, you can find Side A and Side B.
// If you know Hypotenuse C and Angle B, you can find Side A and Side B.
// Let's simplify the 'sideAndAngle' calculation:
// We are given ONE side value and ONE acute angle value.
// Let's try to find the OTHER LEG and the HYPOTENUSE.
// If knownSideType is 'A':
// We have sideA and an angle. What angle? The prompt doesn't specify *which* acute angle.
// Let's assume the input 'knownAngle' is Angle A (opposite side A).
// Then we have sideA and AngleA. This is redundant. A triangle is defined by SSA, SAS, ASA, SSS.
// We need: Side, Side OR Side, Angle, Angle OR Side, Angle, Side.
// The input is Side, Angle. This is ambiguous.
// Let's assume the "Known Angle" is *always* the angle that is *not* directly adjacent to the "Known Side" if it's a leg.
// If knownSide is 'A', knownAngle is Angle B.
// If knownSide is 'B', knownAngle is Angle A.
// If knownSide is 'C', knownAngle is Angle A (or B, doesn't matter for finding A & B).
var angleA_rad, angleB_rad;
var otherAngleDeg;
if (knownSideType === "A") {
sideA = knownSideValue;
angleB_rad = knownAngleRad; // Assume knownAngle is opposite side B
angleB_deg = knownAngleDeg;
angleA_rad = (Math.PI / 2) – angleB_rad;
angleA_deg = 90 – angleB_deg;
// tan(B) = sideB / sideA => sideB = sideA * tan(B)
sideB = sideA * Math.tan(angleB_rad);
// sin(B) = sideB / sideC => sideC = sideB / sin(B)
sideC = sideB / Math.sin(angleB_rad);
calculatedSide = `Side B: ${sideB.toFixed(4)} ${unit}, Hypotenuse C: ${sideC.toFixed(4)} ${unit}`;
calculatedAngle = `Other Acute Angle (A): ${angleA_deg.toFixed(2)} ${angleUnit}`;
} else if (knownSideType === "B") {
sideB = knownSideValue;
angleA_rad = knownAngleRad; // Assume knownAngle is opposite side A
angleA_deg = knownAngleDeg;
angleB_rad = (Math.PI / 2) – angleA_rad;
angleB_deg = 90 – angleA_deg;
// tan(A) = sideA / sideB => sideA = sideB * tan(A)
sideA = sideB * Math.tan(angleA_rad);
// sin(A) = sideA / sideC => sideC = sideA / sin(A)
sideC = sideA / Math.sin(angleA_rad);
calculatedSide = `Side A: ${sideA.toFixed(4)} ${unit}, Hypotenuse C: ${sideC.toFixed(4)} ${unit}`;
calculatedAngle = `Other Acute Angle (B): ${angleB_deg.toFixed(2)} ${angleUnit}`;
} else if (knownSideType === "C") {
sideC = knownSideValue;
// Let's assume knownAngle is Angle A
angleA_rad = knownAngleRad;
angleA_deg = knownAngleDeg;
angleB_rad = (Math.PI / 2) – angleA_rad;
angleB_deg = 90 – angleA_deg;
// sin(A) = sideA / sideC => sideA = sideC * sin(A)
sideA = sideC * Math.sin(angleA_rad);
// cos(A) = sideB / sideC => sideB = sideC * cos(A)
sideB = sideC * Math.cos(angleA_rad);
calculatedSide = `Side A: ${sideA.toFixed(4)} ${unit}, Side B: ${sideB.toFixed(4)} ${unit}`;
calculatedAngle = `Other Acute Angle (B): ${angleB_deg.toFixed(2)} ${angleUnit}`;
}
if (calculatedSide && calculatedAngle) {
resultDiv.innerHTML = `${calculatedSide}${calculatedAngle}`;
} else {
resultDiv.innerHTML = "Could not calculate. Please check inputs.";
}
}
}
}
// Initialize the input visibility on page load
document.addEventListener("DOMContentLoaded", toggleInputs);