gauss_int 0.2.0

Gaussian integer arithmetic and number theory utilities
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use gauss_int::GaussInt;
use num_traits::{One, Zero};

#[test]
fn test_arithmetic_chain() {
    let z1 = GaussInt::from_i64(1, 1);
    let z2 = GaussInt::from_i64(2, 3);
    let z3 = GaussInt::from_i64(4, -1);

    let z2z3 = &z2 * &z3; // (2+3i)(4-i) = 11+10i
    assert_eq!(z2z3, GaussInt::from_i64(11, 10));

    let result = &z1 + &z2z3; // (1+i) + (11+10i) = 12+11i
    assert_eq!(result, GaussInt::from_i64(12, 11));
}

#[test]
fn test_gcd_euclidean_property() {
    let a = GaussInt::from_i64(36, 48);
    let b = GaussInt::from_i64(12, 16);
    let g = a.gcd(&b);
    assert!(a.div_rem(&g).unwrap().1.is_zero());
    assert!(b.div_rem(&g).unwrap().1.is_zero());
}

#[test]
fn test_pow_large_exponent() {
    let z = GaussInt::from_i64(1, 1);
    assert_eq!(z.pow_u32(8), GaussInt::from_i64(16, 0)); // (1+i)^8 = 16
}

#[test]
fn test_field_properties() {
    let zero = GaussInt::zero();
    let one = GaussInt::one();
    let z = GaussInt::from_i64(3, 4);

    assert_eq!(&z + &zero, z);
    assert_eq!(&z * &one, z);
    assert_eq!(&z + &(-&z), zero);

    let z_conj = z.conjugate();
    let product = &z * &z_conj;
    assert!(product.is_real());
    assert_eq!(product.to_string(), "25");
}

#[test]
fn test_rotation_property() {
    // multiplying by i four times = identity
    let z = GaussInt::from_i64(3, 4);
    let i = GaussInt::from_i64(0, 1);
    assert_eq!(&z * &i * &i * &i * &i, z);
}

#[test]
fn test_div_rem_invariant() {
    let pairs = vec![
        (GaussInt::from_i64(100, 0), GaussInt::from_i64(7, 0)),
        (GaussInt::from_i64(0, 100), GaussInt::from_i64(0, 7)),
        (GaussInt::from_i64(-100, -100), GaussInt::from_i64(3, 4)),
        (GaussInt::from_i64(1, 1), GaussInt::from_i64(1, 1)),
    ];
    for (a, b) in pairs {
        let (q, r) = a.div_rem(&b).unwrap();
        assert!(
            r.norm() < b.norm(),
            "N(r)={} >= N(b)={}",
            r.norm(),
            b.norm()
        );
        assert_eq!(&q * &b + &r, a);
    }
}