resistor-calc 0.1.0

A rust library to calculate nearest resistor values for circuit design.
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

extern crate meval;

use std::{f64::EPSILON, str::FromStr};

use RSet;

lazy_static!(
    static ref RNAMES: Vec<String> = (1..=100).map(|i| format!("R{}", i)).collect();
);

enum Bounds {
    Cmp(Box<Fn(f64, f64) -> bool>, meval::Expr, f64),
    Err(meval::Expr, f64),
}

fn split_expr(expr: &str, pat: &str) -> (meval::Expr, f64) {
    let mut split = expr.split(pat);
    (
        split.next().unwrap().trim().parse::<meval::Expr>().unwrap(),
        split.next().unwrap().trim().parse::<f64>().unwrap(),
    )
}

impl FromStr for Bounds {
    type Err = &'static str;

    fn from_str(s: &str) -> Result<Self, <Self as FromStr>::Err> {
        if s.contains("<=") {
            let (ex, trg) = split_expr(s, "<=");
            Ok(Bounds::Cmp(Box::new(|a, b| a <= b), ex, trg))
        } else if s.contains('<') {
            let (ex, trg) = split_expr(s, "<");
            Ok(Bounds::Cmp(Box::new(|a, b| a < b), ex, trg))
        } else if s.contains(">=") {
            let (ex, trg) = split_expr(s, ">=");
            Ok(Bounds::Cmp(Box::new(|a, b| a >= b), ex, trg))
        } else if s.contains('>') {
            let (ex, trg) = split_expr(s, ">");
            Ok(Bounds::Cmp(Box::new(|a, b| a > b), ex, trg))
        } else if s.contains("==") {
            let (ex, trg) = split_expr(s, "==");
            Ok(Bounds::Cmp(
                Box::new(|a, b| (a - b).abs() < EPSILON),
                ex,
                trg,
            ))
        } else if s.contains("!=") {
            let (ex, trg) = split_expr(s, "!=");
            Ok(Bounds::Cmp(
                Box::new(|a, b| (a - b).abs() > EPSILON),
                ex,
                trg,
            ))
        } else if s.contains('~') {
            let (ex, trg) = split_expr(s, "~");
            Ok(Bounds::Err(ex, trg))
        } else {
            Err("Err: Bound must contain either <, <=, >, >=, ==, != or ~")
        }
    }
}

/// Builder struct used to create `f` values for `RCalc::calc` from mathematical expressions.
#[derive(Default)]
pub struct ROpBuilder {
    ops: Vec<Bounds>,
}

impl ROpBuilder {
    /// Init a new builder.
    pub fn new() -> Self {
        ROpBuilder { ops: Vec::new() }
    }

    /// Add a new bound to the builder, this must be an expression of the form `expr op target`
    /// where expr is a math expression using R1,...,Rn and [supported expressions](https://docs.rs/meval/#supported-expressions),
    /// op is one of <, >, <=, >=, ==, != or ~ and target is an [f64 value](https://doc.rust-lang.org/std/primitive.f64.html#impl-FromStr).
    /// For ~ the bound will calculate the difference between the value of expr and target and add
    /// the abs error to the resulting error. For all other ops the bound will compare the value of
    /// expr to target, and if the comparison fails, it will reject the set of proposed values.
    pub fn bound(mut self, expr: &str) -> Self {
        self.ops.push(expr.parse().unwrap());
        self
    }

    fn cmp_bound_fn(&mut self) -> Box<Fn(&meval::Context) -> Option<f64>> {
        match self.ops.pop() {
            Some(b) => match b {
                Bounds::Cmp(op, expr, target) => {
                    let inner_bound = self.cmp_bound_fn();
                    Box::new(move |ctx| {
                        if op(expr.eval_with_context(ctx).unwrap(), target) {
                            inner_bound(ctx)
                        } else {
                            None
                        }
                    })
                }
                Bounds::Err(expr, target) => {
                    let inner_bound = self.cmp_bound_fn();
                    Box::new(move |ctx| {
                        let val = expr.eval_with_context(ctx).unwrap();
                        inner_bound(ctx).map(|v| v + (target - val).abs())
                    })
                }
            },
            None => Box::new(|_| Some(0.0)),
        }
    }

    /// Finishes the building and converts the struct into a function suitable to be passed to calc
    pub fn finish(mut self) -> impl Fn(&RSet) -> Option<f64> {
        let bound = self.cmp_bound_fn();
        move |rs: &RSet| {
            let mut ctx = meval::Context::new();
            for (i, v) in rs.0.iter().enumerate() {
                ctx.var(RNAMES[i].clone(), *v as f64);
            }
            bound(&ctx)
        }
    }
}