Struct Decimal

Source

pub struct Decimal {
    sign: Sign,
    integer: Vec<u64>,
    decimal: Vec<u64>,
}

Fields§

§sign: Sign§integer: Vec<u64>§decimal: Vec<u64>

Implementations§

Source §

impl Decimal

Source

fn cmp_absolute_parts(&self, other: &Self) -> Ordering

Examples found in repository ?

crates/competitive/src/num/decimal.rs (line 99)

97    fn cmp(&self, other: &Self) -> Ordering {
98        self.sign.cmp(&other.sign).then_with(|| match self.sign {
99            Sign::Minus => other.cmp_absolute_parts(self),
100            Sign::Zero => Ordering::Equal,
101            Sign::Plus => self.cmp_absolute_parts(other),
102        })
103    }

More examples

Hide additional examples

crates/competitive/src/num/decimal/addsub.rs (line 93)

92fn sub_absolute_parts_gte(lhs: &Decimal, rhs: &mut Decimal) {
93    debug_assert!(matches!(lhs.cmp_absolute_parts(rhs), Ordering::Greater));
94
95    let mut borrow = false;
96
97    // decimal part
98    let rhs_decimal_len = rhs.decimal.len();
99    if lhs.decimal.len() > rhs_decimal_len {
100        for (l, r) in lhs.decimal[..rhs_decimal_len]
101            .iter()
102            .rev()
103            .zip(rhs.decimal.iter_mut().rev())
104        {
105            borrow = sub_borrow(borrow, *l, *r, r);
106        }
107        rhs.decimal
108            .extend_from_slice(&lhs.decimal[rhs_decimal_len..]);
109    } else {
110        for r in rhs.decimal[lhs.decimal.len()..].iter_mut().rev() {
111            borrow = sub_borrow(borrow, 0, *r, r);
112        }
113        for (l, r) in lhs
114            .decimal
115            .iter()
116            .rev()
117            .zip(rhs.decimal[..lhs.decimal.len()].iter_mut().rev())
118        {
119            borrow = sub_borrow(borrow, *l, *r, r);
120        }
121    }
122
123    // integer part
124    let rhs_integer_len = rhs.integer.len();
125    if lhs.integer.len() > rhs_integer_len {
126        for (l, r) in lhs.integer[..rhs_integer_len]
127            .iter()
128            .zip(rhs.integer.iter_mut())
129        {
130            borrow = sub_borrow(borrow, *l, *r, r);
131        }
132        rhs.integer
133            .extend_from_slice(&lhs.integer[rhs_integer_len..]);
134        if borrow {
135            for r in rhs.integer[rhs_integer_len..].iter_mut() {
136                borrow = sub_borrow(borrow, *r, 0, r);
137                if !borrow {
138                    break;
139                }
140            }
141        }
142    } else {
143        debug_assert_eq!(lhs.integer.len(), rhs_integer_len);
144        for (l, r) in lhs.integer.iter().zip(&mut rhs.integer) {
145            borrow = sub_borrow(borrow, *l, *r, r);
146        }
147    }
148
149    assert!(
150        !borrow,
151        "Cannot subtract lhs from rhs because lhs is smaller than rhs"
152    );
153
154    rhs.normalize();
155}

Source

fn normalize(&mut self)

Examples found in repository ?

crates/competitive/src/num/decimal/addsub.rs (line 77)

17fn add_absolute_parts(lhs: &mut Decimal, rhs: &Decimal) {
18    let mut carry = false;
19
20    // decimal part
21    let lhs_decimal_len = lhs.decimal.len();
22    if lhs_decimal_len < rhs.decimal.len() {
23        for (l, r) in lhs
24            .decimal
25            .iter_mut()
26            .rev()
27            .zip(rhs.decimal[..lhs_decimal_len].iter().rev())
28        {
29            carry = add_carry(carry, *l, *r, l);
30        }
31        lhs.decimal
32            .extend_from_slice(&rhs.decimal[lhs_decimal_len..]);
33    } else {
34        for (l, r) in lhs.decimal[..rhs.decimal.len()]
35            .iter_mut()
36            .rev()
37            .zip(rhs.decimal.iter().rev())
38        {
39            carry = add_carry(carry, *l, *r, l);
40        }
41    }
42
43    // integer part
44    let lhs_integer_len = lhs.integer.len();
45    if lhs_integer_len < rhs.integer.len() {
46        for (l, r) in lhs.integer.iter_mut().zip(&rhs.integer[..lhs_integer_len]) {
47            carry = add_carry(carry, *l, *r, l);
48        }
49        lhs.integer
50            .extend_from_slice(&rhs.integer[lhs_integer_len..]);
51        if carry {
52            for l in lhs.integer[lhs_integer_len..].iter_mut() {
53                carry = add_carry(carry, *l, 0, l);
54                if !carry {
55                    break;
56                }
57            }
58        }
59    } else {
60        for (l, r) in lhs.integer.iter_mut().zip(&rhs.integer) {
61            carry = add_carry(carry, *l, *r, l);
62        }
63        if carry {
64            for l in lhs.integer[rhs.integer.len()..].iter_mut() {
65                carry = add_carry(carry, *l, 0, l);
66                if !carry {
67                    break;
68                }
69            }
70        }
71    }
72
73    if carry {
74        lhs.integer.push(carry as u64);
75    }
76
77    lhs.normalize();
78}
79
80fn sub_borrow(borrow: bool, lhs: u64, rhs: u64, out: &mut u64) -> bool {
81    let (sum, borrow1) = lhs.overflowing_sub(rhs);
82    let (mut sum, borrow2) = sum.overflowing_sub(borrow as u64);
83    let borrow = borrow1 || borrow2;
84    if borrow {
85        sum = sum.wrapping_add(RADIX);
86    }
87    *out = sum;
88    borrow
89}
90
91// assume |lhs| >= |rhs|
92fn sub_absolute_parts_gte(lhs: &Decimal, rhs: &mut Decimal) {
93    debug_assert!(matches!(lhs.cmp_absolute_parts(rhs), Ordering::Greater));
94
95    let mut borrow = false;
96
97    // decimal part
98    let rhs_decimal_len = rhs.decimal.len();
99    if lhs.decimal.len() > rhs_decimal_len {
100        for (l, r) in lhs.decimal[..rhs_decimal_len]
101            .iter()
102            .rev()
103            .zip(rhs.decimal.iter_mut().rev())
104        {
105            borrow = sub_borrow(borrow, *l, *r, r);
106        }
107        rhs.decimal
108            .extend_from_slice(&lhs.decimal[rhs_decimal_len..]);
109    } else {
110        for r in rhs.decimal[lhs.decimal.len()..].iter_mut().rev() {
111            borrow = sub_borrow(borrow, 0, *r, r);
112        }
113        for (l, r) in lhs
114            .decimal
115            .iter()
116            .rev()
117            .zip(rhs.decimal[..lhs.decimal.len()].iter_mut().rev())
118        {
119            borrow = sub_borrow(borrow, *l, *r, r);
120        }
121    }
122
123    // integer part
124    let rhs_integer_len = rhs.integer.len();
125    if lhs.integer.len() > rhs_integer_len {
126        for (l, r) in lhs.integer[..rhs_integer_len]
127            .iter()
128            .zip(rhs.integer.iter_mut())
129        {
130            borrow = sub_borrow(borrow, *l, *r, r);
131        }
132        rhs.integer
133            .extend_from_slice(&lhs.integer[rhs_integer_len..]);
134        if borrow {
135            for r in rhs.integer[rhs_integer_len..].iter_mut() {
136                borrow = sub_borrow(borrow, *r, 0, r);
137                if !borrow {
138                    break;
139                }
140            }
141        }
142    } else {
143        debug_assert_eq!(lhs.integer.len(), rhs_integer_len);
144        for (l, r) in lhs.integer.iter().zip(&mut rhs.integer) {
145            borrow = sub_borrow(borrow, *l, *r, r);
146        }
147    }
148
149    assert!(
150        !borrow,
151        "Cannot subtract lhs from rhs because lhs is smaller than rhs"
152    );
153
154    rhs.normalize();
155}