boilerplate with NormVector encoding

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>

Author: connortsui20

vortex-tensor/src/encodings/mod.rs

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+pub mod norm;
+// mod spherical;

vortex-tensor/src/encodings/norm/array.rs

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayRef;
+
+/// A normalized array that stores unit-normalized vectors alongside their original L2 norms.
+///
+/// Each vector in the array is divided by its L2 norm, producing a unit-normalized vector. The
+/// original norms are stored separately so that the original vectors can be reconstructed.
+#[derive(Debug, Clone)]
+pub struct NormVectorArray {
+    /// The backing vector array that has been unit normalized.
+    ///
+    /// The underlying elements of the vector array must be floating-point.
+    vector_array: ArrayRef,
+
+    /// The L2 (Frobenius) norms of each vector.
+    ///
+    /// This must have the same dtype as the elements of the vector array.
+    norms: ArrayRef,
+}
+
+impl NormVectorArray {
+    /// Returns a reference to the backing vector array that has been unit normalized.
+    pub fn vector_array(&self) -> &ArrayRef {
+        &self.vector_array
+    }
+
+    /// Returns a reference to the L2 (Frobenius) norms of each vector.
+    pub fn norms(&self) -> &ArrayRef {
+        &self.norms
+    }
+}

vortex-tensor/src/encodings/norm/mod.rs

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+mod array;
+pub use array::NormVectorArray;
+
+// pub(crate) mod compute;
+
+mod vtable;
+pub use vtable::NormVector;
+
+// #[cfg(test)]
+// mod tests;

vortex-tensor/src/encodings/norm/vtable/mod.rs

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::hash::Hasher;
+
+use vortex::array::ArrayRef;
+use vortex::array::EmptyMetadata;
+use vortex::array::ExecutionCtx;
+use vortex::array::ExecutionStep;
+use vortex::array::Precision;
+use vortex::array::buffer::BufferHandle;
+use vortex::array::serde::ArrayChildren;
+use vortex::array::stats::StatsSetRef;
+use vortex::array::vtable;
+use vortex::array::vtable::ArrayId;
+use vortex::array::vtable::VTable;
+use vortex::array::vtable::ValidityVTableFromChild;
+use vortex::dtype::DType;
+use vortex::error::VortexResult;
+use vortex::session::VortexSession;
+
+use crate::encodings::norm::array::NormVectorArray;
+
+mod operations;
+mod validity;
+
+vtable!(NormVector);
+
+#[derive(Debug)]
+pub struct NormVector;
+
+impl VTable for NormVector {
+    type Array = NormVectorArray;
+    type Metadata = EmptyMetadata;
+    type OperationsVTable = Self;
+    type ValidityVTable = ValidityVTableFromChild;
+
+    fn id(_array: &NormVectorArray) -> ArrayId {
+        ArrayId::new_ref("vortex.tensor.norm_vector")
+    }
+
+    fn len(array: &NormVectorArray) -> usize {
+        array.vector_array().len()
+    }
+
+    fn dtype(array: &NormVectorArray) -> &DType {
+        array.vector_array().dtype()
+    }
+
+    fn stats(array: &NormVectorArray) -> StatsSetRef<'_> {
+        array.vector_array().statistics()
+    }
+
+    fn array_hash<H: Hasher>(array: &NormVectorArray, state: &mut H, precision: Precision) {
+        todo!()
+    }
+
+    fn array_eq(array: &NormVectorArray, other: &NormVectorArray, precision: Precision) -> bool {
+        todo!()
+    }
+
+    fn nbuffers(array: &NormVectorArray) -> usize {
+        todo!()
+    }
+
+    fn buffer(array: &NormVectorArray, idx: usize) -> BufferHandle {
+        todo!()
+    }
+
+    fn buffer_name(array: &NormVectorArray, idx: usize) -> Option<String> {
+        todo!()
+    }
+
+    fn nchildren(array: &NormVectorArray) -> usize {
+        todo!()
+    }
+
+    fn child(array: &NormVectorArray, idx: usize) -> ArrayRef {
+        todo!()
+    }
+
+    fn child_name(array: &NormVectorArray, idx: usize) -> String {
+        todo!()
+    }
+
+    fn metadata(array: &NormVectorArray) -> VortexResult<Self::Metadata> {
+        todo!()
+    }
+
+    fn serialize(metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
+        todo!()
+    }
+
+    fn deserialize(
+        bytes: &[u8],
+        _dtype: &DType,
+        _len: usize,
+        _buffers: &[BufferHandle],
+        _session: &VortexSession,
+    ) -> VortexResult<Self::Metadata> {
+        todo!()
+    }
+
+    fn build(
+        dtype: &DType,
+        len: usize,
+        metadata: &Self::Metadata,
+        buffers: &[BufferHandle],
+        children: &dyn ArrayChildren,
+    ) -> VortexResult<NormVectorArray> {
+        todo!()
+    }
+
+    fn with_children(array: &mut NormVectorArray, children: Vec<ArrayRef>) -> VortexResult<()> {
+        todo!()
+    }
+
+    fn execute(array: &NormVectorArray, ctx: &mut ExecutionCtx) -> VortexResult<ExecutionStep> {
+        todo!()
+    }
+}

vortex-tensor/src/encodings/norm/vtable/operations.rs

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::vtable::OperationsVTable;
+use vortex::error::VortexResult;
+use vortex::scalar::Scalar;
+
+use crate::encodings::norm::array::NormVectorArray;
+use crate::encodings::norm::vtable::NormVector;
+
+impl OperationsVTable<NormVector> for NormVector {
+    fn scalar_at(array: &NormVectorArray, index: usize) -> VortexResult<Scalar> {
+        todo!()
+    }
+}

vortex-tensor/src/encodings/norm/vtable/validity.rs

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex::array::ArrayRef;
+use vortex::array::vtable::ValidityChild;
+
+use crate::encodings::norm::array::NormVectorArray;
+use crate::encodings::norm::vtable::NormVector;
+
+impl ValidityChild<NormVector> for NormVector {
+    fn validity_child(array: &NormVectorArray) -> &ArrayRef {
+        array.vector_array()
+    }
+}

vortex-tensor/src/lib.rs

@@ -5,8 +5,10 @@
 //! including unit vectors, spherical coordinates, and similarity measures such as cosine
 //! similarity.
 
+pub mod matcher;
+pub mod scalar_fns;
+
 pub mod fixed_shape;
 pub mod vector;
 
-pub mod matcher;
-pub mod scalar_fns;
+pub mod encodings;