Struct Tensor 

pub struct Tensor { /* private fields */ }

An immutable, strided tensor whose packed backing storage is shared by views.

Construction accepts at most MAX_RANK axes and MAX_ELEMENTS elements. Slices and transposes retain the same storage; reshaping a noncontiguous view materializes row-major bytes. Binary operations require matching types and use trailing-axis broadcasting. Serialization is {dtype, shape, data}, where every data entry is an exact decimal scalar string.

Implementations

impl Tensor

pub fn inspect( &self, options: TensorInspectionOptions, ) -> Result<TensorInspection, DataError>

Inspects this tensor without cloning or materializing its backing storage.

Views are visited in logical row-major order through their shape and strides. The inspection reads no more than options.max_samples, capped by MAX_INSPECTION_SAMPLES.

impl Tensor

pub fn from_scalars( dtype: DType, shape: Vec<usize>, values: Vec<Scalar>, ) -> Result<Self, DataError>

Creates a contiguous tensor from scalars of dtype.

pub fn from_le_bytes( dtype: DType, shape: Vec<usize>, bytes: Vec<u8>, ) -> Result<Self, DataError>

Creates a contiguous tensor from packed little-endian scalar bytes.

pub fn zeros(dtype: DType, shape: Vec<usize>) -> Result<Self, DataError>

Creates a zero-filled contiguous tensor.

pub fn dtype(&self) -> DType

Returns the scalar type.

pub fn shape(&self) -> &[usize]

Returns the dimensions in logical axis order.

pub fn strides(&self) -> &[isize]

Returns element strides for each logical axis.

pub fn len(&self) -> usize

Returns the logical element count.

pub fn is_empty(&self) -> bool

Reports whether the tensor has no logical elements.

pub fn byte_len(&self) -> usize

Returns the packed byte count of the logical tensor.

pub fn storage_byte_len(&self) -> usize

Returns the physical byte length of the shared backing allocation.

pub fn get(&self, indices: &[isize]) -> Result<Scalar, DataError>

Reads one scalar using Python-style negative indices.

pub fn slice(&self, indices: &[AxisIndex]) -> Result<Self, DataError>

Produces a shared-storage slice using Python indexing rules.

pub fn with_slice( &self, indices: &[AxisIndex], replacement: &Self, ) -> Result<Self, DataError>

Replaces a selection in a new contiguous tensor of the original shape.

Replacement values broadcast across the selected shape using trailing axes. A rank-zero replacement fills the selection with a single scalar. Source and replacement may share storage: every replacement value is read from its original immutable allocation, so overlapping assignment is safe. Noncontiguous source views are copied in logical row-major order.

Errors

Rejects invalid selectors, different element types, or replacement shapes that cannot broadcast into exactly the selection’s shape. On error, source and replacement remain unchanged.

use konjure_sdk::data::{AxisIndex, DType, Scalar, Tensor};
let original = Tensor::zeros(DType::I16, vec![2, 3])?;
let row = Tensor::from_scalars(DType::I16, vec![3],
    ["1", "2", "3"].into_iter().map(|text| Scalar::parse(DType::I16, text))
        .collect::<Result<Vec<_>, _>>()?)?;
let updated = original.with_slice(&[AxisIndex::Index(-1)], &row)?;
assert_eq!(updated.get(&[1, 2])?.to_string(), "3");
assert_eq!(original.get(&[1, 2])?.to_string(), "0");

pub fn with_index_path( &self, path: &[Vec<AxisIndex>], replacement: &Self, ) -> Result<Self, DataError>

Replaces a selection formed by successive indexing expressions.

Each path entry indexes the preceding view. All entries are composed before one logical payload copy, including for a noncontiguous source. An empty path selects the entire tensor. Broadcasting and immutability follow Self::with_slice.

Errors

Rejects paths longer than MAX_RANK, invalid selectors, mixed types, and replacement shapes that cannot broadcast into the final selection.

pub fn reshape(&self, shape: Vec<usize>) -> Result<Self, DataError>

Changes dimensions while preserving logical row-major order.

pub fn transpose(&self, axes: &[usize]) -> Result<Self, DataError>

Reorders axes; each old axis must occur exactly once.

pub fn binary(&self, operation: BinaryOp, rhs: &Self) -> Result<Self, DataError>

Applies a scalar operation with NumPy trailing-axis broadcasting.

pub fn scalar_binary( &self, operation: BinaryOp, rhs: Scalar, ) -> Result<Self, DataError>

Applies a scalar operation to every element.

pub fn convert(&self, dtype: DType) -> Result<Self, DataError>

Converts every scalar to dtype.

pub fn sum(&self) -> Result<Scalar, DataError>

Returns the additive reduction, or zero for an empty tensor.

pub fn neg(&self) -> Result<Self, DataError>

Returns the element-wise arithmetic negation.

pub fn matmul(&self, rhs: &Self) -> Result<Self, DataError>

Multiplies rank-two-or-greater tensors, broadcasting leading batch axes.

pub fn to_scalars(&self) -> Vec<Scalar>

Materializes logical elements in row-major order.

pub fn to_le_bytes(&self) -> Vec<u8>

Materializes logical elements as packed little-endian scalar bytes.

Trait Implementations

impl Clone for Tensor

fn clone(&self) -> Tensor

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Tensor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Tensor

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for Tensor

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Tensor

impl PartialEq for Tensor

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Tensor

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.