amari-network 0.21.0

Geometric network analysis using Clifford algebra and tropical algebra
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

//! Error types for network analysis operations

use thiserror::Error;

/// Error types for network analysis operations
#[derive(Error, Debug, Clone, PartialEq)]
pub enum NetworkError {
    /// Node index is out of bounds
    #[error("Node index {0} out of bounds")]
    NodeIndexOutOfBounds(usize),

    /// Invalid edge specification
    #[error("Invalid edge: source={0}, target={1}")]
    InvalidEdge(usize, usize),

    /// Matrix dimension mismatch
    #[error("Matrix dimension mismatch: expected {expected}, got {got}")]
    DimensionMismatch { expected: usize, got: usize },

    /// Network is disconnected when connected network required
    #[error("Network is disconnected")]
    DisconnectedNetwork,

    /// Computation failed with detailed message
    #[error("Computation failed: {0}")]
    ComputationError(String),

    /// Invalid parameter value
    #[error("Invalid parameter {parameter}: {value} (must be {constraint})")]
    InvalidParameter {
        parameter: String,
        value: String,
        constraint: String,
    },

    /// Empty network when non-empty required
    #[error("Operation requires non-empty network")]
    EmptyNetwork,

    /// Convergence failure in iterative algorithm
    #[error("Algorithm failed to converge after {iterations} iterations")]
    ConvergenceFailure { iterations: usize },

    /// Insufficient data for analysis
    #[error("Insufficient data: {reason}")]
    InsufficientData { reason: String },
}

/// Result type for network operations
pub type NetworkResult<T> = Result<T, NetworkError>;

impl NetworkError {
    /// Create a computation error with formatted message
    pub fn computation<T: std::fmt::Display>(msg: T) -> Self {
        NetworkError::ComputationError(msg.to_string())
    }

    /// Create an invalid parameter error
    pub fn invalid_param(param: &str, value: impl std::fmt::Display, constraint: &str) -> Self {
        NetworkError::InvalidParameter {
            parameter: param.to_string(),
            value: value.to_string(),
            constraint: constraint.to_string(),
        }
    }

    /// Create an insufficient data error
    pub fn insufficient_data(reason: &str) -> Self {
        NetworkError::InsufficientData {
            reason: reason.to_string(),
        }
    }
}