Add From<array of u64> and use it everywhere.

Much less verbose than either of the previous syntaxes for entering a
large nimber literal.

diff --git a/src/finitenimber.rs b/src/finitenimber.rs
index af4798806eda610d9f036e4d7ca61ac42c662fc2..6bd2a4b0da25d4119061bf0e27d052f78ada326d 100644 (file)
--- a/src/finitenimber.rs
+++ b/src/finitenimber.rs
@@ -302,6 +302,12 @@ impl From<&[Word]> for FiniteNimber {
     }
 }
 
+impl<const N: usize> From<&[Word; N]> for FiniteNimber {
+    fn from(array: &[Word; N]) -> FiniteNimber {
+        FiniteNimber::from(array as &[Word])
+    }
+}
+
 macro_rules! impl_binop_wrappers {
     ($trait:tt, $fn:ident, $assigntrait:tt, $assignfn:ident) => {
         impl $trait<FiniteNimberRef<'_>> for FiniteNimber {
@@ -547,7 +553,7 @@ mod tests {
 
     #[test]
     fn split() {
-        let a = FiniteNimber::from(vec![
+        let a = FiniteNimber::from(&[
             0x8786858483828180,
             0x9796959493929190,
             0xa7a6a5a4a3a2a1a0,
@@ -559,31 +565,31 @@ mod tests {
         let (loref, hiref) = a.to_ref().split(4);
         let lo: FiniteNimber = loref.into();
         let hi: FiniteNimber = hiref.into();
-        assert_eq!(lo, FiniteNimber::from(vec![0x8180]));
-        assert_eq!(hi, FiniteNimber::from(vec![0x8382]));
+        assert_eq!(lo, FiniteNimber::from(&[0x8180]));
+        assert_eq!(hi, FiniteNimber::from(&[0x8382]));
 
         let (loref, hiref) = a.to_ref().split(5);
         let lo: FiniteNimber = loref.into();
         let hi: FiniteNimber = hiref.into();
-        assert_eq!(lo, FiniteNimber::from(vec![0x83828180]));
-        assert_eq!(hi, FiniteNimber::from(vec![0x87868584]));
+        assert_eq!(lo, FiniteNimber::from(&[0x83828180]));
+        assert_eq!(hi, FiniteNimber::from(&[0x87868584]));
 
         let (loref, hiref) = a.to_ref().split(6);
         let lo: FiniteNimber = loref.into();
         let hi: FiniteNimber = hiref.into();
-        assert_eq!(lo, FiniteNimber::from(vec![0x8786858483828180]));
-        assert_eq!(hi, FiniteNimber::from(vec![0x9796959493929190]));
+        assert_eq!(lo, FiniteNimber::from(&[0x8786858483828180]));
+        assert_eq!(hi, FiniteNimber::from(&[0x9796959493929190]));
 
         let (loref, hiref) = a.to_ref().split(7);
         let lo: FiniteNimber = loref.into();
         let hi: FiniteNimber = hiref.into();
         assert_eq!(
             lo,
-            FiniteNimber::from(vec![0x8786858483828180, 0x9796959493929190])
+            FiniteNimber::from(&[0x8786858483828180, 0x9796959493929190])
         );
         assert_eq!(
             hi,
-            FiniteNimber::from(vec![0xa7a6a5a4a3a2a1a0, 0xb7b6b5b4b3b2b1b0,])
+            FiniteNimber::from(&[0xa7a6a5a4a3a2a1a0, 0xb7b6b5b4b3b2b1b0,])
         );
 
         let (loref, hiref) = a.to_ref().split(8);
@@ -591,7 +597,7 @@ mod tests {
         let hi: FiniteNimber = hiref.into();
         assert_eq!(
             lo,
-            FiniteNimber::from(vec![
+            FiniteNimber::from(&[
                 0x8786858483828180,
                 0x9796959493929190,
                 0xa7a6a5a4a3a2a1a0,
@@ -600,7 +606,7 @@ mod tests {
         );
         assert_eq!(
             hi,
-            FiniteNimber::from(vec![0xc7c6c5c4c3c2c1c0, 0xd7d6d5d4d3d2d1d0])
+            FiniteNimber::from(&[0xc7c6c5c4c3c2c1c0, 0xd7d6d5d4d3d2d1d0])
         );
 
         let (loref, hiref) = a.to_ref().split(9);
@@ -608,7 +614,7 @@ mod tests {
         let hi: FiniteNimber = hiref.into();
         assert_eq!(
             lo,
-            FiniteNimber::from(vec![
+            FiniteNimber::from(&[
                 0x8786858483828180,
                 0x9796959493929190,
                 0xa7a6a5a4a3a2a1a0,
@@ -617,27 +623,27 @@ mod tests {
                 0xd7d6d5d4d3d2d1d0
             ])
         );
-        assert_eq!(hi, FiniteNimber::from(vec![0]));
+        assert_eq!(hi, FiniteNimber::from(&[0]));
 
-        let a = FiniteNimber::from(vec![0xFF]);
+        let a = FiniteNimber::from(&[0xFF]);
 
         let (loref, hiref) = a.to_ref().split(0);
         let lo: FiniteNimber = loref.into();
         let hi: FiniteNimber = hiref.into();
-        assert_eq!(lo, FiniteNimber::from(vec![1]));
-        assert_eq!(hi, FiniteNimber::from(vec![1]));
+        assert_eq!(lo, FiniteNimber::from(&[1]));
+        assert_eq!(hi, FiniteNimber::from(&[1]));
 
         let (loref, hiref) = a.to_ref().split(1);
         let lo: FiniteNimber = loref.into();
         let hi: FiniteNimber = hiref.into();
-        assert_eq!(lo, FiniteNimber::from(vec![3]));
-        assert_eq!(hi, FiniteNimber::from(vec![3]));
+        assert_eq!(lo, FiniteNimber::from(&[3]));
+        assert_eq!(hi, FiniteNimber::from(&[3]));
 
         let (loref, hiref) = a.to_ref().split(2);
         let lo: FiniteNimber = loref.into();
         let hi: FiniteNimber = hiref.into();
-        assert_eq!(lo, FiniteNimber::from(vec![0xf]));
-        assert_eq!(hi, FiniteNimber::from(vec![0xf]));
+        assert_eq!(lo, FiniteNimber::from(&[0xf]));
+        assert_eq!(hi, FiniteNimber::from(&[0xf]));
     }
 
     #[test]
@@ -656,70 +662,57 @@ mod tests {
         );
         assert_eq!(
             a.to_ref().join(b.to_ref(), 6),
-            FiniteNimber::from(vec![0x5, 0xa])
+            FiniteNimber::from(&[0x5, 0xa])
         );
         assert_eq!(
             a.to_ref().join(b.to_ref(), 8),
-            FiniteNimber::from(vec![0x5, 0, 0, 0, 0xa])
+            FiniteNimber::from(&[0x5, 0, 0, 0, 0xa])
         );
     }
 
     #[test]
     fn levels() {
-        assert_eq!(FiniteNimber::from(vec![]).to_ref().level(), 0);
-        assert_eq!(FiniteNimber::from(vec![0]).to_ref().level(), 0);
-        assert_eq!(FiniteNimber::from(vec![1]).to_ref().level(), 0);
-        assert_eq!(FiniteNimber::from(vec![2]).to_ref().level(), 1);
-        assert_eq!(FiniteNimber::from(vec![3]).to_ref().level(), 1);
-        assert_eq!(FiniteNimber::from(vec![4]).to_ref().level(), 2);
-        assert_eq!(FiniteNimber::from(vec![0xf]).to_ref().level(), 2);
-        assert_eq!(FiniteNimber::from(vec![0x10]).to_ref().level(), 3);
-        assert_eq!(FiniteNimber::from(vec![0xff]).to_ref().level(), 3);
-        assert_eq!(FiniteNimber::from(vec![0x0100]).to_ref().level(), 4);
-        assert_eq!(FiniteNimber::from(vec![0xffff]).to_ref().level(), 4);
-        assert_eq!(FiniteNimber::from(vec![0x00010000]).to_ref().level(), 5);
-        assert_eq!(FiniteNimber::from(vec![0xffffffff]).to_ref().level(), 5);
+        assert_eq!(FiniteNimber::from(&[]).to_ref().level(), 0);
+        assert_eq!(FiniteNimber::from(&[0]).to_ref().level(), 0);
+        assert_eq!(FiniteNimber::from(&[1]).to_ref().level(), 0);
+        assert_eq!(FiniteNimber::from(&[2]).to_ref().level(), 1);
+        assert_eq!(FiniteNimber::from(&[3]).to_ref().level(), 1);
+        assert_eq!(FiniteNimber::from(&[4]).to_ref().level(), 2);
+        assert_eq!(FiniteNimber::from(&[0xf]).to_ref().level(), 2);
+        assert_eq!(FiniteNimber::from(&[0x10]).to_ref().level(), 3);
+        assert_eq!(FiniteNimber::from(&[0xff]).to_ref().level(), 3);
+        assert_eq!(FiniteNimber::from(&[0x0100]).to_ref().level(), 4);
+        assert_eq!(FiniteNimber::from(&[0xffff]).to_ref().level(), 4);
+        assert_eq!(FiniteNimber::from(&[0x00010000]).to_ref().level(), 5);
+        assert_eq!(FiniteNimber::from(&[0xffffffff]).to_ref().level(), 5);
         assert_eq!(
-            FiniteNimber::from(vec![0x0000000100000000])
-                .to_ref()
-                .level(),
+            FiniteNimber::from(&[0x0000000100000000]).to_ref().level(),
             6
         );
         assert_eq!(
-            FiniteNimber::from(vec![0xffffffffffffffff])
-                .to_ref()
-                .level(),
+            FiniteNimber::from(&[0xffffffffffffffff]).to_ref().level(),
             6
         );
 
+        assert_eq!(FiniteNimber::from(&[0x55, 0, 0, 0]).to_ref().level(), 3);
         assert_eq!(
-            FiniteNimber::from(vec![0x55, 0, 0, 0]).to_ref().level(),
-            3
-        );
-        assert_eq!(
-            FiniteNimber::from(vec![0x55, 1, 0, 0]).to_ref().level(),
+            dbg!(FiniteNimber::from(&[0x55, 1, 0, 0])).to_ref().level(),
             7
         );
+        assert_eq!(FiniteNimber::from(&[0x55, 1, 1, 0]).to_ref().level(), 8);
+        assert_eq!(FiniteNimber::from(&[0x55, 1, 1, 1]).to_ref().level(), 8);
         assert_eq!(
-            FiniteNimber::from(vec![0x55, 1, 1, 0]).to_ref().level(),
-            8
-        );
-        assert_eq!(
-            FiniteNimber::from(vec![0x55, 1, 1, 1]).to_ref().level(),
-            8
-        );
-        assert_eq!(
-            FiniteNimber::from(vec![0x55, 1, 1, 1, 1]).to_ref().level(),
+            FiniteNimber::from(&[0x55, 1, 1, 1, 1]).to_ref().level(),
             9
         );
         assert_eq!(
-            FiniteNimber::from(vec![1, 1, 1, 1, 1, 1, 1, 1])
+            FiniteNimber::from(&[1, 1, 1, 1, 1, 1, 1, 1])
                 .to_ref()
                 .level(),
             9
         );
         assert_eq!(
-            FiniteNimber::from(vec![1, 1, 1, 1, 1, 1, 1, 1, 1])
+            FiniteNimber::from(&[1, 1, 1, 1, 1, 1, 1, 1, 1])
                 .to_ref()
                 .level(),
             10
@@ -732,13 +725,13 @@ mod tests {
         let b = FiniteNimber::from(0b1010);
         assert_eq!(a + b, FiniteNimber::from(0b0110));
 
-        let a = FiniteNimber::from(vec![1, 1, 0, 0]);
-        let b = FiniteNimber::from(vec![1, 0, 1, 0]);
-        assert_eq!(a + b, FiniteNimber::from(vec![0, 1, 1, 0]));
+        let a = FiniteNimber::from(&[1, 1, 0, 0]);
+        let b = FiniteNimber::from(&[1, 0, 1, 0]);
+        assert_eq!(a + b, FiniteNimber::from(&[0, 1, 1 /*, 0 */]));
 
-        let a = FiniteNimber::from(vec![1, 1, 1, 1]);
+        let a = FiniteNimber::from(&[1, 1, 1, 1]);
         let b = FiniteNimber::from(2);
-        assert_eq!(a + b, FiniteNimber::from(vec![3, 1, 1, 1]));
+        assert_eq!(a + b, FiniteNimber::from(&[3, 1, 1, 1]));
     }
 
     #[test]
@@ -750,7 +743,7 @@ mod tests {
         assert_eq!(a.to_ref().mul_by_h(3), FiniteNimber::from(128));
         assert_eq!(
             a.to_ref().mul_by_h(8),
-            FiniteNimber::from(vec![0, 0, 0, 0x8000000000000000])
+            FiniteNimber::from(&[0, 0, 0, 0x8000000000000000])
         );
 
         assert_eq!(
@@ -759,7 +752,7 @@ mod tests {
         );
         assert_eq!(
             a.to_ref().mul_by_h(8).to_ref().mul_by_h(8),
-            FiniteNimber::from(vec![
+            FiniteNimber::from(&[
                 0xa92181714b010a1a,
                 0x4a88a921e2208b6b,
                 0xe3a92850a9218171,
@@ -781,7 +774,7 @@ mod tests {
         );
 
         assert_eq!(
-            FiniteNimber::from(vec![
+            FiniteNimber::from(&[
                 0x3f84d5b5b5470917,
                 0xc0ac29b7c97c50dd,
                 0xbe5466cf34e90c6c,
@@ -790,7 +783,7 @@ mod tests {
                 0xa4093822299f31d0,
                 0x13198a2e03707344,
                 0x243f6a8885a308d3,
-            ]) * FiniteNimber::from(vec![
+            ]) * FiniteNimber::from(&[
                 0x4f7c7b5757f59584,
                 0xda06c80abb1185eb,
                 0xf4bf8d8d8c31d763,
@@ -800,7 +793,7 @@ mod tests {
                 0xbf7158809cf4f3c7,
                 0xb7e151628aed2a6a,
             ]),
-            FiniteNimber::from(vec![
+            FiniteNimber::from(&[
                 0x72890f944be121d8,
                 0xe6429b02014feb2e,
                 0x2454070e4408eff8,
@@ -825,7 +818,7 @@ mod tests {
         );
 
         assert_eq!(
-            FiniteNimber::from(vec![
+            FiniteNimber::from(&[
                 0x3f84d5b5b5470917,
                 0xc0ac29b7c97c50dd,
                 0xbe5466cf34e90c6c,
@@ -836,7 +829,7 @@ mod tests {
                 0x243f6a8885a308d3,
             ])
             .square(),
-            FiniteNimber::from(vec![
+            FiniteNimber::from(&[
                 0xd0e74a0945d35342,
                 0xfa91473032b5438a,
                 0xe17bdc047300f99d,
@@ -857,7 +850,7 @@ mod tests {
         );
 
         assert_eq!(
-            FiniteNimber::from(vec![
+            FiniteNimber::from(&[
                 0x72890f944be121d8,
                 0xe6429b02014feb2e,
                 0x2454070e4408eff8,
@@ -866,7 +859,7 @@ mod tests {
                 0xcfb08c013e9dd19c,
                 0x5eeb02eaf7ae9ea0,
                 0x59cbe194a9599171,
-            ]) / FiniteNimber::from(vec![
+            ]) / FiniteNimber::from(&[
                 0x3f84d5b5b5470917,
                 0xc0ac29b7c97c50dd,
                 0xbe5466cf34e90c6c,
@@ -876,7 +869,7 @@ mod tests {
                 0x13198a2e03707344,
                 0x243f6a8885a308d3,
             ]),
-            FiniteNimber::from(vec![
+            FiniteNimber::from(&[
                 0x4f7c7b5757f59584,
                 0xda06c80abb1185eb,
                 0xf4bf8d8d8c31d763,
@@ -906,7 +899,7 @@ mod tests {
         );
 
         assert_eq!(
-            FiniteNimber::from(vec![
+            FiniteNimber::from(&[
                 0xd0e74a0945d35342,
                 0xfa91473032b5438a,
                 0xe17bdc047300f99d,
@@ -917,7 +910,7 @@ mod tests {
                 0x32ae6e49dcd65156,
             ])
             .sqrt(),
-            FiniteNimber::from(vec![
+            FiniteNimber::from(&[
                 0x3f84d5b5b5470917,
                 0xc0ac29b7c97c50dd,
                 0xbe5466cf34e90c6c,