Struct BlockTensor 

pub struct BlockTensor<T: TensorLike> { /* private fields */ }

A collection of tensors organized in a block structure.

Each block is a tensor of type T implementing TensorLike. The flattened block list is ordered row-by-row: (0, 0), (0, 1), ..., (1, 0), (1, 1), ....

Type Parameters

• T - The tensor type for each block, must implement TensorLike

Implementations

impl<T: TensorLike> BlockTensor<T>

pub fn try_new(blocks: Vec<T>, shape: (usize, usize)) -> Result<Self>

Create a new block tensor with validation.

Arguments

• blocks - Vector of blocks flattened row-by-row
• shape - Block structure as (rows, cols)

Errors

Returns an error if rows * cols != blocks.len().

pub fn new(blocks: Vec<T>, shape: (usize, usize)) -> Self

Create a new block tensor.

Arguments

• blocks - Vector of blocks flattened row-by-row
• shape - Block structure as (rows, cols)

Panics

Panics if rows * cols != blocks.len().

pub fn shape(&self) -> (usize, usize)

Get the block structure (rows, cols).

pub fn num_blocks(&self) -> usize

Get the total number of blocks.

pub fn get(&self, row: usize, col: usize) -> &T

Get a reference to the block at (row, col).

Panics

Panics if the indices are out of bounds.

pub fn get_mut(&mut self, row: usize, col: usize) -> &mut T

Get a mutable reference to the block at (row, col).

Panics

Panics if the indices are out of bounds.

pub fn blocks(&self) -> &[T]

Get all blocks as a slice.

pub fn blocks_mut(&mut self) -> &mut [T]

Get all blocks as a mutable slice.

pub fn into_blocks(self) -> Vec<T>

Consume self and return the blocks.

pub fn validate_indices(&self) -> Result<()>

Validate that blocks share external indices consistently.

For column vectors (cols=1), no index sharing is required between blocks. Different rows can have independent physical indices (the operator determines their relationship).

For matrices (rows x cols), checks that:

• All blocks have the same number of external indices.
• Blocks in the same row share some common index IDs (output indices).
• Blocks in the same column share some common index IDs (input indices).

Trait Implementations

impl<T: Clone + TensorLike> Clone for BlockTensor<T>

fn clone(&self) -> BlockTensor<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + TensorLike> Debug for BlockTensor<T>

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

Formats the value using the given formatter.

impl<T: TensorLike> TensorIndex for BlockTensor<T>

type Index = <T as TensorIndex>::Index

The index type used by this object.

fn external_indices(&self) -> Vec<Self::Index>

Return flattened external indices for this object.

fn replaceind( &self, old_index: &Self::Index, new_index: &Self::Index, ) -> Result<Self>

Replace an index in this object.

fn replaceinds( &self, old_indices: &[Self::Index], new_indices: &[Self::Index], ) -> Result<Self>

Replace multiple indices in this object.

fn num_external_indices(&self) -> usize

Number of external indices.

fn replaceinds_pairs( &self, pairs: &[(Self::Index, Self::Index)], ) -> Result<Self>

Replace indices using pairs of (old, new).

impl<T: TensorLike> TensorLike for BlockTensor<T>

fn norm_squared(&self) -> f64

Compute the squared Frobenius norm of the tensor.

fn maxabs(&self) -> f64

Maximum absolute value of all elements (L-infinity norm).

fn scale(&self, scalar: AnyScalar) -> Result<Self>

Scalar multiplication.

fn axpby(&self, a: AnyScalar, other: &Self, b: AnyScalar) -> Result<Self>

Compute a linear combination: a * self + b * other.

fn inner_product(&self, other: &Self) -> Result<AnyScalar>

Inner product (dot product) of two tensors.

fn conj(&self) -> Self

Tensor conjugate operation.

fn validate(&self) -> Result<()>

Validate structural consistency of this tensor.

fn factorize( &self, _left_inds: &[<Self as TensorIndex>::Index], _options: &FactorizeOptions, ) -> Result<FactorizeResult<Self>, FactorizeError>

Factorize this tensor into left and right factors.

fn direct_sum( &self, _other: &Self, _pairs: &[(<Self as TensorIndex>::Index, <Self as TensorIndex>::Index)], ) -> Result<DirectSumResult<Self>>

Direct sum of two tensors along specified index pairs.

fn outer_product(&self, _other: &Self) -> Result<Self>

Outer product (tensor product) of two tensors.

fn permuteinds( &self, _new_order: &[<Self as TensorIndex>::Index], ) -> Result<Self>

Permute tensor indices to match the specified order.

fn contract(_tensors: &[&Self], _allowed: AllowedPairs<'_>) -> Result<Self>

Contract multiple tensors over their contractable indices.

fn contract_connected( _tensors: &[&Self], _allowed: AllowedPairs<'_>, ) -> Result<Self>

Contract multiple tensors that must form a connected graph.

fn diagonal( _input_index: &<Self as TensorIndex>::Index, _output_index: &<Self as TensorIndex>::Index, ) -> Result<Self>

Create a diagonal (Kronecker delta) tensor for a single index pair.

fn scalar_one() -> Result<Self>

Create a scalar tensor with value 1.0.

fn ones(_indices: &[<Self as TensorIndex>::Index]) -> Result<Self>

Create a tensor filled with 1.0 for the given indices.

fn onehot(_index_vals: &[(<Self as TensorIndex>::Index, usize)]) -> Result<Self>

Create a one-hot tensor with value 1.0 at the specified index positions.

fn norm(&self) -> f64

Compute the Frobenius norm of the tensor.

fn sub(&self, other: &Self) -> Result<Self>

Element-wise subtraction: self - other.

fn neg(&self) -> Result<Self>

Negate all elements: -self.

fn isapprox(&self, other: &Self, atol: f64, rtol: f64) -> bool

Approximate equality check (Julia isapprox semantics).

fn delta( input_indices: &[<Self as TensorIndex>::Index], output_indices: &[<Self as TensorIndex>::Index], ) -> Result<Self>

Create a delta (identity) tensor as outer product of diagonals.