Deprecated: The each() function is deprecated. This message will be suppressed on further calls in /home/zhenxiangba/zhenxiangba.com/public_html/phproxy-improved-master/index.php on line 456
criterion-stats 0.1.1 - Docs.rs
[go: Go Back, main page]

criterion-stats 0.1.1

Criterion's statistics library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//! Helper traits for tupling/untupling

// TODO(HKT) make this more "generic", and move into its own crate
// TODO(negative_bounds) bounds should be `: !Drop` instead of `Copy`

use std::ptr;

use Distribution;

/// Any tuple: `(A, B, ..)`
pub trait Tuple: Sized {
    /// A tuple of distributions associated with this tuple
    type Distributions: TupledDistributions<Item=Self>;
}

/// A tuple of distributions: `(Distribution<A>, Distribution<B>, ..)`
pub trait TupledDistributions: Sized {
    /// A tuple that can be pushed/inserted into the tupled distributions
    type Item: Tuple<Distributions=Self>;

    /// Creates a tuple of unitialized distributions, where each distribution has the same `length`
    unsafe fn uninitialized(length: usize) -> Self;

    /// Writes each element of `tuple` into its corresponding distribution
    unsafe fn set_unchecked(&mut self, i: usize, tuple: Self::Item);
}

impl<A> Tuple for (A,) where A: Copy {
    type Distributions = (Distribution<A>,);
}

impl<A> TupledDistributions for (Distribution<A>,) where A: Copy {
    type Item = (A,);

    unsafe fn uninitialized(n: usize) -> (Distribution<A>,) {
        (
            Distribution({
                let mut v = Vec::with_capacity(n); v.set_len(n); v.into_boxed_slice()
            }),
        )
    }

    unsafe fn set_unchecked(&mut self, i: usize, tuple: (A,)) {
        ptr::write((self.0).0.get_unchecked_mut(i), tuple.0);
    }
}

impl<A, B> Tuple for (A, B) where A: Copy, B: Copy {
    type Distributions = (Distribution<A>, Distribution<B>);
}

impl<A, B> TupledDistributions for (Distribution<A>, Distribution<B>) where A: Copy, B: Copy {
    type Item = (A, B);

    unsafe fn uninitialized(n: usize) -> (Distribution<A>, Distribution<B>) {
        (
            Distribution({
                let mut v = Vec::with_capacity(n); v.set_len(n); v.into_boxed_slice()
            }),
            Distribution({
                let mut v = Vec::with_capacity(n); v.set_len(n); v.into_boxed_slice()
            }),
        )
    }

    unsafe fn set_unchecked(&mut self, i: usize, tuple: (A, B)) {
        ptr::write((self.0).0.get_unchecked_mut(i), tuple.0);
        ptr::write((self.1).0.get_unchecked_mut(i), tuple.1);
    }
}

impl<A, B, C> Tuple for (A, B, C) where A: Copy, B: Copy, C: Copy {
    type Distributions = (Distribution<A>, Distribution<B>, Distribution<C>);
}

impl<A, B, C> TupledDistributions for (Distribution<A>, Distribution<B>, Distribution<C>) where
    A: Copy, B: Copy, C: Copy,
{
    type Item = (A, B, C);

    unsafe fn uninitialized(n: usize) -> (Distribution<A>, Distribution<B>, Distribution<C>) {
        (
            Distribution({
                let mut v = Vec::with_capacity(n); v.set_len(n); v.into_boxed_slice()
            }),
            Distribution({
                let mut v = Vec::with_capacity(n); v.set_len(n); v.into_boxed_slice()
            }),
            Distribution({
                let mut v = Vec::with_capacity(n); v.set_len(n); v.into_boxed_slice()
            }),
        )
    }

    unsafe fn set_unchecked(&mut self, i: usize, tuple: (A, B, C)) {
        ptr::write((self.0).0.get_unchecked_mut(i), tuple.0);
        ptr::write((self.1).0.get_unchecked_mut(i), tuple.1);
        ptr::write((self.2).0.get_unchecked_mut(i), tuple.2);
    }
}

impl<A, B, C, D> Tuple for (A, B, C, D) where A: Copy, B: Copy, C: Copy, D: Copy {
    type Distributions = (Distribution<A>, Distribution<B>, Distribution<C>, Distribution<D>);
}

impl<A, B, C, D> TupledDistributions
for (Distribution<A>, Distribution<B>, Distribution<C>, Distribution<D>) where
    A: Copy, B: Copy, C: Copy, D: Copy,
{
    type Item = (A, B, C, D);

    unsafe fn uninitialized(
        n: usize,
    ) -> (Distribution<A>, Distribution<B>, Distribution<C>, Distribution<D>) {
        (
            Distribution({
                let mut v = Vec::with_capacity(n); v.set_len(n); v.into_boxed_slice()
            }),
            Distribution({
                let mut v = Vec::with_capacity(n); v.set_len(n); v.into_boxed_slice()
            }),
            Distribution({
                let mut v = Vec::with_capacity(n); v.set_len(n); v.into_boxed_slice()
            }),
            Distribution({
                let mut v = Vec::with_capacity(n); v.set_len(n); v.into_boxed_slice()
            }),
        )
    }

    unsafe fn set_unchecked(&mut self, i: usize, tuple: (A, B, C, D)) {
        ptr::write((self.0).0.get_unchecked_mut(i), tuple.0);
        ptr::write((self.1).0.get_unchecked_mut(i), tuple.1);
        ptr::write((self.2).0.get_unchecked_mut(i), tuple.2);
        ptr::write((self.3).0.get_unchecked_mut(i), tuple.3);
    }
}