Calculate missing sides (hypotenuse, base, height) or angles of a right-angled triangle.
Enter any two known values (sides or angles) and select what you want to calculate.
Inputs
Note: Angle C is always 90 degrees. Enter at least two known values.
Results
Base (a): —
Height (b): —
Hypotenuse (c): —
Angle A: —
Angle B: —
Area: —
Perimeter: —
Understanding Right Angled Triangles
A right-angled triangle (or right triangle) is a fundamental shape in geometry and trigonometry. It is defined by having one angle that measures exactly 90 degrees. The sides adjacent to the right angle are called legs (often denoted as 'a' and 'b'), and the side opposite the right angle is called the hypotenuse (denoted as 'c'), which is always the longest side.
This calculator helps you determine unknown properties of a right-angled triangle when you provide at least two of its measurements.
Key Concepts and Formulas
Pythagorean Theorem: This is the cornerstone for calculating sides. It states that the square of the hypotenuse (c) is equal to the sum of the squares of the other two sides (a and b).
a² + b² = c²
From this, we can derive:
c = √(a² + b²) a = √(c² - b²) b = √(c² - a²)
Trigonometric Ratios (SOH CAH TOA): These relate the angles of a right-angled triangle to the ratios of its sides.
These can also be used to find angles:
A = arcsin(a/c) or A = arctan(a/b) B = arccos(a/c) or B = arctan(b/a)
Sum of Angles: The sum of all angles in any triangle is 180 degrees. In a right-angled triangle, since one angle is 90 degrees, the other two acute angles (A and B) must sum to 90 degrees.
A + B = 90°
Area: The area of a right-angled triangle is half the product of its base and height.
Area = (1/2) * base * height = (1/2) * a * b
Perimeter: The perimeter is the sum of all three sides.
Perimeter = a + b + c
How to Use the Calculator
To use this calculator effectively, input at least two known values. These could be two sides, one side and one angle, or two angles (remembering one is always 90°). The calculator will then solve for the remaining unknown properties using the formulas mentioned above.
Use Cases
Right-angled triangles and their properties are fundamental in various fields:
Construction and Engineering: Ensuring right angles, calculating diagonal lengths, determining structural stability.
Navigation: Calculating distances and bearings using trigonometry.
Physics: Analyzing vectors, projectile motion, and forces.
Surveying: Measuring distances and heights indirectly.
Computer Graphics and Game Development: Calculating positions, distances, and angles in 2D and 3D space.
Everyday Problem Solving: Determining the length of a ladder needed to reach a certain height, or the diagonal size of a screen.
Understanding and calculating the properties of right-angled triangles is a foundational skill with wide-ranging practical applications.
function calculateTriangle() {
var sideA = parseFloat(document.getElementById("sideA").value);
var sideB = parseFloat(document.getElementById("sideB").value);
var hypotenuseC = parseFloat(document.getElementById("hypotenuseC").value);
var angleA = parseFloat(document.getElementById("angleA").value);
var angleB = parseFloat(document.getElementById("angleB").value);
var resultA = null;
var resultB = null;
var resultC = null;
var resultAngleA = null;
var resultAngleB = null;
var resultArea = null;
var resultPerimeter = null;
var knownValues = 0;
var inputs = [sideA, sideB, hypotenuseC, angleA, angleB];
inputs.forEach(function(val) {
if (!isNaN(val) && val > 0) {
knownValues++;
}
});
if (knownValues < 2) {
alert("Please enter at least two known values.");
return;
}
// — Calculations —
// Case 1: Two sides known
if (!isNaN(sideA) && !isNaN(sideB)) {
resultA = sideA;
resultB = sideB;
resultC = Math.sqrt(sideA * sideA + sideB * sideB);
resultAngleA = Math.atan(sideA / sideB) * (180 / Math.PI);
resultAngleB = Math.atan(sideB / sideA) * (180 / Math.PI);
} else if (!isNaN(sideA) && !isNaN(hypotenuseC)) {
resultA = sideA;
resultC = hypotenuseC;
if (hypotenuseC <= sideA) {
alert("Hypotenuse must be greater than the given side.");
return;
}
resultB = Math.sqrt(hypotenuseC * hypotenuseC – sideA * sideA);
resultAngleA = Math.asin(sideA / hypotenuseC) * (180 / Math.PI);
resultAngleB = Math.acos(sideA / hypotenuseC) * (180 / Math.PI);
} else if (!isNaN(sideB) && !isNaN(hypotenuseC)) {
resultB = sideB;
resultC = hypotenuseC;
if (hypotenuseC = 90) { alert("Angle B must be less than 90 degrees."); return; }
resultA = sideA;
resultAngleB = angleB;
resultAngleA = 90 – angleB;
resultB = sideA / Math.tan(angleB * Math.PI / 180);
resultC = sideA / Math.sin(angleB * Math.PI / 180);
} else if (!isNaN(sideA) && !isNaN(angleA)) {
if (angleA >= 90) { alert("Angle A must be less than 90 degrees."); return; }
resultA = sideA;
resultAngleA = angleA;
resultAngleB = 90 – angleA;
resultB = sideA / Math.tan(angleA * Math.PI / 180);
resultC = sideA / Math.sin(angleA * Math.PI / 180);
} else if (!isNaN(sideB) && !isNaN(angleA)) {
if (angleA >= 90) { alert("Angle A must be less than 90 degrees."); return; }
resultB = sideB;
resultAngleA = angleA;
resultAngleB = 90 – angleA;
resultA = sideB * Math.tan(angleA * Math.PI / 180);
resultC = sideB / Math.cos(angleA * Math.PI / 180);
} else if (!isNaN(sideB) && !isNaN(angleB)) {
if (angleB >= 90) { alert("Angle B must be less than 90 degrees."); return; }
resultB = sideB;
resultAngleB = angleB;
resultAngleA = 90 – angleB;
resultA = sideB * Math.tan(angleB * Math.PI / 180);
resultC = sideB / Math.cos(angleB * Math.PI / 180);
} else if (!isNaN(hypotenuseC) && !isNaN(angleA)) {
if (angleA >= 90) { alert("Angle A must be less than 90 degrees."); return; }
resultC = hypotenuseC;
resultAngleA = angleA;
resultAngleB = 90 – angleA;
resultA = hypotenuseC * Math.sin(angleA * Math.PI / 180);
resultB = hypotenuseC * Math.cos(angleA * Math.PI / 180);
} else if (!isNaN(hypotenuseC) && !isNaN(angleB)) {
if (angleB >= 90) { alert("Angle B must be less than 90 degrees."); return; }
resultC = hypotenuseC;
resultAngleB = angleB;
resultAngleA = 90 – angleB;
resultA = hypotenuseC * Math.sin(angleB * Math.PI / 180);
resultB = hypotenuseC * Math.cos(angleB * Math.PI / 180);
}
// Case 3: Two angles known (redundant as one is always 90, but handles user input)
if (!isNaN(angleA) && !isNaN(angleB)) {
if (Math.abs(angleA + angleB – 90) > 0.1) { // Allow for small floating point errors
alert("The sum of Angle A and Angle B must be 90 degrees.");
return;
}
resultAngleA = angleA;
resultAngleB = angleB;
}
// If we still don't have all sides/angles, try to fill in missing based on calculated ones
if (resultA !== null && resultB !== null && resultC === null) resultC = Math.sqrt(resultA * resultA + resultB * resultB);
if (resultA !== null && resultC !== null && resultB === null) {
if (resultC <= resultA) { alert("Hypotenuse must be greater than the given side."); return; }
resultB = Math.sqrt(resultC * resultC – resultA * resultA);
}
if (resultB !== null && resultC !== null && resultA === null) {
if (resultC <= resultB) { alert("Hypotenuse must be greater than the given side."); return; }
resultA = Math.sqrt(resultC * resultC – resultB * resultB);
}
if (resultA !== null && resultC !== null && resultAngleA === null) resultAngleA = Math.asin(resultA / resultC) * (180 / Math.PI);
if (resultA !== null && resultC !== null && resultAngleB === null) resultAngleB = Math.acos(resultA / resultC) * (180 / Math.PI);
if (resultB !== null && resultC !== null && resultAngleA === null) resultAngleA = Math.acos(resultB / resultC) * (180 / Math.PI);
if (resultB !== null && resultC !== null && resultAngleB === null) resultAngleB = Math.asin(resultB / resultC) * (180 / Math.PI);
if (resultA !== null && resultB !== null && resultAngleA === null) resultAngleA = Math.atan(resultA / resultB) * (180 / Math.PI);
if (resultA !== null && resultB !== null && resultAngleB === null) resultAngleB = Math.atan(resultB / resultA) * (180 / Math.PI);
if (resultAngleA !== null && resultAngleB === null) resultAngleB = 90 – resultAngleA;
if (resultAngleB !== null && resultAngleA === null) resultAngleA = 90 – resultAngleB;
// Calculate Area and Perimeter if sides are available
if (resultA !== null && resultB !== null) {
resultArea = 0.5 * resultA * resultB;
}
if (resultA !== null && resultB !== null && resultC !== null) {
resultPerimeter = resultA + resultB + resultC;
}
// Display results, rounding to a reasonable precision
document.getElementById("resultA").innerText = resultA !== null ? resultA.toFixed(4) : "–";
document.getElementById("resultB").innerText = resultB !== null ? resultB.toFixed(4) : "–";
document.getElementById("resultC").innerText = resultC !== null ? resultC.toFixed(4) : "–";
document.getElementById("resultAngleA").innerText = resultAngleA !== null ? resultAngleA.toFixed(4) : "–";
document.getElementById("resultAngleB").innerText = resultAngleB !== null ? resultAngleB.toFixed(4) : "–";
document.getElementById("resultArea").innerText = resultArea !== null ? resultArea.toFixed(4) : "–";
document.getElementById("resultPerimeter").innerText = resultPerimeter !== null ? resultPerimeter.toFixed(4) : "–";
}