eigentrust 0.2.0

EigenTrust reputation algorithm: global trust scores for peer-to-peer networks and social graphs, with Sybil resistance
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

use std::fmt;

/// Which input an [`EigenTrustError`] refers to.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Input {
    /// The local trust edges.
    LocalTrust,
    /// The pre-trust (seed) entries.
    PreTrust,
}

impl fmt::Display for Input {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(match self {
            Input::LocalTrust => "local trust",
            Input::PreTrust => "pre-trust",
        })
    }
}

/// Why [`eigentrust`](crate::eigentrust) could not compute scores.
///
/// Input positions are 0-based indices into the iterator that was passed in.
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum EigenTrustError {
    /// `alpha` is not a finite number in `[0, 1]`.
    InvalidAlpha(f64),
    /// `epsilon` is not a finite number greater than zero.
    InvalidEpsilon(f64),
    /// `max_iterations` is zero.
    InvalidMaxIterations,
    /// A weight is NaN or infinite.
    NonFiniteWeight {
        /// The input containing the weight.
        input: Input,
        /// Position of the item in that input.
        position: usize,
    },
    /// A weight is negative. Distrust is not supported.
    NegativeWeight {
        /// The input containing the weight.
        input: Input,
        /// Position of the item in that input.
        position: usize,
        /// The rejected weight.
        weight: f64,
    },
    /// A peer index of `usize::MAX`, which leaves no room to count the peers.
    InvalidPeer {
        /// The input containing the index.
        input: Input,
        /// Position of the item in that input.
        position: usize,
    },
    /// The weights of one truster, or all of pre-trust, add up to more than `f64::MAX`.
    WeightOverflow(Input),
    /// Neither input mentions any peer.
    EmptyNetwork,
    /// The scores did not settle within `max_iterations`. With `alpha` near zero some
    /// networks oscillate instead of converging.
    NotConverged {
        /// Iterations performed.
        iterations: usize,
        /// Change between the last two iterations (L2 norm).
        residual: f64,
    },
}

impl fmt::Display for EigenTrustError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            EigenTrustError::InvalidAlpha(a) => write!(f, "alpha must be in [0, 1], got {}", a),
            EigenTrustError::InvalidEpsilon(e) => {
                write!(f, "epsilon must be finite and greater than 0, got {}", e)
            }
            EigenTrustError::InvalidMaxIterations => {
                f.write_str("max_iterations must be at least 1")
            }
            EigenTrustError::NonFiniteWeight { input, position } => {
                write!(f, "{} item {}: weight must be finite", input, position)
            }
            EigenTrustError::NegativeWeight {
                input,
                position,
                weight,
            } => write!(
                f,
                "{} item {}: weight {} is negative; distrust is not supported",
                input, position, weight
            ),
            EigenTrustError::InvalidPeer { input, position } => {
                write!(
                    f,
                    "{} item {}: peer index usize::MAX is not allowed",
                    input, position
                )
            }
            EigenTrustError::WeightOverflow(input) => {
                write!(
                    f,
                    "{} weights are too large: their sum overflows f64",
                    input
                )
            }
            EigenTrustError::EmptyNetwork => f.write_str("the network has no peers"),
            EigenTrustError::NotConverged {
                iterations,
                residual,
            } => write!(
                f,
                "did not converge in {} iterations (residual {:.3e}); \
                 a small alpha on a periodic trust graph can oscillate, try a larger alpha",
                iterations, residual
            ),
        }
    }
}

impl std::error::Error for EigenTrustError {}