vortex-tensor 0.75.0

Vortex tensor extension type
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright the Vortex contributors

//! Matcher for tensor-like extension types.

use vortex_array::dtype::PType;
use vortex_array::dtype::extension::ExtDTypeRef;
use vortex_array::dtype::extension::Matcher;

use crate::types::fixed_shape_tensor::AnyFixedShapeTensor;
use crate::types::fixed_shape_tensor::FixedShapeTensorMatcherMetadata;
use crate::types::vector::AnyVector;
use crate::types::vector::VectorMatcherMetadata;

/// Matcher for any tensor-like extension type.
///
/// Currently the different kinds of tensors that are available are:
///
/// - `FixedShapeTensor`
/// - `Vector`
pub struct AnyTensor;

/// The matched variant of a tensor-like extension type.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TensorMatch<'a> {
    /// A [`FixedShapeTensor`](crate::fixed_shape_tensor::FixedShapeTensor) extension type.
    FixedShapeTensor(FixedShapeTensorMatcherMetadata<'a>),

    /// A [`Vector`](crate::vector::Vector) extension type.
    ///
    /// Note that we store an owned type here wrapping (copyable) data from the dtype.
    Vector(VectorMatcherMetadata),
}

impl TensorMatch<'_> {
    /// Returns the tensor element type for this tensor-like dtype.
    pub fn element_ptype(self) -> PType {
        match self {
            Self::FixedShapeTensor(metadata) => metadata.element_ptype(),
            Self::Vector(metadata) => metadata.element_ptype(),
        }
    }

    /// Returns the flattened element count for each logical tensor row.
    pub fn list_size(self) -> u32 {
        match self {
            Self::FixedShapeTensor(metadata) => metadata.flat_list_size(),
            Self::Vector(metadata) => metadata.dimensions(),
        }
    }
}

impl Matcher for AnyTensor {
    type Match<'a> = TensorMatch<'a>;

    fn try_match<'a>(ext_dtype: &'a ExtDTypeRef) -> Option<Self::Match<'a>> {
        if let Some(metadata) = ext_dtype.metadata_opt::<AnyFixedShapeTensor>() {
            return Some(TensorMatch::FixedShapeTensor(metadata));
        }

        // Special logic for vectors to get convenience metadata (instead of `EmptyMetadata`).
        if let Some(metadata) = ext_dtype.metadata_opt::<AnyVector>() {
            return Some(TensorMatch::Vector(metadata));
        }

        None
    }
}