diff --git a/custom_derive/index.html b/custom_derive/index.html index 59ab717..ac597f8 100644 --- a/custom_derive/index.html +++ b/custom_derive/index.html @@ -76,10 +76,10 @@ } macro_rules! TypeName { - (() $(pub)* enum $name:ident $($tail:tt)*) => { TypeName! { @impl $name } }; - (() $(pub)* struct $name:ident $($tail:tt)*) => { TypeName! { @impl $name } }; + (() $(pub)* enum $name:ident $($tail:tt)*) => { TypeName! { @impl $name } }; + (() $(pub)* struct $name:ident $($tail:tt)*) => { TypeName! { @impl $name } }; - (@impl $name:ident) => { + (@impl $name:ident) => { impl TypeName for $name { fn type_name() -> &'static str { stringify!($name) } } diff --git a/hamming/fn.distance.html b/hamming/fn.distance.html index d9ad01f..a4d3591 100644 --- a/hamming/fn.distance.html +++ b/hamming/fn.distance.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub fn distance(x: &[u8], y: &[u8]) -> u64

Computes the bitwise Hamming distance between x and y, that is, the number of bits where x and y differ, diff --git a/hamming/fn.distance_fast.html b/hamming/fn.distance_fast.html index 1d20136..dfe3b97 100644 --- a/hamming/fn.distance_fast.html +++ b/hamming/fn.distance_fast.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 

pub fn distance_fast(x: &[u8], y: &[u8]) -> Result<u64, DistanceError>

Computes the bitwise Hamming distance between x and y, that is, the number of bits where x and y differ, diff --git a/implementors/core/any/trait.Any.js b/implementors/core/any/trait.Any.js index 5fd020f..d1b392a 100644 --- a/implementors/core/any/trait.Any.js +++ b/implementors/core/any/trait.Any.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/array/trait.FixedSizeArray.js b/implementors/core/array/trait.FixedSizeArray.js index 5fd020f..d1b392a 100644 --- a/implementors/core/array/trait.FixedSizeArray.js +++ b/implementors/core/array/trait.FixedSizeArray.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/borrow/trait.Borrow.js b/implementors/core/borrow/trait.Borrow.js index 5fd020f..d1b392a 100644 --- a/implementors/core/borrow/trait.Borrow.js +++ b/implementors/core/borrow/trait.Borrow.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/borrow/trait.BorrowMut.js b/implementors/core/borrow/trait.BorrowMut.js index 5fd020f..d1b392a 100644 --- a/implementors/core/borrow/trait.BorrowMut.js +++ b/implementors/core/borrow/trait.BorrowMut.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/clone/trait.Clone.js b/implementors/core/clone/trait.Clone.js index c5f7664..9263d7e 100644 --- a/implementors/core/clone/trait.Clone.js +++ b/implementors/core/clone/trait.Clone.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = ["impl Clone for stat","impl Clone for utimbuf","impl Clone for timeval","impl Clone for timespec",];implementors['rand'] = ["impl<X: Clone> Clone for Range<X>","impl Clone for Gamma","impl Clone for ChiSquared","impl Clone for FisherF","impl Clone for StudentT","impl Clone for StandardNormal","impl Clone for Normal","impl Clone for LogNormal","impl Clone for Exp1","impl Clone for Exp","impl<Sup> Clone for RandSample<Sup>","impl<T: Clone> Clone for Weighted<T>","impl Clone for IsaacRng","impl Clone for Isaac64Rng","impl Clone for ChaChaRng","impl Clone for ReseedWithDefault","impl Clone for XorShiftRng","impl Clone for StdRng","impl Clone for ThreadRng",];implementors['ramp'] = ["impl Clone for Limb","impl Clone for Limbs","impl Clone for LimbsMut","impl Clone for Int","impl Clone for ParseIntError",]; +implementors["libc"] = ["impl Clone for stat","impl Clone for utimbuf","impl Clone for timeval","impl Clone for timespec",];implementors["rand"] = ["impl<X: Clone> Clone for Range<X>","impl Clone for Gamma","impl Clone for ChiSquared","impl Clone for FisherF","impl Clone for StudentT","impl Clone for StandardNormal","impl Clone for Normal","impl Clone for LogNormal","impl Clone for Exp1","impl Clone for Exp","impl<Sup> Clone for RandSample<Sup>","impl<T: Clone> Clone for Weighted<T>","impl Clone for IsaacRng","impl Clone for Isaac64Rng","impl Clone for ChaChaRng","impl Clone for ReseedWithDefault","impl Clone for XorShiftRng","impl Clone for StdRng","impl Clone for ThreadRng",];implementors["ramp"] = ["impl Clone for Limb","impl Clone for Limbs","impl Clone for LimbsMut","impl Clone for Int","impl Clone for ParseIntError",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/cmp/trait.Eq.js b/implementors/core/cmp/trait.Eq.js index bba2e67..48653e9 100644 --- a/implementors/core/cmp/trait.Eq.js +++ b/implementors/core/cmp/trait.Eq.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl Eq for Limb","impl Eq for Limbs","impl Eq for LimbsMut","impl Eq for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl Eq for Limb","impl Eq for Limbs","impl Eq for LimbsMut","impl Eq for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/cmp/trait.Ord.js b/implementors/core/cmp/trait.Ord.js index d55716c..550d656 100644 --- a/implementors/core/cmp/trait.Ord.js +++ b/implementors/core/cmp/trait.Ord.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl Ord for Limb","impl Ord for Limbs","impl Ord for LimbsMut","impl Ord for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl Ord for Limb","impl Ord for Limbs","impl Ord for LimbsMut","impl Ord for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/cmp/trait.PartialEq.js b/implementors/core/cmp/trait.PartialEq.js index 71b42f8..794c610 100644 --- a/implementors/core/cmp/trait.PartialEq.js +++ b/implementors/core/cmp/trait.PartialEq.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl PartialEq<Limb> for Limb","impl PartialEq<BaseInt> for Limb","impl PartialEq for Limbs","impl PartialEq for LimbsMut","impl PartialEq<Int> for Int","impl PartialEq<Limb> for Int","impl PartialEq<Int> for Limb","impl PartialEq<i32> for Int","impl PartialEq<Int> for i32","impl PartialEq<usize> for Int","impl PartialEq<Int> for usize","impl PartialEq<u64> for Int","impl PartialEq<Int> for u64","impl PartialEq<i64> for Int","impl PartialEq<Int> for i64","impl PartialEq for ParseIntError",]; +implementors["libc"] = [];implementors["ramp"] = ["impl PartialEq<Limb> for Limb","impl PartialEq<BaseInt> for Limb","impl PartialEq for Limbs","impl PartialEq for LimbsMut","impl PartialEq<Int> for Int","impl PartialEq<Limb> for Int","impl PartialEq<Int> for Limb","impl PartialEq<i32> for Int","impl PartialEq<Int> for i32","impl PartialEq<usize> for Int","impl PartialEq<Int> for usize","impl PartialEq<u64> for Int","impl PartialEq<Int> for u64","impl PartialEq<i64> for Int","impl PartialEq<Int> for i64","impl PartialEq for ParseIntError",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/cmp/trait.PartialOrd.js b/implementors/core/cmp/trait.PartialOrd.js index 0153a19..044fcb9 100644 --- a/implementors/core/cmp/trait.PartialOrd.js +++ b/implementors/core/cmp/trait.PartialOrd.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl PartialOrd<Limb> for Limb","impl PartialOrd<BaseInt> for Limb","impl PartialOrd for Limbs","impl PartialOrd for LimbsMut","impl PartialOrd<Int> for Int","impl PartialOrd<Limb> for Int","impl PartialOrd<Int> for Limb","impl PartialOrd<i32> for Int","impl PartialOrd<Int> for i32","impl PartialOrd<usize> for Int","impl PartialOrd<Int> for usize","impl PartialOrd<u64> for Int","impl PartialOrd<Int> for u64","impl PartialOrd<i64> for Int","impl PartialOrd<Int> for i64",]; +implementors["libc"] = [];implementors["ramp"] = ["impl PartialOrd<Limb> for Limb","impl PartialOrd<BaseInt> for Limb","impl PartialOrd for Limbs","impl PartialOrd for LimbsMut","impl PartialOrd<Int> for Int","impl PartialOrd<Limb> for Int","impl PartialOrd<Int> for Limb","impl PartialOrd<i32> for Int","impl PartialOrd<Int> for i32","impl PartialOrd<usize> for Int","impl PartialOrd<Int> for usize","impl PartialOrd<u64> for Int","impl PartialOrd<Int> for u64","impl PartialOrd<i64> for Int","impl PartialOrd<Int> for i64",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/convert/trait.AsMut.js b/implementors/core/convert/trait.AsMut.js index 5fd020f..d1b392a 100644 --- a/implementors/core/convert/trait.AsMut.js +++ b/implementors/core/convert/trait.AsMut.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/convert/trait.AsRef.js b/implementors/core/convert/trait.AsRef.js index 5fd020f..d1b392a 100644 --- a/implementors/core/convert/trait.AsRef.js +++ b/implementors/core/convert/trait.AsRef.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/convert/trait.From.js b/implementors/core/convert/trait.From.js index f9d9004..e50e00e 100644 --- a/implementors/core/convert/trait.From.js +++ b/implementors/core/convert/trait.From.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl From<i8> for Int","impl From<i16> for Int","impl From<i32> for Int","impl From<i64> for Int","impl From<isize> for Int","impl From<u8> for Int","impl From<u16> for Int","impl From<u32> for Int","impl From<u64> for Int","impl From<usize> for Int","impl<'a> From<&'a Int> for i8","impl<'a> From<&'a Int> for i16","impl<'a> From<&'a Int> for i32","impl<'a> From<&'a Int> for i64","impl<'a> From<&'a Int> for isize","impl<'a> From<&'a Int> for u8","impl<'a> From<&'a Int> for u16","impl<'a> From<&'a Int> for u32","impl<'a> From<&'a Int> for u64","impl<'a> From<&'a Int> for usize",]; +implementors["libc"] = [];implementors["ramp"] = ["impl From<i8> for Int","impl From<i16> for Int","impl From<i32> for Int","impl From<i64> for Int","impl From<isize> for Int","impl From<u8> for Int","impl From<u16> for Int","impl From<u32> for Int","impl From<u64> for Int","impl From<usize> for Int","impl<'a> From<&'a Int> for i8","impl<'a> From<&'a Int> for i16","impl<'a> From<&'a Int> for i32","impl<'a> From<&'a Int> for i64","impl<'a> From<&'a Int> for isize","impl<'a> From<&'a Int> for u8","impl<'a> From<&'a Int> for u16","impl<'a> From<&'a Int> for u32","impl<'a> From<&'a Int> for u64","impl<'a> From<&'a Int> for usize",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/convert/trait.Into.js b/implementors/core/convert/trait.Into.js index 5fd020f..d1b392a 100644 --- a/implementors/core/convert/trait.Into.js +++ b/implementors/core/convert/trait.Into.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/convert/trait.TryFrom.js b/implementors/core/convert/trait.TryFrom.js new file mode 100644 index 0000000..d1b392a --- /dev/null +++ b/implementors/core/convert/trait.TryFrom.js @@ -0,0 +1,10 @@ +(function() {var implementors = {}; +implementors["libc"] = []; + + if (window.register_implementors) { + window.register_implementors(implementors); + } else { + window.pending_implementors = implementors; + } + +})() diff --git a/implementors/core/convert/trait.TryInto.js b/implementors/core/convert/trait.TryInto.js new file mode 100644 index 0000000..d1b392a --- /dev/null +++ b/implementors/core/convert/trait.TryInto.js @@ -0,0 +1,10 @@ +(function() {var implementors = {}; +implementors["libc"] = []; + + if (window.register_implementors) { + window.register_implementors(implementors); + } else { + window.pending_implementors = implementors; + } + +})() diff --git a/implementors/core/default/trait.Default.js b/implementors/core/default/trait.Default.js index 540c942..2028ea9 100644 --- a/implementors/core/default/trait.Default.js +++ b/implementors/core/default/trait.Default.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['rand'] = ["impl Default for ReseedWithDefault",];implementors['ramp'] = ["impl Default for Int",]; +implementors["libc"] = [];implementors["rand"] = ["impl Default for ReseedWithDefault",];implementors["ramp"] = ["impl Default for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/fmt/trait.Binary.js b/implementors/core/fmt/trait.Binary.js index 4bdb159..8b7547c 100644 --- a/implementors/core/fmt/trait.Binary.js +++ b/implementors/core/fmt/trait.Binary.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['pumpkin'] = ["impl Binary for Prime",]; +implementors['pumpkin'] = ["impl Binary for Prime",];implementors["libc"] = [];implementors["ramp"] = ["impl Binary for Int",];implementors["pumpkin"] = ["impl Binary for Prime",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/fmt/trait.Debug.js b/implementors/core/fmt/trait.Debug.js index 61c20a6..46dfbf1 100644 --- a/implementors/core/fmt/trait.Debug.js +++ b/implementors/core/fmt/trait.Debug.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['pumpkin'] = ["impl Debug for Prime",]; +implementors['pumpkin'] = ["impl Debug for Prime",];implementors["libc"] = [];implementors["ramp"] = ["impl Debug for Limb","impl Debug for Limbs","impl Debug for Int","impl Debug for ParseIntError",];implementors["pumpkin"] = ["impl Debug for Prime",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/fmt/trait.Display.js b/implementors/core/fmt/trait.Display.js index b3cfc50..6ecd441 100644 --- a/implementors/core/fmt/trait.Display.js +++ b/implementors/core/fmt/trait.Display.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['pumpkin'] = ["impl Display for Prime",]; +implementors['pumpkin'] = ["impl Display for Prime",];implementors["libc"] = [];implementors["ramp"] = ["impl Display for Limb","impl Display for Int","impl Display for ParseIntError",];implementors["pumpkin"] = ["impl Display for Prime",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/fmt/trait.LowerExp.js b/implementors/core/fmt/trait.LowerExp.js index 5fd020f..d1b392a 100644 --- a/implementors/core/fmt/trait.LowerExp.js +++ b/implementors/core/fmt/trait.LowerExp.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/fmt/trait.LowerHex.js b/implementors/core/fmt/trait.LowerHex.js index 320af41..0615e55 100644 --- a/implementors/core/fmt/trait.LowerHex.js +++ b/implementors/core/fmt/trait.LowerHex.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['pumpkin'] = ["impl LowerHex for Prime",]; +implementors['pumpkin'] = ["impl LowerHex for Prime",];implementors["libc"] = [];implementors["ramp"] = ["impl LowerHex for Int",];implementors["pumpkin"] = ["impl LowerHex for Prime",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/fmt/trait.Octal.js b/implementors/core/fmt/trait.Octal.js index bd01659..0f08114 100644 --- a/implementors/core/fmt/trait.Octal.js +++ b/implementors/core/fmt/trait.Octal.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['pumpkin'] = ["impl Octal for Prime",]; +implementors['pumpkin'] = ["impl Octal for Prime",];implementors["libc"] = [];implementors["ramp"] = ["impl Octal for Int",];implementors["pumpkin"] = ["impl Octal for Prime",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/fmt/trait.Pointer.js b/implementors/core/fmt/trait.Pointer.js index 5fd020f..d1b392a 100644 --- a/implementors/core/fmt/trait.Pointer.js +++ b/implementors/core/fmt/trait.Pointer.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/fmt/trait.UpperExp.js b/implementors/core/fmt/trait.UpperExp.js index 5fd020f..d1b392a 100644 --- a/implementors/core/fmt/trait.UpperExp.js +++ b/implementors/core/fmt/trait.UpperExp.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/fmt/trait.UpperHex.js b/implementors/core/fmt/trait.UpperHex.js index 6658aa1..291aae9 100644 --- a/implementors/core/fmt/trait.UpperHex.js +++ b/implementors/core/fmt/trait.UpperHex.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['pumpkin'] = ["impl UpperHex for Prime",]; +implementors['pumpkin'] = ["impl UpperHex for Prime",];implementors["libc"] = [];implementors["ramp"] = ["impl UpperHex for Int",];implementors["pumpkin"] = ["impl UpperHex for Prime",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/fmt/trait.Write.js b/implementors/core/fmt/trait.Write.js index 5fd020f..d1b392a 100644 --- a/implementors/core/fmt/trait.Write.js +++ b/implementors/core/fmt/trait.Write.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/hash/trait.BuildHasher.js b/implementors/core/hash/trait.BuildHasher.js index 5fd020f..d1b392a 100644 --- a/implementors/core/hash/trait.BuildHasher.js +++ b/implementors/core/hash/trait.BuildHasher.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/hash/trait.Hash.js b/implementors/core/hash/trait.Hash.js index c369ae3..594bf37 100644 --- a/implementors/core/hash/trait.Hash.js +++ b/implementors/core/hash/trait.Hash.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl Hash for Limb","impl Hash for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl Hash for Limb","impl Hash for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/hash/trait.Hasher.js b/implementors/core/hash/trait.Hasher.js index 5fd020f..d1b392a 100644 --- a/implementors/core/hash/trait.Hasher.js +++ b/implementors/core/hash/trait.Hasher.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/iter/iterator/trait.Iterator.js b/implementors/core/iter/iterator/trait.Iterator.js index 6523ae1..defbfb1 100644 --- a/implementors/core/iter/iterator/trait.Iterator.js +++ b/implementors/core/iter/iterator/trait.Iterator.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['rand'] = ["impl<'a, T: Rand, R: Rng> Iterator for Generator<'a, T, R>","impl<'a, R: Rng> Iterator for AsciiGenerator<'a, R>",]; +implementors["libc"] = [];implementors["rand"] = ["impl<'a, T: Rand, R: Rng> Iterator for Generator<'a, T, R>","impl<'a, R: Rng> Iterator for AsciiGenerator<'a, R>",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/iter/range/trait.Step.js b/implementors/core/iter/range/trait.Step.js index c36f189..71474ed 100644 --- a/implementors/core/iter/range/trait.Step.js +++ b/implementors/core/iter/range/trait.Step.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl Step for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl Step for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/iter/traits/trait.DoubleEndedIterator.js b/implementors/core/iter/traits/trait.DoubleEndedIterator.js index 5fd020f..d1b392a 100644 --- a/implementors/core/iter/traits/trait.DoubleEndedIterator.js +++ b/implementors/core/iter/traits/trait.DoubleEndedIterator.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/iter/traits/trait.ExactSizeIterator.js b/implementors/core/iter/traits/trait.ExactSizeIterator.js index 5fd020f..d1b392a 100644 --- a/implementors/core/iter/traits/trait.ExactSizeIterator.js +++ b/implementors/core/iter/traits/trait.ExactSizeIterator.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/iter/traits/trait.FromIterator.js b/implementors/core/iter/traits/trait.FromIterator.js index 5fd020f..d1b392a 100644 --- a/implementors/core/iter/traits/trait.FromIterator.js +++ b/implementors/core/iter/traits/trait.FromIterator.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/iter/traits/trait.IntoIterator.js b/implementors/core/iter/traits/trait.IntoIterator.js index 5fd020f..d1b392a 100644 --- a/implementors/core/iter/traits/trait.IntoIterator.js +++ b/implementors/core/iter/traits/trait.IntoIterator.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/marker/trait.Copy.js b/implementors/core/marker/trait.Copy.js index 5a4eb49..0a08a78 100644 --- a/implementors/core/marker/trait.Copy.js +++ b/implementors/core/marker/trait.Copy.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = ["impl Copy for stat","impl Copy for utimbuf","impl Copy for timeval","impl Copy for timespec",];implementors['rand'] = ["impl<X: Copy> Copy for Range<X>","impl Copy for Gamma","impl Copy for ChiSquared","impl Copy for FisherF","impl Copy for StudentT","impl Copy for StandardNormal","impl Copy for Normal","impl Copy for LogNormal","impl Copy for Exp1","impl Copy for Exp","impl<Sup> Copy for RandSample<Sup>","impl<T: Copy> Copy for Weighted<T>","impl Copy for IsaacRng","impl Copy for Isaac64Rng","impl Copy for ChaChaRng","impl Copy for ReseedWithDefault","impl Copy for StdRng",];implementors['ramp'] = ["impl Copy for Limb","impl Copy for Limbs","impl Copy for LimbsMut",]; +implementors["libc"] = ["impl Copy for stat","impl Copy for utimbuf","impl Copy for timeval","impl Copy for timespec",];implementors["rand"] = ["impl<X: Copy> Copy for Range<X>","impl Copy for Gamma","impl Copy for ChiSquared","impl Copy for FisherF","impl Copy for StudentT","impl Copy for StandardNormal","impl Copy for Normal","impl Copy for LogNormal","impl Copy for Exp1","impl Copy for Exp","impl<Sup> Copy for RandSample<Sup>","impl<T: Copy> Copy for Weighted<T>","impl Copy for IsaacRng","impl Copy for Isaac64Rng","impl Copy for ChaChaRng","impl Copy for ReseedWithDefault","impl Copy for StdRng",];implementors["ramp"] = ["impl Copy for Limb","impl Copy for Limbs","impl Copy for LimbsMut",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/marker/trait.Send.js b/implementors/core/marker/trait.Send.js index 5fd020f..d1b392a 100644 --- a/implementors/core/marker/trait.Send.js +++ b/implementors/core/marker/trait.Send.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/marker/trait.Sync.js b/implementors/core/marker/trait.Sync.js index 5fd020f..d1b392a 100644 --- a/implementors/core/marker/trait.Sync.js +++ b/implementors/core/marker/trait.Sync.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/nonzero/trait.Zeroable.js b/implementors/core/nonzero/trait.Zeroable.js index 5fd020f..d1b392a 100644 --- a/implementors/core/nonzero/trait.Zeroable.js +++ b/implementors/core/nonzero/trait.Zeroable.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/num/trait.One.js b/implementors/core/num/trait.One.js index f716ebf..ce8cfbe 100644 --- a/implementors/core/num/trait.One.js +++ b/implementors/core/num/trait.One.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl One for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl One for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/num/trait.Zero.js b/implementors/core/num/trait.Zero.js index 759306c..db2f812 100644 --- a/implementors/core/num/trait.Zero.js +++ b/implementors/core/num/trait.Zero.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl Zero for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl Zero for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.Add.js b/implementors/core/ops/trait.Add.js index b4c4e40..8001e8a 100644 --- a/implementors/core/ops/trait.Add.js +++ b/implementors/core/ops/trait.Add.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['pumpkin'] = ["impl Add<Prime> for Prime","impl Add<Int> for Prime",]; +implementors['pumpkin'] = ["impl Add<Prime> for Prime","impl Add<Int> for Prime",];implementors["libc"] = [];implementors["ramp"] = ["impl Add<Limb> for Limb","impl Add<BaseInt> for Limb","impl Add<bool> for Limb","impl Add<Limb> for BaseInt","impl Add<Limb> for Int","impl<'a> Add<&'a Int> for Int","impl<'a> Add<Int> for &'a Int","impl Add<Int> for Int","impl<'a, 'b> Add<&'a Int> for &'b Int","impl Add<i32> for Int","impl<'a> Add<i32> for &'a Int","impl Add<Int> for i32","impl<'a> Add<&'a Int> for i32","impl Add<usize> for Int","impl<'a> Add<usize> for &'a Int","impl Add<Int> for usize","impl<'a> Add<&'a Int> for usize","impl Add<BaseInt> for Int","impl<'a> Add<BaseInt> for &'a Int","impl Add<Int> for BaseInt","impl<'a> Add<&'a Int> for BaseInt",];implementors["pumpkin"] = ["impl Add<Prime> for Prime","impl Add<Int> for Prime",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.AddAssign.js b/implementors/core/ops/trait.AddAssign.js index 7c9c8cb..2ca6db5 100644 --- a/implementors/core/ops/trait.AddAssign.js +++ b/implementors/core/ops/trait.AddAssign.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl AddAssign<Limb> for Int","impl<'a> AddAssign<&'a Int> for Int","impl AddAssign<Int> for Int","impl AddAssign<i32> for Int","impl AddAssign<usize> for Int","impl AddAssign<BaseInt> for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl AddAssign<Limb> for Int","impl<'a> AddAssign<&'a Int> for Int","impl AddAssign<Int> for Int","impl AddAssign<i32> for Int","impl AddAssign<usize> for Int","impl AddAssign<BaseInt> for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.BitAnd.js b/implementors/core/ops/trait.BitAnd.js index 9156d75..fbe4dab 100644 --- a/implementors/core/ops/trait.BitAnd.js +++ b/implementors/core/ops/trait.BitAnd.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['pumpkin'] = ["impl BitAnd<Prime> for Prime","impl BitAnd<Int> for Prime",]; +implementors['pumpkin'] = ["impl BitAnd<Prime> for Prime","impl BitAnd<Int> for Prime",];implementors["libc"] = [];implementors["ramp"] = ["impl BitAnd<Limb> for Limb","impl<'a> BitAnd<Limb> for Int","impl<'a> BitAnd<&'a Int> for Int","impl<'a> BitAnd<Int> for &'a Int","impl<'a, 'b> BitAnd<&'a Int> for &'b Int","impl BitAnd<Int> for Int","impl BitAnd<i32> for Int","impl<'a> BitAnd<i32> for &'a Int","impl BitAnd<Int> for i32","impl<'a> BitAnd<&'a Int> for i32","impl BitAnd<usize> for Int","impl<'a> BitAnd<usize> for &'a Int","impl BitAnd<Int> for usize","impl<'a> BitAnd<&'a Int> for usize","impl BitAnd<BaseInt> for Int","impl<'a> BitAnd<BaseInt> for &'a Int","impl BitAnd<Int> for BaseInt","impl<'a> BitAnd<&'a Int> for BaseInt",];implementors["pumpkin"] = ["impl BitAnd<Prime> for Prime","impl BitAnd<Int> for Prime",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.BitAndAssign.js b/implementors/core/ops/trait.BitAndAssign.js index 8aea5db..ec974c6 100644 --- a/implementors/core/ops/trait.BitAndAssign.js +++ b/implementors/core/ops/trait.BitAndAssign.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl BitAndAssign<Limb> for Int","impl BitAndAssign<Int> for Int","impl<'a> BitAndAssign<&'a Int> for Int","impl BitAndAssign<i32> for Int","impl BitAndAssign<usize> for Int","impl BitAndAssign<BaseInt> for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl BitAndAssign<Limb> for Int","impl BitAndAssign<Int> for Int","impl<'a> BitAndAssign<&'a Int> for Int","impl BitAndAssign<i32> for Int","impl BitAndAssign<usize> for Int","impl BitAndAssign<BaseInt> for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.BitOr.js b/implementors/core/ops/trait.BitOr.js index c8f558b..0ff8e99 100644 --- a/implementors/core/ops/trait.BitOr.js +++ b/implementors/core/ops/trait.BitOr.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['pumpkin'] = ["impl BitOr<Prime> for Prime","impl BitOr<Int> for Prime",]; +implementors['pumpkin'] = ["impl BitOr<Prime> for Prime","impl BitOr<Int> for Prime",];implementors["libc"] = [];implementors["ramp"] = ["impl BitOr<Limb> for Limb","impl BitOr<Limb> for Int","impl<'a> BitOr<&'a Int> for Int","impl<'a> BitOr<Int> for &'a Int","impl<'a, 'b> BitOr<&'a Int> for &'b Int","impl BitOr<Int> for Int","impl BitOr<i32> for Int","impl<'a> BitOr<i32> for &'a Int","impl BitOr<Int> for i32","impl<'a> BitOr<&'a Int> for i32","impl BitOr<usize> for Int","impl<'a> BitOr<usize> for &'a Int","impl BitOr<Int> for usize","impl<'a> BitOr<&'a Int> for usize","impl BitOr<BaseInt> for Int","impl<'a> BitOr<BaseInt> for &'a Int","impl BitOr<Int> for BaseInt","impl<'a> BitOr<&'a Int> for BaseInt",];implementors["pumpkin"] = ["impl BitOr<Prime> for Prime","impl BitOr<Int> for Prime",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.BitOrAssign.js b/implementors/core/ops/trait.BitOrAssign.js index ec7a068..68d28ca 100644 --- a/implementors/core/ops/trait.BitOrAssign.js +++ b/implementors/core/ops/trait.BitOrAssign.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl BitOrAssign<Limb> for Int","impl BitOrAssign<Int> for Int","impl<'a> BitOrAssign<&'a Int> for Int","impl BitOrAssign<i32> for Int","impl BitOrAssign<usize> for Int","impl BitOrAssign<BaseInt> for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl BitOrAssign<Limb> for Int","impl BitOrAssign<Int> for Int","impl<'a> BitOrAssign<&'a Int> for Int","impl BitOrAssign<i32> for Int","impl BitOrAssign<usize> for Int","impl BitOrAssign<BaseInt> for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.BitXor.js b/implementors/core/ops/trait.BitXor.js index de21254..aaf173a 100644 --- a/implementors/core/ops/trait.BitXor.js +++ b/implementors/core/ops/trait.BitXor.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['pumpkin'] = ["impl BitXor<Prime> for Prime","impl BitXor<Int> for Prime",]; +implementors['pumpkin'] = ["impl BitXor<Prime> for Prime","impl BitXor<Int> for Prime",];implementors["libc"] = [];implementors["ramp"] = ["impl BitXor<Limb> for Limb","impl<'a> BitXor<Limb> for Int","impl<'a> BitXor<&'a Int> for Int","impl<'a> BitXor<Int> for &'a Int","impl<'a, 'b> BitXor<&'a Int> for &'b Int","impl BitXor<Int> for Int","impl BitXor<i32> for Int","impl<'a> BitXor<i32> for &'a Int","impl BitXor<Int> for i32","impl<'a> BitXor<&'a Int> for i32","impl BitXor<usize> for Int","impl<'a> BitXor<usize> for &'a Int","impl BitXor<Int> for usize","impl<'a> BitXor<&'a Int> for usize","impl BitXor<BaseInt> for Int","impl<'a> BitXor<BaseInt> for &'a Int","impl BitXor<Int> for BaseInt","impl<'a> BitXor<&'a Int> for BaseInt",];implementors["pumpkin"] = ["impl BitXor<Prime> for Prime","impl BitXor<Int> for Prime",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.BitXorAssign.js b/implementors/core/ops/trait.BitXorAssign.js index 888508c..0e7e934 100644 --- a/implementors/core/ops/trait.BitXorAssign.js +++ b/implementors/core/ops/trait.BitXorAssign.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl BitXorAssign<Limb> for Int","impl BitXorAssign<Int> for Int","impl<'a> BitXorAssign<&'a Int> for Int","impl BitXorAssign<i32> for Int","impl BitXorAssign<usize> for Int","impl BitXorAssign<BaseInt> for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl BitXorAssign<Limb> for Int","impl BitXorAssign<Int> for Int","impl<'a> BitXorAssign<&'a Int> for Int","impl BitXorAssign<i32> for Int","impl BitXorAssign<usize> for Int","impl BitXorAssign<BaseInt> for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.CoerceUnsized.js b/implementors/core/ops/trait.CoerceUnsized.js index 5fd020f..d1b392a 100644 --- a/implementors/core/ops/trait.CoerceUnsized.js +++ b/implementors/core/ops/trait.CoerceUnsized.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.Deref.js b/implementors/core/ops/trait.Deref.js index 2408eb4..dc8aa5b 100644 --- a/implementors/core/ops/trait.Deref.js +++ b/implementors/core/ops/trait.Deref.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl Deref for Limbs","impl Deref for LimbsMut",]; +implementors["libc"] = [];implementors["ramp"] = ["impl Deref for Limbs","impl Deref for LimbsMut",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.DerefMut.js b/implementors/core/ops/trait.DerefMut.js index 92d4b12..98df484 100644 --- a/implementors/core/ops/trait.DerefMut.js +++ b/implementors/core/ops/trait.DerefMut.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl DerefMut for LimbsMut",]; +implementors["libc"] = [];implementors["ramp"] = ["impl DerefMut for LimbsMut",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.Div.js b/implementors/core/ops/trait.Div.js index dccedb7..a65f709 100644 --- a/implementors/core/ops/trait.Div.js +++ b/implementors/core/ops/trait.Div.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['pumpkin'] = ["impl Div<Prime> for Prime","impl Div<Int> for Prime",]; +implementors['pumpkin'] = ["impl Div<Prime> for Prime","impl Div<Int> for Prime",];implementors["libc"] = [];implementors["ramp"] = ["impl Div<Limb> for Limb","impl Div<BaseInt> for Limb","impl Div<Limb> for Int","impl<'a, 'b> Div<&'a Int> for &'b Int","impl<'a> Div<&'a Int> for Int","impl<'a> Div<Int> for &'a Int","impl Div<Int> for Int","impl Div<i32> for Int","impl<'a> Div<i32> for &'a Int","impl Div<Int> for i32","impl<'a> Div<&'a Int> for i32","impl Div<usize> for Int","impl<'a> Div<usize> for &'a Int","impl Div<Int> for usize","impl<'a> Div<&'a Int> for usize","impl Div<BaseInt> for Int","impl<'a> Div<BaseInt> for &'a Int","impl Div<Int> for BaseInt","impl<'a> Div<&'a Int> for BaseInt",];implementors["pumpkin"] = ["impl Div<Prime> for Prime","impl Div<Int> for Prime",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.DivAssign.js b/implementors/core/ops/trait.DivAssign.js index ff43b2e..d2041cd 100644 --- a/implementors/core/ops/trait.DivAssign.js +++ b/implementors/core/ops/trait.DivAssign.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl DivAssign<Limb> for Int","impl<'a> DivAssign<&'a Int> for Int","impl DivAssign<Int> for Int","impl DivAssign<i32> for Int","impl DivAssign<usize> for Int","impl DivAssign<BaseInt> for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl DivAssign<Limb> for Int","impl<'a> DivAssign<&'a Int> for Int","impl DivAssign<Int> for Int","impl DivAssign<i32> for Int","impl DivAssign<usize> for Int","impl DivAssign<BaseInt> for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.Drop.js b/implementors/core/ops/trait.Drop.js index 97f0b9e..d9fd500 100644 --- a/implementors/core/ops/trait.Drop.js +++ b/implementors/core/ops/trait.Drop.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['ramp'] = ["impl Drop for Int",]; +implementors["ramp"] = ["impl Drop for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.Fn.js b/implementors/core/ops/trait.Fn.js index 5fd020f..d1b392a 100644 --- a/implementors/core/ops/trait.Fn.js +++ b/implementors/core/ops/trait.Fn.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.FnMut.js b/implementors/core/ops/trait.FnMut.js index 5fd020f..d1b392a 100644 --- a/implementors/core/ops/trait.FnMut.js +++ b/implementors/core/ops/trait.FnMut.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.FnOnce.js b/implementors/core/ops/trait.FnOnce.js index 5fd020f..d1b392a 100644 --- a/implementors/core/ops/trait.FnOnce.js +++ b/implementors/core/ops/trait.FnOnce.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.Index.js b/implementors/core/ops/trait.Index.js index 5fd020f..d1b392a 100644 --- a/implementors/core/ops/trait.Index.js +++ b/implementors/core/ops/trait.Index.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.IndexMut.js b/implementors/core/ops/trait.IndexMut.js index 5fd020f..d1b392a 100644 --- a/implementors/core/ops/trait.IndexMut.js +++ b/implementors/core/ops/trait.IndexMut.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.Mul.js b/implementors/core/ops/trait.Mul.js index 339fd44..5896ea8 100644 --- a/implementors/core/ops/trait.Mul.js +++ b/implementors/core/ops/trait.Mul.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['pumpkin'] = ["impl Mul<Prime> for Prime","impl Mul<Int> for Prime",]; +implementors['pumpkin'] = ["impl Mul<Prime> for Prime","impl Mul<Int> for Prime",];implementors["libc"] = [];implementors["ramp"] = ["impl Mul<Limb> for Limb","impl Mul<BaseInt> for Limb","impl Mul<Limb> for BaseInt","impl Mul<Limb> for Int","impl<'a, 'b> Mul<&'a Int> for &'b Int","impl<'a> Mul<&'a Int> for Int","impl<'a> Mul<Int> for &'a Int","impl Mul<Int> for Int","impl Mul<i32> for Int","impl<'a> Mul<i32> for &'a Int","impl Mul<Int> for i32","impl<'a> Mul<&'a Int> for i32","impl Mul<usize> for Int","impl<'a> Mul<usize> for &'a Int","impl Mul<Int> for usize","impl<'a> Mul<&'a Int> for usize","impl Mul<BaseInt> for Int","impl<'a> Mul<BaseInt> for &'a Int","impl Mul<Int> for BaseInt","impl<'a> Mul<&'a Int> for BaseInt",];implementors["pumpkin"] = ["impl Mul<Prime> for Prime","impl Mul<Int> for Prime",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.MulAssign.js b/implementors/core/ops/trait.MulAssign.js index 1186173..b05e637 100644 --- a/implementors/core/ops/trait.MulAssign.js +++ b/implementors/core/ops/trait.MulAssign.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl MulAssign<Limb> for Int","impl<'a> MulAssign<&'a Int> for Int","impl MulAssign<Int> for Int","impl MulAssign<i32> for Int","impl MulAssign<usize> for Int","impl MulAssign<BaseInt> for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl MulAssign<Limb> for Int","impl<'a> MulAssign<&'a Int> for Int","impl MulAssign<Int> for Int","impl MulAssign<i32> for Int","impl MulAssign<usize> for Int","impl MulAssign<BaseInt> for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.Neg.js b/implementors/core/ops/trait.Neg.js index bbe5795..664e37f 100644 --- a/implementors/core/ops/trait.Neg.js +++ b/implementors/core/ops/trait.Neg.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl Neg for Limb","impl Neg for Int","impl<'a> Neg for &'a Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl Neg for Limb","impl Neg for Int","impl<'a> Neg for &'a Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.Not.js b/implementors/core/ops/trait.Not.js index a5d03ac..f3b44c1 100644 --- a/implementors/core/ops/trait.Not.js +++ b/implementors/core/ops/trait.Not.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl Not for Limb",]; +implementors["libc"] = [];implementors["ramp"] = ["impl Not for Limb",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.Rem.js b/implementors/core/ops/trait.Rem.js index d2dddd5..fcf0787 100644 --- a/implementors/core/ops/trait.Rem.js +++ b/implementors/core/ops/trait.Rem.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['pumpkin'] = ["impl Rem<Prime> for Prime","impl Rem<Int> for Prime",]; +implementors['pumpkin'] = ["impl Rem<Prime> for Prime","impl Rem<Int> for Prime",];implementors["libc"] = [];implementors["ramp"] = ["impl Rem<Limb> for Limb","impl Rem<BaseInt> for Limb","impl Rem<Limb> for Int","impl<'a, 'b> Rem<&'a Int> for &'b Int","impl<'a> Rem<&'a Int> for Int","impl<'a> Rem<Int> for &'a Int","impl Rem<Int> for Int","impl Rem<i32> for Int","impl<'a> Rem<i32> for &'a Int","impl Rem<Int> for i32","impl<'a> Rem<&'a Int> for i32","impl Rem<usize> for Int","impl<'a> Rem<usize> for &'a Int","impl Rem<Int> for usize","impl<'a> Rem<&'a Int> for usize","impl Rem<BaseInt> for Int","impl<'a> Rem<BaseInt> for &'a Int","impl Rem<Int> for BaseInt","impl<'a> Rem<&'a Int> for BaseInt",];implementors["pumpkin"] = ["impl Rem<Prime> for Prime","impl Rem<Int> for Prime",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.RemAssign.js b/implementors/core/ops/trait.RemAssign.js index ab9db1d..ef0934b 100644 --- a/implementors/core/ops/trait.RemAssign.js +++ b/implementors/core/ops/trait.RemAssign.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl RemAssign<Limb> for Int","impl RemAssign<Int> for Int","impl<'a> RemAssign<&'a Int> for Int","impl RemAssign<i32> for Int","impl RemAssign<usize> for Int","impl RemAssign<BaseInt> for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl RemAssign<Limb> for Int","impl RemAssign<Int> for Int","impl<'a> RemAssign<&'a Int> for Int","impl RemAssign<i32> for Int","impl RemAssign<usize> for Int","impl RemAssign<BaseInt> for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.Shl.js b/implementors/core/ops/trait.Shl.js index 0904359..2f2eadb 100644 --- a/implementors/core/ops/trait.Shl.js +++ b/implementors/core/ops/trait.Shl.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl<I> Shl<I> for Limb where BaseInt: Shl<I, Output=BaseInt>","impl<'a> Shl<usize> for &'a Int","impl Shl<usize> for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl<I> Shl<I> for Limb where BaseInt: Shl<I, Output=BaseInt>","impl<'a> Shl<usize> for &'a Int","impl Shl<usize> for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.ShlAssign.js b/implementors/core/ops/trait.ShlAssign.js index 8491f5f..973c254 100644 --- a/implementors/core/ops/trait.ShlAssign.js +++ b/implementors/core/ops/trait.ShlAssign.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl ShlAssign<usize> for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl ShlAssign<usize> for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.Shr.js b/implementors/core/ops/trait.Shr.js index 05d1802..a231499 100644 --- a/implementors/core/ops/trait.Shr.js +++ b/implementors/core/ops/trait.Shr.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl<I> Shr<I> for Limb where BaseInt: Shr<I, Output=BaseInt>","impl<'a> Shr<usize> for &'a Int","impl Shr<usize> for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl<I> Shr<I> for Limb where BaseInt: Shr<I, Output=BaseInt>","impl<'a> Shr<usize> for &'a Int","impl Shr<usize> for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.ShrAssign.js b/implementors/core/ops/trait.ShrAssign.js index 130497d..c226007 100644 --- a/implementors/core/ops/trait.ShrAssign.js +++ b/implementors/core/ops/trait.ShrAssign.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl ShrAssign<usize> for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl ShrAssign<usize> for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.Sub.js b/implementors/core/ops/trait.Sub.js index ebb2a0d..144367f 100644 --- a/implementors/core/ops/trait.Sub.js +++ b/implementors/core/ops/trait.Sub.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['pumpkin'] = ["impl Sub<Prime> for Prime","impl Sub<Int> for Prime",]; +implementors['pumpkin'] = ["impl Sub<Prime> for Prime","impl Sub<Int> for Prime",];implementors["libc"] = [];implementors["ramp"] = ["impl Sub<Limb> for Limb","impl Sub<BaseInt> for Limb","impl Sub<bool> for Limb","impl Sub<Limb> for BaseInt","impl Sub<Limb> for Int","impl<'a> Sub<&'a Int> for Int","impl<'a> Sub<Int> for &'a Int","impl Sub<Int> for Int","impl<'a, 'b> Sub<&'a Int> for &'b Int","impl Sub<i32> for Int","impl<'a> Sub<i32> for &'a Int","impl Sub<Int> for i32","impl<'a> Sub<&'a Int> for i32","impl Sub<usize> for Int","impl<'a> Sub<usize> for &'a Int","impl Sub<Int> for usize","impl<'a> Sub<&'a Int> for usize","impl Sub<BaseInt> for Int","impl<'a> Sub<BaseInt> for &'a Int","impl Sub<Int> for BaseInt","impl<'a> Sub<&'a Int> for BaseInt",];implementors["pumpkin"] = ["impl Sub<Prime> for Prime","impl Sub<Int> for Prime",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/ops/trait.SubAssign.js b/implementors/core/ops/trait.SubAssign.js index 5e3a70a..3f98619 100644 --- a/implementors/core/ops/trait.SubAssign.js +++ b/implementors/core/ops/trait.SubAssign.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl SubAssign<Limb> for Int","impl<'a> SubAssign<&'a Int> for Int","impl SubAssign<Int> for Int","impl SubAssign<i32> for Int","impl SubAssign<usize> for Int","impl SubAssign<BaseInt> for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl SubAssign<Limb> for Int","impl<'a> SubAssign<&'a Int> for Int","impl SubAssign<Int> for Int","impl SubAssign<i32> for Int","impl SubAssign<usize> for Int","impl SubAssign<BaseInt> for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/raw/trait.Repr.js b/implementors/core/raw/trait.Repr.js index 5fd020f..d1b392a 100644 --- a/implementors/core/raw/trait.Repr.js +++ b/implementors/core/raw/trait.Repr.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/slice/trait.SliceExt.js b/implementors/core/slice/trait.SliceExt.js index 5fd020f..d1b392a 100644 --- a/implementors/core/slice/trait.SliceExt.js +++ b/implementors/core/slice/trait.SliceExt.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/str/pattern/trait.DoubleEndedSearcher.js b/implementors/core/str/pattern/trait.DoubleEndedSearcher.js index 5fd020f..d1b392a 100644 --- a/implementors/core/str/pattern/trait.DoubleEndedSearcher.js +++ b/implementors/core/str/pattern/trait.DoubleEndedSearcher.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/str/pattern/trait.Pattern.js b/implementors/core/str/pattern/trait.Pattern.js index 5fd020f..d1b392a 100644 --- a/implementors/core/str/pattern/trait.Pattern.js +++ b/implementors/core/str/pattern/trait.Pattern.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/str/pattern/trait.ReverseSearcher.js b/implementors/core/str/pattern/trait.ReverseSearcher.js index 5fd020f..d1b392a 100644 --- a/implementors/core/str/pattern/trait.ReverseSearcher.js +++ b/implementors/core/str/pattern/trait.ReverseSearcher.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/str/pattern/trait.Searcher.js b/implementors/core/str/pattern/trait.Searcher.js index 5fd020f..d1b392a 100644 --- a/implementors/core/str/pattern/trait.Searcher.js +++ b/implementors/core/str/pattern/trait.Searcher.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = []; +implementors["libc"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/core/str/trait.FromStr.js b/implementors/core/str/trait.FromStr.js index b1e059e..90d3430 100644 --- a/implementors/core/str/trait.FromStr.js +++ b/implementors/core/str/trait.FromStr.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['libc'] = [];implementors['ramp'] = ["impl FromStr for Int",]; +implementors["libc"] = [];implementors["ramp"] = ["impl FromStr for Int",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/ramp/int/trait.RandomInt.js b/implementors/ramp/int/trait.RandomInt.js new file mode 100644 index 0000000..27d55ae --- /dev/null +++ b/implementors/ramp/int/trait.RandomInt.js @@ -0,0 +1,10 @@ +(function() {var implementors = {}; +implementors["ramp"] = []; + + if (window.register_implementors) { + window.register_implementors(implementors); + } else { + window.pending_implementors = implementors; + } + +})() diff --git a/implementors/rand/distributions/range/trait.SampleRange.js b/implementors/rand/distributions/range/trait.SampleRange.js index 0a2034f..4a757ff 100644 --- a/implementors/rand/distributions/range/trait.SampleRange.js +++ b/implementors/rand/distributions/range/trait.SampleRange.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['rand'] = []; +implementors["rand"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/rand/distributions/trait.IndependentSample.js b/implementors/rand/distributions/trait.IndependentSample.js index 0a2034f..4a757ff 100644 --- a/implementors/rand/distributions/trait.IndependentSample.js +++ b/implementors/rand/distributions/trait.IndependentSample.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['rand'] = []; +implementors["rand"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/rand/distributions/trait.Sample.js b/implementors/rand/distributions/trait.Sample.js index 0a2034f..4a757ff 100644 --- a/implementors/rand/distributions/trait.Sample.js +++ b/implementors/rand/distributions/trait.Sample.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['rand'] = []; +implementors["rand"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/rand/reseeding/trait.Reseeder.js b/implementors/rand/reseeding/trait.Reseeder.js index 0a2034f..4a757ff 100644 --- a/implementors/rand/reseeding/trait.Reseeder.js +++ b/implementors/rand/reseeding/trait.Reseeder.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['rand'] = []; +implementors["rand"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/rand/trait.Rand.js b/implementors/rand/trait.Rand.js index 0a2034f..4a757ff 100644 --- a/implementors/rand/trait.Rand.js +++ b/implementors/rand/trait.Rand.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['rand'] = []; +implementors["rand"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/rand/trait.Rng.js b/implementors/rand/trait.Rng.js index 0a2034f..4a757ff 100644 --- a/implementors/rand/trait.Rng.js +++ b/implementors/rand/trait.Rng.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['rand'] = []; +implementors["rand"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/rand/trait.SeedableRng.js b/implementors/rand/trait.SeedableRng.js index 0a2034f..4a757ff 100644 --- a/implementors/rand/trait.SeedableRng.js +++ b/implementors/rand/trait.SeedableRng.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['rand'] = []; +implementors["rand"] = []; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/implementors/std/error/trait.Error.js b/implementors/std/error/trait.Error.js index 9fefb94..88a8b20 100644 --- a/implementors/std/error/trait.Error.js +++ b/implementors/std/error/trait.Error.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors['ramp'] = ["impl Error for ParseIntError",]; +implementors["ramp"] = ["impl Error for ParseIntError",]; if (window.register_implementors) { window.register_implementors(implementors); diff --git a/libc/constant.TMP_MAX.html b/libc/constant.TMP_MAX.html index f81f89b..b505a47 100644 --- a/libc/constant.TMP_MAX.html +++ b/libc/constant.TMP_MAX.html @@ -48,7 +48,7 @@ [−] [src] -

pub const TMP_MAX: c_uint = 0x7fff
+
pub const TMP_MAX: c_uint = 32767
diff --git a/libc/struct.stat.html b/libc/struct.stat.html index e0e98fa..938622d 100644 --- a/libc/struct.stat.html +++ b/libc/struct.stat.html @@ -72,8 +72,10 @@ st_size st_atime st_mtime - st_ctime

Trait Implementations

impl Copy for stat

impl Clone for stat

fn clone(&self) -> stat

-

fn clone_from(&mut self, source: &Self)1.0.0

+ st_ctime

Trait Implementations

impl Copy for stat
[src]

+

impl Clone for stat
[src]

+

fn clone(&self) -> stat

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/libc/struct.timespec.html b/libc/struct.timespec.html index f651cb4..8e008ac 100644 --- a/libc/struct.timespec.html +++ b/libc/struct.timespec.html @@ -54,8 +54,10 @@ }

Fields

-
tv_sec
tv_nsec

Trait Implementations

impl Copy for timespec

impl Clone for timespec

fn clone(&self) -> timespec

-

fn clone_from(&mut self, source: &Self)1.0.0

+ tv_nsec

Trait Implementations

impl Copy for timespec
[src]

+

impl Clone for timespec
[src]

+

fn clone(&self) -> timespec

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/libc/struct.timeval.html b/libc/struct.timeval.html index dc5b465..727fa77 100644 --- a/libc/struct.timeval.html +++ b/libc/struct.timeval.html @@ -54,8 +54,10 @@ }

Fields

-
tv_sec
tv_usec

Trait Implementations

impl Copy for timeval

impl Clone for timeval

fn clone(&self) -> timeval

-

fn clone_from(&mut self, source: &Self)1.0.0

+ tv_usec

Trait Implementations

impl Copy for timeval
[src]

+

impl Clone for timeval
[src]

+

fn clone(&self) -> timeval

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/libc/struct.utimbuf.html b/libc/struct.utimbuf.html index 62e2a35..db61902 100644 --- a/libc/struct.utimbuf.html +++ b/libc/struct.utimbuf.html @@ -54,8 +54,10 @@ }

Fields

-
actime
modtime

Trait Implementations

impl Copy for utimbuf

impl Clone for utimbuf

fn clone(&self) -> utimbuf

-

fn clone_from(&mut self, source: &Self)1.0.0

+ modtime

Trait Implementations

impl Copy for utimbuf
[src]

+

impl Clone for utimbuf
[src]

+

fn clone(&self) -> utimbuf

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/main.css b/main.css index 5c07386..59b2ff7 100644 --- a/main.css +++ b/main.css @@ -26,6 +26,9 @@ h1.fqn { h2, h3:not(.impl):not(.method):not(.type):not(.tymethod), h4:not(.method):not(.type):not(.tymethod) { border-bottom-color: #DDDDDD; } +.in-band, code { + background-color: white; +} .docblock code { background-color: #F5F5F5; diff --git a/pumpkin/index.html b/pumpkin/index.html index b4ad3e3..25503ef 100644 --- a/pumpkin/index.html +++ b/pumpkin/index.html @@ -47,7 +47,7 @@ [−] - [src] + [src]

A crate for generating large, cryptographically secure prime numbers. Primes are seeded from the operating system's main source of entropy, ensuring proper randomness.

diff --git a/pumpkin/struct.Prime.html b/pumpkin/struct.Prime.html index 80d2dbb..168e9ec 100644 --- a/pumpkin/struct.Prime.html +++ b/pumpkin/struct.Prime.html @@ -48,56 +48,79 @@ [−] -
pub struct Prime(_);

A cryptographically secure prime number.

-

Methods

impl Prime

fn new(bit_length: usize) -> Prime

+
pub struct Prime(pub Int);

A cryptographically secure prime number.

+

Methods

impl Prime
[src]

+

fn new(bit_length: usize) -> Prime

Constructs a new Prime with a size of bit_length bits.

This will initialize an OsRng instance and call the Prime::from_rng() method.

Note: the bit_length MUST be at least 512-bits.

-

fn from_rng(bit_length: usize, rngesus: &mut OsRng) -> Prime

+

fn from_rng(bit_length: usize, rngesus: &mut OsRng) -> Prime

Constructs a new Prime with the size of bit_length bits, sourced from an already-created OsRng. Not that you can ONLY use an OsRng, as it uses the operating system's secure source of entropy.

-

Trait Implementations

impl Debug for Prime

fn fmt(&self, fmt: &mut Formatter) -> Result

-

impl Display for Prime

fn fmt(&self, fmt: &mut Formatter) -> Result

-

impl Binary for Prime

fn fmt(&self, fmt: &mut Formatter) -> Result

-

impl Octal for Prime

fn fmt(&self, fmt: &mut Formatter) -> Result

-

impl LowerHex for Prime

fn fmt(&self, fmt: &mut Formatter) -> Result

-

impl UpperHex for Prime

fn fmt(&self, fmt: &mut Formatter) -> Result

-

impl Add<Prime> for Prime

type Output = Prime

+

Trait Implementations

impl Debug for Prime

+

fn fmt(&self, fmt: &mut Formatter) -> Result

+

impl Display for Prime

+

fn fmt(&self, fmt: &mut Formatter) -> Result

+

impl Binary for Prime

+

fn fmt(&self, fmt: &mut Formatter) -> Result

+

impl Octal for Prime

+

fn fmt(&self, fmt: &mut Formatter) -> Result

+

impl LowerHex for Prime

+

fn fmt(&self, fmt: &mut Formatter) -> Result

+

impl UpperHex for Prime

+

fn fmt(&self, fmt: &mut Formatter) -> Result

+

impl Add<Prime> for Prime

+

type Output = Prime

fn add(self, rhs: Self) -> Prime

-

impl Add<Int> for Prime

type Output = Prime

-

fn add(self, rhs: Int) -> Prime

-

impl Sub<Prime> for Prime

type Output = Prime

+

impl Add<Int> for Prime

+

type Output = Prime

+

fn add(self, rhs: Int) -> Prime

+

impl Sub<Prime> for Prime

+

type Output = Prime

fn sub(self, rhs: Self) -> Prime

-

impl Sub<Int> for Prime

type Output = Prime

-

fn sub(self, rhs: Int) -> Prime

-

impl Mul<Prime> for Prime

type Output = Prime

+

impl Sub<Int> for Prime

+

type Output = Prime

+

fn sub(self, rhs: Int) -> Prime

+

impl Mul<Prime> for Prime

+

type Output = Prime

fn mul(self, rhs: Self) -> Prime

-

impl Mul<Int> for Prime

type Output = Prime

-

fn mul(self, rhs: Int) -> Prime

-

impl Div<Prime> for Prime

type Output = Prime

+

impl Mul<Int> for Prime

+

type Output = Prime

+

fn mul(self, rhs: Int) -> Prime

+

impl Div<Prime> for Prime

+

type Output = Prime

fn div(self, rhs: Self) -> Prime

-

impl Div<Int> for Prime

type Output = Prime

-

fn div(self, rhs: Int) -> Prime

-

impl Rem<Prime> for Prime

type Output = Prime

+

impl Div<Int> for Prime

+

type Output = Prime

+

fn div(self, rhs: Int) -> Prime

+

impl Rem<Prime> for Prime

+

type Output = Prime

fn rem(self, rhs: Self) -> Prime

-

impl Rem<Int> for Prime

type Output = Prime

-

fn rem(self, rhs: Int) -> Prime

-

impl BitAnd<Prime> for Prime

type Output = Prime

+

impl Rem<Int> for Prime

+

type Output = Prime

+

fn rem(self, rhs: Int) -> Prime

+

impl BitAnd<Prime> for Prime

+

type Output = Prime

fn bitand(self, rhs: Self) -> Prime

-

impl BitAnd<Int> for Prime

type Output = Prime

-

fn bitand(self, rhs: Int) -> Prime

-

impl BitOr<Prime> for Prime

type Output = Prime

+

impl BitAnd<Int> for Prime

+

type Output = Prime

+

fn bitand(self, rhs: Int) -> Prime

+

impl BitOr<Prime> for Prime

+

type Output = Prime

fn bitor(self, rhs: Self) -> Prime

-

impl BitOr<Int> for Prime

type Output = Prime

-

fn bitor(self, rhs: Int) -> Prime

-

impl BitXor<Prime> for Prime

type Output = Prime

+

impl BitOr<Int> for Prime

+

type Output = Prime

+

fn bitor(self, rhs: Int) -> Prime

+

impl BitXor<Prime> for Prime

+

type Output = Prime

fn bitxor(self, rhs: Self) -> Prime

-

impl BitXor<Int> for Prime

type Output = Prime

-

fn bitxor(self, rhs: Int) -> Prime

+

impl BitXor<Int> for Prime

+

type Output = Prime

+

fn bitxor(self, rhs: Int) -> Prime

diff --git a/ramp/int/index.html b/ramp/int/index.html index 1aab35b..1352141 100644 --- a/ramp/int/index.html +++ b/ramp/int/index.html @@ -47,7 +47,7 @@ [−] - [src] + [src]

Structs

diff --git a/ramp/int/struct.Int.html b/ramp/int/struct.Int.html index 7d8ad54..cf2f47e 100644 --- a/ramp/int/struct.Int.html +++ b/ramp/int/struct.Int.html @@ -47,7 +47,7 @@ [−] - [src] + [src]
pub struct Int {
     // some fields omitted
 }

An arbitrary-precision signed integer.

@@ -109,7 +109,8 @@ shift-left and shift-right respectively. The sign of the number is unaffected.The remaining bitwise operands act as if the numbers are stored in two's complement format and as if the two inputs have the same number of bits.

-

Methods

impl Int

fn zero() -> Int

+

Methods

impl Int
[src]

+

fn zero() -> Int

fn one() -> Int

fn from_single_limb(limb: Limb) -> Int

Creates a new Int from the given Limb.

@@ -181,314 +182,496 @@ negative numbers as if they're stored in two's complement.

The result is always positive.

fn lcm(&self, other: &Int) -> Int

Calculates the Lowest Common Multiple (LCM) of the number and other.

-

Trait Implementations

impl Clone for Int

fn clone(&self) -> Int

+

Trait Implementations

impl Clone for Int
[src]

+

fn clone(&self) -> Int

fn clone_from(&mut self, other: &Int)

-

impl Default for Int

fn default() -> Int

-

impl Drop for Int

fn drop(&mut self)

-

impl PartialEq<Int> for Int

fn eq(&self, other: &Int) -> bool

-

fn ne(&self, other: &Rhs) -> bool1.0.0

-

impl PartialEq<Limb> for Int

fn eq(&self, other: &Limb) -> bool

-

fn ne(&self, other: &Rhs) -> bool1.0.0

-

impl Eq for Int

impl Ord for Int

fn cmp(&self, other: &Int) -> Ordering

-

impl PartialOrd<Int> for Int

fn partial_cmp(&self, other: &Int) -> Option<Ordering>

-

fn lt(&self, other: &Rhs) -> bool1.0.0

-

fn le(&self, other: &Rhs) -> bool1.0.0

-

fn gt(&self, other: &Rhs) -> bool1.0.0

-

fn ge(&self, other: &Rhs) -> bool1.0.0

-

impl PartialOrd<Limb> for Int

fn partial_cmp(&self, other: &Limb) -> Option<Ordering>

-

fn lt(&self, other: &Rhs) -> bool1.0.0

-

fn le(&self, other: &Rhs) -> bool1.0.0

-

fn gt(&self, other: &Rhs) -> bool1.0.0

-

fn ge(&self, other: &Rhs) -> bool1.0.0

-

impl Hash for Int

fn hash<H>(&self, state: &mut H) where H: Hasher

-

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher1.3.0

-

impl AddAssign<Limb> for Int

fn add_assign(&mut self, other: Limb)

-

impl Add<Limb> for Int

type Output = Int

+

impl Default for Int
[src]

+

fn default() -> Int

+

impl Drop for Int
[src]

+

fn drop(&mut self)

+

impl PartialEq<Int> for Int
[src]

+

fn eq(&self, other: &Int) -> bool

+

fn ne(&self, other: &Rhs) -> bool
1.0.0

+

impl PartialEq<Limb> for Int
[src]

+

fn eq(&self, other: &Limb) -> bool

+

fn ne(&self, other: &Rhs) -> bool
1.0.0

+

impl Eq for Int
[src]

+

impl Ord for Int
[src]

+

fn cmp(&self, other: &Int) -> Ordering

+

impl PartialOrd<Int> for Int
[src]

+

fn partial_cmp(&self, other: &Int) -> Option<Ordering>

+

fn lt(&self, other: &Rhs) -> bool
1.0.0

+

fn le(&self, other: &Rhs) -> bool
1.0.0

+

fn gt(&self, other: &Rhs) -> bool
1.0.0

+

fn ge(&self, other: &Rhs) -> bool
1.0.0

+

impl PartialOrd<Limb> for Int
[src]

+

fn partial_cmp(&self, other: &Limb) -> Option<Ordering>

+

fn lt(&self, other: &Rhs) -> bool
1.0.0

+

fn le(&self, other: &Rhs) -> bool
1.0.0

+

fn gt(&self, other: &Rhs) -> bool
1.0.0

+

fn ge(&self, other: &Rhs) -> bool
1.0.0

+

impl Hash for Int
[src]

+

fn hash<H>(&self, state: &mut H) where H: Hasher

+

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher
1.3.0

+

impl AddAssign<Limb> for Int
[src]

+

fn add_assign(&mut self, other: Limb)

+

impl Add<Limb> for Int
[src]

+

type Output = Int

fn add(self, other: Limb) -> Int

-

impl<'a> AddAssign<&'a Int> for Int

fn add_assign(&mut self, other: &'a Int)

-

impl<'a> Add<&'a Int> for Int

type Output = Int

+

impl<'a> AddAssign<&'a Int> for Int
[src]

+

fn add_assign(&mut self, other: &'a Int)

+

impl<'a> Add<&'a Int> for Int
[src]

+

type Output = Int

fn add(self, other: &'a Int) -> Int

-

impl<'a> Add<Int> for &'a Int

type Output = Int

+

impl<'a> Add<Int> for &'a Int
[src]

+

type Output = Int

fn add(self, other: Int) -> Int

-

impl Add<Int> for Int

type Output = Int

+

impl Add<Int> for Int
[src]

+

type Output = Int

fn add(self, other: Int) -> Int

-

impl AddAssign<Int> for Int

fn add_assign(&mut self, other: Int)

-

impl<'a, 'b> Add<&'a Int> for &'b Int

type Output = Int

+

impl AddAssign<Int> for Int
[src]

+

fn add_assign(&mut self, other: Int)

+

impl<'a, 'b> Add<&'a Int> for &'b Int
[src]

+

type Output = Int

fn add(self, other: &'a Int) -> Int

-

impl SubAssign<Limb> for Int

fn sub_assign(&mut self, other: Limb)

-

impl Sub<Limb> for Int

type Output = Int

+

impl SubAssign<Limb> for Int
[src]

+

fn sub_assign(&mut self, other: Limb)

+

impl Sub<Limb> for Int
[src]

+

type Output = Int

fn sub(self, other: Limb) -> Int

-

impl<'a> SubAssign<&'a Int> for Int

fn sub_assign(&mut self, other: &'a Int)

-

impl<'a> Sub<&'a Int> for Int

type Output = Int

+

impl<'a> SubAssign<&'a Int> for Int
[src]

+

fn sub_assign(&mut self, other: &'a Int)

+

impl<'a> Sub<&'a Int> for Int
[src]

+

type Output = Int

fn sub(self, other: &'a Int) -> Int

-

impl<'a> Sub<Int> for &'a Int

type Output = Int

+

impl<'a> Sub<Int> for &'a Int
[src]

+

type Output = Int

fn sub(self, other: Int) -> Int

-

impl Sub<Int> for Int

type Output = Int

+

impl Sub<Int> for Int
[src]

+

type Output = Int

fn sub(self, other: Int) -> Int

-

impl SubAssign<Int> for Int

fn sub_assign(&mut self, other: Int)

-

impl<'a, 'b> Sub<&'a Int> for &'b Int

type Output = Int

+

impl SubAssign<Int> for Int
[src]

+

fn sub_assign(&mut self, other: Int)

+

impl<'a, 'b> Sub<&'a Int> for &'b Int
[src]

+

type Output = Int

fn sub(self, other: &'a Int) -> Int

-

impl MulAssign<Limb> for Int

fn mul_assign(&mut self, other: Limb)

-

impl Mul<Limb> for Int

type Output = Int

+

impl MulAssign<Limb> for Int
[src]

+

fn mul_assign(&mut self, other: Limb)

+

impl Mul<Limb> for Int
[src]

+

type Output = Int

fn mul(self, other: Limb) -> Int

-

impl<'a, 'b> Mul<&'a Int> for &'b Int

type Output = Int

+

impl<'a, 'b> Mul<&'a Int> for &'b Int
[src]

+

type Output = Int

fn mul(self, other: &'a Int) -> Int

-

impl<'a> Mul<&'a Int> for Int

type Output = Int

+

impl<'a> Mul<&'a Int> for Int
[src]

+

type Output = Int

fn mul(self, other: &'a Int) -> Int

-

impl<'a> Mul<Int> for &'a Int

type Output = Int

+

impl<'a> Mul<Int> for &'a Int
[src]

+

type Output = Int

fn mul(self, other: Int) -> Int

-

impl Mul<Int> for Int

type Output = Int

+

impl Mul<Int> for Int
[src]

+

type Output = Int

fn mul(self, other: Int) -> Int

-

impl<'a> MulAssign<&'a Int> for Int

fn mul_assign(&mut self, other: &'a Int)

-

impl MulAssign<Int> for Int

fn mul_assign(&mut self, other: Int)

-

impl DivAssign<Limb> for Int

fn div_assign(&mut self, other: Limb)

-

impl Div<Limb> for Int

type Output = Int

+

impl<'a> MulAssign<&'a Int> for Int
[src]

+

fn mul_assign(&mut self, other: &'a Int)

+

impl MulAssign<Int> for Int
[src]

+

fn mul_assign(&mut self, other: Int)

+

impl DivAssign<Limb> for Int
[src]

+

fn div_assign(&mut self, other: Limb)

+

impl Div<Limb> for Int
[src]

+

type Output = Int

fn div(self, other: Limb) -> Int

-

impl<'a, 'b> Div<&'a Int> for &'b Int

type Output = Int

+

impl<'a, 'b> Div<&'a Int> for &'b Int
[src]

+

type Output = Int

fn div(self, other: &'a Int) -> Int

-

impl<'a> Div<&'a Int> for Int

type Output = Int

+

impl<'a> Div<&'a Int> for Int
[src]

+

type Output = Int

fn div(self, other: &'a Int) -> Int

-

impl<'a> Div<Int> for &'a Int

type Output = Int

+

impl<'a> Div<Int> for &'a Int
[src]

+

type Output = Int

fn div(self, other: Int) -> Int

-

impl Div<Int> for Int

type Output = Int

+

impl Div<Int> for Int
[src]

+

type Output = Int

fn div(self, other: Int) -> Int

-

impl<'a> DivAssign<&'a Int> for Int

fn div_assign(&mut self, other: &'a Int)

-

impl DivAssign<Int> for Int

fn div_assign(&mut self, other: Int)

-

impl Rem<Limb> for Int

type Output = Int

+

impl<'a> DivAssign<&'a Int> for Int
[src]

+

fn div_assign(&mut self, other: &'a Int)

+

impl DivAssign<Int> for Int
[src]

+

fn div_assign(&mut self, other: Int)

+

impl Rem<Limb> for Int
[src]

+

type Output = Int

fn rem(self, other: Limb) -> Int

-

impl RemAssign<Limb> for Int

fn rem_assign(&mut self, other: Limb)

-

impl<'a, 'b> Rem<&'a Int> for &'b Int

type Output = Int

+

impl RemAssign<Limb> for Int
[src]

+

fn rem_assign(&mut self, other: Limb)

+

impl<'a, 'b> Rem<&'a Int> for &'b Int
[src]

+

type Output = Int

fn rem(self, other: &'a Int) -> Int

-

impl<'a> Rem<&'a Int> for Int

type Output = Int

+

impl<'a> Rem<&'a Int> for Int
[src]

+

type Output = Int

fn rem(self, other: &'a Int) -> Int

-

impl<'a> Rem<Int> for &'a Int

type Output = Int

+

impl<'a> Rem<Int> for &'a Int
[src]

+

type Output = Int

fn rem(self, other: Int) -> Int

-

impl Rem<Int> for Int

type Output = Int

+

impl Rem<Int> for Int
[src]

+

type Output = Int

fn rem(self, other: Int) -> Int

-

impl RemAssign<Int> for Int

fn rem_assign(&mut self, other: Int)

-

impl<'a> RemAssign<&'a Int> for Int

fn rem_assign(&mut self, other: &'a Int)

-

impl Neg for Int

type Output = Int

+

impl RemAssign<Int> for Int
[src]

+

fn rem_assign(&mut self, other: Int)

+

impl<'a> RemAssign<&'a Int> for Int
[src]

+

fn rem_assign(&mut self, other: &'a Int)

+

impl Neg for Int
[src]

+

type Output = Int

fn neg(self) -> Int

-

impl<'a> Neg for &'a Int

type Output = Int

+

impl<'a> Neg for &'a Int
[src]

+

type Output = Int

fn neg(self) -> Int

-

impl ShlAssign<usize> for Int

fn shl_assign(&mut self, cnt: usize)

-

impl<'a> Shl<usize> for &'a Int

type Output = Int

+

impl ShlAssign<usize> for Int
[src]

+

fn shl_assign(&mut self, cnt: usize)

+

impl<'a> Shl<usize> for &'a Int
[src]

+

type Output = Int

fn shl(self, cnt: usize) -> Int

-

impl Shl<usize> for Int

type Output = Int

+

impl Shl<usize> for Int
[src]

+

type Output = Int

fn shl(self, other: usize) -> Int

-

impl ShrAssign<usize> for Int

fn shr_assign(&mut self, cnt: usize)

-

impl<'a> Shr<usize> for &'a Int

type Output = Int

+

impl ShrAssign<usize> for Int
[src]

+

fn shr_assign(&mut self, cnt: usize)

+

impl<'a> Shr<usize> for &'a Int
[src]

+

type Output = Int

fn shr(self, other: usize) -> Int

-

impl Shr<usize> for Int

type Output = Int

+

impl Shr<usize> for Int
[src]

+

type Output = Int

fn shr(self, other: usize) -> Int

-

impl<'a> BitAnd<Limb> for Int

type Output = Int

+

impl<'a> BitAnd<Limb> for Int
[src]

+

type Output = Int

fn bitand(self, other: Limb) -> Int

-

impl BitAndAssign<Limb> for Int

fn bitand_assign(&mut self, other: Limb)

-

impl<'a> BitAnd<&'a Int> for Int

type Output = Int

+

impl BitAndAssign<Limb> for Int
[src]

+

fn bitand_assign(&mut self, other: Limb)

+

impl<'a> BitAnd<&'a Int> for Int
[src]

+

type Output = Int

fn bitand(self, other: &'a Int) -> Int

-

impl<'a> BitAnd<Int> for &'a Int

type Output = Int

+

impl<'a> BitAnd<Int> for &'a Int
[src]

+

type Output = Int

fn bitand(self, other: Int) -> Int

-

impl<'a, 'b> BitAnd<&'a Int> for &'b Int

type Output = Int

+

impl<'a, 'b> BitAnd<&'a Int> for &'b Int
[src]

+

type Output = Int

fn bitand(self, other: &'a Int) -> Int

-

impl BitAnd<Int> for Int

type Output = Int

+

impl BitAnd<Int> for Int
[src]

+

type Output = Int

fn bitand(self, other: Int) -> Int

-

impl BitAndAssign<Int> for Int

fn bitand_assign(&mut self, other: Int)

-

impl<'a> BitAndAssign<&'a Int> for Int

fn bitand_assign(&mut self, other: &'a Int)

-

impl BitOr<Limb> for Int

type Output = Int

+

impl BitAndAssign<Int> for Int
[src]

+

fn bitand_assign(&mut self, other: Int)

+

impl<'a> BitAndAssign<&'a Int> for Int
[src]

+

fn bitand_assign(&mut self, other: &'a Int)

+

impl BitOr<Limb> for Int
[src]

+

type Output = Int

fn bitor(self, other: Limb) -> Int

-

impl BitOrAssign<Limb> for Int

fn bitor_assign(&mut self, other: Limb)

-

impl<'a> BitOr<&'a Int> for Int

type Output = Int

+

impl BitOrAssign<Limb> for Int
[src]

+

fn bitor_assign(&mut self, other: Limb)

+

impl<'a> BitOr<&'a Int> for Int
[src]

+

type Output = Int

fn bitor(self, other: &'a Int) -> Int

-

impl<'a> BitOr<Int> for &'a Int

type Output = Int

+

impl<'a> BitOr<Int> for &'a Int
[src]

+

type Output = Int

fn bitor(self, other: Int) -> Int

-

impl<'a, 'b> BitOr<&'a Int> for &'b Int

type Output = Int

+

impl<'a, 'b> BitOr<&'a Int> for &'b Int
[src]

+

type Output = Int

fn bitor(self, other: &'a Int) -> Int

-

impl BitOr<Int> for Int

type Output = Int

+

impl BitOr<Int> for Int
[src]

+

type Output = Int

fn bitor(self, other: Int) -> Int

-

impl BitOrAssign<Int> for Int

fn bitor_assign(&mut self, other: Int)

-

impl<'a> BitOrAssign<&'a Int> for Int

fn bitor_assign(&mut self, other: &'a Int)

-

impl<'a> BitXor<Limb> for Int

type Output = Int

+

impl BitOrAssign<Int> for Int
[src]

+

fn bitor_assign(&mut self, other: Int)

+

impl<'a> BitOrAssign<&'a Int> for Int
[src]

+

fn bitor_assign(&mut self, other: &'a Int)

+

impl<'a> BitXor<Limb> for Int
[src]

+

type Output = Int

fn bitxor(self, other: Limb) -> Int

-

impl BitXorAssign<Limb> for Int

fn bitxor_assign(&mut self, other: Limb)

-

impl<'a> BitXor<&'a Int> for Int

type Output = Int

+

impl BitXorAssign<Limb> for Int
[src]

+

fn bitxor_assign(&mut self, other: Limb)

+

impl<'a> BitXor<&'a Int> for Int
[src]

+

type Output = Int

fn bitxor(self, other: &'a Int) -> Int

-

impl<'a> BitXor<Int> for &'a Int

type Output = Int

+

impl<'a> BitXor<Int> for &'a Int
[src]

+

type Output = Int

fn bitxor(self, other: Int) -> Int

-

impl<'a, 'b> BitXor<&'a Int> for &'b Int

type Output = Int

+

impl<'a, 'b> BitXor<&'a Int> for &'b Int
[src]

+

type Output = Int

fn bitxor(self, other: &'a Int) -> Int

-

impl BitXor<Int> for Int

type Output = Int

+

impl BitXor<Int> for Int
[src]

+

type Output = Int

fn bitxor(self, other: Int) -> Int

-

impl BitXorAssign<Int> for Int

fn bitxor_assign(&mut self, other: Int)

-

impl<'a> BitXorAssign<&'a Int> for Int

fn bitxor_assign(&mut self, other: &'a Int)

-

impl Add<i32> for Int

type Output = Int

+

impl BitXorAssign<Int> for Int
[src]

+

fn bitxor_assign(&mut self, other: Int)

+

impl<'a> BitXorAssign<&'a Int> for Int
[src]

+

fn bitxor_assign(&mut self, other: &'a Int)

+

impl Add<i32> for Int
[src]

+

type Output = Int

fn add(self, other: i32) -> Int

-

impl AddAssign<i32> for Int

fn add_assign(&mut self, other: i32)

-

impl Sub<i32> for Int

type Output = Int

+

impl AddAssign<i32> for Int
[src]

+

fn add_assign(&mut self, other: i32)

+

impl Sub<i32> for Int
[src]

+

type Output = Int

fn sub(self, other: i32) -> Int

-

impl SubAssign<i32> for Int

fn sub_assign(&mut self, other: i32)

-

impl Mul<i32> for Int

type Output = Int

+

impl SubAssign<i32> for Int
[src]

+

fn sub_assign(&mut self, other: i32)

+

impl Mul<i32> for Int
[src]

+

type Output = Int

fn mul(self, other: i32) -> Int

-

impl MulAssign<i32> for Int

fn mul_assign(&mut self, other: i32)

-

impl DivAssign<i32> for Int

fn div_assign(&mut self, other: i32)

-

impl Div<i32> for Int

type Output = Int

+

impl MulAssign<i32> for Int
[src]

+

fn mul_assign(&mut self, other: i32)

+

impl DivAssign<i32> for Int
[src]

+

fn div_assign(&mut self, other: i32)

+

impl Div<i32> for Int
[src]

+

type Output = Int

fn div(self, other: i32) -> Int

-

impl RemAssign<i32> for Int

fn rem_assign(&mut self, other: i32)

-

impl Rem<i32> for Int

type Output = Int

+

impl RemAssign<i32> for Int
[src]

+

fn rem_assign(&mut self, other: i32)

+

impl Rem<i32> for Int
[src]

+

type Output = Int

fn rem(self, other: i32) -> Int

-

impl BitAndAssign<i32> for Int

fn bitand_assign(&mut self, other: i32)

-

impl BitOrAssign<i32> for Int

fn bitor_assign(&mut self, other: i32)

-

impl BitXorAssign<i32> for Int

fn bitxor_assign(&mut self, other: i32)

-

impl<'a> Add<i32> for &'a Int

type Output = Int

+

impl BitAndAssign<i32> for Int
[src]

+

fn bitand_assign(&mut self, other: i32)

+

impl BitOrAssign<i32> for Int
[src]

+

fn bitor_assign(&mut self, other: i32)

+

impl BitXorAssign<i32> for Int
[src]

+

fn bitxor_assign(&mut self, other: i32)

+

impl<'a> Add<i32> for &'a Int
[src]

+

type Output = Int

fn add(self, other: i32) -> Int

-

impl<'a> Sub<i32> for &'a Int

type Output = Int

+

impl<'a> Sub<i32> for &'a Int
[src]

+

type Output = Int

fn sub(self, other: i32) -> Int

-

impl<'a> Mul<i32> for &'a Int

type Output = Int

+

impl<'a> Mul<i32> for &'a Int
[src]

+

type Output = Int

fn mul(self, other: i32) -> Int

-

impl<'a> Div<i32> for &'a Int

type Output = Int

+

impl<'a> Div<i32> for &'a Int
[src]

+

type Output = Int

fn div(self, other: i32) -> Int

-

impl<'a> Rem<i32> for &'a Int

type Output = Int

+

impl<'a> Rem<i32> for &'a Int
[src]

+

type Output = Int

fn rem(self, other: i32) -> Int

-

impl BitAnd<i32> for Int

type Output = Int

+

impl BitAnd<i32> for Int
[src]

+

type Output = Int

fn bitand(self, other: i32) -> Int

-

impl<'a> BitAnd<i32> for &'a Int

type Output = Int

+

impl<'a> BitAnd<i32> for &'a Int
[src]

+

type Output = Int

fn bitand(self, other: i32) -> Int

-

impl BitOr<i32> for Int

type Output = Int

+

impl BitOr<i32> for Int
[src]

+

type Output = Int

fn bitor(self, other: i32) -> Int

-

impl<'a> BitOr<i32> for &'a Int

type Output = Int

+

impl<'a> BitOr<i32> for &'a Int
[src]

+

type Output = Int

fn bitor(self, other: i32) -> Int

-

impl BitXor<i32> for Int

type Output = Int

+

impl BitXor<i32> for Int
[src]

+

type Output = Int

fn bitxor(self, other: i32) -> Int

-

impl<'a> BitXor<i32> for &'a Int

type Output = Int

+

impl<'a> BitXor<i32> for &'a Int
[src]

+

type Output = Int

fn bitxor(self, other: i32) -> Int

-

impl Add<usize> for Int

type Output = Int

+

impl Add<usize> for Int
[src]

+

type Output = Int

fn add(self, other: usize) -> Int

-

impl AddAssign<usize> for Int

fn add_assign(&mut self, other: usize)

-

impl Sub<usize> for Int

type Output = Int

+

impl AddAssign<usize> for Int
[src]

+

fn add_assign(&mut self, other: usize)

+

impl Sub<usize> for Int
[src]

+

type Output = Int

fn sub(self, other: usize) -> Int

-

impl SubAssign<usize> for Int

fn sub_assign(&mut self, other: usize)

-

impl Mul<usize> for Int

type Output = Int

+

impl SubAssign<usize> for Int
[src]

+

fn sub_assign(&mut self, other: usize)

+

impl Mul<usize> for Int
[src]

+

type Output = Int

fn mul(self, other: usize) -> Int

-

impl MulAssign<usize> for Int

fn mul_assign(&mut self, other: usize)

-

impl Div<usize> for Int

type Output = Int

+

impl MulAssign<usize> for Int
[src]

+

fn mul_assign(&mut self, other: usize)

+

impl Div<usize> for Int
[src]

+

type Output = Int

fn div(self, other: usize) -> Int

-

impl DivAssign<usize> for Int

fn div_assign(&mut self, other: usize)

-

impl Rem<usize> for Int

type Output = Int

+

impl DivAssign<usize> for Int
[src]

+

fn div_assign(&mut self, other: usize)

+

impl Rem<usize> for Int
[src]

+

type Output = Int

fn rem(self, other: usize) -> Int

-

impl RemAssign<usize> for Int

fn rem_assign(&mut self, other: usize)

-

impl BitAndAssign<usize> for Int

fn bitand_assign(&mut self, other: usize)

-

impl BitOrAssign<usize> for Int

fn bitor_assign(&mut self, other: usize)

-

impl BitXorAssign<usize> for Int

fn bitxor_assign(&mut self, other: usize)

-

impl<'a> Add<usize> for &'a Int

type Output = Int

+

impl RemAssign<usize> for Int
[src]

+

fn rem_assign(&mut self, other: usize)

+

impl BitAndAssign<usize> for Int
[src]

+

fn bitand_assign(&mut self, other: usize)

+

impl BitOrAssign<usize> for Int
[src]

+

fn bitor_assign(&mut self, other: usize)

+

impl BitXorAssign<usize> for Int
[src]

+

fn bitxor_assign(&mut self, other: usize)

+

impl<'a> Add<usize> for &'a Int
[src]

+

type Output = Int

fn add(self, other: usize) -> Int

-

impl<'a> Sub<usize> for &'a Int

type Output = Int

+

impl<'a> Sub<usize> for &'a Int
[src]

+

type Output = Int

fn sub(self, other: usize) -> Int

-

impl<'a> Mul<usize> for &'a Int

type Output = Int

+

impl<'a> Mul<usize> for &'a Int
[src]

+

type Output = Int

fn mul(self, other: usize) -> Int

-

impl<'a> Div<usize> for &'a Int

type Output = Int

+

impl<'a> Div<usize> for &'a Int
[src]

+

type Output = Int

fn div(self, other: usize) -> Int

-

impl<'a> Rem<usize> for &'a Int

type Output = Int

+

impl<'a> Rem<usize> for &'a Int
[src]

+

type Output = Int

fn rem(self, other: usize) -> Int

-

impl BitAnd<usize> for Int

type Output = Int

+

impl BitAnd<usize> for Int
[src]

+

type Output = Int

fn bitand(self, other: usize) -> Int

-

impl<'a> BitAnd<usize> for &'a Int

type Output = Int

+

impl<'a> BitAnd<usize> for &'a Int
[src]

+

type Output = Int

fn bitand(self, other: usize) -> Int

-

impl BitOr<usize> for Int

type Output = Int

+

impl BitOr<usize> for Int
[src]

+

type Output = Int

fn bitor(self, other: usize) -> Int

-

impl<'a> BitOr<usize> for &'a Int

type Output = Int

+

impl<'a> BitOr<usize> for &'a Int
[src]

+

type Output = Int

fn bitor(self, other: usize) -> Int

-

impl BitXor<usize> for Int

type Output = Int

+

impl BitXor<usize> for Int
[src]

+

type Output = Int

fn bitxor(self, other: usize) -> Int

-

impl<'a> BitXor<usize> for &'a Int

type Output = Int

+

impl<'a> BitXor<usize> for &'a Int
[src]

+

type Output = Int

fn bitxor(self, other: usize) -> Int

-

impl Add<BaseInt> for Int

type Output = Int

+

impl Add<BaseInt> for Int
[src]

+

type Output = Int

fn add(self, other: BaseInt) -> Int

-

impl AddAssign<BaseInt> for Int

fn add_assign(&mut self, other: BaseInt)

-

impl Sub<BaseInt> for Int

type Output = Int

+

impl AddAssign<BaseInt> for Int
[src]

+

fn add_assign(&mut self, other: BaseInt)

+

impl Sub<BaseInt> for Int
[src]

+

type Output = Int

fn sub(self, other: BaseInt) -> Int

-

impl SubAssign<BaseInt> for Int

fn sub_assign(&mut self, other: BaseInt)

-

impl Mul<BaseInt> for Int

type Output = Int

+

impl SubAssign<BaseInt> for Int
[src]

+

fn sub_assign(&mut self, other: BaseInt)

+

impl Mul<BaseInt> for Int
[src]

+

type Output = Int

fn mul(self, other: BaseInt) -> Int

-

impl MulAssign<BaseInt> for Int

fn mul_assign(&mut self, other: BaseInt)

-

impl Div<BaseInt> for Int

type Output = Int

+

impl MulAssign<BaseInt> for Int
[src]

+

fn mul_assign(&mut self, other: BaseInt)

+

impl Div<BaseInt> for Int
[src]

+

type Output = Int

fn div(self, other: BaseInt) -> Int

-

impl DivAssign<BaseInt> for Int

fn div_assign(&mut self, other: BaseInt)

-

impl Rem<BaseInt> for Int

type Output = Int

+

impl DivAssign<BaseInt> for Int
[src]

+

fn div_assign(&mut self, other: BaseInt)

+

impl Rem<BaseInt> for Int
[src]

+

type Output = Int

fn rem(self, other: BaseInt) -> Int

-

impl RemAssign<BaseInt> for Int

fn rem_assign(&mut self, other: BaseInt)

-

impl BitAndAssign<BaseInt> for Int

fn bitand_assign(&mut self, other: BaseInt)

-

impl BitOrAssign<BaseInt> for Int

fn bitor_assign(&mut self, other: BaseInt)

-

impl BitXorAssign<BaseInt> for Int

fn bitxor_assign(&mut self, other: BaseInt)

-

impl<'a> Add<BaseInt> for &'a Int

type Output = Int

+

impl RemAssign<BaseInt> for Int
[src]

+

fn rem_assign(&mut self, other: BaseInt)

+

impl BitAndAssign<BaseInt> for Int
[src]

+

fn bitand_assign(&mut self, other: BaseInt)

+

impl BitOrAssign<BaseInt> for Int
[src]

+

fn bitor_assign(&mut self, other: BaseInt)

+

impl BitXorAssign<BaseInt> for Int
[src]

+

fn bitxor_assign(&mut self, other: BaseInt)

+

impl<'a> Add<BaseInt> for &'a Int
[src]

+

type Output = Int

fn add(self, other: BaseInt) -> Int

-

impl<'a> Sub<BaseInt> for &'a Int

type Output = Int

+

impl<'a> Sub<BaseInt> for &'a Int
[src]

+

type Output = Int

fn sub(self, other: BaseInt) -> Int

-

impl<'a> Mul<BaseInt> for &'a Int

type Output = Int

+

impl<'a> Mul<BaseInt> for &'a Int
[src]

+

type Output = Int

fn mul(self, other: BaseInt) -> Int

-

impl<'a> Div<BaseInt> for &'a Int

type Output = Int

+

impl<'a> Div<BaseInt> for &'a Int
[src]

+

type Output = Int

fn div(self, other: BaseInt) -> Int

-

impl<'a> Rem<BaseInt> for &'a Int

type Output = Int

+

impl<'a> Rem<BaseInt> for &'a Int
[src]

+

type Output = Int

fn rem(self, other: BaseInt) -> Int

-

impl BitAnd<BaseInt> for Int

type Output = Int

+

impl BitAnd<BaseInt> for Int
[src]

+

type Output = Int

fn bitand(self, other: BaseInt) -> Int

-

impl<'a> BitAnd<BaseInt> for &'a Int

type Output = Int

+

impl<'a> BitAnd<BaseInt> for &'a Int
[src]

+

type Output = Int

fn bitand(self, other: BaseInt) -> Int

-

impl BitOr<BaseInt> for Int

type Output = Int

+

impl BitOr<BaseInt> for Int
[src]

+

type Output = Int

fn bitor(self, other: BaseInt) -> Int

-

impl<'a> BitOr<BaseInt> for &'a Int

type Output = Int

+

impl<'a> BitOr<BaseInt> for &'a Int
[src]

+

type Output = Int

fn bitor(self, other: BaseInt) -> Int

-

impl BitXor<BaseInt> for Int

type Output = Int

+

impl BitXor<BaseInt> for Int
[src]

+

type Output = Int

fn bitxor(self, other: BaseInt) -> Int

-

impl<'a> BitXor<BaseInt> for &'a Int

type Output = Int

+

impl<'a> BitXor<BaseInt> for &'a Int
[src]

+

type Output = Int

fn bitxor(self, other: BaseInt) -> Int

-

impl PartialEq<i32> for Int

fn eq(&self, other: &i32) -> bool

-

fn ne(&self, other: &Rhs) -> bool1.0.0

-

impl PartialOrd<i32> for Int

fn partial_cmp(&self, other: &i32) -> Option<Ordering>

-

fn lt(&self, other: &Rhs) -> bool1.0.0

-

fn le(&self, other: &Rhs) -> bool1.0.0

-

fn gt(&self, other: &Rhs) -> bool1.0.0

-

fn ge(&self, other: &Rhs) -> bool1.0.0

-

impl PartialEq<usize> for Int

fn eq(&self, other: &usize) -> bool

-

fn ne(&self, other: &Rhs) -> bool1.0.0

-

impl PartialOrd<usize> for Int

fn partial_cmp(&self, other: &usize) -> Option<Ordering>

-

fn lt(&self, other: &Rhs) -> bool1.0.0

-

fn le(&self, other: &Rhs) -> bool1.0.0

-

fn gt(&self, other: &Rhs) -> bool1.0.0

-

fn ge(&self, other: &Rhs) -> bool1.0.0

-

impl PartialEq<u64> for Int

fn eq(&self, other: &u64) -> bool

-

fn ne(&self, other: &Rhs) -> bool1.0.0

-

impl PartialOrd<u64> for Int

fn partial_cmp(&self, other: &u64) -> Option<Ordering>

-

fn lt(&self, other: &Rhs) -> bool1.0.0

-

fn le(&self, other: &Rhs) -> bool1.0.0

-

fn gt(&self, other: &Rhs) -> bool1.0.0

-

fn ge(&self, other: &Rhs) -> bool1.0.0

-

impl PartialEq<i64> for Int

fn eq(&self, other: &i64) -> bool

-

fn ne(&self, other: &Rhs) -> bool1.0.0

-

impl PartialOrd<i64> for Int

fn partial_cmp(&self, other: &i64) -> Option<Ordering>

-

fn lt(&self, other: &Rhs) -> bool1.0.0

-

fn le(&self, other: &Rhs) -> bool1.0.0

-

fn gt(&self, other: &Rhs) -> bool1.0.0

-

fn ge(&self, other: &Rhs) -> bool1.0.0

-

impl From<i8> for Int

fn from(val: i8) -> Int

-

impl From<i16> for Int

fn from(val: i16) -> Int

-

impl From<i32> for Int

fn from(val: i32) -> Int

-

impl From<i64> for Int

fn from(val: i64) -> Int

-

impl From<isize> for Int

fn from(val: isize) -> Int

-

impl From<u8> for Int

fn from(val: u8) -> Int

-

impl From<u16> for Int

fn from(val: u16) -> Int

-

impl From<u32> for Int

fn from(val: u32) -> Int

-

impl From<u64> for Int

fn from(val: u64) -> Int

-

impl From<usize> for Int

fn from(val: usize) -> Int

-

impl Binary for Int

fn fmt(&self, f: &mut Formatter) -> Result

-

impl Octal for Int

fn fmt(&self, f: &mut Formatter) -> Result

-

impl Display for Int

fn fmt(&self, f: &mut Formatter) -> Result

-

impl Debug for Int

fn fmt(&self, f: &mut Formatter) -> Result

-

impl LowerHex for Int

fn fmt(&self, f: &mut Formatter) -> Result

-

impl UpperHex for Int

fn fmt(&self, f: &mut Formatter) -> Result

-

impl FromStr for Int

type Err = ParseIntError

+

impl PartialEq<i32> for Int
[src]

+

fn eq(&self, other: &i32) -> bool

+

fn ne(&self, other: &Rhs) -> bool
1.0.0

+

impl PartialOrd<i32> for Int
[src]

+

fn partial_cmp(&self, other: &i32) -> Option<Ordering>

+

fn lt(&self, other: &Rhs) -> bool
1.0.0

+

fn le(&self, other: &Rhs) -> bool
1.0.0

+

fn gt(&self, other: &Rhs) -> bool
1.0.0

+

fn ge(&self, other: &Rhs) -> bool
1.0.0

+

impl PartialEq<usize> for Int
[src]

+

fn eq(&self, other: &usize) -> bool

+

fn ne(&self, other: &Rhs) -> bool
1.0.0

+

impl PartialOrd<usize> for Int
[src]

+

fn partial_cmp(&self, other: &usize) -> Option<Ordering>

+

fn lt(&self, other: &Rhs) -> bool
1.0.0

+

fn le(&self, other: &Rhs) -> bool
1.0.0

+

fn gt(&self, other: &Rhs) -> bool
1.0.0

+

fn ge(&self, other: &Rhs) -> bool
1.0.0

+

impl PartialEq<u64> for Int
[src]

+

fn eq(&self, other: &u64) -> bool

+

fn ne(&self, other: &Rhs) -> bool
1.0.0

+

impl PartialOrd<u64> for Int
[src]

+

fn partial_cmp(&self, other: &u64) -> Option<Ordering>

+

fn lt(&self, other: &Rhs) -> bool
1.0.0

+

fn le(&self, other: &Rhs) -> bool
1.0.0

+

fn gt(&self, other: &Rhs) -> bool
1.0.0

+

fn ge(&self, other: &Rhs) -> bool
1.0.0

+

impl PartialEq<i64> for Int
[src]

+

fn eq(&self, other: &i64) -> bool

+

fn ne(&self, other: &Rhs) -> bool
1.0.0

+

impl PartialOrd<i64> for Int
[src]

+

fn partial_cmp(&self, other: &i64) -> Option<Ordering>

+

fn lt(&self, other: &Rhs) -> bool
1.0.0

+

fn le(&self, other: &Rhs) -> bool
1.0.0

+

fn gt(&self, other: &Rhs) -> bool
1.0.0

+

fn ge(&self, other: &Rhs) -> bool
1.0.0

+

impl From<i8> for Int
[src]

+

fn from(val: i8) -> Int

+

impl From<i16> for Int
[src]

+

fn from(val: i16) -> Int

+

impl From<i32> for Int
[src]

+

fn from(val: i32) -> Int

+

impl From<i64> for Int
[src]

+

fn from(val: i64) -> Int

+

impl From<isize> for Int
[src]

+

fn from(val: isize) -> Int

+

impl From<u8> for Int
[src]

+

fn from(val: u8) -> Int

+

impl From<u16> for Int
[src]

+

fn from(val: u16) -> Int

+

impl From<u32> for Int
[src]

+

fn from(val: u32) -> Int

+

impl From<u64> for Int
[src]

+

fn from(val: u64) -> Int

+

impl From<usize> for Int
[src]

+

fn from(val: usize) -> Int

+

impl Binary for Int
[src]

+

fn fmt(&self, f: &mut Formatter) -> Result

+

impl Octal for Int
[src]

+

fn fmt(&self, f: &mut Formatter) -> Result

+

impl Display for Int
[src]

+

fn fmt(&self, f: &mut Formatter) -> Result

+

impl Debug for Int
[src]

+

fn fmt(&self, f: &mut Formatter) -> Result

+

impl LowerHex for Int
[src]

+

fn fmt(&self, f: &mut Formatter) -> Result

+

impl UpperHex for Int
[src]

+

fn fmt(&self, f: &mut Formatter) -> Result

+

impl FromStr for Int
[src]

+

type Err = ParseIntError

fn from_str(src: &str) -> Result<Int, ParseIntError>

-

impl Zero for Int

fn zero() -> Int

-

impl One for Int

fn one() -> Int

-

impl Step for Int

fn step(&self, by: &Int) -> Option<Int>

+

impl Zero for Int
[src]

+

fn zero() -> Int

+

impl One for Int
[src]

+

fn one() -> Int

+

impl Step for Int
[src]

+

fn step(&self, by: &Int) -> Option<Int>

fn steps_between(start: &Int, end: &Int, by: &Int) -> Option<usize>

diff --git a/ramp/int/struct.ParseIntError.html b/ramp/int/struct.ParseIntError.html index 6c164c6..433f2a7 100644 --- a/ramp/int/struct.ParseIntError.html +++ b/ramp/int/struct.ParseIntError.html @@ -47,17 +47,22 @@ [−] - [src] + [src]
pub struct ParseIntError {
     // some fields omitted
-}

Trait Implementations

impl Error for ParseIntError

fn description<'a>(&'a self) -> &'a str

-

fn cause(&self) -> Option<&Error>1.0.0

-

impl Display for ParseIntError

fn fmt(&self, f: &mut Formatter) -> Result

-

Derived Implementations

impl PartialEq for ParseIntError

fn eq(&self, __arg_0: &ParseIntError) -> bool

+}

Trait Implementations

impl Error for ParseIntError
[src]

+

fn description<'a>(&'a self) -> &'a str

+

fn cause(&self) -> Option<&Error>
1.0.0

+

impl Display for ParseIntError
[src]

+

fn fmt(&self, f: &mut Formatter) -> Result

+

Derived Implementations

impl PartialEq for ParseIntError
[src]

+

fn eq(&self, __arg_0: &ParseIntError) -> bool

fn ne(&self, __arg_0: &ParseIntError) -> bool

-

impl Clone for ParseIntError

fn clone(&self) -> ParseIntError

-

fn clone_from(&mut self, source: &Self)1.0.0

-

impl Debug for ParseIntError

fn fmt(&self, __arg_0: &mut Formatter) -> Result

+

impl Clone for ParseIntError
[src]

+

fn clone(&self) -> ParseIntError

+

fn clone_from(&mut self, source: &Self)
1.0.0

+

impl Debug for ParseIntError
[src]

+

fn fmt(&self, __arg_0: &mut Formatter) -> Result

diff --git a/ramp/int/trait.RandomInt.html b/ramp/int/trait.RandomInt.html index 12880cb..ecce034 100644 --- a/ramp/int/trait.RandomInt.html +++ b/ramp/int/trait.RandomInt.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub trait RandomInt {
     fn gen_uint(&mut self, bits: usize) -> Int;
     fn gen_int(&mut self, bits: usize) -> Int;
@@ -81,7 +81,8 @@ Fails when the upper bound is not greater than the lower bound.

Implementors

    -
diff --git a/ramp/ll/base/fn.base_digits_to_len.html b/ramp/ll/base/fn.base_digits_to_len.html index dd905c4..03db3ec 100644 --- a/ramp/ll/base/fn.base_digits_to_len.html +++ b/ramp/ll/base/fn.base_digits_to_len.html @@ -47,7 +47,7 @@ [−] - [src] + [src]
pub fn base_digits_to_len(num: usize, base: u32) -> usize
diff --git a/ramp/ll/base/fn.from_base.html b/ramp/ll/base/fn.from_base.html index f19ddae..1900d62 100644 --- a/ramp/ll/base/fn.from_base.html +++ b/ramp/ll/base/fn.from_base.html @@ -47,7 +47,7 @@ [−] - [src] + [src]
pub unsafe fn from_base(out: LimbsMut, bp: *const u8, bs: i32, base: u32) -> usize

Converts the base base bytestring {bp, bs}, storing the limbs in out. out is assumed to have enough space to store the result.

diff --git a/ramp/ll/base/fn.num_base_digits.html b/ramp/ll/base/fn.num_base_digits.html index 2a5e9e0..39bf48e 100644 --- a/ramp/ll/base/fn.num_base_digits.html +++ b/ramp/ll/base/fn.num_base_digits.html @@ -47,7 +47,7 @@ [−] - [src] + [src]
pub unsafe fn num_base_digits(p: Limbs, n: i32, base: u32) -> usize
diff --git a/ramp/ll/base/fn.to_base.html b/ramp/ll/base/fn.to_base.html index a02b9d7..d590ccc 100644 --- a/ramp/ll/base/fn.to_base.html +++ b/ramp/ll/base/fn.to_base.html @@ -47,7 +47,7 @@ [−] - [src] + [src]
pub unsafe fn to_base<F: FnMut(u8)>(base: u32, np: Limbs, nn: i32, out_byte: F)

Converts nn limbs at np to the given base, storing the output in out. out is assumed to have enough space for the entire digit. The output is stored from most-significant digit to least.

diff --git a/ramp/ll/fn.cmp.html b/ramp/ll/fn.cmp.html index e5c7a01..ffda8c4 100644 --- a/ramp/ll/fn.cmp.html +++ b/ramp/ll/fn.cmp.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub unsafe fn cmp(xp: Limbs, yp: Limbs, n: i32) -> Ordering

Compares the n least-significant limbs of xp and yp, returning whether {xp, n} is less than, equal to or greater than {yp, n}

diff --git a/ramp/ll/fn.copy_decr.html b/ramp/ll/fn.copy_decr.html index ee2a491..3cb11fe 100644 --- a/ramp/ll/fn.copy_decr.html +++ b/ramp/ll/fn.copy_decr.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub unsafe fn copy_decr(src: Limbs, dst: LimbsMut, n: i32)

Copies the n limbs from src to dst in a decremental fashion.

diff --git a/ramp/ll/fn.copy_incr.html b/ramp/ll/fn.copy_incr.html index fd2cb2b..13a9968 100644 --- a/ramp/ll/fn.copy_incr.html +++ b/ramp/ll/fn.copy_incr.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub unsafe fn copy_incr(src: Limbs, dst: LimbsMut, n: i32)

Copies the n limbs from src to dst in an incremental fashion.

diff --git a/ramp/ll/fn.copy_rest.html b/ramp/ll/fn.copy_rest.html index 5849cbd..d2ddb5b 100644 --- a/ramp/ll/fn.copy_rest.html +++ b/ramp/ll/fn.copy_rest.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub unsafe fn copy_rest(src: Limbs, dst: LimbsMut, n: i32, start: i32)

Copies the n - start limbs from src + start to dst + start

diff --git a/ramp/ll/fn.divide_by_zero.html b/ramp/ll/fn.divide_by_zero.html index 848ee1a..4c59add 100644 --- a/ramp/ll/fn.divide_by_zero.html +++ b/ramp/ll/fn.divide_by_zero.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub fn divide_by_zero() -> !

Called when a divide by zero occurs.

If debug assertions are enabled, a message is printed and the diff --git a/ramp/ll/fn.is_zero.html b/ramp/ll/fn.is_zero.html index efc7af8..f1dbdc1 100644 --- a/ramp/ll/fn.is_zero.html +++ b/ramp/ll/fn.is_zero.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 

pub unsafe fn is_zero(np: Limbs, nn: i32) -> bool

Checks that all nn limbs in np are zero

diff --git a/ramp/ll/fn.normalize.html b/ramp/ll/fn.normalize.html index a96a6ef..d0ba46d 100644 --- a/ramp/ll/fn.normalize.html +++ b/ramp/ll/fn.normalize.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub unsafe fn normalize(p: Limbs, n: i32) -> i32

Returns the size of the integer pointed to by p such that the most significant limb is non-zero.

diff --git a/ramp/ll/fn.overlap.html b/ramp/ll/fn.overlap.html index fd3ddf7..44894c8 100644 --- a/ramp/ll/fn.overlap.html +++ b/ramp/ll/fn.overlap.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub unsafe fn overlap(xp: LimbsMut, xs: i32, yp: Limbs, ys: i32) -> bool
diff --git a/ramp/ll/fn.same_or_decr.html b/ramp/ll/fn.same_or_decr.html index 1bbcdd8..e759da0 100644 --- a/ramp/ll/fn.same_or_decr.html +++ b/ramp/ll/fn.same_or_decr.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub unsafe fn same_or_decr(xp: LimbsMut, xs: i32, yp: Limbs, ys: i32) -> bool
diff --git a/ramp/ll/fn.same_or_incr.html b/ramp/ll/fn.same_or_incr.html index 8a61f20..1bb9360 100644 --- a/ramp/ll/fn.same_or_incr.html +++ b/ramp/ll/fn.same_or_incr.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub unsafe fn same_or_incr(xp: LimbsMut, xs: i32, yp: Limbs, ys: i32) -> bool
diff --git a/ramp/ll/fn.same_or_separate.html b/ramp/ll/fn.same_or_separate.html index 0998b6f..1980ed5 100644 --- a/ramp/ll/fn.same_or_separate.html +++ b/ramp/ll/fn.same_or_separate.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub unsafe fn same_or_separate(xp: LimbsMut, xs: i32, yp: Limbs, ys: i32) -> bool
diff --git a/ramp/ll/fn.zero.html b/ramp/ll/fn.zero.html index bcd3172..5e1ef47 100644 --- a/ramp/ll/fn.zero.html +++ b/ramp/ll/fn.zero.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub unsafe fn zero(np: LimbsMut, nn: i32)
diff --git a/ramp/ll/limb/fn.add_2.html b/ramp/ll/limb/fn.add_2.html index 6f53ec7..63215e6 100644 --- a/ramp/ll/limb/fn.add_2.html +++ b/ramp/ll/limb/fn.add_2.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub fn add_2(ah: Limb, al: Limb, bh: Limb, bl: Limb) -> (Limb, Limb)

Performs the two-word addition (ah, al) + (bh, bl), ignoring any overflow.

diff --git a/ramp/ll/limb/fn.div.html b/ramp/ll/limb/fn.div.html index eafe5db..555d3cb 100644 --- a/ramp/ll/limb/fn.div.html +++ b/ramp/ll/limb/fn.div.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub fn div(nh: Limb, nl: Limb, d: Limb) -> (Limb, Limb)

Divides the two-limb numerator (nh, nl) by d, returning a single-limb quotient, Q, and remainder, R, as (Q, R).

diff --git a/ramp/ll/limb/fn.div_preinv.html b/ramp/ll/limb/fn.div_preinv.html index 5511c49..5ce1516 100644 --- a/ramp/ll/limb/fn.div_preinv.html +++ b/ramp/ll/limb/fn.div_preinv.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub fn div_preinv(nh: Limb, nl: Limb, d: Limb, dinv: Limb) -> (Limb, Limb)

Divides (nh, nl) by d using the inverted limb dinv. Returns the quotient, Q, and remainder, R, as (Q, R);

diff --git a/ramp/ll/limb/fn.sub_2.html b/ramp/ll/limb/fn.sub_2.html index 527b196..944904f 100644 --- a/ramp/ll/limb/fn.sub_2.html +++ b/ramp/ll/limb/fn.sub_2.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub fn sub_2(ah: Limb, al: Limb, bh: Limb, bl: Limb) -> (Limb, Limb)

Performs the two-word subtraction (ah, al) - (bh, bl), ignoring any borrow.

diff --git a/ramp/ll/limb/index.html b/ramp/ll/limb/index.html index 41f8a2c..49d1f0a 100644 --- a/ramp/ll/limb/index.html +++ b/ramp/ll/limb/index.html @@ -47,7 +47,7 @@ [−] - [src] + [src]

Structs

diff --git a/ramp/ll/limb/struct.Limb.html b/ramp/ll/limb/struct.Limb.html index f4078da..3256e6d 100644 --- a/ramp/ll/limb/struct.Limb.html +++ b/ramp/ll/limb/struct.Limb.html @@ -47,12 +47,13 @@ [−] - [src] + [src]
pub struct Limb(pub BaseInt);

Helper newtype for operations.

A "Limb" is a single digit in base 2word size.

-

Methods

impl Limb

const BITS: usize = 64

-

const B: Limb = Limb(1 << (Limb::BITS / 2))

+

Methods

impl Limb
[src]

+

const BITS: usize = 64

+

const B: Limb = Limb(1 << Limb::BITS / 2)

fn high_part(self) -> Limb

Returns the high half of the limb

fn low_part(self) -> Limb

@@ -77,73 +78,105 @@ to be d >= BASE/2.

Returns the number of leading zeros in the limb

fn trailing_zeros(self) -> BaseInt

Returns the number of trailing zeros in the limb

-

Trait Implementations

impl Clone for Limb

fn clone(&self) -> Limb

-

fn clone_from(&mut self, source: &Self)1.0.0

-

impl Add<Limb> for Limb

type Output = Limb

+

Trait Implementations

impl Clone for Limb
[src]

+

fn clone(&self) -> Limb

+

fn clone_from(&mut self, source: &Self)
1.0.0

+

impl Add<Limb> for Limb
[src]

+

type Output = Limb

fn add(self, other: Limb) -> Limb

-

impl Add<BaseInt> for Limb

type Output = Limb

+

impl Add<BaseInt> for Limb
[src]

+

type Output = Limb

fn add(self, other: BaseInt) -> Limb

-

impl Add<bool> for Limb

type Output = Limb

+

impl Add<bool> for Limb
[src]

+

type Output = Limb

fn add(self, other: bool) -> Limb

-

impl Sub<Limb> for Limb

type Output = Limb

+

impl Sub<Limb> for Limb
[src]

+

type Output = Limb

fn sub(self, other: Limb) -> Limb

-

impl Sub<BaseInt> for Limb

type Output = Limb

+

impl Sub<BaseInt> for Limb
[src]

+

type Output = Limb

fn sub(self, other: BaseInt) -> Limb

-

impl Sub<bool> for Limb

type Output = Limb

+

impl Sub<bool> for Limb
[src]

+

type Output = Limb

fn sub(self, other: bool) -> Limb

-

impl Mul<Limb> for Limb

type Output = Limb

+

impl Mul<Limb> for Limb
[src]

+

type Output = Limb

fn mul(self, other: Limb) -> Limb

-

impl Mul<BaseInt> for Limb

type Output = Limb

+

impl Mul<BaseInt> for Limb
[src]

+

type Output = Limb

fn mul(self, other: BaseInt) -> Limb

-

impl Div<Limb> for Limb

type Output = Limb

+

impl Div<Limb> for Limb
[src]

+

type Output = Limb

fn div(self, other: Limb) -> Limb

-

impl Div<BaseInt> for Limb

type Output = Limb

+

impl Div<BaseInt> for Limb
[src]

+

type Output = Limb

fn div(self, other: BaseInt) -> Limb

-

impl Rem<Limb> for Limb

type Output = Limb

+

impl Rem<Limb> for Limb
[src]

+

type Output = Limb

fn rem(self, other: Limb) -> Limb

-

impl Rem<BaseInt> for Limb

type Output = Limb

+

impl Rem<BaseInt> for Limb
[src]

+

type Output = Limb

fn rem(self, other: BaseInt) -> Limb

-

impl Neg for Limb

type Output = Limb

+

impl Neg for Limb
[src]

+

type Output = Limb

fn neg(self) -> Limb

-

impl<I> Shl<I> for Limb where BaseInt: Shl<I, Output=BaseInt>

type Output = Limb

+

impl<I> Shl<I> for Limb where BaseInt: Shl<I, Output=BaseInt>
[src]

+

type Output = Limb

fn shl(self, other: I) -> Limb

-

impl<I> Shr<I> for Limb where BaseInt: Shr<I, Output=BaseInt>

type Output = Limb

+

impl<I> Shr<I> for Limb where BaseInt: Shr<I, Output=BaseInt>
[src]

+

type Output = Limb

fn shr(self, other: I) -> Limb

-

impl Not for Limb

type Output = Limb

+

impl Not for Limb
[src]

+

type Output = Limb

fn not(self) -> Limb

-

impl BitAnd<Limb> for Limb

type Output = Limb

+

impl BitAnd<Limb> for Limb
[src]

+

type Output = Limb

fn bitand(self, other: Limb) -> Limb

-

impl BitOr<Limb> for Limb

type Output = Limb

+

impl BitOr<Limb> for Limb
[src]

+

type Output = Limb

fn bitor(self, other: Limb) -> Limb

-

impl BitXor<Limb> for Limb

type Output = Limb

+

impl BitXor<Limb> for Limb
[src]

+

type Output = Limb

fn bitxor(self, other: Limb) -> Limb

-

impl PartialEq<Limb> for Limb

fn eq(&self, other: &Limb) -> bool

+

impl PartialEq<Limb> for Limb
[src]

+

fn eq(&self, other: &Limb) -> bool

fn ne(&self, other: &Limb) -> bool

-

impl PartialOrd<Limb> for Limb

fn partial_cmp(&self, other: &Limb) -> Option<Ordering>

+

impl PartialOrd<Limb> for Limb
[src]

+

fn partial_cmp(&self, other: &Limb) -> Option<Ordering>

fn lt(&self, other: &Limb) -> bool

fn le(&self, other: &Limb) -> bool

fn gt(&self, other: &Limb) -> bool

fn ge(&self, other: &Limb) -> bool

-

impl PartialEq<BaseInt> for Limb

fn eq(&self, other: &BaseInt) -> bool

+

impl PartialEq<BaseInt> for Limb
[src]

+

fn eq(&self, other: &BaseInt) -> bool

fn ne(&self, other: &BaseInt) -> bool

-

impl PartialOrd<BaseInt> for Limb

fn partial_cmp(&self, other: &BaseInt) -> Option<Ordering>

+

impl PartialOrd<BaseInt> for Limb
[src]

+

fn partial_cmp(&self, other: &BaseInt) -> Option<Ordering>

fn lt(&self, other: &BaseInt) -> bool

fn le(&self, other: &BaseInt) -> bool

fn gt(&self, other: &BaseInt) -> bool

fn ge(&self, other: &BaseInt) -> bool

-

impl Debug for Limb

fn fmt(&self, f: &mut Formatter) -> Result

-

impl Display for Limb

fn fmt(&self, f: &mut Formatter) -> Result

-

impl PartialEq<Int> for Limb

fn eq(&self, other: &Int) -> bool

-

fn ne(&self, other: &Rhs) -> bool1.0.0

-

impl PartialOrd<Int> for Limb

fn partial_cmp(&self, other: &Int) -> Option<Ordering>

-

fn lt(&self, other: &Rhs) -> bool1.0.0

-

fn le(&self, other: &Rhs) -> bool1.0.0

-

fn gt(&self, other: &Rhs) -> bool1.0.0

-

fn ge(&self, other: &Rhs) -> bool1.0.0

-

Derived Implementations

impl Hash for Limb

fn hash<__H: Hasher>(&self, __arg_0: &mut __H)

-

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher1.3.0

-

impl Ord for Limb

fn cmp(&self, __arg_0: &Limb) -> Ordering

-

impl Eq for Limb

impl Copy for Limb

+

impl Debug for Limb
[src]

+

fn fmt(&self, f: &mut Formatter) -> Result

+

impl Display for Limb
[src]

+

fn fmt(&self, f: &mut Formatter) -> Result

+

impl PartialEq<Int> for Limb
[src]

+

fn eq(&self, other: &Int) -> bool

+

fn ne(&self, other: &Rhs) -> bool
1.0.0

+

impl PartialOrd<Int> for Limb
[src]

+

fn partial_cmp(&self, other: &Int) -> Option<Ordering>

+

fn lt(&self, other: &Rhs) -> bool
1.0.0

+

fn le(&self, other: &Rhs) -> bool
1.0.0

+

fn gt(&self, other: &Rhs) -> bool
1.0.0

+

fn ge(&self, other: &Rhs) -> bool
1.0.0

+

Derived Implementations

impl Hash for Limb
[src]

+

fn hash<__H: Hasher>(&self, __arg_0: &mut __H)

+

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher
1.3.0

+

impl Ord for Limb
[src]

+

fn cmp(&self, __arg_0: &Limb) -> Ordering

+

impl Eq for Limb
[src]

+

impl Copy for Limb
[src]

+
diff --git a/ramp/ll/limb/type.BaseInt.html b/ramp/ll/limb/type.BaseInt.html index 87b796f..7abea4f 100644 --- a/ramp/ll/limb/type.BaseInt.html +++ b/ramp/ll/limb/type.BaseInt.html @@ -47,7 +47,7 @@ [−] - [src] + [src]
type BaseInt = u64;
diff --git a/ramp/ll/limb_ptr/index.html b/ramp/ll/limb_ptr/index.html index 65a7bb3..360e896 100644 --- a/ramp/ll/limb_ptr/index.html +++ b/ramp/ll/limb_ptr/index.html @@ -47,7 +47,7 @@ [−] - [src] + [src]

Structs

diff --git a/ramp/ll/limb_ptr/struct.Limbs.html b/ramp/ll/limb_ptr/struct.Limbs.html index b7e57c3..abf1976 100644 --- a/ramp/ll/limb_ptr/struct.Limbs.html +++ b/ramp/ll/limb_ptr/struct.Limbs.html @@ -47,18 +47,19 @@ [−] - [src] + [src]
pub struct Limbs {
     // some fields omitted
 }

A version of *const Limb that is bounds-checked when debug assertions are on

-

Methods

impl Limbs

unsafe fn new(base: *const Limb, start: i32, end: i32) -> Limbs

+

Methods

impl Limbs
[src]

+

unsafe fn new(base: *const Limb, start: i32, end: i32) -> Limbs

Create a new instance, pointing at base and valid from base.offset(start) to base.offset(end).

unsafe fn offset(self, x: isize) -> Limbs

Move self to point to the xth Limbs from the current location.

Methods from Deref<Target=Limb>

const BITS: usize = 64

-

const B: Limb = Limb(1 << (Limb::BITS / 2))

+

const B: Limb = Limb(1 << Limb::BITS / 2)

fn high_part(self) -> Limb

Returns the high half of the limb

fn low_part(self) -> Limb

@@ -83,20 +84,28 @@ to be d >= BASE/2.

Returns the number of leading zeros in the limb

fn trailing_zeros(self) -> BaseInt

Returns the number of trailing zeros in the limb

-

Trait Implementations

impl PartialEq for Limbs

fn eq(&self, other: &Limbs) -> bool

-

fn ne(&self, other: &Rhs) -> bool1.0.0

-

impl PartialOrd for Limbs

fn partial_cmp(&self, other: &Limbs) -> Option<Ordering>

-

fn lt(&self, other: &Rhs) -> bool1.0.0

-

fn le(&self, other: &Rhs) -> bool1.0.0

-

fn gt(&self, other: &Rhs) -> bool1.0.0

-

fn ge(&self, other: &Rhs) -> bool1.0.0

-

impl Eq for Limbs

impl Ord for Limbs

fn cmp(&self, other: &Limbs) -> Ordering

-

impl Deref for Limbs

type Target = Limb

+

Trait Implementations

impl PartialEq for Limbs
[src]

+

fn eq(&self, other: &Limbs) -> bool

+

fn ne(&self, other: &Rhs) -> bool
1.0.0

+

impl PartialOrd for Limbs
[src]

+

fn partial_cmp(&self, other: &Limbs) -> Option<Ordering>

+

fn lt(&self, other: &Rhs) -> bool
1.0.0

+

fn le(&self, other: &Rhs) -> bool
1.0.0

+

fn gt(&self, other: &Rhs) -> bool
1.0.0

+

fn ge(&self, other: &Rhs) -> bool
1.0.0

+

impl Eq for Limbs
[src]

+

impl Ord for Limbs
[src]

+

fn cmp(&self, other: &Limbs) -> Ordering

+

impl Deref for Limbs
[src]

+

type Target = Limb

fn deref(&self) -> &Limb

-

Derived Implementations

impl Debug for Limbs

fn fmt(&self, __arg_0: &mut Formatter) -> Result

-

impl Clone for Limbs

fn clone(&self) -> Limbs

-

fn clone_from(&mut self, source: &Self)1.0.0

-

impl Copy for Limbs

+

Derived Implementations

impl Debug for Limbs
[src]

+

fn fmt(&self, __arg_0: &mut Formatter) -> Result

+

impl Clone for Limbs
[src]

+

fn clone(&self) -> Limbs

+

fn clone_from(&mut self, source: &Self)
1.0.0

+

impl Copy for Limbs
[src]

+
diff --git a/ramp/ll/limb_ptr/struct.LimbsMut.html b/ramp/ll/limb_ptr/struct.LimbsMut.html index 89c0ef0..0c8973d 100644 --- a/ramp/ll/limb_ptr/struct.LimbsMut.html +++ b/ramp/ll/limb_ptr/struct.LimbsMut.html @@ -47,20 +47,22 @@ [−] - [src] + [src]
pub struct LimbsMut {
     // some fields omitted
 }

A version of *mut Limb that is bounds-checked when debug assertions are on

-

Methods

impl LimbsMut

unsafe fn new(base: *mut Limb, start: i32, end: i32) -> LimbsMut

+

Methods

impl LimbsMut
[src]

+

unsafe fn new(base: *mut Limb, start: i32, end: i32) -> LimbsMut

Create a new instance, pointing at base and valid from base.offset(start) to base.offset(end).

unsafe fn offset(self, x: isize) -> LimbsMut

Move self to point to the xth Limbs from the current location.

-

impl LimbsMut

fn as_const(self) -> Limbs

+

impl LimbsMut
[src]

+

fn as_const(self) -> Limbs

View the LimbsMut as a Limbs (an explicit *const Limb -> *mut Limb conversion)

Methods from Deref<Target=Limb>

const BITS: usize = 64

-

const B: Limb = Limb(1 << (Limb::BITS / 2))

+

const B: Limb = Limb(1 << Limb::BITS / 2)

fn high_part(self) -> Limb

Returns the high half of the limb

fn low_part(self) -> Limb

@@ -85,20 +87,28 @@ to be d >= BASE/2.

Returns the number of leading zeros in the limb

fn trailing_zeros(self) -> BaseInt

Returns the number of trailing zeros in the limb

-

Trait Implementations

impl PartialEq for LimbsMut

fn eq(&self, other: &LimbsMut) -> bool

-

fn ne(&self, other: &Rhs) -> bool1.0.0

-

impl PartialOrd for LimbsMut

fn partial_cmp(&self, other: &LimbsMut) -> Option<Ordering>

-

fn lt(&self, other: &Rhs) -> bool1.0.0

-

fn le(&self, other: &Rhs) -> bool1.0.0

-

fn gt(&self, other: &Rhs) -> bool1.0.0

-

fn ge(&self, other: &Rhs) -> bool1.0.0

-

impl Eq for LimbsMut

impl Ord for LimbsMut

fn cmp(&self, other: &LimbsMut) -> Ordering

-

impl Deref for LimbsMut

type Target = Limb

+

Trait Implementations

impl PartialEq for LimbsMut
[src]

+

fn eq(&self, other: &LimbsMut) -> bool

+

fn ne(&self, other: &Rhs) -> bool
1.0.0

+

impl PartialOrd for LimbsMut
[src]

+

fn partial_cmp(&self, other: &LimbsMut) -> Option<Ordering>

+

fn lt(&self, other: &Rhs) -> bool
1.0.0

+

fn le(&self, other: &Rhs) -> bool
1.0.0

+

fn gt(&self, other: &Rhs) -> bool
1.0.0

+

fn ge(&self, other: &Rhs) -> bool
1.0.0

+

impl Eq for LimbsMut
[src]

+

impl Ord for LimbsMut
[src]

+

fn cmp(&self, other: &LimbsMut) -> Ordering

+

impl Deref for LimbsMut
[src]

+

type Target = Limb

fn deref(&self) -> &Limb

-

impl DerefMut for LimbsMut

fn deref_mut(&mut self) -> &mut Limb

-

Derived Implementations

impl Clone for LimbsMut

fn clone(&self) -> LimbsMut

-

fn clone_from(&mut self, source: &Self)1.0.0

-

impl Copy for LimbsMut

+

impl DerefMut for LimbsMut
[src]

+

fn deref_mut(&mut self) -> &mut Limb

+

Derived Implementations

impl Clone for LimbsMut
[src]

+

fn clone(&self) -> LimbsMut

+

fn clone_from(&mut self, source: &Self)
1.0.0

+

impl Copy for LimbsMut
[src]

+
diff --git a/rand/chacha/index.html b/rand/chacha/index.html index 5b3afac..8a38749 100644 --- a/rand/chacha/index.html +++ b/rand/chacha/index.html @@ -47,7 +47,7 @@ [−] - [src] + [src]

The ChaCha random number generator.

Structs

diff --git a/rand/chacha/struct.ChaChaRng.html b/rand/chacha/struct.ChaChaRng.html index ec942d3..6eab1f6 100644 --- a/rand/chacha/struct.ChaChaRng.html +++ b/rand/chacha/struct.ChaChaRng.html @@ -47,7 +47,7 @@ [−] - [src] + [src]
pub struct ChaChaRng {
     // some fields omitted
 }

A random number generator that uses the ChaCha20 algorithm [1].

@@ -59,7 +59,8 @@ the operating system for cases that need high security.

[1]: D. J. Bernstein, ChaCha, a variant of Salsa20

-

Methods

impl ChaChaRng

fn new_unseeded() -> ChaChaRng

+

Methods

impl ChaChaRng
[src]

+

fn new_unseeded() -> ChaChaRng

Create an ChaCha random number generator using the default fixed key of 8 zero words.

fn set_counter(&mut self, counter_low: u64, counter_high: u64)

@@ -71,7 +72,8 @@ arbitrarily ahead (or backwards) in the pseudorandom stream.

users wishing to obtain the conventional ChaCha pseudorandom stream associated with a particular nonce can call this function with arguments 0, desired_nonce.

-

Trait Implementations

impl Rng for ChaChaRng

fn next_u32(&mut self) -> u32

+

Trait Implementations

impl Rng for ChaChaRng
[src]

+

fn next_u32(&mut self) -> u32

fn next_u64(&mut self) -> u64

fn next_f32(&mut self) -> f32

fn next_f64(&mut self) -> f64

@@ -83,16 +85,20 @@ arguments 0, desired_nonce.

fn gen_ascii_chars<'a>(&'a mut self) -> AsciiGenerator<'a, Self> where Self: Sized

fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> where Self: Sized

fn shuffle<T>(&mut self, values: &mut [T]) where Self: Sized

-

impl<'a> SeedableRng<&'a [u32]> for ChaChaRng

fn reseed(&mut self, seed: &'a [u32])

+

impl<'a> SeedableRng<&'a [u32]> for ChaChaRng
[src]

+

fn reseed(&mut self, seed: &'a [u32])

fn from_seed(seed: &'a [u32]) -> ChaChaRng

Create a ChaCha generator from a seed, obtained from a variable-length u32 array. Only up to 8 words are used; if less than 8 words are used, the remaining are set to zero.

-

impl Rand for ChaChaRng

fn rand<R: Rng>(other: &mut R) -> ChaChaRng

-

Derived Implementations

impl Clone for ChaChaRng

fn clone(&self) -> ChaChaRng

-

fn clone_from(&mut self, source: &Self)1.0.0

-

impl Copy for ChaChaRng

+

impl Rand for ChaChaRng
[src]

+

fn rand<R: Rng>(other: &mut R) -> ChaChaRng

+

Derived Implementations

impl Clone for ChaChaRng
[src]

+

fn clone(&self) -> ChaChaRng

+

fn clone_from(&mut self, source: &Self)
1.0.0

+

impl Copy for ChaChaRng
[src]

+
diff --git a/rand/distributions/exponential/struct.Exp.html b/rand/distributions/exponential/struct.Exp.html index f346d35..8f3c772 100644 --- a/rand/distributions/exponential/struct.Exp.html +++ b/rand/distributions/exponential/struct.Exp.html @@ -61,13 +61,18 @@ letexp=Exp::new(2.0); letv=exp.ind_sample(&mutrand::thread_rng()); println!("{} is from a Exp(2) distribution", v); -

Methods

impl Exp

fn new(lambda: f64) -> Exp

+

Methods

impl Exp
[src]

+

fn new(lambda: f64) -> Exp

Construct a new Exp with the given shape parameter lambda. Panics if lambda <= 0.

-

Trait Implementations

impl Sample<f64> for Exp

fn sample<R: Rng>(&mut self, rng: &mut R) -> f64

-

impl IndependentSample<f64> for Exp

fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64

-

Derived Implementations

impl Copy for Exp

impl Clone for Exp

fn clone(&self) -> Exp

-

fn clone_from(&mut self, source: &Self)1.0.0

+

Trait Implementations

impl Sample<f64> for Exp
[src]

+

fn sample<R: Rng>(&mut self, rng: &mut R) -> f64

+

impl IndependentSample<f64> for Exp
[src]

+

fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64

+

Derived Implementations

impl Copy for Exp
[src]

+

impl Clone for Exp
[src]

+

fn clone(&self) -> Exp

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/rand/distributions/exponential/struct.Exp1.html b/rand/distributions/exponential/struct.Exp1.html index 1a1b0d0..335212f 100644 --- a/rand/distributions/exponential/struct.Exp1.html +++ b/rand/distributions/exponential/struct.Exp1.html @@ -67,9 +67,12 @@ College, Oxford

letExp1(x) =rand::random(); println!("{}", x); -

Trait Implementations

impl Rand for Exp1

fn rand<R: Rng>(rng: &mut R) -> Exp1

-

Derived Implementations

impl Copy for Exp1

impl Clone for Exp1

fn clone(&self) -> Exp1

-

fn clone_from(&mut self, source: &Self)1.0.0

+

Trait Implementations

impl Rand for Exp1
[src]

+

fn rand<R: Rng>(rng: &mut R) -> Exp1

+

Derived Implementations

impl Copy for Exp1
[src]

+

impl Clone for Exp1
[src]

+

fn clone(&self) -> Exp1

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/rand/distributions/gamma/struct.ChiSquared.html b/rand/distributions/gamma/struct.ChiSquared.html index cf5acf5..5c2e0e8 100644 --- a/rand/distributions/gamma/struct.ChiSquared.html +++ b/rand/distributions/gamma/struct.ChiSquared.html @@ -64,13 +64,18 @@ of k independent standard normal random variables. For other letchi=ChiSquared::new(11.0); letv=chi.ind_sample(&mutrand::thread_rng()); println!("{} is from a χ²(11) distribution", v) -

Methods

impl ChiSquared

fn new(k: f64) -> ChiSquared

+

Methods

impl ChiSquared
[src]

+

fn new(k: f64) -> ChiSquared

Create a new chi-squared distribution with degrees-of-freedom k. Panics if k < 0.

-

Trait Implementations

impl Sample<f64> for ChiSquared

fn sample<R: Rng>(&mut self, rng: &mut R) -> f64

-

impl IndependentSample<f64> for ChiSquared

fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64

-

Derived Implementations

impl Copy for ChiSquared

impl Clone for ChiSquared

fn clone(&self) -> ChiSquared

-

fn clone_from(&mut self, source: &Self)1.0.0

+

Trait Implementations

impl Sample<f64> for ChiSquared
[src]

+

fn sample<R: Rng>(&mut self, rng: &mut R) -> f64

+

impl IndependentSample<f64> for ChiSquared
[src]

+

fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64

+

Derived Implementations

impl Copy for ChiSquared
[src]

+

impl Clone for ChiSquared
[src]

+

fn clone(&self) -> ChiSquared

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/rand/distributions/gamma/struct.FisherF.html b/rand/distributions/gamma/struct.FisherF.html index 7dd0622..d4f16b5 100644 --- a/rand/distributions/gamma/struct.FisherF.html +++ b/rand/distributions/gamma/struct.FisherF.html @@ -62,13 +62,18 @@ chi-squared distributions, that is, F(m,n) = (χ²(m)/m) / (χ²(n)/n)let f = FisherF::new(2.0, 32.0); let v = f.ind_sample(&mut rand::thread_rng()); println!("{} is from an F(2, 32) distribution", v) -

Methods

impl FisherF

fn new(m: f64, n: f64) -> FisherF

+

Methods

impl FisherF
[src]

+

fn new(m: f64, n: f64) -> FisherF

Create a new FisherF distribution, with the given parameter. Panics if either m or n are not positive.

-

Trait Implementations

impl Sample<f64> for FisherF

fn sample<R: Rng>(&mut self, rng: &mut R) -> f64

-

impl IndependentSample<f64> for FisherF

fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64

-

Derived Implementations

impl Copy for FisherF

impl Clone for FisherF

fn clone(&self) -> FisherF

-

fn clone_from(&mut self, source: &Self)1.0.0

+

Trait Implementations

impl Sample<f64> for FisherF
[src]

+

fn sample<R: Rng>(&mut self, rng: &mut R) -> f64

+

impl IndependentSample<f64> for FisherF
[src]

+

fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64

+

Derived Implementations

impl Copy for FisherF
[src]

+

impl Clone for FisherF
[src]

+

fn clone(&self) -> FisherF

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/rand/distributions/gamma/struct.Gamma.html b/rand/distributions/gamma/struct.Gamma.html index f562c44..155a935 100644 --- a/rand/distributions/gamma/struct.Gamma.html +++ b/rand/distributions/gamma/struct.Gamma.html @@ -76,15 +76,20 @@ falling back to directly sampling from an Exponential for shape == 1ACM Trans. Math. Softw. 26, 3 (September 2000), 363-372. DOI:10.1145/358407.358414

-

Methods

impl Gamma

fn new(shape: f64, scale: f64) -> Gamma

+

Methods

impl Gamma
[src]

+

fn new(shape: f64, scale: f64) -> Gamma

Construct an object representing the Gamma(shape, scale) distribution.

Panics if shape <= 0 or scale <= 0.

-

Trait Implementations

impl Sample<f64> for Gamma

fn sample<R: Rng>(&mut self, rng: &mut R) -> f64

-

impl IndependentSample<f64> for Gamma

fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64

-

Derived Implementations

impl Copy for Gamma

impl Clone for Gamma

fn clone(&self) -> Gamma

-

fn clone_from(&mut self, source: &Self)1.0.0

+

Trait Implementations

impl Sample<f64> for Gamma
[src]

+

fn sample<R: Rng>(&mut self, rng: &mut R) -> f64

+

impl IndependentSample<f64> for Gamma
[src]

+

fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64

+

Derived Implementations

impl Copy for Gamma
[src]

+

impl Clone for Gamma
[src]

+

fn clone(&self) -> Gamma

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/rand/distributions/gamma/struct.StudentT.html b/rand/distributions/gamma/struct.StudentT.html index 9b945ff..3a3bfa4 100644 --- a/rand/distributions/gamma/struct.StudentT.html +++ b/rand/distributions/gamma/struct.StudentT.html @@ -60,13 +60,18 @@ freedom.

let t = StudentT::new(11.0); let v = t.ind_sample(&mut rand::thread_rng()); println!("{} is from a t(11) distribution", v) -

Methods

impl StudentT

fn new(n: f64) -> StudentT

+

Methods

impl StudentT
[src]

+

fn new(n: f64) -> StudentT

Create a new Student t distribution with n degrees of freedom. Panics if n <= 0.

-

Trait Implementations

impl Sample<f64> for StudentT

fn sample<R: Rng>(&mut self, rng: &mut R) -> f64

-

impl IndependentSample<f64> for StudentT

fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64

-

Derived Implementations

impl Copy for StudentT

impl Clone for StudentT

fn clone(&self) -> StudentT

-

fn clone_from(&mut self, source: &Self)1.0.0

+

Trait Implementations

impl Sample<f64> for StudentT
[src]

+

fn sample<R: Rng>(&mut self, rng: &mut R) -> f64

+

impl IndependentSample<f64> for StudentT
[src]

+

fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64

+

Derived Implementations

impl Copy for StudentT
[src]

+

impl Clone for StudentT
[src]

+

fn clone(&self) -> StudentT

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/rand/distributions/normal/struct.LogNormal.html b/rand/distributions/normal/struct.LogNormal.html index 17be2d3..b6ee626 100644 --- a/rand/distributions/normal/struct.LogNormal.html +++ b/rand/distributions/normal/struct.LogNormal.html @@ -62,16 +62,21 @@ let log_normal = LogNormal::new(2.0, 3.0); let v = log_normal.ind_sample(&mut rand::thread_rng()); println!("{} is from an ln N(2, 9) distribution", v) -

Methods

impl LogNormal

fn new(mean: f64, std_dev: f64) -> LogNormal

+

Methods

impl LogNormal
[src]

+

fn new(mean: f64, std_dev: f64) -> LogNormal

Construct a new LogNormal distribution with the given mean and standard deviation.

Panics

Panics if std_dev < 0.

-

Trait Implementations

impl Sample<f64> for LogNormal

fn sample<R: Rng>(&mut self, rng: &mut R) -> f64

-

impl IndependentSample<f64> for LogNormal

fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64

-

Derived Implementations

impl Copy for LogNormal

impl Clone for LogNormal

fn clone(&self) -> LogNormal

-

fn clone_from(&mut self, source: &Self)1.0.0

+

Trait Implementations

impl Sample<f64> for LogNormal
[src]

+

fn sample<R: Rng>(&mut self, rng: &mut R) -> f64

+

impl IndependentSample<f64> for LogNormal
[src]

+

fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64

+

Derived Implementations

impl Copy for LogNormal
[src]

+

impl Clone for LogNormal
[src]

+

fn clone(&self) -> LogNormal

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/rand/distributions/normal/struct.Normal.html b/rand/distributions/normal/struct.Normal.html index c7b388d..3570e37 100644 --- a/rand/distributions/normal/struct.Normal.html +++ b/rand/distributions/normal/struct.Normal.html @@ -63,16 +63,21 @@ let normal = Normal::new(2.0, 3.0); let v = normal.ind_sample(&mut rand::thread_rng()); println!("{} is from a N(2, 9) distribution", v) -

Methods

impl Normal

fn new(mean: f64, std_dev: f64) -> Normal

+

Methods

impl Normal
[src]

+

fn new(mean: f64, std_dev: f64) -> Normal

Construct a new Normal distribution with the given mean and standard deviation.

Panics

Panics if std_dev < 0.

-

Trait Implementations

impl Sample<f64> for Normal

fn sample<R: Rng>(&mut self, rng: &mut R) -> f64

-

impl IndependentSample<f64> for Normal

fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64

-

Derived Implementations

impl Copy for Normal

impl Clone for Normal

fn clone(&self) -> Normal

-

fn clone_from(&mut self, source: &Self)1.0.0

+

Trait Implementations

impl Sample<f64> for Normal
[src]

+

fn sample<R: Rng>(&mut self, rng: &mut R) -> f64

+

impl IndependentSample<f64> for Normal
[src]

+

fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64

+

Derived Implementations

impl Copy for Normal
[src]

+

impl Clone for Normal
[src]

+

fn clone(&self) -> Normal

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/rand/distributions/normal/struct.StandardNormal.html b/rand/distributions/normal/struct.StandardNormal.html index 56599ae..f3556b0 100644 --- a/rand/distributions/normal/struct.StandardNormal.html +++ b/rand/distributions/normal/struct.StandardNormal.html @@ -66,9 +66,12 @@ College, Oxford

let StandardNormal(x) = rand::random(); println!("{}", x); -

Trait Implementations

impl Rand for StandardNormal

fn rand<R: Rng>(rng: &mut R) -> StandardNormal

-

Derived Implementations

impl Copy for StandardNormal

impl Clone for StandardNormal

fn clone(&self) -> StandardNormal

-

fn clone_from(&mut self, source: &Self)1.0.0

+

Trait Implementations

impl Rand for StandardNormal
[src]

+

fn rand<R: Rng>(rng: &mut R) -> StandardNormal

+

Derived Implementations

impl Copy for StandardNormal
[src]

+

impl Clone for StandardNormal
[src]

+

fn clone(&self) -> StandardNormal

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/rand/distributions/range/struct.Range.html b/rand/distributions/range/struct.Range.html index a6ed5c5..a205691 100644 --- a/rand/distributions/range/struct.Range.html +++ b/rand/distributions/range/struct.Range.html @@ -77,13 +77,18 @@ normally satisfy it, but rounding may mean high can occur.

} println!("{}", sum); } -

Methods

impl<X: SampleRange + PartialOrd> Range<X>

fn new(low: X, high: X) -> Range<X>

+

Methods

impl<X: SampleRange + PartialOrd> Range<X>
[src]

+

fn new(low: X, high: X) -> Range<X>

Create a new Range instance that samples uniformly from [low, high). Panics if low >= high.

-

Trait Implementations

impl<Sup: SampleRange> Sample<Sup> for Range<Sup>

fn sample<R: Rng>(&mut self, rng: &mut R) -> Sup

-

impl<Sup: SampleRange> IndependentSample<Sup> for Range<Sup>

fn ind_sample<R: Rng>(&self, rng: &mut R) -> Sup

-

Derived Implementations

impl<X: Copy> Copy for Range<X>

impl<X: Clone> Clone for Range<X>

fn clone(&self) -> Range<X>

-

fn clone_from(&mut self, source: &Self)1.0.0

+

Trait Implementations

impl<Sup: SampleRange> Sample<Sup> for Range<Sup>
[src]

+

fn sample<R: Rng>(&mut self, rng: &mut R) -> Sup

+

impl<Sup: SampleRange> IndependentSample<Sup> for Range<Sup>
[src]

+

fn ind_sample<R: Rng>(&self, rng: &mut R) -> Sup

+

Derived Implementations

impl<X: Copy> Copy for Range<X>
[src]

+

impl<X: Clone> Clone for Range<X>
[src]

+

fn clone(&self) -> Range<X>

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/rand/distributions/struct.RandSample.html b/rand/distributions/struct.RandSample.html index 9be50fe..3a18c11 100644 --- a/rand/distributions/struct.RandSample.html +++ b/rand/distributions/struct.RandSample.html @@ -52,11 +52,16 @@ // some fields omitted }

A wrapper for generating types that implement Rand via the Sample & IndependentSample traits.

-

Methods

impl<Sup> RandSample<Sup>

fn new() -> RandSample<Sup>

-

Trait Implementations

impl<Sup> Copy for RandSample<Sup>

impl<Sup> Clone for RandSample<Sup>

fn clone(&self) -> Self

-

fn clone_from(&mut self, source: &Self)1.0.0

-

impl<Sup: Rand> Sample<Sup> for RandSample<Sup>

fn sample<R: Rng>(&mut self, rng: &mut R) -> Sup

-

impl<Sup: Rand> IndependentSample<Sup> for RandSample<Sup>

fn ind_sample<R: Rng>(&self, rng: &mut R) -> Sup

+

Methods

impl<Sup> RandSample<Sup>
[src]

+

fn new() -> RandSample<Sup>

+

Trait Implementations

impl<Sup> Copy for RandSample<Sup>
[src]

+

impl<Sup> Clone for RandSample<Sup>
[src]

+

fn clone(&self) -> Self

+

fn clone_from(&mut self, source: &Self)
1.0.0

+

impl<Sup: Rand> Sample<Sup> for RandSample<Sup>
[src]

+

fn sample<R: Rng>(&mut self, rng: &mut R) -> Sup

+

impl<Sup: Rand> IndependentSample<Sup> for RandSample<Sup>
[src]

+

fn ind_sample<R: Rng>(&self, rng: &mut R) -> Sup

diff --git a/rand/distributions/struct.Weighted.html b/rand/distributions/struct.Weighted.html index 0ba99f4..da2c2fd 100644 --- a/rand/distributions/struct.Weighted.html +++ b/rand/distributions/struct.Weighted.html @@ -57,8 +57,10 @@
weight

The numerical weight of this item

item

The actual item which is being weighted

-

Trait Implementations

Derived Implementations

impl<T: Copy> Copy for Weighted<T>

impl<T: Clone> Clone for Weighted<T>

fn clone(&self) -> Weighted<T>

-

fn clone_from(&mut self, source: &Self)1.0.0

+

Trait Implementations

Derived Implementations

impl<T: Copy> Copy for Weighted<T>
[src]

+

impl<T: Clone> Clone for Weighted<T>
[src]

+

fn clone(&self) -> Weighted<T>

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/rand/distributions/struct.WeightedChoice.html b/rand/distributions/struct.WeightedChoice.html index 766cdec..b887611 100644 --- a/rand/distributions/struct.WeightedChoice.html +++ b/rand/distributions/struct.WeightedChoice.html @@ -73,15 +73,18 @@ another vector.

// on average prints 'a' 4 times, 'b' 8 and 'c' twice. println!("{}", wc.ind_sample(&mut rng)); } -

Methods

impl<'a, T: Clone> WeightedChoice<'a, T>

fn new(items: &'a mut [Weighted<T>]) -> WeightedChoice<'a, T>

+

Methods

impl<'a, T: Clone> WeightedChoice<'a, T>
[src]

+

fn new(items: &'a mut [Weighted<T>]) -> WeightedChoice<'a, T>

Create a new WeightedChoice.

Panics if: - v is empty - the total weight is 0 - the total weight is larger than a u32 can contain.

-

Trait Implementations

impl<'a, T: Clone> Sample<T> for WeightedChoice<'a, T>

fn sample<R: Rng>(&mut self, rng: &mut R) -> T

-

impl<'a, T: Clone> IndependentSample<T> for WeightedChoice<'a, T>

fn ind_sample<R: Rng>(&self, rng: &mut R) -> T

+

Trait Implementations

impl<'a, T: Clone> Sample<T> for WeightedChoice<'a, T>
[src]

+

fn sample<R: Rng>(&mut self, rng: &mut R) -> T

+

impl<'a, T: Clone> IndependentSample<T> for WeightedChoice<'a, T>
[src]

+

fn ind_sample<R: Rng>(&self, rng: &mut R) -> T

diff --git a/rand/fn.random.html b/rand/fn.random.html index 9a074e5..914c78e 100644 --- a/rand/fn.random.html +++ b/rand/fn.random.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub fn random<T: Rand>() -> T

Generates a random value using the thread-local random number generator.

random() can generate various types of random things, and so may require diff --git a/rand/fn.sample.html b/rand/fn.sample.html index ecda0bb..6a04ebc 100644 --- a/rand/fn.sample.html +++ b/rand/fn.sample.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 

pub fn sample<T, I, R>(rng: &mut R, iterable: I, amount: usize) -> Vec<T> where I: IntoIterator<Item=T>, R: Rng

Randomly sample up to amount elements from an iterator.

Example

diff --git a/rand/fn.thread_rng.html b/rand/fn.thread_rng.html index eea2f3d..8739cd2 100644 --- a/rand/fn.thread_rng.html +++ b/rand/fn.thread_rng.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub fn thread_rng() -> ThreadRng

Retrieve the lazily-initialized thread-local random number generator, seeded by the system. Intended to be used in method chaining style, e.g. thread_rng().gen::<i32>().

diff --git a/rand/fn.weak_rng.html b/rand/fn.weak_rng.html index 20ec29e..d12a46c 100644 --- a/rand/fn.weak_rng.html +++ b/rand/fn.weak_rng.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub fn weak_rng() -> XorShiftRng

Create a weak random number generator with a default algorithm and seed.

It returns the fastest Rng algorithm currently available in Rust without diff --git a/rand/index.html b/rand/index.html index 504d926..0297459 100644 --- a/rand/index.html +++ b/rand/index.html @@ -242,10 +242,10 @@ steps it will indeed confirm that it is better to switch.

let result = simulate(&random_door, &mut rng); match (result.win, result.switch) { - (true, true) => switch_wins += 1, - (true, false) => keep_wins += 1, - (false, true) => switch_losses += 1, - (false, false) => keep_losses += 1, + (true, true) => switch_wins += 1, + (true, false) => keep_wins += 1, + (false, true) => switch_losses += 1, + (false, false) => keep_losses += 1, } } diff --git a/rand/isaac/index.html b/rand/isaac/index.html index 7e0f855..79deee6 100644 --- a/rand/isaac/index.html +++ b/rand/isaac/index.html @@ -47,7 +47,7 @@ [−] - [src] + [src]

The ISAAC random number generator.

Structs

diff --git a/rand/isaac/struct.Isaac64Rng.html b/rand/isaac/struct.Isaac64Rng.html index 820ee18..f149be6 100644 --- a/rand/isaac/struct.Isaac64Rng.html +++ b/rand/isaac/struct.Isaac64Rng.html @@ -47,7 +47,7 @@ [−] - [src] + [src]
pub struct Isaac64Rng {
     // some fields omitted
 }

A random number generator that uses ISAAC-64[1], the 64-bit @@ -60,12 +60,15 @@ the operating system for cases that need high security.

[1]: Bob Jenkins, ISAAC: A fast cryptographic random number generator

-

Methods

impl Isaac64Rng

fn new_unseeded() -> Isaac64Rng

+

Methods

impl Isaac64Rng
[src]

+

fn new_unseeded() -> Isaac64Rng

Create a 64-bit ISAAC random number generator using the default fixed seed.

-

Trait Implementations

impl Clone for Isaac64Rng

fn clone(&self) -> Isaac64Rng

-

fn clone_from(&mut self, source: &Self)1.0.0

-

impl Rng for Isaac64Rng

fn next_u32(&mut self) -> u32

+

Trait Implementations

impl Clone for Isaac64Rng
[src]

+

fn clone(&self) -> Isaac64Rng

+

fn clone_from(&mut self, source: &Self)
1.0.0

+

impl Rng for Isaac64Rng
[src]

+

fn next_u32(&mut self) -> u32

fn next_u64(&mut self) -> u64

fn next_f32(&mut self) -> f32

fn next_f64(&mut self) -> f64

@@ -77,15 +80,18 @@ default fixed seed.

fn gen_ascii_chars<'a>(&'a mut self) -> AsciiGenerator<'a, Self> where Self: Sized

fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> where Self: Sized

fn shuffle<T>(&mut self, values: &mut [T]) where Self: Sized

-

impl<'a> SeedableRng<&'a [u64]> for Isaac64Rng

fn reseed(&mut self, seed: &'a [u64])

+

impl<'a> SeedableRng<&'a [u64]> for Isaac64Rng
[src]

+

fn reseed(&mut self, seed: &'a [u64])

fn from_seed(seed: &'a [u64]) -> Isaac64Rng

Create an ISAAC random number generator with a seed. This can be any length, although the maximum number of elements used is 256 and any more will be silently ignored. A generator constructed with a given seed will generate the same sequence of values as all other generators constructed with that seed.

-

impl Rand for Isaac64Rng

fn rand<R: Rng>(other: &mut R) -> Isaac64Rng

-

Derived Implementations

impl Copy for Isaac64Rng

+

impl Rand for Isaac64Rng
[src]

+

fn rand<R: Rng>(other: &mut R) -> Isaac64Rng

+

Derived Implementations

impl Copy for Isaac64Rng
[src]

+
diff --git a/rand/isaac/struct.IsaacRng.html b/rand/isaac/struct.IsaacRng.html index f82fb10..53c1451 100644 --- a/rand/isaac/struct.IsaacRng.html +++ b/rand/isaac/struct.IsaacRng.html @@ -47,7 +47,7 @@ [−] - [src] + [src]
pub struct IsaacRng {
     // some fields omitted
 }

A random number generator that uses the ISAAC algorithm[1].

@@ -59,12 +59,15 @@ the operating system for cases that need high security.

[1]: Bob Jenkins, ISAAC: A fast cryptographic random number generator

-

Methods

impl IsaacRng

fn new_unseeded() -> IsaacRng

+

Methods

impl IsaacRng
[src]

+

fn new_unseeded() -> IsaacRng

Create an ISAAC random number generator using the default fixed seed.

-

Trait Implementations

impl Clone for IsaacRng

fn clone(&self) -> IsaacRng

-

fn clone_from(&mut self, source: &Self)1.0.0

-

impl Rng for IsaacRng

fn next_u32(&mut self) -> u32

+

Trait Implementations

impl Clone for IsaacRng
[src]

+

fn clone(&self) -> IsaacRng

+

fn clone_from(&mut self, source: &Self)
1.0.0

+

impl Rng for IsaacRng
[src]

+

fn next_u32(&mut self) -> u32

fn next_u64(&mut self) -> u64

fn next_f32(&mut self) -> f32

fn next_f64(&mut self) -> f64

@@ -76,15 +79,18 @@ fixed seed.

fn gen_ascii_chars<'a>(&'a mut self) -> AsciiGenerator<'a, Self> where Self: Sized

fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> where Self: Sized

fn shuffle<T>(&mut self, values: &mut [T]) where Self: Sized

-

impl<'a> SeedableRng<&'a [u32]> for IsaacRng

fn reseed(&mut self, seed: &'a [u32])

+

impl<'a> SeedableRng<&'a [u32]> for IsaacRng
[src]

+

fn reseed(&mut self, seed: &'a [u32])

fn from_seed(seed: &'a [u32]) -> IsaacRng

Create an ISAAC random number generator with a seed. This can be any length, although the maximum number of elements used is 256 and any more will be silently ignored. A generator constructed with a given seed will generate the same sequence of values as all other generators constructed with that seed.

-

impl Rand for IsaacRng

fn rand<R: Rng>(other: &mut R) -> IsaacRng

-

Derived Implementations

impl Copy for IsaacRng

+

impl Rand for IsaacRng
[src]

+

fn rand<R: Rng>(other: &mut R) -> IsaacRng

+

Derived Implementations

impl Copy for IsaacRng
[src]

+
diff --git a/rand/os/index.html b/rand/os/index.html index 00fa2bc..eb57a10 100644 --- a/rand/os/index.html +++ b/rand/os/index.html @@ -47,7 +47,7 @@ [−] - [src] + [src]

Interfaces to the operating system provided random number generators.

Structs

diff --git a/rand/os/struct.OsRng.html b/rand/os/struct.OsRng.html index 1154424..be1f69b 100644 --- a/rand/os/struct.OsRng.html +++ b/rand/os/struct.OsRng.html @@ -47,7 +47,7 @@ [−] - [src] + [src]
pub struct OsRng(_);

A random number generator that retrieves randomness straight from the operating system. Platform sources:

@@ -61,9 +61,11 @@ service provider with the PROV_RSA_FULL type.

This does not block.

-

Methods

impl OsRng

fn new() -> Result<OsRng>

+

Methods

impl OsRng
[src]

+

fn new() -> Result<OsRng>

Create a new OsRng.

-

Trait Implementations

impl Rng for OsRng

fn next_u32(&mut self) -> u32

+

Trait Implementations

impl Rng for OsRng
[src]

+

fn next_u32(&mut self) -> u32

fn next_u64(&mut self) -> u64

fn fill_bytes(&mut self, v: &mut [u8])

fn next_f32(&mut self) -> f32

diff --git a/rand/read/index.html b/rand/read/index.html index 415e116..1d039d7 100644 --- a/rand/read/index.html +++ b/rand/read/index.html @@ -47,7 +47,7 @@ [−] - [src] + [src]

A wrapper around any Read to treat it as an RNG.

Structs

diff --git a/rand/read/struct.ReadRng.html b/rand/read/struct.ReadRng.html index 2705a5f..72adbbf 100644 --- a/rand/read/struct.ReadRng.html +++ b/rand/read/struct.ReadRng.html @@ -47,7 +47,7 @@ [−] - [src] + [src]
pub struct ReadRng<R> {
     // some fields omitted
 }

An RNG that reads random bytes straight from a Read. This will @@ -63,9 +63,11 @@ work best with an infinite reader, but this is not required.

let data = vec![1, 2, 3, 4, 5, 6, 7, 8]; let mut rng = read::ReadRng::new(&data[..]); println!("{:x}", rng.gen::<u32>()); -

Methods

impl<R: Read> ReadRng<R>

fn new(r: R) -> ReadRng<R>

+

Methods

impl<R: Read> ReadRng<R>
[src]

+

fn new(r: R) -> ReadRng<R>

Create a new ReadRng from a Read.

-

Trait Implementations

impl<R: Read> Rng for ReadRng<R>

fn next_u32(&mut self) -> u32

+

Trait Implementations

impl<R: Read> Rng for ReadRng<R>
[src]

+

fn next_u32(&mut self) -> u32

fn next_u64(&mut self) -> u64

fn fill_bytes(&mut self, v: &mut [u8])

fn next_f32(&mut self) -> f32

diff --git a/rand/reseeding/index.html b/rand/reseeding/index.html index d9bfef1..d53bf02 100644 --- a/rand/reseeding/index.html +++ b/rand/reseeding/index.html @@ -47,7 +47,7 @@ [−] - [src] + [src]

A wrapper around another RNG that reseeds it after it generates a certain number of random bytes.

Structs

diff --git a/rand/reseeding/struct.ReseedWithDefault.html b/rand/reseeding/struct.ReseedWithDefault.html index 1f38e1e..07da75d 100644 --- a/rand/reseeding/struct.ReseedWithDefault.html +++ b/rand/reseeding/struct.ReseedWithDefault.html @@ -47,13 +47,17 @@ [−] - [src] + [src] 
pub struct ReseedWithDefault;

Reseed an RNG using a Default instance. This reseeds by replacing the RNG with the result of a Default::default call.

-

Trait Implementations

impl<R: Rng + Default> Reseeder<R> for ReseedWithDefault

fn reseed(&mut self, rng: &mut R)

-

impl Default for ReseedWithDefault

fn default() -> ReseedWithDefault

-

Derived Implementations

impl Copy for ReseedWithDefault

impl Clone for ReseedWithDefault

fn clone(&self) -> ReseedWithDefault

-

fn clone_from(&mut self, source: &Self)1.0.0

+

Trait Implementations

impl<R: Rng + Default> Reseeder<R> for ReseedWithDefault
[src]

+

fn reseed(&mut self, rng: &mut R)

+

impl Default for ReseedWithDefault
[src]

+

fn default() -> ReseedWithDefault

+

Derived Implementations

impl Copy for ReseedWithDefault
[src]

+

impl Clone for ReseedWithDefault
[src]

+

fn clone(&self) -> ReseedWithDefault

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/rand/reseeding/struct.ReseedingRng.html b/rand/reseeding/struct.ReseedingRng.html index 381b1c8..ba9f26d 100644 --- a/rand/reseeding/struct.ReseedingRng.html +++ b/rand/reseeding/struct.ReseedingRng.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub struct ReseedingRng<R, Rsdr> {
     pub reseeder: Rsdr,
     // some fields omitted
@@ -56,7 +56,8 @@ has generated a certain number of random bytes.

Fields

reseeder

Controls the behaviour when reseeding the RNG.

-

Methods

impl<R: Rng, Rsdr: Reseeder<R>> ReseedingRng<R, Rsdr>

fn new(rng: R, generation_threshold: u64, reseeder: Rsdr) -> ReseedingRng<R, Rsdr>

+

Methods

impl<R: Rng, Rsdr: Reseeder<R>> ReseedingRng<R, Rsdr>
[src]

+

fn new(rng: R, generation_threshold: u64, reseeder: Rsdr) -> ReseedingRng<R, Rsdr>

Create a new ReseedingRng with the given parameters.

Arguments

@@ -68,7 +69,8 @@ has generated a certain number of random bytes.

fn reseed_if_necessary(&mut self)

Reseed the internal RNG if the number of bytes that have been generated exceed the threshold.

-

Trait Implementations

impl<R: Rng, Rsdr: Reseeder<R>> Rng for ReseedingRng<R, Rsdr>

fn next_u32(&mut self) -> u32

+

Trait Implementations

impl<R: Rng, Rsdr: Reseeder<R>> Rng for ReseedingRng<R, Rsdr>
[src]

+

fn next_u32(&mut self) -> u32

fn next_u64(&mut self) -> u64

fn fill_bytes(&mut self, dest: &mut [u8])

fn next_f32(&mut self) -> f32

@@ -80,7 +82,8 @@ generated exceed the threshold.

fn gen_ascii_chars<'a>(&'a mut self) -> AsciiGenerator<'a, Self> where Self: Sized

fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> where Self: Sized

fn shuffle<T>(&mut self, values: &mut [T]) where Self: Sized

-

impl<S, R: SeedableRng<S>, Rsdr: Reseeder<R> + Default> SeedableRng<(Rsdr, S)> for ReseedingRng<R, Rsdr>

fn reseed(&mut self, (rsdr, seed): (Rsdr, S))

+

impl<S, R: SeedableRng<S>, Rsdr: Reseeder<R> + Default> SeedableRng<(Rsdr, S)> for ReseedingRng<R, Rsdr>
[src]

+

fn reseed(&mut self, (rsdr, seed): (Rsdr, S))

fn from_seed((rsdr, seed): (Rsdr, S)) -> ReseedingRng<R, Rsdr>

Create a new ReseedingRng from the given reseeder and seed. This uses a default value for generation_threshold.

diff --git a/rand/reseeding/trait.Reseeder.html b/rand/reseeding/trait.Reseeder.html index 26aef7d..17d8b4b 100644 --- a/rand/reseeding/trait.Reseeder.html +++ b/rand/reseeding/trait.Reseeder.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub trait Reseeder<R> {
     fn reseed(&mut self, rng: &mut R);
 }

Something that can be used to reseed an RNG via ReseedingRng.

@@ -66,7 +66,7 @@ } } fn main() { - let rsdr = TickTockReseeder { tick: true }; + let rsdr = TickTockReseeder { tick: true }; let inner = StdRng::new().unwrap(); let mut rng = ReseedingRng::new(inner, 10, rsdr); diff --git a/rand/struct.AsciiGenerator.html b/rand/struct.AsciiGenerator.html index bcd4c67..3857576 100644 --- a/rand/struct.AsciiGenerator.html +++ b/rand/struct.AsciiGenerator.html @@ -47,60 +47,61 @@ [−] - [src] + [src] 
pub struct AsciiGenerator<'a, R: 'a> {
     // some fields omitted
 }

Iterator which will continuously generate random ascii characters.

This iterator is created via the gen_ascii_chars method on Rng.

-

Trait Implementations

impl<'a, R: Rng> Iterator for AsciiGenerator<'a, R>

type Item = char

+

Trait Implementations

impl<'a, R: Rng> Iterator for AsciiGenerator<'a, R>
[src]

+

type Item = char

fn next(&mut self) -> Option<char>

-

fn size_hint(&self) -> (usize, Option<usize>)1.0.0

-

fn count(self) -> usize1.0.0

-

fn last(self) -> Option<Self::Item>1.0.0

-

fn nth(&mut self, n: usize) -> Option<Self::Item>1.0.0

-

fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where U: IntoIterator<Item=Self::Item>1.0.0

-

fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where U: IntoIterator1.0.0

-

fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B1.0.0

-

fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool1.0.0

-

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>1.0.0

-

fn enumerate(self) -> Enumerate<Self>1.0.0

-

fn peekable(self) -> Peekable<Self>1.0.0

-

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool1.0.0

-

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool1.0.0

-

fn skip(self, n: usize) -> Skip<Self>1.0.0

-

fn take(self, n: usize) -> Take<Self>1.0.0

-

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>1.0.0

-

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: IntoIterator1.0.0

-

fn fuse(self) -> Fuse<Self>1.0.0

-

fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item) -> ()1.0.0

-

fn by_ref(&mut self) -> &mut Self1.0.0

-

fn collect<B>(self) -> B where B: FromIterator<Self::Item>1.0.0

-

fn partition<B, F>(self, f: F) -> (B, B) where F: FnMut(&Self::Item) -> bool, B: Default + Extend<Self::Item>1.0.0

-

fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B1.0.0

-

fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool1.0.0

-

fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool1.0.0

-

fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool1.0.0

-

fn position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool1.0.0

-

fn rposition<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator1.0.0

-

fn max(self) -> Option<Self::Item> where Self::Item: Ord1.0.0

-

fn min(self) -> Option<Self::Item> where Self::Item: Ord1.0.0

-

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, B: Ord1.6.0

-

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, B: Ord1.6.0

-

fn rev(self) -> Rev<Self> where Self: DoubleEndedIterator1.0.0

-

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where FromB: Default + Extend<B>, FromA: Default + Extend<A>, Self: Iterator<Item=(A, B)>1.0.0

-

fn cloned<'a, T>(self) -> Cloned<Self> where T: 'a + Clone, Self: Iterator<Item=&'a T>1.0.0

-

fn cycle(self) -> Cycle<Self> where Self: Clone1.0.0

+

fn size_hint(&self) -> (usize, Option<usize>)
1.0.0

+

fn count(self) -> usize
1.0.0

+

fn last(self) -> Option<Self::Item>
1.0.0

+

fn nth(&mut self, n: usize) -> Option<Self::Item>
1.0.0

+

fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where U: IntoIterator<Item=Self::Item>
1.0.0

+

fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where U: IntoIterator
1.0.0

+

fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B
1.0.0

+

fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool
1.0.0

+

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>
1.0.0

+

fn enumerate(self) -> Enumerate<Self>
1.0.0

+

fn peekable(self) -> Peekable<Self>
1.0.0

+

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool
1.0.0

+

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool
1.0.0

+

fn skip(self, n: usize) -> Skip<Self>
1.0.0

+

fn take(self, n: usize) -> Take<Self>
1.0.0

+

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>
1.0.0

+

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: IntoIterator
1.0.0

+

fn fuse(self) -> Fuse<Self>
1.0.0

+

fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item) -> ()
1.0.0

+

fn by_ref(&mut self) -> &mut Self
1.0.0

+

fn collect<B>(self) -> B where B: FromIterator<Self::Item>
1.0.0

+

fn partition<B, F>(self, f: F) -> (B, B) where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool
1.0.0

+

fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B
1.0.0

+

fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool
1.0.0

+

fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool
1.0.0

+

fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool
1.0.0

+

fn position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool
1.0.0

+

fn rposition<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator
1.0.0

+

fn max(self) -> Option<Self::Item> where Self::Item: Ord
1.0.0

+

fn min(self) -> Option<Self::Item> where Self::Item: Ord
1.0.0

+

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B
1.6.0

+

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B
1.6.0

+

fn rev(self) -> Rev<Self> where Self: DoubleEndedIterator
1.0.0

+

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Iterator<Item=(A, B)>
1.0.0

+

fn cloned<'a, T>(self) -> Cloned<Self> where Self: Iterator<Item=&'a T>, T: 'a + Clone
1.0.0

+

fn cycle(self) -> Cycle<Self> where Self: Clone
1.0.0

fn sum<S>(self) -> S where S: Add<Self::Item, Output=S> + Zero

fn product<P>(self) -> P where P: Mul<Self::Item, Output=P> + One

-

fn cmp<I>(self, other: I) -> Ordering where I: IntoIterator<Item=Self::Item>, Self::Item: Ord1.5.0

-

fn partial_cmp<I>(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<I::Item>1.5.0

-

fn eq<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>1.5.0

-

fn ne<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>1.5.0

-

fn lt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>1.5.0

-

fn le<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>1.5.0

-

fn gt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>1.5.0

-

fn ge<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>1.5.0

+

fn cmp<I>(self, other: I) -> Ordering where I: IntoIterator<Item=Self::Item>, Self::Item: Ord
1.5.0

+

fn partial_cmp<I>(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<I::Item>
1.5.0

+

fn eq<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>
1.5.0

+

fn ne<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>
1.5.0

+

fn lt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>
1.5.0

+

fn le<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>
1.5.0

+

fn gt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>
1.5.0

+

fn ge<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>
1.5.0

diff --git a/rand/struct.Closed01.html b/rand/struct.Closed01.html index 01d61dc..e8e5145 100644 --- a/rand/struct.Closed01.html +++ b/rand/struct.Closed01.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub struct Closed01<F>(pub F);

A wrapper for generating floating point numbers uniformly in the closed interval [0,1] (including both endpoints).

@@ -61,8 +61,10 @@ closed interval [0,1] (including both endpoints).

let Closed01(val) = random::<Closed01<f32>>(); println!("f32 from [0,1]: {}", val); -

Trait Implementations

impl Rand for Closed01<f64>

fn rand<R: Rng>(rng: &mut R) -> Closed01<f64>

-

impl Rand for Closed01<f32>

fn rand<R: Rng>(rng: &mut R) -> Closed01<f32>

+

Trait Implementations

impl Rand for Closed01<f64>
[src]

+

fn rand<R: Rng>(rng: &mut R) -> Closed01<f64>

+

impl Rand for Closed01<f32>
[src]

+

fn rand<R: Rng>(rng: &mut R) -> Closed01<f32>

diff --git a/rand/struct.Generator.html b/rand/struct.Generator.html index 2fce752..c640f35 100644 --- a/rand/struct.Generator.html +++ b/rand/struct.Generator.html @@ -47,60 +47,61 @@ [−] - [src] + [src] 
pub struct Generator<'a, T, R: 'a> {
     // some fields omitted
 }

Iterator which will generate a stream of random items.

This iterator is created via the gen_iter method on Rng.

-

Trait Implementations

impl<'a, T: Rand, R: Rng> Iterator for Generator<'a, T, R>

type Item = T

+

Trait Implementations

impl<'a, T: Rand, R: Rng> Iterator for Generator<'a, T, R>
[src]

+

type Item = T

fn next(&mut self) -> Option<T>

-

fn size_hint(&self) -> (usize, Option<usize>)1.0.0

-

fn count(self) -> usize1.0.0

-

fn last(self) -> Option<Self::Item>1.0.0

-

fn nth(&mut self, n: usize) -> Option<Self::Item>1.0.0

-

fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where U: IntoIterator<Item=Self::Item>1.0.0

-

fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where U: IntoIterator1.0.0

-

fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B1.0.0

-

fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool1.0.0

-

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>1.0.0

-

fn enumerate(self) -> Enumerate<Self>1.0.0

-

fn peekable(self) -> Peekable<Self>1.0.0

-

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool1.0.0

-

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool1.0.0

-

fn skip(self, n: usize) -> Skip<Self>1.0.0

-

fn take(self, n: usize) -> Take<Self>1.0.0

-

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>1.0.0

-

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: IntoIterator1.0.0

-

fn fuse(self) -> Fuse<Self>1.0.0

-

fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item) -> ()1.0.0

-

fn by_ref(&mut self) -> &mut Self1.0.0

-

fn collect<B>(self) -> B where B: FromIterator<Self::Item>1.0.0

-

fn partition<B, F>(self, f: F) -> (B, B) where F: FnMut(&Self::Item) -> bool, B: Default + Extend<Self::Item>1.0.0

-

fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B1.0.0

-

fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool1.0.0

-

fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool1.0.0

-

fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool1.0.0

-

fn position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool1.0.0

-

fn rposition<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator1.0.0

-

fn max(self) -> Option<Self::Item> where Self::Item: Ord1.0.0

-

fn min(self) -> Option<Self::Item> where Self::Item: Ord1.0.0

-

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, B: Ord1.6.0

-

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, B: Ord1.6.0

-

fn rev(self) -> Rev<Self> where Self: DoubleEndedIterator1.0.0

-

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where FromB: Default + Extend<B>, FromA: Default + Extend<A>, Self: Iterator<Item=(A, B)>1.0.0

-

fn cloned<'a, T>(self) -> Cloned<Self> where T: 'a + Clone, Self: Iterator<Item=&'a T>1.0.0

-

fn cycle(self) -> Cycle<Self> where Self: Clone1.0.0

+

fn size_hint(&self) -> (usize, Option<usize>)
1.0.0

+

fn count(self) -> usize
1.0.0

+

fn last(self) -> Option<Self::Item>
1.0.0

+

fn nth(&mut self, n: usize) -> Option<Self::Item>
1.0.0

+

fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where U: IntoIterator<Item=Self::Item>
1.0.0

+

fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where U: IntoIterator
1.0.0

+

fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B
1.0.0

+

fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool
1.0.0

+

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>
1.0.0

+

fn enumerate(self) -> Enumerate<Self>
1.0.0

+

fn peekable(self) -> Peekable<Self>
1.0.0

+

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool
1.0.0

+

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool
1.0.0

+

fn skip(self, n: usize) -> Skip<Self>
1.0.0

+

fn take(self, n: usize) -> Take<Self>
1.0.0

+

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>
1.0.0

+

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: IntoIterator
1.0.0

+

fn fuse(self) -> Fuse<Self>
1.0.0

+

fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item) -> ()
1.0.0

+

fn by_ref(&mut self) -> &mut Self
1.0.0

+

fn collect<B>(self) -> B where B: FromIterator<Self::Item>
1.0.0

+

fn partition<B, F>(self, f: F) -> (B, B) where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool
1.0.0

+

fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B
1.0.0

+

fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool
1.0.0

+

fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool
1.0.0

+

fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool
1.0.0

+

fn position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool
1.0.0

+

fn rposition<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator
1.0.0

+

fn max(self) -> Option<Self::Item> where Self::Item: Ord
1.0.0

+

fn min(self) -> Option<Self::Item> where Self::Item: Ord
1.0.0

+

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B
1.6.0

+

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B
1.6.0

+

fn rev(self) -> Rev<Self> where Self: DoubleEndedIterator
1.0.0

+

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Iterator<Item=(A, B)>
1.0.0

+

fn cloned<'a, T>(self) -> Cloned<Self> where Self: Iterator<Item=&'a T>, T: 'a + Clone
1.0.0

+

fn cycle(self) -> Cycle<Self> where Self: Clone
1.0.0

fn sum<S>(self) -> S where S: Add<Self::Item, Output=S> + Zero

fn product<P>(self) -> P where P: Mul<Self::Item, Output=P> + One

-

fn cmp<I>(self, other: I) -> Ordering where I: IntoIterator<Item=Self::Item>, Self::Item: Ord1.5.0

-

fn partial_cmp<I>(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<I::Item>1.5.0

-

fn eq<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>1.5.0

-

fn ne<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>1.5.0

-

fn lt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>1.5.0

-

fn le<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>1.5.0

-

fn gt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>1.5.0

-

fn ge<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>1.5.0

+

fn cmp<I>(self, other: I) -> Ordering where I: IntoIterator<Item=Self::Item>, Self::Item: Ord
1.5.0

+

fn partial_cmp<I>(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<I::Item>
1.5.0

+

fn eq<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>
1.5.0

+

fn ne<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>
1.5.0

+

fn lt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>
1.5.0

+

fn le<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>
1.5.0

+

fn gt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>
1.5.0

+

fn ge<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>
1.5.0

diff --git a/rand/struct.Open01.html b/rand/struct.Open01.html index 5afc914..9f294eb 100644 --- a/rand/struct.Open01.html +++ b/rand/struct.Open01.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub struct Open01<F>(pub F);

A wrapper for generating floating point numbers uniformly in the open interval (0,1) (not including either endpoint).

@@ -61,8 +61,10 @@ open interval (0,1) (not including either endpoint).

let Open01(val) = random::<Open01<f32>>(); println!("f32 from (0,1): {}", val); -

Trait Implementations

impl Rand for Open01<f64>

fn rand<R: Rng>(rng: &mut R) -> Open01<f64>

-

impl Rand for Open01<f32>

fn rand<R: Rng>(rng: &mut R) -> Open01<f32>

+

Trait Implementations

impl Rand for Open01<f64>
[src]

+

fn rand<R: Rng>(rng: &mut R) -> Open01<f64>

+

impl Rand for Open01<f32>
[src]

+

fn rand<R: Rng>(rng: &mut R) -> Open01<f32>

diff --git a/rand/struct.StdRng.html b/rand/struct.StdRng.html index 0dd293c..ee6597a 100644 --- a/rand/struct.StdRng.html +++ b/rand/struct.StdRng.html @@ -47,12 +47,13 @@ [−] - [src] + [src] 
pub struct StdRng {
     // some fields omitted
 }

The standard RNG. This is designed to be efficient on the current platform.

-

Methods

impl StdRng

fn new() -> Result<StdRng>

+

Methods

impl StdRng
[src]

+

fn new() -> Result<StdRng>

Create a randomly seeded instance of StdRng.

This is a very expensive operation as it has to read @@ -64,7 +65,8 @@ appropriate.

Reading the randomness from the OS may fail, and any error is propagated via the io::Result return value.

-

Trait Implementations

impl Rng for StdRng

fn next_u32(&mut self) -> u32

+

Trait Implementations

impl Rng for StdRng
[src]

+

fn next_u32(&mut self) -> u32

fn next_u64(&mut self) -> u64

fn next_f32(&mut self) -> f32

fn next_f64(&mut self) -> f64

@@ -76,11 +78,14 @@ propagated via the io::Result return value.

fn gen_ascii_chars<'a>(&'a mut self) -> AsciiGenerator<'a, Self> where Self: Sized

fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> where Self: Sized

fn shuffle<T>(&mut self, values: &mut [T]) where Self: Sized

-

impl<'a> SeedableRng<&'a [usize]> for StdRng

fn reseed(&mut self, seed: &'a [usize])

+

impl<'a> SeedableRng<&'a [usize]> for StdRng
[src]

+

fn reseed(&mut self, seed: &'a [usize])

fn from_seed(seed: &'a [usize]) -> StdRng

-

Derived Implementations

impl Clone for StdRng

fn clone(&self) -> StdRng

-

fn clone_from(&mut self, source: &Self)1.0.0

-

impl Copy for StdRng

+

Derived Implementations

impl Clone for StdRng
[src]

+

fn clone(&self) -> StdRng

+

fn clone_from(&mut self, source: &Self)
1.0.0

+

impl Copy for StdRng
[src]

+
diff --git a/rand/struct.ThreadRng.html b/rand/struct.ThreadRng.html index ad5fe87..0910722 100644 --- a/rand/struct.ThreadRng.html +++ b/rand/struct.ThreadRng.html @@ -47,11 +47,12 @@ [−] - [src] + [src] 
pub struct ThreadRng {
     // some fields omitted
 }

The thread-local RNG.

-

Trait Implementations

impl Rng for ThreadRng

fn next_u32(&mut self) -> u32

+

Trait Implementations

impl Rng for ThreadRng
[src]

+

fn next_u32(&mut self) -> u32

fn next_u64(&mut self) -> u64

fn fill_bytes(&mut self, bytes: &mut [u8])

fn next_f32(&mut self) -> f32

@@ -63,8 +64,9 @@

fn gen_ascii_chars<'a>(&'a mut self) -> AsciiGenerator<'a, Self> where Self: Sized

fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> where Self: Sized

fn shuffle<T>(&mut self, values: &mut [T]) where Self: Sized

-

Derived Implementations

impl Clone for ThreadRng

fn clone(&self) -> ThreadRng

-

fn clone_from(&mut self, source: &Self)1.0.0

+

Derived Implementations

impl Clone for ThreadRng
[src]

+

fn clone(&self) -> ThreadRng

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/rand/struct.XorShiftRng.html b/rand/struct.XorShiftRng.html index 1b316ac..5282811 100644 --- a/rand/struct.XorShiftRng.html +++ b/rand/struct.XorShiftRng.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub struct XorShiftRng {
     // some fields omitted
 }

An Xorshift[1] random number @@ -60,14 +60,16 @@ requirements, use a more secure one such as IsaacRng or OsRng

[1]: Marsaglia, George (July 2003). "Xorshift RNGs". Journal of Statistical Software. Vol. 8 (Issue 14).

-

Methods

impl XorShiftRng

fn new_unseeded() -> XorShiftRng

+

Methods

impl XorShiftRng
[src]

+

fn new_unseeded() -> XorShiftRng

Creates a new XorShiftRng instance which is not seeded.

The initial values of this RNG are constants, so all generators created by this function will yield the same stream of random numbers. It is highly recommended that this is created through SeedableRng instead of this function

-

Trait Implementations

impl Rng for XorShiftRng

fn next_u32(&mut self) -> u32

+

Trait Implementations

impl Rng for XorShiftRng
[src]

+

fn next_u32(&mut self) -> u32

fn next_u64(&mut self) -> u64

fn next_f32(&mut self) -> f32

fn next_f64(&mut self) -> f64

@@ -79,13 +81,16 @@ this function

fn gen_ascii_chars<'a>(&'a mut self) -> AsciiGenerator<'a, Self> where Self: Sized

fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> where Self: Sized

fn shuffle<T>(&mut self, values: &mut [T]) where Self: Sized

-

impl SeedableRng<[u32; 4]> for XorShiftRng

fn reseed(&mut self, seed: [u32; 4])

+

impl SeedableRng<[u32; 4]> for XorShiftRng
[src]

+

fn reseed(&mut self, seed: [u32; 4])

Reseed an XorShiftRng. This will panic if seed is entirely 0.

fn from_seed(seed: [u32; 4]) -> XorShiftRng

Create a new XorShiftRng. This will panic if seed is entirely 0.

-

impl Rand for XorShiftRng

fn rand<R: Rng>(rng: &mut R) -> XorShiftRng

-

Derived Implementations

impl Clone for XorShiftRng

fn clone(&self) -> XorShiftRng

-

fn clone_from(&mut self, source: &Self)1.0.0

+

impl Rand for XorShiftRng
[src]

+

fn rand<R: Rng>(rng: &mut R) -> XorShiftRng

+

Derived Implementations

impl Clone for XorShiftRng
[src]

+

fn clone(&self) -> XorShiftRng

+

fn clone_from(&mut self, source: &Self)
1.0.0

diff --git a/rand/trait.Rand.html b/rand/trait.Rand.html index 39b0b8d..64477fa 100644 --- a/rand/trait.Rand.html +++ b/rand/trait.Rand.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
pub trait Rand: Sized {
     fn rand<R: Rng>(rng: &mut R) -> Self;
 }

A type that can be randomly generated using an Rng.

@@ -95,38 +95,51 @@ randomness.

  • impl<A: Rand, B: Rand, C: Rand, D: Rand, E: Rand, F: Rand, G: Rand, H: Rand, I: Rand, J: Rand> Rand for (A, B, C, D, E, F, G, H, I, J)
  • impl<A: Rand, B: Rand, C: Rand, D: Rand, E: Rand, F: Rand, G: Rand, H: Rand, I: Rand, J: Rand, K: Rand> Rand for (A, B, C, D, E, F, G, H, I, J, K)
  • impl<A: Rand, B: Rand, C: Rand, D: Rand, E: Rand, F: Rand, G: Rand, H: Rand, I: Rand, J: Rand, K: Rand, L: Rand> Rand for (A, B, C, D, E, F, G, H, I, J, K, L)
    • -
  • impl<T> Rand for [T; $n - 1]
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • -
  • impl<T> Rand for [T; $n - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 + - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1]
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 + - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 + - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 + - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 + - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 + - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 + - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 + - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 + - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 + - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 + - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 + - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 + - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1 - 1] where T: Rand
    • +
  • impl<T> Rand for [T; 32 - 1] where T: Rand
  • impl<T> Rand for [T; 32] where T: Rand
  • impl<T: Rand> Rand for Option<T>
  • impl Rand for XorShiftRng
    • diff --git a/rand/trait.Rng.html b/rand/trait.Rng.html index f42df51..7049a62 100644 --- a/rand/trait.Rng.html +++ b/rand/trait.Rng.html @@ -47,7 +47,7 @@ [−] - [src] + [src] 
    pub trait Rng {
     fn next_u32(&mut self) -> u32;
 
diff --git a/rand/trait.SeedableRng.html b/rand/trait.SeedableRng.html
index 7deffdf..bb80827 100644
--- a/rand/trait.SeedableRng.html
+++ b/rand/trait.SeedableRng.html
@@ -47,7 +47,7 @@
                    
                        [−]
                    
-               [src]
+               [src]
 
    pub trait SeedableRng<Seed>: Rng {
     fn reseed(&mut self, Seed);
     fn from_seed(seed: Seed) -> Self;
diff --git a/rustdoc.css b/rustdoc.css
index c07871a..4d65b91 100644
--- a/rustdoc.css
+++ b/rustdoc.css
@@ -97,6 +97,7 @@ h1, h2, h3:not(.impl):not(.method):not(.type):not(.tymethod), h4:not(.method):no
 h1.fqn {
     border-bottom: 1px dashed;
     margin-top: 0;
+    position: relative;
 }
 h2, h3:not(.impl):not(.method):not(.type):not(.tymethod), h4:not(.method):not(.type):not(.tymethod) {
     border-bottom: 1px solid;
@@ -105,6 +106,7 @@ h3.impl, h3.method, h4.method, h3.type, h4.type {
     font-weight: 600;
     margin-top: 10px;
     margin-bottom: 10px;
+    position: relative;
 }
 h3.impl, h3.method, h3.type {
     margin-top: 15px;
@@ -265,20 +267,39 @@ nav.sub {
 
 .content .out-of-band {
     font-size: 23px;
-    width: 40%;
     margin: 0px;
     padding: 0px;
     text-align: right;
     display: inline-block;
+    font-weight: normal;
+    position: absolute;
+    right: 0;
+}
+
+h3.impl > .out-of-band {
+    font-size: 21px;
+}
+
+h4 > code, h3 > code {
+    position: inherit;
+}
+
+.in-band, code {
+    z-index: 5;
 }
 
 .content .in-band {
-    width: 60%;
     margin: 0px;
     padding: 0px;
     display: inline-block;
 }
 
+#main { position: relative; }
+#main > .since {
+    top: inherit;
+    font-family: "Fira Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
+}
+
 .content table {
     border-spacing: 0 5px;
     border-collapse: separate;
@@ -498,11 +519,13 @@ em.stab p {
     opacity: 0.65;
 }
 
-span.since {
-    float: right;
+.since {
     font-weight: normal;
     font-size: initial;
     color: grey;
+    position: absolute;
+    right: 0;
+    top: 0;
 }
 
 .variants_table {
@@ -597,7 +620,19 @@ a.test-arrow {
     color: #999;
 }
 
+.ghost {
+    display: none;
+}
 
+.ghost + .since {
+    position: initial;
+    display: table-cell;
+}
+
+.since + .srclink {
+    display: table-cell;
+    padding-left: 10px;
+}
 
 /* Media Queries */
 
diff --git a/search-index.js b/search-index.js
index 18a1ce6..5bfb191 100644
--- a/search-index.js
+++ b/search-index.js
@@ -1,3 +1,9 @@
 var searchIndex = {};
-searchIndex["pumpkin"] = {"doc":"A crate for generating large, cryptographically secure prime numbers.\n`Primes` are seeded from the operating system's main source of entropy,\nensuring proper randomness.","items":[[3,"Prime","pumpkin","A cryptographically secure prime number.",null,null],[11,"fmt","","",0,{"inputs":[{"name":"prime"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",0,{"inputs":[{"name":"prime"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",0,{"inputs":[{"name":"prime"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",0,{"inputs":[{"name":"prime"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",0,{"inputs":[{"name":"prime"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",0,{"inputs":[{"name":"prime"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"add","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"add","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"sub","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"sub","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"mul","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"mul","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"div","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"div","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"rem","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"rem","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"bitand","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"bitand","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"bitor","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"bitor","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"bitxor","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"bitxor","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"new","","Constructs a new `Prime` with a size of `bit_length` bits.",0,{"inputs":[{"name":"usize"}],"output":{"name":"prime"}}],[11,"from_rng","","Constructs a new `Prime` with the size of `bit_length` bits, sourced\nfrom an already-created `OsRng`. Not that you can **ONLY** use an\n`OsRng`, as it uses the operating system's secure source of entropy.",0,{"inputs":[{"name":"usize"},{"name":"osrng"}],"output":{"name":"prime"}}]],"paths":[[3,"Prime"]]};
+searchIndex["pumpkin"] = {"doc":"A crate for generating large, cryptographically secure prime numbers.\n`Primes` are seeded from the operating system's main source of entropy,\nensuring proper randomness.","items":[[3,"Prime","pumpkin","A cryptographically secure prime number.",null,null],[12,"0","","",0,null],[11,"fmt","","",0,{"inputs":[{"name":"prime"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",0,{"inputs":[{"name":"prime"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",0,{"inputs":[{"name":"prime"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",0,{"inputs":[{"name":"prime"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",0,{"inputs":[{"name":"prime"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",0,{"inputs":[{"name":"prime"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"add","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"add","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"sub","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"sub","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"mul","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"mul","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"div","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"div","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"rem","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"rem","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"bitand","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"bitand","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"bitor","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"bitor","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"bitxor","","",0,{"inputs":[{"name":"prime"},{"name":"self"}],"output":{"name":"prime"}}],[11,"bitxor","","",0,{"inputs":[{"name":"prime"},{"name":"int"}],"output":{"name":"prime"}}],[11,"new","","Constructs a new `Prime` with a size of `bit_length` bits.",0,{"inputs":[{"name":"usize"}],"output":{"name":"prime"}}],[11,"from_rng","","Constructs a new `Prime` with the size of `bit_length` bits, sourced\nfrom an already-created `OsRng`. Not that you can **ONLY** use an\n`OsRng`, as it uses the operating system's secure source of entropy.",0,{"inputs":[{"name":"usize"},{"name":"osrng"}],"output":{"name":"prime"}}]],"paths":[[3,"Prime"]]};
+searchIndex["ramp"] = {"doc":"","items":[[0,"ll","ramp","This module provides the low-level operations for working with arbitrary precision numbers.",null,null],[5,"shl","ramp::ll","Performs a bit-shift of the limbs in {xp, xs}, left by `cnt` bits storing the result in {rp,\nrs}. The top-most shifted bits are returned.",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"i32"},{"name":"u32"}],"output":{"name":"limb"}}],[5,"shr","","Performs a bit-shift of the limbs in {xp, xs}, right by `cnt` bits storing the result in {rp,\nrs}. The bottom-most shifted bits are returned.",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"i32"},{"name":"u32"}],"output":{"name":"limb"}}],[5,"and_n","","Performs a bitwise "and" (`&`) of the n least signficant limbs of `xp` and `yp`, storing the\nresult in `wp`",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"limbs"},{"name":"i32"}],"output":null}],[5,"and_not_n","","Performs a bitwise and of the n least signficant limbs of `xp` and `yp`, with the limbs of `yp`\nbeing first inverted. The result is stored in `wp`.",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"limbs"},{"name":"i32"}],"output":null}],[5,"nand_n","","Performs a bitwise "nand" of the n least signficant limbs of `xp` and `yp`, storing the\nresult in `wp`",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"limbs"},{"name":"i32"}],"output":null}],[5,"or_n","","Performs a bitwise "or" (`|`) of the n least signficant limbs of `xp` and `yp`, storing the\nresult in `wp`",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"limbs"},{"name":"i32"}],"output":null}],[5,"or_not_n","","Performs a bitwise "or" of the n least signficant limbs of `xp` and `yp`, with the limbs of `yp`\nbeing first inverted. The result is stored in `wp`.",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"limbs"},{"name":"i32"}],"output":null}],[5,"nor_n","","Performs a bitwise "nor" of the n least signficant limbs of `xp` and `yp`, storing the\nresult in `wp`",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"limbs"},{"name":"i32"}],"output":null}],[5,"xor_n","","Performs a bitwise "xor" (`^`) of the n least signficant limbs of `xp` and `yp`, storing the\nresult in `wp`",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"limbs"},{"name":"i32"}],"output":null}],[5,"not","","Performs a bitwise inversion ("not") of the n least signficant limbs of `xp`, storing the\nresult in `wp`",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"i32"}],"output":null}],[5,"scan_1","","Scans for the first 1 bit starting from the least-significant bit the the most, returning\nthe bit index.",null,{"inputs":[{"name":"limbs"},{"name":"i32"}],"output":{"name":"u32"}}],[5,"scan_0","","Scans for the first 0 bit starting from the least-significant bit the the most, returning\nthe bit index.",null,{"inputs":[{"name":"limbs"},{"name":"i32"}],"output":{"name":"u32"}}],[5,"twos_complement","","Computes the two's complement of the `xs` least significant words\nof `xp`. The result is stored the result in `wp`, and a carry is\nreturned, if there is one.",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"i32"}],"output":{"name":"limb"}}],[5,"add_n","","Adds the `n` least signficant limbs of `xp` and `yp`, storing the result in {wp, n}.\nIf there was a carry, it is returned.",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"limbs"},{"name":"i32"}],"output":{"name":"limb"}}],[5,"sub_n","","Subtracts the `n` least signficant limbs of `yp` from `xp`, storing the result in {wp, n}.\nIf there was a borrow from a higher-limb (i.e., the result would be negative), it is returned.",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"limbs"},{"name":"i32"}],"output":{"name":"limb"}}],[5,"add","","",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"i32"},{"name":"limbs"},{"name":"i32"}],"output":{"name":"limb"}}],[5,"sub","","",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"i32"},{"name":"limbs"},{"name":"i32"}],"output":{"name":"limb"}}],[5,"add_1","","",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"i32"},{"name":"limb"}],"output":{"name":"limb"}}],[5,"sub_1","","",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"i32"},{"name":"limb"}],"output":{"name":"limb"}}],[5,"incr","","",null,{"inputs":[{"name":"limbsmut"},{"name":"limb"}],"output":null}],[5,"decr","","",null,{"inputs":[{"name":"limbsmut"},{"name":"limb"}],"output":null}],[5,"addmul_1","","Multiplies the `n` least-signficiant digits of `xp` by `vl` and adds them to the `n`\nleast-significant digits of `wp`. Returns the highest limb of the result.",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"i32"},{"name":"limb"}],"output":{"name":"limb"}}],[5,"submul_1","","Multiplies the `n` least-signficiant digits of `xp` by `vl` and subtracts them from the `n`\nleast-significant digits of `wp`. Returns the highest limb of the result, adjust for borrow.",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"i32"},{"name":"limb"}],"output":{"name":"limb"}}],[5,"mul_1","","Multiplies the `n` least-significant limbs of `xp` by `vl` storing the `n` least-significant\nlimbs of the product in `{wp, n}`.",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"i32"},{"name":"limb"}],"output":{"name":"limb"}}],[5,"mul","","Multiplies `{xp, xs}` by `{yp, ys}`, storing the result to `{wp, xs + ys}`.",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"i32"},{"name":"limbs"},{"name":"i32"}],"output":null}],[5,"sqr","","Squares the number in `{xp, xs}` storing the result in `{wp, xs*2}`.\nThis is slightly more efficient than regular multiplication with both\ninputs the same.",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"i32"}],"output":null}],[5,"divrem_1","","Divides the `xs` least-significant limbs at `xp` by `d`, storing the result in {qp, qxn + xs}.",null,{"inputs":[{"name":"limbsmut"},{"name":"i32"},{"name":"limbs"},{"name":"i32"},{"name":"limb"}],"output":{"name":"limb"}}],[5,"divrem_2","","",null,{"inputs":[{"name":"limbsmut"},{"name":"i32"},{"name":"limbsmut"},{"name":"i32"},{"name":"limbs"}],"output":{"name":"limb"}}],[5,"divrem","","Divides {np, ns} by {dp, ds}. If ns <= ds, the quotient is stored in {qp, 1}, otherwise\nthe quotient is stored to {qp, (ns - ds) + 1}. The remainder is always stored to {rp, ds}.",null,{"inputs":[{"name":"limbsmut"},{"name":"limbsmut"},{"name":"limbs"},{"name":"i32"},{"name":"limbs"},{"name":"i32"}],"output":null}],[5,"gcd","","",null,{"inputs":[{"name":"limbsmut"},{"name":"limbsmut"},{"name":"i32"},{"name":"limbsmut"},{"name":"i32"}],"output":{"name":"i32"}}],[5,"overlap","","",null,{"inputs":[{"name":"limbsmut"},{"name":"i32"},{"name":"limbs"},{"name":"i32"}],"output":{"name":"bool"}}],[5,"same_or_separate","","",null,{"inputs":[{"name":"limbsmut"},{"name":"i32"},{"name":"limbs"},{"name":"i32"}],"output":{"name":"bool"}}],[5,"same_or_incr","","",null,{"inputs":[{"name":"limbsmut"},{"name":"i32"},{"name":"limbs"},{"name":"i32"}],"output":{"name":"bool"}}],[5,"same_or_decr","","",null,{"inputs":[{"name":"limbsmut"},{"name":"i32"},{"name":"limbs"},{"name":"i32"}],"output":{"name":"bool"}}],[5,"copy_incr","","Copies the `n` limbs from `src` to `dst` in an incremental fashion.",null,{"inputs":[{"name":"limbs"},{"name":"limbsmut"},{"name":"i32"}],"output":null}],[5,"copy_decr","","Copies the `n` limbs from `src` to `dst` in a decremental fashion.",null,{"inputs":[{"name":"limbs"},{"name":"limbsmut"},{"name":"i32"}],"output":null}],[5,"copy_rest","","Copies the `n - start` limbs from `src + start` to `dst + start`",null,{"inputs":[{"name":"limbs"},{"name":"limbsmut"},{"name":"i32"},{"name":"i32"}],"output":null}],[5,"normalize","","Returns the size of the integer pointed to by `p` such that the most\nsignificant limb is non-zero.",null,{"inputs":[{"name":"limbs"},{"name":"i32"}],"output":{"name":"i32"}}],[5,"divide_by_zero","","Called when a divide by zero occurs.",null,{"inputs":[],"output":null}],[5,"is_zero","","Checks that all `nn` limbs in `np` are zero",null,{"inputs":[{"name":"limbs"},{"name":"i32"}],"output":{"name":"bool"}}],[5,"zero","","",null,{"inputs":[{"name":"limbsmut"},{"name":"i32"}],"output":null}],[5,"cmp","","Compares the `n` least-significant limbs of `xp` and `yp`, returning whether\n{xp, n} is less than, equal to or greater than {yp, n}",null,{"inputs":[{"name":"limbs"},{"name":"limbs"},{"name":"i32"}],"output":{"name":"ordering"}}],[0,"pow","","",null,null],[5,"pow","ramp::ll::pow","Takes `{ap, an}` to the power of `exp` and stores the result to `wp`. `wp` is\nassumed to have enough space to store the result (which can be calculated using\n`num_pow_limbs`",null,{"inputs":[{"name":"limbsmut"},{"name":"limbs"},{"name":"i32"},{"name":"u32"}],"output":null}],[5,"num_pow_limbs","","Calculates the number of limbs required to store the result of taking\n`{xp, xn}` to the power of `exp`",null,{"inputs":[{"name":"limbs"},{"name":"i32"},{"name":"u32"}],"output":{"name":"i32"}}],[0,"base","ramp::ll","Base conversion utilities",null,null],[5,"num_base_digits","ramp::ll::base","",null,{"inputs":[{"name":"limbs"},{"name":"i32"},{"name":"u32"}],"output":{"name":"usize"}}],[5,"base_digits_to_len","","",null,{"inputs":[{"name":"usize"},{"name":"u32"}],"output":{"name":"usize"}}],[5,"to_base","","Converts `nn` limbs at `np` to the given base, storing the output in `out`. `out` is assumed to\nhave enough space for the entire digit. The output is stored from most-significant digit to least.",null,{"inputs":[{"name":"u32"},{"name":"limbs"},{"name":"i32"},{"name":"f"}],"output":null}],[5,"from_base","","Converts the base `base` bytestring {bp, bs}, storing the limbs in `out`. `out` is assumed to\nhave enough space to store the result.",null,null],[0,"limb","ramp::ll","",null,null],[3,"Limb","ramp::ll::limb","Helper newtype for operations.",null,null],[12,"0","","",0,null],[5,"add_2","","Performs the two-word addition (ah, al) + (bh, bl), ignoring any overflow.",null,null],[5,"sub_2","","Performs the two-word subtraction (ah, al) - (bh, bl), ignoring any borrow.",null,null],[5,"div","","Divides the two-limb numerator `(nh, nl)` by `d`, returning a single-limb\nquotient, Q, and remainder, R, as (Q, R).",null,null],[5,"div_preinv","","Divides `(nh, nl)` by `d` using the inverted limb `dinv`. Returns the quotient, Q, and\nremainder, R, as (Q, R);",null,null],[6,"BaseInt","","",null,null],[11,"hash","","",0,null],[11,"cmp","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"ordering"}}],[11,"clone","","",0,{"inputs":[{"name":"limb"}],"output":{"name":"limb"}}],[18,"BITS","ramp::ll","",0,null],[18,"B","","",0,null],[11,"high_part","ramp::ll::limb","Returns the high half of the limb",0,{"inputs":[{"name":"limb"}],"output":{"name":"limb"}}],[11,"low_part","","Returns the low half of the limb",0,{"inputs":[{"name":"limb"}],"output":{"name":"limb"}}],[11,"add_overflow","","Performs `self + other`, returning the result and whether or not the addition overflowed",0,null],[11,"sub_overflow","","Performs `self - other`, returning the result and whether or not the subtraction overflowed",0,null],[11,"mul_lo","","Performs `self * other` returning the lower half of the product",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"limb"}}],[11,"mul_hi","","Performs `self * other` returning the higher half of the product",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"limb"}}],[11,"mul_hilo","","Performs `self * other` returning the two-limb result as (high, low).",0,null],[11,"invert","","",0,{"inputs":[{"name":"limb"}],"output":{"name":"limb"}}],[11,"high_bit_set","","Returns whether or not the highest bit in the limb is set.",0,{"inputs":[{"name":"limb"}],"output":{"name":"bool"}}],[11,"leading_zeros","","Returns the number of leading zeros in the limb",0,{"inputs":[{"name":"limb"}],"output":{"name":"baseint"}}],[11,"trailing_zeros","","Returns the number of trailing zeros in the limb",0,{"inputs":[{"name":"limb"}],"output":{"name":"baseint"}}],[11,"add","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"limb"}}],[11,"add","","",0,{"inputs":[{"name":"limb"},{"name":"baseint"}],"output":{"name":"limb"}}],[11,"add","","",0,{"inputs":[{"name":"limb"},{"name":"bool"}],"output":{"name":"limb"}}],[11,"add","","",1,{"inputs":[{"name":"baseint"},{"name":"limb"}],"output":{"name":"limb"}}],[11,"sub","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"limb"}}],[11,"sub","","",0,{"inputs":[{"name":"limb"},{"name":"baseint"}],"output":{"name":"limb"}}],[11,"sub","","",0,{"inputs":[{"name":"limb"},{"name":"bool"}],"output":{"name":"limb"}}],[11,"sub","","",1,{"inputs":[{"name":"baseint"},{"name":"limb"}],"output":{"name":"limb"}}],[11,"mul","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"limb"}}],[11,"mul","","",0,{"inputs":[{"name":"limb"},{"name":"baseint"}],"output":{"name":"limb"}}],[11,"mul","","",1,{"inputs":[{"name":"baseint"},{"name":"limb"}],"output":{"name":"limb"}}],[11,"div","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"limb"}}],[11,"div","","",0,{"inputs":[{"name":"limb"},{"name":"baseint"}],"output":{"name":"limb"}}],[11,"rem","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"limb"}}],[11,"rem","","",0,{"inputs":[{"name":"limb"},{"name":"baseint"}],"output":{"name":"limb"}}],[11,"neg","","",0,{"inputs":[{"name":"limb"}],"output":{"name":"limb"}}],[11,"shl","","",0,{"inputs":[{"name":"limb"},{"name":"i"}],"output":{"name":"limb"}}],[11,"shr","","",0,{"inputs":[{"name":"limb"},{"name":"i"}],"output":{"name":"limb"}}],[11,"not","","",0,{"inputs":[{"name":"limb"}],"output":{"name":"limb"}}],[11,"bitand","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"limb"}}],[11,"bitor","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"limb"}}],[11,"bitxor","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"limb"}}],[11,"eq","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"bool"}}],[11,"ne","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"bool"}}],[11,"partial_cmp","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"option"}}],[11,"lt","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"bool"}}],[11,"le","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"bool"}}],[11,"gt","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"bool"}}],[11,"ge","","",0,{"inputs":[{"name":"limb"},{"name":"limb"}],"output":{"name":"bool"}}],[11,"eq","","",0,{"inputs":[{"name":"limb"},{"name":"baseint"}],"output":{"name":"bool"}}],[11,"ne","","",0,{"inputs":[{"name":"limb"},{"name":"baseint"}],"output":{"name":"bool"}}],[11,"partial_cmp","","",0,{"inputs":[{"name":"limb"},{"name":"baseint"}],"output":{"name":"option"}}],[11,"lt","","",0,{"inputs":[{"name":"limb"},{"name":"baseint"}],"output":{"name":"bool"}}],[11,"le","","",0,{"inputs":[{"name":"limb"},{"name":"baseint"}],"output":{"name":"bool"}}],[11,"gt","","",0,{"inputs":[{"name":"limb"},{"name":"baseint"}],"output":{"name":"bool"}}],[11,"ge","","",0,{"inputs":[{"name":"limb"},{"name":"baseint"}],"output":{"name":"bool"}}],[11,"fmt","","",0,{"inputs":[{"name":"limb"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",0,{"inputs":[{"name":"limb"},{"name":"formatter"}],"output":{"name":"result"}}],[0,"limb_ptr","ramp::ll","",null,null],[3,"Limbs","ramp::ll::limb_ptr","A version of `*const Limb` that is bounds-checked when debug assertions are on",null,null],[3,"LimbsMut","","A version of `*mut Limb` that is bounds-checked when debug assertions are on",null,null],[11,"fmt","","",2,{"inputs":[{"name":"limbs"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",2,{"inputs":[{"name":"limbs"}],"output":{"name":"limbs"}}],[11,"clone","","",3,{"inputs":[{"name":"limbsmut"}],"output":{"name":"limbsmut"}}],[11,"new","","Create a new instance, pointing at `base` and valid\nfrom `base.offset(start)` to `base.offset(end)`.",2,null],[11,"offset","","Move `self` to point to the `x`th Limbs from the\ncurrent location.",2,{"inputs":[{"name":"limbs"},{"name":"isize"}],"output":{"name":"limbs"}}],[11,"eq","","",2,{"inputs":[{"name":"limbs"},{"name":"limbs"}],"output":{"name":"bool"}}],[11,"partial_cmp","","",2,{"inputs":[{"name":"limbs"},{"name":"limbs"}],"output":{"name":"option"}}],[11,"cmp","","",2,{"inputs":[{"name":"limbs"},{"name":"limbs"}],"output":{"name":"ordering"}}],[11,"deref","","",2,{"inputs":[{"name":"limbs"}],"output":{"name":"limb"}}],[11,"new","","Create a new instance, pointing at `base` and valid\nfrom `base.offset(start)` to `base.offset(end)`.",3,null],[11,"offset","","Move `self` to point to the `x`th Limbs from the\ncurrent location.",3,{"inputs":[{"name":"limbsmut"},{"name":"isize"}],"output":{"name":"limbsmut"}}],[11,"eq","","",3,{"inputs":[{"name":"limbsmut"},{"name":"limbsmut"}],"output":{"name":"bool"}}],[11,"partial_cmp","","",3,{"inputs":[{"name":"limbsmut"},{"name":"limbsmut"}],"output":{"name":"option"}}],[11,"cmp","","",3,{"inputs":[{"name":"limbsmut"},{"name":"limbsmut"}],"output":{"name":"ordering"}}],[11,"deref","","",3,{"inputs":[{"name":"limbsmut"}],"output":{"name":"limb"}}],[11,"as_const","","View the `LimbsMut` as a `Limbs` (an explicit `*const\nLimb` -> `*mut Limb` conversion)",3,{"inputs":[{"name":"limbsmut"}],"output":{"name":"limbs"}}],[11,"deref_mut","","",3,{"inputs":[{"name":"limbsmut"}],"output":{"name":"limb"}}],[0,"int","ramp","",null,null],[3,"Int","ramp::int","An arbitrary-precision signed integer.",null,null],[3,"ParseIntError","","",null,null],[8,"RandomInt","","Trait for generating random `Int`.",null,null],[10,"gen_uint","","Generate a random unsigned `Int` of given bit size.",4,{"inputs":[{"name":"randomint"},{"name":"usize"}],"output":{"name":"int"}}],[10,"gen_int","","Generate a random `Int` of given bit size.",4,{"inputs":[{"name":"randomint"},{"name":"usize"}],"output":{"name":"int"}}],[10,"gen_uint_below","","Generate a random unsigned `Int` less than the given bound.\nFails when the bound is zero or negative.",4,{"inputs":[{"name":"randomint"},{"name":"int"}],"output":{"name":"int"}}],[10,"gen_int_range","","Generate a random `Int` within the given range.\nThe lower bound is inclusive; the upper bound is exclusive.\nFails when the upper bound is not greater than the lower bound.",4,{"inputs":[{"name":"randomint"},{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"zero","","",5,{"inputs":[],"output":{"name":"int"}}],[11,"one","","",5,{"inputs":[],"output":{"name":"int"}}],[11,"from_single_limb","","Creates a new Int from the given Limb.",5,{"inputs":[{"name":"limb"}],"output":{"name":"int"}}],[11,"sign","","Returns the sign of the Int as either -1, 0 or 1 for self being negative, zero\nor positive, respectively.",5,{"inputs":[{"name":"int"}],"output":{"name":"i32"}}],[11,"abs","","Consumes self and returns the absolute value",5,{"inputs":[{"name":"int"}],"output":{"name":"int"}}],[11,"to_single_limb","","Returns the least-significant limb of self.",5,{"inputs":[{"name":"int"}],"output":{"name":"limb"}}],[11,"abs_cmp","","Compare the absolute value of self to the absolute value of other,\nreturning an Ordering with the result.",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"ordering"}}],[11,"shrink_to_fit","","Try to shrink the allocated data for this Int.",5,{"inputs":[{"name":"int"}],"output":null}],[11,"to_str_radix","","Returns a string containing the value of self in base `base`. For bases greater than\nten, if `upper` is true, upper-case letters are used, otherwise lower-case ones are used.",5,{"inputs":[{"name":"int"},{"name":"u8"},{"name":"bool"}],"output":{"name":"string"}}],[11,"write_radix","","",5,{"inputs":[{"name":"int"},{"name":"w"},{"name":"u8"},{"name":"bool"}],"output":{"name":"result"}}],[11,"from_str_radix","","Creates a new Int from the given string in base `base`.",5,{"inputs":[{"name":"str"},{"name":"u8"}],"output":{"name":"result"}}],[11,"divmod","","Divide self by other, returning the quotient, Q, and remainder, R as (Q, R).",5,null],[11,"pow","","Raises self to the power of exp",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":{"name":"int"}}],[11,"square","","Returns the square of `self`.",5,{"inputs":[{"name":"int"}],"output":{"name":"int"}}],[11,"dsquare","","",5,{"inputs":[{"name":"int"}],"output":{"name":"int"}}],[11,"sqrt_rem","","Compute the sqrt of this number, returning its floor, S,  and the\nremainder, R, as Some((S, R)), or None if this number is negative.",5,{"inputs":[{"name":"int"}],"output":{"name":"option"}}],[11,"negate","","Negates `self` in-place",5,{"inputs":[{"name":"int"}],"output":null}],[11,"is_even","","Returns whether or not this number is even.",5,{"inputs":[{"name":"int"}],"output":{"name":"bool"}}],[11,"trailing_zeros","","Returns the number of trailing zero bits in this number",5,{"inputs":[{"name":"int"}],"output":{"name":"u32"}}],[11,"count_ones","","Returns the number of ones (the population count) in this number",5,{"inputs":[{"name":"int"}],"output":{"name":"usize"}}],[11,"bit_length","","Returns the number of bits required to represent (the absolute\nvalue of) this number, that is, `floor(log2(abs(self))) + 1`.",5,{"inputs":[{"name":"int"}],"output":{"name":"u32"}}],[11,"bit","","Returns the value of the `bit`th bit in this number, as if it\nwere represented in two's complement.",5,{"inputs":[{"name":"int"},{"name":"u32"}],"output":{"name":"bool"}}],[11,"set_bit","","Set the `bit`th bit of this number to `bit_val`, treating\nnegative numbers as if they're stored in two's complement.",5,{"inputs":[{"name":"int"},{"name":"u32"},{"name":"bool"}],"output":null}],[11,"gcd","","Calculates the Greatest Common Divisor (GCD) of the number and `other`.",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"lcm","","Calculates the Lowest Common Multiple (LCM) of the number and `other`.",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"clone","","",5,{"inputs":[{"name":"int"}],"output":{"name":"int"}}],[11,"clone_from","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"default","","",5,{"inputs":[],"output":{"name":"int"}}],[11,"drop","","",5,{"inputs":[{"name":"int"}],"output":null}],[11,"eq","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"bool"}}],[11,"eq","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":{"name":"bool"}}],[11,"eq","ramp::ll::limb","",0,{"inputs":[{"name":"limb"},{"name":"int"}],"output":{"name":"bool"}}],[11,"cmp","ramp::int","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"ordering"}}],[11,"partial_cmp","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"option"}}],[11,"partial_cmp","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":{"name":"option"}}],[11,"partial_cmp","ramp::ll::limb","",0,{"inputs":[{"name":"limb"},{"name":"int"}],"output":{"name":"option"}}],[11,"hash","ramp::int","",5,{"inputs":[{"name":"int"},{"name":"h"}],"output":null}],[11,"add_assign","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":null}],[11,"add","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":{"name":"int"}}],[11,"add_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"add","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"add","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"add_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"sub_assign","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":null}],[11,"sub","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":{"name":"int"}}],[11,"sub_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"sub","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"sub","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"sub_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"mul_assign","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":null}],[11,"mul","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":{"name":"int"}}],[11,"mul","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"mul","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"mul_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"mul_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"div_assign","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":null}],[11,"div","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":{"name":"int"}}],[11,"div","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"div","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"div_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"div_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"rem","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":{"name":"int"}}],[11,"rem_assign","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":null}],[11,"rem","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"rem","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"rem_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"rem_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"neg","","",5,{"inputs":[{"name":"int"}],"output":{"name":"int"}}],[11,"shl_assign","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":null}],[11,"shl","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":{"name":"int"}}],[11,"shr_assign","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":null}],[11,"shr","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":{"name":"int"}}],[11,"bitand","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":{"name":"int"}}],[11,"bitand_assign","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":null}],[11,"bitand","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"bitand","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"bitand_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"bitand_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"bitor","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":{"name":"int"}}],[11,"bitor_assign","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":null}],[11,"bitor","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"bitor","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"bitor_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"bitor_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"bitxor","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":{"name":"int"}}],[11,"bitxor_assign","","",5,{"inputs":[{"name":"int"},{"name":"limb"}],"output":null}],[11,"bitxor","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"bitxor","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"int"}}],[11,"bitxor_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"bitxor_assign","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":null}],[11,"add","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":{"name":"int"}}],[11,"add_assign","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":null}],[11,"sub","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":{"name":"int"}}],[11,"sub_assign","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":null}],[11,"mul","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":{"name":"int"}}],[11,"mul_assign","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":null}],[11,"div_assign","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":null}],[11,"div","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":{"name":"int"}}],[11,"rem_assign","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":null}],[11,"rem","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":{"name":"int"}}],[11,"bitand_assign","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":null}],[11,"bitor_assign","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":null}],[11,"bitxor_assign","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":null}],[11,"bitand","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":{"name":"int"}}],[11,"bitor","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":{"name":"int"}}],[11,"bitxor","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":{"name":"int"}}],[11,"add","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":{"name":"int"}}],[11,"add_assign","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":null}],[11,"sub","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":{"name":"int"}}],[11,"sub_assign","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":null}],[11,"mul","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":{"name":"int"}}],[11,"mul_assign","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":null}],[11,"div","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":{"name":"int"}}],[11,"div_assign","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":null}],[11,"rem","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":{"name":"int"}}],[11,"rem_assign","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":null}],[11,"bitand_assign","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":null}],[11,"bitor_assign","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":null}],[11,"bitxor_assign","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":null}],[11,"bitand","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":{"name":"int"}}],[11,"bitor","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":{"name":"int"}}],[11,"bitxor","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":{"name":"int"}}],[11,"add","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":{"name":"int"}}],[11,"add_assign","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":null}],[11,"sub","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":{"name":"int"}}],[11,"sub_assign","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":null}],[11,"mul","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":{"name":"int"}}],[11,"mul_assign","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":null}],[11,"div","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":{"name":"int"}}],[11,"div_assign","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":null}],[11,"rem","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":{"name":"int"}}],[11,"rem_assign","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":null}],[11,"bitand_assign","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":null}],[11,"bitor_assign","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":null}],[11,"bitxor_assign","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":null}],[11,"add","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"add","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"sub","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"sub","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"mul","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"mul","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"div","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"div","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"rem","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"rem","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"bitand","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":{"name":"int"}}],[11,"bitand","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"bitand","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"bitor","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":{"name":"int"}}],[11,"bitor","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"bitor","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"bitxor","","",5,{"inputs":[{"name":"int"},{"name":"baseint"}],"output":{"name":"int"}}],[11,"bitxor","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"bitxor","","",1,{"inputs":[{"name":"baseint"},{"name":"int"}],"output":{"name":"int"}}],[11,"eq","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":{"name":"bool"}}],[11,"partial_cmp","","",5,{"inputs":[{"name":"int"},{"name":"i32"}],"output":{"name":"option"}}],[11,"eq","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":{"name":"bool"}}],[11,"partial_cmp","","",5,{"inputs":[{"name":"int"},{"name":"usize"}],"output":{"name":"option"}}],[11,"eq","","",5,{"inputs":[{"name":"int"},{"name":"u64"}],"output":{"name":"bool"}}],[11,"partial_cmp","","",5,{"inputs":[{"name":"int"},{"name":"u64"}],"output":{"name":"option"}}],[11,"eq","","",5,{"inputs":[{"name":"int"},{"name":"i64"}],"output":{"name":"bool"}}],[11,"partial_cmp","","",5,{"inputs":[{"name":"int"},{"name":"i64"}],"output":{"name":"option"}}],[11,"from","","",5,{"inputs":[{"name":"i8"}],"output":{"name":"int"}}],[11,"from","","",5,{"inputs":[{"name":"i16"}],"output":{"name":"int"}}],[11,"from","","",5,{"inputs":[{"name":"i32"}],"output":{"name":"int"}}],[11,"from","","",5,{"inputs":[{"name":"i64"}],"output":{"name":"int"}}],[11,"from","","",5,{"inputs":[{"name":"isize"}],"output":{"name":"int"}}],[11,"from","","",5,{"inputs":[{"name":"u8"}],"output":{"name":"int"}}],[11,"from","","",5,{"inputs":[{"name":"u16"}],"output":{"name":"int"}}],[11,"from","","",5,{"inputs":[{"name":"u32"}],"output":{"name":"int"}}],[11,"from","","",5,{"inputs":[{"name":"u64"}],"output":{"name":"int"}}],[11,"from","","",5,{"inputs":[{"name":"usize"}],"output":{"name":"int"}}],[11,"fmt","","",5,{"inputs":[{"name":"int"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",5,{"inputs":[{"name":"int"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",5,{"inputs":[{"name":"int"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",5,{"inputs":[{"name":"int"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",5,{"inputs":[{"name":"int"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",5,{"inputs":[{"name":"int"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"eq","","",6,{"inputs":[{"name":"parseinterror"},{"name":"parseinterror"}],"output":{"name":"bool"}}],[11,"ne","","",6,{"inputs":[{"name":"parseinterror"},{"name":"parseinterror"}],"output":{"name":"bool"}}],[11,"clone","","",6,{"inputs":[{"name":"parseinterror"}],"output":{"name":"parseinterror"}}],[11,"fmt","","",6,{"inputs":[{"name":"parseinterror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"description","","",6,{"inputs":[{"name":"parseinterror"}],"output":{"name":"str"}}],[11,"fmt","","",6,{"inputs":[{"name":"parseinterror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"from_str","","",5,{"inputs":[{"name":"str"}],"output":{"name":"result"}}],[11,"zero","","",5,{"inputs":[],"output":{"name":"int"}}],[11,"one","","",5,{"inputs":[],"output":{"name":"int"}}],[11,"step","","",5,{"inputs":[{"name":"int"},{"name":"int"}],"output":{"name":"option"}}],[11,"steps_between","","",5,{"inputs":[{"name":"int"},{"name":"int"},{"name":"int"}],"output":{"name":"option"}}]],"paths":[[3,"Limb"],[6,"BaseInt"],[3,"Limbs"],[3,"LimbsMut"],[8,"RandomInt"],[3,"Int"],[3,"ParseIntError"]]};
+searchIndex["rand"] = {"doc":"Utilities for random number generation","items":[[3,"Generator","rand","Iterator which will generate a stream of random items.",null,null],[3,"AsciiGenerator","","Iterator which will continuously generate random ascii characters.",null,null],[3,"XorShiftRng","","An Xorshift[1] random number\ngenerator.",null,null],[3,"Open01","","A wrapper for generating floating point numbers uniformly in the\nopen interval `(0,1)` (not including either endpoint).",null,null],[12,"0","","",0,null],[3,"Closed01","","A wrapper for generating floating point numbers uniformly in the\nclosed interval `[0,1]` (including both endpoints).",null,null],[12,"0","","",1,null],[3,"StdRng","","The standard RNG. This is designed to be efficient on the current\nplatform.",null,null],[3,"ThreadRng","","The thread-local RNG.",null,null],[5,"weak_rng","","Create a weak random number generator with a default algorithm and seed.",null,{"inputs":[],"output":{"name":"xorshiftrng"}}],[5,"thread_rng","","Retrieve the lazily-initialized thread-local random number\ngenerator, seeded by the system. Intended to be used in method\nchaining style, e.g. `thread_rng().gen::<i32>()`.",null,{"inputs":[],"output":{"name":"threadrng"}}],[5,"random","","Generates a random value using the thread-local random number generator.",null,{"inputs":[],"output":{"name":"t"}}],[5,"sample","","Randomly sample up to `amount` elements from an iterator.",null,{"inputs":[{"name":"r"},{"name":"i"},{"name":"usize"}],"output":{"name":"vec"}}],[0,"distributions","","Sampling from random distributions.",null,null],[3,"RandSample","rand::distributions","A wrapper for generating types that implement `Rand` via the\n`Sample` & `IndependentSample` traits.",null,null],[3,"Weighted","","A value with a particular weight for use with `WeightedChoice`.",null,null],[12,"weight","","The numerical weight of this item",2,null],[12,"item","","The actual item which is being weighted",2,null],[3,"WeightedChoice","","A distribution that selects from a finite collection of weighted items.",null,null],[0,"range","","Generating numbers between two others.",null,null],[3,"Range","rand::distributions::range","Sample values uniformly between two bounds.",null,null],[8,"SampleRange","","The helper trait for types that have a sensible way to sample\nuniformly between two values. This should not be used directly,\nand is only to facilitate `Range`.",null,null],[10,"construct_range","","Construct the `Range` object that `sample_range`\nrequires. This should not ever be called directly, only via\n`Range::new`, which will check that `low < high`, so this\nfunction doesn't have to repeat the check.",3,{"inputs":[{"name":"self"},{"name":"self"}],"output":{"name":"range"}}],[10,"sample_range","","Sample a value from the given `Range` with the given `Rng` as\na source of randomness.",3,{"inputs":[{"name":"range"},{"name":"r"}],"output":{"name":"self"}}],[11,"clone","","",4,{"inputs":[{"name":"range"}],"output":{"name":"range"}}],[11,"new","","Create a new `Range` instance that samples uniformly from\n`[low, high)`. Panics if `low >= high`.",4,{"inputs":[{"name":"x"},{"name":"x"}],"output":{"name":"range"}}],[11,"sample","","",4,{"inputs":[{"name":"range"},{"name":"r"}],"output":{"name":"sup"}}],[11,"ind_sample","","",4,{"inputs":[{"name":"range"},{"name":"r"}],"output":{"name":"sup"}}],[0,"gamma","rand::distributions","The Gamma and derived distributions.",null,null],[3,"Gamma","rand::distributions::gamma","The Gamma distribution `Gamma(shape, scale)` distribution.",null,null],[3,"ChiSquared","","The chi-squared distribution `χ²(k)`, where `k` is the degrees of\nfreedom.",null,null],[3,"FisherF","","The Fisher F distribution `F(m, n)`.",null,null],[3,"StudentT","","The Student t distribution, `t(nu)`, where `nu` is the degrees of\nfreedom.",null,null],[11,"clone","","",5,{"inputs":[{"name":"gamma"}],"output":{"name":"gamma"}}],[11,"new","","Construct an object representing the `Gamma(shape, scale)`\ndistribution.",5,{"inputs":[{"name":"f64"},{"name":"f64"}],"output":{"name":"gamma"}}],[11,"sample","","",5,{"inputs":[{"name":"gamma"},{"name":"r"}],"output":{"name":"f64"}}],[11,"ind_sample","","",5,{"inputs":[{"name":"gamma"},{"name":"r"}],"output":{"name":"f64"}}],[11,"clone","","",6,{"inputs":[{"name":"chisquared"}],"output":{"name":"chisquared"}}],[11,"new","","Create a new chi-squared distribution with degrees-of-freedom\n`k`. Panics if `k < 0`.",6,{"inputs":[{"name":"f64"}],"output":{"name":"chisquared"}}],[11,"sample","","",6,{"inputs":[{"name":"chisquared"},{"name":"r"}],"output":{"name":"f64"}}],[11,"ind_sample","","",6,{"inputs":[{"name":"chisquared"},{"name":"r"}],"output":{"name":"f64"}}],[11,"clone","","",7,{"inputs":[{"name":"fisherf"}],"output":{"name":"fisherf"}}],[11,"new","","Create a new `FisherF` distribution, with the given\nparameter. Panics if either `m` or `n` are not positive.",7,{"inputs":[{"name":"f64"},{"name":"f64"}],"output":{"name":"fisherf"}}],[11,"sample","","",7,{"inputs":[{"name":"fisherf"},{"name":"r"}],"output":{"name":"f64"}}],[11,"ind_sample","","",7,{"inputs":[{"name":"fisherf"},{"name":"r"}],"output":{"name":"f64"}}],[11,"clone","","",8,{"inputs":[{"name":"studentt"}],"output":{"name":"studentt"}}],[11,"new","","Create a new Student t distribution with `n` degrees of\nfreedom. Panics if `n <= 0`.",8,{"inputs":[{"name":"f64"}],"output":{"name":"studentt"}}],[11,"sample","","",8,{"inputs":[{"name":"studentt"},{"name":"r"}],"output":{"name":"f64"}}],[11,"ind_sample","","",8,{"inputs":[{"name":"studentt"},{"name":"r"}],"output":{"name":"f64"}}],[0,"normal","rand::distributions","The normal and derived distributions.",null,null],[3,"StandardNormal","rand::distributions::normal","A wrapper around an `f64` to generate N(0, 1) random numbers\n(a.k.a.  a standard normal, or Gaussian).",null,null],[12,"0","","",9,null],[3,"Normal","","The normal distribution `N(mean, std_dev**2)`.",null,null],[3,"LogNormal","","The log-normal distribution `ln N(mean, std_dev**2)`.",null,null],[11,"clone","","",9,{"inputs":[{"name":"standardnormal"}],"output":{"name":"standardnormal"}}],[11,"rand","","",9,{"inputs":[{"name":"r"}],"output":{"name":"standardnormal"}}],[11,"clone","","",10,{"inputs":[{"name":"normal"}],"output":{"name":"normal"}}],[11,"new","","Construct a new `Normal` distribution with the given mean and\nstandard deviation.",10,{"inputs":[{"name":"f64"},{"name":"f64"}],"output":{"name":"normal"}}],[11,"sample","","",10,{"inputs":[{"name":"normal"},{"name":"r"}],"output":{"name":"f64"}}],[11,"ind_sample","","",10,{"inputs":[{"name":"normal"},{"name":"r"}],"output":{"name":"f64"}}],[11,"clone","","",11,{"inputs":[{"name":"lognormal"}],"output":{"name":"lognormal"}}],[11,"new","","Construct a new `LogNormal` distribution with the given mean\nand standard deviation.",11,{"inputs":[{"name":"f64"},{"name":"f64"}],"output":{"name":"lognormal"}}],[11,"sample","","",11,{"inputs":[{"name":"lognormal"},{"name":"r"}],"output":{"name":"f64"}}],[11,"ind_sample","","",11,{"inputs":[{"name":"lognormal"},{"name":"r"}],"output":{"name":"f64"}}],[0,"exponential","rand::distributions","The exponential distribution.",null,null],[3,"Exp1","rand::distributions::exponential","A wrapper around an `f64` to generate Exp(1) random numbers.",null,null],[12,"0","","",12,null],[3,"Exp","","The exponential distribution `Exp(lambda)`.",null,null],[11,"clone","","",12,{"inputs":[{"name":"exp1"}],"output":{"name":"exp1"}}],[11,"rand","","",12,{"inputs":[{"name":"r"}],"output":{"name":"exp1"}}],[11,"clone","","",13,{"inputs":[{"name":"exp"}],"output":{"name":"exp"}}],[11,"new","","Construct a new `Exp` with the given shape parameter\n`lambda`. Panics if `lambda <= 0`.",13,{"inputs":[{"name":"f64"}],"output":{"name":"exp"}}],[11,"sample","","",13,{"inputs":[{"name":"exp"},{"name":"r"}],"output":{"name":"f64"}}],[11,"ind_sample","","",13,{"inputs":[{"name":"exp"},{"name":"r"}],"output":{"name":"f64"}}],[8,"Sample","rand::distributions","Types that can be used to create a random instance of `Support`.",null,null],[10,"sample","","Generate a random value of `Support`, using `rng` as the\nsource of randomness.",14,{"inputs":[{"name":"sample"},{"name":"r"}],"output":{"name":"support"}}],[8,"IndependentSample","","`Sample`s that do not require keeping track of state.",null,null],[10,"ind_sample","","Generate a random value.",15,{"inputs":[{"name":"independentsample"},{"name":"r"}],"output":{"name":"support"}}],[11,"clone","","",16,{"inputs":[{"name":"randsample"}],"output":{"name":"self"}}],[11,"sample","","",16,{"inputs":[{"name":"randsample"},{"name":"r"}],"output":{"name":"sup"}}],[11,"ind_sample","","",16,{"inputs":[{"name":"randsample"},{"name":"r"}],"output":{"name":"sup"}}],[11,"new","","",16,{"inputs":[],"output":{"name":"randsample"}}],[11,"clone","","",2,{"inputs":[{"name":"weighted"}],"output":{"name":"weighted"}}],[11,"new","","Create a new `WeightedChoice`.",17,null],[11,"sample","","",17,{"inputs":[{"name":"weightedchoice"},{"name":"r"}],"output":{"name":"t"}}],[11,"ind_sample","","",17,{"inputs":[{"name":"weightedchoice"},{"name":"r"}],"output":{"name":"t"}}],[0,"isaac","rand","The ISAAC random number generator.",null,null],[3,"IsaacRng","rand::isaac","A random number generator that uses the ISAAC algorithm[1].",null,null],[3,"Isaac64Rng","","A random number generator that uses ISAAC-64[1], the 64-bit\nvariant of the ISAAC algorithm.",null,null],[11,"new_unseeded","","Create an ISAAC random number generator using the default\nfixed seed.",18,{"inputs":[],"output":{"name":"isaacrng"}}],[11,"clone","","",18,{"inputs":[{"name":"isaacrng"}],"output":{"name":"isaacrng"}}],[11,"next_u32","","",18,{"inputs":[{"name":"isaacrng"}],"output":{"name":"u32"}}],[11,"reseed","","",18,null],[11,"from_seed","","Create an ISAAC random number generator with a seed. This can\nbe any length, although the maximum number of elements used is\n256 and any more will be silently ignored. A generator\nconstructed with a given seed will generate the same sequence\nof values as all other generators constructed with that seed.",18,null],[11,"rand","","",18,{"inputs":[{"name":"r"}],"output":{"name":"isaacrng"}}],[11,"new_unseeded","","Create a 64-bit ISAAC random number generator using the\ndefault fixed seed.",19,{"inputs":[],"output":{"name":"isaac64rng"}}],[11,"clone","","",19,{"inputs":[{"name":"isaac64rng"}],"output":{"name":"isaac64rng"}}],[11,"next_u32","","",19,{"inputs":[{"name":"isaac64rng"}],"output":{"name":"u32"}}],[11,"next_u64","","",19,{"inputs":[{"name":"isaac64rng"}],"output":{"name":"u64"}}],[11,"reseed","","",19,null],[11,"from_seed","","Create an ISAAC random number generator with a seed. This can\nbe any length, although the maximum number of elements used is\n256 and any more will be silently ignored. A generator\nconstructed with a given seed will generate the same sequence\nof values as all other generators constructed with that seed.",19,null],[11,"rand","","",19,{"inputs":[{"name":"r"}],"output":{"name":"isaac64rng"}}],[0,"chacha","rand","The ChaCha random number generator.",null,null],[3,"ChaChaRng","rand::chacha","A random number generator that uses the ChaCha20 algorithm [1].",null,null],[11,"clone","","",20,{"inputs":[{"name":"chacharng"}],"output":{"name":"chacharng"}}],[11,"new_unseeded","","Create an ChaCha random number generator using the default\nfixed key of 8 zero words.",20,{"inputs":[],"output":{"name":"chacharng"}}],[11,"set_counter","","Sets the internal 128-bit ChaCha counter to\na user-provided value. This permits jumping\narbitrarily ahead (or backwards) in the pseudorandom stream.",20,{"inputs":[{"name":"chacharng"},{"name":"u64"},{"name":"u64"}],"output":null}],[11,"next_u32","","",20,{"inputs":[{"name":"chacharng"}],"output":{"name":"u32"}}],[11,"reseed","","",20,null],[11,"from_seed","","Create a ChaCha generator from a seed,\nobtained from a variable-length u32 array.\nOnly up to 8 words are used; if less than 8\nwords are used, the remaining are set to zero.",20,null],[11,"rand","","",20,{"inputs":[{"name":"r"}],"output":{"name":"chacharng"}}],[0,"reseeding","rand","A wrapper around another RNG that reseeds it after it\ngenerates a certain number of random bytes.",null,null],[3,"ReseedingRng","rand::reseeding","A wrapper around any RNG which reseeds the underlying RNG after it\nhas generated a certain number of random bytes.",null,null],[12,"reseeder","","Controls the behaviour when reseeding the RNG.",21,null],[3,"ReseedWithDefault","","Reseed an RNG using a `Default` instance. This reseeds by\nreplacing the RNG with the result of a `Default::default` call.",null,null],[8,"Reseeder","","Something that can be used to reseed an RNG via `ReseedingRng`.",null,null],[10,"reseed","","Reseed the given RNG.",22,{"inputs":[{"name":"reseeder"},{"name":"r"}],"output":null}],[11,"new","","Create a new `ReseedingRng` with the given parameters.",21,{"inputs":[{"name":"r"},{"name":"u64"},{"name":"rsdr"}],"output":{"name":"reseedingrng"}}],[11,"reseed_if_necessary","","Reseed the internal RNG if the number of bytes that have been\ngenerated exceed the threshold.",21,{"inputs":[{"name":"reseedingrng"}],"output":null}],[11,"next_u32","","",21,{"inputs":[{"name":"reseedingrng"}],"output":{"name":"u32"}}],[11,"next_u64","","",21,{"inputs":[{"name":"reseedingrng"}],"output":{"name":"u64"}}],[11,"fill_bytes","","",21,null],[11,"reseed","","",21,null],[11,"from_seed","","Create a new `ReseedingRng` from the given reseeder and\nseed. This uses a default value for `generation_threshold`.",21,null],[11,"clone","","",23,{"inputs":[{"name":"reseedwithdefault"}],"output":{"name":"reseedwithdefault"}}],[11,"reseed","","",23,{"inputs":[{"name":"reseedwithdefault"},{"name":"r"}],"output":null}],[11,"default","","",23,{"inputs":[],"output":{"name":"reseedwithdefault"}}],[11,"rand","rand","",0,{"inputs":[{"name":"r"}],"output":{"name":"open01"}}],[11,"rand","","",1,{"inputs":[{"name":"r"}],"output":{"name":"closed01"}}],[11,"rand","","",0,{"inputs":[{"name":"r"}],"output":{"name":"open01"}}],[11,"rand","","",1,{"inputs":[{"name":"r"}],"output":{"name":"closed01"}}],[11,"rand","core::option","",24,{"inputs":[{"name":"r"}],"output":{"name":"option"}}],[0,"os","rand","Interfaces to the operating system provided random number\ngenerators.",null,null],[3,"OsRng","rand::os","A random number generator that retrieves randomness straight from\nthe operating system. Platform sources:",null,null],[11,"new","","Create a new `OsRng`.",25,{"inputs":[],"output":{"name":"result"}}],[11,"next_u32","","",25,{"inputs":[{"name":"osrng"}],"output":{"name":"u32"}}],[11,"next_u64","","",25,{"inputs":[{"name":"osrng"}],"output":{"name":"u64"}}],[11,"fill_bytes","","",25,null],[0,"read","rand","A wrapper around any Read to treat it as an RNG.",null,null],[3,"ReadRng","rand::read","An RNG that reads random bytes straight from a `Read`. This will\nwork best with an infinite reader, but this is not required.",null,null],[11,"new","","Create a new `ReadRng` from a `Read`.",26,{"inputs":[{"name":"r"}],"output":{"name":"readrng"}}],[11,"next_u32","","",26,{"inputs":[{"name":"readrng"}],"output":{"name":"u32"}}],[11,"next_u64","","",26,{"inputs":[{"name":"readrng"}],"output":{"name":"u64"}}],[11,"fill_bytes","","",26,null],[8,"Rand","rand","A type that can be randomly generated using an `Rng`.",null,null],[10,"rand","","Generates a random instance of this type using the specified source of\nrandomness.",27,{"inputs":[{"name":"r"}],"output":{"name":"self"}}],[8,"Rng","","A random number generator.",null,null],[10,"next_u32","","Return the next random u32.",28,{"inputs":[{"name":"rng"}],"output":{"name":"u32"}}],[11,"next_u64","","Return the next random u64.",28,{"inputs":[{"name":"rng"}],"output":{"name":"u64"}}],[11,"next_f32","","Return the next random f32 selected from the half-open\ninterval `[0, 1)`.",28,{"inputs":[{"name":"rng"}],"output":{"name":"f32"}}],[11,"next_f64","","Return the next random f64 selected from the half-open\ninterval `[0, 1)`.",28,{"inputs":[{"name":"rng"}],"output":{"name":"f64"}}],[11,"fill_bytes","","Fill `dest` with random data.",28,null],[11,"gen","","Return a random value of a `Rand` type.",28,{"inputs":[{"name":"rng"}],"output":{"name":"t"}}],[11,"gen_iter","","Return an iterator that will yield an infinite number of randomly\ngenerated items.",28,{"inputs":[{"name":"rng"}],"output":{"name":"generator"}}],[11,"gen_range","","Generate a random value in the range [`low`, `high`).",28,{"inputs":[{"name":"rng"},{"name":"t"},{"name":"t"}],"output":{"name":"t"}}],[11,"gen_weighted_bool","","Return a bool with a 1 in n chance of true",28,{"inputs":[{"name":"rng"},{"name":"u32"}],"output":{"name":"bool"}}],[11,"gen_ascii_chars","","Return an iterator of random characters from the set A-Z,a-z,0-9.",28,{"inputs":[{"name":"rng"}],"output":{"name":"asciigenerator"}}],[11,"choose","","Return a random element from `values`.",28,null],[11,"shuffle","","Shuffle a mutable slice in place.",28,null],[8,"SeedableRng","","A random number generator that can be explicitly seeded to produce\nthe same stream of randomness multiple times.",null,null],[10,"reseed","","Reseed an RNG with the given seed.",29,{"inputs":[{"name":"seedablerng"},{"name":"seed"}],"output":null}],[10,"from_seed","","Create a new RNG with the given seed.",29,{"inputs":[{"name":"seed"}],"output":{"name":"self"}}],[11,"next_u32","alloc::boxed","",30,{"inputs":[{"name":"box"}],"output":{"name":"u32"}}],[11,"next_u64","","",30,{"inputs":[{"name":"box"}],"output":{"name":"u64"}}],[11,"next_f32","","",30,{"inputs":[{"name":"box"}],"output":{"name":"f32"}}],[11,"next_f64","","",30,{"inputs":[{"name":"box"}],"output":{"name":"f64"}}],[11,"fill_bytes","","",30,null],[11,"next","rand","",31,{"inputs":[{"name":"generator"}],"output":{"name":"option"}}],[11,"next","","",32,{"inputs":[{"name":"asciigenerator"}],"output":{"name":"option"}}],[11,"clone","","",33,{"inputs":[{"name":"xorshiftrng"}],"output":{"name":"xorshiftrng"}}],[11,"new_unseeded","","Creates a new XorShiftRng instance which is not seeded.",33,{"inputs":[],"output":{"name":"xorshiftrng"}}],[11,"next_u32","","",33,{"inputs":[{"name":"xorshiftrng"}],"output":{"name":"u32"}}],[11,"reseed","","Reseed an XorShiftRng. This will panic if `seed` is entirely 0.",33,null],[11,"from_seed","","Create a new XorShiftRng. This will panic if `seed` is entirely 0.",33,null],[11,"rand","","",33,{"inputs":[{"name":"r"}],"output":{"name":"xorshiftrng"}}],[11,"clone","","",34,{"inputs":[{"name":"stdrng"}],"output":{"name":"stdrng"}}],[11,"new","","Create a randomly seeded instance of `StdRng`.",34,{"inputs":[],"output":{"name":"result"}}],[11,"next_u32","","",34,{"inputs":[{"name":"stdrng"}],"output":{"name":"u32"}}],[11,"next_u64","","",34,{"inputs":[{"name":"stdrng"}],"output":{"name":"u64"}}],[11,"reseed","","",34,null],[11,"from_seed","","",34,null],[11,"clone","","",35,{"inputs":[{"name":"threadrng"}],"output":{"name":"threadrng"}}],[11,"next_u32","","",35,{"inputs":[{"name":"threadrng"}],"output":{"name":"u32"}}],[11,"next_u64","","",35,{"inputs":[{"name":"threadrng"}],"output":{"name":"u64"}}],[11,"fill_bytes","","",35,null]],"paths":[[3,"Open01"],[3,"Closed01"],[3,"Weighted"],[8,"SampleRange"],[3,"Range"],[3,"Gamma"],[3,"ChiSquared"],[3,"FisherF"],[3,"StudentT"],[3,"StandardNormal"],[3,"Normal"],[3,"LogNormal"],[3,"Exp1"],[3,"Exp"],[8,"Sample"],[8,"IndependentSample"],[3,"RandSample"],[3,"WeightedChoice"],[3,"IsaacRng"],[3,"Isaac64Rng"],[3,"ChaChaRng"],[3,"ReseedingRng"],[8,"Reseeder"],[3,"ReseedWithDefault"],[4,"Option"],[3,"OsRng"],[3,"ReadRng"],[8,"Rand"],[8,"Rng"],[8,"SeedableRng"],[3,"Box"],[3,"Generator"],[3,"AsciiGenerator"],[3,"XorShiftRng"],[3,"StdRng"],[3,"ThreadRng"]]};
+searchIndex["libc"] = {"doc":"Crate docs","items":[[3,"stat","libc","",null,null],[12,"st_dev","","",0,null],[12,"st_ino","","",0,null],[12,"st_mode","","",0,null],[12,"st_nlink","","",0,null],[12,"st_uid","","",0,null],[12,"st_gid","","",0,null],[12,"st_rdev","","",0,null],[12,"st_size","","",0,null],[12,"st_atime","","",0,null],[12,"st_mtime","","",0,null],[12,"st_ctime","","",0,null],[3,"utimbuf","","",null,null],[12,"actime","","",1,null],[12,"modtime","","",1,null],[3,"timeval","","",null,null],[12,"tv_sec","","",2,null],[12,"tv_usec","","",2,null],[3,"timespec","","",null,null],[12,"tv_sec","","",3,null],[12,"tv_nsec","","",3,null],[4,"c_void","","",null,null],[4,"FILE","","",null,null],[4,"fpos_t","","",null,null],[4,"timezone","","",null,null],[5,"isalnum","","",null,null],[5,"isalpha","","",null,null],[5,"iscntrl","","",null,null],[5,"isdigit","","",null,null],[5,"isgraph","","",null,null],[5,"islower","","",null,null],[5,"isprint","","",null,null],[5,"ispunct","","",null,null],[5,"isspace","","",null,null],[5,"isupper","","",null,null],[5,"isxdigit","","",null,null],[5,"tolower","","",null,null],[5,"toupper","","",null,null],[5,"fopen","","",null,null],[5,"freopen","","",null,null],[5,"fflush","","",null,null],[5,"fclose","","",null,null],[5,"remove","","",null,null],[5,"rename","","",null,null],[5,"tmpfile","","",null,null],[5,"setvbuf","","",null,null],[5,"setbuf","","",null,null],[5,"fgetc","","",null,null],[5,"fgets","","",null,null],[5,"fputc","","",null,null],[5,"fputs","","",null,null],[5,"puts","","",null,null],[5,"ungetc","","",null,null],[5,"fread","","",null,null],[5,"fwrite","","",null,null],[5,"fseek","","",null,null],[5,"ftell","","",null,null],[5,"rewind","","",null,null],[5,"fgetpos","","",null,null],[5,"fsetpos","","",null,null],[5,"feof","","",null,null],[5,"ferror","","",null,null],[5,"perror","","",null,null],[5,"atoi","","",null,null],[5,"strtod","","",null,null],[5,"strtol","","",null,null],[5,"strtoul","","",null,null],[5,"calloc","","",null,null],[5,"malloc","","",null,null],[5,"realloc","","",null,null],[5,"free","","",null,null],[5,"abort","","",null,null],[5,"exit","","",null,null],[5,"_exit","","",null,null],[5,"atexit","","",null,null],[5,"system","","",null,null],[5,"getenv","","",null,null],[5,"strcpy","","",null,null],[5,"strncpy","","",null,null],[5,"strcat","","",null,null],[5,"strncat","","",null,null],[5,"strcmp","","",null,null],[5,"strncmp","","",null,null],[5,"strcoll","","",null,null],[5,"strchr","","",null,null],[5,"strrchr","","",null,null],[5,"strspn","","",null,null],[5,"strcspn","","",null,null],[5,"strpbrk","","",null,null],[5,"strstr","","",null,null],[5,"strlen","","",null,null],[5,"strerror","","",null,null],[5,"strtok","","",null,null],[5,"strxfrm","","",null,null],[5,"wcslen","","",null,null],[5,"memcmp","","",null,null],[5,"memchr","","",null,null],[5,"abs","","",null,null],[5,"atof","","",null,null],[5,"labs","","",null,null],[5,"rand","","",null,null],[5,"srand","","",null,null],[5,"chmod","","",null,null],[5,"wchmod","","",null,null],[5,"mkdir","","",null,null],[5,"wrmdir","","",null,null],[5,"fstat","","",null,null],[5,"stat","","",null,null],[5,"wstat","","",null,null],[5,"wutime","","",null,null],[5,"popen","","",null,null],[5,"pclose","","",null,null],[5,"fdopen","","",null,null],[5,"fileno","","",null,null],[5,"open","","",null,null],[5,"wopen","","",null,null],[5,"creat","","",null,null],[5,"access","","",null,null],[5,"chdir","","",null,null],[5,"close","","",null,null],[5,"dup","","",null,null],[5,"dup2","","",null,null],[5,"execv","","",null,null],[5,"execve","","",null,null],[5,"execvp","","",null,null],[5,"execvpe","","",null,null],[5,"getcwd","","",null,null],[5,"getpid","","",null,null],[5,"isatty","","",null,null],[5,"lseek","","",null,null],[5,"pipe","","",null,null],[5,"read","","",null,null],[5,"rmdir","","",null,null],[5,"unlink","","",null,null],[5,"write","","",null,null],[5,"commit","","",null,null],[5,"get_osfhandle","","",null,null],[5,"open_osfhandle","","",null,null],[11,"is_some","core::option","Returns `true` if the option is a `Some` value",4,{"inputs":[{"name":"option"}],"output":{"name":"bool"}}],[11,"is_none","","Returns `true` if the option is a `None` value",4,{"inputs":[{"name":"option"}],"output":{"name":"bool"}}],[11,"as_ref","","Converts from `Option<T>` to `Option<&T>`",4,{"inputs":[{"name":"option"}],"output":{"name":"option"}}],[11,"as_mut","","Converts from `Option<T>` to `Option<&mut T>`",4,{"inputs":[{"name":"option"}],"output":{"name":"option"}}],[11,"expect","","Unwraps an option, yielding the content of a `Some`.",4,{"inputs":[{"name":"option"},{"name":"str"}],"output":{"name":"t"}}],[11,"unwrap","","Moves the value `v` out of the `Option<T>` if it is `Some(v)`.",4,{"inputs":[{"name":"option"}],"output":{"name":"t"}}],[11,"unwrap_or","","Returns the contained value or a default.",4,{"inputs":[{"name":"option"},{"name":"t"}],"output":{"name":"t"}}],[11,"unwrap_or_else","","Returns the contained value or computes it from a closure.",4,{"inputs":[{"name":"option"},{"name":"f"}],"output":{"name":"t"}}],[11,"map","","Maps an `Option<T>` to `Option<U>` by applying a function to a contained value",4,{"inputs":[{"name":"option"},{"name":"f"}],"output":{"name":"option"}}],[11,"map_or","","Applies a function to the contained value (if any),\nor returns a `default` (if not).",4,{"inputs":[{"name":"option"},{"name":"u"},{"name":"f"}],"output":{"name":"u"}}],[11,"map_or_else","","Applies a function to the contained value (if any),\nor computes a `default` (if not).",4,{"inputs":[{"name":"option"},{"name":"d"},{"name":"f"}],"output":{"name":"u"}}],[11,"ok_or","","Transforms the `Option<T>` into a `Result<T, E>`, mapping `Some(v)` to\n`Ok(v)` and `None` to `Err(err)`.",4,{"inputs":[{"name":"option"},{"name":"e"}],"output":{"name":"result"}}],[11,"ok_or_else","","Transforms the `Option<T>` into a `Result<T, E>`, mapping `Some(v)` to\n`Ok(v)` and `None` to `Err(err())`.",4,{"inputs":[{"name":"option"},{"name":"f"}],"output":{"name":"result"}}],[11,"iter","","Returns an iterator over the possibly contained value.",4,{"inputs":[{"name":"option"}],"output":{"name":"iter"}}],[11,"iter_mut","","Returns a mutable iterator over the possibly contained value.",4,{"inputs":[{"name":"option"}],"output":{"name":"itermut"}}],[11,"and","","Returns `None` if the option is `None`, otherwise returns `optb`.",4,{"inputs":[{"name":"option"},{"name":"option"}],"output":{"name":"option"}}],[11,"and_then","","Returns `None` if the option is `None`, otherwise calls `f` with the\nwrapped value and returns the result.",4,{"inputs":[{"name":"option"},{"name":"f"}],"output":{"name":"option"}}],[11,"or","","Returns the option if it contains a value, otherwise returns `optb`.",4,{"inputs":[{"name":"option"},{"name":"option"}],"output":{"name":"option"}}],[11,"or_else","","Returns the option if it contains a value, otherwise calls `f` and\nreturns the result.",4,{"inputs":[{"name":"option"},{"name":"f"}],"output":{"name":"option"}}],[11,"take","","Takes the value out of the option, leaving a `None` in its place.",4,{"inputs":[{"name":"option"}],"output":{"name":"option"}}],[11,"cloned","","Maps an `Option<&T>` to an `Option<T>` by cloning the contents of the\noption.",4,{"inputs":[{"name":"option"}],"output":{"name":"option"}}],[11,"unwrap_or_default","","Returns the contained value or a default",4,{"inputs":[{"name":"option"}],"output":{"name":"t"}}],[11,"hash","core::num","",5,null],[11,"default","","",5,{"inputs":[],"output":{"name":"wrapping"}}],[11,"clone","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"cmp","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"ordering"}}],[11,"partial_cmp","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"option"}}],[11,"lt","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"bool"}}],[11,"le","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"bool"}}],[11,"gt","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"bool"}}],[11,"ge","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"bool"}}],[11,"eq","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"bool"}}],[11,"ne","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"bool"}}],[11,"fmt","","",5,{"inputs":[{"name":"wrapping"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",5,{"inputs":[{"name":"wrapping"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"shl","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shl_assign","","",5,null],[11,"shr","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shr_assign","","",5,null],[11,"shl","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shl_assign","","",5,null],[11,"shr","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shr_assign","","",5,null],[11,"shl","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shl_assign","","",5,null],[11,"shr","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shr_assign","","",5,null],[11,"shl","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shl_assign","","",5,null],[11,"shr","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shr_assign","","",5,null],[11,"shl","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shl_assign","","",5,null],[11,"shr","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shr_assign","","",5,null],[11,"shl","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shl_assign","","",5,null],[11,"shr","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shr_assign","","",5,null],[11,"shl","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shl_assign","","",5,null],[11,"shr","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shr_assign","","",5,null],[11,"shl","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shl_assign","","",5,null],[11,"shr","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shr_assign","","",5,null],[11,"shl","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shl_assign","","",5,null],[11,"shr","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shr_assign","","",5,null],[11,"shl","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shl_assign","","",5,null],[11,"shr","","",5,{"inputs":[{"name":"wrapping"},{"name":"usize"}],"output":{"name":"wrapping"}}],[11,"shr_assign","","",5,null],[11,"add","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add_assign","","",5,null],[11,"sub","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"sub_assign","","",5,null],[11,"mul","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"mul_assign","","",5,null],[11,"div","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"div_assign","","",5,null],[11,"rem","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"rem_assign","","",5,null],[11,"not","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor_assign","","",5,null],[11,"bitor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitor_assign","","",5,null],[11,"bitand","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitand_assign","","",5,null],[11,"neg","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add_assign","","",5,null],[11,"sub","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"sub_assign","","",5,null],[11,"mul","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"mul_assign","","",5,null],[11,"div","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"div_assign","","",5,null],[11,"rem","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"rem_assign","","",5,null],[11,"not","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor_assign","","",5,null],[11,"bitor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitor_assign","","",5,null],[11,"bitand","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitand_assign","","",5,null],[11,"neg","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add_assign","","",5,null],[11,"sub","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"sub_assign","","",5,null],[11,"mul","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"mul_assign","","",5,null],[11,"div","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"div_assign","","",5,null],[11,"rem","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"rem_assign","","",5,null],[11,"not","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor_assign","","",5,null],[11,"bitor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitor_assign","","",5,null],[11,"bitand","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitand_assign","","",5,null],[11,"neg","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add_assign","","",5,null],[11,"sub","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"sub_assign","","",5,null],[11,"mul","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"mul_assign","","",5,null],[11,"div","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"div_assign","","",5,null],[11,"rem","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"rem_assign","","",5,null],[11,"not","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor_assign","","",5,null],[11,"bitor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitor_assign","","",5,null],[11,"bitand","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitand_assign","","",5,null],[11,"neg","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add_assign","","",5,null],[11,"sub","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"sub_assign","","",5,null],[11,"mul","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"mul_assign","","",5,null],[11,"div","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"div_assign","","",5,null],[11,"rem","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"rem_assign","","",5,null],[11,"not","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor_assign","","",5,null],[11,"bitor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitor_assign","","",5,null],[11,"bitand","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitand_assign","","",5,null],[11,"neg","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add_assign","","",5,null],[11,"sub","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"sub_assign","","",5,null],[11,"mul","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"mul_assign","","",5,null],[11,"div","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"div_assign","","",5,null],[11,"rem","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"rem_assign","","",5,null],[11,"not","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor_assign","","",5,null],[11,"bitor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitor_assign","","",5,null],[11,"bitand","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitand_assign","","",5,null],[11,"neg","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add_assign","","",5,null],[11,"sub","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"sub_assign","","",5,null],[11,"mul","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"mul_assign","","",5,null],[11,"div","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"div_assign","","",5,null],[11,"rem","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"rem_assign","","",5,null],[11,"not","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor_assign","","",5,null],[11,"bitor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitor_assign","","",5,null],[11,"bitand","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitand_assign","","",5,null],[11,"neg","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add_assign","","",5,null],[11,"sub","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"sub_assign","","",5,null],[11,"mul","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"mul_assign","","",5,null],[11,"div","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"div_assign","","",5,null],[11,"rem","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"rem_assign","","",5,null],[11,"not","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor_assign","","",5,null],[11,"bitor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitor_assign","","",5,null],[11,"bitand","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitand_assign","","",5,null],[11,"neg","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add_assign","","",5,null],[11,"sub","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"sub_assign","","",5,null],[11,"mul","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"mul_assign","","",5,null],[11,"div","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"div_assign","","",5,null],[11,"rem","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"rem_assign","","",5,null],[11,"not","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor_assign","","",5,null],[11,"bitor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitor_assign","","",5,null],[11,"bitand","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitand_assign","","",5,null],[11,"neg","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"add_assign","","",5,null],[11,"sub","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"sub_assign","","",5,null],[11,"mul","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"mul_assign","","",5,null],[11,"div","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"div_assign","","",5,null],[11,"rem","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"rem_assign","","",5,null],[11,"not","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitxor_assign","","",5,null],[11,"bitor","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitor_assign","","",5,null],[11,"bitand","","",5,{"inputs":[{"name":"wrapping"},{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"bitand_assign","","",5,null],[11,"neg","","",5,{"inputs":[{"name":"wrapping"}],"output":{"name":"wrapping"}}],[11,"eq","core::num::dec2flt","",6,{"inputs":[{"name":"parsefloaterror"},{"name":"parsefloaterror"}],"output":{"name":"bool"}}],[11,"ne","","",6,{"inputs":[{"name":"parsefloaterror"},{"name":"parsefloaterror"}],"output":{"name":"bool"}}],[11,"clone","","",6,{"inputs":[{"name":"parsefloaterror"}],"output":{"name":"parsefloaterror"}}],[11,"fmt","","",6,{"inputs":[{"name":"parsefloaterror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",6,{"inputs":[{"name":"parsefloaterror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","core::num","",7,{"inputs":[{"name":"fpcategory"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"eq","","",7,{"inputs":[{"name":"fpcategory"},{"name":"fpcategory"}],"output":{"name":"bool"}}],[11,"clone","","",7,{"inputs":[{"name":"fpcategory"}],"output":{"name":"fpcategory"}}],[11,"clone","","",8,{"inputs":[{"name":"tryfrominterror"}],"output":{"name":"tryfrominterror"}}],[11,"fmt","","",8,{"inputs":[{"name":"tryfrominterror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",8,{"inputs":[{"name":"tryfrominterror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"eq","","",9,{"inputs":[{"name":"parseinterror"},{"name":"parseinterror"}],"output":{"name":"bool"}}],[11,"ne","","",9,{"inputs":[{"name":"parseinterror"},{"name":"parseinterror"}],"output":{"name":"bool"}}],[11,"clone","","",9,{"inputs":[{"name":"parseinterror"}],"output":{"name":"parseinterror"}}],[11,"fmt","","",9,{"inputs":[{"name":"parseinterror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",9,{"inputs":[{"name":"parseinterror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"hash","core::nonzero","",10,null],[11,"fmt","","",10,{"inputs":[{"name":"nonzero"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"partial_cmp","","",10,{"inputs":[{"name":"nonzero"},{"name":"nonzero"}],"output":{"name":"option"}}],[11,"lt","","",10,{"inputs":[{"name":"nonzero"},{"name":"nonzero"}],"output":{"name":"bool"}}],[11,"le","","",10,{"inputs":[{"name":"nonzero"},{"name":"nonzero"}],"output":{"name":"bool"}}],[11,"gt","","",10,{"inputs":[{"name":"nonzero"},{"name":"nonzero"}],"output":{"name":"bool"}}],[11,"ge","","",10,{"inputs":[{"name":"nonzero"},{"name":"nonzero"}],"output":{"name":"bool"}}],[11,"cmp","","",10,{"inputs":[{"name":"nonzero"},{"name":"nonzero"}],"output":{"name":"ordering"}}],[11,"eq","","",10,{"inputs":[{"name":"nonzero"},{"name":"nonzero"}],"output":{"name":"bool"}}],[11,"ne","","",10,{"inputs":[{"name":"nonzero"},{"name":"nonzero"}],"output":{"name":"bool"}}],[11,"clone","","",10,{"inputs":[{"name":"nonzero"}],"output":{"name":"nonzero"}}],[11,"new","","Creates an instance of NonZero with the provided value.\nYou must indeed ensure that the value is actually "non-zero".",10,{"inputs":[{"name":"t"}],"output":{"name":"nonzero"}}],[11,"deref","","",10,{"inputs":[{"name":"nonzero"}],"output":{"name":"t"}}],[11,"new","core::ptr","Creates a new `Unique`.",11,null],[11,"get","","Dereferences the content.",11,{"inputs":[{"name":"unique"}],"output":{"name":"t"}}],[11,"get_mut","","Mutably dereferences the content.",11,{"inputs":[{"name":"unique"}],"output":{"name":"t"}}],[11,"deref","","",11,null],[11,"fmt","","",11,{"inputs":[{"name":"unique"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"new","","Creates a new `Shared`.",12,null],[11,"clone","","",12,{"inputs":[{"name":"shared"}],"output":{"name":"shared"}}],[11,"deref","","",12,null],[11,"fmt","","",12,{"inputs":[{"name":"shared"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"hash","core::marker","",13,null],[11,"eq","","",13,{"inputs":[{"name":"phantomdata"},{"name":"phantomdata"}],"output":{"name":"bool"}}],[11,"partial_cmp","","",13,{"inputs":[{"name":"phantomdata"},{"name":"phantomdata"}],"output":{"name":"option"}}],[11,"cmp","","",13,{"inputs":[{"name":"phantomdata"},{"name":"phantomdata"}],"output":{"name":"ordering"}}],[11,"clone","","",13,{"inputs":[{"name":"phantomdata"}],"output":{"name":"phantomdata"}}],[11,"default","","",13,{"inputs":[],"output":{"name":"phantomdata"}}],[11,"eq","core::ops","",14,{"inputs":[{"name":"rangefull"},{"name":"rangefull"}],"output":{"name":"bool"}}],[11,"clone","","",14,{"inputs":[{"name":"rangefull"}],"output":{"name":"rangefull"}}],[11,"fmt","","",14,{"inputs":[{"name":"rangefull"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"eq","","",15,{"inputs":[{"name":"range"},{"name":"range"}],"output":{"name":"bool"}}],[11,"ne","","",15,{"inputs":[{"name":"range"},{"name":"range"}],"output":{"name":"bool"}}],[11,"clone","","",15,{"inputs":[{"name":"range"}],"output":{"name":"range"}}],[11,"fmt","","",15,{"inputs":[{"name":"range"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"contains","","# Examples",15,{"inputs":[{"name":"range"},{"name":"idx"}],"output":{"name":"bool"}}],[11,"eq","","",16,{"inputs":[{"name":"rangefrom"},{"name":"rangefrom"}],"output":{"name":"bool"}}],[11,"ne","","",16,{"inputs":[{"name":"rangefrom"},{"name":"rangefrom"}],"output":{"name":"bool"}}],[11,"clone","","",16,{"inputs":[{"name":"rangefrom"}],"output":{"name":"rangefrom"}}],[11,"fmt","","",16,{"inputs":[{"name":"rangefrom"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"contains","","# Examples",16,{"inputs":[{"name":"rangefrom"},{"name":"idx"}],"output":{"name":"bool"}}],[11,"eq","","",17,{"inputs":[{"name":"rangeto"},{"name":"rangeto"}],"output":{"name":"bool"}}],[11,"ne","","",17,{"inputs":[{"name":"rangeto"},{"name":"rangeto"}],"output":{"name":"bool"}}],[11,"clone","","",17,{"inputs":[{"name":"rangeto"}],"output":{"name":"rangeto"}}],[11,"fmt","","",17,{"inputs":[{"name":"rangeto"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"contains","","# Examples",17,{"inputs":[{"name":"rangeto"},{"name":"idx"}],"output":{"name":"bool"}}],[11,"eq","","",18,{"inputs":[{"name":"rangeinclusive"},{"name":"rangeinclusive"}],"output":{"name":"bool"}}],[11,"ne","","",18,{"inputs":[{"name":"rangeinclusive"},{"name":"rangeinclusive"}],"output":{"name":"bool"}}],[11,"clone","","",18,{"inputs":[{"name":"rangeinclusive"}],"output":{"name":"rangeinclusive"}}],[11,"fmt","","",18,{"inputs":[{"name":"rangeinclusive"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"from","","",18,{"inputs":[{"name":"range"}],"output":{"name":"rangeinclusive"}}],[11,"contains","","# Examples",18,{"inputs":[{"name":"rangeinclusive"},{"name":"idx"}],"output":{"name":"bool"}}],[11,"eq","","",19,{"inputs":[{"name":"rangetoinclusive"},{"name":"rangetoinclusive"}],"output":{"name":"bool"}}],[11,"ne","","",19,{"inputs":[{"name":"rangetoinclusive"},{"name":"rangetoinclusive"}],"output":{"name":"bool"}}],[11,"clone","","",19,{"inputs":[{"name":"rangetoinclusive"}],"output":{"name":"rangetoinclusive"}}],[11,"fmt","","",19,{"inputs":[{"name":"rangetoinclusive"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"contains","","# Examples",19,{"inputs":[{"name":"rangetoinclusive"},{"name":"idx"}],"output":{"name":"bool"}}],[11,"hash","core::cmp","",20,null],[11,"fmt","","",20,{"inputs":[{"name":"ordering"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"eq","","",20,{"inputs":[{"name":"ordering"},{"name":"ordering"}],"output":{"name":"bool"}}],[11,"clone","","",20,{"inputs":[{"name":"ordering"}],"output":{"name":"ordering"}}],[11,"reverse","","Reverse the `Ordering`.",20,{"inputs":[{"name":"ordering"}],"output":{"name":"ordering"}}],[11,"cmp","","",20,{"inputs":[{"name":"ordering"},{"name":"ordering"}],"output":{"name":"ordering"}}],[11,"partial_cmp","","",20,{"inputs":[{"name":"ordering"},{"name":"ordering"}],"output":{"name":"option"}}],[11,"fmt","libc","",21,{"inputs":[{"name":"any"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",21,{"inputs":[{"name":"any"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"is","","Returns true if the boxed type is the same as `T`",21,{"inputs":[{"name":"any"}],"output":{"name":"bool"}}],[11,"downcast_ref","","Returns some reference to the boxed value if it is of type `T`, or\n`None` if it isn't.",21,{"inputs":[{"name":"any"}],"output":{"name":"option"}}],[11,"downcast_mut","","Returns some mutable reference to the boxed value if it is of type `T`, or\n`None` if it isn't.",21,{"inputs":[{"name":"any"}],"output":{"name":"option"}}],[11,"is","","Forwards to the method defined on the type `Any`.",21,{"inputs":[{"name":"any"}],"output":{"name":"bool"}}],[11,"downcast_ref","","Forwards to the method defined on the type `Any`.",21,{"inputs":[{"name":"any"}],"output":{"name":"option"}}],[11,"downcast_mut","","Forwards to the method defined on the type `Any`.",21,{"inputs":[{"name":"any"}],"output":{"name":"option"}}],[11,"hash","core::any","",22,null],[11,"fmt","","",22,{"inputs":[{"name":"typeid"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"eq","","",22,{"inputs":[{"name":"typeid"},{"name":"typeid"}],"output":{"name":"bool"}}],[11,"ne","","",22,{"inputs":[{"name":"typeid"},{"name":"typeid"}],"output":{"name":"bool"}}],[11,"clone","","",22,{"inputs":[{"name":"typeid"}],"output":{"name":"typeid"}}],[11,"of","","Returns the `TypeId` of the type this generic function has been\ninstantiated with",22,{"inputs":[],"output":{"name":"typeid"}}],[11,"default","core::sync::atomic","",23,{"inputs":[],"output":{"name":"atomicbool"}}],[11,"default","","",24,{"inputs":[],"output":{"name":"atomicptr"}}],[11,"fmt","","",25,{"inputs":[{"name":"ordering"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",25,{"inputs":[{"name":"ordering"}],"output":{"name":"ordering"}}],[11,"new","","Creates a new `AtomicBool`.",23,{"inputs":[{"name":"bool"}],"output":{"name":"atomicbool"}}],[11,"load","","Loads a value from the bool.",23,{"inputs":[{"name":"atomicbool"},{"name":"ordering"}],"output":{"name":"bool"}}],[11,"store","","Stores a value into the bool.",23,null],[11,"swap","","Stores a value into the bool, returning the old value.",23,{"inputs":[{"name":"atomicbool"},{"name":"bool"},{"name":"ordering"}],"output":{"name":"bool"}}],[11,"compare_and_swap","","Stores a value into the `bool` if the current value is the same as the `current` value.",23,{"inputs":[{"name":"atomicbool"},{"name":"bool"},{"name":"bool"},{"name":"ordering"}],"output":{"name":"bool"}}],[11,"compare_exchange","","Stores a value into the `bool` if the current value is the same as the `current` value.",23,{"inputs":[{"name":"atomicbool"},{"name":"bool"},{"name":"bool"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"compare_exchange_weak","","Stores a value into the `bool` if the current value is the same as the `current` value.",23,{"inputs":[{"name":"atomicbool"},{"name":"bool"},{"name":"bool"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"fetch_and","","Logical "and" with a boolean value.",23,{"inputs":[{"name":"atomicbool"},{"name":"bool"},{"name":"ordering"}],"output":{"name":"bool"}}],[11,"fetch_nand","","Logical "nand" with a boolean value.",23,{"inputs":[{"name":"atomicbool"},{"name":"bool"},{"name":"ordering"}],"output":{"name":"bool"}}],[11,"fetch_or","","Logical "or" with a boolean value.",23,{"inputs":[{"name":"atomicbool"},{"name":"bool"},{"name":"ordering"}],"output":{"name":"bool"}}],[11,"fetch_xor","","Logical "xor" with a boolean value.",23,{"inputs":[{"name":"atomicbool"},{"name":"bool"},{"name":"ordering"}],"output":{"name":"bool"}}],[11,"new","","Creates a new `AtomicPtr`.",24,null],[11,"load","","Loads a value from the pointer.",24,null],[11,"store","","Stores a value into the pointer.",24,null],[11,"swap","","Stores a value into the pointer, returning the old value.",24,null],[11,"compare_and_swap","","Stores a value into the pointer if the current value is the same as the `current` value.",24,null],[11,"compare_exchange","","Stores a value into the pointer if the current value is the same as the `current` value.",24,null],[11,"compare_exchange_weak","","Stores a value into the pointer if the current value is the same as the `current` value.",24,null],[11,"default","","",26,{"inputs":[],"output":{"name":"atomici8"}}],[11,"fmt","","",26,{"inputs":[{"name":"atomici8"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"new","","Creates a new atomic integer.",26,{"inputs":[{"name":"i8"}],"output":{"name":"atomici8"}}],[11,"load","","Loads a value from the atomic integer.",26,{"inputs":[{"name":"atomici8"},{"name":"ordering"}],"output":{"name":"i8"}}],[11,"store","","Stores a value into the atomic integer.",26,null],[11,"swap","","Stores a value into the atomic integer, returning the old value.",26,{"inputs":[{"name":"atomici8"},{"name":"i8"},{"name":"ordering"}],"output":{"name":"i8"}}],[11,"compare_and_swap","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",26,{"inputs":[{"name":"atomici8"},{"name":"i8"},{"name":"i8"},{"name":"ordering"}],"output":{"name":"i8"}}],[11,"compare_exchange","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",26,{"inputs":[{"name":"atomici8"},{"name":"i8"},{"name":"i8"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"compare_exchange_weak","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",26,{"inputs":[{"name":"atomici8"},{"name":"i8"},{"name":"i8"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"fetch_add","","Add to the current value, returning the previous value.",26,{"inputs":[{"name":"atomici8"},{"name":"i8"},{"name":"ordering"}],"output":{"name":"i8"}}],[11,"fetch_sub","","Subtract from the current value, returning the previous value.",26,{"inputs":[{"name":"atomici8"},{"name":"i8"},{"name":"ordering"}],"output":{"name":"i8"}}],[11,"fetch_and","","Bitwise and with the current value, returning the previous value.",26,{"inputs":[{"name":"atomici8"},{"name":"i8"},{"name":"ordering"}],"output":{"name":"i8"}}],[11,"fetch_or","","Bitwise or with the current value, returning the previous value.",26,{"inputs":[{"name":"atomici8"},{"name":"i8"},{"name":"ordering"}],"output":{"name":"i8"}}],[11,"fetch_xor","","Bitwise xor with the current value, returning the previous value.",26,{"inputs":[{"name":"atomici8"},{"name":"i8"},{"name":"ordering"}],"output":{"name":"i8"}}],[11,"default","","",27,{"inputs":[],"output":{"name":"atomicu8"}}],[11,"fmt","","",27,{"inputs":[{"name":"atomicu8"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"new","","Creates a new atomic integer.",27,{"inputs":[{"name":"u8"}],"output":{"name":"atomicu8"}}],[11,"load","","Loads a value from the atomic integer.",27,{"inputs":[{"name":"atomicu8"},{"name":"ordering"}],"output":{"name":"u8"}}],[11,"store","","Stores a value into the atomic integer.",27,null],[11,"swap","","Stores a value into the atomic integer, returning the old value.",27,{"inputs":[{"name":"atomicu8"},{"name":"u8"},{"name":"ordering"}],"output":{"name":"u8"}}],[11,"compare_and_swap","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",27,{"inputs":[{"name":"atomicu8"},{"name":"u8"},{"name":"u8"},{"name":"ordering"}],"output":{"name":"u8"}}],[11,"compare_exchange","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",27,{"inputs":[{"name":"atomicu8"},{"name":"u8"},{"name":"u8"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"compare_exchange_weak","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",27,{"inputs":[{"name":"atomicu8"},{"name":"u8"},{"name":"u8"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"fetch_add","","Add to the current value, returning the previous value.",27,{"inputs":[{"name":"atomicu8"},{"name":"u8"},{"name":"ordering"}],"output":{"name":"u8"}}],[11,"fetch_sub","","Subtract from the current value, returning the previous value.",27,{"inputs":[{"name":"atomicu8"},{"name":"u8"},{"name":"ordering"}],"output":{"name":"u8"}}],[11,"fetch_and","","Bitwise and with the current value, returning the previous value.",27,{"inputs":[{"name":"atomicu8"},{"name":"u8"},{"name":"ordering"}],"output":{"name":"u8"}}],[11,"fetch_or","","Bitwise or with the current value, returning the previous value.",27,{"inputs":[{"name":"atomicu8"},{"name":"u8"},{"name":"ordering"}],"output":{"name":"u8"}}],[11,"fetch_xor","","Bitwise xor with the current value, returning the previous value.",27,{"inputs":[{"name":"atomicu8"},{"name":"u8"},{"name":"ordering"}],"output":{"name":"u8"}}],[11,"default","","",28,{"inputs":[],"output":{"name":"atomici16"}}],[11,"fmt","","",28,{"inputs":[{"name":"atomici16"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"new","","Creates a new atomic integer.",28,{"inputs":[{"name":"i16"}],"output":{"name":"atomici16"}}],[11,"load","","Loads a value from the atomic integer.",28,{"inputs":[{"name":"atomici16"},{"name":"ordering"}],"output":{"name":"i16"}}],[11,"store","","Stores a value into the atomic integer.",28,null],[11,"swap","","Stores a value into the atomic integer, returning the old value.",28,{"inputs":[{"name":"atomici16"},{"name":"i16"},{"name":"ordering"}],"output":{"name":"i16"}}],[11,"compare_and_swap","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",28,{"inputs":[{"name":"atomici16"},{"name":"i16"},{"name":"i16"},{"name":"ordering"}],"output":{"name":"i16"}}],[11,"compare_exchange","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",28,{"inputs":[{"name":"atomici16"},{"name":"i16"},{"name":"i16"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"compare_exchange_weak","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",28,{"inputs":[{"name":"atomici16"},{"name":"i16"},{"name":"i16"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"fetch_add","","Add to the current value, returning the previous value.",28,{"inputs":[{"name":"atomici16"},{"name":"i16"},{"name":"ordering"}],"output":{"name":"i16"}}],[11,"fetch_sub","","Subtract from the current value, returning the previous value.",28,{"inputs":[{"name":"atomici16"},{"name":"i16"},{"name":"ordering"}],"output":{"name":"i16"}}],[11,"fetch_and","","Bitwise and with the current value, returning the previous value.",28,{"inputs":[{"name":"atomici16"},{"name":"i16"},{"name":"ordering"}],"output":{"name":"i16"}}],[11,"fetch_or","","Bitwise or with the current value, returning the previous value.",28,{"inputs":[{"name":"atomici16"},{"name":"i16"},{"name":"ordering"}],"output":{"name":"i16"}}],[11,"fetch_xor","","Bitwise xor with the current value, returning the previous value.",28,{"inputs":[{"name":"atomici16"},{"name":"i16"},{"name":"ordering"}],"output":{"name":"i16"}}],[11,"default","","",29,{"inputs":[],"output":{"name":"atomicu16"}}],[11,"fmt","","",29,{"inputs":[{"name":"atomicu16"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"new","","Creates a new atomic integer.",29,{"inputs":[{"name":"u16"}],"output":{"name":"atomicu16"}}],[11,"load","","Loads a value from the atomic integer.",29,{"inputs":[{"name":"atomicu16"},{"name":"ordering"}],"output":{"name":"u16"}}],[11,"store","","Stores a value into the atomic integer.",29,null],[11,"swap","","Stores a value into the atomic integer, returning the old value.",29,{"inputs":[{"name":"atomicu16"},{"name":"u16"},{"name":"ordering"}],"output":{"name":"u16"}}],[11,"compare_and_swap","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",29,{"inputs":[{"name":"atomicu16"},{"name":"u16"},{"name":"u16"},{"name":"ordering"}],"output":{"name":"u16"}}],[11,"compare_exchange","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",29,{"inputs":[{"name":"atomicu16"},{"name":"u16"},{"name":"u16"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"compare_exchange_weak","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",29,{"inputs":[{"name":"atomicu16"},{"name":"u16"},{"name":"u16"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"fetch_add","","Add to the current value, returning the previous value.",29,{"inputs":[{"name":"atomicu16"},{"name":"u16"},{"name":"ordering"}],"output":{"name":"u16"}}],[11,"fetch_sub","","Subtract from the current value, returning the previous value.",29,{"inputs":[{"name":"atomicu16"},{"name":"u16"},{"name":"ordering"}],"output":{"name":"u16"}}],[11,"fetch_and","","Bitwise and with the current value, returning the previous value.",29,{"inputs":[{"name":"atomicu16"},{"name":"u16"},{"name":"ordering"}],"output":{"name":"u16"}}],[11,"fetch_or","","Bitwise or with the current value, returning the previous value.",29,{"inputs":[{"name":"atomicu16"},{"name":"u16"},{"name":"ordering"}],"output":{"name":"u16"}}],[11,"fetch_xor","","Bitwise xor with the current value, returning the previous value.",29,{"inputs":[{"name":"atomicu16"},{"name":"u16"},{"name":"ordering"}],"output":{"name":"u16"}}],[11,"default","","",30,{"inputs":[],"output":{"name":"atomici32"}}],[11,"fmt","","",30,{"inputs":[{"name":"atomici32"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"new","","Creates a new atomic integer.",30,{"inputs":[{"name":"i32"}],"output":{"name":"atomici32"}}],[11,"load","","Loads a value from the atomic integer.",30,{"inputs":[{"name":"atomici32"},{"name":"ordering"}],"output":{"name":"i32"}}],[11,"store","","Stores a value into the atomic integer.",30,null],[11,"swap","","Stores a value into the atomic integer, returning the old value.",30,{"inputs":[{"name":"atomici32"},{"name":"i32"},{"name":"ordering"}],"output":{"name":"i32"}}],[11,"compare_and_swap","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",30,{"inputs":[{"name":"atomici32"},{"name":"i32"},{"name":"i32"},{"name":"ordering"}],"output":{"name":"i32"}}],[11,"compare_exchange","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",30,{"inputs":[{"name":"atomici32"},{"name":"i32"},{"name":"i32"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"compare_exchange_weak","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",30,{"inputs":[{"name":"atomici32"},{"name":"i32"},{"name":"i32"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"fetch_add","","Add to the current value, returning the previous value.",30,{"inputs":[{"name":"atomici32"},{"name":"i32"},{"name":"ordering"}],"output":{"name":"i32"}}],[11,"fetch_sub","","Subtract from the current value, returning the previous value.",30,{"inputs":[{"name":"atomici32"},{"name":"i32"},{"name":"ordering"}],"output":{"name":"i32"}}],[11,"fetch_and","","Bitwise and with the current value, returning the previous value.",30,{"inputs":[{"name":"atomici32"},{"name":"i32"},{"name":"ordering"}],"output":{"name":"i32"}}],[11,"fetch_or","","Bitwise or with the current value, returning the previous value.",30,{"inputs":[{"name":"atomici32"},{"name":"i32"},{"name":"ordering"}],"output":{"name":"i32"}}],[11,"fetch_xor","","Bitwise xor with the current value, returning the previous value.",30,{"inputs":[{"name":"atomici32"},{"name":"i32"},{"name":"ordering"}],"output":{"name":"i32"}}],[11,"default","","",31,{"inputs":[],"output":{"name":"atomicu32"}}],[11,"fmt","","",31,{"inputs":[{"name":"atomicu32"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"new","","Creates a new atomic integer.",31,{"inputs":[{"name":"u32"}],"output":{"name":"atomicu32"}}],[11,"load","","Loads a value from the atomic integer.",31,{"inputs":[{"name":"atomicu32"},{"name":"ordering"}],"output":{"name":"u32"}}],[11,"store","","Stores a value into the atomic integer.",31,null],[11,"swap","","Stores a value into the atomic integer, returning the old value.",31,{"inputs":[{"name":"atomicu32"},{"name":"u32"},{"name":"ordering"}],"output":{"name":"u32"}}],[11,"compare_and_swap","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",31,{"inputs":[{"name":"atomicu32"},{"name":"u32"},{"name":"u32"},{"name":"ordering"}],"output":{"name":"u32"}}],[11,"compare_exchange","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",31,{"inputs":[{"name":"atomicu32"},{"name":"u32"},{"name":"u32"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"compare_exchange_weak","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",31,{"inputs":[{"name":"atomicu32"},{"name":"u32"},{"name":"u32"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"fetch_add","","Add to the current value, returning the previous value.",31,{"inputs":[{"name":"atomicu32"},{"name":"u32"},{"name":"ordering"}],"output":{"name":"u32"}}],[11,"fetch_sub","","Subtract from the current value, returning the previous value.",31,{"inputs":[{"name":"atomicu32"},{"name":"u32"},{"name":"ordering"}],"output":{"name":"u32"}}],[11,"fetch_and","","Bitwise and with the current value, returning the previous value.",31,{"inputs":[{"name":"atomicu32"},{"name":"u32"},{"name":"ordering"}],"output":{"name":"u32"}}],[11,"fetch_or","","Bitwise or with the current value, returning the previous value.",31,{"inputs":[{"name":"atomicu32"},{"name":"u32"},{"name":"ordering"}],"output":{"name":"u32"}}],[11,"fetch_xor","","Bitwise xor with the current value, returning the previous value.",31,{"inputs":[{"name":"atomicu32"},{"name":"u32"},{"name":"ordering"}],"output":{"name":"u32"}}],[11,"default","","",32,{"inputs":[],"output":{"name":"atomici64"}}],[11,"fmt","","",32,{"inputs":[{"name":"atomici64"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"new","","Creates a new atomic integer.",32,{"inputs":[{"name":"i64"}],"output":{"name":"atomici64"}}],[11,"load","","Loads a value from the atomic integer.",32,{"inputs":[{"name":"atomici64"},{"name":"ordering"}],"output":{"name":"i64"}}],[11,"store","","Stores a value into the atomic integer.",32,null],[11,"swap","","Stores a value into the atomic integer, returning the old value.",32,{"inputs":[{"name":"atomici64"},{"name":"i64"},{"name":"ordering"}],"output":{"name":"i64"}}],[11,"compare_and_swap","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",32,{"inputs":[{"name":"atomici64"},{"name":"i64"},{"name":"i64"},{"name":"ordering"}],"output":{"name":"i64"}}],[11,"compare_exchange","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",32,{"inputs":[{"name":"atomici64"},{"name":"i64"},{"name":"i64"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"compare_exchange_weak","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",32,{"inputs":[{"name":"atomici64"},{"name":"i64"},{"name":"i64"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"fetch_add","","Add to the current value, returning the previous value.",32,{"inputs":[{"name":"atomici64"},{"name":"i64"},{"name":"ordering"}],"output":{"name":"i64"}}],[11,"fetch_sub","","Subtract from the current value, returning the previous value.",32,{"inputs":[{"name":"atomici64"},{"name":"i64"},{"name":"ordering"}],"output":{"name":"i64"}}],[11,"fetch_and","","Bitwise and with the current value, returning the previous value.",32,{"inputs":[{"name":"atomici64"},{"name":"i64"},{"name":"ordering"}],"output":{"name":"i64"}}],[11,"fetch_or","","Bitwise or with the current value, returning the previous value.",32,{"inputs":[{"name":"atomici64"},{"name":"i64"},{"name":"ordering"}],"output":{"name":"i64"}}],[11,"fetch_xor","","Bitwise xor with the current value, returning the previous value.",32,{"inputs":[{"name":"atomici64"},{"name":"i64"},{"name":"ordering"}],"output":{"name":"i64"}}],[11,"default","","",33,{"inputs":[],"output":{"name":"atomicu64"}}],[11,"fmt","","",33,{"inputs":[{"name":"atomicu64"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"new","","Creates a new atomic integer.",33,{"inputs":[{"name":"u64"}],"output":{"name":"atomicu64"}}],[11,"load","","Loads a value from the atomic integer.",33,{"inputs":[{"name":"atomicu64"},{"name":"ordering"}],"output":{"name":"u64"}}],[11,"store","","Stores a value into the atomic integer.",33,null],[11,"swap","","Stores a value into the atomic integer, returning the old value.",33,{"inputs":[{"name":"atomicu64"},{"name":"u64"},{"name":"ordering"}],"output":{"name":"u64"}}],[11,"compare_and_swap","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",33,{"inputs":[{"name":"atomicu64"},{"name":"u64"},{"name":"u64"},{"name":"ordering"}],"output":{"name":"u64"}}],[11,"compare_exchange","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",33,{"inputs":[{"name":"atomicu64"},{"name":"u64"},{"name":"u64"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"compare_exchange_weak","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",33,{"inputs":[{"name":"atomicu64"},{"name":"u64"},{"name":"u64"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"fetch_add","","Add to the current value, returning the previous value.",33,{"inputs":[{"name":"atomicu64"},{"name":"u64"},{"name":"ordering"}],"output":{"name":"u64"}}],[11,"fetch_sub","","Subtract from the current value, returning the previous value.",33,{"inputs":[{"name":"atomicu64"},{"name":"u64"},{"name":"ordering"}],"output":{"name":"u64"}}],[11,"fetch_and","","Bitwise and with the current value, returning the previous value.",33,{"inputs":[{"name":"atomicu64"},{"name":"u64"},{"name":"ordering"}],"output":{"name":"u64"}}],[11,"fetch_or","","Bitwise or with the current value, returning the previous value.",33,{"inputs":[{"name":"atomicu64"},{"name":"u64"},{"name":"ordering"}],"output":{"name":"u64"}}],[11,"fetch_xor","","Bitwise xor with the current value, returning the previous value.",33,{"inputs":[{"name":"atomicu64"},{"name":"u64"},{"name":"ordering"}],"output":{"name":"u64"}}],[11,"default","","",34,{"inputs":[],"output":{"name":"atomicisize"}}],[11,"fmt","","",34,{"inputs":[{"name":"atomicisize"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"new","","Creates a new atomic integer.",34,{"inputs":[{"name":"isize"}],"output":{"name":"atomicisize"}}],[11,"load","","Loads a value from the atomic integer.",34,{"inputs":[{"name":"atomicisize"},{"name":"ordering"}],"output":{"name":"isize"}}],[11,"store","","Stores a value into the atomic integer.",34,null],[11,"swap","","Stores a value into the atomic integer, returning the old value.",34,{"inputs":[{"name":"atomicisize"},{"name":"isize"},{"name":"ordering"}],"output":{"name":"isize"}}],[11,"compare_and_swap","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",34,{"inputs":[{"name":"atomicisize"},{"name":"isize"},{"name":"isize"},{"name":"ordering"}],"output":{"name":"isize"}}],[11,"compare_exchange","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",34,{"inputs":[{"name":"atomicisize"},{"name":"isize"},{"name":"isize"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"compare_exchange_weak","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",34,{"inputs":[{"name":"atomicisize"},{"name":"isize"},{"name":"isize"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"fetch_add","","Add to the current value, returning the previous value.",34,{"inputs":[{"name":"atomicisize"},{"name":"isize"},{"name":"ordering"}],"output":{"name":"isize"}}],[11,"fetch_sub","","Subtract from the current value, returning the previous value.",34,{"inputs":[{"name":"atomicisize"},{"name":"isize"},{"name":"ordering"}],"output":{"name":"isize"}}],[11,"fetch_and","","Bitwise and with the current value, returning the previous value.",34,{"inputs":[{"name":"atomicisize"},{"name":"isize"},{"name":"ordering"}],"output":{"name":"isize"}}],[11,"fetch_or","","Bitwise or with the current value, returning the previous value.",34,{"inputs":[{"name":"atomicisize"},{"name":"isize"},{"name":"ordering"}],"output":{"name":"isize"}}],[11,"fetch_xor","","Bitwise xor with the current value, returning the previous value.",34,{"inputs":[{"name":"atomicisize"},{"name":"isize"},{"name":"ordering"}],"output":{"name":"isize"}}],[11,"default","","",35,{"inputs":[],"output":{"name":"atomicusize"}}],[11,"fmt","","",35,{"inputs":[{"name":"atomicusize"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"new","","Creates a new atomic integer.",35,{"inputs":[{"name":"usize"}],"output":{"name":"atomicusize"}}],[11,"load","","Loads a value from the atomic integer.",35,{"inputs":[{"name":"atomicusize"},{"name":"ordering"}],"output":{"name":"usize"}}],[11,"store","","Stores a value into the atomic integer.",35,null],[11,"swap","","Stores a value into the atomic integer, returning the old value.",35,{"inputs":[{"name":"atomicusize"},{"name":"usize"},{"name":"ordering"}],"output":{"name":"usize"}}],[11,"compare_and_swap","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",35,{"inputs":[{"name":"atomicusize"},{"name":"usize"},{"name":"usize"},{"name":"ordering"}],"output":{"name":"usize"}}],[11,"compare_exchange","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",35,{"inputs":[{"name":"atomicusize"},{"name":"usize"},{"name":"usize"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"compare_exchange_weak","","Stores a value into the atomic integer if the current value is the same as the\n`current` value.",35,{"inputs":[{"name":"atomicusize"},{"name":"usize"},{"name":"usize"},{"name":"ordering"},{"name":"ordering"}],"output":{"name":"result"}}],[11,"fetch_add","","Add to the current value, returning the previous value.",35,{"inputs":[{"name":"atomicusize"},{"name":"usize"},{"name":"ordering"}],"output":{"name":"usize"}}],[11,"fetch_sub","","Subtract from the current value, returning the previous value.",35,{"inputs":[{"name":"atomicusize"},{"name":"usize"},{"name":"ordering"}],"output":{"name":"usize"}}],[11,"fetch_and","","Bitwise and with the current value, returning the previous value.",35,{"inputs":[{"name":"atomicusize"},{"name":"usize"},{"name":"ordering"}],"output":{"name":"usize"}}],[11,"fetch_or","","Bitwise or with the current value, returning the previous value.",35,{"inputs":[{"name":"atomicusize"},{"name":"usize"},{"name":"ordering"}],"output":{"name":"usize"}}],[11,"fetch_xor","","Bitwise xor with the current value, returning the previous value.",35,{"inputs":[{"name":"atomicusize"},{"name":"usize"},{"name":"ordering"}],"output":{"name":"usize"}}],[11,"fmt","","",23,{"inputs":[{"name":"atomicbool"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",24,{"inputs":[{"name":"atomicptr"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"new","core::cell","Creates a new `Cell` containing the given value.",36,{"inputs":[{"name":"t"}],"output":{"name":"cell"}}],[11,"get","","Returns a copy of the contained value.",36,{"inputs":[{"name":"cell"}],"output":{"name":"t"}}],[11,"set","","Sets the contained value.",36,null],[11,"as_unsafe_cell","","Returns a reference to the underlying `UnsafeCell`.",36,{"inputs":[{"name":"cell"}],"output":{"name":"unsafecell"}}],[11,"get_mut","","Returns a mutable reference to the underlying data.",36,{"inputs":[{"name":"cell"}],"output":{"name":"t"}}],[11,"clone","","",36,{"inputs":[{"name":"cell"}],"output":{"name":"cell"}}],[11,"default","","",36,{"inputs":[],"output":{"name":"cell"}}],[11,"eq","","",36,{"inputs":[{"name":"cell"},{"name":"cell"}],"output":{"name":"bool"}}],[11,"fmt","","",37,{"inputs":[{"name":"borrowstate"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"eq","","",37,{"inputs":[{"name":"borrowstate"},{"name":"borrowstate"}],"output":{"name":"bool"}}],[11,"clone","","",37,{"inputs":[{"name":"borrowstate"}],"output":{"name":"borrowstate"}}],[11,"new","","Creates a new `RefCell` containing `value`.",38,{"inputs":[{"name":"t"}],"output":{"name":"refcell"}}],[11,"into_inner","","Consumes the `RefCell`, returning the wrapped value.",38,{"inputs":[{"name":"refcell"}],"output":{"name":"t"}}],[11,"borrow_state","","Query the current state of this `RefCell`",38,{"inputs":[{"name":"refcell"}],"output":{"name":"borrowstate"}}],[11,"borrow","","Immutably borrows the wrapped value.",38,{"inputs":[{"name":"refcell"}],"output":{"name":"ref"}}],[11,"borrow_mut","","Mutably borrows the wrapped value.",38,{"inputs":[{"name":"refcell"}],"output":{"name":"refmut"}}],[11,"as_unsafe_cell","","Returns a reference to the underlying `UnsafeCell`.",38,{"inputs":[{"name":"refcell"}],"output":{"name":"unsafecell"}}],[11,"get_mut","","Returns a mutable reference to the underlying data.",38,{"inputs":[{"name":"refcell"}],"output":{"name":"t"}}],[11,"clone","","",38,{"inputs":[{"name":"refcell"}],"output":{"name":"refcell"}}],[11,"default","","",38,{"inputs":[],"output":{"name":"refcell"}}],[11,"eq","","",38,{"inputs":[{"name":"refcell"},{"name":"refcell"}],"output":{"name":"bool"}}],[11,"deref","","",39,{"inputs":[{"name":"ref"}],"output":{"name":"t"}}],[11,"clone","","Copies a `Ref`.",39,{"inputs":[{"name":"ref"}],"output":{"name":"ref"}}],[11,"map","","Make a new `Ref` for a component of the borrowed data.",39,{"inputs":[{"name":"ref"},{"name":"f"}],"output":{"name":"ref"}}],[11,"filter_map","","Make a new `Ref` for an optional component of the borrowed data, e.g. an\nenum variant.",39,{"inputs":[{"name":"ref"},{"name":"f"}],"output":{"name":"option"}}],[11,"map","","Make a new `RefMut` for a component of the borrowed data, e.g. an enum\nvariant.",40,{"inputs":[{"name":"refmut"},{"name":"f"}],"output":{"name":"refmut"}}],[11,"filter_map","","Make a new `RefMut` for an optional component of the borrowed data, e.g.\nan enum variant.",40,{"inputs":[{"name":"refmut"},{"name":"f"}],"output":{"name":"option"}}],[11,"deref","","",40,{"inputs":[{"name":"refmut"}],"output":{"name":"t"}}],[11,"deref_mut","","",40,{"inputs":[{"name":"refmut"}],"output":{"name":"t"}}],[11,"new","","Constructs a new instance of `UnsafeCell` which will wrap the specified\nvalue.",41,{"inputs":[{"name":"t"}],"output":{"name":"unsafecell"}}],[11,"into_inner","","Unwraps the value.",41,{"inputs":[{"name":"unsafecell"}],"output":{"name":"t"}}],[11,"get","","Gets a mutable pointer to the wrapped value.",41,null],[11,"default","","",41,{"inputs":[],"output":{"name":"unsafecell"}}],[11,"fmt","core::char","",42,{"inputs":[{"name":"escapeunicode"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",42,{"inputs":[{"name":"escapeunicode"}],"output":{"name":"escapeunicode"}}],[11,"next","","",42,{"inputs":[{"name":"escapeunicode"}],"output":{"name":"option"}}],[11,"size_hint","","",42,null],[11,"fmt","","",43,{"inputs":[{"name":"escapedefault"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",43,{"inputs":[{"name":"escapedefault"}],"output":{"name":"escapedefault"}}],[11,"next","","",43,{"inputs":[{"name":"escapedefault"}],"output":{"name":"option"}}],[11,"size_hint","","",43,null],[11,"count","","",43,{"inputs":[{"name":"escapedefault"}],"output":{"name":"usize"}}],[11,"nth","","",43,{"inputs":[{"name":"escapedefault"},{"name":"usize"}],"output":{"name":"option"}}],[11,"last","","",43,{"inputs":[{"name":"escapedefault"}],"output":{"name":"option"}}],[11,"fmt","","",44,{"inputs":[{"name":"encodeutf8"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"as_slice","","Returns the remaining bytes of this iterator as a slice.",44,null],[11,"next","","",44,{"inputs":[{"name":"encodeutf8"}],"output":{"name":"option"}}],[11,"size_hint","","",44,null],[11,"fmt","","",45,{"inputs":[{"name":"encodeutf16"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"as_slice","","Returns the remaining bytes of this iterator as a slice.",45,null],[11,"next","","",45,{"inputs":[{"name":"encodeutf16"}],"output":{"name":"option"}}],[11,"size_hint","","",45,null],[11,"fmt","core::iter::range","",46,{"inputs":[{"name":"stepby"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",46,{"inputs":[{"name":"stepby"}],"output":{"name":"stepby"}}],[11,"step_by","core::ops","Creates an iterator starting at the same point, but stepping by\nthe given amount at each iteration.",16,{"inputs":[{"name":"rangefrom"},{"name":"a"}],"output":{"name":"stepby"}}],[11,"step_by","","Creates an iterator with the same range, but stepping by the\ngiven amount at each iteration.",15,{"inputs":[{"name":"range"},{"name":"a"}],"output":{"name":"stepby"}}],[11,"step_by","","Creates an iterator with the same range, but stepping by the\ngiven amount at each iteration.",18,{"inputs":[{"name":"rangeinclusive"},{"name":"a"}],"output":{"name":"stepby"}}],[11,"next","core::iter::range","",46,{"inputs":[{"name":"stepby"}],"output":{"name":"option"}}],[11,"size_hint","","",46,null],[11,"next","","",46,{"inputs":[{"name":"stepby"}],"output":{"name":"option"}}],[11,"size_hint","","",46,null],[11,"next","","",46,{"inputs":[{"name":"stepby"}],"output":{"name":"option"}}],[11,"size_hint","","",46,null],[11,"next","core::ops","",15,{"inputs":[{"name":"range"}],"output":{"name":"option"}}],[11,"size_hint","","",15,null],[11,"next_back","","",15,{"inputs":[{"name":"range"}],"output":{"name":"option"}}],[11,"next","","",16,{"inputs":[{"name":"rangefrom"}],"output":{"name":"option"}}],[11,"next","","",18,{"inputs":[{"name":"rangeinclusive"}],"output":{"name":"option"}}],[11,"size_hint","","",18,null],[11,"next_back","","",18,{"inputs":[{"name":"rangeinclusive"}],"output":{"name":"option"}}],[11,"fmt","core::iter::sources","",47,{"inputs":[{"name":"repeat"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",47,{"inputs":[{"name":"repeat"}],"output":{"name":"repeat"}}],[11,"next","","",47,{"inputs":[{"name":"repeat"}],"output":{"name":"option"}}],[11,"size_hint","","",47,null],[11,"next_back","","",47,{"inputs":[{"name":"repeat"}],"output":{"name":"option"}}],[11,"fmt","","",48,{"inputs":[{"name":"empty"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",48,{"inputs":[{"name":"empty"}],"output":{"name":"option"}}],[11,"size_hint","","",48,null],[11,"next_back","","",48,{"inputs":[{"name":"empty"}],"output":{"name":"option"}}],[11,"len","","",48,{"inputs":[{"name":"empty"}],"output":{"name":"usize"}}],[11,"clone","","",48,{"inputs":[{"name":"empty"}],"output":{"name":"empty"}}],[11,"default","","",48,{"inputs":[],"output":{"name":"empty"}}],[11,"fmt","","",49,{"inputs":[{"name":"once"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",49,{"inputs":[{"name":"once"}],"output":{"name":"once"}}],[11,"next","","",49,{"inputs":[{"name":"once"}],"output":{"name":"option"}}],[11,"size_hint","","",49,null],[11,"next_back","","",49,{"inputs":[{"name":"once"}],"output":{"name":"option"}}],[11,"len","","",49,{"inputs":[{"name":"once"}],"output":{"name":"usize"}}],[11,"fmt","core::iter","",50,{"inputs":[{"name":"rev"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",50,{"inputs":[{"name":"rev"}],"output":{"name":"rev"}}],[11,"next","","",50,{"inputs":[{"name":"rev"}],"output":{"name":"option"}}],[11,"size_hint","","",50,null],[11,"next_back","","",50,{"inputs":[{"name":"rev"}],"output":{"name":"option"}}],[11,"fmt","","",51,{"inputs":[{"name":"cloned"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",51,{"inputs":[{"name":"cloned"}],"output":{"name":"cloned"}}],[11,"next","","",51,{"inputs":[{"name":"cloned"}],"output":{"name":"option"}}],[11,"size_hint","","",51,null],[11,"next_back","","",51,{"inputs":[{"name":"cloned"}],"output":{"name":"option"}}],[11,"fmt","","",52,{"inputs":[{"name":"cycle"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",52,{"inputs":[{"name":"cycle"}],"output":{"name":"cycle"}}],[11,"next","","",52,{"inputs":[{"name":"cycle"}],"output":{"name":"option"}}],[11,"size_hint","","",52,null],[11,"fmt","","",53,{"inputs":[{"name":"chain"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",53,{"inputs":[{"name":"chain"}],"output":{"name":"chain"}}],[11,"next","","",53,{"inputs":[{"name":"chain"}],"output":{"name":"option"}}],[11,"count","","",53,{"inputs":[{"name":"chain"}],"output":{"name":"usize"}}],[11,"nth","","",53,{"inputs":[{"name":"chain"},{"name":"usize"}],"output":{"name":"option"}}],[11,"find","","",53,{"inputs":[{"name":"chain"},{"name":"p"}],"output":{"name":"option"}}],[11,"last","","",53,{"inputs":[{"name":"chain"}],"output":{"name":"option"}}],[11,"size_hint","","",53,null],[11,"next_back","","",53,{"inputs":[{"name":"chain"}],"output":{"name":"option"}}],[11,"fmt","","",54,{"inputs":[{"name":"zip"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",54,{"inputs":[{"name":"zip"}],"output":{"name":"zip"}}],[11,"next","","",54,{"inputs":[{"name":"zip"}],"output":{"name":"option"}}],[11,"size_hint","","",54,null],[11,"next_back","","",54,{"inputs":[{"name":"zip"}],"output":{"name":"option"}}],[11,"clone","","",55,{"inputs":[{"name":"map"}],"output":{"name":"map"}}],[11,"fmt","","",55,{"inputs":[{"name":"map"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",55,{"inputs":[{"name":"map"}],"output":{"name":"option"}}],[11,"size_hint","","",55,null],[11,"next_back","","",55,{"inputs":[{"name":"map"}],"output":{"name":"option"}}],[11,"clone","","",56,{"inputs":[{"name":"filter"}],"output":{"name":"filter"}}],[11,"fmt","","",56,{"inputs":[{"name":"filter"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",56,{"inputs":[{"name":"filter"}],"output":{"name":"option"}}],[11,"size_hint","","",56,null],[11,"next_back","","",56,{"inputs":[{"name":"filter"}],"output":{"name":"option"}}],[11,"clone","","",57,{"inputs":[{"name":"filtermap"}],"output":{"name":"filtermap"}}],[11,"fmt","","",57,{"inputs":[{"name":"filtermap"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",57,{"inputs":[{"name":"filtermap"}],"output":{"name":"option"}}],[11,"size_hint","","",57,null],[11,"next_back","","",57,{"inputs":[{"name":"filtermap"}],"output":{"name":"option"}}],[11,"fmt","","",58,{"inputs":[{"name":"enumerate"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",58,{"inputs":[{"name":"enumerate"}],"output":{"name":"enumerate"}}],[11,"next","","# Overflow Behavior",58,{"inputs":[{"name":"enumerate"}],"output":{"name":"option"}}],[11,"size_hint","","",58,null],[11,"nth","","",58,{"inputs":[{"name":"enumerate"},{"name":"usize"}],"output":{"name":"option"}}],[11,"count","","",58,{"inputs":[{"name":"enumerate"}],"output":{"name":"usize"}}],[11,"next_back","","",58,{"inputs":[{"name":"enumerate"}],"output":{"name":"option"}}],[11,"fmt","","",59,{"inputs":[{"name":"peekable"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",59,{"inputs":[{"name":"peekable"}],"output":{"name":"peekable"}}],[11,"next","","",59,{"inputs":[{"name":"peekable"}],"output":{"name":"option"}}],[11,"count","","",59,{"inputs":[{"name":"peekable"}],"output":{"name":"usize"}}],[11,"nth","","",59,{"inputs":[{"name":"peekable"},{"name":"usize"}],"output":{"name":"option"}}],[11,"last","","",59,{"inputs":[{"name":"peekable"}],"output":{"name":"option"}}],[11,"size_hint","","",59,null],[11,"peek","","Returns a reference to the next() value without advancing the iterator.",59,{"inputs":[{"name":"peekable"}],"output":{"name":"option"}}],[11,"is_empty","","Checks if the iterator has finished iterating.",59,{"inputs":[{"name":"peekable"}],"output":{"name":"bool"}}],[11,"clone","","",60,{"inputs":[{"name":"skipwhile"}],"output":{"name":"skipwhile"}}],[11,"fmt","","",60,{"inputs":[{"name":"skipwhile"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",60,{"inputs":[{"name":"skipwhile"}],"output":{"name":"option"}}],[11,"size_hint","","",60,null],[11,"clone","","",61,{"inputs":[{"name":"takewhile"}],"output":{"name":"takewhile"}}],[11,"fmt","","",61,{"inputs":[{"name":"takewhile"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",61,{"inputs":[{"name":"takewhile"}],"output":{"name":"option"}}],[11,"size_hint","","",61,null],[11,"fmt","","",62,{"inputs":[{"name":"skip"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",62,{"inputs":[{"name":"skip"}],"output":{"name":"skip"}}],[11,"next","","",62,{"inputs":[{"name":"skip"}],"output":{"name":"option"}}],[11,"nth","","",62,{"inputs":[{"name":"skip"},{"name":"usize"}],"output":{"name":"option"}}],[11,"count","","",62,{"inputs":[{"name":"skip"}],"output":{"name":"usize"}}],[11,"last","","",62,{"inputs":[{"name":"skip"}],"output":{"name":"option"}}],[11,"size_hint","","",62,null],[11,"next_back","","",62,{"inputs":[{"name":"skip"}],"output":{"name":"option"}}],[11,"fmt","","",63,{"inputs":[{"name":"take"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",63,{"inputs":[{"name":"take"}],"output":{"name":"take"}}],[11,"next","","",63,{"inputs":[{"name":"take"}],"output":{"name":"option"}}],[11,"nth","","",63,{"inputs":[{"name":"take"},{"name":"usize"}],"output":{"name":"option"}}],[11,"size_hint","","",63,null],[11,"clone","","",64,{"inputs":[{"name":"scan"}],"output":{"name":"scan"}}],[11,"fmt","","",64,{"inputs":[{"name":"scan"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",64,{"inputs":[{"name":"scan"}],"output":{"name":"option"}}],[11,"size_hint","","",64,null],[11,"clone","","",65,{"inputs":[{"name":"flatmap"}],"output":{"name":"flatmap"}}],[11,"fmt","","",65,{"inputs":[{"name":"flatmap"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",65,{"inputs":[{"name":"flatmap"}],"output":{"name":"option"}}],[11,"size_hint","","",65,null],[11,"next_back","","",65,{"inputs":[{"name":"flatmap"}],"output":{"name":"option"}}],[11,"fmt","","",66,{"inputs":[{"name":"fuse"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",66,{"inputs":[{"name":"fuse"}],"output":{"name":"fuse"}}],[11,"next","","",66,{"inputs":[{"name":"fuse"}],"output":{"name":"option"}}],[11,"nth","","",66,{"inputs":[{"name":"fuse"},{"name":"usize"}],"output":{"name":"option"}}],[11,"last","","",66,{"inputs":[{"name":"fuse"}],"output":{"name":"option"}}],[11,"count","","",66,{"inputs":[{"name":"fuse"}],"output":{"name":"usize"}}],[11,"size_hint","","",66,null],[11,"next_back","","",66,{"inputs":[{"name":"fuse"}],"output":{"name":"option"}}],[11,"clone","","",67,{"inputs":[{"name":"inspect"}],"output":{"name":"inspect"}}],[11,"fmt","","",67,{"inputs":[{"name":"inspect"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",67,{"inputs":[{"name":"inspect"}],"output":{"name":"option"}}],[11,"size_hint","","",67,null],[11,"next_back","","",67,{"inputs":[{"name":"inspect"}],"output":{"name":"option"}}],[11,"hash","core::option","",4,null],[11,"fmt","","",4,{"inputs":[{"name":"option"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"cmp","","",4,{"inputs":[{"name":"option"},{"name":"option"}],"output":{"name":"ordering"}}],[11,"partial_cmp","","",4,{"inputs":[{"name":"option"},{"name":"option"}],"output":{"name":"option"}}],[11,"lt","","",4,{"inputs":[{"name":"option"},{"name":"option"}],"output":{"name":"bool"}}],[11,"le","","",4,{"inputs":[{"name":"option"},{"name":"option"}],"output":{"name":"bool"}}],[11,"gt","","",4,{"inputs":[{"name":"option"},{"name":"option"}],"output":{"name":"bool"}}],[11,"ge","","",4,{"inputs":[{"name":"option"},{"name":"option"}],"output":{"name":"bool"}}],[11,"eq","","",4,{"inputs":[{"name":"option"},{"name":"option"}],"output":{"name":"bool"}}],[11,"ne","","",4,{"inputs":[{"name":"option"},{"name":"option"}],"output":{"name":"bool"}}],[11,"clone","","",4,{"inputs":[{"name":"option"}],"output":{"name":"option"}}],[11,"default","","",4,{"inputs":[],"output":{"name":"option"}}],[11,"into_iter","","Returns a consuming iterator over the possibly contained value.",4,{"inputs":[{"name":"option"}],"output":{"name":"intoiter"}}],[11,"fmt","","",68,{"inputs":[{"name":"iter"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",68,{"inputs":[{"name":"iter"}],"output":{"name":"option"}}],[11,"size_hint","","",68,null],[11,"next_back","","",68,{"inputs":[{"name":"iter"}],"output":{"name":"option"}}],[11,"clone","","",68,{"inputs":[{"name":"iter"}],"output":{"name":"iter"}}],[11,"fmt","","",69,{"inputs":[{"name":"itermut"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",69,{"inputs":[{"name":"itermut"}],"output":{"name":"option"}}],[11,"size_hint","","",69,null],[11,"next_back","","",69,{"inputs":[{"name":"itermut"}],"output":{"name":"option"}}],[11,"fmt","","",70,{"inputs":[{"name":"intoiter"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",70,{"inputs":[{"name":"intoiter"}],"output":{"name":"intoiter"}}],[11,"next","","",70,{"inputs":[{"name":"intoiter"}],"output":{"name":"option"}}],[11,"size_hint","","",70,null],[11,"next_back","","",70,{"inputs":[{"name":"intoiter"}],"output":{"name":"option"}}],[11,"from_iter","","Takes each element in the `Iterator`: if it is `None`, no further\nelements are taken, and the `None` is returned. Should no `None` occur, a\ncontainer with the values of each `Option` is returned.",4,{"inputs":[{"name":"i"}],"output":{"name":"option"}}],[11,"clone","core::raw","",71,{"inputs":[{"name":"slice"}],"output":{"name":"slice"}}],[11,"clone","","",72,{"inputs":[{"name":"traitobject"}],"output":{"name":"traitobject"}}],[11,"hash","core::result","",73,null],[11,"fmt","","",73,{"inputs":[{"name":"result"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"cmp","","",73,{"inputs":[{"name":"result"},{"name":"result"}],"output":{"name":"ordering"}}],[11,"partial_cmp","","",73,{"inputs":[{"name":"result"},{"name":"result"}],"output":{"name":"option"}}],[11,"lt","","",73,{"inputs":[{"name":"result"},{"name":"result"}],"output":{"name":"bool"}}],[11,"le","","",73,{"inputs":[{"name":"result"},{"name":"result"}],"output":{"name":"bool"}}],[11,"gt","","",73,{"inputs":[{"name":"result"},{"name":"result"}],"output":{"name":"bool"}}],[11,"ge","","",73,{"inputs":[{"name":"result"},{"name":"result"}],"output":{"name":"bool"}}],[11,"eq","","",73,{"inputs":[{"name":"result"},{"name":"result"}],"output":{"name":"bool"}}],[11,"ne","","",73,{"inputs":[{"name":"result"},{"name":"result"}],"output":{"name":"bool"}}],[11,"clone","","",73,{"inputs":[{"name":"result"}],"output":{"name":"result"}}],[11,"is_ok","","Returns true if the result is `Ok`",73,{"inputs":[{"name":"result"}],"output":{"name":"bool"}}],[11,"is_err","","Returns true if the result is `Err`",73,{"inputs":[{"name":"result"}],"output":{"name":"bool"}}],[11,"ok","","Converts from `Result<T, E>` to `Option<T>`",73,{"inputs":[{"name":"result"}],"output":{"name":"option"}}],[11,"err","","Converts from `Result<T, E>` to `Option<E>`",73,{"inputs":[{"name":"result"}],"output":{"name":"option"}}],[11,"as_ref","","Converts from `Result<T, E>` to `Result<&T, &E>`",73,{"inputs":[{"name":"result"}],"output":{"name":"result"}}],[11,"as_mut","","Converts from `Result<T, E>` to `Result<&mut T, &mut E>`",73,{"inputs":[{"name":"result"}],"output":{"name":"result"}}],[11,"map","","Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a\ncontained `Ok` value, leaving an `Err` value untouched.",73,{"inputs":[{"name":"result"},{"name":"f"}],"output":{"name":"result"}}],[11,"map_err","","Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a\ncontained `Err` value, leaving an `Ok` value untouched.",73,{"inputs":[{"name":"result"},{"name":"o"}],"output":{"name":"result"}}],[11,"iter","","Returns an iterator over the possibly contained value.",73,{"inputs":[{"name":"result"}],"output":{"name":"iter"}}],[11,"iter_mut","","Returns a mutable iterator over the possibly contained value.",73,{"inputs":[{"name":"result"}],"output":{"name":"itermut"}}],[11,"and","","Returns `res` if the result is `Ok`, otherwise returns the `Err` value of `self`.",73,{"inputs":[{"name":"result"},{"name":"result"}],"output":{"name":"result"}}],[11,"and_then","","Calls `op` if the result is `Ok`, otherwise returns the `Err` value of `self`.",73,{"inputs":[{"name":"result"},{"name":"f"}],"output":{"name":"result"}}],[11,"or","","Returns `res` if the result is `Err`, otherwise returns the `Ok` value of `self`.",73,{"inputs":[{"name":"result"},{"name":"result"}],"output":{"name":"result"}}],[11,"or_else","","Calls `op` if the result is `Err`, otherwise returns the `Ok` value of `self`.",73,{"inputs":[{"name":"result"},{"name":"o"}],"output":{"name":"result"}}],[11,"unwrap_or","","Unwraps a result, yielding the content of an `Ok`.\nElse it returns `optb`.",73,{"inputs":[{"name":"result"},{"name":"t"}],"output":{"name":"t"}}],[11,"unwrap_or_else","","Unwraps a result, yielding the content of an `Ok`.\nIf the value is an `Err` then it calls `op` with its value.",73,{"inputs":[{"name":"result"},{"name":"f"}],"output":{"name":"t"}}],[11,"unwrap","","Unwraps a result, yielding the content of an `Ok`.",73,{"inputs":[{"name":"result"}],"output":{"name":"t"}}],[11,"expect","","Unwraps a result, yielding the content of an `Ok`.",73,{"inputs":[{"name":"result"},{"name":"str"}],"output":{"name":"t"}}],[11,"unwrap_err","","Unwraps a result, yielding the content of an `Err`.",73,{"inputs":[{"name":"result"}],"output":{"name":"e"}}],[11,"into_iter","","Returns a consuming iterator over the possibly contained value.",73,{"inputs":[{"name":"result"}],"output":{"name":"intoiter"}}],[11,"fmt","","",74,{"inputs":[{"name":"iter"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",74,{"inputs":[{"name":"iter"}],"output":{"name":"option"}}],[11,"size_hint","","",74,null],[11,"next_back","","",74,{"inputs":[{"name":"iter"}],"output":{"name":"option"}}],[11,"clone","","",74,{"inputs":[{"name":"iter"}],"output":{"name":"iter"}}],[11,"fmt","","",75,{"inputs":[{"name":"itermut"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",75,{"inputs":[{"name":"itermut"}],"output":{"name":"option"}}],[11,"size_hint","","",75,null],[11,"next_back","","",75,{"inputs":[{"name":"itermut"}],"output":{"name":"option"}}],[11,"fmt","","",76,{"inputs":[{"name":"intoiter"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",76,{"inputs":[{"name":"intoiter"}],"output":{"name":"option"}}],[11,"size_hint","","",76,null],[11,"next_back","","",76,{"inputs":[{"name":"intoiter"}],"output":{"name":"option"}}],[11,"from_iter","","Takes each element in the `Iterator`: if it is an `Err`, no further\nelements are taken, and the `Err` is returned. Should no `Err` occur, a\ncontainer with the values of each `Result` is returned.",73,{"inputs":[{"name":"i"}],"output":{"name":"result"}}],[11,"fmt","core::slice","",77,{"inputs":[{"name":"iter"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"as_slice","","View the underlying data as a subslice of the original data.",77,null],[11,"next","","",77,{"inputs":[{"name":"iter"}],"output":{"name":"option"}}],[11,"size_hint","","",77,null],[11,"count","","",77,{"inputs":[{"name":"iter"}],"output":{"name":"usize"}}],[11,"nth","","",77,{"inputs":[{"name":"iter"},{"name":"usize"}],"output":{"name":"option"}}],[11,"last","","",77,{"inputs":[{"name":"iter"}],"output":{"name":"option"}}],[11,"next_back","","",77,{"inputs":[{"name":"iter"}],"output":{"name":"option"}}],[11,"clone","","",77,{"inputs":[{"name":"iter"}],"output":{"name":"iter"}}],[11,"fmt","","",78,{"inputs":[{"name":"itermut"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"into_slice","","View the underlying data as a subslice of the original data.",78,null],[11,"next","","",78,{"inputs":[{"name":"itermut"}],"output":{"name":"option"}}],[11,"size_hint","","",78,null],[11,"count","","",78,{"inputs":[{"name":"itermut"}],"output":{"name":"usize"}}],[11,"nth","","",78,{"inputs":[{"name":"itermut"},{"name":"usize"}],"output":{"name":"option"}}],[11,"last","","",78,{"inputs":[{"name":"itermut"}],"output":{"name":"option"}}],[11,"next_back","","",78,{"inputs":[{"name":"itermut"}],"output":{"name":"option"}}],[11,"fmt","","",79,{"inputs":[{"name":"split"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",79,{"inputs":[{"name":"split"}],"output":{"name":"split"}}],[11,"next","","",79,{"inputs":[{"name":"split"}],"output":{"name":"option"}}],[11,"size_hint","","",79,null],[11,"next_back","","",79,{"inputs":[{"name":"split"}],"output":{"name":"option"}}],[11,"fmt","","",80,{"inputs":[{"name":"splitmut"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",80,{"inputs":[{"name":"splitmut"}],"output":{"name":"option"}}],[11,"size_hint","","",80,null],[11,"next_back","","",80,{"inputs":[{"name":"splitmut"}],"output":{"name":"option"}}],[11,"fmt","","",81,{"inputs":[{"name":"splitn"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",82,{"inputs":[{"name":"rsplitn"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",83,{"inputs":[{"name":"splitnmut"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",84,{"inputs":[{"name":"rsplitnmut"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",81,{"inputs":[{"name":"splitn"}],"output":{"name":"option"}}],[11,"size_hint","","",81,null],[11,"next","","",82,{"inputs":[{"name":"rsplitn"}],"output":{"name":"option"}}],[11,"size_hint","","",82,null],[11,"next","","",83,{"inputs":[{"name":"splitnmut"}],"output":{"name":"option"}}],[11,"size_hint","","",83,null],[11,"next","","",84,{"inputs":[{"name":"rsplitnmut"}],"output":{"name":"option"}}],[11,"size_hint","","",84,null],[11,"fmt","","",85,{"inputs":[{"name":"windows"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",85,{"inputs":[{"name":"windows"}],"output":{"name":"windows"}}],[11,"next","","",85,{"inputs":[{"name":"windows"}],"output":{"name":"option"}}],[11,"size_hint","","",85,null],[11,"count","","",85,{"inputs":[{"name":"windows"}],"output":{"name":"usize"}}],[11,"nth","","",85,{"inputs":[{"name":"windows"},{"name":"usize"}],"output":{"name":"option"}}],[11,"last","","",85,{"inputs":[{"name":"windows"}],"output":{"name":"option"}}],[11,"next_back","","",85,{"inputs":[{"name":"windows"}],"output":{"name":"option"}}],[11,"fmt","","",86,{"inputs":[{"name":"chunks"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",86,{"inputs":[{"name":"chunks"}],"output":{"name":"chunks"}}],[11,"next","","",86,{"inputs":[{"name":"chunks"}],"output":{"name":"option"}}],[11,"size_hint","","",86,null],[11,"count","","",86,{"inputs":[{"name":"chunks"}],"output":{"name":"usize"}}],[11,"nth","","",86,{"inputs":[{"name":"chunks"},{"name":"usize"}],"output":{"name":"option"}}],[11,"last","","",86,{"inputs":[{"name":"chunks"}],"output":{"name":"option"}}],[11,"next_back","","",86,{"inputs":[{"name":"chunks"}],"output":{"name":"option"}}],[11,"fmt","","",87,{"inputs":[{"name":"chunksmut"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",87,{"inputs":[{"name":"chunksmut"}],"output":{"name":"option"}}],[11,"size_hint","","",87,null],[11,"count","","",87,{"inputs":[{"name":"chunksmut"}],"output":{"name":"usize"}}],[11,"nth","","",87,{"inputs":[{"name":"chunksmut"},{"name":"usize"}],"output":{"name":"option"}}],[11,"last","","",87,{"inputs":[{"name":"chunksmut"}],"output":{"name":"option"}}],[11,"next_back","","",87,{"inputs":[{"name":"chunksmut"}],"output":{"name":"option"}}],[11,"fmt","core::str::pattern","",88,{"inputs":[{"name":"searchstep"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"eq","","",88,{"inputs":[{"name":"searchstep"},{"name":"searchstep"}],"output":{"name":"bool"}}],[11,"ne","","",88,{"inputs":[{"name":"searchstep"},{"name":"searchstep"}],"output":{"name":"bool"}}],[11,"clone","","",88,{"inputs":[{"name":"searchstep"}],"output":{"name":"searchstep"}}],[11,"fmt","","",89,{"inputs":[{"name":"charsearcher"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",89,{"inputs":[{"name":"charsearcher"}],"output":{"name":"charsearcher"}}],[11,"haystack","","",89,{"inputs":[{"name":"charsearcher"}],"output":{"name":"str"}}],[11,"next","","",89,{"inputs":[{"name":"charsearcher"}],"output":{"name":"searchstep"}}],[11,"next_match","","",89,{"inputs":[{"name":"charsearcher"}],"output":{"name":"option"}}],[11,"next_reject","","",89,{"inputs":[{"name":"charsearcher"}],"output":{"name":"option"}}],[11,"next_back","","",89,{"inputs":[{"name":"charsearcher"}],"output":{"name":"searchstep"}}],[11,"next_match_back","","",89,{"inputs":[{"name":"charsearcher"}],"output":{"name":"option"}}],[11,"next_reject_back","","",89,{"inputs":[{"name":"charsearcher"}],"output":{"name":"option"}}],[11,"fmt","","",90,{"inputs":[{"name":"charslicesearcher"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",90,{"inputs":[{"name":"charslicesearcher"}],"output":{"name":"charslicesearcher"}}],[11,"haystack","","",90,{"inputs":[{"name":"charslicesearcher"}],"output":{"name":"str"}}],[11,"next","","",90,{"inputs":[{"name":"charslicesearcher"}],"output":{"name":"searchstep"}}],[11,"next_match","","",90,{"inputs":[{"name":"charslicesearcher"}],"output":{"name":"option"}}],[11,"next_reject","","",90,{"inputs":[{"name":"charslicesearcher"}],"output":{"name":"option"}}],[11,"next_back","","",90,{"inputs":[{"name":"charslicesearcher"}],"output":{"name":"searchstep"}}],[11,"next_match_back","","",90,{"inputs":[{"name":"charslicesearcher"}],"output":{"name":"option"}}],[11,"next_reject_back","","",90,{"inputs":[{"name":"charslicesearcher"}],"output":{"name":"option"}}],[11,"clone","","",91,{"inputs":[{"name":"charpredicatesearcher"}],"output":{"name":"charpredicatesearcher"}}],[11,"fmt","","",91,{"inputs":[{"name":"charpredicatesearcher"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"haystack","","",91,{"inputs":[{"name":"charpredicatesearcher"}],"output":{"name":"str"}}],[11,"next","","",91,{"inputs":[{"name":"charpredicatesearcher"}],"output":{"name":"searchstep"}}],[11,"next_match","","",91,{"inputs":[{"name":"charpredicatesearcher"}],"output":{"name":"option"}}],[11,"next_reject","","",91,{"inputs":[{"name":"charpredicatesearcher"}],"output":{"name":"option"}}],[11,"next_back","","",91,{"inputs":[{"name":"charpredicatesearcher"}],"output":{"name":"searchstep"}}],[11,"next_match_back","","",91,{"inputs":[{"name":"charpredicatesearcher"}],"output":{"name":"option"}}],[11,"next_reject_back","","",91,{"inputs":[{"name":"charpredicatesearcher"}],"output":{"name":"option"}}],[11,"fmt","","",92,{"inputs":[{"name":"strsearcher"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",92,{"inputs":[{"name":"strsearcher"}],"output":{"name":"strsearcher"}}],[11,"haystack","","",92,{"inputs":[{"name":"strsearcher"}],"output":{"name":"str"}}],[11,"next","","",92,{"inputs":[{"name":"strsearcher"}],"output":{"name":"searchstep"}}],[11,"next_match","","",92,{"inputs":[{"name":"strsearcher"}],"output":{"name":"option"}}],[11,"next_back","","",92,{"inputs":[{"name":"strsearcher"}],"output":{"name":"searchstep"}}],[11,"next_match_back","","",92,{"inputs":[{"name":"strsearcher"}],"output":{"name":"option"}}],[11,"eq","core::str","",93,{"inputs":[{"name":"parseboolerror"},{"name":"parseboolerror"}],"output":{"name":"bool"}}],[11,"ne","","",93,{"inputs":[{"name":"parseboolerror"},{"name":"parseboolerror"}],"output":{"name":"bool"}}],[11,"clone","","",93,{"inputs":[{"name":"parseboolerror"}],"output":{"name":"parseboolerror"}}],[11,"fmt","","",93,{"inputs":[{"name":"parseboolerror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",93,{"inputs":[{"name":"parseboolerror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",94,{"inputs":[{"name":"utf8error"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",94,{"inputs":[{"name":"utf8error"}],"output":{"name":"utf8error"}}],[11,"eq","","",94,{"inputs":[{"name":"utf8error"},{"name":"utf8error"}],"output":{"name":"bool"}}],[11,"ne","","",94,{"inputs":[{"name":"utf8error"},{"name":"utf8error"}],"output":{"name":"bool"}}],[11,"valid_up_to","","Returns the index in the given string up to which valid UTF-8 was\nverified.",94,{"inputs":[{"name":"utf8error"}],"output":{"name":"usize"}}],[11,"fmt","","",94,{"inputs":[{"name":"utf8error"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",95,{"inputs":[{"name":"chars"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",95,{"inputs":[{"name":"chars"}],"output":{"name":"chars"}}],[11,"next","","",95,{"inputs":[{"name":"chars"}],"output":{"name":"option"}}],[11,"size_hint","","",95,null],[11,"next_back","","",95,{"inputs":[{"name":"chars"}],"output":{"name":"option"}}],[11,"as_str","","View the underlying data as a subslice of the original data.",95,{"inputs":[{"name":"chars"}],"output":{"name":"str"}}],[11,"fmt","","",96,{"inputs":[{"name":"charindices"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",96,{"inputs":[{"name":"charindices"}],"output":{"name":"charindices"}}],[11,"next","","",96,{"inputs":[{"name":"charindices"}],"output":{"name":"option"}}],[11,"size_hint","","",96,null],[11,"next_back","","",96,{"inputs":[{"name":"charindices"}],"output":{"name":"option"}}],[11,"as_str","","View the underlying data as a subslice of the original data.",96,{"inputs":[{"name":"charindices"}],"output":{"name":"str"}}],[11,"fmt","","",97,{"inputs":[{"name":"bytes"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",97,{"inputs":[{"name":"bytes"}],"output":{"name":"bytes"}}],[11,"next","","",97,{"inputs":[{"name":"bytes"}],"output":{"name":"option"}}],[11,"size_hint","","",97,null],[11,"count","","",97,{"inputs":[{"name":"bytes"}],"output":{"name":"usize"}}],[11,"last","","",97,{"inputs":[{"name":"bytes"}],"output":{"name":"option"}}],[11,"nth","","",97,{"inputs":[{"name":"bytes"},{"name":"usize"}],"output":{"name":"option"}}],[11,"next_back","","",97,{"inputs":[{"name":"bytes"}],"output":{"name":"option"}}],[11,"len","","",97,{"inputs":[{"name":"bytes"}],"output":{"name":"usize"}}],[11,"fmt","","",98,{"inputs":[{"name":"split"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",98,{"inputs":[{"name":"split"}],"output":{"name":"option"}}],[11,"clone","","",98,{"inputs":[{"name":"split"}],"output":{"name":"split"}}],[11,"fmt","","",99,{"inputs":[{"name":"rsplit"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",99,{"inputs":[{"name":"rsplit"}],"output":{"name":"option"}}],[11,"clone","","",99,{"inputs":[{"name":"rsplit"}],"output":{"name":"rsplit"}}],[11,"next_back","","",98,{"inputs":[{"name":"split"}],"output":{"name":"option"}}],[11,"next_back","","",99,{"inputs":[{"name":"rsplit"}],"output":{"name":"option"}}],[11,"fmt","","",100,{"inputs":[{"name":"splitterminator"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",100,{"inputs":[{"name":"splitterminator"}],"output":{"name":"option"}}],[11,"clone","","",100,{"inputs":[{"name":"splitterminator"}],"output":{"name":"splitterminator"}}],[11,"fmt","","",101,{"inputs":[{"name":"rsplitterminator"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",101,{"inputs":[{"name":"rsplitterminator"}],"output":{"name":"option"}}],[11,"clone","","",101,{"inputs":[{"name":"rsplitterminator"}],"output":{"name":"rsplitterminator"}}],[11,"next_back","","",100,{"inputs":[{"name":"splitterminator"}],"output":{"name":"option"}}],[11,"next_back","","",101,{"inputs":[{"name":"rsplitterminator"}],"output":{"name":"option"}}],[11,"fmt","","",102,{"inputs":[{"name":"splitn"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",102,{"inputs":[{"name":"splitn"}],"output":{"name":"option"}}],[11,"clone","","",102,{"inputs":[{"name":"splitn"}],"output":{"name":"splitn"}}],[11,"fmt","","",103,{"inputs":[{"name":"rsplitn"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",103,{"inputs":[{"name":"rsplitn"}],"output":{"name":"option"}}],[11,"clone","","",103,{"inputs":[{"name":"rsplitn"}],"output":{"name":"rsplitn"}}],[11,"fmt","","",104,{"inputs":[{"name":"matchindices"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",104,{"inputs":[{"name":"matchindices"}],"output":{"name":"option"}}],[11,"clone","","",104,{"inputs":[{"name":"matchindices"}],"output":{"name":"matchindices"}}],[11,"fmt","","",105,{"inputs":[{"name":"rmatchindices"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",105,{"inputs":[{"name":"rmatchindices"}],"output":{"name":"option"}}],[11,"clone","","",105,{"inputs":[{"name":"rmatchindices"}],"output":{"name":"rmatchindices"}}],[11,"next_back","","",104,{"inputs":[{"name":"matchindices"}],"output":{"name":"option"}}],[11,"next_back","","",105,{"inputs":[{"name":"rmatchindices"}],"output":{"name":"option"}}],[11,"fmt","","",106,{"inputs":[{"name":"matches"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",106,{"inputs":[{"name":"matches"}],"output":{"name":"option"}}],[11,"clone","","",106,{"inputs":[{"name":"matches"}],"output":{"name":"matches"}}],[11,"fmt","","",107,{"inputs":[{"name":"rmatches"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"next","","",107,{"inputs":[{"name":"rmatches"}],"output":{"name":"option"}}],[11,"clone","","",107,{"inputs":[{"name":"rmatches"}],"output":{"name":"rmatches"}}],[11,"next_back","","",106,{"inputs":[{"name":"matches"}],"output":{"name":"option"}}],[11,"next_back","","",107,{"inputs":[{"name":"rmatches"}],"output":{"name":"option"}}],[11,"fmt","","",108,{"inputs":[{"name":"lines"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",108,{"inputs":[{"name":"lines"}],"output":{"name":"lines"}}],[11,"next","","",108,{"inputs":[{"name":"lines"}],"output":{"name":"option"}}],[11,"size_hint","","",108,null],[11,"next_back","","",108,{"inputs":[{"name":"lines"}],"output":{"name":"option"}}],[11,"fmt","","",109,{"inputs":[{"name":"linesany"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",109,{"inputs":[{"name":"linesany"}],"output":{"name":"linesany"}}],[11,"next","","",109,{"inputs":[{"name":"linesany"}],"output":{"name":"option"}}],[11,"size_hint","","",109,null],[11,"next_back","","",109,{"inputs":[{"name":"linesany"}],"output":{"name":"option"}}],[11,"fmt","","",110,{"inputs":[{"name":"charrange"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",110,{"inputs":[{"name":"charrange"}],"output":{"name":"charrange"}}],[11,"fmt","core::hash::sip","",111,{"inputs":[{"name":"siphasher"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"new","","Creates a new `SipHasher` with the two initial keys set to 0.",111,{"inputs":[],"output":{"name":"siphasher"}}],[11,"new_with_keys","","Creates a `SipHasher` that is keyed off the provided keys.",111,{"inputs":[{"name":"u64"},{"name":"u64"}],"output":{"name":"siphasher"}}],[11,"write","","",111,null],[11,"finish","","",111,{"inputs":[{"name":"siphasher"}],"output":{"name":"u64"}}],[11,"clone","","",111,{"inputs":[{"name":"siphasher"}],"output":{"name":"siphasher"}}],[11,"default","","",111,{"inputs":[],"output":{"name":"siphasher"}}],[11,"fmt","core::hash","",112,{"inputs":[{"name":"buildhasherdefault"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"build_hasher","","",112,{"inputs":[{"name":"buildhasherdefault"}],"output":{"name":"h"}}],[11,"clone","","",112,{"inputs":[{"name":"buildhasherdefault"}],"output":{"name":"buildhasherdefault"}}],[11,"default","","",112,{"inputs":[],"output":{"name":"buildhasherdefault"}}],[11,"fmt","core::fmt","",113,{"inputs":[{"name":"alignment"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"field","core::fmt::builders","Adds a new field to the generated struct output.",114,{"inputs":[{"name":"debugstruct"},{"name":"str"},{"name":"debug"}],"output":{"name":"debugstruct"}}],[11,"finish","","Finishes output and returns any error encountered.",114,{"inputs":[{"name":"debugstruct"}],"output":{"name":"result"}}],[11,"field","","Adds a new field to the generated tuple struct output.",115,{"inputs":[{"name":"debugtuple"},{"name":"debug"}],"output":{"name":"debugtuple"}}],[11,"finish","","Finishes output and returns any error encountered.",115,{"inputs":[{"name":"debugtuple"}],"output":{"name":"result"}}],[11,"entry","","Adds a new entry to the set output.",116,{"inputs":[{"name":"debugset"},{"name":"debug"}],"output":{"name":"debugset"}}],[11,"entries","","Adds the contents of an iterator of entries to the set output.",116,{"inputs":[{"name":"debugset"},{"name":"i"}],"output":{"name":"debugset"}}],[11,"finish","","Finishes output and returns any error encountered.",116,{"inputs":[{"name":"debugset"}],"output":{"name":"result"}}],[11,"entry","","Adds a new entry to the list output.",117,{"inputs":[{"name":"debuglist"},{"name":"debug"}],"output":{"name":"debuglist"}}],[11,"entries","","Adds the contents of an iterator of entries to the list output.",117,{"inputs":[{"name":"debuglist"},{"name":"i"}],"output":{"name":"debuglist"}}],[11,"finish","","Finishes output and returns any error encountered.",117,{"inputs":[{"name":"debuglist"}],"output":{"name":"result"}}],[11,"entry","","Adds a new entry to the map output.",118,{"inputs":[{"name":"debugmap"},{"name":"debug"},{"name":"debug"}],"output":{"name":"debugmap"}}],[11,"entries","","Adds the contents of an iterator of entries to the map output.",118,{"inputs":[{"name":"debugmap"},{"name":"i"}],"output":{"name":"debugmap"}}],[11,"finish","","Finishes output and returns any error encountered.",118,{"inputs":[{"name":"debugmap"}],"output":{"name":"result"}}],[11,"partial_cmp","core::fmt","",119,{"inputs":[{"name":"error"},{"name":"error"}],"output":{"name":"option"}}],[11,"eq","","",119,{"inputs":[{"name":"error"},{"name":"error"}],"output":{"name":"bool"}}],[11,"cmp","","",119,{"inputs":[{"name":"error"},{"name":"error"}],"output":{"name":"ordering"}}],[11,"hash","","",119,null],[11,"default","","",119,{"inputs":[],"output":{"name":"error"}}],[11,"fmt","","",119,{"inputs":[{"name":"error"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",119,{"inputs":[{"name":"error"}],"output":{"name":"error"}}],[11,"clone","","",120,{"inputs":[{"name":"arguments"}],"output":{"name":"arguments"}}],[11,"fmt","","",120,{"inputs":[{"name":"arguments"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",120,{"inputs":[{"name":"arguments"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"pad_integral","","Performs the correct padding for an integer which has already been\nemitted into a str. The str should *not* contain the sign for the\ninteger, that will be added by this method.",121,{"inputs":[{"name":"formatter"},{"name":"bool"},{"name":"str"},{"name":"str"}],"output":{"name":"result"}}],[11,"pad","","This function takes a string slice and emits it to the internal buffer\nafter applying the relevant formatting flags specified. The flags\nrecognized for generic strings are:",121,{"inputs":[{"name":"formatter"},{"name":"str"}],"output":{"name":"result"}}],[11,"write_str","","Writes some data to the underlying buffer contained within this\nformatter.",121,{"inputs":[{"name":"formatter"},{"name":"str"}],"output":{"name":"result"}}],[11,"write_fmt","","Writes some formatted information into this instance",121,{"inputs":[{"name":"formatter"},{"name":"arguments"}],"output":{"name":"result"}}],[11,"flags","","Flags for formatting (packed version of rt::Flag)",121,{"inputs":[{"name":"formatter"}],"output":{"name":"u32"}}],[11,"fill","","Character used as 'fill' whenever there is alignment",121,{"inputs":[{"name":"formatter"}],"output":{"name":"char"}}],[11,"align","","Flag indicating what form of alignment was requested",121,{"inputs":[{"name":"formatter"}],"output":{"name":"alignment"}}],[11,"width","","Optionally specified integer width that the output should be",121,{"inputs":[{"name":"formatter"}],"output":{"name":"option"}}],[11,"precision","","Optionally specified precision for numeric types",121,{"inputs":[{"name":"formatter"}],"output":{"name":"option"}}],[11,"sign_plus","","Determines if the `+` flag was specified.",121,{"inputs":[{"name":"formatter"}],"output":{"name":"bool"}}],[11,"sign_minus","","Determines if the `-` flag was specified.",121,{"inputs":[{"name":"formatter"}],"output":{"name":"bool"}}],[11,"alternate","","Determines if the `#` flag was specified.",121,{"inputs":[{"name":"formatter"}],"output":{"name":"bool"}}],[11,"sign_aware_zero_pad","","Determines if the `0` flag was specified.",121,{"inputs":[{"name":"formatter"}],"output":{"name":"bool"}}],[11,"debug_struct","","Creates a `DebugStruct` builder designed to assist with creation of\n`fmt::Debug` implementations for structs.",121,{"inputs":[{"name":"formatter"},{"name":"str"}],"output":{"name":"debugstruct"}}],[11,"debug_tuple","","Creates a `DebugTuple` builder designed to assist with creation of\n`fmt::Debug` implementations for tuple structs.",121,{"inputs":[{"name":"formatter"},{"name":"str"}],"output":{"name":"debugtuple"}}],[11,"debug_list","","Creates a `DebugList` builder designed to assist with creation of\n`fmt::Debug` implementations for list-like structures.",121,{"inputs":[{"name":"formatter"}],"output":{"name":"debuglist"}}],[11,"debug_set","","Creates a `DebugSet` builder designed to assist with creation of\n`fmt::Debug` implementations for set-like structures.",121,{"inputs":[{"name":"formatter"}],"output":{"name":"debugset"}}],[11,"debug_map","","Creates a `DebugMap` builder designed to assist with creation of\n`fmt::Debug` implementations for map-like structures.",121,{"inputs":[{"name":"formatter"}],"output":{"name":"debugmap"}}],[11,"write_str","","",121,{"inputs":[{"name":"formatter"},{"name":"str"}],"output":{"name":"result"}}],[11,"write_char","","",121,{"inputs":[{"name":"formatter"},{"name":"char"}],"output":{"name":"result"}}],[11,"write_fmt","","",121,{"inputs":[{"name":"formatter"},{"name":"arguments"}],"output":{"name":"result"}}],[11,"fmt","","",119,{"inputs":[{"name":"error"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","core::marker","",13,{"inputs":[{"name":"phantomdata"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","core::cell","",36,{"inputs":[{"name":"cell"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",38,{"inputs":[{"name":"refcell"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",39,{"inputs":[{"name":"ref"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",40,{"inputs":[{"name":"refmut"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",41,{"inputs":[{"name":"unsafecell"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone_from","libc::dox","Performs copy-assignment from `source`.",122,null],[11,"clone_from","libc::dox::imp","Performs copy-assignment from `source`.",122,null],[11,"clone","libc","",0,{"inputs":[{"name":"stat"}],"output":{"name":"stat"}}],[11,"clone","","",1,{"inputs":[{"name":"utimbuf"}],"output":{"name":"utimbuf"}}],[11,"clone","","",2,{"inputs":[{"name":"timeval"}],"output":{"name":"timeval"}}],[11,"clone","","",3,{"inputs":[{"name":"timespec"}],"output":{"name":"timespec"}}],[6,"int8_t","","",null,null],[6,"int16_t","","",null,null],[6,"int32_t","","",null,null],[6,"int64_t","","",null,null],[6,"uint8_t","","",null,null],[6,"uint16_t","","",null,null],[6,"uint32_t","","",null,null],[6,"uint64_t","","",null,null],[6,"c_schar","","",null,null],[6,"c_uchar","","",null,null],[6,"c_short","","",null,null],[6,"c_ushort","","",null,null],[6,"c_int","","",null,null],[6,"c_uint","","",null,null],[6,"c_float","","",null,null],[6,"c_double","","",null,null],[6,"c_longlong","","",null,null],[6,"c_ulonglong","","",null,null],[6,"intmax_t","","",null,null],[6,"uintmax_t","","",null,null],[6,"size_t","","",null,null],[6,"ptrdiff_t","","",null,null],[6,"intptr_t","","",null,null],[6,"uintptr_t","","",null,null],[6,"ssize_t","","",null,null],[6,"c_char","","",null,null],[6,"c_long","","",null,null],[6,"c_ulong","","",null,null],[6,"wchar_t","","",null,null],[6,"clock_t","","",null,null],[6,"time_t","","",null,null],[6,"off_t","","",null,null],[6,"dev_t","","",null,null],[6,"ino_t","","",null,null],[6,"time64_t","","",null,null],[17,"EXIT_FAILURE","","",null,null],[17,"EXIT_SUCCESS","","",null,null],[17,"RAND_MAX","","",null,null],[17,"EOF","","",null,null],[17,"SEEK_SET","","",null,null],[17,"SEEK_CUR","","",null,null],[17,"SEEK_END","","",null,null],[17,"_IOFBF","","",null,null],[17,"_IONBF","","",null,null],[17,"_IOLBF","","",null,null],[17,"BUFSIZ","","",null,null],[17,"FOPEN_MAX","","",null,null],[17,"FILENAME_MAX","","",null,null],[17,"L_tmpnam","","",null,null],[17,"TMP_MAX","","",null,null],[17,"O_RDONLY","","",null,null],[17,"O_WRONLY","","",null,null],[17,"O_RDWR","","",null,null],[17,"O_APPEND","","",null,null],[17,"O_CREAT","","",null,null],[17,"O_EXCL","","",null,null],[17,"O_TEXT","","",null,null],[17,"O_BINARY","","",null,null],[17,"O_NOINHERIT","","",null,null],[17,"O_TRUNC","","",null,null],[17,"S_IFCHR","","",null,null],[17,"S_IFDIR","","",null,null],[17,"S_IFREG","","",null,null],[17,"S_IFMT","","",null,null],[17,"S_IEXEC","","",null,null],[17,"S_IWRITE","","",null,null],[17,"S_IREAD","","",null,null]],"paths":[[3,"stat"],[3,"utimbuf"],[3,"timeval"],[3,"timespec"],[4,"Option"],[3,"Wrapping"],[3,"ParseFloatError"],[4,"FpCategory"],[3,"TryFromIntError"],[3,"ParseIntError"],[3,"NonZero"],[3,"Unique"],[3,"Shared"],[3,"PhantomData"],[3,"RangeFull"],[3,"Range"],[3,"RangeFrom"],[3,"RangeTo"],[4,"RangeInclusive"],[3,"RangeToInclusive"],[4,"Ordering"],[8,"Any"],[3,"TypeId"],[3,"AtomicBool"],[3,"AtomicPtr"],[4,"Ordering"],[3,"AtomicI8"],[3,"AtomicU8"],[3,"AtomicI16"],[3,"AtomicU16"],[3,"AtomicI32"],[3,"AtomicU32"],[3,"AtomicI64"],[3,"AtomicU64"],[3,"AtomicIsize"],[3,"AtomicUsize"],[3,"Cell"],[4,"BorrowState"],[3,"RefCell"],[3,"Ref"],[3,"RefMut"],[3,"UnsafeCell"],[3,"EscapeUnicode"],[3,"EscapeDefault"],[3,"EncodeUtf8"],[3,"EncodeUtf16"],[3,"StepBy"],[3,"Repeat"],[3,"Empty"],[3,"Once"],[3,"Rev"],[3,"Cloned"],[3,"Cycle"],[3,"Chain"],[3,"Zip"],[3,"Map"],[3,"Filter"],[3,"FilterMap"],[3,"Enumerate"],[3,"Peekable"],[3,"SkipWhile"],[3,"TakeWhile"],[3,"Skip"],[3,"Take"],[3,"Scan"],[3,"FlatMap"],[3,"Fuse"],[3,"Inspect"],[3,"Iter"],[3,"IterMut"],[3,"IntoIter"],[3,"Slice"],[3,"TraitObject"],[4,"Result"],[3,"Iter"],[3,"IterMut"],[3,"IntoIter"],[3,"Iter"],[3,"IterMut"],[3,"Split"],[3,"SplitMut"],[3,"SplitN"],[3,"RSplitN"],[3,"SplitNMut"],[3,"RSplitNMut"],[3,"Windows"],[3,"Chunks"],[3,"ChunksMut"],[4,"SearchStep"],[3,"CharSearcher"],[3,"CharSliceSearcher"],[3,"CharPredicateSearcher"],[3,"StrSearcher"],[3,"ParseBoolError"],[3,"Utf8Error"],[3,"Chars"],[3,"CharIndices"],[3,"Bytes"],[3,"Split"],[3,"RSplit"],[3,"SplitTerminator"],[3,"RSplitTerminator"],[3,"SplitN"],[3,"RSplitN"],[3,"MatchIndices"],[3,"RMatchIndices"],[3,"Matches"],[3,"RMatches"],[3,"Lines"],[3,"LinesAny"],[3,"CharRange"],[3,"SipHasher"],[3,"BuildHasherDefault"],[4,"Alignment"],[3,"DebugStruct"],[3,"DebugTuple"],[3,"DebugSet"],[3,"DebugList"],[3,"DebugMap"],[3,"Error"],[3,"Arguments"],[3,"Formatter"],[8,"Clone"]]};
+searchIndex["hamming"] = {"doc":"A crate to count ones and xor bytes, fast (aka popcount, hamming\nweight and hamming distance).","items":[[5,"weight","hamming","Computes the [Hamming\nweight](https://en.wikipedia.org/wiki/Hamming_weight) of `x`, that\nis, the population count, or number of ones.",null,null],[5,"distance","","Computes the bitwise [Hamming\ndistance](https://en.wikipedia.org/wiki/Hamming_distance) between\n`x` and `y`, that is, the number of bits where `x` and `y` differ,\nor, the number of set bits in the xor of `x` and `y`.",null,null],[5,"distance_fast","","Computes the bitwise [Hamming\ndistance](https://en.wikipedia.org/wiki/Hamming_distance) between\n`x` and `y`, that is, the number of bits where `x` and `y` differ,\nor, the number of set bits in the xor of `x` and `y`.",null,null]],"paths":[]};
+searchIndex["newtype_derive"] = {"doc":"This crate provides several macros for deriving implementations of various traits for "newtype" wrappers (*i.e.* tuple structs with a single element).  That is, given a tuple struct with exactly one field (*e.g.* `struct Buckets(i32)`), these macros will derive "obvious" implementations of traits such as `Add`, `Neg`, `Index`, `Deref`, `From`, etc.","items":[[14,"NewtypeAdd!","newtype_derive","",null,null],[14,"NewtypeBitAnd!","","",null,null],[14,"NewtypeBitOr!","","",null,null],[14,"NewtypeBitXor!","","",null,null],[14,"NewtypeDiv!","","",null,null],[14,"NewtypeMul!","","",null,null],[14,"NewtypeRem!","","",null,null],[14,"NewtypeSub!","","",null,null],[14,"NewtypeShl!","","",null,null],[14,"NewtypeShr!","","",null,null],[14,"NewtypeNeg!","","",null,null],[14,"NewtypeNot!","","",null,null],[14,"NewtypeDeref!","","",null,null],[14,"NewtypeDerefMut!","","",null,null],[14,"NewtypeIndex!","","",null,null],[14,"NewtypeIndexMut!","","",null,null],[14,"NewtypeFrom!","","",null,null],[14,"NewtypeBinary!","","",null,null],[14,"NewtypeDebug!","","",null,null],[14,"NewtypeDisplay!","","",null,null],[14,"NewtypeLowerExp!","","",null,null],[14,"NewtypeLowerHex!","","",null,null],[14,"NewtypeOctal!","","",null,null],[14,"NewtypePointer!","","",null,null],[14,"NewtypeUpperExp!","","",null,null],[14,"NewtypeUpperHex!","","",null,null]],"paths":[]};
+searchIndex["custom_derive"] = {"doc":"This crate provides a macro that enables the use of custom `derive` attributes.","items":[],"paths":[]};
 initSearch(searchIndex);
diff --git a/src/custom_derive/lib.rs.html b/src/custom_derive/lib.rs.html
index b252249..c6fd112 100644
--- a/src/custom_derive/lib.rs.html
+++ b/src/custom_derive/lib.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     lib.rs.html -- source
@@ -581,7 +581,7 @@ Finally, `@impl` is merely a trick to pack multiple, different functions into a
         enum $($it:tt)*
     ) => {
         custom_derive! {
-            @split_attrs
+            @split_attrs
             ($(#[$($attrs)*],)*), (), (),
             (enum $($it)*)
         }
@@ -592,7 +592,7 @@ Finally, `@impl` is merely a trick to pack multiple, different functions into a
         pub $($it:tt)*
     ) => {
         custom_derive! {
-            @split_attrs
+            @split_attrs
             ($(#[$($attrs)*],)*), (), (),
             (pub $($it)*)
         }
@@ -603,7 +603,7 @@ Finally, `@impl` is merely a trick to pack multiple, different functions into a
         struct $($it:tt)*
     ) => {
         custom_derive! {
-            @split_attrs
+            @split_attrs
             ($(#[$($attrs)*],)*), (), (),
             (struct $($it)*)
         }
@@ -622,14 +622,14 @@ Finally, `@impl` is merely a trick to pack multiple, different functions into a
 
     */
     (
-        @split_attrs
+        @split_attrs
         (),
         $non_derives:tt,
         $derives:tt,
         $it:tt
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             { $non_derives, $it },
             $derives,
             (),
@@ -638,14 +638,14 @@ Finally, `@impl` is merely a trick to pack multiple, different functions into a
     };
 
     (
-        @split_attrs
+        @split_attrs
         (#[derive($($new_drv:ident $(($($new_drv_args:tt)*))*),* $(,)*)], $(#[$($attrs:tt)*],)*),
         $non_derives:tt,
         ($($derives:ident,)*),
         $it:tt
     ) => {
         custom_derive! {
-            @split_attrs
+            @split_attrs
             ($(#[$($attrs)*],)*),
             $non_derives,
             ($($derives,)* $($new_drv $(($($new_drv_args)*))*,)*),
@@ -654,14 +654,14 @@ Finally, `@impl` is merely a trick to pack multiple, different functions into a
     };
 
     (
-        @split_attrs
+        @split_attrs
         (#[$new_attr:meta], $(#[$($attrs:tt)*],)*),
         ($($non_derives:tt)*),
         $derives:tt,
         $it:tt
     ) => {
         custom_derive! {
-            @split_attrs
+            @split_attrs
             ($(#[$($attrs)*],)*),
             ($($non_derives)* #[$new_attr],),
             $derives,
@@ -682,177 +682,177 @@ Finally, `@impl` is merely a trick to pack multiple, different functions into a
     And yes, as far as I can see, we *have* to have a separate rule for each of those.  What I wouldn't give for an alternation pattern...
     */
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         { ($(#[$($non_derives:tt)*],)*), ($($it:tt)*) },
         (), (), ($($user_drvs:tt)*)
     ) => {
         custom_derive! {
-            @as_item
+            @as_item
             $(#[$($non_derives)*])*
             $($it)*
         }
 
         custom_derive! {
-            @expand_user_drvs
+            @expand_user_drvs
             ($($user_drvs)*), ($($it)*)
         }
     };
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         { ($(#[$($non_derives:tt)*],)*), ($($it:tt)*) },
         (), ($($bi_drvs:ident,)+), ($($user_drvs:tt)*)
     ) => {
         custom_derive! {
-            @as_item
+            @as_item
             #[derive($($bi_drvs,)+)]
             $(#[$($non_derives)*])*
             $($it)*
         }
 
         custom_derive! {
-            @expand_user_drvs
+            @expand_user_drvs
             ($($user_drvs)*), ($($it)*)
         }
     };
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         $fixed:tt,
         (Hash, $($tail:tt)*), ($($bi_drvs:ident,)*), $user_drvs:tt
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             $fixed,
             ($($tail)*), ($($bi_drvs,)* Hash,), $user_drvs
         }
     };
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         $fixed:tt,
         (Clone, $($tail:tt)*), ($($bi_drvs:ident,)*), $user_drvs:tt
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             $fixed,
             ($($tail)*), ($($bi_drvs,)* Clone,), $user_drvs
         }
     };
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         $fixed:tt,
         (RustcEncodable, $($tail:tt)*), ($($bi_drvs:ident,)*), $user_drvs:tt
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             $fixed,
             ($($tail)*), ($($bi_drvs,)* RustcEncodable,), $user_drvs
         }
     };
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         $fixed:tt,
         (RustcDecodable, $($tail:tt)*), ($($bi_drvs:ident,)*), $user_drvs:tt
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             $fixed,
             ($($tail)*), ($($bi_drvs,)* RustcDecodable,), $user_drvs
         }
     };
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         $fixed:tt,
         (PartialEq, $($tail:tt)*), ($($bi_drvs:ident,)*), $user_drvs:tt
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             $fixed,
             ($($tail)*), ($($bi_drvs,)* PartialEq,), $user_drvs
         }
     };
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         $fixed:tt,
         (Eq, $($tail:tt)*), ($($bi_drvs:ident,)*), $user_drvs:tt
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             $fixed,
             ($($tail)*), ($($bi_drvs,)* Eq,), $user_drvs
         }
     };
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         $fixed:tt,
         (PartialOrd, $($tail:tt)*), ($($bi_drvs:ident,)*), $user_drvs:tt
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             $fixed,
             ($($tail)*), ($($bi_drvs,)* PartialOrd,), $user_drvs
         }
     };
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         $fixed:tt,
         (Ord, $($tail:tt)*), ($($bi_drvs:ident,)*), $user_drvs:tt
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             $fixed,
             ($($tail)*), ($($bi_drvs,)* Ord,), $user_drvs
         }
     };
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         $fixed:tt,
         (Debug, $($tail:tt)*), ($($bi_drvs:ident,)*), $user_drvs:tt
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             $fixed,
             ($($tail)*), ($($bi_drvs,)* Debug,), $user_drvs
         }
     };
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         $fixed:tt,
         (Default, $($tail:tt)*), ($($bi_drvs:ident,)*), $user_drvs:tt
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             $fixed,
             ($($tail)*), ($($bi_drvs,)* Default,), $user_drvs
         }
     };
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         $fixed:tt,
         (Send ,$($tail:tt)*), ($($bi_drvs:ident,)*), $user_drvs:tt
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             $fixed,
             ($($tail)*), ($($bi_drvs,)* Send,), $user_drvs
         }
     };
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         $fixed:tt,
         (Sync, $($tail:tt)*), ($($bi_drvs:ident,)*), $user_drvs:tt
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             $fixed,
             ($($tail)*), ($($bi_drvs,)* Sync,), $user_drvs
         }
     };
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         $fixed:tt,
         (Copy, $($tail:tt)*), ($($bi_drvs:ident,)*), $user_drvs:tt
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             $fixed,
             ($($tail)*), ($($bi_drvs,)* Copy,), $user_drvs
         }
@@ -867,22 +867,22 @@ Finally, `@impl` is merely a trick to pack multiple, different functions into a
     The *reason* we care is that, in order to simplify the derivation macros, we want to detect the argument-less case and generate an empty pair of parens.
 
     */
-    (@split_derive_attrs
+    (@split_derive_attrs
         $fixed:tt,
         ($new_user:ident, $($tail:tt)*), $bi_drvs:tt, ($($user_drvs:tt)*)
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             $fixed, ($($tail)*), $bi_drvs, ($($user_drvs)* $new_user(),)
         }
     };
 
-    (@split_derive_attrs
+    (@split_derive_attrs
         $fixed:tt,
         ($new_user:ident ($($new_user_args:tt)*), $($tail:tt)*), $bi_drvs:tt, ($($user_drvs:tt)*)
     ) => {
         custom_derive! {
-            @split_derive_attrs
+            @split_derive_attrs
             $fixed, ($($tail)*), $bi_drvs, ($($user_drvs)* $new_user($($new_user_args)*),)
         }
     };
@@ -896,16 +896,16 @@ Finally, `@impl` is merely a trick to pack multiple, different functions into a
     This *has* to be recursive because we need to expand two independent repetition sequences simultaneously, and this causes `macro_rules!` to throw a wobbly.  Don't want that.  So, recursive it is.
 
     */
-    (@expand_user_drvs
+    (@expand_user_drvs
         (), ($($it:tt)*)
     ) => {};
 
-    (@expand_user_drvs
+    (@expand_user_drvs
         ($user_drv:ident $arg:tt, $($tail:tt)*), ($($it:tt)*)
     ) => {
         $user_drv! { $arg $($it)* }
         custom_derive! {
-            @expand_user_drvs
+            @expand_user_drvs
             ($($tail)*), ($($it)*)
         }
     };
@@ -915,7 +915,7 @@ Finally, `@impl` is merely a trick to pack multiple, different functions into a
     # Miscellaneous Rules
 
     */
-    (@as_item $($i:item)*) => {$($i)*};
+    (@as_item $($i:item)*) => {$($i)*};
 }
 
    
 
diff --git a/src/hamming/distance_.rs.html b/src/hamming/distance_.rs.html
index 57da74f..cae46a2 100644
--- a/src/hamming/distance_.rs.html
+++ b/src/hamming/distance_.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     distance_.rs.html -- source
diff --git a/src/hamming/lib.rs.html b/src/hamming/lib.rs.html
index c1268e8..c811038 100644
--- a/src/hamming/lib.rs.html
+++ b/src/hamming/lib.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     lib.rs.html -- source
diff --git a/src/hamming/weight_.rs.html b/src/hamming/weight_.rs.html
index 313a86f..c85f18f 100644
--- a/src/hamming/weight_.rs.html
+++ b/src/hamming/weight_.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     weight_.rs.html -- source
diff --git a/src/libc/dox.rs.html b/src/libc/dox.rs.html
index 6e8aeed..ef68e1b 100644
--- a/src/libc/dox.rs.html
+++ b/src/libc/dox.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     dox.rs.html -- source
@@ -199,7 +199,7 @@
     }
 
     pub trait Clone {
-        fn clone(&self) -> Self;
+        fn clone(&self) -> Self;
     }
 
     #[lang = "copy"]
@@ -230,7 +230,7 @@
     #[lang = "div"]
     pub trait Div<RHS> {
         type Output;
-        fn div(self, rhs: RHS) -> Self::Output;
+        fn div(self, rhs: RHS) -> Self::Output;
     }
 
     macro_rules! impl_div {
@@ -246,7 +246,7 @@
     #[lang = "shl"]
     pub trait Shl<RHS> {
         type Output;
-        fn shl(self, rhs: RHS) -> Self::Output;
+        fn shl(self, rhs: RHS) -> Self::Output;
     }
 
     macro_rules! impl_shl {
@@ -260,9 +260,9 @@
     each_int!(impl_shl);
 
     #[lang = "mul"]
-    pub trait Mul<RHS=Self> {
+    pub trait Mul<RHS=Self> {
         type Output;
-        fn mul(self, rhs: RHS) -> Self::Output;
+        fn mul(self, rhs: RHS) -> Self::Output;
     }
 
     macro_rules! impl_mul {
@@ -276,9 +276,9 @@
     each_int!(impl_mul);
 
     #[lang = "sub"]
-    pub trait Sub<RHS=Self> {
+    pub trait Sub<RHS=Self> {
         type Output;
-        fn sub(self, rhs: RHS) -> Self::Output;
+        fn sub(self, rhs: RHS) -> Self::Output;
     }
 
     macro_rules! impl_sub {
@@ -292,9 +292,9 @@
     each_int!(impl_sub);
 
     #[lang = "bitor"]
-    pub trait Bitor<RHS=Self> {
+    pub trait Bitor<RHS=Self> {
         type Output;
-        fn bitor(self, rhs: RHS) -> Self::Output;
+        fn bitor(self, rhs: RHS) -> Self::Output;
     }
 
     macro_rules! impl_bitor {
diff --git a/src/libc/lib.rs.html b/src/libc/lib.rs.html
index d21bf1c..37421ec 100644
--- a/src/libc/lib.rs.html
+++ b/src/libc/lib.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     lib.rs.html -- source
diff --git a/src/libc/macros.rs.html b/src/libc/macros.rs.html
index 88f9f8a..a8a0c42 100644
--- a/src/libc/macros.rs.html
+++ b/src/libc/macros.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     macros.rs.html -- source
@@ -236,19 +236,19 @@
 
     cfg_if! {
         if #[cfg(foo)] {
-            fn works2() -> bool { false }
+            fn works2() -> bool { false }
         } else if #[cfg(test)] {
-            fn works2() -> bool { true }
+            fn works2() -> bool { true }
         } else {
-            fn works2() -> bool { false }
+            fn works2() -> bool { false }
         }
     }
 
     cfg_if! {
         if #[cfg(foo)] {
-            fn works3() -> bool { false }
+            fn works3() -> bool { false }
         } else {
-            fn works3() -> bool { true }
+            fn works3() -> bool { true }
         }
     }
 
diff --git a/src/libc/windows.rs.html b/src/libc/windows.rs.html
index bef8885..4b7154b 100644
--- a/src/libc/windows.rs.html
+++ b/src/libc/windows.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     windows.rs.html -- source
diff --git a/src/newtype_derive/lib.rs.html b/src/newtype_derive/lib.rs.html
index af3182e..550a763 100644
--- a/src/newtype_derive/lib.rs.html
+++ b/src/newtype_derive/lib.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     lib.rs.html -- source
@@ -1127,7 +1127,7 @@ macro_rules! Newtype\2 {
         newtype_as_item! {
             impl $($tr)*<$name> for $name {
                 type Output = $name;
-                fn $meth(self, rhs: Self) -> $name {
+                fn $meth(self, rhs: Self) -> $name {
                     $name((self.0).$meth(rhs.0))
                 }
             }
@@ -1142,7 +1142,7 @@ macro_rules! Newtype\2 {
         newtype_as_item! {
             impl $($tr)*<$name> for $name {
                 type Output = $name;
-                fn $meth(self, rhs: Self) -> $name {
+                fn $meth(self, rhs: Self) -> $name {
                     $name((self.0).$meth(rhs.0))
                 }
             }
@@ -1157,7 +1157,7 @@ macro_rules! Newtype\2 {
         newtype_as_item! {
             impl<'a> $($tr)*<&'a $name> for &'a $name {
                 type Output = $name;
-                fn $meth(self, rhs: Self) -> $name {
+                fn $meth(self, rhs: Self) -> $name {
                     $name((self.0).$meth(rhs.0))
                 }
             }
@@ -1172,7 +1172,7 @@ macro_rules! Newtype\2 {
         newtype_as_item! {
             impl<'a> $($tr)*<&'a $name> for &'a $name {
                 type Output = $name;
-                fn $meth(self, rhs: Self) -> $name {
+                fn $meth(self, rhs: Self) -> $name {
                     $name((self.0).$meth(rhs.0))
                 }
             }
@@ -1181,7 +1181,7 @@ macro_rules! Newtype\2 {
 
     (
         trait: ($($tr:tt)*)::$meth:ident,
-        kind: rhs_rewrap(&Self),
+        kind: rhs_rewrap(&Self),
         item: $(pub)* struct $name:ident(pub $t:ty);
     ) => {
         newtype_as_item! {
@@ -1196,7 +1196,7 @@ macro_rules! Newtype\2 {
 
     (
         trait: ($($tr:tt)*)::$meth:ident,
-        kind: rhs_rewrap(&Self),
+        kind: rhs_rewrap(&Self),
         item: $(pub)* struct $name:ident($t:ty);
     ) => {
         newtype_as_item! {
@@ -1241,7 +1241,7 @@ macro_rules! Newtype\2 {
 
     (
         trait: ($($tr:tt)*)::$meth:ident,
-        kind: ref_rhs_rewrap(Self),
+        kind: ref_rhs_rewrap(Self),
         item: $(pub)* struct $name:ident(pub $t:ty);
     ) => {
         newtype_as_item! {
@@ -1256,7 +1256,7 @@ macro_rules! Newtype\2 {
 
     (
         trait: ($($tr:tt)*)::$meth:ident,
-        kind: ref_rhs_rewrap(Self),
+        kind: ref_rhs_rewrap(Self),
         item: $(pub)* struct $name:ident($t:ty);
     ) => {
         newtype_as_item! {
@@ -1370,8 +1370,8 @@ macro_rules! Newtype\2 {
     ((*) $($tts:tt)*) => {
         NewtypeAdd! { () $($tts)* }
         NewtypeAdd! { (&self) $($tts)* }
-        NewtypeAdd! { (&Self) $($tts)* }
-        NewtypeAdd! { (&self, Self) $($tts)* }
+        NewtypeAdd! { (&Self) $($tts)* }
+        NewtypeAdd! { (&self, Self) $($tts)* }
     };
     (() $($tts:tt)*) => {
         newtype_wrap_bin_op! { trait: (::std::ops::Add)::add, kind: simple, item: $($tts)* }
@@ -1393,8 +1393,8 @@ macro_rules! Newtype\2 {
     ((*) $($tts:tt)*) => {
         NewtypeBitAnd! { () $($tts)* }
         NewtypeBitAnd! { (&self) $($tts)* }
-        NewtypeBitAnd! { (&Self) $($tts)* }
-        NewtypeBitAnd! { (&self, Self) $($tts)* }
+        NewtypeBitAnd! { (&Self) $($tts)* }
+        NewtypeBitAnd! { (&self, Self) $($tts)* }
     };
     (() $($tts:tt)*) => {
         newtype_wrap_bin_op! { trait: (::std::ops::BitAnd)::bitand, kind: simple, item: $($tts)* }
@@ -1416,8 +1416,8 @@ macro_rules! Newtype\2 {
     ((*) $($tts:tt)*) => {
         NewtypeBitOr! { () $($tts)* }
         NewtypeBitOr! { (&self) $($tts)* }
-        NewtypeBitOr! { (&Self) $($tts)* }
-        NewtypeBitOr! { (&self, Self) $($tts)* }
+        NewtypeBitOr! { (&Self) $($tts)* }
+        NewtypeBitOr! { (&self, Self) $($tts)* }
     };
     (() $($tts:tt)*) => {
         newtype_wrap_bin_op! { trait: (::std::ops::BitOr)::bitor, kind: simple, item: $($tts)* }
@@ -1439,8 +1439,8 @@ macro_rules! Newtype\2 {
     ((*) $($tts:tt)*) => {
         NewtypeBitXor! { () $($tts)* }
         NewtypeBitXor! { (&self) $($tts)* }
-        NewtypeBitXor! { (&Self) $($tts)* }
-        NewtypeBitXor! { (&self, Self) $($tts)* }
+        NewtypeBitXor! { (&Self) $($tts)* }
+        NewtypeBitXor! { (&self, Self) $($tts)* }
     };
     (() $($tts:tt)*) => {
         newtype_wrap_bin_op! { trait: (::std::ops::BitXor)::bitxor, kind: simple, item: $($tts)* }
@@ -1462,8 +1462,8 @@ macro_rules! Newtype\2 {
     ((*) $($tts:tt)*) => {
         NewtypeDiv! { () $($tts)* }
         NewtypeDiv! { (&self) $($tts)* }
-        NewtypeDiv! { (&Self) $($tts)* }
-        NewtypeDiv! { (&self, Self) $($tts)* }
+        NewtypeDiv! { (&Self) $($tts)* }
+        NewtypeDiv! { (&self, Self) $($tts)* }
     };
     (() $($tts:tt)*) => {
         newtype_wrap_bin_op! { trait: (::std::ops::Div)::div, kind: simple, item: $($tts)* }
@@ -1485,8 +1485,8 @@ macro_rules! Newtype\2 {
     ((*) $($tts:tt)*) => {
         NewtypeMul! { () $($tts)* }
         NewtypeMul! { (&self) $($tts)* }
-        NewtypeMul! { (&Self) $($tts)* }
-        NewtypeMul! { (&self, Self) $($tts)* }
+        NewtypeMul! { (&Self) $($tts)* }
+        NewtypeMul! { (&self, Self) $($tts)* }
     };
     (() $($tts:tt)*) => {
         newtype_wrap_bin_op! { trait: (::std::ops::Mul)::mul, kind: simple, item: $($tts)* }
@@ -1508,8 +1508,8 @@ macro_rules! Newtype\2 {
     ((*) $($tts:tt)*) => {
         NewtypeRem! { () $($tts)* }
         NewtypeRem! { (&self) $($tts)* }
-        NewtypeRem! { (&Self) $($tts)* }
-        NewtypeRem! { (&self, Self) $($tts)* }
+        NewtypeRem! { (&Self) $($tts)* }
+        NewtypeRem! { (&self, Self) $($tts)* }
     };
     (() $($tts:tt)*) => {
         newtype_wrap_bin_op! { trait: (::std::ops::Rem)::rem, kind: simple, item: $($tts)* }
@@ -1531,8 +1531,8 @@ macro_rules! Newtype\2 {
     ((*) $($tts:tt)*) => {
         NewtypeSub! { () $($tts)* }
         NewtypeSub! { (&self) $($tts)* }
-        NewtypeSub! { (&Self) $($tts)* }
-        NewtypeSub! { (&self, Self) $($tts)* }
+        NewtypeSub! { (&Self) $($tts)* }
+        NewtypeSub! { (&self, Self) $($tts)* }
     };
     (() $($tts:tt)*) => {
         newtype_wrap_bin_op! { trait: (::std::ops::Sub)::sub, kind: simple, item: $($tts)* }
@@ -1554,8 +1554,8 @@ macro_rules! Newtype\2 {
     ((*) $($tts:tt)*) => {
         NewtypeShl! { () $($tts)* }
         NewtypeShl! { (&self) $($tts)* }
-        NewtypeShl! { (&Self) $($tts)* }
-        NewtypeShl! { (&self, Self) $($tts)* }
+        NewtypeShl! { (&Self) $($tts)* }
+        NewtypeShl! { (&self, Self) $($tts)* }
     };
     (() $($tts:tt)*) => {
         newtype_wrap_bin_op! { trait: (::std::ops::Shl)::shl, kind: simple, item: $($tts)* }
@@ -1577,8 +1577,8 @@ macro_rules! Newtype\2 {
     ((*) $($tts:tt)*) => {
         NewtypeShr! { () $($tts)* }
         NewtypeShr! { (&self) $($tts)* }
-        NewtypeShr! { (&Self) $($tts)* }
-        NewtypeShr! { (&self, Self) $($tts)* }
+        NewtypeShr! { (&Self) $($tts)* }
+        NewtypeShr! { (&self, Self) $($tts)* }
     };
     (() $($tts:tt)*) => {
         newtype_wrap_bin_op! { trait: (::std::ops::Shr)::shr, kind: simple, item: $($tts)* }
@@ -1629,7 +1629,7 @@ macro_rules! Newtype\2 {
     (() $(pub)* struct $name:ident(pub $t0:ty);) => {
         impl ::std::ops::Deref for $name {
             type Target = $t0;
-            fn deref(&self) -> &Self::Target {
+            fn deref(&self) -> &Self::Target {
                 &self.0
             }
         }
@@ -1638,7 +1638,7 @@ macro_rules! Newtype\2 {
     (() $(pub)* struct $name:ident($t0:ty);) => {
         impl ::std::ops::Deref for $name {
             type Target = $t0;
-            fn deref(&self) -> &Self::Target {
+            fn deref(&self) -> &Self::Target {
                 &self.0
             }
         }
@@ -1649,7 +1649,7 @@ macro_rules! Newtype\2 {
 macro_rules! NewtypeDerefMut {
     (() $(pub)* struct $name:ident(pub $t0:ty);) => {
         impl ::std::ops::DerefMut for $name {
-            fn deref_mut(&mut self) -> &mut Self::Target {
+            fn deref_mut(&mut self) -> &mut Self::Target {
                 &mut self.0
             }
         }
@@ -1657,7 +1657,7 @@ macro_rules! Newtype\2 {
 
     (() $(pub)* struct $name:ident($t0:ty);) => {
         impl ::std::ops::DerefMut for $name {
-            fn deref_mut(&mut self) -> &mut Self::Target {
+            fn deref_mut(&mut self) -> &mut Self::Target {
                 &mut self.0
             }
         }
@@ -1669,7 +1669,7 @@ macro_rules! Newtype\2 {
     (($index_ty:ty) $(pub)* struct $name:ident(pub $t0:ty);) => {
         impl ::std::ops::Index<$index_ty> for $name {
             type Output = <$t0 as ::std::ops::Index<$index_ty>>::Output;
-            fn index(&self, index: $index_ty) -> &Self::Output {
+            fn index(&self, index: $index_ty) -> &Self::Output {
                 (&self.0).index(index)
             }
         }
@@ -1678,7 +1678,7 @@ macro_rules! Newtype\2 {
     (($index_ty:ty) $(pub)* struct $name:ident($t0:ty);) => {
         impl ::std::ops::Index<$index_ty> for $name {
             type Output = <$t0 as ::std::ops::Index<$index_ty>>::Output;
-            fn index(&self, index: $index_ty) -> &Self::Output {
+            fn index(&self, index: $index_ty) -> &Self::Output {
                 (&self.0).index(index)
             }
         }
@@ -1689,7 +1689,7 @@ macro_rules! Newtype\2 {
 macro_rules! NewtypeIndexMut {
     (($index_ty:ty) $(pub)* struct $name:ident(pub $t0:ty);) => {
         impl ::std::ops::IndexMut<$index_ty> for $name {
-            fn index_mut(&mut self, index: $index_ty) -> &mut Self::Output {
+            fn index_mut(&mut self, index: $index_ty) -> &mut Self::Output {
                 (&mut self.0).index_mut(index)
             }
         }
@@ -1697,7 +1697,7 @@ macro_rules! Newtype\2 {
 
     (($index_ty:ty) $(pub)* struct $name:ident($t0:ty);) => {
         impl ::std::ops::IndexMut<$index_ty> for $name {
-            fn index_mut(&mut self, index: $index_ty) -> &mut Self::Output {
+            fn index_mut(&mut self, index: $index_ty) -> &mut Self::Output {
                 (&mut self.0).index_mut(index)
             }
         }
@@ -1708,12 +1708,12 @@ macro_rules! Newtype\2 {
 macro_rules! NewtypeFrom {
     (() $(pub)* struct $name:ident(pub $t0:ty);) => {
         impl ::std::convert::From<$t0> for $name {
-            fn from(v: $t0) -> Self {
+            fn from(v: $t0) -> Self {
                 $name(v)
             }
         }
         impl ::std::convert::From<$name> for $t0 {
-            fn from(v: $name) -> Self {
+            fn from(v: $name) -> Self {
                 v.0
             }
         }
@@ -1721,12 +1721,12 @@ macro_rules! Newtype\2 {
 
     (() $(pub)* struct $name:ident($t0:ty);) => {
         impl ::std::convert::From<$t0> for $name {
-            fn from(v: $t0) -> Self {
+            fn from(v: $t0) -> Self {
                 $name(v)
             }
         }
         impl ::std::convert::From<$name> for $t0 {
-            fn from(v: $name) -> Self {
+            fn from(v: $name) -> Self {
                 v.0
             }
         }
diff --git a/src/pumpkin/src/lib.rs.html b/src/pumpkin/src/lib.rs.html
index 7bdf33d..63131f3 100644
--- a/src/pumpkin/src/lib.rs.html
+++ b/src/pumpkin/src/lib.rs.html
@@ -119,6 +119,11 @@
 75
 76
 77
+78
+79
+80
+81
+82
 
     #![feature(test)]
 #![deny(missing_docs, missing_debug_implementations,
@@ -182,6 +187,11 @@
         Prime::from_rng(511, &mut rngesus);
     }
 
+    #[test]
+    fn test_should_destructure() {
+        let Prime(n) = Prime::new(512);
+    }
+
     #[bench]
     fn bench_generate_512_bit_prime(b: &mut Bencher) {
         b.iter(|| Prime::new(512));
diff --git a/src/pumpkin/src/prime.rs.html b/src/pumpkin/src/prime.rs.html
index 3210801..4476186 100644
--- a/src/pumpkin/src/prime.rs.html
+++ b/src/pumpkin/src/prime.rs.html
@@ -508,7 +508,7 @@
         NewtypeBitAnd(Int), NewtypeBitOr, NewtypeBitOr(Int), NewtypeBitXor,
         NewtypeBitXor(Int)
     )]
-    pub struct Prime(Int);
+    pub struct Prime(pub Int);
 }
 
 impl Prime {
@@ -540,7 +540,7 @@
         // with a new random number.
         loop {
             let mut counter = 0;
-            let mut found_prime = true;
+            let mut found_prime = true;
             candidate = rngesus.gen_uint(bit_length);
 
             // We first want to make sure that the candidate is in the appropriate
@@ -560,7 +560,7 @@
                 counter += 1;
 
                 if counter > 499 {
-                    found_prime = false;
+                    found_prime = false;
                     break;
                 }
             }
@@ -615,21 +615,21 @@
         if r != 0_usize {
             continue;
         } else {
-            return false;
+            return false;
         }
     }
 
     // Second, do a Fermat test on the candidate
     if !fermat(candidate) {
-        return false;
+        return false;
     }
 
     // Finally, do a Miller-Rabin test
     if !miller_rabin(candidate) {
-        return false;
+        return false;
     }
 
-    true
+    true
 }
 
 fn fermat(candidate: &Int) -> bool {
@@ -656,16 +656,16 @@
             for _ in Int::one()..s - 1_usize {
                 x = mod_exp(&x, &Int::from(2), candidate);
                 if x == 1_usize {
-                    return false;
+                    return false;
                 } else if x == candidate - 1_usize {
                     break;
                 }
             }
-            return false;
+            return false;
         }
     }
 
-    true
+    true
 }
 
 #[cfg(test)]
diff --git a/src/ramp/int.rs.html b/src/ramp/int.rs.html
index 4fd0710..c971b7c 100644
--- a/src/ramp/int.rs.html
+++ b/src/ramp/int.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     int.rs.html -- source
@@ -5443,10 +5443,10 @@
      * the capacity and that the most significant limb is non-zero
      */
     fn well_formed(&self) -> bool {
-        if self.size == 0 { return true; }
+        if self.size == 0 { return true; }
 
         if (self.abs_size() as u32) > self.cap {
-            return false;
+            return false;
         }
 
         let high_limb = unsafe {
@@ -5573,7 +5573,7 @@
                 ll::cmp(self.limbs(), other.limbs(), self.abs_size()) == Ordering::Equal
             }
         } else {
-            false
+            false
         }
     }
 }
@@ -5582,7 +5582,7 @@
     #[inline]
     fn eq(&self, other: &Limb) -> bool {
         if *other == 0 && self.size == 0 {
-            return true;
+            return true;
         }
 
         self.size == 1 && *self.limbs() == *other
@@ -5981,10 +5981,10 @@
                     }
                     Ordering::Less => {
                         self.ensure_capacity(other.abs_size() as u32);
-                        (other.limbs(), other.size, self.limbs(), self.size, true)
+                        (other.limbs(), other.size, self.limbs(), self.size, true)
                     }
                     Ordering::Greater =>
-                        (self.limbs(), self.size, other.limbs(), other.size, false)
+                        (self.limbs(), self.size, other.limbs(), other.size, false)
                 };
 
                 // Fetch the pointer first to make completely sure the compiler
@@ -6744,7 +6744,7 @@
                     ll::not(ptr, ptr.as_const(), max_size - min_size);
                 }
                 ((a_sign < 0) ^ (b_sign < 0),
-                 true)
+                 true)
             }
         };
 
@@ -6816,7 +6816,7 @@
                         ll::not(ptr, ptr.as_const(), max_size - min_size);
                     }
                     ((a_sign < 0) ^ (b_sign < 0),
-                     true)
+                     true)
                 }
             };
             a.size = if use_max_size {
@@ -6843,7 +6843,7 @@
 
 impl BitAndAssign<Limb> for Int {
     fn bitand_assign(&mut self, other: Limb) {
-        bitop_limb(self, other, false, BitOp::And)
+        bitop_limb(self, other, false, BitOp::And)
     }
 }
 
@@ -6919,7 +6919,7 @@
 
 impl BitOrAssign<Limb> for Int {
     fn bitor_assign(&mut self, other: Limb) {
-        bitop_limb(self, other, false, BitOp::Or)
+        bitop_limb(self, other, false, BitOp::Or)
     }
 }
 
@@ -6996,7 +6996,7 @@
 
 impl BitXorAssign<Limb> for Int {
     fn bitxor_assign(&mut self, other: Limb) {
-        bitop_limb(self, other, false, BitOp::Xor)
+        bitop_limb(self, other, false, BitOp::Xor)
     }
 }
 
@@ -7203,21 +7203,21 @@
         impl BitAndAssign<$t> for Int {
             #[inline]
             fn bitand_assign(&mut self, other: $t) {
-                bitop_limb(self, Limb(other as BaseInt), true, BitOp::And)
+                bitop_limb(self, Limb(other as BaseInt), true, BitOp::And)
             }
         }
 
         impl BitOrAssign<$t> for Int {
             #[inline]
             fn bitor_assign(&mut self, other: $t) {
-                bitop_limb(self, Limb(other as BaseInt), true, BitOp::Or)
+                bitop_limb(self, Limb(other as BaseInt), true, BitOp::Or)
             }
         }
 
         impl BitXorAssign<$t> for Int {
             #[inline]
             fn bitxor_assign(&mut self, other: $t) {
-                bitop_limb(self, Limb(other as BaseInt), true, BitOp::Xor)
+                bitop_limb(self, Limb(other as BaseInt), true, BitOp::Xor)
             }
         }
 
@@ -7346,21 +7346,21 @@
         impl BitAndAssign<$t> for Int {
             #[inline]
             fn bitand_assign(&mut self, other: $t) {
-                bitop_limb(self, Limb(other as BaseInt), false, BitOp::And)
+                bitop_limb(self, Limb(other as BaseInt), false, BitOp::And)
             }
         }
 
         impl BitOrAssign<$t> for Int {
             #[inline]
             fn bitor_assign(&mut self, other: $t) {
-                bitop_limb(self, Limb(other as BaseInt), false, BitOp::Or)
+                bitop_limb(self, Limb(other as BaseInt), false, BitOp::Or)
             }
         }
 
         impl BitXorAssign<$t> for Int {
             #[inline]
             fn bitxor_assign(&mut self, other: $t) {
-                bitop_limb(self, Limb(other as BaseInt), false, BitOp::Xor)
+                bitop_limb(self, Limb(other as BaseInt), false, BitOp::Xor)
             }
         }
 
@@ -7673,13 +7673,13 @@
         }
         // Differing signs
         if sign < 0 && other > 0 || sign > 0 && other < 0 {
-            return false;
+            return false;
         }
 
         // We can't fall back to the `== Limb` impl when self is negative
         // since it'll fail because of signs
         if sign < 0 {
-            if self.abs_size() > 1 { return false; }
+            if self.abs_size() > 1 { return false; }
             return *self.limbs() == (other.abs() as BaseInt);
         }
 
@@ -7774,10 +7774,10 @@
 fn eq_64(x: &Int, mag: u64, neg: bool) -> bool {
     let sign = if mag == 0 { 0 } else if neg { -1 } else { 1 };
     if x.sign() != sign {
-        return false
+        return false
     } else if mag == 0 {
         // we're guaranteed to have x == 0 since the signs match
-        return true
+        return true
     }
 
 
@@ -7798,7 +7798,7 @@
             hi_limb.0 == (mag >> 32) as BaseInt
                 && lo_limb.0 == mag as BaseInt
         } else {
-            false
+            false
         }
     }
 }
@@ -7841,25 +7841,25 @@
 
 impl PartialEq<u64> for Int {
     fn eq(&self, &other: &u64) -> bool {
-        eq_64(self, other, false)
+        eq_64(self, other, false)
     }
 }
 
 impl PartialEq<Int> for u64 {
     fn eq(&self, other: &Int) -> bool {
-        eq_64(other, *self, false)
+        eq_64(other, *self, false)
     }
 }
 
 impl PartialOrd<u64> for Int {
     fn partial_cmp(&self, &other: &u64) -> Option<Ordering> {
-        Some(cmp_64(self, other, false))
+        Some(cmp_64(self, other, false))
     }
 }
 
 impl PartialOrd<Int> for u64 {
     fn partial_cmp(&self, other: &Int) -> Option<Ordering> {
-        Some(cmp_64(other, *self, false).reverse())
+        Some(cmp_64(other, *self, false).reverse())
     }
 }
 
@@ -7985,7 +7985,7 @@
     };
 
     ($t:path, $radix:expr, $prefix:expr) => {
-        impl_fmt!($t, $radix, false, $prefix);
+        impl_fmt!($t, $radix, false, $prefix);
     }
 );
 
@@ -7993,8 +7993,8 @@
 impl_fmt!(fmt::Octal,     8, "0o");
 impl_fmt!(fmt::Display,  10, "");
 impl_fmt!(fmt::Debug,    10, "");
-impl_fmt!(fmt::LowerHex, 16, false, "0x");
-impl_fmt!(fmt::UpperHex, 16, true, "0x");
+impl_fmt!(fmt::LowerHex, 16, false, "0x");
+impl_fmt!(fmt::UpperHex, 16, true, "0x");
 
 // String parsing
 
@@ -8326,7 +8326,7 @@
         ];
 
         for &(s, ref n) in cases.iter() {
-            assert_eq!(s, &n.to_str_radix(16, false));
+            assert_eq!(s, &n.to_str_radix(16, false));
         }
     }
 
@@ -8634,10 +8634,10 @@
     #[test]
     fn is_even() {
         let cases = [
-            ("0", true),
-            ("1", false),
-            ("47398217493274092174042109472", true),
-            ("47398217493274092174042109471", false),
+            ("0", true),
+            ("1", false),
+            ("47398217493274092174042109472", true),
+            ("47398217493274092174042109471", false),
         ];
 
         for &(v, even) in cases.iter() {
diff --git a/src/ramp/lib.rs.html b/src/ramp/lib.rs.html
index 2cb8ad1..7b747d0 100644
--- a/src/ramp/lib.rs.html
+++ b/src/ramp/lib.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     lib.rs.html -- source
diff --git a/src/ramp/ll/addsub.rs.html b/src/ramp/ll/addsub.rs.html
index 54294bd..ab2bac7 100644
--- a/src/ramp/ll/addsub.rs.html
+++ b/src/ramp/ll/addsub.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     addsub.rs.html -- source
diff --git a/src/ramp/ll/base.rs.html b/src/ramp/ll/base.rs.html
index cde792b..81153d9 100644
--- a/src/ramp/ll/base.rs.html
+++ b/src/ramp/ll/base.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     base.rs.html -- source
diff --git a/src/ramp/ll/bit.rs.html b/src/ramp/ll/bit.rs.html
index fea4bb1..7ad3a8a 100644
--- a/src/ramp/ll/bit.rs.html
+++ b/src/ramp/ll/bit.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     bit.rs.html -- source
diff --git a/src/ramp/ll/div.rs.html b/src/ramp/ll/div.rs.html
index 94d5a15..4fd8433 100644
--- a/src/ramp/ll/div.rs.html
+++ b/src/ramp/ll/div.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     div.rs.html -- source
diff --git a/src/ramp/ll/gcd.rs.html b/src/ramp/ll/gcd.rs.html
index 650f446..732023a 100644
--- a/src/ramp/ll/gcd.rs.html
+++ b/src/ramp/ll/gcd.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     gcd.rs.html -- source
diff --git a/src/ramp/ll/limb.rs.html b/src/ramp/ll/limb.rs.html
index 7cab82a..76e4ce0 100644
--- a/src/ramp/ll/limb.rs.html
+++ b/src/ramp/ll/limb.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     limb.rs.html -- source
diff --git a/src/ramp/ll/limb_ptr.rs.html b/src/ramp/ll/limb_ptr.rs.html
index 768b0a6..7f609d3 100644
--- a/src/ramp/ll/limb_ptr.rs.html
+++ b/src/ramp/ll/limb_ptr.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     limb_ptr.rs.html -- source
@@ -349,9 +349,9 @@
 impl Bounds {
     fn new(_ptr: usize, _start: i32, _end: i32) -> Bounds { Bounds }
     #[inline]
-    fn can_deref(self, _ptr: usize) -> bool { true }
+    fn can_deref(self, _ptr: usize) -> bool { true }
     #[inline]
-    fn offset_valid(self, _ptr: usize, _offset: isize) -> bool { true }
+    fn offset_valid(self, _ptr: usize, _offset: isize) -> bool { true }
 }
 impl fmt::Debug for Bounds {
     #[cfg(debug_assertions)]
diff --git a/src/ramp/ll/mod.rs.html b/src/ramp/ll/mod.rs.html
index 5310b54..80a31c7 100644
--- a/src/ramp/ll/mod.rs.html
+++ b/src/ramp/ll/mod.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     mod.rs.html -- source
@@ -981,11 +981,11 @@
  */
 pub unsafe fn is_zero(mut np: Limbs, mut nn: i32) -> bool {
     while nn > 0 {
-        if *np != 0 { return false; }
+        if *np != 0 { return false; }
         np = np.offset(1);
         nn -= 1;
     }
-    return true;
+    return true;
 }
 
 pub unsafe fn zero(mut np: LimbsMut, mut nn: i32) {
diff --git a/src/ramp/ll/mul.rs.html b/src/ramp/ll/mul.rs.html
index acea816..5ca907a 100644
--- a/src/ramp/ll/mul.rs.html
+++ b/src/ramp/ll/mul.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     mul.rs.html -- source
@@ -841,13 +841,13 @@
 
     let zx1 = wp; // nl limbs
     let zy1 = wp.offset(nl as isize); // nl limbs
-    let mut z1_neg = false; // Keep track of whether the real z1 is negative
+    let mut z1_neg = false; // Keep track of whether the real z1 is negative
 
     // Calculate zx1
     if nl == xh {
         if ll::cmp(x0, x1, nl) == Ordering::Less {
             ll::sub_n(zx1, x1, x0, nl);
-            z1_neg = true;
+            z1_neg = true;
         } else {
             ll::sub_n(zx1, x0, x1, nl);
         }
@@ -855,7 +855,7 @@
         if ll::is_zero(x0.offset(xh as isize), nl-xh) && ll::cmp(x0, x1, xh) == Ordering::Less {
             ll::sub_n(zx1, x1, x0, xh);
             ll::zero(zx1.offset(xh as isize), nl-xh); // Zero the extra limbs
-            z1_neg = true;
+            z1_neg = true;
         } else {
             ll::sub(zx1, x0, nl, x1, xh);
         }
diff --git a/src/ramp/ll/pow.rs.html b/src/ramp/ll/pow.rs.html
index db7f3d3..0bc3cbf 100644
--- a/src/ramp/ll/pow.rs.html
+++ b/src/ramp/ll/pow.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     pow.rs.html -- source
diff --git a/src/ramp/mem.rs.html b/src/ramp/mem.rs.html
index 9a3fd8f..4dd3e96 100644
--- a/src/ramp/mem.rs.html
+++ b/src/ramp/mem.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     mem.rs.html -- source
diff --git a/src/rand/chacha.rs.html b/src/rand/chacha.rs.html
index 8ca7f18..97d08f1 100644
--- a/src/rand/chacha.rs.html
+++ b/src/rand/chacha.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     chacha.rs.html -- source
diff --git a/src/rand/distributions/exponential.rs.html b/src/rand/distributions/exponential.rs.html
index ad54971..bcbc402 100644
--- a/src/rand/distributions/exponential.rs.html
+++ b/src/rand/distributions/exponential.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     exponential.rs.html -- source
@@ -220,7 +220,7 @@
             ziggurat_tables::ZIG_EXP_R - rng.gen::<f64>().ln()
         }
 
-        Exp1(ziggurat(rng, false,
+        Exp1(ziggurat(rng, false,
                       &ziggurat_tables::ZIG_EXP_X,
                       &ziggurat_tables::ZIG_EXP_F,
                       pdf, zero_case))
diff --git a/src/rand/distributions/gamma.rs.html b/src/rand/distributions/gamma.rs.html
index cc957d0..3180be8 100644
--- a/src/rand/distributions/gamma.rs.html
+++ b/src/rand/distributions/gamma.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     gamma.rs.html -- source
diff --git a/src/rand/distributions/mod.rs.html b/src/rand/distributions/mod.rs.html
index 9800e3c..69acfcf 100644
--- a/src/rand/distributions/mod.rs.html
+++ b/src/rand/distributions/mod.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     mod.rs.html -- source
@@ -508,7 +508,7 @@
 
 impl<Sup> Copy for RandSample<Sup> {}
 impl<Sup> Clone for RandSample<Sup> {
-    fn clone(&self) -> Self { *self }
+    fn clone(&self) -> Self { *self }
 }
 
 impl<Sup: Rand> Sample<Sup> for RandSample<Sup> {
diff --git a/src/rand/distributions/normal.rs.html b/src/rand/distributions/normal.rs.html
index e34d0a4..22be22c 100644
--- a/src/rand/distributions/normal.rs.html
+++ b/src/rand/distributions/normal.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     normal.rs.html -- source
@@ -312,7 +312,7 @@
 
         StandardNormal(ziggurat(
             rng,
-            true, // this is symmetric
+            true, // this is symmetric
             &ziggurat_tables::ZIG_NORM_X,
             &ziggurat_tables::ZIG_NORM_F,
             pdf, zero_case))
diff --git a/src/rand/distributions/range.rs.html b/src/rand/distributions/range.rs.html
index eb1d052..5e9e29d 100644
--- a/src/rand/distributions/range.rs.html
+++ b/src/rand/distributions/range.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     range.rs.html -- source
@@ -358,11 +358,11 @@
     /// requires. This should not ever be called directly, only via
     /// `Range::new`, which will check that `low < high`, so this
     /// function doesn't have to repeat the check.
-    fn construct_range(low: Self, high: Self) -> Range<Self>;
+    fn construct_range(low: Self, high: Self) -> Range<Self>;
 
     /// Sample a value from the given `Range` with the given `Rng` as
     /// a source of randomness.
-    fn sample_range<R: Rng>(r: &Range<Self>, rng: &mut R) -> Self;
+    fn sample_range<R: Rng>(r: &Range<Self>, rng: &mut R) -> Self;
 }
 
 macro_rules! integer_impl {
diff --git a/src/rand/distributions/ziggurat_tables.rs.html b/src/rand/distributions/ziggurat_tables.rs.html
index 421ed82..1692bcc 100644
--- a/src/rand/distributions/ziggurat_tables.rs.html
+++ b/src/rand/distributions/ziggurat_tables.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     ziggurat_tables.rs.html -- source
diff --git a/src/rand/isaac.rs.html b/src/rand/isaac.rs.html
index 19fd372..a0fb4d2 100644
--- a/src/rand/isaac.rs.html
+++ b/src/rand/isaac.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     isaac.rs.html -- source
@@ -722,7 +722,7 @@
     /// fixed seed.
     pub fn new_unseeded() -> IsaacRng {
         let mut rng = EMPTY;
-        rng.init(false);
+        rng.init(false);
         rng
     }
 
@@ -894,7 +894,7 @@
         self.b = w(0);
         self.c = w(0);
 
-        self.init(true);
+        self.init(true);
     }
 
     /// Create an ISAAC random number generator with a seed. This can
@@ -923,7 +923,7 @@
         ret.b = w(0);
         ret.c = w(0);
 
-        ret.init(true);
+        ret.init(true);
         return ret;
     }
 }
@@ -963,7 +963,7 @@
     /// default fixed seed.
     pub fn new_unseeded() -> Isaac64Rng {
         let mut rng = EMPTY_64;
-        rng.init(false);
+        rng.init(false);
         rng
     }
 
@@ -1137,7 +1137,7 @@
         self.b = w(0);
         self.c = w(0);
 
-        self.init(true);
+        self.init(true);
     }
 
     /// Create an ISAAC random number generator with a seed. This can
@@ -1166,7 +1166,7 @@
         ret.b = w(0);
         ret.c = w(0);
 
-        ret.init(true);
+        ret.init(true);
         return ret;
     }
 }
diff --git a/src/rand/lib.rs.html b/src/rand/lib.rs.html
index b88b74f..2d0b4ef 100644
--- a/src/rand/lib.rs.html
+++ b/src/rand/lib.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     lib.rs.html -- source
@@ -1551,7 +1551,7 @@
 pub trait Rand : Sized {
     /// Generates a random instance of this type using the specified source of
     /// randomness.
-    fn rand<R: Rng>(rng: &mut R) -> Self;
+    fn rand<R: Rng>(rng: &mut R) -> Self;
 }
 
 /// A random number generator.
@@ -1688,7 +1688,7 @@
     /// println!("{:?}", rng.gen::<(f64, bool)>());
     /// ```
     #[inline(always)]
-    fn gen<T: Rand>(&mut self) -> T where Self: Sized {
+    fn gen<T: Rand>(&mut self) -> T where Self: Sized {
         Rand::rand(self)
     }
 
@@ -1706,7 +1706,7 @@
     /// println!("{:?}", rng.gen_iter::<(f64, bool)>().take(5)
     ///                     .collect::<Vec<(f64, bool)>>());
     /// ```
-    fn gen_iter<'a, T: Rand>(&'a mut self) -> Generator<'a, T, Self> where Self: Sized {
+    fn gen_iter<'a, T: Rand>(&'a mut self) -> Generator<'a, T, Self> where Self: Sized {
         Generator { rng: self, _marker: marker::PhantomData }
     }
 
@@ -1733,7 +1733,7 @@
     /// let m: f64 = rng.gen_range(-40.0f64, 1.3e5f64);
     /// println!("{}", m);
     /// ```
-    fn gen_range<T: PartialOrd + SampleRange>(&mut self, low: T, high: T) -> T where Self: Sized {
+    fn gen_range<T: PartialOrd + SampleRange>(&mut self, low: T, high: T) -> T where Self: Sized {
         assert!(low < high, "Rng.gen_range called with low >= high");
         Range::new(low, high).ind_sample(self)
     }
@@ -1748,7 +1748,7 @@
     /// let mut rng = thread_rng();
     /// println!("{}", rng.gen_weighted_bool(3));
     /// ```
-    fn gen_weighted_bool(&mut self, n: u32) -> bool where Self: Sized {
+    fn gen_weighted_bool(&mut self, n: u32) -> bool where Self: Sized {
         n <= 1 || self.gen_range(0, n) == 0
     }
 
@@ -1762,7 +1762,7 @@
     /// let s: String = thread_rng().gen_ascii_chars().take(10).collect();
     /// println!("{}", s);
     /// ```
-    fn gen_ascii_chars<'a>(&'a mut self) -> AsciiGenerator<'a, Self> where Self: Sized {
+    fn gen_ascii_chars<'a>(&'a mut self) -> AsciiGenerator<'a, Self> where Self: Sized {
         AsciiGenerator { rng: self }
     }
 
@@ -1780,7 +1780,7 @@
     /// println!("{:?}", rng.choose(&choices));
     /// assert_eq!(rng.choose(&choices[..0]), None);
     /// ```
-    fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> where Self: Sized {
+    fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> where Self: Sized {
         if values.is_empty() {
             None
         } else {
@@ -1802,7 +1802,7 @@
     /// rng.shuffle(&mut y);
     /// println!("{:?}", y);
     /// ```
-    fn shuffle<T>(&mut self, values: &mut [T]) where Self: Sized {
+    fn shuffle<T>(&mut self, values: &mut [T]) where Self: Sized {
         let mut i = values.len();
         while i >= 2 {
             // invariant: elements with index >= i have been locked in place.
@@ -1921,7 +1921,7 @@
     /// let mut rng: StdRng = SeedableRng::from_seed(seed);
     /// println!("{}", rng.gen::<f64>());
     /// ```
-    fn from_seed(seed: Seed) -> Self;
+    fn from_seed(seed: Seed) -> Self;
 }
 
 /// An Xorshift[1] random number
@@ -2285,8 +2285,8 @@
         loop {
             match (i.next(), j.next()) {
                 (Some(ref ei), Some(ref ej)) if ei == ej => { }
-                (None, None) => return true,
-                _ => return false,
+                (None, None) => return true,
+                _ => return false,
             }
         }
     }
@@ -2357,8 +2357,8 @@
     #[test]
     fn test_gen_weighted_bool() {
         let mut r = thread_rng();
-        assert_eq!(r.gen_weighted_bool(0), true);
-        assert_eq!(r.gen_weighted_bool(1), true);
+        assert_eq!(r.gen_weighted_bool(0), true);
+        assert_eq!(r.gen_weighted_bool(1), true);
     }
 
     #[test]
diff --git a/src/rand/os.rs.html b/src/rand/os.rs.html
index d66d52c..7dce56b 100644
--- a/src/rand/os.rs.html
+++ b/src/rand/os.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     os.rs.html -- source
@@ -651,7 +651,7 @@
                 let err = io::Error::last_os_error().raw_os_error();
                 err != Some(libc::ENOSYS)
             } else {
-                true
+                true
             };
             AVAILABLE.store(available, Ordering::Relaxed);
         });
@@ -665,7 +665,7 @@
                       target_arch = "arm",
                       target_arch = "aarch64",
                       target_arch = "powerpc"))))]
-    fn is_getrandom_available() -> bool { false }
+    fn is_getrandom_available() -> bool { false }
 
     pub struct OsRng {
         inner: OsRngInner,
diff --git a/src/rand/rand_impls.rs.html b/src/rand/rand_impls.rs.html
index 270b12f..c0e13d3 100644
--- a/src/rand/rand_impls.rs.html
+++ b/src/rand/rand_impls.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     rand_impls.rs.html -- source
diff --git a/src/rand/read.rs.html b/src/rand/read.rs.html
index bd1cfe1..6adb9c0 100644
--- a/src/rand/read.rs.html
+++ b/src/rand/read.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     read.rs.html -- source
diff --git a/src/rand/reseeding.rs.html b/src/rand/reseeding.rs.html
index a5784e1..f933ba5 100644
--- a/src/rand/reseeding.rs.html
+++ b/src/rand/reseeding.rs.html
@@ -4,7 +4,7 @@
     
     
     
-    
+    
     
 
     reseeding.rs.html -- source