Triangles are fundamental geometric shapes with three sides and three interior angles. The sum of these interior angles always equals 180 degrees. Calculating the length of a side or the measure of an angle within a triangle often requires knowing at least some of its other properties. This calculator helps you find unknown sides or angles using well-established trigonometric laws, provided you have sufficient information about the triangle.
When to Use This Calculator
This calculator is useful in various scenarios:
Construction and Architecture: Determining dimensions for roofs, bridges, or building frames.
Navigation: Calculating distances and bearings between points.
Engineering: Analyzing forces, stress, and structures.
Surveying: Measuring distances and elevations of land features.
Physics: Solving problems involving vectors and projectile motion.
Mathematics Education: Assisting students in understanding trigonometric principles.
Mathematical Principles Used
This calculator employs two primary trigonometric laws, depending on the inputs provided and the desired output:
1. The Law of Sines
The Law of Sines relates the length of the sides of a triangle to the sine of its opposite angles. It's particularly useful when you know:
Two angles and one side (AAS or ASA)
Two sides and an angle opposite one of them (SSA – be aware this case can sometimes yield two possible triangles)
The formula is:
a / sin(A) = b / sin(B) = c / sin(C)
Where:
a, b, c are the lengths of the sides opposite angles A, B, and C, respectively.
A, B, C are the measures of the interior angles.
2. The Law of Cosines
The Law of Cosines is an extension of the Pythagorean theorem. It relates the lengths of the sides of a triangle to the cosine of one of its angles. It's useful when you know:
All three sides (SSS)
Two sides and the included angle (SAS)
The formulas are:
a² = b² + c² - 2bc * cos(A) b² = a² + c² - 2ac * cos(B) c² = a² + b² - 2ab * cos(C)
These can be rearranged to solve for angles if all sides are known.
How the Calculator Works
You input the values for the sides and angles you know. The calculator then determines which trigonometric law to apply based on the combination of inputs and the desired calculation. It converts angles to radians for trigonometric functions (as JavaScript's Math.sin and Math.cos expect radians) and then converts the result back to degrees if an angle is being calculated.
For example, if you know sides a and b and angle C, and you want to find side c, the Law of Cosines is used: c = sqrt(a² + b² - 2ab * cos(C)). If you know sides a and b and angle A, and want to find angle B, you might use the Law of Sines: sin(B) = (b * sin(A)) / a, and then B = asin(sin(B)).
The calculator validates inputs to ensure they are valid numbers and that the triangle inequality theorem (sum of any two sides must be greater than the third side) is considered where applicable, and that angles result in valid triangles.
function toRadians(degrees) {
return degrees * Math.PI / 180;
}
function toDegrees(radians) {
return radians * 180 / Math.PI;
}
function calculateTriangleSide() {
var sideA = parseFloat(document.getElementById('knownSideA').value);
var sideB = parseFloat(document.getElementById('knownSideB').value);
var sideC = parseFloat(document.getElementById('knownSideC').value);
var angleA = parseFloat(document.getElementById('knownAngleA').value);
var angleB = parseFloat(document.getElementById('knownAngleB').value);
var angleC = parseFloat(document.getElementById('knownAngleC').value);
var calculationType = document.getElementById('calculationType').value;
var resultDiv = document.getElementById('result');
var errorDiv = document.getElementById('error');
resultDiv.textContent = '–';
errorDiv.textContent = ";
var knownSides = 0;
if (!isNaN(sideA)) knownSides++;
if (!isNaN(sideB)) knownSides++;
if (!isNaN(sideC)) knownSides++;
var knownAngles = 0;
if (!isNaN(angleA)) knownAngles++;
if (!isNaN(angleB)) knownAngles++;
if (!isNaN(angleC)) knownAngles++;
var inputs = {
a: !isNaN(sideA) ? sideA : null,
b: !isNaN(sideB) ? sideB : null,
c: !isNaN(sideC) ? sideC : null,
A: !isNaN(angleA) ? angleA : null,
B: !isNaN(angleB) ? angleB : null,
C: !isNaN(angleC) ? angleC : null,
};
var calculatedValue = null;
var calculationMethod = "";
try {
// — Logic for calculating unknown values —
if (calculationType === 'sideA') {
if (inputs.b !== null && inputs.c !== null && inputs.A !== null) { // SAS case
calculationMethod = "Law of Cosines";
var angleARad = toRadians(inputs.A);
calculatedValue = Math.sqrt(inputs.b * inputs.b + inputs.c * inputs.c – 2 * inputs.b * inputs.c * Math.cos(angleARad));
} else if (inputs.b !== null && inputs.B !== null && inputs.C !== null) { // Angle-Angle-Side (AAS)
calculationMethod = "Law of Sines";
inputs.A = 180 – inputs.B – inputs.C; // Calculate missing angle A
if (inputs.A = 180) throw new Error("Invalid angles provided, sum must be 180 degrees and positive.");
var angleARad = toRadians(inputs.A);
calculatedValue = (inputs.b * Math.sin(angleARad)) / Math.sin(inputs.B);
} else if (inputs.c !== null && inputs.C !== null && inputs.B !== null) { // Angle-Angle-Side (AAS) – symmetrical to above
calculationMethod = "Law of Sines";
inputs.A = 180 – inputs.B – inputs.C;
if (inputs.A = 180) throw new Error("Invalid angles provided, sum must be 180 degrees and positive.");
var angleARad = toRadians(inputs.A);
calculatedValue = (inputs.c * Math.sin(angleARad)) / Math.sin(inputs.C);
} else if (inputs.b !== null && inputs.c !== null && inputs.a !== null) { // SSS case – implies we are checking if it's valid, not calculating side a
throw new Error("Side A is already provided or cannot be uniquely determined from SSS.");
} else if (inputs.b !== null && inputs.B !== null && inputs.a !== null) { // SSA – ambiguous case, check if side A is calculable
calculationMethod = "Law of Sines";
var angleARad = Math.asin((inputs.a * Math.sin(inputs.B)) / inputs.b);
calculatedValue = toDegrees(angleARad);
// NOTE: This SSA calculation for side A is unusual. Typically SSA is used for angles.
// If side A is *known*, and we are calculating ANOTHER side A, this is usually an error state.
// Assuming the user meant to calculate an angle or another side.
throw new Error("Calculating Side A when Side A is already known or ambiguous via SSA is not directly supported. Consider calculating an angle.");
} else if (inputs.c !== null && inputs.C !== null && inputs.a !== null) { // SSA – ambiguous case, check if side A is calculable
calculationMethod = "Law of Sines";
var angleARad = Math.asin((inputs.a * Math.sin(inputs.C)) / inputs.c);
calculatedValue = toDegrees(angleARad);
throw new Error("Calculating Side A when Side A is already known or ambiguous via SSA is not directly supported. Consider calculating an angle.");
}
else {
throw new Error("Insufficient information to calculate Side A. Need SAS (b, c, Angle A) or AAS/ASA (two angles and one adjacent side).");
}
} else if (calculationType === 'sideB') {
if (inputs.a !== null && inputs.c !== null && inputs.B !== null) { // SAS case
calculationMethod = "Law of Cosines";
var angleBRad = toRadians(inputs.B);
calculatedValue = Math.sqrt(inputs.a * inputs.a + inputs.c * inputs.c – 2 * inputs.a * inputs.c * Math.cos(angleBRad));
} else if (inputs.a !== null && inputs.A !== null && inputs.C !== null) { // AAS
calculationMethod = "Law of Sines";
inputs.B = 180 – inputs.A – inputs.C;
if (inputs.B = 180) throw new Error("Invalid angles provided, sum must be 180 degrees and positive.");
var angleBRad = toRadians(inputs.B);
calculatedValue = (inputs.a * Math.sin(angleBRad)) / Math.sin(inputs.A);
} else if (inputs.c !== null && inputs.C !== null && inputs.A !== null) { // ASA
calculationMethod = "Law of Sines";
inputs.B = 180 – inputs.A – inputs.C;
if (inputs.B = 180) throw new Error("Invalid angles provided, sum must be 180 degrees and positive.");
var angleBRad = toRadians(inputs.B);
calculatedValue = (inputs.c * Math.sin(angleBRad)) / Math.sin(inputs.C);
} else if (inputs.a !== null && inputs.c !== null && inputs.b !== null) { // SSS case
throw new Error("Side B is already provided or cannot be uniquely determined from SSS.");
} else if (inputs.a !== null && inputs.A !== null && inputs.b !== null) { // SSA
throw new Error("Calculating Side B when Side B is already known or ambiguous via SSA is not directly supported. Consider calculating an angle.");
} else if (inputs.c !== null && inputs.C !== null && inputs.b !== null) { // SSA
throw new Error("Calculating Side B when Side B is already known or ambiguous via SSA is not directly supported. Consider calculating an angle.");
}
else {
throw new Error("Insufficient information to calculate Side B. Need SAS (a, c, Angle B) or AAS/ASA (two angles and one adjacent side).");
}
} else if (calculationType === 'sideC') {
if (inputs.a !== null && inputs.b !== null && inputs.C !== null) { // SAS case
calculationMethod = "Law of Cosines";
var angleCRad = toRadians(inputs.C);
calculatedValue = Math.sqrt(inputs.a * inputs.a + inputs.b * inputs.b – 2 * inputs.a * inputs.b * Math.cos(angleCRad));
} else if (inputs.a !== null && inputs.A !== null && inputs.B !== null) { // AAS
calculationMethod = "Law of Sines";
inputs.C = 180 – inputs.A – inputs.B;
if (inputs.C = 180) throw new Error("Invalid angles provided, sum must be 180 degrees and positive.");
var angleCRad = toRadians(inputs.C);
calculatedValue = (inputs.a * Math.sin(angleCRad)) / Math.sin(inputs.A);
} else if (inputs.b !== null && inputs.B !== null && inputs.A !== null) { // ASA
calculationMethod = "Law of Sines";
inputs.C = 180 – inputs.A – inputs.B;
if (inputs.C = 180) throw new Error("Invalid angles provided, sum must be 180 degrees and positive.");
var angleCRad = toRadians(inputs.C);
calculatedValue = (inputs.b * Math.sin(angleCRad)) / Math.sin(inputs.B);
} else if (inputs.a !== null && inputs.b !== null && inputs.c !== null) { // SSS case
throw new Error("Side C is already provided or cannot be uniquely determined from SSS.");
} else if (inputs.a !== null && inputs.A !== null && inputs.c !== null) { // SSA
throw new Error("Calculating Side C when Side C is already known or ambiguous via SSA is not directly supported. Consider calculating an angle.");
} else if (inputs.b !== null && inputs.B !== null && inputs.c !== null) { // SSA
throw new Error("Calculating Side C when Side C is already known or ambiguous via SSA is not directly supported. Consider calculating an angle.");
}
else {
throw new Error("Insufficient information to calculate Side C. Need SAS (a, b, Angle C) or AAS/ASA (two angles and one adjacent side).");
}
} else if (calculationType === 'angleA') {
if (inputs.a !== null && inputs.b !== null && inputs.B !== null) { // Side-Side-Angle (SSA) – potentially ambiguous
calculationMethod = "Law of Sines";
var sinA = (inputs.a * Math.sin(toRadians(inputs.B))) / inputs.b;
if (sinA > 1 || sinA a and sinA is valid, there might be a second angle A' = 180 – A
// This calculator provides the primary solution. For full ambiguity, manual check needed.
// Also, if a > b and angle B is acute, sinA < 1, there is only one solution.
// If a = b and angle B is acute, sinA = 1, A = 90. Only one solution.
// If a < b and angle B is acute, sinA b*sinB
// If angle B is obtuse, a MUST be greater than b. Only one solution.
if (inputs.a < inputs.b && inputs.B < 90 && sinA 0) {
// A second valid triangle exists. This calculator shows the principal value.
// For educational purposes, we'll note this:
console.warn("Ambiguous case detected. A second possible angle A exists.");
}
}
} else if (inputs.a !== null && inputs.b !== null && inputs.c !== null) { // Side-Side-Side (SSS)
calculationMethod = "Law of Cosines";
var cosA = (inputs.b * inputs.b + inputs.c * inputs.c – inputs.a * inputs.a) / (2 * inputs.b * inputs.c);
if (cosA > 1 || cosA 1 || sinA 1 || sinB < -1) throw new Error("Invalid triangle: sine value out of range.");
calculatedValue = toDegrees(Math.asin(sinB));
if (inputs.b < inputs.a && inputs.A < 90 && sinB 1 || cosB 1 || sinB 1 || sinC < -1) throw new Error("Invalid triangle: sine value out of range.");
calculatedValue = toDegrees(Math.asin(sinC));
if (inputs.c < inputs.a && inputs.A < 90 && sinC 1 || cosC 1 || sinC < -1) throw new Error("Invalid triangle: sine value out of range.");
calculatedValue = toDegrees(Math.asin(sinC));
}
else {
throw new Error("Insufficient information to calculate Angle C. Need SSS (a, b, c) or SSA (a, c, Angle A) or SAS (a, b, Angle C, and adjacent sides/angles to derive).");
}
}
// Basic triangle validity checks after calculation attempt
if (calculatedValue !== null) {
// Check if all required inputs were provided for the successful calculation path
var requiredInputsMet = true;
if (calculationType.startsWith('side')) {
if (calculationType === 'sideA' && (inputs.b === null || inputs.c === null || inputs.A === null)) requiredInputsMet = false;
if (calculationType === 'sideB' && (inputs.a === null || inputs.c === null || inputs.B === null)) requiredInputsMet = false;
if (calculationType === 'sideC' && (inputs.a === null || inputs.b === null || inputs.C === null)) requiredInputsMet = false;
} else { // calculating angle
if (calculationType === 'angleA' && !((inputs.a !== null && inputs.b !== null && inputs.c !== null) || (inputs.a !== null && inputs.b !== null && inputs.B !== null) || (inputs.b !== null && inputs.c !== null && inputs.A !== null))) requiredInputsMet = false;
if (calculationType === 'angleB' && !((inputs.a !== null && inputs.b !== null && inputs.c !== null) || (inputs.a !== null && inputs.b !== null && inputs.A !== null) || (inputs.a !== null && inputs.c !== null && inputs.B !== null))) requiredInputsMet = false;
if (calculationType === 'angleC' && !((inputs.a !== null && inputs.b !== null && inputs.c !== null) || (inputs.a !== null && inputs.c !== null && inputs.A !== null) || (inputs.a !== null && inputs.b !== null && inputs.C !== null))) requiredInputsMet = false;
}
if (!requiredInputsMet) {
throw new Error("Calculation failed due to missing required input fields for the selected calculation type.");
}
// Perform final validity check if possible (e.g., triangle inequality for sides, sum of angles)
var finalA = !isNaN(angleA) ? angleA : (calculationType === 'angleA' ? calculatedValue : null);
var finalB = !isNaN(angleB) ? angleB : (calculationType === 'angleB' ? calculatedValue : null);
var finalC = !isNaN(angleC) ? angleC : (calculationType === 'angleC' ? calculatedValue : null);
var final_a = !isNaN(sideA) ? sideA : (calculationType === 'sideA' ? calculatedValue : null);
var final_b = !isNaN(sideB) ? sideB : (calculationType === 'sideB' ? calculatedValue : null);
var final_c = !isNaN(sideC) ? sideC : (calculationType === 'sideC' ? calculatedValue : null);
// Re-evaluate known/calculated values for completeness
if (final_a === null && calculationType === 'sideA') final_a = calculatedValue;
if (final_b === null && calculationType === 'sideB') final_b = calculatedValue;
if (final_c === null && calculationType === 'sideC') final_c = calculatedValue;
if (finalA === null && calculationType === 'angleA') finalA = calculatedValue;
if (finalB === null && calculationType === 'angleB') finalB = calculatedValue;
if (finalC === null && calculationType === 'angleC') finalC = calculatedValue;
// Check triangle inequality for sides if enough sides are known/calculated
if (final_a !== null && final_b !== null && final_c !== null) {
if (final_a + final_b <= final_c || final_a + final_c <= final_b || final_b + final_c 0.1) { // Allow for small floating point errors
throw new Error("Invalid triangle: The sum of the interior angles must be 180 degrees.");
}
}
resultDiv.textContent = calculatedValue.toFixed(4); // Display result with 4 decimal places
}
} catch (e) {
errorDiv.textContent = "Error: " + e.message;
}
// Display result
if (calculatedValue !== null && errorDiv.textContent === ") {
resultDiv.textContent = calculatedValue.toFixed(4);
}
}