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
99
100
101
102
103
104
105


use crate::{Integer, Bit};
use std::error::Error;
use std::ops::{Div};
use super::divider;

impl Div for Integer {
    type Output = Result<Self, Box<dyn Error>>;
    fn div(self, b: Self) -> Result<Self, Box<dyn Error>> {
        &self / &b
    }
}

impl Div<&u8> for &Integer {
    type Output = Result<Integer, Box<dyn Error>>;
    fn div(self, b: &u8) -> Result<Integer, Box<dyn Error>> {
        let b_int: Integer = b.into();
        self / &b_int
    }
}

impl Div<&u16> for &Integer {
    type Output = Result<Integer, Box<dyn Error>>;
    fn div(self, b: &u16) -> Result<Integer, Box<dyn Error>> {
        let b_int: Integer = b.into();
        self / &b_int
    }
}

impl Div<&u32> for &Integer {
    type Output = Result<Integer, Box<dyn Error>>;
    fn div(self, b: &u32) -> Result<Integer, Box<dyn Error>> {
        let b_int: Integer = b.into();
        self / &b_int
    }
}

impl Div<&u64> for &Integer {
    type Output = Result<Integer, Box<dyn Error>>;
    fn div(self, b: &u64) -> Result<Integer, Box<dyn Error>> {
        let b_int: Integer = b.into();
        self / &b_int
    }
}

impl Div<&u128> for &Integer {
    type Output = Result<Integer, Box<dyn Error>>;
    fn div(self, b: &u128) -> Result<Integer, Box<dyn Error>> {
        let b_int: Integer = b.into();
        self / &b_int
    }
}

impl Div<&usize> for &Integer {
    type Output = Result<Integer, Box<dyn Error>>;
    fn div(self, b: &usize) -> Result<Integer, Box<dyn Error>> {
        let b_int: Integer = b.into();
        self / &b_int
    }
}

impl Div for &Integer {

    type Output = Result<Integer, Box<dyn Error>>;

    fn div(self, b: Self) -> Result<Integer, Box<dyn Error>> {

        if self == &Integer::zero() {

            Ok(Integer::zero())

        } else if b == &Integer::zero() {

            Err("a/0 is undefined!")?

        } else {

            let a_pos =
                if self.0[0] == Bit::Zero {
                    self.clone()
                } else {
                    self.negate()
                };

            let b_pos =
                if b.0[0] == Bit::Zero {
                    b.clone()
                } else {
                    b.negate()
                };

            let (quotient, _) = divider::run(&a_pos, &b_pos);

            match (self.0[0], b.0[0]) {
                (Bit::Zero, Bit::Zero) => Ok(quotient),
                (Bit::One, Bit::One) => Ok(quotient),
                (Bit::Zero, Bit::One) => Ok(quotient.negate()),
                (Bit::One, Bit::Zero) => Ok(quotient.negate())
            }

        }
    
    }

}