Struct BackendScalar 

pub struct BackendScalar { /* private fields */ }

Dynamic scalar used across tensor4all backends.

This is a tensor4all-owned rank-0 wrapper over tenferro’s dynamic tensor.

Examples

use tensor4all_tensorbackend::BackendScalar;

// Real scalar
let a = BackendScalar::new_real(3.14);
assert!((a.real() - 3.14).abs() < 1e-10);
assert_eq!(a.imag(), 0.0);
assert!(a.is_real());
assert!(!a.is_complex());

// Complex scalar
let b = BackendScalar::new_complex(1.0, 2.0);
assert!((b.real() - 1.0).abs() < 1e-10);
assert!((b.imag() - 2.0).abs() < 1e-10);
assert!(b.is_complex());

// Arithmetic
let c = BackendScalar::new_real(2.0);
let d = a + c;
assert!((d.real() - 5.14).abs() < 1e-10);

Implementations

impl BackendScalar

pub fn from_value<T: ScalarTensorElement>(value: T) -> Self

Creates a scalar from any supported public tensor element type.

Examples

use tensor4all_tensorbackend::BackendScalar;

let s = BackendScalar::from_value(3.14_f64);
assert!((s.real() - 3.14).abs() < 1e-10);

use num_complex::Complex64;
let z = BackendScalar::from_value(Complex64::new(1.0, 2.0));
assert!(z.is_complex());
assert!((z.real() - 1.0).abs() < 1e-10);
assert!((z.imag() - 2.0).abs() < 1e-10);

pub fn from_real(x: f64) -> Self

Creates a real scalar from an f64 value.

Examples

use tensor4all_tensorbackend::BackendScalar;

let s = BackendScalar::from_real(2.5);
assert!((s.real() - 2.5).abs() < 1e-10);
assert!(s.is_real());

pub fn from_complex(re: f64, im: f64) -> Self

Creates a complex scalar from real and imaginary parts.

Examples

use tensor4all_tensorbackend::BackendScalar;

let s = BackendScalar::from_complex(1.0, -1.0);
assert!((s.real() - 1.0).abs() < 1e-10);
assert!((s.imag() - (-1.0)).abs() < 1e-10);
assert!(s.is_complex());

pub fn new_real(x: f64) -> Self

Backward-compatible constructor for a real scalar.

Examples

use tensor4all_tensorbackend::BackendScalar;

let s = BackendScalar::new_real(42.0);
assert!((s.real() - 42.0).abs() < 1e-10);

pub fn new_complex(re: f64, im: f64) -> Self

Backward-compatible constructor for a complex scalar.

Examples

use tensor4all_tensorbackend::BackendScalar;

let s = BackendScalar::new_complex(3.0, 4.0);
assert!((s.abs() - 5.0).abs() < 1e-10); // |3 + 4i| = 5

pub fn primal(&self) -> Self

Returns the scalar’s plain rank-0 tensor value.

Examples

use tensor4all_tensorbackend::BackendScalar;

let s = BackendScalar::new_real(5.0);
let p = s.primal();
assert!((p.real() - 5.0).abs() < 1e-10);

pub fn real(&self) -> f64

Returns the real part while intentionally dropping AD metadata.

Examples

use tensor4all_tensorbackend::BackendScalar;

let s = BackendScalar::new_complex(3.0, 4.0);
assert!((s.real() - 3.0).abs() < 1e-10);

pub fn imag(&self) -> f64

Returns the imaginary part while intentionally dropping AD metadata.

Returns 0.0 for real scalars.

Examples

use tensor4all_tensorbackend::BackendScalar;

let s = BackendScalar::new_complex(3.0, 4.0);
assert!((s.imag() - 4.0).abs() < 1e-10);

let r = BackendScalar::new_real(5.0);
assert_eq!(r.imag(), 0.0);

pub fn abs(&self) -> f64

Returns the absolute value while intentionally dropping AD metadata.

For complex scalars, returns the complex modulus (sqrt(re^2 + im^2)).

Examples

use tensor4all_tensorbackend::BackendScalar;

let s = BackendScalar::new_complex(3.0, 4.0);
assert!((s.abs() - 5.0).abs() < 1e-10);

let r = BackendScalar::new_real(-7.0);
assert!((r.abs() - 7.0).abs() < 1e-10);

pub fn is_complex(&self) -> bool

Returns true when the scalar is complex.

Examples

use tensor4all_tensorbackend::BackendScalar;

assert!(BackendScalar::new_complex(1.0, 0.0).is_complex());
assert!(!BackendScalar::new_real(1.0).is_complex());

pub fn is_real(&self) -> bool

Returns true when the scalar is real.

Examples

use tensor4all_tensorbackend::BackendScalar;

assert!(BackendScalar::new_real(1.0).is_real());
assert!(!BackendScalar::new_complex(1.0, 2.0).is_real());

pub fn is_zero(&self) -> bool

Returns true when the scalar is zero.

Examples

use tensor4all_tensorbackend::BackendScalar;

assert!(BackendScalar::new_real(0.0).is_zero());
assert!(!BackendScalar::new_real(1.0).is_zero());

pub fn as_f64(&self) -> Option<f64>

Returns the underlying value as f64 when real.

Returns None for complex scalars.

Examples

use tensor4all_tensorbackend::BackendScalar;

let r = BackendScalar::new_real(2.5);
assert_eq!(r.as_f64(), Some(2.5));

let c = BackendScalar::new_complex(1.0, 1.0);
assert_eq!(c.as_f64(), None);

pub fn as_c64(&self) -> Option<Complex64>

Returns the underlying value as Complex64 when complex.

Returns None for real scalars.

Examples

use tensor4all_tensorbackend::BackendScalar;
use num_complex::Complex64;

let c = BackendScalar::new_complex(1.0, 2.0);
assert_eq!(c.as_c64(), Some(Complex64::new(1.0, 2.0)));

let r = BackendScalar::new_real(1.0);
assert_eq!(r.as_c64(), None);

pub fn conj(&self) -> Self

Returns the complex conjugate.

For real scalars, returns a copy (conjugate of a real number is itself).

Examples

use tensor4all_tensorbackend::BackendScalar;

let c = BackendScalar::new_complex(3.0, 4.0);
let cc = c.conj();
assert!((cc.real() - 3.0).abs() < 1e-10);
assert!((cc.imag() - (-4.0)).abs() < 1e-10);

let r = BackendScalar::new_real(5.0);
assert!((r.conj().real() - 5.0).abs() < 1e-10);

pub fn real_part(&self) -> Self

Returns the real part as a scalar, preserving scalar semantics.

Unlike real, this returns an BackendScalar rather than raw f64.

Examples

use tensor4all_tensorbackend::BackendScalar;

let c = BackendScalar::new_complex(3.0, 4.0);
let re = c.real_part();
assert!(re.is_real());
assert!((re.real() - 3.0).abs() < 1e-10);

pub fn imag_part(&self) -> Self

Returns the imaginary part as a scalar, preserving scalar semantics.

Unlike imag, this returns an BackendScalar rather than raw f64. The result is always a real scalar.

Examples

use tensor4all_tensorbackend::BackendScalar;

let c = BackendScalar::new_complex(3.0, 4.0);
let im = c.imag_part();
assert!(im.is_real());
assert!((im.real() - 4.0).abs() < 1e-10);

pub fn compose_complex(real: Self, imag: Self) -> Result<Self>

Compose a complex scalar from real-valued parts.

Errors

Returns an error when either input is not a real scalar (a dtype mismatch failure).

Examples

use tensor4all_tensorbackend::BackendScalar;

let re = BackendScalar::new_real(3.0);
let im = BackendScalar::new_real(4.0);
let c = BackendScalar::compose_complex(re, im).unwrap();
assert!(c.is_complex());
assert!((c.real() - 3.0).abs() < 1e-10);
assert!((c.imag() - 4.0).abs() < 1e-10);

pub fn sqrt(&self) -> Self

Square root, preserving AD metadata.

Automatically promotes to complex if the value is negative.

Examples

use tensor4all_tensorbackend::BackendScalar;

let s = BackendScalar::new_real(9.0);
assert!((s.sqrt().real() - 3.0).abs() < 1e-10);

pub fn powf(&self, exponent: f64) -> Self

Real exponent power, preserving AD metadata.

Automatically promotes to complex when the base is negative and the exponent is non-integer.

Examples

use tensor4all_tensorbackend::BackendScalar;

let s = BackendScalar::new_real(2.0);
assert!((s.powf(3.0).real() - 8.0).abs() < 1e-10);

pub fn powi(&self, exponent: i32) -> Self

Integer exponent power, preserving AD metadata.

Examples

use tensor4all_tensorbackend::BackendScalar;

let s = BackendScalar::new_real(3.0);
assert!((s.powi(2).real() - 9.0).abs() < 1e-10);

Trait Implementations

impl Add for BackendScalar

type Output = BackendScalar

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for BackendScalar

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BackendScalar

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

Formats the value using the given formatter.

impl Default for BackendScalar

fn default() -> Self

Returns the “default value” for a type.

impl Display for BackendScalar

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

Formats the value using the given formatter.

impl Div for BackendScalar

type Output = BackendScalar

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl Div<BackendScalar> for Complex64

type Output = BackendScalar

The resulting type after applying the / operator.

fn div(self, rhs: BackendScalar) -> Self::Output

Performs the / operation.

impl From<BackendScalar> for Complex64

fn from(value: BackendScalar) -> Self

Converts to this type from the input type.

impl From<Complex<f32>> for BackendScalar

fn from(value: Complex32) -> Self

Converts to this type from the input type.

impl From<Complex<f64>> for BackendScalar

fn from(value: Complex64) -> Self

Converts to this type from the input type.

impl From<f32> for BackendScalar

fn from(value: f32) -> Self

Converts to this type from the input type.

impl From<f64> for BackendScalar

fn from(value: f64) -> Self

Converts to this type from the input type.

impl Mul for BackendScalar

type Output = BackendScalar

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl Mul<BackendScalar> for f64

type Output = BackendScalar

The resulting type after applying the * operator.

fn mul(self, rhs: BackendScalar) -> Self::Output

Performs the * operation.

impl Mul<BackendScalar> for Complex64

type Output = BackendScalar

The resulting type after applying the * operator.

fn mul(self, rhs: BackendScalar) -> Self::Output

Performs the * operation.

impl Mul<BackendScalar> for &Storage

Multiply storage by a scalar (BackendScalar). May promote f64 storage to Complex64 when scalar is complex.

type Output = Storage

The resulting type after applying the * operator.

fn mul(self, scalar: BackendScalar) -> Self::Output

Performs the * operation.

impl Neg for BackendScalar

type Output = BackendScalar

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl One for BackendScalar

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl PartialEq for BackendScalar

fn eq(&self, other: &Self) -> 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 BackendScalar

fn partial_cmp(&self, other: &Self) -> 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 Sub for BackendScalar

type Output = BackendScalar

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl SumFromStorage for BackendScalar

fn sum_from_storage(storage: &Storage) -> Self

Compute the sum of all elements in the storage.

impl TryFrom<BackendScalar> for f64

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: BackendScalar) -> Result<Self, Self::Error>

Performs the conversion.

impl Zero for BackendScalar

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.