Yet another matrix rewrite

ext/crates/algebra/src/algebra/adem_algebra.rs

@@ -6,7 +6,7 @@ use itertools::Itertools;
 use rustc_hash::FxHashMap as HashMap;
 
 use fp::prime::{BinomialIterator, BitflagIterator, ValidPrime};
-use fp::vector::{FpVector, SliceMut};
+use fp::vector::{prelude::*, FpVector, SliceMut};
 use once::OnceVec;
 
 use crate::algebra::combinatorics::{self, MAX_XI_TAU};

ext/crates/algebra/src/algebra/algebra_trait.rs

@@ -1,5 +1,5 @@
 use fp::prime::ValidPrime;
-use fp::vector::{Slice, SliceMut};
+use fp::vector::{prelude::*, Slice, SliceMut};
 
 use std::fmt::Write as _; // Needed for write! macro for String
 

ext/crates/algebra/src/algebra/combinatorics.rs

@@ -1,4 +1,4 @@
-use fp::vector::FpVector;
+use fp::vector::{prelude::*, FpVector};
 use once::OnceVec;
 
 use fp::prime::{minus_one_to_the_n, Binomial, ValidPrime};
@@ -9,7 +9,7 @@ pub const MAX_XI_TAU: usize = MAX_MULTINOMIAL_LEN;
 /// If p is the nth prime, then `XI_DEGREES[n][i - 1]` is the degree of $ξ_i$ at the prime p divided by
 /// q, where q = 2p - 2 if p != 2 and 1 if p = 2.
 const XI_DEGREES: [[i32; MAX_XI_TAU]; NUM_PRIMES] = {
-    let mut res = [[0; 10]; 8];
+    let mut res = [[0; 10]; NUM_PRIMES];
     const_for! { p_idx in 0 .. NUM_PRIMES {
         let p = PRIMES[p_idx];
         let mut p_to_the_i = p;
@@ -26,7 +26,7 @@ const XI_DEGREES: [[i32; MAX_XI_TAU]; NUM_PRIMES] = {
 /// If p is the nth prime, then `TAU_DEGREES[n][i]` is the degree of $τ_i$ at the prime p. Its value is
 /// nonsense at the prime 2
 const TAU_DEGREES: [[i32; MAX_XI_TAU]; NUM_PRIMES] = {
-    let mut res = [[0; 10]; 8];
+    let mut res = [[0; 10]; NUM_PRIMES];
     const_for! { p_idx in 0 .. NUM_PRIMES {
         let p = PRIMES[p_idx];
         let mut p_to_the_i: u32 = 1;

ext/crates/algebra/src/algebra/field.rs

@@ -2,7 +2,7 @@
 
 use crate::algebra::{Algebra, Bialgebra};
 use fp::prime::ValidPrime;
-use fp::vector::{Slice, SliceMut};
+use fp::vector::{prelude::*, Slice, SliceMut};
 
 /// $\mathbb{F}_p$, viewed as an [`Algebra`] over itself.
 ///

ext/crates/algebra/src/algebra/milnor_algebra.rs

@@ -5,7 +5,7 @@ use std::cell::Cell;
 use crate::algebra::combinatorics;
 use crate::algebra::{Algebra, Bialgebra, GeneratedAlgebra, UnstableAlgebra};
 use fp::prime::{factor_pk, integer_power, Binomial, BitflagIterator, ValidPrime};
-use fp::vector::{FpVector, Slice, SliceMut};
+use fp::vector::{prelude::*, FpVector, Slice, SliceMut};
 use once::OnceVec;
 
 #[cfg(feature = "json")]

ext/crates/algebra/src/algebra/pair_algebra.rs

@@ -9,7 +9,7 @@
 use crate::combinatorics;
 use crate::Algebra;
 use fp::prime::TWO;
-use fp::vector::{FpVector, Slice, SliceMut};
+use fp::vector::{prelude::*, FpVector, Slice, SliceMut};
 use rustc_hash::FxHasher;
 
 type HashMap<K, V> = hashbrown::HashMap<K, V, std::hash::BuildHasherDefault<FxHasher>>;

ext/crates/algebra/src/algebra/polynomial_algebra.rs

@@ -3,7 +3,7 @@ use rustc_hash::FxHashMap as HashMap;
 use std::fmt;
 
 use fp::prime::ValidPrime;
-use fp::vector::{FpVector, SliceMut};
+use fp::vector::{prelude::*, FpVector, SliceMut};
 use once::OnceVec;
 
 use crate::algebra::combinatorics::TruncatedPolynomialMonomialBasis;

ext/crates/algebra/src/module/block_structure.rs

@@ -1,5 +1,5 @@
 use bivec::BiVec;
-use fp::vector::{Slice, SliceMut};
+use fp::vector::{prelude::*, Slice, SliceMut};
 use std::ops::Range;
 
 #[derive(Debug)]

ext/crates/algebra/src/module/finite_dimensional_module.rs

@@ -1,7 +1,7 @@
 use crate::algebra::Algebra;
 use crate::module::{Module, ZeroModule};
 use bivec::BiVec;
-use fp::vector::{FpVector, SliceMut};
+use fp::vector::{prelude::*, FpVector, SliceMut};
 
 use std::fmt::Write as _;
 use std::sync::Arc;
@@ -178,7 +178,7 @@ impl<A: Algebra> Module for FiniteDimensionalModule<A> {
             return;
         }
         let output = self.action(op_degree, op_index, mod_degree, mod_index);
-        result.add(output.as_slice(), coeff);
+        result.add(output, coeff);
     }
 
     fn max_degree(&self) -> Option<i32> {

ext/crates/algebra/src/module/finitely_presented_module.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use crate::algebra::Algebra;
 use crate::module::homomorphism::{FreeModuleHomomorphism, ModuleHomomorphism};
 use crate::module::{FreeModule, Module, ZeroModule};
-use fp::vector::{FpVector, SliceMut};
+use fp::vector::{prelude::*, FpVector, SliceMut};
 use once::OnceBiVec;
 
 #[cfg(feature = "json")]
@@ -233,7 +233,7 @@ impl<A: Algebra> Module for FinitelyPresentedModule<A> {
         );
         let image = self.map.image(out_deg).unwrap();
         image.reduce(temp_vec.as_slice_mut());
-        for i in 0..result.as_slice().len() {
+        for i in 0..result.len() {
             let value = temp_vec.entry(self.fp_idx_to_gen_idx(out_deg, i));
             result.add_basis_element(i, value);
         }

ext/crates/algebra/src/module/free_module.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use crate::algebra::MuAlgebra;
 use crate::module::{Module, ZeroModule};
-use fp::vector::{Slice, SliceMut};
+use fp::vector::{prelude::*, Slice, SliceMut};
 use once::{OnceBiVec, OnceVec};
 
 #[derive(Clone, Debug)]

ext/crates/algebra/src/module/hom_module.rs

@@ -5,7 +5,7 @@ use bivec::BiVec;
 use crate::algebra::Field;
 use crate::module::block_structure::BlockStructure;
 use crate::module::{FreeModule, Module};
-use fp::vector::SliceMut;
+use fp::vector::{prelude::*, SliceMut};
 use once::OnceBiVec;
 
 /// Given a module N and a free module M, this is the module Hom(M, N) as a module over the ground

ext/crates/algebra/src/module/homomorphism/free_module_homomorphism.rs

@@ -5,7 +5,7 @@ use crate::module::free_module::OperationGeneratorPair;
 use crate::module::homomorphism::{ModuleHomomorphism, ZeroHomomorphism};
 use crate::module::{Module, MuFreeModule};
 use fp::matrix::{MatrixSliceMut, QuasiInverse, Subspace};
-use fp::vector::{FpVector, Slice, SliceMut};
+use fp::vector::{prelude::*, FpVector, Slice, SliceMut};
 use once::OnceBiVec;
 
 pub type FreeModuleHomomorphism<M> = MuFreeModuleHomomorphism<false, M>;
@@ -55,10 +55,7 @@ where
         assert!(input_degree >= self.source.min_degree());
         assert!(input_index < self.source.dimension(input_degree));
         let output_degree = input_degree - self.degree_shift;
-        assert_eq!(
-            self.target.dimension(output_degree),
-            result.as_slice().len()
-        );
+        assert_eq!(self.target.dimension(output_degree), result.len());
         let OperationGeneratorPair {
             operation_degree,
             generator_degree,
@@ -191,7 +188,6 @@ where
         }
         for (i, new_output) in new_outputs.iter_mut().enumerate() {
             new_output
-                .as_slice_mut()
                 .assign(outputs_vectors.slice(target_dimension * i, target_dimension * (i + 1)));
         }
         self.outputs.push_checked(new_outputs, degree);
@@ -213,7 +209,7 @@ where
             return;
         }
         for (i, new_output) in new_outputs.iter_mut().enumerate() {
-            new_output.as_slice_mut().assign(matrix.row(i));
+            new_output.assign(matrix.row(i));
         }
         self.outputs.push_checked(new_outputs, degree);
     }

ext/crates/algebra/src/module/homomorphism/full_module_homomorphism.rs

@@ -5,7 +5,7 @@ use crate::module::homomorphism::{IdentityHomomorphism, ModuleHomomorphism, Zero
 use crate::module::Module;
 use bivec::BiVec;
 use fp::matrix::{Matrix, QuasiInverse, Subspace};
-use fp::vector::SliceMut;
+use fp::vector::{prelude::*, SliceMut};
 use once::OnceBiVec;
 
 /// A ModuleHomomorphism that simply records the matrix of the homomorphism in every degree.
@@ -62,7 +62,7 @@ impl<S: Module, T: Module<Algebra = S::Algebra>> ModuleHomomorphism
     ) {
         let output_degree = input_degree - self.degree_shift;
         if let Some(matrix) = self.matrices.get(output_degree) {
-            result.add(matrix[input_idx].as_slice(), coeff);
+            result.add(&matrix[input_idx], coeff);
         }
     }
 

ext/crates/algebra/src/module/homomorphism/hom_pullback.rs

@@ -5,7 +5,7 @@ use crate::module::homomorphism::{FreeModuleHomomorphism, ModuleHomomorphism};
 use crate::module::HomModule;
 use crate::module::{FreeModule, Module};
 use fp::matrix::{QuasiInverse, Subspace};
-use fp::vector::SliceMut;
+use fp::vector::{prelude::*, SliceMut};
 use once::OnceBiVec;
 
 /// Given a map $\mathtt{map}: A \to B$ and hom modules $\mathtt{source} = \Hom(B, X)$, $\mathtt{target} = \Hom(A, X)$, produce the induced pullback map $\Hom(B, X) \to \Hom(A, X)$.

ext/crates/algebra/src/module/homomorphism/mod.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use crate::module::Module;
 use fp::matrix::{AugmentedMatrix, Matrix, MatrixSliceMut, QuasiInverse, Subspace};
 use fp::prime::ValidPrime;
-use fp::vector::{Slice, SliceMut};
+use fp::vector::{prelude::*, Slice, SliceMut};
 
 #[cfg(feature = "concurrent")]
 use rayon::prelude::*;

ext/crates/algebra/src/module/homomorphism/quotient_homomorphism.rs

@@ -1,5 +1,5 @@
 use crate::module::{Module, QuotientModule};
-use fp::vector::{FpVector, SliceMut};
+use fp::vector::{prelude::*, FpVector, SliceMut};
 use std::sync::Arc;
 
 use crate::module::homomorphism::ModuleHomomorphism;

ext/crates/algebra/src/module/module_trait.rs

@@ -3,7 +3,7 @@ use itertools::Itertools;
 use std::sync::Arc;
 
 use fp::prime::ValidPrime;
-use fp::vector::{Slice, SliceMut};
+use fp::vector::{prelude::*, Slice, SliceMut};
 
 use crate::algebra::Algebra;
 

ext/crates/algebra/src/module/quotient_module.rs

@@ -1,7 +1,7 @@
 use crate::module::{Module, ZeroModule};
 use bivec::BiVec;
 use fp::matrix::Subspace;
-use fp::vector::{FpVector, Slice, SliceMut};
+use fp::vector::{prelude::*, FpVector, Slice, SliceMut};
 use std::sync::Arc;
 
 /// A quotient of a module truncated below a fix degree.

ext/crates/algebra/src/module/rpn.rs

@@ -5,7 +5,7 @@ use crate::algebra::{
 };
 use crate::module::{Module, ZeroModule};
 use fp::prime::{Binomial, TWO};
-use fp::vector::SliceMut;
+use fp::vector::{prelude::*, SliceMut};
 
 use std::sync::Arc;
 

ext/crates/algebra/src/module/tensor_module.rs

@@ -5,7 +5,7 @@ use crate::algebra::{Algebra, Bialgebra};
 use crate::module::block_structure::BlockStructure;
 use crate::module::{Module, ZeroModule};
 use fp::prime::minus_one_to_the_n;
-use fp::vector::{FpVector, Slice, SliceMut};
+use fp::vector::{prelude::*, FpVector, Slice, SliceMut};
 
 use std::sync::Arc;
 

ext/crates/algebra/src/steenrod_evaluator.rs

@@ -3,7 +3,7 @@ use crate::algebra::{AdemAlgebra, Algebra, MilnorAlgebra};
 use crate::milnor_algebra::{MilnorBasisElement, PPartEntry};
 use crate::steenrod_parser::*;
 use fp::prime::ValidPrime;
-use fp::vector::FpVector;
+use fp::vector::{prelude::*, FpVector};
 
 use anyhow::anyhow;
 use std::collections::BTreeMap;

ext/crates/fp/benches/criterion.rs

@@ -1,9 +1,12 @@
-use std::time::Duration;
-
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use fp::{matrix::Matrix, prime::ValidPrime};
 use rand::Rng;
 
+#[cfg(feature = "odd-primes")]
+static TEST_PRIMES: [u32; 4] = [2, 3, 5, 7];
+#[cfg(not(feature = "odd-primes"))]
+static TEST_PRIMES: [u32; 1] = [2];
+
 fn random_matrix(p: ValidPrime, dimension: usize) -> Matrix {
     Matrix::from_vec(
         p,
@@ -14,10 +17,15 @@ fn random_matrix(p: ValidPrime, dimension: usize) -> Matrix {
 }
 
 fn row_reductions(c: &mut Criterion) {
-    for p in [2, 3, 5, 7].iter() {
+    for p in TEST_PRIMES.iter() {
         let p = ValidPrime::new(*p);
         let mut group = c.benchmark_group(&format!("row_reduce_{}", p));
-        for dimension in [10, 20, 69, 100, 420, 1000] {
+        let sizes = if *p == 2 {
+            vec![10, 20, 69, 100, 420, 1000, 2000, 4000]
+        } else {
+            vec![10, 20, 69, 100, 420, 1000]
+        };
+        for dimension in sizes {
             group.bench_function(&format!("row_reduce_{}_{}", p, dimension), move |b| {
                 b.iter_batched_ref(
                     || random_matrix(p, dimension),
@@ -41,7 +49,7 @@ fn random_vector(p: ValidPrime, dimension: usize) -> Vec<u32> {
 
 criterion_group! {
     name = row_reduction;
-    config = Criterion::default().sample_size(100).measurement_time(Duration::from_secs(100));
+    config = Criterion::default().sample_size(100).measurement_time(std::time::Duration::from_secs(100));
     targets = row_reductions
 }
 

ext/crates/fp/benches/iai.rs

@@ -117,6 +117,7 @@ fn row_reduce_7_420() {
     row_reduce_p_n(ValidPrime::new(7), 420);
 }
 
+#[cfg(feature = "odd-primes")]
 iai::main!(
     row_reduce_2_10,
     row_reduce_2_20,
@@ -143,3 +144,13 @@ iai::main!(
     row_reduce_7_420,
     row_reduce_7_1000,
 );
+
+#[cfg(not(feature = "odd-primes"))]
+iai::main!(
+    row_reduce_2_10,
+    row_reduce_2_20,
+    row_reduce_2_69,
+    row_reduce_2_100,
+    row_reduce_2_420,
+    row_reduce_2_1000,
+);

ext/crates/fp/build.rs

@@ -5,8 +5,13 @@ use build_const::ConstWriter;
 type Limb = u64;
 
 fn main() -> Result<(), Error> {
+    #[cfg(feature = "odd-primes")]
     let num_primes = 8;
+    #[cfg(not(feature = "odd-primes"))]
+    let num_primes = 1;
+
     let primes = first_n_primes(num_primes);
+
     let max_prime = *primes.last().unwrap();
     let not_a_prime: usize = u32::MAX as usize; // Hack for 32-bit architectures
     let max_multinomial_len = 10;
@@ -22,15 +27,15 @@ fn main() -> Result<(), Error> {
 
     writer.add_raw("/// The number of primes that are supported.");
     writer.add_value("NUM_PRIMES", "usize", num_primes);
-    writer.add_raw("/// The `MAX_PRIME`th prime number. Constructing a `ValidPrime` using any number larger than");
+    writer.add_raw("/// The `NUM_PRIMES`th prime number. Constructing a `ValidPrime` using any number larger than");
     writer.add_raw("/// this value will cause a panic.");
     writer.add_value("MAX_PRIME", "usize", max_prime);
-    // `NOT_A_PRIME` is never used if odd-primes is disabled.
-    writer.add_raw("#[allow(dead_code)]");
     writer.add_raw(
         "/// A sentinel value. `PRIME_TO_INDEX_MAP[i] == NOT_A_PRIME` if and only if `i` is not",
     );
     writer.add_raw("/// a prime number.");
+    // `NOT_A_PRIME` is never used if odd-primes is disabled.
+    writer.add_raw("#[allow(dead_code)]");
     writer.add_value("NOT_A_PRIME", "usize", not_a_prime);
     writer.add_value("MAX_MULTINOMIAL_LEN", "usize", max_multinomial_len);
     writer.add_raw("/// An array containing the first `NUM_PRIMES` prime numbers.");

ext/crates/fp/src/lib.rs

@@ -1,17 +1,16 @@
+#![allow(unused_macros)] // For when odd-primes is disabled
+
 mod constants;
 mod limb;
 
 pub use constants::{MAX_MULTINOMIAL_LEN, NUM_PRIMES, PRIMES, PRIME_TO_INDEX_MAP};
 
+#[macro_use]
+pub(crate) mod macros;
+
 pub mod matrix;
 pub mod prime;
-#[cfg(feature = "odd-primes")]
 pub mod vector;
-pub mod vector_2;
-#[cfg(not(feature = "odd-primes"))]
-pub use vector_2 as vector;
-
-pub mod vector_inner;
 
 pub(crate) mod simd;