Enum Tensor 

pub enum Tensor {
    Scalar(f64),
    Array(Vec<Tensor>),
}

A multi-dimensional numerical array.

Tensors can be scalars (single values) or arrays of nested tensors. All leaf values are stored as f64.

Examples

use hedl_core::lex::{parse_tensor, Tensor};

// Scalar
let scalar = Tensor::Scalar(42.0);
assert_eq!(scalar.shape(), vec![]);
assert_eq!(scalar.flatten(), vec![42.0]);

// 1D array
let vec = parse_tensor("[1, 2, 3]").unwrap();
assert_eq!(vec.shape(), vec![3]);
assert!(vec.is_integer());

// 2D matrix
let matrix = parse_tensor("[[1.5, 2.5], [3.5, 4.5]]").unwrap();
assert_eq!(matrix.shape(), vec![2, 2]);
assert!(!matrix.is_integer());

Variants

Scalar(f64)

A scalar number (integer or float).

Array(Vec<Tensor>)

A nested array of tensors.

Implementations

impl Tensor

pub fn is_integer(&self) -> bool

Returns true if this tensor contains only integers (no decimal points).

A number is considered an integer if its fractional part is zero.

Examples

use hedl_core::lex::{parse_tensor, Tensor};

let integers = parse_tensor("[1, 2, 3]").unwrap();
assert!(integers.is_integer());

let floats = parse_tensor("[1.5, 2.5]").unwrap();
assert!(!floats.is_integer());

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

Returns the shape of the tensor as a vector of dimensions.

Examples

use hedl_core::lex::{parse_tensor, Tensor};

let scalar = Tensor::Scalar(42.0);
assert_eq!(scalar.shape(), vec![]);

let vec = parse_tensor("[1, 2, 3]").unwrap();
assert_eq!(vec.shape(), vec![3]);

let matrix = parse_tensor("[[1, 2], [3, 4]]").unwrap();
assert_eq!(matrix.shape(), vec![2, 2]);

pub fn flatten(&self) -> Vec<f64>

Flattens the tensor into a 1D vector of f64 values in row-major order.

Examples

use hedl_core::lex::parse_tensor;

let matrix = parse_tensor("[[1, 2], [3, 4]]").unwrap();
assert_eq!(matrix.flatten(), vec![1.0, 2.0, 3.0, 4.0]);

pub fn is_scalar(&self) -> bool

Returns true if this is a scalar value.

pub fn is_array(&self) -> bool

Returns true if this is an array.

pub fn ndim(&self) -> usize

Returns the number of dimensions (0 for scalar).

pub fn len(&self) -> usize

Returns the total number of elements.

pub fn is_empty(&self) -> bool

Returns true if the tensor has no elements.

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: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Tensor

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

Formats the tensor as a parseable HEDL tensor literal.

This produces output that can be parsed back by parse_tensor().

impl PartialEq for Tensor

fn eq(&self, other: &Tensor) -> 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>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Tensor