unitforge 0.5.3

A library for unit and quantity consistent computations in Rust
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use core::fmt;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum UnitforgeError {
    QuantityConversion(QuantityConversionError),
    QuantityOperation(QuantityOperationError),
    Linalg(LinalgError),
}

pub type UnitforgeResult<T> = Result<T, UnitforgeError>;

impl fmt::Display for UnitforgeError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            UnitforgeError::QuantityConversion(err) => err.fmt(f),
            UnitforgeError::QuantityOperation(err) => err.fmt(f),
            UnitforgeError::Linalg(err) => err.fmt(f),
        }
    }
}

impl From<QuantityConversionError> for UnitforgeError {
    fn from(value: QuantityConversionError) -> Self {
        UnitforgeError::QuantityConversion(value)
    }
}

impl From<QuantityOperationError> for UnitforgeError {
    fn from(value: QuantityOperationError) -> Self {
        UnitforgeError::QuantityOperation(value)
    }
}

impl From<LinalgError> for UnitforgeError {
    fn from(value: LinalgError) -> Self {
        UnitforgeError::Linalg(value)
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum QuantityConversionError {
    InvalidQuantityUnitPair,
    InvalidQuantityExtraction,
    InvalidPythonQuantity,
    InvalidPythonUnit,
    UnknownQuantityKindId { kind_id: u32 },
    UnknownUnitKindId { kind_id: u32 },
    UnknownUnitVariantId { kind_id: u32, variant_id: i32 },
}

pub type QuantityConversionResult<T> = Result<T, QuantityConversionError>;

impl fmt::Display for QuantityConversionError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            QuantityConversionError::InvalidQuantityUnitPair => {
                write!(f, "Cannot use given pair of quantity and unit")
            }
            QuantityConversionError::InvalidQuantityExtraction => {
                write!(f, "Cannot extract requested quantity type")
            }
            QuantityConversionError::InvalidPythonQuantity => {
                write!(f, "Cannot interpret given value as Quantity")
            }
            QuantityConversionError::InvalidPythonUnit => {
                write!(f, "Cannot interpret given value as Unit")
            }
            QuantityConversionError::UnknownQuantityKindId { kind_id } => {
                write!(f, "Unknown quantity kind id: {kind_id}")
            }
            QuantityConversionError::UnknownUnitKindId { kind_id } => {
                write!(f, "Unknown unit kind id: {kind_id}")
            }
            QuantityConversionError::UnknownUnitVariantId {
                kind_id,
                variant_id,
            } => write!(
                f,
                "Unknown unit variant id {variant_id} for unit kind id {kind_id}"
            ),
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum QuantityOperationError {
    AddError,
    SubError,
    MulError,
    DivError,
    ModError,
    PowError,
    SqrtError,
    ComparisonError,
}

pub type QuantityOperationResult<T> = Result<T, QuantityOperationError>;

impl fmt::Display for QuantityOperationError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            QuantityOperationError::AddError => write!(f, "Addition operation failed"),
            QuantityOperationError::SubError => write!(f, "Subtraction operation failed"),
            QuantityOperationError::MulError => write!(f, "Multiplication operation failed"),
            QuantityOperationError::DivError => write!(f, "Division operation failed"),
            QuantityOperationError::ModError => write!(f, "Modulo operation failed"),
            QuantityOperationError::PowError => write!(f, "Power operation failed"),
            QuantityOperationError::SqrtError => write!(f, "Sqrt operation failed"),
            QuantityOperationError::ComparisonError => write!(f, "Comparison operation failed"),
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum LinalgShape {
    Vector { len: usize },
    Matrix { rows: usize, cols: usize },
}

impl fmt::Display for LinalgShape {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            LinalgShape::Vector { len } => write!(f, "vector length {len}"),
            LinalgShape::Matrix { rows, cols } => write!(f, "matrix shape {rows}x{cols}"),
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum LinalgError {
    ShapeMismatch {
        expected: LinalgShape,
        actual: LinalgShape,
    },
    ShapeConstructionFailed,
}

pub type LinalgResult<T> = Result<T, LinalgError>;

impl fmt::Display for LinalgError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            LinalgError::ShapeMismatch { expected, actual } => {
                write!(f, "Shape mismatch: expected {expected}, got {actual}")
            }
            LinalgError::ShapeConstructionFailed => write!(f, "Shape construction failed"),
        }
    }
}

#[cfg(not(feature = "no_std"))]
impl std::error::Error for UnitforgeError {}

#[cfg(not(feature = "no_std"))]
impl std::error::Error for QuantityConversionError {}

#[cfg(not(feature = "no_std"))]
impl std::error::Error for QuantityOperationError {}

#[cfg(not(feature = "no_std"))]
impl std::error::Error for LinalgError {}