bijli 1.1.0

Electromagnetism simulation — fields, Maxwell's equations, charge dynamics, EM waves
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

//! Error types for bijli.

#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum BijliError {
    #[error("invalid field dimensions: expected {expected}D, got {got}D")]
    DimensionMismatch { expected: usize, got: usize },

    #[error("charge magnitude is zero — cannot compute field direction")]
    ZeroCharge,

    #[error("singularity: field evaluation at source point (distance = 0)")]
    Singularity,

    #[error("grid resolution too coarse: {cells} cells for domain size {domain_size}")]
    InsufficientResolution { cells: usize, domain_size: f64 },

    #[error("invalid permittivity: {value} (must be > 0)")]
    InvalidPermittivity { value: f64 },

    #[error("invalid permeability: {value} (must be > 0)")]
    InvalidPermeability { value: f64 },

    #[error("division by zero in EM calculation: {context}")]
    DivisionByZero { context: String },

    #[error("invalid parameter: {reason}")]
    InvalidParameter { reason: String },
}

pub type Result<T> = std::result::Result<T, BijliError>;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_dimension_mismatch() {
        let e = BijliError::DimensionMismatch {
            expected: 3,
            got: 2,
        };
        let msg = e.to_string();
        assert!(msg.contains("3D"));
        assert!(msg.contains("2D"));
    }

    #[test]
    fn test_zero_charge() {
        let e = BijliError::ZeroCharge;
        assert!(e.to_string().contains("zero"));
    }

    #[test]
    fn test_singularity() {
        let e = BijliError::Singularity;
        assert!(e.to_string().contains("distance = 0"));
    }

    #[test]
    fn test_insufficient_resolution() {
        let e = BijliError::InsufficientResolution {
            cells: 4,
            domain_size: 100.0,
        };
        assert!(e.to_string().contains("4 cells"));
    }

    #[test]
    fn test_invalid_permittivity() {
        let e = BijliError::InvalidPermittivity { value: -1.0 };
        assert!(e.to_string().contains("-1"));
    }

    #[test]
    fn test_invalid_permeability() {
        let e = BijliError::InvalidPermeability { value: 0.0 };
        assert!(e.to_string().contains("0"));
    }

    #[test]
    fn test_division_by_zero() {
        let e = BijliError::DivisionByZero {
            context: "field magnitude".into(),
        };
        assert!(e.to_string().contains("field magnitude"));
    }

    #[test]
    fn test_invalid_parameter() {
        let e = BijliError::InvalidParameter {
            reason: "negative frequency".into(),
        };
        assert!(e.to_string().contains("negative frequency"));
    }

    #[test]
    fn test_result_alias() {
        let ok: Result<f64> = Ok(1.0);
        assert!(ok.is_ok());
        let err: Result<f64> = Err(BijliError::ZeroCharge);
        assert!(err.is_err());
    }

    #[test]
    fn test_error_is_debug() {
        let e = BijliError::Singularity;
        let debug = format!("{:?}", e);
        assert!(debug.contains("Singularity"));
    }
}