Rustb 0.6.7

A package for calculating band, angle state, linear and nonlinear conductivities based on tight-binding models
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

//!这个是给程序提供泛型支持的模块
use crate::SpinDirection;
use crate::TbError;
use crate::model::Dimension;
use num_complex::Complex64;
use num_traits::identities::Zero;

pub trait ToFloat {
    fn to_float(self) -> f64;
}
impl ToFloat for usize {
    fn to_float(self) -> f64 {
        self as f64
    }
}

impl ToFloat for isize {
    fn to_float(self) -> f64 {
        self as f64
    }
}

impl ToFloat for f32 {
    fn to_float(self) -> f64 {
        self as f64
    }
}

impl ToFloat for f64 {
    fn to_float(self) -> f64 {
        self
    }
}

pub trait usefloat: Copy + Clone + Zero + std::fmt::Display + PartialOrd {
    fn from<T: ToFloat>(n: T) -> Self;
}
impl usefloat for f32 {
    fn from<T: ToFloat>(n: T) -> Self {
        n.to_float() as f32
    }
}

impl usefloat for f64 {
    fn from<T: ToFloat>(n: T) -> Self {
        n.to_float()
    }
}

//这里的trait是为了让set_hop 可以同时满足 f64 和 Complex64 的
pub trait hop_use: Copy + Clone + Zero {
    fn to_complex(&self) -> Complex64;
}
impl hop_use for f64 {
    fn to_complex(&self) -> Complex64 {
        Complex64::new(*self, 0.0)
    }
}

impl hop_use for Complex64 {
    fn to_complex(&self) -> Complex64 {
        *self
    }
}

// 实现从u8到SpinDirection的转换
impl From<u8> for SpinDirection {
    fn from(value: u8) -> Self {
        match value {
            0 => SpinDirection::None,
            1 => SpinDirection::x,
            2 => SpinDirection::y,
            3 => SpinDirection::z,
            _ => panic!("Invalid value for SpinDirection"),
        }
    }
}

// 实现从usize到SpinDirection的转换
impl From<usize> for SpinDirection {
    fn from(value: usize) -> Self {
        match value {
            0 => SpinDirection::None,
            1 => SpinDirection::x,
            2 => SpinDirection::y,
            3 => SpinDirection::z,
            _ => panic!("Invalid value for SpinDirection"),
        }
    }
}

// 实现从i32到SpinDirection的转换
impl From<i32> for SpinDirection {
    fn from(value: i32) -> Self {
        match value {
            0 => SpinDirection::None,
            1 => SpinDirection::x,
            2 => SpinDirection::y,
            3 => SpinDirection::z,
            _ => panic!("Invalid value for SpinDirection"),
        }
    }
}

impl From<Dimension> for usize {
    fn from(d: Dimension) -> Self {
        d as usize
    }
}

impl TryFrom<usize> for Dimension {
    type Error = TbError;

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Dimension::zero),
            1 => Ok(Dimension::one),
            2 => Ok(Dimension::two),
            3 => Ok(Dimension::three),
            _ => Err(TbError::InvalidDimension {
                dim: value,
                supported: vec![0, 1, 2, 3],
            }),
        }
    }
}