Struct Spensor 

pub struct Spensor { /* private fields */ }

A tensor class that can be either dense or sparse with flexible data types.

The tensor can store data as floats, complex numbers, or symbolic expressions. Tensors have an associated structure that defines their shape and index properties.

Examples

from symbolica.community.spenso import Tensor, TensorIndices, Representation structure = TensorIndices(Representation.euc(4)(1)) data = [1.0, 2.0, 3.0, 4.0] tensor = Tensor.dense(structure, data) sparse_tensor = Tensor.sparse(structure, float)

Implementations

impl Spensor

pub fn structure(&self) -> SpensoIndices

pub fn sparse( structure: ConvertibleToStructure, type_info: Bound<'_, PyType>, ) -> PyResult<Spensor>

Create a new sparse empty tensor with the given structure and data type.

Parameters

structure : TensorIndices or list of Slots The tensor structure defining shape and index properties type_info : type The data type - either float or Expression class

Returns

Tensor A new sparse tensor with all elements initially zero

Examples

from symbolica.community.spenso import Tensor, TensorIndices, Representation as R structure = TensorIndices(R.euc(3)(1), R.euc(3)(2)) sparse_float = Tensor.sparse(structure, float) sparse_sym = Tensor.sparse(structure, symbolica.Expression)

pub fn dense( structure: ConvertibleToStructure, data: AtomsOrFloats, ) -> PyResult<Spensor>

Create a new dense tensor with the given structure and data.

Parameters

structure : TensorIndices or list of Slots The tensor structure defining shape and index properties data : list of float, complex, or Expression The tensor data in row-major order

Returns

Tensor A new dense tensor with the specified data

Examples

from symbolica import S from symbolica.community.spenso import Tensor, TensorIndices, Representation as R structure = TensorIndices(R.euc(2)(1), R.euc(2)(2)) data = [1.0, 2.0, 3.0, 4.0] tensor = Tensor.dense(structure, data) x, y = S(“x”, “y”) sym_data = [x, y, x * y, x + y] sym_tensor = Tensor.dense(structure, sym_data)

pub fn one() -> Spensor

Create a scalar tensor with value 1.0.

Returns

Tensor A scalar tensor containing the value 1.0

Examples

from symbolica.community.spenso import Tensor one = Tensor.one()

pub fn zero() -> Spensor

Create a scalar tensor with value 0.0.

Returns

Tensor A scalar tensor containing the value 0.0

Examples

from symbolica.community.spenso import Tensor zero = Tensor.zero()

pub fn evaluator( &self, constants: HashMap<PythonExpression, PythonExpression>, funs: HashMap<(PolyVariable, String, Vec<PolyVariable>), PythonExpression>, params: Vec<PythonExpression>, iterations: usize, n_cores: usize, verbose: bool, ) -> PyResult<SpensoExpressionEvaluator>

Create an optimized evaluator for symbolic tensor expressions.

Create an optimized evaluator for symbolic tensor expressions.

Compiles the symbolic expressions in this tensor into an optimized evaluation tree that can efficiently compute numerical values for different parameter inputs.

Parameters

constants : dict Dict mapping symbolic expressions to their constant numerical values funs : dict Dict mapping function signatures to their symbolic definitions params : list of Expression List of symbolic parameters that will be varied during evaluation iterations : int, optional Number of optimization iterations for Horner scheme (default: 100) n_cores : int, optional Number of CPU cores to use for optimization (default: 4) verbose : bool, optional Whether to print optimization progress (default: False)

Returns

TensorEvaluator An optimized evaluator for efficient numerical evaluation

Examples

from symbolica import S from symbolica.community.spenso import Tensor, TensorIndices, Representation as R x, y = S(“x”, “y”) structure = TensorIndices(R.euc(2)(1)) tensor = Tensor.dense(structure, [x * y, x + y]) evaluator = tensor.evaluator(constants={}, funs={}, params=[x, y], iterations=50) results = evaluator.evaluate_complex([[1.0, 2.0], [3.0, 4.0]])

Trait Implementations

impl Clone for Spensor

fn clone(&self) -> Spensor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Deref for Spensor

type Target = ParamOrConcrete<RealOrComplexTensor<f64, NamedStructure<Symbol, Vec<Atom>>>, NamedStructure<Symbol, Vec<Atom>>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefToPyAny for Spensor

impl ExtractPyClassWithClone for Spensor

impl From<DataTensor<Complex<f64>, NamedStructure<Symbol, Vec<Atom>>>> for Spensor

fn from( value: DataTensor<Complex<f64>, ShadowedStructure<AbstractIndex>>, ) -> Self

Converts to this type from the input type.

impl From<DataTensor<f64, NamedStructure<Symbol, Vec<Atom>>>> for Spensor

fn from(value: DataTensor<f64, ShadowedStructure<AbstractIndex>>) -> Self

Converts to this type from the input type.

impl From<ParamOrConcrete<RealOrComplexTensor<f64, NamedStructure<Symbol, Vec<Atom>>>, NamedStructure<Symbol, Vec<Atom>>>> for Spensor

fn from(value: MixedTensor<f64, ShadowedStructure<AbstractIndex>>) -> Self

Converts to this type from the input type.

impl<'py> IntoPyObject<'py> for Spensor

type Target = Spensor

The Python output type

type Output = Bound<'py, <Spensor as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for Spensor

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for Spensor

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// A tensor class that can be either dense or sparse with flexible data types. /// /// The tensor can store data as floats, complex numbers, or symbolic expressions. /// Tensors have an associated structure that defines their shape and index properties. /// /// Examples /// -------- /// >>> from symbolica.community.spenso import Tensor, TensorIndices, Representation /// >>> structure = TensorIndices(Representation.euc(4)(1)) /// >>> data = [1.0, 2.0, 3.0, 4.0] /// >>> tensor = Tensor.dense(structure, data) /// >>> sparse_tensor = Tensor.sparse(structure, float)

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<Spensor>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClass__setitem__SlotFragment<Spensor> for PyClassImplCollector<Spensor>

unsafe fn __setitem__( self, py: Python<'_>, _raw_slf: *mut PyObject, arg0: *mut PyObject, arg1: NonNull<PyObject>, ) -> PyResult<()>

Safety: _slf and _attr must be valid non-null Python objects

impl PyMethods<Spensor> for PyClassImplCollector<Spensor>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for Spensor

const NAME: &'static str = "Tensor"

Class name.

const MODULE: Option<&'static str>

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.