From 0e7406f03e93bae61d6a0d7ec93a1d3dc7e188f5 Mon Sep 17 00:00:00 2001
From: Simon Tatham <anakin@pobox.com>
Date: Wed, 16 Apr 2025 19:29:45 +0100
Subject: [PATCH] Some better examples.

Computes more minimal polynomials than just the sequence I thought was
interesting, and also, an example to print some obvious tables.
---
 examples/{a382121.rs => minpoly.rs} | 12 +++++++
 examples/tables.rs                  | 50 +++++++++++++++++++++++++++++
 2 files changed, 62 insertions(+)
 rename examples/{a382121.rs => minpoly.rs} (90%)
 create mode 100644 examples/tables.rs

diff --git a/examples/a382121.rs b/examples/minpoly.rs
similarity index 90%
rename from examples/a382121.rs
rename to examples/minpoly.rs
index ce8d9d9..2c5b7bf 100644
--- a/examples/a382121.rs
+++ b/examples/minpoly.rs
@@ -109,6 +109,18 @@ fn largest_nimber_in_subfield(level: usize) -> FiniteNimber {
 }
 
 fn main() {
+    println!("Min poly of nimbers up to 2^8:");
+    for n in (0..256).map(FiniteNimber::from) {
+        println!(
+            "{} has minimal polynomial {}",
+            &n,
+            minimal_polynomial(&n)
+        );
+    }
+
+    println!();
+
+    println!("Min poly of largest nimber in each subfield (https://oeis.org/A382121):");
     for level in 0..13 {
         let n = largest_nimber_in_subfield(level);
         println!(
diff --git a/examples/tables.rs b/examples/tables.rs
new file mode 100644
index 0000000..1e24c8c
--- /dev/null
+++ b/examples/tables.rs
@@ -0,0 +1,50 @@
+use nimber::FiniteNimber;
+
+fn main() {
+    println!("Multiplication table for nimbers less than 16:");
+    for y in (0..16).map(|y| FiniteNimber::from(y)) {
+        for (xi, x) in (0..16).map(|x| FiniteNimber::from(x)).enumerate() {
+            let product = x * &y;
+            print!("{}{:x}", if xi==0 { "" } else { " " }, product.as_slice()[0]);
+        }
+        println!();
+    }
+
+    println!();
+
+    println!("Multiplication table for powers of 2 less than 2^16:");
+    for y in (0..16).map(|y| FiniteNimber::from(1 << y)) {
+        for (xi, x) in (0..16).map(|x| FiniteNimber::from(1 << x)).enumerate() {
+            let product = x * &y;
+            print!("{}{:04x}", if xi==0 { "" } else { " " }, product.as_slice()[0]);
+        }
+        println!();
+    }
+
+    println!();
+
+    println!("Multiplicative inverses of nimbers up to 2^8:");
+    for y in 0..16 {
+        for (xi, x) in (0..16).enumerate() {
+            let n = FiniteNimber::from(y * 16 + x);
+            let invstr = match n.inverse() {
+                None => "--".into(),
+                Some(inv) => format!("{:02x}", inv.as_slice()[0]),
+            };
+            print!("{}{}", if xi==0 { "" } else { " " }, invstr);
+        }
+        println!();
+    }
+
+    println!();
+
+    println!("Square roots of nimbers up to 2^8:");
+    for y in 0..16 {
+        for (xi, x) in (0..16).enumerate() {
+            let n = FiniteNimber::from(y * 16 + x);
+            let sqrt = n.sqrt();
+            print!("{}{:02x}", if xi==0 { "" } else { " " }, sqrt.as_slice()[0]);
+        }
+        println!();
+    }
+}
-- 
2.30.2