dynamic_expressions 0.10.0

Fast batched evaluation + forward-mode derivatives for symbolic expressions (Rust port of DynamicExpressions.jl).
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

mod macros {
    macro_rules! unary_wrappers {
        ($( $fname:ident => $Op:ty ),* $(,)?) => {
            $(
                #[inline]
                #[must_use]
                pub fn $fname<T, Ops, const D: usize>(
                    x: crate::expression::PostfixExpr<T, Ops, D>,
                ) -> crate::expression::PostfixExpr<T, Ops, D>
                where
                    Ops: crate::traits::HasOp<$Op>,
                {
                    crate::expression_algebra::__apply_postfix::<T, Ops, D, 1>(
                        <Ops as crate::traits::HasOp<$Op>>::ID,
                        [x],
                    )
                }
            )*
        };
    }

    macro_rules! binary_wrappers {
        ($( $fname:ident => $Op:ty ),* $(,)?) => {
            $(
                #[inline]
                #[must_use]
                pub fn $fname<T, Ops, const D: usize>(
                    x: crate::expression::PostfixExpr<T, Ops, D>,
                    y: crate::expression::PostfixExpr<T, Ops, D>,
                ) -> crate::expression::PostfixExpr<T, Ops, D>
                where
                    Ops: crate::traits::HasOp<$Op>,
                {
                    crate::expression_algebra::__apply_postfix::<T, Ops, D, 2>(
                        <Ops as crate::traits::HasOp<$Op>>::ID,
                        [x, y],
                    )
                }
            )*
        };
    }

    macro_rules! ternary_wrappers {
        ($( $fname:ident => $Op:ty ),* $(,)?) => {
            $(
                #[inline]
                #[must_use]
                pub fn $fname<T, Ops, const D: usize>(
                    x: crate::expression::PostfixExpr<T, Ops, D>,
                    y: crate::expression::PostfixExpr<T, Ops, D>,
                    z: crate::expression::PostfixExpr<T, Ops, D>,
                ) -> crate::expression::PostfixExpr<T, Ops, D>
                where
                    Ops: crate::traits::HasOp<$Op>,
                {
                    crate::expression_algebra::__apply_postfix::<T, Ops, D, 3>(
                        <Ops as crate::traits::HasOp<$Op>>::ID,
                        [x, y, z],
                    )
                }
            )*
        };
    }

    pub(crate) use {binary_wrappers, ternary_wrappers, unary_wrappers};
}

use macros::{binary_wrappers, ternary_wrappers, unary_wrappers};

use crate::operator_enum::builtin;

unary_wrappers! {
    cos => builtin::Cos,
    sin => builtin::Sin,
    tan => builtin::Tan,
    asin => builtin::Asin,
    acos => builtin::Acos,
    atan => builtin::Atan,
    sinh => builtin::Sinh,
    cosh => builtin::Cosh,
    tanh => builtin::Tanh,
    asinh => builtin::Asinh,
    acosh => builtin::Acosh,
    atanh => builtin::Atanh,
    sec => builtin::Sec,
    csc => builtin::Csc,
    cot => builtin::Cot,
    exp => builtin::Exp,
    exp2 => builtin::Exp2,
    expm1 => builtin::Expm1,
    log => builtin::Log,
    log2 => builtin::Log2,
    log10 => builtin::Log10,
    log1p => builtin::Log1p,
    sqrt => builtin::Sqrt,
    cbrt => builtin::Cbrt,
    abs => builtin::Abs,
    abs2 => builtin::Abs2,
    inv => builtin::Inv,
    sign => builtin::Sign,
    identity => builtin::Identity,
    neg => builtin::Neg,
}

binary_wrappers! {
    div => builtin::Div,
    add => builtin::Add,
    sub => builtin::Sub,
    mul => builtin::Mul,
    pow => builtin::Pow,
    atan2 => builtin::Atan2,
    min => builtin::Min,
    max => builtin::Max,
}

ternary_wrappers! {
    fma => builtin::Fma,
    clamp => builtin::Clamp,
}