Unify the two matrix types

diskann-benchmark-core/src/build/graph/multi.rs

@@ -10,7 +10,7 @@ use diskann::{
     graph::{self, glue},
     provider,
 };
-use diskann_utils::{future::AsyncFriendly, views::Matrix};
+use diskann_utils::{future::AsyncFriendly, matrix::Matrix};
 
 use crate::build::{Build, ids::ToId};
 

diskann-benchmark-core/src/build/graph/single.rs

@@ -10,7 +10,7 @@ use diskann::{
     graph::{self, glue},
     provider,
 };
-use diskann_utils::{future::AsyncFriendly, views::Matrix};
+use diskann_utils::{future::AsyncFriendly, matrix::Matrix};
 
 use crate::build::{Build, ids::ToId};
 

diskann-benchmark-core/src/recall.rs

@@ -9,8 +9,8 @@ use std::{
 };
 
 use diskann_utils::{
+    matrix::{Matrix, MatrixView},
     strided::StridedView,
-    views::{Matrix, MatrixView},
 };
 use thiserror::Error;
 
@@ -364,7 +364,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use diskann_utils::views::{self, Matrix};
+    use diskann_utils::matrix::{self, Matrix};
 
     use super::*;
 
@@ -380,7 +380,7 @@ mod tests {
     fn test_rows() {
         let mut i = 0usize;
         let mat = Matrix::new(
-            views::Init(|| {
+            matrix::Init(|| {
                 let v = i;
                 i += 1;
                 v

diskann-benchmark-core/src/search/api.rs

@@ -9,7 +9,7 @@ use diskann::{ANNResult, graph, utils::async_tools};
 use diskann_benchmark_runner::utils::MicroSeconds;
 use diskann_utils::{
     future::{AsyncFriendly, boxit},
-    views::{self, Matrix},
+    matrix::{self, Matrix},
 };
 
 use crate::{
@@ -517,7 +517,7 @@ where
     T: Search,
 {
     let mut lengths = Vec::with_capacity(range.len());
-    let mut ids = Matrix::new(views::Init(T::Id::default), range.len(), num_ids.into());
+    let mut ids = Matrix::new(matrix::Init(T::Id::default), range.len(), num_ids.into());
 
     let mut latencies = Vec::<MicroSeconds>::with_capacity(range.len());
     let mut outputs = Vec::<T::Output>::with_capacity(range.len());

diskann-benchmark-core/src/search/graph/inline.rs

@@ -10,7 +10,7 @@ use diskann::{
     graph::{self, ext::labeled, glue, search::AdaptiveL},
     provider,
 };
-use diskann_utils::{future::AsyncFriendly, views::Matrix};
+use diskann_utils::{future::AsyncFriendly, matrix::Matrix};
 
 use crate::search::{self, Search, graph::Strategy};
 

diskann-benchmark-core/src/search/graph/knn.rs

@@ -13,7 +13,7 @@ use diskann::{
     provider,
 };
 use diskann_benchmark_runner::utils::{MicroSeconds, percentiles};
-use diskann_utils::{future::AsyncFriendly, views::Matrix};
+use diskann_utils::{future::AsyncFriendly, matrix::Matrix};
 
 use crate::{
     recall,

diskann-benchmark-core/src/search/graph/multihop.rs

@@ -10,7 +10,7 @@ use diskann::{
     graph::{self, ext::labeled, glue},
     provider,
 };
-use diskann_utils::{future::AsyncFriendly, views::Matrix};
+use diskann_utils::{future::AsyncFriendly, matrix::Matrix};
 
 use crate::search::{self, Search, graph::Strategy};
 

diskann-benchmark-core/src/search/graph/range.rs

@@ -11,7 +11,7 @@ use diskann::{
     provider,
 };
 use diskann_benchmark_runner::utils::{MicroSeconds, percentiles};
-use diskann_utils::{future::AsyncFriendly, views::Matrix};
+use diskann_utils::{future::AsyncFriendly, matrix::Matrix};
 
 use crate::{
     recall,

diskann-benchmark-core/src/search/ids.rs

@@ -3,7 +3,7 @@
  * Licensed under the MIT license.
  */
 
-use diskann_utils::views::{self, Matrix};
+use diskann_utils::matrix::{self, Matrix};
 
 use crate::recall;
 
@@ -231,7 +231,7 @@ where
                 len,
                 num_ids,
             } => {
-                let mut dst = Matrix::new(views::Init(|| I::default()), len, num_ids);
+                let mut dst = Matrix::new(matrix::Init(|| I::default()), len, num_ids);
                 let mut lengths = Vec::with_capacity(len);
 
                 let mut output_row = 0;

diskann-benchmark-core/src/streaming/executors/bigann/withdata.rs

@@ -5,7 +5,7 @@
 
 use std::{ops::Range, path::Path, sync::Arc};
 
-use diskann_utils::views::{Matrix, MatrixView};
+use diskann_utils::matrix::{Matrix, MatrixView};
 
 use crate::{recall, streaming};
 

diskann-benchmark-simd/src/lib.rs

@@ -7,7 +7,7 @@
 
 use std::{io::Write, num::NonZeroUsize};
 
-use diskann_utils::views::{Matrix, MatrixView};
+use diskann_utils::matrix::{Matrix, MatrixView};
 use diskann_vector::distance::simd;
 use diskann_wide::Architecture;
 use half::f16;
@@ -755,7 +755,7 @@ impl<Q, D> Data<Q, D> {
             .map(|_| StandardUniform.sample(&mut rng))
             .collect();
         let data = Matrix::<D>::new(
-            diskann_utils::views::Init(|| StandardUniform.sample(&mut rng)),
+            diskann_utils::matrix::Init(|| StandardUniform.sample(&mut rng)),
             run.num_points.get(),
             run.dim.get(),
         );

diskann-benchmark/src/disk_index/search.rs

@@ -31,7 +31,7 @@ use diskann_providers::{
     utils::{create_thread_pool, ParallelIteratorInPool},
 };
 use diskann_tools::utils::{search_index_utils, KRecallAtN};
-use diskann_utils::views::Matrix;
+use diskann_utils::matrix::Matrix;
 use serde::{Deserialize, Serialize};
 
 use crate::{

diskann-benchmark/src/exhaustive/algos.rs

@@ -33,15 +33,15 @@ where
 
 #[derive(Debug, Clone)]
 pub(super) struct LinearSearch {
-    pub(super) ids: diskann_utils::views::Matrix<u32>,
+    pub(super) ids: diskann_utils::matrix::Matrix<u32>,
     pub(super) preprocess: Vec<MicroSeconds>,
     pub(super) search: Vec<MicroSeconds>,
     pub(super) total: MicroSeconds,
 }
 
 pub(super) fn linear_search<Q, C>(
     store: &Q,
-    queries: diskann_utils::views::MatrixView<f32>,
+    queries: diskann_utils::matrix::MatrixView<f32>,
     builder: &C,
     results_per_query: usize,
     progress: &indicatif::ProgressBar,
@@ -51,7 +51,7 @@ where
     C: CreateQuantComputer<Q> + Sync,
 {
     let mut output =
-        diskann_utils::views::Matrix::<u32>::new(u32::MAX, queries.nrows(), results_per_query);
+        diskann_utils::matrix::Matrix::<u32>::new(u32::MAX, queries.nrows(), results_per_query);
 
     struct Times {
         preprocess: MicroSeconds,

diskann-benchmark/src/exhaustive/minmax.rs

@@ -370,7 +370,7 @@ mod imp {
     pub(super) struct Store<const NBITS: usize> {
         // The number of bytes to take from each row.
         bytes: usize,
-        data: diskann_utils::views::Matrix<u8>,
+        data: diskann_utils::matrix::Matrix<u8>,
         quantizer: diskann_quantization::minmax::MinMaxQuantizer,
     }
 
@@ -379,7 +379,7 @@ mod imp {
         Unsigned: Representation<NBITS>,
     {
         fn new(
-            input: diskann_utils::views::MatrixView<f32>,
+            input: diskann_utils::matrix::MatrixView<f32>,
             quantizer: diskann_quantization::minmax::MinMaxQuantizer,
             progress: &ProgressBar,
         ) -> anyhow::Result<Self> {
@@ -389,7 +389,7 @@ mod imp {
             // The APIs below should correctly handle these variables.
             let output_dim = quantizer.output_dim();
             let bytes = Data::<NBITS>::canonical_bytes(output_dim);
-            let mut data = diskann_utils::views::Matrix::new(0, input.nrows(), bytes);
+            let mut data = diskann_utils::matrix::Matrix::new(0, input.nrows(), bytes);
 
             // Compress the data.
             //

diskann-benchmark/src/exhaustive/product.rs

@@ -322,18 +322,18 @@ mod imp {
 
     /// A store for quantized data.
     pub(super) struct Store {
-        data: diskann_utils::views::Matrix<u8>,
+        data: diskann_utils::matrix::Matrix<u8>,
         quantizer: diskann_providers::model::pq::FixedChunkPQTable,
     }
 
     impl Store {
         fn new(
-            input: diskann_utils::views::MatrixView<f32>,
+            input: diskann_utils::matrix::MatrixView<f32>,
             quantizer: diskann_providers::model::pq::FixedChunkPQTable,
             progress: &ProgressBar,
         ) -> anyhow::Result<Self> {
             let mut data =
-                diskann_utils::views::Matrix::new(0, input.nrows(), quantizer.get_num_chunks());
+                diskann_utils::matrix::Matrix::new(0, input.nrows(), quantizer.get_num_chunks());
 
             // Compress the data.
             #[allow(clippy::disallowed_methods)]

diskann-benchmark/src/exhaustive/spherical.rs

@@ -394,7 +394,7 @@ mod imp {
     pub(super) struct Store<const NBITS: usize> {
         // The number of bytes to take from each row.
         bytes: usize,
-        data: diskann_utils::views::Matrix<u8>,
+        data: diskann_utils::matrix::Matrix<u8>,
         plan: diskann_quantization::spherical::iface::Impl<NBITS>,
     }
 
@@ -405,7 +405,7 @@ mod imp {
             for<'a> CompressIntoWith<&'a [f32], DataMut<'a, NBITS>, ScopedAllocator<'a>>,
     {
         fn new(
-            input: diskann_utils::views::MatrixView<f32>,
+            input: diskann_utils::matrix::MatrixView<f32>,
             plan: diskann_quantization::spherical::iface::Impl<NBITS>,
             progress: &ProgressBar,
         ) -> anyhow::Result<Self> {
@@ -416,7 +416,7 @@ mod imp {
             let output_dim = plan.quantizer().output_dim();
             let bytes =
                 diskann_quantization::spherical::DataRef::<NBITS>::canonical_bytes(output_dim);
-            let mut data = diskann_utils::views::Matrix::new(0, input.nrows(), bytes);
+            let mut data = diskann_utils::matrix::Matrix::new(0, input.nrows(), bytes);
 
             // Compress the data.
             #[allow(clippy::disallowed_methods)]

diskann-benchmark/src/flat/search.rs

@@ -24,7 +24,7 @@ use diskann_benchmark_runner::{
     utils::{datatype::AsDataType, percentiles, MicroSeconds},
     Benchmark, Checkpoint, Registry,
 };
-use diskann_utils::{future::SendFuture, views::Matrix};
+use diskann_utils::{future::SendFuture, matrix::Matrix};
 use diskann_vector::{distance::Metric, PreprocessedDistanceFunction};
 use half::f16;
 use serde::Serialize;

diskann-benchmark/src/index/benchmarks.rs

@@ -31,7 +31,7 @@ use diskann_providers::{
 };
 use diskann_utils::{
     future::AsyncFriendly,
-    views::{Matrix, MatrixView},
+    matrix::{Matrix, MatrixView},
 };
 use half::f16;
 

diskann-benchmark/src/index/bftree/full_precision_streaming.rs

@@ -24,7 +24,7 @@ use diskann_providers::{
     model::graph::provider::async_::common::FullPrecision,
     storage::{FileStorageProvider, SaveWith},
 };
-use diskann_utils::views::{Matrix, MatrixView};
+use diskann_utils::matrix::{Matrix, MatrixView};
 
 use crate::{
     index::{

diskann-benchmark/src/index/bftree/spherical.rs

@@ -23,7 +23,7 @@ use diskann_quantization::{
         SphericalQuantizer,
     },
 };
-use diskann_utils::views::Matrix;
+use diskann_utils::matrix::Matrix;
 use rand::SeedableRng;
 
 use crate::{

diskann-benchmark/src/index/bftree/spherical_streaming.rs

@@ -30,7 +30,7 @@ use diskann_quantization::spherical::{
     iface::{self as spherical_iface, Quantizer},
     SphericalQuantizer,
 };
-use diskann_utils::views::{Matrix, MatrixView};
+use diskann_utils::matrix::{Matrix, MatrixView};
 use rand::SeedableRng;
 
 use crate::{

diskann-benchmark/src/index/build.rs

@@ -23,7 +23,7 @@ use diskann_providers::{
 };
 use diskann_utils::{
     future::AsyncFriendly,
-    views::{Matrix, MatrixView},
+    matrix::{Matrix, MatrixView},
 };
 use indicatif::{ProgressBar, ProgressStyle};
 use serde::Serialize;

diskann-benchmark/src/index/inmem/product.rs

@@ -49,7 +49,7 @@ mod imp {
             IndexConfiguration,
         },
     };
-    use diskann_utils::views::{Matrix, MatrixView};
+    use diskann_utils::matrix::{Matrix, MatrixView};
 
     use diskann_benchmark_runner::{
         benchmark::{MatchContext, Score},

diskann-benchmark/src/index/inmem/scalar.rs

@@ -69,7 +69,7 @@ mod imp {
             graph::provider::async_::{common, inmem},
         },
     };
-    use diskann_utils::views::{Matrix, MatrixView};
+    use diskann_utils::matrix::{Matrix, MatrixView};
 
     use crate::{
         index::{

diskann-benchmark/src/index/inmem/spherical.rs

@@ -75,7 +75,7 @@ mod imp {
         model::graph::provider::async_::{common, inmem},
     };
     use diskann_quantization::alloc::GlobalAllocator;
-    use diskann_utils::views::Matrix;
+    use diskann_utils::matrix::Matrix;
     use rand::SeedableRng;
     use serde::Serialize;
     use std::{io::Write, sync::Arc};

diskann-benchmark/src/index/streaming/full_precision.rs

@@ -19,7 +19,7 @@ use diskann_providers::model::graph::provider::async_::{
 };
 use diskann_utils::{
     future::AsyncFriendly,
-    views::{Matrix, MatrixView},
+    matrix::{Matrix, MatrixView},
 };
 
 use super::{

diskann-benchmark/src/index/streaming/managed.rs

@@ -11,7 +11,7 @@ use diskann_benchmark_core::{
     streaming::{self, executors},
 };
 use diskann_benchmark_runner::{timed, utils::MicroSeconds};
-use diskann_utils::views::{Matrix, MatrixView};
+use diskann_utils::matrix::{Matrix, MatrixView};
 
 use crate::utils::streaming::TagSlotManager;
 

diskann-benchmark/src/multi_vector/driver.rs

@@ -14,7 +14,7 @@ use diskann_benchmark_runner::{
     },
     Checker, Input,
 };
-use diskann_quantization::multi_vector::{Mat, MatRef, MaxSimKernel, Overflow, Standard};
+use diskann_quantization::multi_vector::{Mat, MatRef, MaxSimKernel, Overflow, RowMajor};
 use rand::{
     distr::{Distribution, StandardUniform},
     rngs::StdRng,
@@ -68,8 +68,8 @@ impl Input for MultiVectorTolerance {
 
 /// Random query / doc fixture for a single benchmark run.
 pub(super) struct Data<T: Copy> {
-    pub(super) queries: Mat<Standard<T>>,
-    pub(super) docs: Mat<Standard<T>>,
+    pub(super) queries: Mat<RowMajor<T>>,
+    pub(super) docs: Mat<RowMajor<T>>,
 }
 
 impl<T: Copy> Data<T>
@@ -79,11 +79,11 @@ where
     pub(super) fn new(run: &Run) -> Result<Self, Overflow> {
         let mut rng = StdRng::seed_from_u64(0x12345);
         let queries = Mat::from_fn(
-            Standard::new(run.num_query_vectors.get(), run.dim.get())?,
+            RowMajor::new(run.num_query_vectors.get(), run.dim.get())?,
             || StandardUniform.sample(&mut rng),
         );
         let docs = Mat::from_fn(
-            Standard::new(run.num_doc_vectors.get(), run.dim.get())?,
+            RowMajor::new(run.num_doc_vectors.get(), run.dim.get())?,
             || StandardUniform.sample(&mut rng),
         );
         Ok(Self { queries, docs })
@@ -96,7 +96,7 @@ where
 
 pub(super) fn run_with_kernel<T: Copy>(
     run: &Run,
-    doc: MatRef<'_, Standard<T>>,
+    doc: MatRef<'_, RowMajor<T>>,
     kernel: &dyn MaxSimKernel<T>,
 ) -> RunResult {
     let mut scores = vec![0.0f32; run.num_query_vectors.get()];