reda-spice 0.1.0

Spice simulate and parse library
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

use reda_unit::{Complex, Number, Unit, UnitComplex, UnitNumber};

#[derive(Debug, Clone, PartialEq)]
pub enum Value {
    Real(Number),
    Complex(Complex),
}

impl Value {
    pub fn real<V: Into<Number>>(v: V) -> Self {
        Self::Real(v.into())
    }

    pub fn complex<V1: Into<Number>, V2: Into<Number>>(re: V1, im: V2) -> Self {
        Self::Complex(Complex::new(re.into(), im.into()))
    }
}

impl Value {
    pub fn extract_numbers(values: &[Self]) -> Option<Vec<Number>> {
        let mut numbers = Vec::new(); 
        for v in values.iter() {
            match v {
                Value::Real(r) => numbers.push(*r),
                Value::Complex(_) => return None,
            }
        }
        Some(numbers)
    }

    pub fn extract_complexs(values: &[Self]) -> Option<Vec<Complex>> {
        let mut complexs = Vec::new(); 
        for v in values.iter() {
            match v {
                Value::Real(_) => return None,
                Value::Complex(c) => complexs.push(*c),
            }
        }
        Some(complexs)
    }

    pub fn extract_units<U: Unit>(values: &[Self]) -> Option<Vec<UnitNumber<U>>> {
        let mut numbers = Vec::new(); 
        for v in values.iter() {
            match v {
                Value::Real(r) => numbers.push(UnitNumber::new(*r)),
                Value::Complex(_) => return None,
            }
        }
        Some(numbers)
    }

    pub fn extract_unit_complexs<U: Unit>(values: &[Self]) -> Option<Vec<UnitComplex<U>>> {
        let mut numbers = Vec::new(); 
        for v in values.iter() {
            match v {
                Value::Real(_) => return None,
                Value::Complex(c) => numbers.push(UnitComplex::new(c.re, c.im)),
            }
        }
        Some(numbers)
    }
}