- Independent researcher: Nguyễn Khánh Tùng
- ORCID: 0009-0002-9877-4137
- Email: traiphieu.com@gmail.com
- Website: https://traiphieu.com
Abstract / 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.
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 <iostream>
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 constantsconstant 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 simulatorVerilog
// Verilog: hardware description language// Example conceptual calculationreal 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 conceptuallyAutoHotkey
; AutoHotkey: Windows automationx:=2; v:=3; m:=5; dm_dt:=0.1p:=m*vNKTg1:=x*pNKTg2:=dm_dt*pMsgBox % "p=" p " NKTg1=" NKTg1 " NKTg2=" NKTg2AutoLISP
; 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 processingBEGIN{ 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.1p=$(echo"$m*$v"|bc)
NKTg1=$(echo"$x*$p"|bc)
NKTg2=$(echo"$dm_dt*$p"|bc)
echo"p=$pNKTg1=$NKTg1NKTg2=$NKTg2"
bc
# bc: calculator scriptingx=2; v=3; m=5; dm_dt=0.1p=m*vNKTg1=x*pNKTg2=dm_dt*pp NKTg1 NKTg2Boo
# Boo: statically typed .NET languagex=2.0v=3.0m=5.0dm_dt=0.1p=m*vNKTg1=x*pNKTg2=dm_dt*pprint "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 languagex, v, m, dm_dt = 2.0, 3.0, 5.0, 0.1p = m*vNKTg1 = x*pNKTg2 = dm_dt*pputs "p=#{p} NKTg1=#{NKTg1} NKTg2=#{NKTg2}"D
// D: systems programmingimport 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 languagelet 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-orientedclass NKTgLawcreate makefeature 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") endendElixir
# Elixir: functional programmingx=2; v=3; m=5; dm_dt=0.1p=m*vNKTg1=x*pNKTg2=dm_dt*pIO.puts("p=#{p} NKTg1=#{NKTg1} NKTg2=#{NKTg2}")Elm
-- Elm: functional web languagex = 2v = 3m = 5dm_dt = 0.1p = m * vnktg1 = x * pnktg2 = dm_dt * p-- Elm uses Html.text to display in browserEmacs 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 functionalX=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 .NETlet x,v,m,dm_dt=2.0,3.0,5.0,0.1let p=m*vlet NKTg1=x*plet NKTg2=dm_dt*pprintfn "p=%f NKTg1=%f NKTg2=%f" p NKTg1 NKTg2Factor
! Factor: stack-based2 3 5 0.1 [ * ] [ * ] [ * ] .Falcon
# Falcon: scripting languagex=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 languageclass 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-paradigmval x=2.0; val v=3.0; val m=5.0; val dm_dt=0.1val p=m*v; val NKTg1=x*p; val NKTg2=dm_dt*pprintln("p=$p NKTg1=$NKTg1 NKTg2=$NKTg2")Forth
\ Forth: stack-based2 3 5 0.1\ calculate p, NKTg1, NKTg2 on stackFortress
// Fortress: scientific computingx=2; v=3; m=5; dm_dt=0.1p=m*v; NKTg1=x*p; NKTg2=dm_dt*pprintln("p="+p+" NKTg1="+NKTg1+" NKTg2="+NKTg2)Frink
// Frink: units-aware languagex=2; v=3; m=5; dm_dt=0.1p=m*vNKTg1=x*pNKTg2=dm_dt*pprintln("p="+p+" NKTg1="+NKTg1+" NKTg2="+NKTg2)Gambas
' Gambas: BASIC dialectDim x,v,m,dm_dt,p,NKTg1,NKTg2 As Floatx=2:v=3:m=5:dm_dt=0.1p=m*v:NKTg1=x*p:NKTg2=dm_dt*pPrint "p="&p&" NKTg1="&NKTg1&" NKTg2="&NKTg2GAMS
* GAMS: mathematical modelingScalar 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 theoryx:=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-likeinit 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 languagefloat 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-platformclass 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 conceptuallyHLSL
// HLSL: shader programmingfloat 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 languagelet x = 2, v = 3, m = 5, dm_dt = 0.1let p = m*vlet NKTg1 = x*plet NKTg2 = dm_dt*pHTML (with JS)
<!-- HTML: front-end -->
<script>
letx=2,v=3,m=5,dm_dt=0.1;
letp=m*v,NKTg1=x*p,NKTg2=dm_dt*p;
console.log(`p=${p}NKTg1=${NKTg1}NKTg2=${NKTg2}`);
</script>
HyperTalk
-- HyperTalk: AppleScript-likeput 2 into xput 3 into vput 5 into mput 0.1 into dm_dtput m*v into pput x*p into NKTg1put dm_dt*p into NKTg2answer "p=" & p & " NKTg1=" & NKTg1 & " NKTg2=" & NKTg2Io
// 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 😡 * :p
make “NKTg2 :dm_dt * :p
print (list :p :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)
