bigfixed 0.0.0

Arbitrary precision fixed point numbers
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use bigfixed::{digit::*, Index, BigFixed};

#[test]
fn index_position() {
    let x = BigFixed::construct(ALLONES, vec![5], Index::Position(-5)).unwrap();
    assert_eq!(x[Index::Position(-700)], 0, "tail far");
    assert_eq!(x[Index::Position(-6)], 0, "tail");
    assert_eq!(x[Index::Position(-5)], 5, "body");
    assert_eq!(x[Index::Position(-4)], ALLONES, "head");
    assert_eq!(x[Index::Position(6)], ALLONES, "head far");
}

#[test]
fn index_bit() {
    let x = BigFixed::construct(ALLONES, vec![5], Index::Position(0)).unwrap();
    assert_eq!(x[Index::Bit(-700)], 0, "tail far");
    assert_eq!(x[Index::Bit(-1)], 0, "tail");
    assert_eq!(x[Index::Bit(0)], 1, "body 0");
    assert_eq!(x[Index::Bit(1)], 0, "body 1");
    assert_eq!(x[Index::Bit(2)], 1, "body 2");
    assert_eq!(x[Index::Bit(3)], 0, "body 3");
    assert_eq!(x[Index::Bit(DIGITBITS as isize)], 1, "head");
    assert_eq!(x[Index::Bit(DIGITBITS as isize * 700)], 1, "head far");
}

#[test]
fn index_mut_position() {
    let mut x = BigFixed::ZERO.clone();
    x[Index::Position(0)] = 1;
    assert_eq!(x, BigFixed::from(1), "zero to one");
    x[Index::Position(0)] = 0;
    assert!(x.full_eq(&BigFixed {
        head: 0,
        body: vec![0],
        position: Index::Position(0)
    }).unwrap(), "one to zero");
    x[Index::Position(3)] = 1;
    assert!(x.full_eq(&BigFixed {
        head: 0,
        body: vec![0, 0, 0, 1],
        position: Index::Position(0)
    }).unwrap(), "into head");
    x[Index::Position(-2)] = ALLONES;
    assert!(x.full_eq(&BigFixed {
        head: 0,
        body: vec![ALLONES, 0, 0, 0, 0, 1],
        position: Index::Position(-2)
    }).unwrap(), "into tail");
}

// gives a reference to the digit in the corresponding position, not to the bit itself
#[test]
fn index_mut_bit() {
    let mut x = BigFixed::from(0);
    x[Index::Bit(0)] = 1;
    assert_eq!(x, BigFixed::from(1), "zero to one");
    x[Index::Bit(0)] = 0;
    assert!(x.full_eq(&BigFixed {
        head: 0,
        body: vec![0],
        position: Index::Position(0)
    }).unwrap(), "one to zero");
    x[Index::Bit(3 * DIGITBITS as isize + 3)] = 1;
    assert!(x.full_eq(&BigFixed {
        head: 0,
        body: vec![0, 0, 0, 1],
        position: Index::Position(0)
    }).unwrap(), "into head");
    x[Index::Bit(-2 * DIGITBITS as isize)] = ALLONES;
    assert!(x.full_eq(&BigFixed {
        head: 0,
        body: vec![ALLONES, 0, 0, 0, 0, 1],
        position: Index::Position(-2)
    }).unwrap(), "into tail");
}

#[test]
fn set_bit() {
    let mut x = BigFixed::from(-1);
    x.set_bit(4, 0);
    assert!(x.full_eq(&BigFixed {
        head: ALLONES,
        body: vec![!16],
        position: Index::Position(0)
    }).unwrap(), "one bit");
    x.set_bit(4, 1);
    assert!(x.full_eq(&BigFixed {
        head: ALLONES,
        body: vec![ALLONES],
        position: Index::Position(0)
    }).unwrap(), "one bit");
    x.set_bit(-1, 0);
    assert!(x.full_eq(&BigFixed {
        head: ALLONES,
        body: vec![0, ALLONES],
        position: Index::Position(-1)
    }).unwrap(), "one bit");
}