MongoDB $cosh Operator

What Is $cosh?

$cosh is a MongoDB aggregation expression that returns the hyperbolic cosine of a number. The input is measured in radians. For real numbers, the result is always ≥ 1.

$cosh = Math.cosh for aggregation

{ $cosh: <expression> }

input  → radians (any real number)
output → ≥ 1  (grows as |x| grows)
even   → cosh(-x) = cosh(x)

cosh(0) → 1
null / missing → null
NaN → NaN

How to Use $cosh in MongoDB

Pass a numeric expression (radians). Convert degrees first if that is how your angle is stored.

1. Choose an expression stage ($addFields or $project).
2. If the value is in degrees, convert with $degreesToRadians.
3. Pass that expression to $cosh.
4. Use the result (≥ 1) as a field, in formulas, or with other hyperbolic ops.

Pseudocode

for each document:
    x = evaluate(expression)   // radians
    if x is null or missing:
        result = null
    else if x is NaN:
        result = NaN
    else:
        result = cosh(x)       // ≥ 1 for real x
    emit { ..., field: result }

Cheat Sheet

Keep these facts handy while writing hyperbolic-cosine expressions.

Live Preview

Watch $cosh turn a number into its hyperbolic cosine. Try negatives to see the even property.

x = 1
$cosh(x) → 1.543081

{ y: 1.543081 }

Worked Walkthrough — cosh(0), cosh(1), cosh(-1)

Hyperbolic cosine is even: the sign of x does not change the result. Zero is the minimum.

cosh(x) = (e^x + e^(-x)) / 2

x = 0
  cosh(0) = (1 + 1) / 2 = 1

x = 1
  cosh(1) ≈ 1.543081

x = -1
  cosh(-1) ≈ 1.543081   ← same as cosh(1)

x = 2
  cosh(2) ≈ 3.762196

Minimum on the real line: cosh(0) = 1

MongoDB Examples

We use a small hyperbolic collection with values of x. First we compute $cosh, then we highlight the even property. Insert the sample data once in mongosh.

db.hyperbolic.insertMany([
  { _id: 1, x: 0 },
  { _id: 2, x: 1 },
  { _id: 3, x: -1 },
  { _id: 4, x: 2 }
]);

db.hyperbolic.find()

[
  { _id: 1, x: 0 },
  { _id: 2, x: 1 },
  { _id: 3, x: -1 },
  { _id: 4, x: 2 }
]

Hyperbolic cosine curve (sketch):

  y
  |         /
  |        /
  |   ____/____   ← minimum at cosh(0) = 1
  |  /         \
  | /
  +--------------→ x
     -2  -1  0  1  2

  cosh(-1) = cosh(1)  (mirror / even)

db.hyperbolic.aggregate([
  {
    $addFields: {
      y: { $cosh: "$x" }
    }
  }
]);

[
  { _id: 1, x: 0,  y: 1 },
  { _id: 2, x: 1,  y: 1.5430806348152437 },
  { _id: 3, x: -1, y: 1.5430806348152437 },
  { _id: 4, x: 2,  y: 3.7621956910836314 }
]

db.hyperbolic.aggregate([
  { $match: { x: { $in: [1, -1] } } },
  {
    $addFields: {
      y: { $cosh: "$x" }
    }
  }
]);

[
  { _id: 2, x: 1,  y: 1.5430806348152437 },
  { _id: 3, x: -1, y: 1.5430806348152437 }
]

Performance Notes

Hyperbolic expressions are cheap compared with large sorts or joins. Filter early with $match when only some documents need $cosh.

Key Takeaways