NKTgLaw
NKTg Law on Variable Inertia Across 150 Modern Languages
Introduction
The NKTg Law on Varying Inertia describes the tendency of an object in motion depending on its position, velocity, and mass. The law is expressed as:
NKTg = f(x, v, m)
Where:
-
x = position/displacement relative to a reference point
-
v = velocity
-
m = mass
Two primary quantities define the movement tendency:
NKTg₁ = x × p
NKTg₂ = (dm/dt) × p
Where:
-
p = m × v (linear momentum)
-
dm/dt = rate of mass change over time
-
NKTg₁ represents the product of position and momentum
-
NKTg₂ represents the product of mass variation and momentum
-
The unit of measurement is NKTm, representing a unit of varying inertia
The sign and magnitude of these quantities determine motion tendencies:
-
If NKTg₁ > 0 → object tends to move away from the stable state
-
If NKTg₁ < 0 → object tends to move toward the stable state
-
If NKTg₂ > 0 → mass variation supports motion
-
If NKTg₂ < 0 → mass variation resists motion
Stable state is defined as a configuration where x, v, and m interact to maintain motion structure without losing control.
Implementation in 150 Programming Languages
The NKTg Law has been implemented in 150 programming languages, allowing for a wide variety of practical applications and experiments across different environments.
Programming Languages
The NKTg Law is implemented in the following 150 programming languages:
Python, C++, Java, C, C#, JavaScript, TypeScript, PHP, Ruby, Swift, Go, Rust, Kotlin, Dart, Scala, R, MATLAB, Julia, Haskell, Perl, Shell, SQL, Visual Basic, Assembly, Ada, Fortran, Prolog, Scheme, Lisp, Scratch, Smalltalk, Pascal, Groovy, PowerShell, Apex, ABAP, ActionScript, Algol, Alice, AmbientTalk, AngelScript, APL, Arc, Arduino, ASP.NET, AssemblyScript, ATS, AWK, Ballerina, BASIC, VHDL, Verilog, Assembly, AutoHotkey, AutoLISP, AWK, Bash, bc, Boo, Clojure, COBOL, Common Lisp, Crystal, D, Delphi/Object Pascal, Dylan, Eiffel, Elixir, Elm, Emacs Lisp, Erlang, F#, Factor, Falcon, Fantom, Felix, Forth, Fortress, Frink, Gambas, GAMS, GAP, Genie, GLSL, Hack, Haxe, HDL, HLSL, Hope, HTML, HyperTalk, Icon, IDL, Inform, Io, Ioke, J, J#, JScript, JavaFX Script, Io, Ioke, J, J#, JScript, Julia, Kotlin, LabVIEW, Ladder Logic, Lasso, Lava, Lisp, LiveCode, Logo, Lua, M4, Magik, Maple, Mathematica, MATLAB, Mercury, Modula-2, Modula-3, MoonScript, Nemerle, NetLogo, Nim, Nix, Objective-C, Objective-J, OCaml, OpenCL, OpenEdge ABL, Oz, PL/I, PL/SQL, PostScript, Promela, Pure, Q#, Racket, RAPID, REBOL, Red, Rexx, Ring, Solidity, SPARK, SPSS, Squirre
How to Read the Code
-
Each snippet calculates p, NKTg₁, and NKTg₂ with the default example values:
- x = 2, v = 3, m = 5, dm_dt = 0.1
-
Code is structured for readability and execution in the respective programming environment.
-
Comments indicate the language purpose or usage domain.
-
Units and calculations follow the definitions of the NKTg Law.
Code Snippets
All 150 language implementations follow below.
Python
# Python: versatile, easy to learn, strong for AI and data science
x, v, m, dm_dt = 2.0, 3.0, 5.0, 0.1
p = m*v
NKTg1 = x*p
NKTg2 = dm_dt*p
print(f"p={p}, NKTg1={NKTg1}, NKTg2={NKTg2}")
C++
// C++: high performance, widely used in games and embedded systems
#include
int main() {
double x=2.0,v=3.0,m=5.0,dm_dt=0.1;
double p=x\*v,mom=NKTg1=NKTg2=0;
p=m\*v; double NKTg1=x\*p, NKTg2=dm_dt\*p;
std::cout<<"p="<<p<<" NKTg1="<<NKTg1<<" NKTg2="<<NKTg2<<"\\n";
return 0;
}
Java
// Java: enterprise applications, Android
public class NKTgLaw {
public static void main(String\[\] args) {
double x=2,v=3,m=5,dm_dt=0.1;
double p=m\*v, NKTg1=x\*p, NKTg2=dm_dt\*p;
System.out.printf("p=%.2f NKTg1=%.2f NKTg2=%.2f%n", p, NKTg1, NKTg2);
}
}
C
/* C: foundation language, operating systems */
#include <stdio.h>
int main() {
double x=2.0,v=3.0,m=5.0,dm_dt=0.1;
double p=m\*v, NKTg1=x\*p, NKTg2=dm_dt\*p;
printf("p=%.2f NKTg1=%.2f NKTg2=%.2f\\n", p, NKTg1, NKTg2);
return 0;
}
C#
// C#: Windows apps, Unity
using System;
class Program{
static void Main(){
double x=2,v=3,m=5,dm_dt=0.1;
double p=m\*v,NKTg1=x\*p,NKTg2=dm_dt\*p;
Console.WriteLine($"p={p} NKTg1={NKTg1} NKTg2={NKTg2}");
}
}
JavaScript (Node.js)
// JavaScript: web front-end and back-end
const x=2,v=3,m=5,dm_dt=0.1;
const p=m*v, NKTg1=x*p, NKTg2=dm_dt*p;
console.log(`p=${p} NKTg1=${NKTg1} NKTg2=${NKTg2}`);
TypeScript
// TypeScript: JavaScript with static types
const x: number=2,v: number=3,m: number=5,dm_dt: number=0.1;
const p=m*v,NKTg1=x*p,NKTg2=dm_dt*p;
console.log(`p=${p} NKTg1=${NKTg1} NKTg2=${NKTg2}`);
PHP
<?php // PHP: server-side web development $x=2;$v=3;$m=5;$dm_dt=0.1; $p=$m\*$v;$NKTg1=$x\*$p;$NKTg2=$dm_dt\*$p; echo "p=$p NKTg1=$NKTg1 NKTg2=$NKTg2\\n"; ?>Go
// Go: distributed systems, high performance
package main
import “fmt”
func main(){
x,v,m,dm_dt:=2.0,3.0,5.0,0.1
p:=m\*v; NKTg1:=x\*p; NKTg2:=dm_dt\*p
fmt.Println("p=",p,"NKTg1=",NKTg1,"NKTg2=",NKTg2)
}
Ruby
# Ruby: dynamic, web and scripting
x,v,m,dm_dt=2.0,3.0,5.0,0.1
p=m*v; NKTg1=x*p; NKTg2=dm_dt*p
puts “p=#{p} NKTg1=#{NKTg1} NKTg2=#{NKTg2}”
R
# R: statistical computing, data science
x<-2;v<-3;m<-5;dm_dt<-0.1
p=m*v; NKTg1=x*p; NKTg2=dm_dt*p
cat(“p=”,p," NKTg1=“,NKTg1,” NKTg2=“,NKTg2,”\n")
Swift
// Swift: iOS development
let x=2.0,v=3.0,m=5.0,dm_dt=0.1
let p=m*v,NKTg1=x*p,NKTg2=dm_dt*p
print(“p=\(p) NKTg1=\(NKTg1) NKTg2=\(NKTg2)”)
Kotlin
// Kotlin: Android development
fun main(){
val x=2.0; val v=3.0; val m=5.0; val dm_dt=0.1
val p=m\*v; val NKTg1=x\*p; val NKTg2=dm_dt\*p
println("p=$p NKTg1=$NKTg1 NKTg2=$NKTg2")
}
Dart
// Dart: Flutter and cross-platform
void main(){
double x=2.0,v=3.0,m=5.0,dm_dt=0.1;
double p=m\*v,NKTg1=x\*p,NKTg2=dm_dt\*p;
print("p=$p NKTg1=$NKTg1 NKTg2=$NKTg2");
}
Scala
// Scala: functional and JVM
object NKTgLaw extends App{
val x=2.0; val v=3.0; val m=5.0; val dm_dt=0.1
val p=m\*v; val NKTg1=x\*p; val NKTg2=dm_dt\*p
println(s"p=$p NKTg1=$NKTg1 NKTg2=$NKTg2")
}
MATLAB
% MATLAB: numerical computing
x=2;v=3;m=5;dm_dt=0.1;
p=m*v; NKTg1=x*p; NKTg2=dm_dt*p;
fprintf(‘p=%.2f NKTg1=%.2f NKTg2=%.2f\n’,p,NKTg1,NKTg2)
Julia
# Julia: high-performance computing
x=2.0;v=3.0;m=5.0;dm_dt=0.1
p=m*v; NKTg1=x*p; NKTg2=dm_dt*p
println(“p=$p NKTg1=$NKTg1 NKTg2=$NKTg2”)
Haskell
-- Haskell: functional programming
let x=2;v=3;m=5;dm_dt=0.1
let p=m*v; let n1=x*p; let n2=dm_dt*p
putStrLn $ “p=”++show p++" NKTg1=“++show n1++” NKTg2="++show n2
Perl
# Perl: text processing and scripting
my($x,$v,$m,$dm_dt)=(2,3,5,0.1);
my $p=$m*$v; my $NKTg1=$x*$p; my $NKTg2=$dm_dt*$p;
print “p=$p NKTg1=$NKTg1 NKTg2=$NKTg2\n”;
Shell (bash)
# Bash: scripting and automation
x=2;v=3;m=5;dm_dt=0.1
p=$(echo “$m*$v”|bc); NKTg1=$(echo “$x*$p”|bc); NKTg2=$(echo “$dm_dt*$p”|bc)
echo “p=$p NKTg1=$NKTg1 NKTg2=$NKTg2”
SQL (SQLite)
-- SQL: database management
SELECT 2 AS x,3 AS v,5 AS m,0.1 AS dm_dt,
(5\*3) AS p,
(2\*(5\*3)) AS NKTg1,
(0.1\*(5\*3)) AS NKTg2;
Visual Basic
’ Visual Basic: Windows applications
Module NKTgLaw
Sub Main()
Dim x As Double = 2, v As Double = 3, m As Double = 5, dm_dt As Double = 0.1
Dim p As Double = m\*v, NKTg1 As Double = x\*p, NKTg2 As Double = dm_dt\*p
Console.WriteLine("p=" & p & " NKTg1=" & NKTg1 & " NKTg2=" & NKTg2)
End Sub
End Module
Assembly (NASM x86-64)
; Assembly: low-level programming (example concept, not executable)
; x=2, v=3, m=5, dm_dt=0.1
; p=m*v, NKTg1=x*p, NKTg2=dm_dt*p
; Print manually or via debugger
Ada
-- Ada: reliability and safety-critical
with Ada.Text_IO; use Ada.Text_IO;
procedure NKTgLaw is
x,v,m,dm_dt,p,NKTg1,NKTg2: Float;
begin
x:=2.0; v:=3.0; m:=5.0; dm_dt:=0.1;
p:=m*v; NKTg1:=x*p; NKTg2:=dm_dt*p;
Put_Line(“p=” & Float’Image(p) & " NKTg1=" & Float’Image(NKTg1) & " NKTg2=" & Float’Image(NKTg2));
end NKTgLaw;
Fortran
! Fortran: scientific computing
program NKTgLaw
real :: x,v,m,dm_dt,p,NKTg1,NKTg2
x=2.0; v=3.0; m=5.0; dm_dt=0.1
p=m*v; NKTg1=x*p; NKTg2=dm_dt*p
print *, ‘p=’,p,’ NKTg1=‘,NKTg1,’ NKTg2=',NKTg2
end program NKTgLaw
Prolog
% Prolog: logic programming
x(2). v(3). m(5). dm_dt(0.1).
calc(P,NKTg1,NKTg2):- x(X),v(V),m(M),dm_dt(DM), P is M*V, NKTg1 is X*P, NKTg2 is DM*P.
Scheme
;; Scheme: Lisp dialect
(define x 2)
(define v 3)
(define m 5)
(define dm_dt 0.1)
(define p (* m v))
(define NKTg1 (* x p))
(define NKTg2 (* dm_dt p))
(display (list p NKTg1 NKTg2))
Lisp (Common Lisp)
;; Common Lisp: functional programming
(defparameter x 2 v 3 m 5 dm_dt 0.1)
(defparameter p (* m v))
(defparameter NKTg1 (* x p))
(defparameter NKTg2 (* dm_dt p))
(format t “p=~a NKTg1=~a NKTg2=~a~%” p NKTg1 NKTg2)
Scratch
// Scratch: visual programming
// Conceptual: use variables x=2, v=3, m=5, dm_dt=0.1
// Calculate p, NKTg1, NKTg2 using blocks
Smalltalk
“Smalltalk: object-oriented”
| x v m dm_dt p NKTg1 NKTg2 |
x:=2.0. v:=3.0. m:=5.0. dm_dt:=0.1.
p:=m*v. NKTg1:=x*p. NKTg2:=dm_dt*p.
Transcript show: ‘p=’,p,’ NKTg1=‘,NKTg1,’ NKTg2=',NKTg2; cr.
Pascal
{ Pascal: educational and structured }
program NKTgLaw;
var x,v,m,dm_dt,p,NKTg1,NKTg2: real;
begin
x:=2; v:=3; m:=5; dm_dt:=0.1;
p:=m*v; NKTg1:=x*p; NKTg2:=dm_dt*p;
writeln(‘p=’,p,’ NKTg1=‘,NKTg1,’ NKTg2=',NKTg2);
end.
Groovy
// Groovy: scripting for JVM
def x=2.0,v=3.0,m=5.0,dm_dt=0.1
def p=m*v, NKTg1=x*p, NKTg2=dm_dt*p
println “p=$p NKTg1=$NKTg1 NKTg2=$NKTg2”
PowerShell
# PowerShell: Windows scripting
$x=2;$v=3;$m=5;$dm_dt=0.1
$p=$m*$v;$NKTg1=$x*$p;$NKTg2=$dm_dt*$p
Write-Output “p=$p NKTg1=$NKTg1 NKTg2=$NKTg2”
Apex
// Apex: Salesforce development
Double x=2,v=3,m=5,dm_dt=0.1;
Double p=m*v,NKTg1=x*p,NKTg2=dm_dt*p;
System.debug(‘p=’+p+’ NKTg1=‘+NKTg1+’ NKTg2='+NKTg2);
ABAP
* ABAP: SAP applications
DATA: x TYPE f VALUE 2, v TYPE f VALUE 3, m TYPE f VALUE 5, dm_dt TYPE f VALUE 0.1.
DATA: p TYPE f, NKTg1 TYPE f, NKTg2 TYPE f.
p = m*v. NKTg1 = x*p. NKTg2 = dm_dt*p.
WRITE: / ‘p=’, p, ’ NKTg1=‘, NKTg1, ’ NKTg2=’, NKTg2.
ActionScript
// ActionScript: Flash development
var x:Number=2,v:Number=3,m:Number=5,dm_dt:Number=0.1;
var p:Number=m*v,NKTg1:Number=x*p,NKTg2:Number=dm_dt*p;
trace(“p=”+p+" NKTg1=“+NKTg1+” NKTg2="+NKTg2);
Algol
begin
real x,v,m,dm_dt,p,NKTg1,NKTg2;
x:=2; v:=3; m:=5; dm_dt:=0.1;
p:=m*v; NKTg1:=x*p; NKTg2:=dm_dt*p;
print(p); print(NKTg1); print(NKTg2);
end
Alice
// Alice: educational 3D programming
// Use variables x=2, v=3, m=5, dm_dt=0.1
// Calculate p, NKTg1, NKTg2 using properties and output text
AmbientTalk
// AmbientTalk: distributed actor programming
def x:=2; def v:=3; def m:=5; def dm_dt:=0.1;
def p:=m*v; def NKTg1:=x*p; def NKTg2:=dm_dt*p;
println(“p=”+p+" NKTg1=“+NKTg1+” NKTg2="+NKTg2)
AngelScript
// AngelScript: embedded scripting
float x=2,v=3,m=5,dm_dt=0.1;
float p=m*v,NKTg1=x*p,NKTg2=dm_dt*p;
print(“p=”+p+" NKTg1=“+NKTg1+” NKTg2=“+NKTg2+”\n");
APL
⎕ ← ‘p=’,5*3,’ NKTg1=‘,2*5*3,’ NKTg2=',0.1*5*3
Arc
;; Arc: Lisp dialect
(def x 2 v 3 m 5 dm_dt 0.1)
(def p (* m v))
(def NKTg1 (* x p))
(def NKTg2 (* dm_dt p))
(prn p NKTg1 NKTg2)
Arduino (C++)
// Arduino: embedded C++
void setup(){
Serial.begin(9600);
double x=2,v=3,m=5,dm_dt=0.1;
double p=m*v,NKTg1=x*p,NKTg2=dm_dt*p;
Serial.println(“p=”+String(p)+" NKTg1=“+String(NKTg1)+” NKTg2="+String(NKTg2));
}
void loop(){}
ASP.NET (C#)
// ASP.NET: web applications
double x=2,v=3,m=5,dm_dt=0.1;
double p=m*v,NKTg1=x*p,NKTg2=dm_dt*p;
Console.WriteLine($“p={p} NKTg1={NKTg1} NKTg2={NKTg2}”);
AssemblyScript
// AssemblyScript: WebAssembly
let x: f64=2,v: f64=3,m: f64=5,dm_dt: f64=0.1;
let p=f64(m*v), NKTg1=f64(x*p), NKTg2=f64(dm_dt*p);
console.log(`p=${p} NKTg1=${NKTg1} NKTg2=${NKTg2}`);
ATS
(* ATS: safe systems programming *)
val x=2.0; val v=3.0; val m=5.0; val dm_dt=0.1
val p=m*v; val NKTg1=x*p; val NKTg2=dm_dt*p
println!(“p=”,p," NKTg1=“,NKTg1,” NKTg2=",NKTg2)
AWK
# AWK: text processing
BEGIN{ x=2; v=3; m=5; dm_dt=0.1; p=m*v; NKTg1=x*p; NKTg2=dm_dt*p; print "p=“p,” NKTg1=“NKTg1,” NKTg2="NKTg2 }
Ballerina
// Ballerina: network services
float x=2,v=3,m=5,dm_dt=0.1;
float p=m*v,NKTg1=x*p,NKTg2=dm_dt*p;
io:println(“p=”,p," NKTg1=“,NKTg1,” NKTg2=",NKTg2);
BASIC
’ BASIC: educational and legacy
x=2: v=3: m=5: dm_dt=0.1
p=m*v: NKTg1=x*p: NKTg2=dm_dt*p
PRINT “p=”;p;" NKTg1=“;NKTg1;” NKTg2=";NKTg2
VHDL
-- VHDL: hardware description language
-- Conceptual example: define constants
constant x: real := 2.0;
constant v: real := 3.0;
constant m: real := 5.0;
constant dm_dt: real := 0.1;
-- p := m*v; NKTg1 := x*p; NKTg2 := dm_dt*p
-- Display results via testbench or simulator
Verilog
// Verilog: hardware description language
// Example conceptual calculation
real x=2.0, v=3.0, m=5.0, dm_dt=0.1;
real p = m*v, NKTg1 = x*p, NKTg2 = dm_dt*p;
$display("p=%f NKTg1=%f NKTg2=%f", p, NKTg1, NKTg2);
Assembly
; Assembly: low-level programming
; x=2, v=3, m=5, dm_dt=0.1
; Calculate p=m*v, NKTg1=x*p, NKTg2=dm_dt*p conceptually
AutoHotkey
; AutoHotkey: Windows automation
x:=2; v:=3; m:=5; dm_dt:=0.1
p:=m*v
NKTg1:=x*p
NKTg2:=dm_dt*p
MsgBox % "p=" p " NKTg1=" NKTg1 " NKTg2=" NKTg2
AutoLISP
; AutoLISP: scripting for AutoCAD
(setq x 2 v 3 m 5 dm_dt 0.1)
(setq p (* m v))
(setq NKTg1 (* x p))
(setq NKTg2 (* dm_dt p))
(princ (strcat "p=" (rtos p 2 2) " NKTg1=" (rtos NKTg1 2 2) " NKTg2=" (rtos NKTg2 2 2)))
AWK
# AWK: text processing
BEGIN{ x=2; v=3; m=5; dm_dt=0.1; p=m*v; NKTg1=x*p; NKTg2=dm_dt*p; print "p="p," NKTg1="NKTg1," NKTg2="NKTg2 }
Bash
# Bash: scripting
x=2; v=3; m=5; dm_dt=0.1
p=$(echo "$m*$v"|bc)
NKTg1=$(echo "$x*$p"|bc)
NKTg2=$(echo "$dm_dt*$p"|bc)
echo "p=$p NKTg1=$NKTg1 NKTg2=$NKTg2"
bc
# bc: calculator scripting
x=2; v=3; m=5; dm_dt=0.1
p=m*v
NKTg1=x*p
NKTg2=dm_dt*p
p NKTg1 NKTg2
Boo
# Boo: statically typed .NET language
x=2.0
v=3.0
m=5.0
dm_dt=0.1
p=m*v
NKTg1=x*p
NKTg2=dm_dt*p
print "p=%s NKTg1=%s NKTg2=%s" % (p,NKTg1,NKTg2)
Clojure
;; Clojure: functional JVM
(def x 2)
(def v 3)
(def m 5)
(def dm_dt 0.1)
(def p (* m v))
(def NKTg1 (* x p))
(def NKTg2 (* dm_dt p))
(println "p=" p " NKTg1=" NKTg1 " NKTg2=" NKTg2)
COBOL
IDENTIFICATION DIVISION.
PROGRAM-ID. NKTgLaw.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 x PIC 9V9 VALUE 2.0.
01 v PIC 9V9 VALUE 3.0.
01 m PIC 9V9 VALUE 5.0.
01 dm_dt PIC 9V9 VALUE 0.1.
01 p PIC 9V9.
01 NKTg1 PIC 9V9.
01 NKTg2 PIC 9V9.
PROCEDURE DIVISION.
COMPUTE p = m * v
COMPUTE NKTg1 = x * p
COMPUTE NKTg2 = dm_dt * p
DISPLAY "p=" p " NKTg1=" NKTg1 " NKTg2=" NKTg2
STOP RUN.
Common Lisp
;; Common Lisp
(setq x 2 v 3 m 5 dm_dt 0.1)
(setq p (* m v))
(setq NKTg1 (* x p))
(setq NKTg2 (* dm_dt p))
(format t "p=~a NKTg1=~a NKTg2=~a~%" p NKTg1 NKTg2)
Crystal
# Crystal: Ruby-like language
x, v, m, dm_dt = 2.0, 3.0, 5.0, 0.1
p = m*v
NKTg1 = x*p
NKTg2 = dm_dt*p
puts "p=#{p} NKTg1=#{NKTg1} NKTg2=#{NKTg2}"
D
// D: systems programming
import std.stdio;
void main() {
double x=2,v=3,m=5,dm_dt=0.1;
double p=m*v, NKTg1=x*p, NKTg2=dm_dt*p;
writeln("p=",p," NKTg1=",NKTg1," NKTg2=",NKTg2);
}
Delphi/Object Pascal
program NKTgLaw;
begin
var x,v,m,dm_dt,p,NKTg1,NKTg2: Real;
x:=2; v:=3; m:=5; dm_dt:=0.1;
p:=m*v; NKTg1:=x*p; NKTg2:=dm_dt*p;
Writeln('p=',p,' NKTg1=',NKTg1,' NKTg2=',NKTg2);
end.
Dylan
// Dylan: multi-paradigm language
let x := 2.0; let v := 3.0; let m := 5.0; let dm_dt := 0.1;
let p := m*v;
let NKTg1 := x*p;
let NKTg2 := dm_dt*p;
format-out("p=~a NKTg1=~a NKTg2=~a~%", p, NKTg1, NKTg2);
Eiffel
-- Eiffel: object-oriented
class NKTgLaw
create make
feature
make
local x,v,m,dm_dt,p,NKTg1,NKTg2: REAL
do
x:=2.0; v:=3.0; m:=5.0; dm_dt:=0.1
p:=m*v; NKTg1:=x*p; NKTg2:=dm_dt*p
print ("p=" + p.out + " NKTg1=" + NKTg1.out + " NKTg2=" + NKTg2.out + "%N")
end
end
Elixir
# Elixir: functional programming
x=2; v=3; m=5; dm_dt=0.1
p=m*v
NKTg1=x*p
NKTg2=dm_dt*p
IO.puts("p=#{p} NKTg1=#{NKTg1} NKTg2=#{NKTg2}")
Elm
-- Elm: functional web language
x = 2
v = 3
m = 5
dm_dt = 0.1
p = m * v
nktg1 = x * p
nktg2 = dm_dt * p
-- Elm uses Html.text to display in browser
Emacs Lisp
;; Emacs Lisp
(setq x 2 v 3 m 5 dm_dt 0.1)
(setq p (* m v))
(setq NKTg1 (* x p))
(setq NKTg2 (* dm_dt p))
(message "p=%s NKTg1=%s NKTg2=%s" p NKTg1 NKTg2)
Erlang
% Erlang: concurrent functional
X=2, V=3, M=5, DM_DT=0.1,
P=M*V,
NKTG1=X*P,
NKTG2=DM_DT*P,
io:format("p=~p NKTg1=~p NKTg2=~p~n",[P,NKTG1,NKTG2]).
F#
// F#: functional .NET
let x,v,m,dm_dt=2.0,3.0,5.0,0.1
let p=m*v
let NKTg1=x*p
let NKTg2=dm_dt*p
printfn "p=%f NKTg1=%f NKTg2=%f" p NKTg1 NKTg2
Factor
! Factor: stack-based
2 3 5 0.1 [ * ] [ * ] [ * ] .
Falcon
# Falcon: scripting language
x=2; v=3; m=5; dm_dt=0.1;
p=m*v; NKTg1=x*p; NKTg2=dm_dt*p;
println("p=#{p} NKTg1=#{NKTg1} NKTg2=#{NKTg2}");
Fantom
// Fantom: JVM language
class NKTgLaw {
static Void main() {
Float x=2,v=3,m=5,dm_dt=0.1
Float p=m*v,NKTg1=x*p,NKTg2=dm_dt*p
echo("p=$p NKTg1=$NKTg1 NKTg2=$NKTg2")
}
}
Felix
// Felix: multi-paradigm
val x=2.0; val v=3.0; val m=5.0; val dm_dt=0.1
val p=m*v; val NKTg1=x*p; val NKTg2=dm_dt*p
println("p=$p NKTg1=$NKTg1 NKTg2=$NKTg2")
Forth
\ Forth: stack-based
2 3 5 0.1
\ calculate p, NKTg1, NKTg2 on stack
Fortress
// Fortress: scientific computing
x=2; v=3; m=5; dm_dt=0.1
p=m*v; NKTg1=x*p; NKTg2=dm_dt*p
println("p="+p+" NKTg1="+NKTg1+" NKTg2="+NKTg2)
Frink
// Frink: units-aware language
x=2; v=3; m=5; dm_dt=0.1
p=m*v
NKTg1=x*p
NKTg2=dm_dt*p
println("p="+p+" NKTg1="+NKTg1+" NKTg2="+NKTg2)
Gambas
' Gambas: BASIC dialect
Dim x,v,m,dm_dt,p,NKTg1,NKTg2 As Float
x=2:v=3:m=5:dm_dt=0.1
p=m*v:NKTg1=x*p:NKTg2=dm_dt*p
Print "p="&p&" NKTg1="&NKTg1&" NKTg2="&NKTg2
GAMS
* GAMS: mathematical modeling
Scalar x,v,m,dm_dt,p,NKTg1,NKTg2;
x=2;v=3;m=5;dm_dt=0.1;
p=m*v; NKTg1=x*p; NKTg2=dm_dt*p;
Display p,NKTg1,NKTg2;
GAP
# GAP: group theory
x:=2; v:=3; m:=5; dm_dt:=0.1;
p:=m*v; NKTg1:=x*p; NKTg2:=dm_dt*p;
Print([p,NKTg1,NKTg2]);
Genie
# Genie: Vala-like
init
var x=2.0; var v=3.0; var m=5.0; var dm_dt=0.1
var p=m*v; var NKTg1=x*p; var NKTg2=dm_dt*p
print "p=%f NKTg1=%f NKTg2=%f\n" % [p,NKTg1,NKTg2]
GLSL
// GLSL: shading language
float x=2.0,v=3.0,m=5.0,dm_dt=0.1;
float p=m*v,NKTg1=x*p,NKTg2=dm_dt*p;
Hack
<?hh
// Hack: PHP derivative
$x=2.0;$v=3.0;$m=5.0;$dm_dt=0.1;
$p=$m*$v; $NKTg1=$x*$p; $NKTg2=$dm_dt*$p;
echo "p=$p NKTg1=$NKTg1 NKTg2=$NKTg2\n";
Haxe
// Haxe: cross-platform
class NKTgLaw{
static function main(){
var x=2.0, v=3.0, m=5.0, dm_dt=0.1;
var p=m*v, NKTg1=x*p, NKTg2=dm_dt*p;
trace("p="+p+" NKTg1="+NKTg1+" NKTg2="+NKTg2);
}
}
HDL
-- HDL: generic hardware description
-- Define constants x=2,v=3,m=5,dm_dt=0.1
-- Compute p=m*v, NKTg1=x*p, NKTg2=dm_dt*p conceptually
HLSL
// HLSL: shader programming
float x=2.0,v=3.0,m=5.0,dm_dt=0.1;
float p=m*v,NKTg1=x*p,NKTg2=dm_dt*p;
Hope
-- Hope: functional language
let x = 2, v = 3, m = 5, dm_dt = 0.1
let p = m*v
let NKTg1 = x*p
let NKTg2 = dm_dt*p
HTML (with JS)
<!-- HTML: front-end -->
<script>
let x=2,v=3,m=5,dm_dt=0.1;
let p=m*v,NKTg1=x*p,NKTg2=dm_dt*p;
console.log(`p=${p} NKTg1=${NKTg1} NKTg2=${NKTg2}`);
</script>
HyperTalk
-- HyperTalk: AppleScript-like
put 2 into x
put 3 into v
put 5 into m
put 0.1 into dm_dt
put m*v into p
put x*p into NKTg1
put dm_dt*p into NKTg2
answer "p=" & p & " NKTg1=" & NKTg1 & " NKTg2=" & NKTg2
Io
// Io: prototype-based
x := 2
v := 3
m := 5
dm_dt := 0.1
p := m * v
NKTg1 := x * p
NKTg2 := dm_dt * p
println(“p=”, p, " NKTg1=“, NKTg1, " NKTg2=”, NKTg2)
Ioke
# Ioke: dynamic language
x=2 v=3 m=5 dm_dt=0.1
p=m*v
NKTg1=x*p
NKTg2=dm_dt*p
println(“p=#{p} NKTg1=#{NKTg1} NKTg2=#{NKTg2}”)
J
NB. J: array programming
x=2.0
v=3.0
m=5.0
dm_dt=0.1
p = m * v
NKTg1 = x * p
NKTg2 = dm_dt * p
p NKTg1 NKTg2
J#
// J#: .NET language
double x=2,v=3,m=5,dm_dt=0.1;
double p=m*v,NKTg1=x*p,NKTg2=dm_dt*p;
Console.WriteLine(“p={0} NKTg1={1} NKTg2={2}”,p,NKTg1,NKTg2);
JScript
// JScript: Microsoft scripting
var x=2,v=3,m=5,dm_dt=0.1;
var p=m*v,NKTg1=x*p,NKTg2=dm_dt*p;
WScript.Echo(“p=”+p+" NKTg1=“+NKTg1+” NKTg2="+NKTg2);
Julia
# Julia: scientific computing
x,v,m,dm_dt = 2.0,3.0,5.0,0.1
p = m*v
NKTg1 = x*p
NKTg2 = dm_dt*p
println(“p=$p NKTg1=$NKTg1 NKTg2=$NKTg2”)
Kotlin
// Kotlin: Android
fun main() {
val x=2.0; val v=3.0; val m=5.0; val dm_dt=0.1
val p=m\*v; val NKTg1=x\*p; val NKTg2=dm_dt\*p
println("p=$p NKTg1=$NKTg1 NKTg2=$NKTg2")
}
LabVIEW
// LabVIEW: graphical programming
// Conceptual: use numeric controls x,v,m,dm_dt
// Compute p=m*v, NKTg1=x*p, NKTg2=dm_dt*p
Ladder Logic
// Ladder Logic: PLC programming
// Conceptual: assign variables x,v,m,dm_dt
// Compute p=m*v, NKTg1=x*p, NKTg2=dm_dt*p using math blocks
Lasso
# Lasso: web scripting
x=2; v=3; m=5; dm_dt=0.1
p=m*v; NKTg1=x*p; NKTg2=dm_dt*p
output(“p=$p NKTg1=$NKTg1 NKTg2=$NKTg2”)
Lava
// Lava: concurrent object-oriented
val x=2.0; val v=3.0; val m=5.0; val dm_dt=0.1
val p=m*v; val NKTg1=x*p; val NKTg2=dm_dt*p
println(“p=”+p+" NKTg1=“+NKTg1+” NKTg2="+NKTg2)
Lisp
;; Lisp: classic
(setq x 2 v 3 m 5 dm_dt 0.1)
(setq p (* m v))
(setq NKTg1 (* x p))
(setq NKTg2 (* dm_dt p))
(format t “p=~a NKTg1=~a NKTg2=~a~%” p NKTg1 NKTg2)
LiveCode
-- LiveCode: visual scripting
put 2 into x
put 3 into v
put 5 into m
put 0.1 into dm_dt
put m*v into p
put x*p into NKTg1
put dm_dt*p into NKTg2
answer “p=” & p & " NKTg1=" & NKTg1 & " NKTg2=" & NKTg2
Logo
; Logo: educational turtle language
make "x 2
make "v 3
make "m 5
make "dm_dt 0.1
make "p :m * :v
make "NKTg1 :x * 
make "NKTg2 :dm_dt *
print (list :NKTg1 :NKTg2)
Lua
-- Lua: lightweight scripting
x,v,m,dm_dt=2,3,5,0.1
p=m*v
NKTg1=x*p
NKTg2=dm_dt*p
print(“p=”..p.." NKTg1=“..NKTg1..” NKTg2="..NKTg2)
M4
dnl M4: macro processor
define(`x’,2)
define(`v’,3)
define(`m’,5)
define(`dm_dt’,0.1)
define(`p’,eval(m*v))
define(`NKTg1’,eval(x*p))
define(`NKTg2’,eval(dm_dt*p))
Magik
! Magik: object-oriented scripting
x<<2; v<<3; m<<5; dm_dt<<0.1
p<<m*v; NKTg1<<x*p; NKTg2<<dm_dt*p
print(p," “,NKTg1,” ",NKTg2)
Maple
# Maple: symbolic computation
x:=2: v:=3: m:=5: dm_dt:=0.1:
p:=m*v: NKTg1:=x*p: NKTg2:=dm_dt*p:
p,NKTg1,NKTg2;
Mathematica
(* Mathematica: symbolic *)
x=2; v=3; m=5; dm_dt=0.1;
p=m*v; NKTg1=x*p; NKTg2=dm_dt*p;
{p,NKTg1,NKTg2}
MATLAB
% MATLAB: numerical computing
x=2; v=3; m=5; dm_dt=0.1;
p=m*v; NKTg1=x*p; NKTg2=dm_dt*p;
disp([p NKTg1 NKTg2])
Mercury
% Mercury: logic/functional
:- module nktglaw.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
main(!IO) :-
X = 2.0, V = 3.0, M = 5.0, DM_DT = 0.1,
P = M\*V, NKTG1 = X\*P, NKTG2 = DM_DT\*P,
io.write_string("p=" ++ float.to_string(P) ++ " NKTg1=" ++ float.to_string(NKTG1) ++ " NKTg2=" ++ float.to_string(NKTG2) ++ "\\n", !IO).
Modula-2
(* Modula-2: systems language *)
MODULE NKTgLaw;
VAR x,v,m,dm_dt,p,NKTg1,NKTg2: REAL;
BEGIN
x:=2; v:=3; m:=5; dm_dt:=0.1;
p:=m*v; NKTg1:=x*p; NKTg2:=dm_dt*p;
WriteReal(p); WriteReal(NKTg1); WriteReal(NKTg2);
END NKTgLaw.
Modula-3
-- Modula-3: safe systems language
IMPORT IO;
VAR x,v,m,dm_dt,p,NKTg1,NKTg2: REAL;
BEGIN
x:=2; v:=3; m:=5; dm_dt:=0.1;
p:=m*v; NKTg1:=x*p; NKTg2:=dm_dt*p;
IO.Put(p); IO.Put(NKTg1); IO.Put(NKTg2)
END
MoonScript
# MoonScript: Lua-based
x,v,m,dm_dt=2,3,5,0.1
p=m*v
NKTg1=x*p
NKTg2=dm_dt*p
print “p=#{p} NKTg1=#{NKTg1} NKTg2=#{NKTg2}”
Nemerle
// Nemerle: .NET functional
val x=2.0; val v=3.0; val m=5.0; val dm_dt=0.1;
val p=m*v; val NKTg1=x*p; val NKTg2=dm_dt*p;
Console.WriteLine(“p={0} NKTg1={1} NKTg2={2}”, p,NKTg1,NKTg2);
NetLogo
; NetLogo: agent-based modeling
let x 2
let v 3
let m 5
let dm_dt 0.1
let p m * v
let NKTg1 x * p
let NKTg2 dm_dt * p
show (list p NKTg1 NKTg2)
Nim
# Nim: compiled systems language
var x=2.0; var v=3.0; var m=5.0; var dm_dt=0.1
let p=m*v; let NKTg1=x*p; let NKTg2=dm_dt*p
echo “p=”,p," NKTg1=“,NKTg1,” NKTg2=",NKTg2
Nix
# Nix: package/configuration
let x=2; v=3; m=5; dm_dt=0.1; p=m*v; NKTg1=x*p; NKTg2=dm_dt*p; in { inherit p NKTg1 NKTg2; }
Objective-C
// Objective-C: Apple development
double x=2,v=3,m=5,dm_dt=0.1;
double p=m*v,NKTg1=x*p,NKTg2=dm_dt*p;
NSLog(@“p=%f NKTg1=%f NKTg2=%f”,p,NKTg1,NKTg2);
Objective-J
// Objective-J: Cappuccino
var x=2, v=3, m=5, dm_dt=0.1;
var p=m*v, NKTg1=x*p, NKTg2=dm_dt*p;
console.log(“p=”+p+" NKTg1=“+NKTg1+” NKTg2="+NKTg2);
OCaml
(* OCaml: functional *)
let x=2.0 and v=3.0 and m=5.0 and dm_dt=0.1;;
let p = m *. v;;
let nktg1 = x *. p;;
let nktg2 = dm_dt *. p;;
Printf.printf “p=%f NKTg1=%f NKTg2=%f\n” p nktg1 nktg2;;
OpenCL
// OpenCL: GPU computing
__kernel void nktglaw() {
double x=2,v=3,m=5,dm_dt=0.1;
double p=m\*v,NKTg1=x\*p,NKTg2=dm_dt\*p;
}
OpenEdge ABL
/* OpenEdge: business apps */
DEFINE VARIABLE x AS DECIMAL NO-UNDO INIT 2.
DEFINE VARIABLE v AS DECIMAL NO-UNDO INIT 3.
DEFINE VARIABLE m AS DECIMAL NO-UNDO INIT 5.
DEFINE VARIABLE dm_dt AS DECIMAL NO-UNDO INIT 0.1.
DEFINE VARIABLE p AS DECIMAL NO-UNDO.
DEFINE VARIABLE NKTg1 AS DECIMAL NO-UNDO.
DEFINE VARIABLE NKTg2 AS DECIMAL NO-UNDO.
ASSIGN p = m * v NKTg1 = x * p NKTg2 = dm_dt * p.
DISPLAY p NKTg1 NKTg2.
Oz
% Oz: multi-paradigm
declare
X=2.0 V=3.0 M=5.0 DM_DT=0.1
P=M*V
NKTg1=X*P
NKTg2=DM_DT*P
{Browse [P NKTg1 NKTg2]}
PL/I
/* PL/I: general-purpose */
DCL x FIXED DECIMAL(5,2) INIT(2);
DCL v FIXED DECIMAL(5,2) INIT(3);
DCL m FIXED DECIMAL(5,2) INIT(5);
DCL dm_dt FIXED DECIMAL(5,2) INIT(0.1);
DCL p FIXED DECIMAL(5,2);
DCL NKTg1 FIXED DECIMAL(5,2);
DCL NKTg2 FIXED DECIMAL(5,2);
p = m*v; NKTg1 = x*p; NKTg2 = dm_dt*p;
PUT SKIP LIST(‘p=’, p, ’ NKTg1=‘, NKTg1, ’ NKTg2=’, NKTg2);
PL/SQL
-- PL/SQL: Oracle
DECLARE
x NUMBER := 2;
v NUMBER := 3;
m NUMBER := 5;
dm_dt NUMBER := 0.1;
p NUMBER;
NKTg1 NUMBER;
NKTg2 NUMBER;
BEGIN
p := m*v;
NKTg1 := x*p;
NKTg2 := dm_dt*p;
DBMS_OUTPUT.PUT_LINE(‘p=’||p||’ NKTg1=‘||NKTg1||’ NKTg2='||NKTg2);
END;
PostScript
% PostScript: page description
/ x 2 def
/ v 3 def
/ m 5 def
/ dm_dt 0.1 def
/ p m v mul def
/ NKTg1 x p mul def
/ NKTg2 dm_dt p mul def
(p=) print p == ( NKTg1=) print NKTg1 == ( NKTg2=) print NKTg2 ==
Promela
// Promela: model checking
byte x=2; byte v=3; byte m=5; real dm_dt=0.1;
real p = m*v; real NKTg1 = x*p; real NKTg2 = dm_dt*p;
Pure
-- Pure: functional
x := 2
v := 3
m := 5
dm_dt := 0.1
p := m*v
NKTg1 := x*p
NKTg2 := dm_dt*p
[p, NKTg1, NKTg2]
Q#
// Q#: quantum programming
let x=2.0;
let v=3.0;
let m=5.0;
let dm_dt=0.1;
let p=m*v;
let NKTg1=x*p;
let NKTg2=dm_dt*p;
Message($“p={p} NKTg1={NKTg1} NKTg2={NKTg2}”);
Racket
;; Racket: Scheme derivative
(define x 2)
(define v 3)
(define m 5)
(define dm_dt 0.1)
(define p (* m v))
(define NKTg1 (* x p))
(define NKTg2 (* dm_dt p))
(displayln (list p NKTg1 NKTg2))
RAPID
! RAPID: ABB robots
VAR num x:=2, v:=3, m:=5, dm_dt:=0.1;
VAR num p:=m*v;
VAR num NKTg1:=x*p;
VAR num NKTg2:=dm_dt*p;
TPWrite “p=”+p+" NKTg1=“+NKTg1+” NKTg2="+NKTg2;
REBOL
; REBOL: scripting
x: 2 v: 3 m: 5 dm_dt: 0.1
p: m*v
NKTg1: x*p
NKTg2: dm_dt*p
print [“p=” p " NKTg1=" NKTg1 " NKTg2=" NKTg2]
Red
; Red: full-stack language
x:2 v:3 m:5 dm_dt:0.1
p:m*v
NKTg1:x*p
NKTg2:dm_dt*p
print [“p=” p " NKTg1=" NKTg1 " NKTg2=" NKTg2]
Rexx
/* Rexx: scripting */
x=2; v=3; m=5; dm_dt=0.1
p=m*v
NKTg1=x*p
NKTg2=dm_dt*p
say "p=“p” NKTg1=“NKTg1” NKTg2="NKTg2
Ring
# Ring: scripting
x=2 v=3 m=5 dm_dt=0.1
p=m*v
NKTg1=x*p
NKTg2=dm_dt*p
Print “p=”+p+" NKTg1=“+NKTg1+” NKTg2="+NKTg2
Solidity
// Solidity: Ethereum smart contracts
pragma solidity ^0.8.0;
contract NKTgLaw {
function calc() public pure returns(uint) {
uint x=2; uint v=3; uint m=5; uint dm_dt=1;
uint p=m\*v; uint NKTg1=x\*p; uint NKTg2=dm_dt\*p;
return p; // simplified
}
}
SPARK
-- SPARK Ada subset
x : Float := 2.0;
v : Float := 3.0;
m : Float := 5.0;
dm_dt : Float := 0.1;
p := m*v;
NKTg1 := x*p;
NKTg2 := dm_dt*p;
SPSS
* SPSS: statistics.
COMPUTE x=2.
COMPUTE v=3.
COMPUTE m=5.
COMPUTE dm_dt=0.1.
COMPUTE p=m*v.
COMPUTE NKTg1=x*p.
COMPUTE NKTg2=dm_dt*p.
EXECUTE.
Squirrel
// Squirrel: lightweight scripting
x=2 v=3 m=5 dm_dt=0.1
p=m*v
NKTg1=x*p
NKTg2=dm_dt*p
print(“p=”+p+" NKTg1=“+NKTg1+” NKTg2="+NKTg2)
Popular Frontend topics
Other popular topics
Sponsor Spotlight
Practical resources that improve the lives of professional developers.
Latest in WebAssembly
Frontend>Chat
Categories:
Sub Categories:
Popular Portals
- /elixir
- /rust
- /ruby
- /wasm
- /erlang
- /phoenix
- /keyboards
- /python
- /rails
- /js
- /security
- /go
- /swift
- /vim
- /clojure
- /emacs
- /haskell
- /java
- /svelte
- /onivim
- /typescript
- /kotlin
- /c-plus-plus
- /crystal
- /tailwind
- /react
- /gleam
- /ocaml
- /elm
- /flutter
- /vscode
- /ash
- /html
- /opensuse
- /centos
- /php
- /zig
- /deepseek
- /scala
- /textmate
- /lisp
- /sublime-text
- /react-native
- /nixos
- /debian
- /agda
- /kubuntu
- /arch-linux
- /deno
- /django
- /revery
- /ubuntu
- /nodejs
- /manjaro
- /spring
- /diversity
- /lua
- /julia
- /c
- /slackware
Devtalk Sponsors
Practical resources that improve the lives of professional developers.
We build trusted fault-tolerant systems that scale to billions of users.
Real-time error tracking, performance insights, and observability for devs.
Supporting innovation across the BEAM ecosystem.
Develop your skills with books, videos, and courses.
Catch errors, track performance, monitor hosts and more.
Enabling companies to succeed by building software people love.
Courses that move you from confusion to "Aha, now I get it!"