docs: auto-sync Rosetta Code examples from zenc repo

Author: github-actions[bot]

rosetta/Angle_difference_between_two_bearings.md

@@ -33,11 +33,11 @@ fn main() {
         (60175.77306795546, 42213.07192354373)
     ];
 
-    "Differences (to 4dp) between these bearings:";
+    println "Differences (to 4dp) between these bearings:";
     for pair in pairs {
         let (p0, p1) = pair;
         let diff = subtract(p0, p1);
-        "{p0:12.4f}° and {p1:12.4f}° -> {diff:9.4f}°";
+        println "{p0:12.4f}° and {p1:12.4f}° -> {diff:9.4f}°";
     }
 }
 ```

rosetta/Arithmetic-geometric_mean.md

@@ -10,7 +10,7 @@ title = "Arithmetic-geometric mean"
 import "std/math.zc"
 
 fn agm(a: f64, g: f64) -> f64 {
-    let eps: const f64 = Math::pow(10.0, -14);
+    let eps: const f64 = 1e-14;
     while Math::abs(a - g) > Math::abs(a) * eps {
         let t = a;
         a = (a + g) / 2.0;
@@ -21,7 +21,7 @@ fn agm(a: f64, g: f64) -> f64 {
 
 fn main() {
     let a = agm(1.0, 1.0 / Math::sqrt(2.0));
-    "{a:0.16f}";
+    println "{a:0.16f}";
 }
 ```
 

rosetta/Determine_if_a_string_is_numeric.md

@@ -15,12 +15,12 @@ fn is_numeric(s: const string) -> bool {
 }
 
 fn main() {
-    "Are these strings numeric?\n"
+    println "Are these strings numeric?\n"
     let tests: const string[8] = [NULL, "1", " 3.14", "-100", "1e2", "NaN", "0xaf", "rose"];
     for t in tests {
         let isnum = is_numeric(t);
         let yn = isnum ? "yes" : "no";
-        "{t:-6s} -> {yn}";
+        println "{t:-6s} -> {yn}";
     }
 }
 ```

rosetta/Diversity_prediction_theorem.md

@@ -9,15 +9,15 @@ title = "Diversity prediction theorem"
 ```zc
 fn average_square_diff(f: f64, preds: f64*, size: usize) -> f64 {
     let sum = 0.0;
-    for i in 0 ..< size {
+    for i in 0..<size {
         sum += (preds[i] - f) * (preds[i] - f);
     }
     return sum / size;
 }
 
 fn diversity_theorem(truth: f64, preds: f64*, size: usize) -> (f64, f64, f64) {
     let sum = 0.0;
-    for i in 0 ..< size {
+    for i in 0..<size {
         sum += preds[i];
     }
     let av = sum / size;
@@ -37,9 +37,9 @@ fn main() {
     res[1] = diversity_theorem(truth, a2, 4);
     for r in res {
         let (ae, ce, div) = r;
-        "Average-error {ae:6.3f}";
-        "Crowd-error   {ce:6.3f}";
-        "Diversity     {div:6.3f}\n";
+        println "Average-error {ae:6.3f}";
+        println "Crowd-error   {ce:6.3f}";
+        println "Diversity     {div:6.3f}\n";
     }
 }
 ```

rosetta/Experimental_Verification_of_the_NKTg_Law_Using_NASA_Neptune_Data_(2023–2024).md

@@ -0,0 +1,169 @@
++++
+title = "Experimental Verification of the NKTg Law Using NASA Neptune Data (2023–2024)"
++++
+
+# Experimental Verification of the NKTg Law Using NASA Neptune Data (2023–2024)
+
+{{trans|Q#}}
+
+```zc
+import "std/math.zc"
+
+fn compute_nktg(x: f64, v: f64, m: f64, dm_dt: f64) {
+    let p = m * v;
+    let nktg1 = x * p;
+    let nktg2 = dm_dt * p;
+    let nktg  = Math::sqrt(nktg1 * nktg1 + nktg2 * nktg2);
+
+    println "--------------------------------------------";
+    println "Position (x)         : {x:0.0f}";
+    println "Velocity (v)         : {v:0.2f}";
+    println "Mass (m)             : {m:0.0f}";
+    println "Momentum (p = m * v) : {p:0.0f}";
+    println "NKTg1 = x * p        : {nktg1:0.0f}";
+    println "NKTg2 = dm_dt * p    : {nktg2:0.0f}";
+    println "Total NKTg           : {nktg:0.0f}";
+}
+
+fn main() {
+    println "============================================";
+    println "NKTg Law - Neptune 2023 NASA Data";
+    println "============================================";
+
+    // 2023 NASA Data (Neptune)
+    let dm_dt = -0.00002000;
+
+    let data2023: (f64, f64, f64)[5] = [
+        [4498396440.0, 5.43, 1.02430000e26],
+        [4503443661.0, 5.43, 1.02429980e26],
+        [4553946490.0, 5.43, 1.02429960e26],
+        [4503443661.0, 5.43, 1.02429940e26],
+        [4498396440.0, 5.43, 1.02429920e26]
+    ];
+
+    for e in data2023 {
+        let (x, v, m) = e;
+        compute_nktg(x, v, m, dm_dt);
+    }
+
+    println "\n============================================";
+    println "NKTg Law - Neptune 2024 Simulation";
+    println "============================================";
+
+    let data2024: (f64, f64, f64)[5] = [ 
+        (4498396440.0, 5.43, 1.02429900e26),
+        (4503443661.0, 5.43, 1.02429880e26),
+        (4553946490.0, 5.43, 1.02429860e26),
+        (4503443661.0, 5.43, 1.02429840e26),
+        (4498396440.0, 5.43, 1.02429820e26)
+    ];
+
+    for e in data2024 {
+        let (x, v, m) = e;
+        compute_nktg(x, v, m, dm_dt);
+    }
+
+    println "\n============================================";
+    println "Experiment Completed";
+    println "============================================";
+}
+```
+
+**Output:**
+
+```
+
+############################################ NKTg Law - Neptune 2023 NASA Data
+
+--------------------------------------------
+Position (x)         : 4498396440
+Velocity (v)         : 5.43
+Mass (m)             : 102430000000000008208252928
+Momentum (p = m * v) : 556194900000000047834988544
+NKTg1 = x * p        : 2501985158106156083146661858719563776
+NKTg2 = dm_dt * p    : -11123898000000002555904
+Total NKTg           : 2501985158106156083146661858719563776
+--------------------------------------------
+Position (x)         : 4503443661
+Velocity (v)         : 5.43
+Mass (m)             : 102429979999999995655749632
+Momentum (p = m * v) : 556194791399999965415604224
+NKTg1 = x * p        : 2504791907611547214820196617625272320
+NKTg2 = dm_dt * p    : -11123895827999999655936
+Total NKTg           : 2504791907611547214820196617625272320
+--------------------------------------------
+Position (x)         : 4553946490
+Velocity (v)         : 5.43
+Mass (m)             : 102429960000000000283115520
+Momentum (p = m * v) : 556194682799999951715696640
+NKTg1 = x * p        : 2532880823493723022518856423204454400
+NKTg2 = dm_dt * p    : -11123893656000000950272
+Total NKTg           : 2532880823493723022518856423204454400
+--------------------------------------------
+Position (x)         : 4503443661
+Velocity (v)         : 5.43
+Mass (m)             : 102429940000000004910481408
+Momentum (p = m * v) : 556194574200000006735265792
+NKTg1 = x * p        : 2504790929463584156593795259823030272
+NKTg2 = dm_dt * p    : -11123891484000000147456
+Total NKTg           : 2504790929463584156593795259823030272
+--------------------------------------------
+Position (x)         : 4498396440
+Velocity (v)         : 5.43
+Mass (m)             : 102429919999999992357978112
+Momentum (p = m * v) : 556194465599999924315881472
+NKTg1 = x * p        : 2501983204002742083276785197042892800
+NKTg2 = dm_dt * p    : -11123889311999999344640
+Total NKTg           : 2501983204002742083276785197042892800
+
+############################################ NKTg Law - Neptune 2024 Simulation
+
+--------------------------------------------
+Position (x)         : 4498396440
+Velocity (v)         : 5.43
+Mass (m)             : 102429899999999996985344000
+Momentum (p = m * v) : 556194356999999979335450624
+NKTg1 = x * p        : 2501982715476888878457221210976550912
+NKTg2 = dm_dt * p    : -11123887140000000638976
+Total NKTg           : 2501982715476888878457221210976550912
+--------------------------------------------
+Position (x)         : 4503443661
+Velocity (v)         : 5.43
+Mass (m)             : 102429880000000001612709888
+Momentum (p = m * v) : 556194248399999965635543040
+NKTg1 = x * p        : 2504789462241639274106288043766841344
+NKTg2 = dm_dt * p    : -11123884967999999836160
+Total NKTg           : 2504789462241639274106288043766841344
+--------------------------------------------
+Position (x)         : 4553946490
+Velocity (v)         : 5.43
+Mass (m)             : 102429860000000006240075776
+Momentum (p = m * v) : 556194139800000020655112192
+NKTg1 = x * p        : 2532878350700779383730369029335941120
+NKTg2 = dm_dt * p    : -11123882796000001130496
+Total NKTg           : 2532878350700779383730369029335941120
+--------------------------------------------
+Position (x)         : 4503443661
+Velocity (v)         : 5.43
+Mass (m)             : 102429839999999993687572480
+Momentum (p = m * v) : 556194031199999938235727872
+NKTg1 = x * p        : 2504788484093675920731981506611773440
+NKTg2 = dm_dt * p    : -11123880624000000327680
+Total NKTg           : 2504788484093675920731981506611773440
+--------------------------------------------
+Position (x)         : 4498396440
+Velocity (v)         : 5.43
+Mass (m)             : 102429819999999998314938368
+Momentum (p = m * v) : 556193922599999993255297024
+NKTg1 = x * p        : 2501980761373475468883154908005531648
+NKTg2 = dm_dt * p    : -11123878452000001622016
+Total NKTg           : 2501980761373475468883154908005531648
+
+############################################ Experiment Completed
+
+```
+
+---
+**Attribution:** This is a community solution for the Rosetta Code task [**Experimental Verification of the NKTg Law Using NASA Neptune Data (2023–2024)**](https://rosettacode.org/wiki/Experimental_Verification_of_the_NKTg_Law_Using_NASA_Neptune_Data_(2023–2024)) in Zen C.
+
+*This article uses material from the Rosetta Code article **Experimental Verification of the NKTg Law Using NASA Neptune Data (2023–2024)**, which is released under the [GNU Free Documentation License 1.3](https://www.gnu.org/licenses/fdl-1.3.html). A list of the original authors can be found in the [page history](https://rosettacode.org/wiki/Experimental_Verification_of_the_NKTg_Law_Using_NASA_Neptune_Data_(2023–2024)?action=history).*

rosetta/Experimental_Verification_of_the_NKTg_Law_in_Earth_Orbit_Based_on_NASA’s_2025_Earth_Dataset.md

@@ -17,7 +17,7 @@ struct OrbitalData {
 }
 
 fn new_od(date: string, x: f64, v: f64, m: f64) -> OrbitalData {
-    return OrbitalData { date: date, x: x, v: v, m: m }
+    return OrbitalData { date: date, x: x, v: v, m: m };
 }
         
 struct ResultRow {
@@ -32,7 +32,7 @@ struct ResultRow {
 
 impl ResultRow {
     fn display(self) -> void {
-        println "{.date:-12s} {.p:14.3e} {.nktg1:14.3e} {.nktg2:14.3e} {.v_sim:12.3e} {.v_nasa:12.3e} {.error:10.4f}%"
+        println "{.date:-12s} {.p:14.3e} {.nktg1:14.3e} {.nktg2:14.3e} {.v_sim:12.3e} {.v_nasa:12.3e} {.error:10.4f}%";
     }
 }
 
@@ -71,10 +71,10 @@ fn main() {
         ("12/31/2025", 3.0286e4)
     ];
 
-    "\nExperimental Verification of NKTg Law (Earth 2025)\n"
+    println "\nExperimental Verification of NKTg Law (Earth 2025)\n";
 
-    "Date            Momentum(p)          NKTg1          NKTg2        v_sim       v_NASA      Error"
-    "-----------------------------------------------------------------------------------------------"
+    println "Date            Momentum(p)          NKTg1          NKTg2        v_sim       v_NASA      Error";
+    println "-----------------------------------------------------------------------------------------------";
 
     for i, data in sim_2025 {
         let p      = momentum(data.m, data.v);

rosetta/Hello_world_Newline_omission.md

@@ -6,7 +6,7 @@ title = "Hello world/Newline omission"
 
 ```zc
 fn main() {
-    "Goodbye, World!" ..;
+    print "Goodbye, World!";
 }
 ```
 

rosetta/Hello_world_Standard_error.md

@@ -6,7 +6,7 @@ title = "Hello world/Standard error"
 
 ```zc
 fn main() {
-    !"Goodbye, World!"
+    eprintln "Goodbye, World!";
 }
 ```
 

rosetta/Hello_world_Text.md

@@ -6,7 +6,7 @@ title = "Hello world/Text"
 
 ```zc
 fn main() {
-    "Hello world!";
+    println "Hello world!";
 }
 ```
 

rosetta/Inheritance_Multiple.md

@@ -0,0 +1,48 @@
++++
+title = "Inheritance/Multiple"
++++
+
+# Inheritance/Multiple
+
+Zen C does not have classes but does have structs which can implement methods.
+
+The language doesn't have inheritance as such but instead uses composition to embed other structs. Any number of structs can be embedded in this way.
+
+In the following code, the CameraPhone struct embeds both the Camera and Phone structs in a way which enables it to call their methods.
+
+```zc
+struct Camera {}
+
+impl Camera {
+    fn snap(self) { println "Taking a photo."; }
+}
+
+struct Phone {}
+
+impl Phone {
+    fn call(self) { println "Calling home."; }
+}
+
+struct CameraPhone {
+    use camera : Camera;
+    use phone  : Phone;
+}
+
+fn main() {
+    let cp = CameraPhone{camera: Camera{}, phone: Phone{}};
+    cp.camera.snap();
+    cp.phone.call();
+}
+```
+
+**Output:**
+
+```
+Taking a photo.
+Calling home.
+```
+
+---
+**Attribution:** This is a community solution for the Rosetta Code task [**Inheritance/Multiple**](https://rosettacode.org/wiki/Inheritance/Multiple) in Zen C.
+
+*This article uses material from the Rosetta Code article **Inheritance/Multiple**, which is released under the [GNU Free Documentation License 1.3](https://www.gnu.org/licenses/fdl-1.3.html). A list of the original authors can be found in the [page history](https://rosettacode.org/wiki/Inheritance/Multiple?action=history).*