MongoDB $radiansToDegrees Operator

Beginner
5 min read
Updated: Oct 2026
3 examples
Live preview

What Is $radiansToDegrees?

$radiansToDegrees is a MongoDB aggregation expression that converts an angle from radians to degrees. Formula: degrees = radians × (180 / π).

Remember
$radiansToDegrees = radians → degrees

{ $radiansToDegrees: <expression> }

degrees = radians × (180 / π)

π/2 rad → 90°
π   rad → 180°
0   rad → 0°

null / missing → null
NaN → NaN
±Infinity → ±Infinity

inverse: $degreesToRadians
NeedPrefer
Radians → degrees$radiansToDegrees
Degrees → radians$degreesToRadians
Angle from cosine$acos then $radiansToDegrees

How to Use $radiansToDegrees in MongoDB

Pass a radian value (field or expression), then store the degree result in a stage.

  1. Choose an expression stage ($addFields or $project).
  2. Write { $radiansToDegrees: "$angle_rad" }.
  3. Or nest a trig result: { $radiansToDegrees: { $acos: "$x" } }.
  4. Use the degree value for display, reports, or APIs.
PieceRequired?Role
$radiansToDegreesYesRadians → degrees
ExpressionYesNumber in radians (field, literal, or nested trig)
StageYes$addFields / $project to store the result

Pseudocode

Pseudocode
for each document:
    r = evaluate(radianExpression)
    if r is null or missing:
        result = null
    else if r is NaN:
        result = NaN
    else if r is ±Infinity:
        result = ±Infinity
    else:
        result = r * (180 / π)
    emit { ..., field: result }

Cheat Sheet

Keep these facts handy while converting angles.

TopicDetail
TypeAggregation expression (not a find filter)
Syntax{ $radiansToDegrees: "$angle_rad" }
Formularad × 180 / π
Common valuesπ/2 → 90, π → 180, π/4 → 45
With trig{ $radiansToDegrees: { $acos: <x> } }
Inverse$degreesToRadians
Sample checkπ/2 radians → 90 degrees

Live Preview

Watch $radiansToDegrees convert common radian values to degrees.

Simulates { $radiansToDegrees: radians } (same idea as the mongosh examples below).

Result
radians = π/2 ≈ 1.570796

$radiansToDegrees → 90

{ degrees: 90 }

Worked Walkthrough — π/2 to 90°

An angle is stored as π/2 radians. We want degrees.

Calculation
Document:
  { angle_rad: π/2 }   // ≈ 1.570796

$radiansToDegrees: "$angle_rad"

degrees = (π/2) × (180 / π)
        = 180 / 2
        = 90

Result:
  90

Check: a right angle is 90° ✓

MongoDB Examples

We use one angle document. First we store a radian value, then we convert it to degrees, then we nest $acos and convert in one step. Run these in mongosh after inserting the sample data once.

Example 1 — Sample Data

Imagine one angle of π/2 radians (a right angle) and a cosine sample value of 0.8 for later. We save both in a collection named angles.

mongosh
db.angles.insertOne({
  _id: 1,
  label: "Right angle",
  angle_rad: Math.PI / 2,
  cos_x: 0.8
});

How the Data Is Stored in MongoDB

After the insert, MongoDB keeps one document in angles. Run find() to see it:

mongosh
db.angles.find()

Read that document like this:

Field in MongoDBValuePlain English
_id1Document id (row number for this lesson)
label"Right angle"Friendly name
angle_radπ/2 ≈ 1.5708Angle in radians
cos_x0.8Cosine input for Example 3
Picture
Right angle (easy check):

  π/2 rad  --$radiansToDegrees-->  90°

Also stored for later:
  0.8 --$acos--> ~0.6435 rad
      --$radiansToDegrees--> ~36.87°

How It Works

  1. Insert once. insertOne adds a single document to angles.
  2. Store radians as a number. Math.PI / 2 becomes a double in MongoDB.
  3. find() shows the same shape. What you inserted is what you get back—ready for conversion next.

Example 2 — Convert to Degrees

Goal: add a degrees field from angle_rad.

mongosh
db.angles.aggregate([
  {
    $addFields: {
      degrees: { $radiansToDegrees: "$angle_rad" }
    }
  }
]);

How It Works

  1. Read the stored radians. MongoDB already has angle_rad ≈ 1.5708 (π/2) from Example 1.
  2. Apply the formula. $radiansToDegrees multiplies by 180 / π.
  3. Get 90. A right angle in degrees—an easy check.
  4. Keep all fields. $addFields adds degrees next to angle_rad—nothing is deleted.

Example 3 — With $acos

Nest $acos (returns radians) inside $radiansToDegrees for a degree angle.

mongosh
db.angles.aggregate([
  {
    $project: {
      cos_x: 1,
      angle_deg: {
        $radiansToDegrees: {
          $acos: "$cos_x"
        }
      }
    }
  }
]);

How It Works

  1. Start with cosine. Still using cos_x: 0.8 from Example 1.
  2. Get radians from $acos. About 0.6435 rad.
  3. Convert immediately. Outer $radiansToDegrees yields about 36.87°.
  4. One expression. No need to store the radian middle step.

Edge Cases & Pitfalls

Check these before using $radiansToDegrees in production pipelines.

unit

Input must already be radians

Passing a degree value (like 90) does not “fix” units—it multiplies by 180/π again and produces a wrong number.

null

Null or missing → null

Missing fields return null, not 0. Handle them before conversion if nulls are invalid.

range

No automatic wrap to 0–360

Large or negative radians convert linearly. Normalize yourself if you need a wrapped compass bearing.

pair

Use the inverse carefully

Going degrees → radians uses $degreesToRadians, not this operator.

Performance Notes

ApproachCostBest for
$radiansToDegrees aloneCheap per documentDisplay / reporting fields
Nested with trigStill lightweightOne-step degree angles from $acos
Store degrees on writeWrite cost, cheaper readsVery frequent degree queries

Conversion is a simple multiply—cheap compared with large sorts or joins. Filter early with $match when only some documents need degrees. Keep radians for math stages and convert late when humans need degrees.

Key Takeaways

  • Role: radians → degrees.
  • Formula: × 180 / π.
  • Common pair: $acos / $atan then convert.
  • Inverse: $degreesToRadians.

One line: $radiansToDegrees answers “what is this radian angle in degrees?”

Frequently Asked Questions

$radiansToDegrees converts an angle from radians to degrees. Use it when trig operators return radians but you want human-readable degree values for display or reports.
The syntax is { $radiansToDegrees: <expression> }. The expression can be a field path like "$angle_rad", a literal number, or another numeric expression such as { $acos: 0.8 }.
degrees = radians × (180 / π). For example, π radians becomes 180°, and π/2 radians becomes 90°.
$degreesToRadians converts degrees to radians. The two operators are inverses.
If the argument is null or refers to a missing field, $radiansToDegrees returns null. NaN stays NaN; ±Infinity stay ±Infinity.
Trig operators like $acos and $atan return radians. Wrap them with $radiansToDegrees when you want degrees.

Next: $rand

Generate a random floating-point number in an aggregation pipeline.

$rand tutorial →

About the author

Mari Selvan M P
Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

  • Experience 12 years building web and cloud systems
  • Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

9 people found this page helpful