Select the knowns and provide their values to calculate the unknown side of a triangle.
Side
Angle
Side
Angle
Side
Angle
Side A
Side B
Side C
Unknown Side: —
Understanding Triangle Side Calculations
Triangles are fundamental geometric shapes with three sides and three angles. The sum of the interior angles of any triangle is always 180 degrees.
Calculating the length of a side of a triangle requires specific information about other sides and angles. This calculator helps determine an unknown side when you have sufficient known values, utilizing key trigonometric laws.
When Can You Calculate a Triangle's Side?
You can solve for a triangle's side if you know:
Two sides and the included angle (SAS): The Side-Angle-Side case allows you to find the third side using the Law of Cosines.
Three sides (SSS): If all three sides are known, you can find any angle using the Law of Cosines, but this calculator focuses on finding sides.
Two angles and a side (AAS or ASA): The Angle-Angle-Side or Angle-Side-Angle cases allow you to find the third angle (since they sum to 180°) and then use the Law of Sines to find the unknown sides.
Mathematical Laws Used:
Law of Sines: This law relates the lengths of the sides of a triangle to the sines of its opposite angles. For a triangle with sides a, b, c and opposite angles A, B, C respectively:
a / sin(A) = b / sin(B) = c / sin(C)
This is particularly useful when you have two angles and a side (ASA or AAS).
Law of Cosines: This law is an extension of the Pythagorean theorem and relates the lengths of the sides of a triangle to the cosine of one of its angles.
For side a: a² = b² + c² - 2bc * cos(A)
For side b: b² = a² + c² - 2ac * cos(B)
For side c: c² = a² + b² - 2ab * cos(C)
This is used for the SAS (Side-Angle-Side) case to find the third side.
How to Use This Calculator:
Select the 'Type' for each of the three known inputs (Side or Angle).
Enter the corresponding 'Value' for each known input. Make sure angles are in degrees.
Choose which side (A, B, or C) you want to calculate.
Click 'Calculate'.
Note: This calculator assumes standard triangle conventions where side a is opposite angle A, side b opposite angle B, and side c opposite angle C. Ensure your inputs represent a valid triangle (e.g., sum of angles is 180 degrees, triangle inequality holds).
function degToRad(degrees) {
return degrees * (Math.PI / 180);
}
function radToDeg(radians) {
return radians * (180 / Math.PI);
}
function calculateSide() {
var known1_type = document.getElementById("known1_type").value;
var known1_value = parseFloat(document.getElementById("known1_value").value);
var known2_type = document.getElementById("known2_type").value;
var known2_value = parseFloat(document.getElementById("known2_value").value);
var known3_type = document.getElementById("known3_type").value;
var known3_value = parseFloat(document.getElementById("known3_value").value);
var unknown_side = document.getElementById("unknown_side").value;
var resultElement = document.getElementById("result").querySelector("span");
resultElement.textContent = "–"; // Reset result
var inputs = [
{ type: known1_type, value: known1_value, id: "known1" },
{ type: known2_type, value: known2_value, id: "known2" },
{ type: known3_type, value: known3_value, id: "known3" }
];
// Filter out invalid inputs
var valid_inputs = inputs.filter(input => !isNaN(input.value) && input.value > 0);
// Identify known sides and angles
var known_sides = valid_inputs.filter(input => input.type === "side");
var known_angles = valid_inputs.filter(input => input.type === "angle");
var calculated_side_value = NaN;
// — Calculation Logic —
// Case 1: Two sides and included angle (SAS)
if (known_sides.length === 2 && known_angles.length === 1) {
var side1_val = known_sides[0].value;
var side2_val = known_sides[1].value;
var angle_val = known_angles[0].value;
var angle_rad = degToRad(angle_val);
// Determine which side is unknown based on the known angle
var known_side1_id = known_sides[0].id;
var known_side2_id = known_sides[1].id;
var known_angle_id = known_angles[0].id;
var unknown_side_char = unknown_side;
// Check if the known angle is indeed the included angle
var is_included_angle = false;
if (known_angle_id === "known1" && (known_side1_id === "known2" || known_side1_id === "known3") && (known_side2_id === "known1" || known_side2_id === "known3")) is_included_angle = true;
if (known_angle_id === "known2" && (known_side2_id === "known1" || known_side2_id === "known3") && (known_side1_id === "known2" || known_side1_id === "known3")) is_included_angle = true;
if (known_angle_id === "known3" && (known_side3_id === "known1" || known_side3_id === "known2") && (known_side1_id === "known3" || known_side1_id === "known2")) is_included_angle = true;
// This logic needs to map input IDs to side variables a, b, c
// For simplicity, we'll assume the user selects the unknown_side based on the side they are solving for.
// A more robust solution would map input IDs to angles/sides a, b, c correctly.
// For SAS, Law of Cosines is used: c^2 = a^2 + b^2 – 2ab cos(C)
// We need to map side1_val, side2_val, and angle_val to the correct variables based on the unknown_side.
var a, b, c, A, B, C;
// Simplification: Assume inputs are correctly identified as a, b, C for calculating c
// This requires mapping the input values to the correct sides and angles.
// A robust implementation would require mapping inputs like 'known1_type' to 'a', 'b', 'c' and 'A', 'B', 'C'.
// For this simplified example, let's assume the user provides two sides and the angle OPPOSITE the third side.
// This is not SAS, but AAS/ASA logic, let's adjust.
// Let's re-evaluate based on general input types.
// We need to cover:
// 1. AAS/ASA (2 angles, 1 side) -> Law of Sines
// 2. SAS (2 sides, 1 angle) -> Law of Cosines
// 3. SSS (3 sides) -> Not for finding a side.
// Let's restructure the logic to be more general.
// Store known sides and angles with their corresponding labels (a, b, c, A, B, C)
var side_a = NaN, side_b = NaN, side_c = NaN;
var angle_A = NaN, angle_B = NaN, angle_C = NaN;
var current_inputs = {};
current_inputs["known1"] = { type: known1_type, value: known1_value };
current_inputs["known2"] = { type: known2_type, value: known2_value };
current_inputs["known3"] = { type: known3_type, value: known3_value };
// A proper mapping of known inputs to triangle components (a, b, c, A, B, C) is complex without more specific input fields.
// For this calculator's current structure, we'll use a common interpretation:
// If we have two sides and an angle, assume it's SAS and the angle is INCULUDED.
// If we have two angles and a side, assume ASA/AAS and the side is ADJACENT to at least one angle.
if (known_sides.length === 2 && known_angles.length === 1) { // SAS
var side1 = known_sides[0].value;
var side2 = known_sides[1].value;
var angle_deg = known_angles[0].value;
var angle_rad = degToRad(angle_deg);
// Assume the given angle is the included angle between the two given sides.
// We need to know which of the 'known_side' values correspond to 'a', 'b', 'c'.
// This requires more user input or a more complex interpretation.
// Let's simplify: if we are solving for side 'c', and we have 'a', 'b', and angle 'C'.
// This requires a mapping. For now, we'll assume the inputs can be mapped to a, b, and C to find c.
// A general solution for SAS given ANY two sides and ANY angle requires more logic or specific input fields.
// For example, if we want to find side C and we have sides a, b and angle C:
// c^2 = a^2 + b^2 – 2ab * cos(C)
// if (unknown_side === 'c' && known_sides.length === 2 && known_angles.length === 1) {
// var side_a_val = known_sides.find(s => s.id !== "known_angle_id").value; // This is too complex with generic IDs
// }
// Given the current input structure, the most straightforward SAS calculation is possible
// if we assume the two known sides are 'a' and 'b', and the known angle is 'C'.
// If the user wants to calculate 'c':
var a_val = NaN, b_val = NaN, C_val = NaN;
var inputs_array = [
{ type: known1_type, value: known1_value, id: "known1_index", order: 0 },
{ type: known2_type, value: known2_value, id: "known2_index", order: 1 },
{ type: known3_type, value: known3_value, id: "known3_index", order: 2 }
];
var s1 = inputs_array.filter(i => i.type === 'side')[0];
var s2 = inputs_array.filter(i => i.type === 'side')[1];
var ang = inputs_array.filter(i => i.type === 'angle')[0];
// SAS case: c^2 = a^2 + b^2 – 2ab cos(C)
if (s1 && s2 && ang) {
var angle_rad_sas = degToRad(ang.value);
var side1_val = s1.value;
var side2_val = s2.value;
if (unknown_side === 'c') {
calculated_side_value = Math.sqrt(side1_val*side1_val + side2_val*side2_val – 2 * side1_val * side2_val * Math.cos(angle_rad_sas));
} else if (unknown_side === 'a') {
// Need to rearrange Law of Cosines: a^2 = b^2 + c^2 – 2bc cos(A)
// If known: b, c, A => find a
// This structure needs more specific fields to assign which input is 'b', 'c', 'A'.
// Let's assume if calculating 'a', the knowns are 'b', 'c', and 'A'.
var side_b_val = s1.value; // Assuming first side input is b
var side_c_val = s2.value; // Assuming second side input is c
var angle_A_rad = degToRad(ang.value); // Assuming known angle is A
calculated_side_value = Math.sqrt(side_b_val*side_b_val + side_c_val*side_c_val – 2 * side_b_val * side_c_val * Math.cos(angle_A_rad));
} else if (unknown_side === 'b') {
// If known: a, c, B => find b
var side_a_val = s1.value; // Assuming first side input is a
var side_c_val = s2.value; // Assuming second side input is c
var angle_B_rad = degToRad(ang.value); // Assuming known angle is B
calculated_side_value = Math.sqrt(side_a_val*side_a_val + side_c_val*side_c_val – 2 * side_a_val * side_c_val * Math.cos(angle_B_rad));
}
}
}
// Case 2: Two angles and a side (AAS or ASA) – Law of Sines
if (known_angles.length === 2 && known_sides.length === 1) {
var side_val = known_sides[0].value;
var angle1_deg = known_angles[0].value;
var angle2_deg = known_angles[1].value;
var angle1_rad = degToRad(angle1_deg);
var angle2_rad = degToRad(angle2_deg);
var third_angle_deg = 180 – angle1_deg – angle2_deg;
var third_angle_rad = degToRad(third_angle_deg);
var side_known_id = known_sides[0].id; // e.g., 'known1' if it's a side
var angle1_known_id = known_angles[0].id; // e.g., 'known2' if it's an angle
var angle2_known_id = known_angles[1].id; // e.g., 'known3' if it's an angle
// We need to determine which side (a, b, or c) is the known side.
// And which angles (A, B, or C) correspond to the known angles.
// This mapping is crucial.
// Let's assume the known side is 'a' and the angles are 'A' and 'B'. Then we can find 'b' and 'c'.
// Or known side is 'a', angles are 'B' and 'C', then we find 'b' and 'c'.
// If unknown_side is 'a': We need 'b', 'c', 'B' or 'C'
// If unknown_side is 'b': We need 'a', 'c', 'A' or 'C'
// If unknown_side is 'c': We need 'a', 'b', 'A' or 'B'
// Using Law of Sines: a/sin(A) = b/sin(B) = c/sin(C)
// If we know side X and angles Y, Z. We want to find unknown side U.
// We know: X/sin(angle_opposite_X) = U/sin(angle_opposite_U)
// U = X * sin(angle_opposite_U) / sin(angle_opposite_X)
var known_side_val = side_val;
var known_angle_rad = NaN; // Angle opposite the known side
var unknown_angle_rad = NaN; // Angle opposite the unknown side
// This part is tricky with generic inputs. We need to know which angle is opposite which side.
// Let's assign the known side to 'a', and the two known angles to 'B' and 'C' to find 'b' and 'c'.
// Or known side to 'a', angles 'A' and 'B', to find 'b' and 'c'.
// Let's identify the sides/angles from the input objects directly.
var identified_sides = [];
var identified_angles = [];
inputs.forEach(function(input, index) {
if (input.type === "side") {
identified_sides.push({ value: input.value, index: index });
} else {
identified_angles.push({ value: input.value, index: index });
}
});
var known_s_val = identified_sides[0].value;
var known_ang1_deg = identified_angles[0].value;
var known_ang2_deg = identified_angles[1].value;
var third_ang_deg = 180 – known_ang1_deg – known_ang2_deg;
var angle_opp_known_side = NaN;
var angle_opp_unknown_side = NaN;
// We need to map the known side and angles to 'a', 'b', 'c', 'A', 'B', 'C'
// The current structure doesn't allow this mapping directly.
// A common assumption for ASA/AAS is that the known side is BETWEEN two angles (ASA), or one of the known angles is opposite the known side (AAS).
// Let's assume the known side is the one we will use in the law of sines formula.
// And the two known angles are the ones we'll use to find the third angle and the target angle.
// If calculating 'a': we need angle 'A', and have side 'b' or 'c' and their opposite angles.
// If we have side 'b' and angles 'A', 'C', then we can find 'a'.
// b / sin(B) = a / sin(A) => a = b * sin(A) / sin(B)
// Here, B is the angle not given, so B = 180 – A – C.
if (unknown_side === 'a') {
// We need angle A, and other side/angle pair.
// Let's assume the known side is 'b', and the known angles are 'A' and 'C'.
// So we have b, A, C. We want to find a.
// First find angle B: B = 180 – A – C
// Then use Law of Sines: a/sin(A) = b/sin(B) => a = b * sin(A) / sin(B)
var side_b_val = known_s_val; // Assume known side is b
var angle_A_deg = known_ang1_deg; // Assume known angle is A
var angle_C_deg = known_ang2_deg; // Assume known angle is C
var angle_B_deg = 180 – angle_A_deg – angle_C_deg;
if (angle_B_deg > 0 && angle_B_deg b = a * sin(B) / sin(A)
var side_a_val = known_s_val; // Assume known side is a
var angle_B_deg = known_ang1_deg; // Assume known angle is B
var angle_C_deg = known_ang2_deg; // Assume known angle is C
var angle_A_deg = 180 – angle_B_deg – angle_C_deg;
if (angle_A_deg > 0 && angle_A_deg c = a * sin(C) / sin(A)
var side_a_val = known_s_val; // Assume known side is a
var angle_A_deg = known_ang1_deg; // Assume known angle is A
var angle_B_deg = known_ang2_deg; // Assume known angle is B
var angle_C_deg = 180 – angle_A_deg – angle_B_deg;
if (angle_C_deg > 0 && angle_C_deg < 180) {
var angle_C_rad = degToRad(angle_C_deg);
var angle_A_rad = degToRad(angle_A_deg);
calculated_side_value = side_a_val * Math.sin(angle_C_rad) / Math.sin(angle_A_rad);
}
}
}
// Handle cases where there are insufficient or invalid inputs.
// e.g., SSS (3 sides), SSA (ambiguous case, not fully covered here), etc.
// For this calculator, we are specifically targeting SAS and AAS/ASA.
if (isNaN(calculated_side_value)) {
resultElement.textContent = "Invalid Input or Case";
} else {
resultElement.textContent = calculated_side_value.toFixed(4);
}
}
// Helper function to update input field placeholders based on type
function updateInputFields() {
var known1_type = document.getElementById("known1_type").value;
var known1_input = document.getElementById("known1_value");
known1_input.placeholder = "Value of " + (known1_type === "side" ? "Side" : "Angle") + " 1";
var known2_type = document.getElementById("known2_type").value;
var known2_input = document.getElementById("known2_value");
known2_input.placeholder = "Value of " + (known2_type === "side" ? "Side" : "Angle") + " 2";
var known3_type = document.getElementById("known3_type").value;
var known3_input = document.getElementById("known3_value");
known3_input.placeholder = "Value of " + (known3_type === "side" ? "Side" : "Angle") + " 3";
}