Struct Complex 

pub struct Complex { /* private fields */ }

Nombre complexe en virgule flottante simple précision.

Représenté sous forme cartésienne re + im·i.

Invariants

Aucun invariant fort n’est imposé : NaN et Infinity sont autorisés (ils se propagent naturellement comme en IEEE 754).

Implementations

impl Complex

pub const ZERO: Self

Le zéro complexe 0 + 0i.

pub const ONE: Self

L’unité réelle 1 + 0i.

pub const I: Self

L’unité imaginaire 0 + 1i.

pub const fn new(re: f32, im: f32) -> Self

Crée un nouveau nombre complexe re + im·i.

use embedded_complex_f32::Complex;
let z = Complex::new(1.0, -2.0);
assert_eq!(z.re(), 1.0);
assert_eq!(z.im(), -2.0);

pub const fn re(self) -> f32

Partie réelle.

pub const fn im(self) -> f32

Partie imaginaire.

pub fn is_nan(self) -> bool

Retourne true si l’un des composants est NaN.

pub fn is_infinite(self) -> bool

Retourne true si l’un des composants est infini.

pub fn is_finite(self) -> bool

Retourne true si les deux composants sont finis.

impl Complex

pub fn conj(self) -> Self

Conjugué : re - im·i.

use embedded_complex_f32::Complex;
let z = Complex::new(3.0, -4.0);
assert_eq!(z.conj(), Complex::new(3.0, 4.0));

pub fn norm(self) -> f32

Norme (module) : √(re² + im²).

Utilise embedded_f32_sqrt::sqrt aucune dépendance C requise.

use embedded_complex_f32::Complex;
let z = Complex::new(3.0, 4.0);
assert!((z.norm() - 5.0).abs() < 1e-4);

pub fn norm_sq(self) -> f32

Carré de la norme : re² + im² (évite la racine carrée).

use embedded_complex_f32::Complex;
let z = Complex::new(3.0, 4.0);
assert!((z.norm_sq() - 25.0).abs() < 1e-4);

pub fn checked_div(self, rhs: Self) -> Result<Self, ComplexError>

Division vérifiée — retourne Err(ComplexError::DivisionByZero) si |rhs| == 0.

use embedded_complex_f32::{Complex, ComplexError};
let z = Complex::new(1.0, 0.0);
assert_eq!(z.checked_div(Complex::ZERO), Err(ComplexError::DivisionByZero));

pub fn inv(self) -> Result<Self, ComplexError>

Inverse : 1 / self.

Retourne Err(ComplexError::DivisionByZero) si |self| == 0.

use embedded_complex_f32::Complex;
let r = Complex::new(4.0, 0.0).inv().unwrap();
assert!((r.re() - 0.25).abs() < 1e-5);

pub fn csqrt(self) -> Result<Self, ComplexError>

Racine carrée complexe.

Pour z = r·e^{iθ}, retourne √r · e^{iθ/2} via les identités trigonométriques demi-angle sans libm, sans appel trig approché.

use embedded_complex_f32::Complex;
let z = Complex::new(3.0, 4.0);
let s = z.csqrt().unwrap();
let back = s * s;
assert!((back.re() - 3.0).abs() < 1e-4);
assert!((back.im() - 4.0).abs() < 1e-4);

pub fn powi(self, n: i32) -> Result<Self, ComplexError>

Puissance entière self^n par exponentiation rapide.

n peut être négatif (utilise inv si n < 0).

use embedded_complex_f32::Complex;
// i⁴ = 1
let r = Complex::I.powi(4).unwrap();
assert!((r.re() - 1.0).abs() < 1e-5);

Trait Implementations

impl Add<f32> for Complex

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for Complex

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for Complex

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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 the value using the given formatter.

impl Div<f32> for Complex

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for Complex

Division via conjugué : (a+bi)/(c+di) = [(a+bi)(c−di)] / (c²+d²).

Retourne NaN + NaN·i si |rhs| == 0. Préférez Complex::checked_div pour une gestion explicite de l’erreur.

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign for Complex

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl From<(f32, f32)> for Complex

fn from((re, im): (f32, f32)) -> Self

Converts to this type from the input type.

impl From<Complex> for (f32, f32)

fn from(z: Complex) -> Self

Converts to this type from the input type.

impl From<f32> for Complex

fn from(x: f32) -> Self

Embed un scalaire réel comme x + 0i.

impl Mul<f32> for Complex

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for Complex

(a+bi)(c+di) = (ac−bd) + (ad+bc)i

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for Complex

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for Complex

type Output = Complex

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

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 Sub<f32> for Complex

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for Complex

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for Complex

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for Complex

impl StructuralPartialEq for Complex