Enum GenerationShape 

pub enum GenerationShape {
    Scalar,
    Vector(usize),
    Matrix(usize, usize),
    Tensor3D(usize, usize, usize),
    Tensor4D(usize, usize, usize, usize),
}

Represents the shape of a tensor as it will be generated.

While tensors can conceptually have rank larger than four, even infinite, tensors in the OpenQudit Expression library are generated into a buffer indexed by 0, 1, 2, 3, or 4 physical dimensions.

Variants

Scalar

A 0-dimensional tensor (a single value).

Vector(usize)

A 1-dimensional tensor with nelems elements.

Matrix(usize, usize)

A 2-dimensional tensor (matrix) with nrows rows and ncols columns.

Tensor3D(usize, usize, usize)

A 3-dimensional tensor with nmats matrices, each of nrows rows and ncols columns.

Tensor4D(usize, usize, usize, usize)

A 4-dimensional tensor usually for derivatives (ntens, nmats, nrows, ncols)

Implementations

impl GenerationShape

pub fn num_elements(&self) -> usize

Calculates the total number of elements in a tensor with this shape.

Returns

The total number of elements as usize.

pub fn gradient_shape(&self, num_params: usize) -> Self

Determines the shape of the derivative of a tensor with respect to num_params parameters.

This method effectively prepends num_params to the current tensor’s dimensions. For example, the derivative of a Scalar with respect to num_params becomes a Vector(num_params). The derivative of a Matrix(R, C) becomes a Tensor3D(num_params, R, C).

Arguments

• num_params - The number of parameters in the gradient.

Returns

A new GenerationShape representing the shape of the gradient.

See Also

• [hessian_shape] For the shape of a hessian tensor.

pub fn hessian_shape(&self, num_params: usize) -> Self

Determine the hessian shape of a tensor with this shape that has num_params parameters.

Arguments

• num_params - The number of parameters in the hessian.

Returns

A new GenerationShape representing the shape of the hessian.

See Also

• [gradient_shape] For the shape of a gradient tensor.

pub fn to_vec(&self) -> Vec<usize>

Converts the tensor shape object to a vector of integers.

Returns

A Vec<usize> containing the dimensions of the shape.

Examples

use qudit_expr::GenerationShape;

let scalar_shape = GenerationShape::Scalar;
assert_eq!(scalar_shape.to_vec(), Vec::<usize>::new());

let vector_shape = GenerationShape::Vector(5);
assert_eq!(vector_shape.to_vec(), vec![5]);

let matrix_shape = GenerationShape::Matrix(2, 3);
assert_eq!(matrix_shape.to_vec(), vec![2, 3]);

pub fn is_scalar(&self) -> bool

Checks if the current GenerationShape is strictly a scalar variant.

pub fn is_vector(&self) -> bool

Checks if the current GenerationShape is strictly a vector variant.

pub fn is_matrix(&self) -> bool

Checks if the current GenerationShape is strictly a matrix variant.

pub fn is_tensor3d(&self) -> bool

Checks if the current GenerationShape is strictly a tensor3D variant.

pub fn is_tensor4d(&self) -> bool

Checks if the current GenerationShape is strictly a tensor4D variant.

pub fn is_0d(&self) -> bool

Check if there is only one element.

Returns

true if the shape can be treated as a scalar, false otherwise.

Examples

use qudit_expr::GenerationShape;

let test_scalar = GenerationShape::Scalar;
let test_vector = GenerationShape::Vector(1);
let test_matrix = GenerationShape::Matrix(1, 1);
let test_tensor3d = GenerationShape::Tensor3D(1, 1, 1);

let test_vector_2 = GenerationShape::Vector(9);
let test_matrix_2 = GenerationShape::Matrix(9, 9);
let test_tensor3d_2 = GenerationShape::Tensor3D(1, 9, 9);

assert!(test_scalar.is_0d());
assert!(test_vector.is_0d());
assert!(test_matrix.is_0d());
assert!(test_tensor3d.is_0d());

assert_eq!(test_vector_2.is_0d(), false);
assert_eq!(test_matrix_2.is_0d(), false);
assert_eq!(test_tensor3d_2.is_0d(), false);

pub fn is_1d(&self) -> bool

Check if the shape can be conceptually treated as a 1d tensor.

Returns

true if the shape has exactly one dimension with 1 or more elements.

Examples

use qudit_expr::GenerationShape;

let test_vector = GenerationShape::Vector(9);
let test_matrix = GenerationShape::Matrix(1, 9);
let test_tensor3d = GenerationShape::Tensor3D(1, 1, 9);

let test_scalar = GenerationShape::Scalar;
let test_matrix_2 = GenerationShape::Matrix(9, 9);
let test_tensor3d_2 = GenerationShape::Tensor3D(1, 9, 9);

assert!(test_vector.is_1d());
assert!(test_matrix.is_1d());
assert!(test_tensor3d.is_1d());

assert_eq!(test_scalar.is_1d(), false);
assert_eq!(test_matrix_2.is_1d(), false);
assert_eq!(test_tensor3d_2.is_1d(), false);

pub fn is_2d(&self) -> bool

Checks if the current GenerationShape can be conceptually treated as a 2-dimensional matrix. This is true for GenerationShape variants with a dimensionality of at least 2, with any additional dimensions having size 1.

Returns

true if the shape can be treated as a matrix, false otherwise.

Examples

use qudit_expr::GenerationShape;

let test_scalar = GenerationShape::Scalar;
let test_vector = GenerationShape::Vector(1);
let test_tensor3d_2 = GenerationShape::Tensor3D(9, 9, 9);
let test_tensor_nd_2 = GenerationShape::Tensor4D(1, 9, 9, 9);

let test_matrix = GenerationShape::Matrix(9, 9);
let test_tensor3d = GenerationShape::Tensor3D(1, 9, 9);
let test_tensor_nd = GenerationShape::Tensor4D(1, 1, 9, 9);

assert_eq!(test_scalar.is_2d(), false);
assert_eq!(test_vector.is_2d(), false);
assert_eq!(test_tensor3d_2.is_2d(), false);
assert_eq!(test_tensor_nd_2.is_2d(), false);

assert_eq!(test_matrix.is_2d(), true);
assert_eq!(test_tensor3d.is_2d(), true);
assert_eq!(test_tensor_nd.is_2d(), true);

pub fn is_3d(&self) -> bool

Checks if the current GenerationShape can be conceptually treated as a 3D tensor. This is true for GenerationShape variants with a dimensionality of at least 3, with any additional dimensions having size 1.

Returns

true if the shape can be treated as a 3D tensor, false otherwise.

Examples

use qudit_expr::GenerationShape;

let test_scalar = GenerationShape::Scalar;
let test_vector = GenerationShape::Vector(1);
let test_matrix = GenerationShape::Matrix(1, 1);
let test_tensor_nd_2 = GenerationShape::Tensor4D(9, 1, 9, 9);

let test_tensor3d = GenerationShape::Tensor3D(9, 9, 9);
let test_tensor_nd = GenerationShape::Tensor4D(1, 9, 9, 9);

assert_eq!(test_scalar.is_3d(), false);
assert_eq!(test_vector.is_3d(), false);
assert_eq!(test_matrix.is_3d(), false);
assert_eq!(test_tensor_nd_2.is_3d(), false);

assert_eq!(test_tensor3d.is_3d(), true);
assert_eq!(test_tensor_nd.is_3d(), true);

pub fn is_4d(&self) -> bool

Checks if the current GenerationShape can be conceptually treated as a 4D tensor. This is true for GenerationShape variants with a dimensionality of at least 4, with any additional dimensions having size 1.

Returns

true if the shape can be treated as a 4D tensor, false otherwise.

Examples

use qudit_expr::GenerationShape;

let test_scalar = GenerationShape::Scalar;
let test_vector = GenerationShape::Vector(1);
let test_matrix = GenerationShape::Matrix(1, 1);
let test_tensor3d = GenerationShape::Tensor3D(1, 1, 1);

let test_tensor4d = GenerationShape::Tensor4D(9, 9, 9, 9);
let test_tensor_nd = GenerationShape::Tensor4D(1, 9, 9, 9);

assert_eq!(test_scalar.is_4d(), false);
assert_eq!(test_vector.is_4d(), false);
assert_eq!(test_matrix.is_4d(), false);
assert_eq!(test_tensor3d.is_4d(), false);

assert_eq!(test_tensor4d.is_4d(), true);
assert_eq!(test_tensor_nd.is_4d(), true);

pub fn ncols(&self) -> usize

Returns the number of columns for the current shape.

Returns

The number of columns.

Examples

use qudit_expr::GenerationShape;
let matrix_shape = GenerationShape::Matrix(2, 3);
assert_eq!(matrix_shape.ncols(), 3);

pub fn nrows(&self) -> usize

Returns the number of rows for the current shape.

Returns

The number of rows.

Examples

use qudit_expr::GenerationShape;
let matrix_shape = GenerationShape::Matrix(2, 3);
assert_eq!(matrix_shape.nrows(), 2);

pub fn nmats(&self) -> usize

Returns the number of matrices for the current shape.

Returns

The number of matrices.

Examples

use qudit_expr::GenerationShape;
let tensor3d_shape = GenerationShape::Tensor3D(5, 2, 3);
assert_eq!(tensor3d_shape.nmats(), 5);

pub fn ntens(&self) -> usize

Returns the number of tensors (in the first dimension) for the current shape.

Returns

The number of tensors.

Examples

use qudit_expr::GenerationShape;
let tensor4d_shape = GenerationShape::Tensor4D(7, 5, 2, 3);
assert_eq!(tensor4d_shape.ntens(), 7);

pub fn calculate_directions(&self, index_sizes: &[usize]) -> Vec<IndexDirection>

Trait Implementations

impl Add for GenerationShape

type Output = GenerationShape

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl Clone for GenerationShape

fn clone(&self) -> GenerationShape

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GenerationShape

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

Formats the value using the given formatter.

impl<I: AsRef<[TensorIndex]>> From<I> for GenerationShape

fn from(indices: I) -> Self

Converts to this type from the input type.

impl Hash for GenerationShape

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for GenerationShape

fn cmp(&self, other: &GenerationShape) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for GenerationShape

fn eq(&self, other: &GenerationShape) -> 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 PartialOrd for GenerationShape

fn partial_cmp(&self, other: &GenerationShape) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for GenerationShape

impl Eq for GenerationShape

impl StructuralPartialEq for GenerationShape