C, C++, MFC  

Simulating the NKTg Law on Varying Inertia Using C#

📘 Introduction

In classical physics, motion is usually analyzed under the assumption of constant mass. But what happens when an object's mass varies over time — such as rockets losing fuel, comets shedding material, or artificial systems consuming energy?

To explore that, I introduce the NKTg Law on Varying Inertia — a simple but powerful framework for simulating motion when mass is not constant. In this article, we'll explore the theory and show how to simulate it using C#.

🧠 The NKTg Law: Concept

The motion tendency of an object is modeled using the relationship between:

  • x: Position

  • v: Velocity

  • m: Mass

The momentum p is defined as usual:

p = m × v

From there, we define two quantities:

NKTg₁ = x × p NKTg₂ = (dm/dt) × p

Where:

  • NKTg₁ captures how position and momentum affect motion.

  • NKTg₂ measures how the rate of mass change influences that motion.

These quantities are expressed in a unit we call NKTm (unit of varying inertia).

🔍 Interpreting the Values

The signs of NKTg₁ and NKTg₂ give insight into the system's dynamics:

Quantity Meaning
NKTg₁ > 0 Object tends to move away from stable state
NKTg₁ < 0 Object tends to return to stable state
NKTg₂ > 0 Mass variation supports motion
NKTg₂ < 0 Mass variation resists motion

A stable state means position, velocity, and mass are balanced so that the object maintains its motion structure.

💻 C# Implementation

Here's a simple simulation of an object using the NKTg model in C#:

using System;
public struct Body {
  public float x;
  // Position (meters) 
  public float v;
  // Velocity (m/s) 
  public float m;
  // Mass (kg) 
  public float dm_dt;
  // Rate of mass change (kg/s) 
}
class Program {
  static void SimulateNKTg(Body b) {
    float p = b.m * b.v;
    float NKTg1 = b.x * p;
    float NKTg2 = b.dm_dt * p;
    Console.WriteLine($ "p = {p:F2} kg·m/s");
    Console.WriteLine($ "NKTg₁ = {NKTg1:F2} → {(NKTg1 > 0 ? "
    Moving away from stability " : "
    Moving toward stability ")}");
    Console.WriteLine($ "NKTg₂ = {NKTg2:F2} → {(NKTg2 > 0 ? "
    Mass supports motion " : "
    Mass resists motion ")}");
  }
  static void Main() {
    Body asteroid = new Body {
      x = 5000,
      // meters from a reference point 
      v = 100,
      // m/s 
      m = 1500,
      // kg 
      dm_dt = -2
      // kg/s (mass loss, e.g., comet shedding gas) 
    };
    SimulateNKTg(asteroid);
  }
}

🧪 Sample Output

p = 150000.00 kg·m/s NKTg₁ = 750000000.00 → Moving away from stability NKTg₂ = -300000.00 → Mass resists motion

🔬 Applications

This model can be applied in:

  • Astrophysics: Comets, asteroids, solar mass loss

  • Rocket science: Engines with mass ejection

  • Game physics: Dynamic mass systems in Unity

  • Custom physics simulations in C#/.NET environments

📌 Conclusion

The NKTg Law offers a simple yet insightful approach to modeling objects with variable mass. When implemented in C#, it becomes a useful tool for educational simulations, scientific prototypes, and even physics-based games.

🙋 Feedback Welcome

Do you think this law could be useful in your simulations or research? Let me know in the comments or contribute to the GitHub project.

Membership not found