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().

Examples

use tensor4all_core::block_tensor::BlockTensor;
use tensor4all_core::{DynIndex, TensorDynLen};

let i = DynIndex::new_dyn(2);
let t1 = TensorDynLen::from_dense(vec![i.clone()], vec![1.0, 2.0]).unwrap();
let t2 = TensorDynLen::from_dense(vec![i.clone()], vec![3.0, 4.0]).unwrap();

let bt = BlockTensor::try_new(vec![t1, t2], (2, 1)).unwrap();
assert_eq!(bt.shape(), (2, 1));

// Wrong number of blocks returns an error
let t3 = TensorDynLen::from_dense(vec![i], vec![5.0, 6.0]).unwrap();
assert!(BlockTensor::try_new(vec![t3], (2, 1)).is_err());

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().

Examples

use tensor4all_core::block_tensor::BlockTensor;
use tensor4all_core::{DynIndex, TensorDynLen};

let i = DynIndex::new_dyn(2);
let t = TensorDynLen::from_dense(vec![i], vec![1.0, 2.0]).unwrap();
let bt = BlockTensor::new(vec![t], (1, 1));
assert_eq!(bt.shape(), (1, 1));

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

Get the block structure (rows, cols).

Examples

use tensor4all_core::block_tensor::BlockTensor;
use tensor4all_core::{DynIndex, TensorDynLen};

let i = DynIndex::new_dyn(2);
let blocks: Vec<TensorDynLen> = (0..6)
    .map(|_| TensorDynLen::from_dense(vec![i.clone()], vec![0.0, 0.0]).unwrap())
    .collect();
let bt = BlockTensor::new(blocks, (2, 3));
assert_eq!(bt.shape(), (2, 3));

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.

Examples

use tensor4all_core::block_tensor::BlockTensor;
use tensor4all_core::{DynIndex, TensorDynLen};

let i = DynIndex::new_dyn(2);
let t1 = TensorDynLen::from_dense(vec![i.clone()], vec![1.0, 2.0]).unwrap();
let t2 = TensorDynLen::from_dense(vec![i], vec![3.0, 4.0]).unwrap();
let bt = BlockTensor::new(vec![t1, t2], (2, 1));
assert_eq!(bt.get(0, 0).dims(), vec![2]);
assert_eq!(bt.get(1, 0).dims(), vec![2]);

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.

Examples

use tensor4all_core::block_tensor::BlockTensor;
use tensor4all_core::{DynIndex, TensorDynLen};

let i = DynIndex::new_dyn(2);
let t = TensorDynLen::from_dense(vec![i.clone()], vec![1.0, 2.0]).unwrap();
let mut bt = BlockTensor::new(vec![t], (1, 1));
let block = bt.get_mut(0, 0);
assert_eq!(block.dims(), vec![2]);

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

Get all blocks as a slice.

Examples

use tensor4all_core::block_tensor::BlockTensor;
use tensor4all_core::{DynIndex, TensorDynLen};

let i = DynIndex::new_dyn(2);
let t1 = TensorDynLen::from_dense(vec![i.clone()], vec![1.0, 2.0]).unwrap();
let t2 = TensorDynLen::from_dense(vec![i], vec![3.0, 4.0]).unwrap();
let bt = BlockTensor::new(vec![t1, t2], (1, 2));
assert_eq!(bt.blocks().len(), 2);

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

Get all blocks as a mutable slice.

Examples

use tensor4all_core::block_tensor::BlockTensor;
use tensor4all_core::{DynIndex, TensorDynLen};

let i = DynIndex::new_dyn(2);
let t = TensorDynLen::from_dense(vec![i], vec![1.0, 2.0]).unwrap();
let mut bt = BlockTensor::new(vec![t], (1, 1));
assert_eq!(bt.blocks_mut().len(), 1);

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

Consume self and return the blocks.

Examples

use tensor4all_core::block_tensor::BlockTensor;
use tensor4all_core::{DynIndex, TensorDynLen};

let i = DynIndex::new_dyn(2);
let t = TensorDynLen::from_dense(vec![i], vec![1.0, 2.0]).unwrap();
let bt = BlockTensor::new(vec![t], (1, 1));
let blocks = bt.into_blocks();
assert_eq!(blocks.len(), 1);
assert_eq!(blocks[0].dims(), vec![2]);

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).

Examples

use tensor4all_core::block_tensor::BlockTensor;
use tensor4all_core::{DynIndex, TensorDynLen};

// Column vector: always valid regardless of index sharing
let i = DynIndex::new_dyn(2);
let j = DynIndex::new_dyn(2);
let t1 = TensorDynLen::from_dense(vec![i], vec![1.0, 2.0]).unwrap();
let t2 = TensorDynLen::from_dense(vec![j], vec![3.0, 4.0]).unwrap();
let bt = BlockTensor::new(vec![t1, t2], (2, 1));
assert!(bt.validate_indices().is_ok());

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 factorize_full_rank( &self, _left_inds: &[<Self as TensorIndex>::Index], _alg: FactorizeAlg, _canonical: Canonical, ) -> Result<FactorizeResult<Self>, FactorizeError>

Factorize this tensor without applying truncation controls.

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 fuse_indices( &self, old_indices: &[Self::Index], new_index: Self::Index, order: LinearizationOrder, ) -> Result<Self>

Fuse local tensor indices into one replacement index.

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.