Struct Complex 

pub struct Complex { /* private fields */ }

Dataset container for double-precision (f64) examples.

Same shape and semantics as Data, but stores features and labels with f64 precision for algorithms or tests that require higher numeric fidelity. A complex number represented by real and imaginary components

This is a lightweight, copy-friendly type suitable for use in tensors and GPU computations. It implements all standard complex arithmetic operations and integrates seamlessly with the tensor framework.

Properties

• Copy: Can be freely copied without performance penalty
• DeviceCopy: Compatible with CUDA memory transfers
• Comparable: Implements PartialEq for complex comparison

Example

use iron_learn::Complex;

let z1 = Complex::new(3.0, 4.0);   // 3 + 4i
let z2 = Complex::new(1.0, 2.0);   // 1 + 2i

let sum = z1 + z2;                 // 4 + 6i
let product = z1 * z2;             // -5 + 10i

Implementations

impl Complex

pub fn new(real: f64, imaginary: f64) -> Self

Creates a new complex number from real and imaginary parts

Arguments

• real - The real component of the complex number
• imaginary - The imaginary component of the complex number

Returns

A new Complex instance

Example

use iron_learn::Complex;

let z = Complex::new(3.0, 4.0);  // Represents 3 + 4i

Trait Implementations

impl Add for Complex

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

Adds two complex numbers

Implements complex addition: (a + bi) + (c + di) = (a + c) + (b + d)i

Arguments

• rhs - The complex number to add

Returns

The sum of the two complex numbers

Example

use iron_learn::Complex;

let a = Complex::new(1.0, 2.0);
let b = Complex::new(3.0, 4.0);
let sum = a + b;
assert_eq!(sum, Complex::new(4.0, 6.0));

type Output = Complex

The resulting type after applying the + operator.

impl Clone for Complex

fn clone(&self) -> Complex

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Complex

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

Formats the value using the given formatter.

impl Display for Complex

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

Formats complex number in standard mathematical notation

Examples:

• 3 + 4i for Complex::new(3.0, 4.0)
• 2 - 1i for Complex::new(2.0, -1.0)

Example

use iron_learn::Complex;

let z = Complex::new(1.0, 2.0);
println!("{}", z);  // Output: "1 + 2i"

impl Div for Complex

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

Divides one complex number by another

Implements complex division using conjugate multiplication: (a + bi)/(c + di) = ((ac + bd) + (bc - ad)i) / (c² + d²)

Arguments

• rhs - The complex number to divide by

Returns

The quotient of the two complex numbers

Panics

Does not panic on division by zero; returns NaN/Inf values

Example

use iron_learn::Complex;

let a = Complex::new(1.0, 2.0);
let b = Complex::new(3.0, 4.0);
let quotient = a / b;
assert_eq!(quotient, Complex::new(0.44, 0.08));

type Output = Complex

The resulting type after applying the / operator.

impl Mul for Complex

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

Multiplies two complex numbers

Implements complex multiplication using the distributive property: (a + bi)(c + di) = (ac - bd) + (ad + bc)i

Arguments

• rhs - The complex number to multiply by

Returns

The product of the two complex numbers

Example

use iron_learn::Complex;

let a = Complex::new(1.0, 2.0);
let b = Complex::new(3.0, 4.0);
let product = a * b;
assert_eq!(product, Complex::new(-5.0, 10.0));

type Output = Complex

The resulting type after applying the * operator.

impl Neg for Complex

fn neg(self) -> Self::Output

Negates a complex number

Multiplies both real and imaginary parts by -1

Returns

The negated complex number

Example

use iron_learn::Complex;

let a = Complex::new(1.0, 2.0);
let negated = -a;
assert_eq!(negated, Complex::new(-1.0, -2.0));

type Output = Complex

The resulting type after applying the - operator.

impl Numeric for Complex

Implementation of Numeric for the Complex type from the complex module.

fn zero() -> Self

Returns a complex number representing zero.

fn one() -> Self

Returns a complex number representing one.

fn f32(&self) -> f32

Returns f32 equivalent of t

fn f64(&self) -> f64

Returns f64 equivalent of t

fn from_u32(value: u32) -> Self

Casts the value to Self and returns

impl PartialEq for Complex

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

fn partial_cmp(&self, other: &Complex) -> 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 Complex

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

Subtracts one complex number from another

Implements complex subtraction: (a + bi) - (c + di) = (a - c) + (b - d)i

Arguments

• rhs - The complex number to subtract

Returns

The difference of the two complex numbers

Example

use iron_learn::Complex;

let a = Complex::new(1.0, 2.0);
let b = Complex::new(3.0, 4.0);
let diff = a - b;
assert_eq!(diff, Complex::new(-2.0, -2.0));

type Output = Complex

The resulting type after applying the - operator.

impl Copy for Complex

impl SignedNumeric for Complex

impl StructuralPartialEq for Complex