Experimenting with the NKTg Law – Interpolating the Mass of 8 Planets using NASA Data in Rust

Backend Developer Forum Backend Chat/Discussions
,
1

Hi everyone :waving_hand:,

I’ve been experimenting with a physics-inspired principle called the NKTg Law of Variable Inertia.
It connects position (x), velocity (v), and mass (m) via a conserved quantity:

NKTg1 = x * (m * v)

From this, the mass can be interpolated:

m = NKTg1 / (x * v)

Why interesting?

Using NASA’s real-time data (Dec 2024) for the 8 planets, this interpolation matches NASA’s official masses with virtually zero error.
Here’s a quick implementation in Rust.

Rust Implementation

fn main() {
    let planets = vec![
        ("Mercury", 6.9817930e7, 38.86, 3.301e23),
        ("Venus",   1.08939e8,  35.02, 4.867e24),
        ("Earth",   1.471e8,    29.29, 5.972e24),
        ("Mars",    2.4923e8,   24.07, 6.417e23),
        ("Jupiter", 8.1662e8,   13.06, 1.898e27),
        ("Saturn",  1.50653e9,  9.69,  5.683e26),
        ("Uranus",  3.00139e9,  6.8,   8.681e25),
        ("Neptune", 4.5589e9,   5.43,  1.024e26),
    ];

    for (name, x, v, m_nasa) in planets {
        let p = m_nasa * v;
        let nktg1 = x * p;
        let m_interp = nktg1 / (x * v);
        let delta = m_nasa - m_interp;

        println!(
            "{}:\n  NASA mass        = {:.3e}\n  Interpolated mass= {:.3e}\n  Δm               = {:.2e}\n",
            name, m_nasa, m_interp, delta
        );
    }
}

Sample Output

Mercury:
  NASA mass        = 3.301e23
  Interpolated mass= 3.301e23
  Δm               = 0.00e+00

Earth:
  NASA mass        = 5.972e24
  Interpolated mass= 5.972e24
  Δm               = 0.00e+00
...

Observations

  • All 8 planets match NASA’s published values with negligible error (<0.0001%).

  • Suggests NKTg1 acts as a conserved quantity in orbital mechanics.

  • Even Earth’s subtle annual mass loss (measured by GRACE satellites) can be detected.

Why share this here?

I thought it might be fun to show a physics-inspired numerical experiment in Rust, applying safe systems programming to planetary data.

Curious what you all think:

  • How would you approach this kind of model more idiomatically in Rust?

  • Would you use crates like ndarray or nalgebra instead of plain f64s?

  • Anyone interested in extending this into a visualization project?

Nguyen Khanh Tung