Some better examples.

Computes more minimal polynomials than just the sequence I thought was
interesting, and also, an example to print some obvious tables.

diff --git a/examples/a382121.rs b/examples/minpoly.rs
similarity index 90%
rename from examples/a382121.rs
rename to examples/minpoly.rs
index ce8d9d9c6a453f59c392acf38e8fe0eff4acce1b..2c5b7bf02fd4f2807d65fa4996ee0bd790bc23c8 100644 (file)
--- 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 (file)
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!();
+    }
+}