Rust has support for generics but sometimes, can be really hard to get your head around. That is because of its strong, edge cutting type system.

That good news is that Traits are here to help, in particular, when it comes to “shape” a generic type via trait bounds.

Implementing complex numbers helped me get a grasp on how to use generic types and traits in Rust.

If u are not comfortable with complex numbers, take a quick look to this quick introduction

## Generics

So what do I mean by “Implementing Complex Numbers in Rust”?

I need a data structure which has multiplication (cross product), dot product with another complex number, addition, comparison, has its complex conjugate and has a standard way to be displayed.

A complex number hold two numbers, so let’s start with:

```
struct Complex {
Real: f64,
Imaginary: f64,
}
```

Here is already a great opportunity to add generics. (Real, Imaginary) can be any type number: `f32`

, `f64`

or even `i128`

(quite dangerous).

The great news here is that those types are Copy types and `Complex<T>`

, being composed of Copy types, can also a Copy type. That means overall less hassle with the Borrow Checker.

The crate `num_traits`

has a handy trait `Num`

that unifies all types of numbers.

```
use num_traits::Num as Number;
#[derive(PartialEq, PartialOrd, Eq, Copy, Clone, Debug)]
struct Complex<T: Number> {
Real: T,
Imaginaire: T,
}
impl<T: Copy + Number> Complex<T> {
pub fn new(imaginary: T, real: T) -> Complex<T> {
Complex {
Real: real,
Imaginaire: imaginary,
}
}
}
```

## Overloading operations

Rust supports operator overloading which is nice for better reading.

Instead of having to invoke `add`

and `mul`

functions for all complex, using overloaded operations for more concise (less verbose in Rust loll)

```
T * T => T // (cross product not dot product)
T + T => T
```

Overloading is done by implementing a trait: the trait `Add<Complex<T>>`

.

For `+`

, `Complex<T>`

has to implement the `Add<Complex<T>>`

trait with

```
impl<T: Copy + Number + Neg<Output = T>> Add<Complex<T>> for Complex<T> {
type Output = Complex<T>;
fn add(self, another: Complex<T>) -> Complex<T> {
Complex {
Imaginaire: another.Imaginaire + self.Imaginaire,
Real: another.Real + self.Real,
}
}
}
```

And for `*`

, `Complex<T>`

has to implement the `Mul<Complex<T>>`

trait with

```
impl<T: Copy + Number + Neg<Output = T>> Mul<Complex<T>> for Complex<T> {
type Output = Complex<T>;
fn mul(self, another: Complex<T>) -> Complex<T> {
let real = (self.Real * another.Real) - (self.Imaginaire * another.Imaginaire);
let im = (self.Real * another.Imaginaire) + (self.Imaginaire * another.Real);
Complex {
Real: real,
Imaginaire: im,
}
}
}
```

Dot Product:

```
pub fn dot_product(&self, another: Complex<T>) -> T {
(self.Real * another.Imaginaire) - (self.Imaginaire * another.Real)
}
```

for conjugate:

```
pub fn conjugate(&self) -> Complex<T> {
Complex {
Imaginaire: -self.Imaginaire,
Real: self.Real,
}
}
```

## Traits for the win

While implementing the `Display`

Trait for `Complex<T>`

, I fell on the need of zero.
I needed to know if the sign of the Imaginary part of my current number or if it was nil.

By chance, numbers in Rust implement the `Zero`

Trait. YOUPPPIII
That Trait gives access to the zero of a generic type.

```
impl<T: Copy + Number + Zero + PartialOrd + Display> Display for Complex<T> {
fn fmt(&self, f: &mut Formatter) -> Result {
match self.Imaginaire {
number if number.is_zero() => write!(f, "{}", self.Real),
number if number < T::zero() => write!(f, "{}{}i", self.Real, number),
_ => write!(f, "{}+{}i", self.Real, self.Imaginaire),
}
}
}
impl<T: Clone + Copy + Neg<Output = T> + Number + Zero> Zero for Complex<T> {
fn zero() -> Complex<T> {
Complex::new(T::zero(), T::zero())
}
fn is_zero(&self) -> bool {
self.Real.is_zero() && self.Imaginaire.is_zero()
}
}
```

## Example

```
let i = complex::Complex::<f64>::new(3.0, 3.0);
let j = complex::Complex::<f64>::new(3.0, 3.0);
println!("ADD: {}", j + i); // ADD: 6+6i
println!("MULT: {}", j * i); // MULT: 0+18i
println!("DOT Product: ({}).({}) = {}", i, j, i.dot_product(j)); // DOT Product: (3+3i).(3+3i) = 0
println!("Conjugate: {}", i.conjugate()); // Conjugate: 3-3i
```

All the code is available, here. However this library is way more complete, even if it share a similar thought process.