kalix 0.2.1

Declarative Kalman filtering from dynamics expressions. Write the physics, derive the filter.
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

/// Expression AST nodes for symbolic dynamics.
///
/// Expressions are polynomial in state variables and the special token `dt`.
/// Supported operations: addition, subtraction, multiplication, division-by-literal,
/// integer powers, and trigonometric functions (`sin`, `cos`, `log`, `exp`).
#[derive(Debug, Clone, PartialEq)]
pub enum Expr {
    /// A numeric literal: `3.14`, `0.5`, `1.0`
    Lit(f64),
    /// A variable reference: state variable name (e.g. `"pos"`) or `"dt"`
    Var(String),
    /// Addition: `a + b`
    Add(Box<Expr>, Box<Expr>),
    /// Subtraction: `a - b`
    Sub(Box<Expr>, Box<Expr>),
    /// Multiplication: `a * b`
    Mul(Box<Expr>, Box<Expr>),
    /// Division: `a / b` — right-hand side must be a literal
    Div(Box<Expr>, Box<Expr>),
    /// Integer power: `a ^ n` where n is a positive integer
    Pow(Box<Expr>, u32),
    /// Sine: `sin(expr)`
    Sin(Box<Expr>),
    /// Cosine: `cos(expr)`
    Cos(Box<Expr>),
    /// Natural logarithm: `log(expr)`
    Log(Box<Expr>),
    /// Exponential: `exp(expr)`
    Exp(Box<Expr>),
}

impl Expr {
    /// Create a `Lit` node.
    pub fn lit(v: f64) -> Self {
        Expr::Lit(v)
    }

    /// Create a `Var` node.
    pub fn var(name: &str) -> Self {
        Expr::Var(name.to_string())
    }

    /// Convenience: `a + b`
    #[allow(clippy::should_implement_trait)]
    pub fn add(a: Expr, b: Expr) -> Self {
        Expr::Add(Box::new(a), Box::new(b))
    }

    /// Convenience: `a - b`
    #[allow(clippy::should_implement_trait)]
    pub fn sub(a: Expr, b: Expr) -> Self {
        Expr::Sub(Box::new(a), Box::new(b))
    }

    /// Convenience: `a * b`
    #[allow(clippy::should_implement_trait)]
    pub fn mul(a: Expr, b: Expr) -> Self {
        Expr::Mul(Box::new(a), Box::new(b))
    }

    /// Convenience: `a / b`
    #[allow(clippy::should_implement_trait)]
    pub fn div(a: Expr, b: Expr) -> Self {
        Expr::Div(Box::new(a), Box::new(b))
    }

    /// Convenience: `a ^ n`
    pub fn pow(a: Expr, n: u32) -> Self {
        Expr::Pow(Box::new(a), n)
    }

    /// Convenience: `sin(a)`
    pub fn sin(a: Expr) -> Self {
        Expr::Sin(Box::new(a))
    }

    /// Convenience: `cos(a)`
    pub fn cos(a: Expr) -> Self {
        Expr::Cos(Box::new(a))
    }

    /// Convenience: `log(a)` (natural log)
    pub fn log(a: Expr) -> Self {
        Expr::Log(Box::new(a))
    }

    /// Convenience: `exp(a)`
    pub fn exp(a: Expr) -> Self {
        Expr::Exp(Box::new(a))
    }
}

impl std::fmt::Display for Expr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Expr::Lit(v) => write!(f, "{}", v),
            Expr::Var(name) => write!(f, "{}", name),
            Expr::Add(a, b) => write!(f, "({} + {})", a, b),
            Expr::Sub(a, b) => write!(f, "({} - {})", a, b),
            Expr::Mul(a, b) => write!(f, "({} * {})", a, b),
            Expr::Div(a, b) => write!(f, "({} / {})", a, b),
            Expr::Pow(a, n) => write!(f, "({} ^ {})", a, n),
            Expr::Sin(a) => write!(f, "sin({})", a),
            Expr::Cos(a) => write!(f, "cos({})", a),
            Expr::Log(a) => write!(f, "log({})", a),
            Expr::Exp(a) => write!(f, "exp({})", a),
        }
    }
}