MongoDB $tan Operator

What You’ll Learn

The $tan operator computes the tangent of an angle in MongoDB aggregation pipelines. Input must be in radians. Use it for slopes, trigonometric analysis, and geometry calculations alongside $sin and $cos.

Definition and Usage

In MongoDB’s aggregation framework, the $tan operator returns the tangent of an angle given in radians. For example, { $tan: 0.7853981633974483 } (45°) returns approximately 1, and { $tan: 0.5235987755982988 } (30°) returns approximately 0.5774.

Tangent represents the ratio of sine to cosine: tan(θ) = sin(θ) / cos(θ). In practice, it is useful for slope calculations, angle analysis, and engineering formulas stored in your documents.

📝 Syntax

The $tan operator takes one numeric expression (angle in radians):

{ $tan: <expression> }

Literal Examples

{ $tan: 0 }
// Result: 0

{ $tan: 0.7853981633974483 }
// ~45° in radians → ~1

{ $tan: { $degreesToRadians: 30 } }
// 30° → ~0.5774

Syntax Rules

• $tan — returns the tangent of the angle that follows.
• <expression> — angle in radians (field path, literal, or nested expression).
• Use inside $project, $addFields, or $set.
• Convert degrees with $degreesToRadians before calling $tan.
• Undefined at odd multiples of π/2 (e.g., 90°, 270°) — may return very large values or null depending on input.
• null input — returns null.

Examples Gallery

Compute tangents from degree fields, work with radian literals, and derive slope values from angles.

[
  { "_id": 1, "label": "30° angle",  "degrees": 30 },
  { "_id": 2, "label": "45° angle",  "degrees": 45 },
  { "_id": 3, "label": "60° angle",  "degrees": 60 }
]

db.angles.aggregate([
  {
    $project: {
      label: 1,
      degrees: 1,
      tangent: {
        $tan: {
          $degreesToRadians: "$degrees"
        }
      }
    }
  }
])

// 30° → tangent: ~0.5774
// 45° → tangent: ~1
// 60° → tangent: ~1.7321

db.angles.aggregate([
  {
    $project: {
      tangentZero: { $tan: 0 },
      tangentPi4:  { $tan: 0.7853981633974483 }
    }
  }
])

// $tan(0)           → 0
// $tan(π/4 radians) → ~1

db.terrain.aggregate([
  {
    $project: {
      segment: 1,
      angleDegrees: 1,
      slope: {
        $tan: {
          $degreesToRadians: "$angleDegrees"
        }
      }
    }
  }
])

// angleDegrees: 45 → slope: ~1 (45° incline)
// angleDegrees: 0  → slope: 0 (flat)

db.angles.aggregate([
  {
    $project: {
      degrees: 1,
      viaTan: {
        $tan: {
          $degreesToRadians: "$degrees"
        }
      },
      viaSinCos: {
        $divide: [
          {
            $sin: {
              $degreesToRadians: "$degrees"
            }
          },
          {
            $cos: {
              $degreesToRadians: "$degrees"
            }
          }
        ]
      }
    }
  }
])

db.measurements.aggregate([
  {
    $project: {
      sensor: 1,
      radians: 1,
      tangent: { $tan: "$radians" }
    }
  }
])

🚀 Use Cases

• Geometry and trigonometry — compute slopes, angles, and distances in spatial data.
• Engineering and physics — evaluate formulas that use tangent in simulations or sensor data.
• Terrain and elevation — derive incline (slope) from angle measurements.
• Signal processing — combine with other trig operators for phase and waveform analysis.

💡 Best Practices