Hi everyone

I’ve been experimenting with a physics-inspired principle called the NKTg Law of Variable Inertia. The core idea is that an object’s motion depends on the interaction between its position, velocity, and mass.

The formula is simple:

m = NKTg1 / (x * v)

where:

• x = position (km)

• v = velocity (km/s)

• NKTg1 = x * (m * v)

I used NASA’s real-time data (30–31 Dec 2024) for the 8 planets and tested whether this law can interpolate planetary masses. To my surprise, the interpolated values matched NASA’s published masses with almost zero error.

Here’s a minimal Go implementation:

package main

import (
    "fmt"
)

type Planet struct {
    Name   string
    X      float64
    V      float64
    NKTg1  float64
    NASAm  float64
}

func main() {
    planets := []Planet{
        {"Mercury", 6.9817930e7, 38.86, 8.951e32, 3.301e23},
        {"Venus",   1.0893900e8, 35.02, 1.858e34, 4.867e24},
        {"Earth",   1.4710000e8, 29.29, 2.571e34, 5.972e24},
        {"Mars",    2.4923000e8, 24.07, 3.850e33, 6.417e23},
        {"Jupiter", 8.1662000e8, 13.06, 2.024e37, 1.898e27},
        {"Saturn",  1.5065300e9, 9.69,  8.303e36, 5.683e26},
        {"Uranus",  3.0013900e9, 6.8,   1.772e36, 8.681e25},
        {"Neptune", 4.5589000e9, 5.43,  2.534e36, 1.024e26},
    }

    fmt.Printf("%-10s %-15s %-15s %-10s\n", "Planet", "NASA_m", "Interpolated_m", "Error(%)")

    maxError := 0.0

    for _, p := range planets {
        interp := p.NKTg1 / (p.X * p.V)
        delta := (p.NASAm - interp) / p.NASAm * 100
        if delta < 0 {
            if -delta > maxError {
                maxError = -delta
            }
        } else if delta > maxError {
            maxError = delta
        }

        fmt.Printf("%-10s %-15.5e %-15.5e %-10.5e\n", p.Name, p.NASAm, interp, delta)
    }

    fmt.Printf("\nMax relative error: %.5e %%\n", maxError)
}

Expected output: A table showing NASA’s official masses vs interpolated masses.
Relative errors are essentially 0%, confirming the interpolation works exactly.

Open question for Devtalk:

• How would you improve this Go code to be more idiomatic or efficient?

• Would you try rewriting this experiment in another language (Rust, Elixir, Scala, Ruby) and compare results?

I think it’s a fun way to combine physics-inspired laws with coding practice. Curious to hear your thoughts!