conspire 0.7.7

The Rust interface to conspire.
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

use crate::{
    math::{Quantity, Scalar},
    physics::molecular::potential::Potential,
    units::{Energy, Force, ForcePerLength, Length, ReciprocalForcePerLength, Stress},
};

/// The harmonic potential.
#[derive(Clone, Debug)]
pub struct Harmonic {
    /// The rest length $`x_0`$.
    pub rest_length: Scalar,
    /// The stiffness $`k`$.
    pub stiffness: Scalar,
}

impl Potential for Harmonic {
    /// ```math
    /// u(x) = \frac{1}{2}\,k(x - x_0)^2
    /// ```
    fn energy(&self, length: Quantity<Length>) -> Quantity<Energy> {
        let delta = length - self.rest_length();
        0.5 * self.stiffness_quantity() * (delta * delta)
    }
    /// ```math
    /// f(x) = k(x - x_0)
    /// ```
    fn force(&self, length: Quantity<Length>) -> Quantity<Force> {
        self.stiffness_quantity() * (length - self.rest_length())
    }
    /// ```math
    /// f = \pm\sqrt{2ku}
    /// ```
    fn forces_at_energy(&self, energy: Quantity<Energy>) -> [Quantity<Force>; 2] {
        let force = Quantity::new((2.0 * self.stiffness * energy.value()).sqrt());
        [force, -force]
    }
    /// ```math
    /// k(x) = k
    /// ```
    fn stiffness(&self, _length: Quantity<Length>) -> Quantity<ForcePerLength> {
        self.stiffness_quantity()
    }
    /// ```math
    /// h(x) = 0.0
    /// ```
    fn anharmonicity(&self, _length: Quantity<Length>) -> Quantity<Stress> {
        Quantity::new(0.0)
    }
    /// ```math
    /// \Delta x(f) = \frac{f}{k}
    /// ```
    fn extension(&self, force: Quantity<Force>) -> Quantity<Length> {
        force / self.stiffness_quantity()
    }
    /// ```math
    /// \Delta x = \pm\sqrt{\frac{2u}{k}}
    /// ```
    fn extensions_at_energy(&self, energy: Quantity<Energy>) -> [Quantity<Length>; 2] {
        let extension = Quantity::new((2.0 * energy.value() / self.stiffness).sqrt());
        [extension, -extension]
    }
    /// ```math
    /// c(f) = \frac{1}{k}
    /// ```
    fn compliance(&self, _force: Quantity<Force>) -> Quantity<ReciprocalForcePerLength> {
        1.0 / self.stiffness_quantity()
    }
    /// ```math
    /// \text{arg max }u(x) = \infty
    /// ```
    fn peak(&self) -> Quantity<Length> {
        Quantity::new(Scalar::INFINITY)
    }
    /// ```math
    /// f(x_\mathrm{peak}) = \infty
    /// ```
    fn peak_force(&self) -> Quantity<Force> {
        Quantity::new(Scalar::INFINITY)
    }
    /// ```math
    /// \text{arg min }u(x) = x_0
    /// ```
    fn rest_length(&self) -> Quantity<Length> {
        Quantity::new(self.rest_length)
    }
}

impl Harmonic {
    /// Returns the stiffness.
    fn stiffness_quantity(&self) -> Quantity<ForcePerLength> {
        Quantity::new(self.stiffness)
    }
}