Struct Complex 

#[repr(transparent)]
pub struct Complex<T>(pub [T; 2]);

A complex number in cartesian coordinates

Tuple Fields

0: [T; 2]

Real and imaginary parts

Implementations

impl<T: Copy> Complex<T>

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

Create a new Complex<T>

pub fn re(&self) -> T

The real part

pub fn im(&self) -> T

The imaginary part

impl<T: Copy + Neg<Output = T>> Complex<T>

pub fn conj(self) -> Self

Conjugate

impl Complex<Q32<31>>

pub fn from_angle(angle: Wrapping<i32>) -> Self

Return a Complex on the unit circle given an angle.

Example:

use core::num::Wrapping as W;
use idsp::Complex;
Complex::<_>::from_angle(W(0));
Complex::<_>::from_angle(W(1 << 30)); // pi/2
Complex::<_>::from_angle(W(-1 << 30)); // -pi/2

impl Complex<i32>

pub fn norm_sqr(&self) -> P32<31>

Return the absolute square (the squared magnitude).

Note(panic): This will panic for Complex(i32::MIN, i32::MIN)

Example:

use dsp_fixedpoint::{P32, Q32};
use idsp::Complex;
assert_eq!(Complex::new(i32::MIN, 0).norm_sqr(), P32::new(1 << 31));
assert_eq!(
    Complex::new(i32::MAX, i32::MAX).norm_sqr(),
    P32::new(u32::MAX - 3)
);
assert_eq!(
    Complex::new(i32::MIN, i32::MAX).norm_sqr(),
    P32::new(u32::MAX - 1)
);

pub fn log2(&self) -> i32

trunc(log2(power)) re full scale (approximation)

TODO: scale up, interpolate

Example:

use idsp::Complex;
assert_eq!(Complex::new(i32::MIN, i32::MIN).log2(), 0);
assert_eq!(Complex::new(i32::MAX, i32::MAX).log2(), -1);
assert_eq!(Complex::new(i32::MIN, 0).log2(), -1);
assert_eq!(Complex::new(i32::MAX, 0).log2(), -2);
assert_eq!(Complex::new(-1, 0).log2(), -63);
assert_eq!(Complex::new(1, 0).log2(), -63);
assert_eq!(Complex::new(0, 0).log2(), -64);

pub fn arg(&self) -> Wrapping<i32>

Return the angle.

Note: Normalization is 1 << 31 == pi.

Example:

use core::num::Wrapping as W;
use idsp::Complex;
assert_eq!(Complex::new(0, 0).arg(), W(0));
assert_eq!(Complex::new(0, 1).arg(), W((1 << 30) - 1));

Trait Implementations

impl<T: Copy + Add<Output = T>> Add for Complex<T>

type Output = Complex<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Copy + BitAnd<Output = T>> BitAnd<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the & operator.

fn bitand(self, rhs: T) -> Self

Performs the & operation.

impl<T: Copy + BitAnd<Output = T>> BitAnd for Complex<T>

type Output = Complex<T>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T: Copy + BitOr<Output = T>> BitOr<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the | operator.

fn bitor(self, rhs: T) -> Self

Performs the | operation.

impl<T: Copy + BitOr<Output = T>> BitOr for Complex<T>

type Output = Complex<T>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T: Copy + BitXor<Output = T>> BitXor<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: T) -> Self

Performs the ^ operation.

impl<T: Copy + BitXor<Output = T>> BitXor for Complex<T>

type Output = Complex<T>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T: Clone> Clone for Complex<T>

fn clone(&self) -> Complex<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Complex<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Complex<T>

fn default() -> Complex<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Complex<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Copy + Div<Output = T>> Div<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Copy + Mul<Output = T>> Mul<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: 'static + Copy + Mul<Output = A>, A: Add<Output = A> + Sub<Output = A> + AsPrimitive<T>> Mul for Complex<T>

type Output = Complex<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Copy + Neg<Output = T>> Neg for Complex<T>

type Output = Complex<T>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<T: Copy + Not<Output = T>> Not for Complex<T>

type Output = Complex<T>

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl<T: Ord> Ord for Complex<T>

fn cmp(&self, other: &Complex<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for Complex<T>

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

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

where Self: Default + Mul<Output = Self>,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<T: Copy + Rem<Output = T>> Rem<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self

Performs the % operation.

impl<T> Serialize for Complex<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<C: SplitProcess<i32, i32, S>, S> SplitProcess<(i32, Complex<Q<i32, i64, 31>>), Complex<i32>, [S; 2]> for Lockin<C>

Input and LO

fn process( &self, state: &mut [S; 2], x: (i32, Complex<Q32<31>>), ) -> Complex<i32>

Update the lockin with a sample taken at a local oscillator IQ value.

fn block(&self, state: &mut S, x: &[X], y: &mut [Y])

Process a block of inputs

impl<C: SplitProcess<i32, i32, S>, S> SplitProcess<(i32, Wrapping<i32>), Complex<i32>, [S; 2]> for Lockin<C>

Sample and phase

fn process(&self, state: &mut [S; 2], x: (i32, Wrapping<i32>)) -> Complex<i32>

Update the lockin with a sample taken at a given phase.

fn block(&self, state: &mut S, x: &[X], y: &mut [Y])

Process a block of inputs

impl<T: Copy + Sub<Output = T>> Sub for Complex<T>

type Output = Complex<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sum for Complex<T>

where Self: Default + Add<Output = Self>,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T> Zeroable for Complex<T>

where T: Zeroable,

fn zeroed() -> Self

Calls zeroed.

impl<T: Copy> Copy for Complex<T>

impl<T: Eq> Eq for Complex<T>

impl<T> Pod for Complex<T>

where T: Pod,

impl<T> StructuralPartialEq for Complex<T>