hcomplex 0.2.0

Lightweight complex and hypercomplex algebra library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

use rand::{prelude::*};
use rand_distr::{Uniform};
use rand_xorshift::XorShiftRng;
use ::approx::*;
use crate::{*, random::*};

const SAMPLE_ATTEMPTS: usize = 256;


#[test]
fn constructor() {
    let a = Complex::new(0.0, 1.0);
    assert_abs_diff_eq!(a.re(), 0.0);
    assert_abs_diff_eq!(a.im(), 1.0);
}

#[test]
fn inversion() {
    let mut rng = XorShiftRng::seed_from_u64(0xCAFE0);
    for _ in 0..SAMPLE_ATTEMPTS {
        let a: Complex<f64> = rng.sample(NonZero);
        assert_abs_diff_eq!(a/a, Complex::new(1.0, 0.0));
    }
}

#[test]
fn square_root() {
    let mut rng = XorShiftRng::seed_from_u64(0xCAFE1);
    for _ in 0..SAMPLE_ATTEMPTS {
        let a: Complex<f64> = rng.sample(StandardNormal);
        let b = a.sqrt();
        assert_abs_diff_eq!(b*b, a, epsilon=1e-12);
    }
}

#[test]
fn power() {
    let mut rng = XorShiftRng::seed_from_u64(0xCAFE1);
    for _ in 0..SAMPLE_ATTEMPTS {
        let a: Complex<f64> = rng.sample(StandardNormal);
        let n = rng.sample(Uniform::from(2..12));
        let b = a.powf(1.0 / n as f64);
        let mut c = Complex::new(1.0, 0.0);
        for _ in 0..n {
            c *= b;
        }
        assert_abs_diff_eq!(c, a, epsilon=1e-12);
    }
}

#[test]
fn norm() {
    let c = Complex::new(3.0, -4.0);
    assert_abs_diff_eq!(c.abs(), 5.0);
    assert_abs_diff_eq!(c.norm_l1(), 7.0);
}