DEV Community

Nguyen Khanh Tung
Nguyen Khanh Tung

Posted on

NKTg Law on Variable Inertia Presented in 150 Languages

#nktglaw #variable #inertia #150languages

• Independent researcher: Nguyễn Khánh Tùng
• ORCID: 0009-0002-9877-4137
• Email: traiphieu.com@gmail.com
• Website: https://traiphieu.com

Introduction
The NKTg Law on Varying Inertia defines how an object’s motion tendency is governed by its position, velocity, and mass. It can be formulated 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:
o 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

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 --> let x=2,v=3,m=5,dm_dt=0.1; let p=m*v,NKTg1=x*p,NKTg2=dm_dt*p; console.log(<code>p=${p} NKTg1=${NKTg1} NKTg2=${NKTg2}</code>); 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 * :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)

Top comments (0)