var_quantity 0.3.3

Provides an interface for defining variable quantities whose value depends on that of other quantities.
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

use serde::{Deserialize, Serialize};
use var_quantity::uom::si::{
    electric_current::ampere, electric_potential::volt, f64::*, frequency::hertz,
    magnetic_flux_density::tesla, power::watt, thermodynamic_temperature::degree_celsius,
};
use var_quantity::{DynQuantity, PredefUnit, Unit};
use var_quantity::{IsQuantityFunction, QuantityFunction, VarQuantity};

#[test]
fn test_var_quantity() {
    let conditions = [
        ElectricCurrent::new::<ampere>(2.0).into(),
        ThermodynamicTemperature::new::<degree_celsius>(2.0).into(),
    ];

    let var_quantity = VarQuantity::Constant(Power::new::<watt>(1.0));
    assert_eq!(var_quantity.get(conditions.as_slice()).get::<watt>(), 1.0);
}

#[test]
fn test_multiply_by_current() {
    #[derive(Serialize, Deserialize, Clone, PartialEq)]
    struct MultiplyIfCurrent(ElectricPotential);

    let conditions = [
        ElectricCurrent::new::<ampere>(2.0).into(),
        ThermodynamicTemperature::new::<degree_celsius>(2.0).into(),
    ];

    #[typetag::serde]
    impl IsQuantityFunction for MultiplyIfCurrent {
        fn call(&self, conditions: &[DynQuantity<f64>]) -> DynQuantity<f64> {
            let value = conditions
                .into_iter()
                .find_map(|iq| {
                    if Unit::from(PredefUnit::ElectricCurrent) == iq.unit {
                        return Some(iq.clone());
                    } else {
                        return None;
                    }
                })
                .unwrap_or(DynQuantity::new(0.0, PredefUnit::ElectricCurrent));
            return DynQuantity::from(self.0) * value;
        }

        fn dyn_eq(&self, other: &dyn IsQuantityFunction) -> bool {
            (other as &dyn std::any::Any).downcast_ref::<Self>() == Some(self)
        }
    }

    let wrapper = QuantityFunction::new(Box::new(MultiplyIfCurrent(
        ElectricPotential::new::<volt>(0.5),
    )))
    .unwrap();

    // Test deref
    fn do_nothing_ref(_function: &dyn IsQuantityFunction) {}
    do_nothing_ref(&*wrapper);
    fn do_nothing_any(_function: &dyn std::any::Any) {}
    do_nothing_any(&*wrapper);

    // Test casting
    assert!(
        (wrapper.as_ref() as &dyn std::any::Any)
            .downcast_ref::<MultiplyIfCurrent>()
            .is_some()
    );

    let var_quantity: VarQuantity<Power> = VarQuantity::Function(wrapper);
    assert_eq!(var_quantity.get(conditions.as_slice()).get::<watt>(), 1.0);

    // Test cast to dyn Any
    let function = var_quantity.function().unwrap();
    let any_fn = function as &dyn std::any::Any;
    assert!(any_fn.downcast_ref::<MultiplyIfCurrent>().is_some());
}

#[test]
fn test_readme_example() {
    // Model 1: p = k * B^2
    #[derive(Clone, serde::Deserialize, serde::Serialize, PartialEq)]
    struct Model1(DynQuantity<f64>);

    #[typetag::serde]
    impl IsQuantityFunction for Model1 {
        fn call(&self, conditions: &[DynQuantity<f64>]) -> DynQuantity<f64> {
            let mut b = DynQuantity::new(0.0, PredefUnit::MagneticFluxDensity);
            for factor in conditions.iter() {
                if b.unit == factor.unit {
                    b = factor.clone();
                }
            }
            return self.0 * b.powi(2);
        }

        fn dyn_eq(&self, other: &dyn IsQuantityFunction) -> bool {
            (other as &dyn std::any::Any).downcast_ref::<Self>() == Some(self)
        }
    }

    // Model 2: p = k * f^2 * B^2
    #[derive(Clone, serde::Deserialize, serde::Serialize, PartialEq)]
    struct Model2(DynQuantity<f64>);

    #[typetag::serde]
    impl IsQuantityFunction for Model2 {
        fn call(&self, conditions: &[DynQuantity<f64>]) -> DynQuantity<f64> {
            let mut b = DynQuantity::new(0.0, PredefUnit::MagneticFluxDensity);
            let mut f = DynQuantity::new(0.0, PredefUnit::Frequency);
            for factor in conditions.iter() {
                if b.unit == factor.unit {
                    b = factor.clone();
                }
                if f.unit == factor.unit {
                    f = factor.clone();
                }
            }
            return self.0 * f.powi(2) * b.powi(2);
        }

        fn dyn_eq(&self, other: &dyn IsQuantityFunction) -> bool {
            (other as &dyn std::any::Any).downcast_ref::<Self>() == Some(self)
        }
    }

    let k = DynQuantity::new(
        1000.0,
        Unit::from(PredefUnit::Power) / Unit::from(PredefUnit::MagneticFluxDensity).powi(2),
    );
    let model1: VarQuantity<Power> = VarQuantity::Function(
        QuantityFunction::new(Box::new(Model1(k))).expect("output unit is watt"),
    );

    let k = DynQuantity::new(
        2.0,
        Unit::from(PredefUnit::Power)
            / Unit::from(PredefUnit::MagneticFluxDensity).powi(2)
            / Unit::from(PredefUnit::Frequency).powi(2),
    );
    let model2: VarQuantity<Power> = VarQuantity::Function(
        QuantityFunction::new(Box::new(Model2(k))).expect("output unit is watt"),
    );

    // This function takes a variable quantity, the magnetic flux density and
    // the frequency and calculates the losses
    fn losses(model: &VarQuantity<Power>, b: MagneticFluxDensity, f: Frequency) -> Power {
        return model.get(&[b.into(), f.into()]);
    }

    let b = MagneticFluxDensity::new::<tesla>(1.2);
    let f = Frequency::new::<hertz>(20.0);

    assert_eq!(losses(&model1, b, f).get::<watt>(), 1440.0);
    assert_eq!(losses(&model2, b, f).get::<watt>(), 1152.0);
}