• Nhà nghiên cứu độc lập: Nguyễn Khánh Tùng
• ORCID: 0009-0002-9877-4137
• Email: traiphieu.com@gmail.com
• Website: https://traiphieu.com
Tóm tắt
Định luật NKTg về Quán tính Biến thiên mô tả xu hướng của một vật đang chuyển động phụ thuộc vào vị trí, vận tốc và khối lượng của nó. Định luật được biểu diễn như sau:
NKTg = f(x, v, m)
Trong đó:
• x = vị trí / dịch chuyển so với một điểm tham chiếu
• v = vận tốc
• m = khối lượng
Hai đại lượng chính xác định xu hướng chuyển động:
NKTg₁ = x × p
NKTg₂ = (dm/dt) × p
Trong đó:
• p = m × v (động lượng tuyến tính)
• dm/dt = tốc độ thay đổi khối lượng theo thời gian
• NKTg₁ đại diện cho tích của vị trí và động lượng
• NKTg₂ đại diện cho tích của biến thiên khối lượng và động lượng
• Đơn vị đo là NKTm, đại diện cho một đơn vị quán tính biến thiên
Dấu và độ lớn của các đại lượng này quyết định xu hướng chuyển động:
• Nếu NKTg₁ > 0 → vật có xu hướng chuyển động ra khỏi trạng thái ổn định
• Nếu NKTg₁ < 0 → vật có xu hướng chuyển động về trạng thái ổn định
• Nếu NKTg₂ > 0 → biến thiên khối lượng hỗ trợ chuyển động
• Nếu NKTg₂ < 0 → biến thiên khối lượng chống lại chuyển động
Trạng thái ổn định được định nghĩa là một cấu hình mà trong đó x, v và m tương tác để duy trì cấu trúc chuyển động mà không mất kiểm soát.
Ngôn ngữ Lập trình
Định luật NKTg được triển khai trong 150 ngôn ngữ lập trình sau:
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
Cách Đọc Mã Lệnh
• Mỗi đoạn mã tính toán p, NKTg₁ và NKTg₂ với các giá trị ví dụ mặc định:
o x = 2, v = 3, m = 5, dm_dt = 0.1
• Mã được cấu trúc để dễ đọc và thực thi trong môi trường lập trình tương ứng.
• Chú thích chỉ ra mục đích ngôn ngữ hoặc lĩnh vực sử dụng.
• Đơn vị và phép tính tuân theo định nghĩa của Định luật NKTg.
Đoạn Mã
Tất cả 150 ngôn ngữ được triển khai như dưới đây.
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
Cách Đọc Mã Lệnh
• Mỗi đoạn mã tính toán p, NKTg₁ và NKTg₂ với các giá trị ví dụ mặc định:
o x = 2, v = 3, m = 5, dm_dt = 0.1
• Mã được cấu trúc để dễ đọc và thực thi trong môi trường lập trình tương ứng.
• Chú thích chỉ ra mục đích ngôn ngữ hoặc lĩnh vực sử dụng.
• Đơn vị và phép tính tuân theo định nghĩa của Định luật NKTg.
Đoạn Mã
Tất cả 150 ngôn ngữ được triển khai như dưới đây.
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)
