apint 0.2.0

Arbitrary precision integers 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

use digit::Digit;

use std::slice;

/// A sequence of digits.
/// 
/// This is a very efficient `DigitSeq` since its data is contiguous in memory.
#[derive(Debug, Clone)]
pub(crate) struct ContiguousDigitSeq<'a> {
	digits: slice::Iter<'a, Digit>
}

impl<'a> From<&'a [Digit]> for ContiguousDigitSeq<'a> {
	#[inline]
	fn from(slice: &'a [Digit]) -> ContiguousDigitSeq<'a> {
		ContiguousDigitSeq{digits: slice.iter()}
	}
}

impl<'a> Iterator for ContiguousDigitSeq<'a> {
	type Item = Digit;

	#[inline]
	fn next(&mut self) -> Option<Self::Item> {
		self.digits.next().cloned()
	}
}

/// A sequence of mutable digits.
/// 
/// This is a very efficient `DigitSeqMut` since its data is contiguous in memory.
#[derive(Debug)]
pub(crate) struct ContiguousDigitSeqMut<'a> {
	digits: slice::IterMut<'a, Digit>
}

impl<'a> From<&'a mut [Digit]> for ContiguousDigitSeqMut<'a> {
	#[inline]
	fn from(slice: &'a mut [Digit]) -> ContiguousDigitSeqMut<'a> {
		ContiguousDigitSeqMut{digits: slice.iter_mut()}
	}
}

impl<'a> Iterator for ContiguousDigitSeqMut<'a> {
	type Item = &'a mut Digit;

	#[inline]
	fn next(&mut self) -> Option<Self::Item> {
		self.digits.next()
	}
}