DEV Community

Cover image for The Trigonometry of Oblique Spaces: Solving Triangles with the Law of Sines and Cosines in Code
kandz
kandz

Posted on

The Trigonometry of Oblique Spaces: Solving Triangles with the Law of Sines and Cosines in Code

#math #geometry #programming #webdev

In computer graphics, spatial mapping, navigation, and structural engineering, the triangle represents the fundamental geometric simplex. While solving right-angled triangles requires only basic Pythagorean theorems and standard trigonometric ratios (sine, cosine, tangent), solving oblique (non-right) triangles requires more advanced algebraic models.

To resolve these structures, we must implement the Law of Sines and the Law of Cosines in code.

Let's break down the mathematical formulations for solving oblique triangles, handle the complex "Ambiguous Case" of trigonometry, and write clean, constant-time algorithms to resolve any triangle's dimensions.

1. The Trigonometric Foundations of Oblique Solvers

A triangle consists of three sides ($a, b, c$) and three opposing angles ($A, B, C$).

          C
         / \
      b /   \ a
       /     \
      A-------B
          c
Enter fullscreen mode Exit fullscreen mode

To solve a triangle means to calculate all unknown dimensions when given at least three known parameters (with at least one of those parameters being a side).

Methodology A: The Law of Cosines (SSS & SAS)

The Law of Cosines is a generalization of the Pythagorean theorem. It is used to resolve triangles when we are given three sides (SSS) or two sides and their enclosed angle (SAS).

The formula states:
$$c^2 = a^2 + b^2 - 2ab \cdot \cos(C)$$

To find an angle when given three sides (SSS), we can rewrite the equation as:
$$\cos(C) = \frac{a^2 + b^2 - c^2}{2ab}$$
$$C = \arccos\left(\frac{a^2 + b^2 - c^2}{2ab}\right)$$

In programming, we must convert degrees to radians before passing values to native trigonometric functions, and convert the returned radians back to degrees:
$$\text{Radians} = \text{Degrees} \times \frac{\pi}{180}$$

Methodology B: The Law of Sines (ASA & AAS)

The Law of Sines establishes a constant ratio between the length of a triangle's sides and the sine of their opposing angles:
$$\frac{a}{\sin(A)} = \frac{b}{\sin(B)} = \frac{c}{\sin(C)}$$

This is used to resolve triangles when we are given two angles and a side (ASA or AAS). If we know two angles, the third angle is easily found since the sum of internal angles in a Euclidean triangle is always 180°:
$$C = 180^{\circ} - A - B$$

Once all angles are known, we can calculate any missing side:
$$a = b \cdot \frac{\sin(A)}{\sin(B)}$$

Methodology C: The Ambiguous Case (SSA)

The most mathematically complex scenario is the Side-Side-Angle (SSA) configuration, where we are given two sides ($a, b$) and a non-enclosed angle ($A$).

Depending on the relationship between side $a$, side $b$, and the height $h = b \cdot \sin(A)$, the system can yield:

  1. Zero Solutions: If $a < h$ (the side is too short to reach the base line).
  2. One Solution: If $a \ge b$ or $a = h$.
  3. Two Solutions (The Ambiguous Case): If $h < a < b$. In this scenario, two entirely different triangles can be formed with the same given parameters—one acute and one obtuse.

An oblique solver must calculate both possible configurations, alerting the user to this dual-coordinate state.

2. Implementing the Solver in TypeScript

Here is a clean TypeScript function that parses and solves a Side-Angle-Angle (AAS) triangle, converting degrees and utilizing the Law of Sines:

interface TriangleResult {
  a: number;
  b: number;
  c: number;
  A: number;
  B: number;
  C: number;
  area: number;
  perimeter: number;
}

function solveAAS(
  knownSideValue: number,
  opposingAngleDeg: number,
  secondAngleDeg: number
): TriangleResult {
  const degToRad = Math.PI / 180;
  const radToDeg = 180 / Math.PI;

  const A = opposingAngleDeg;
  const B = secondAngleDeg;
  const C = 180 - A - B;

  const a = knownSideValue;

  const sinA = Math.sin(A * degToRad);
  const sinB = Math.sin(B * degToRad);
  const sinC = Math.sin(C * degToRad);

  const b = a * (sinB / sinA);
  const c = a * (sinC / sinA);

  const perimeter = a + b + c;

  // Area calculated using Heron's formula
  const s = perimeter / 2;
  const area = Math.sqrt(s * (s - a) * (s - b) * (s - c));

  return {
    a: Number(a.toFixed(4)),
    b: Number(b.toFixed(4)),
    c: Number(c.toFixed(4)),
    A: Number(A.toFixed(2)),
    B: Number(B.toFixed(2)),
    C: Number(C.toFixed(2)),
    area: Number(area.toFixed(4)),
    perimeter: Number(perimeter.toFixed(4))
  };
}
Enter fullscreen mode Exit fullscreen mode

3. Client-Side Security for Engineering and CAD Specifications

Civil engineers, surveyors, and CAD draftsmen regularly calculate precise triangle dimensions for proprietary structures, land plots, or mechanical designs. Submitting these specific measurements, coordinate boundaries, or spatial specs to external cloud-logged tools presents substantial corporate intellectual property risks.

We enforce a strict 100% Client-Side Privacy Law across our tool suite. Every trigonometric evaluation, radian conversion, and area calculation is computed locally inside your browser's RAM. No spatial parameters are ever transmitted over the network, keeping your engineering designs and CAD assets secure.

Solve triangle dimensions privately: Triangle (Trigonometry) Solver - Kandz.me

Top comments (0)