rsdiff-macros 0.0.2

the crate implements custom macros for rsdiff
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

/*
    Appellation: binary <module>
    Contrib: FL03 <jo3mccain@icloud.com>
*/
use super::handle_expr;
use crate::{foil, foil_expr};
use proc_macro2::TokenStream;
use quote::quote;
use syn::{BinOp, Expr, ExprBinary, Ident};

pub fn handle_binary(expr: &ExprBinary, var: &Ident) -> TokenStream {
    let ExprBinary {
        left, right, op, ..
    } = expr;

    // Compute the partial derivative of the left expression w.r.t. the variable
    let dl = handle_expr(left, var);
    // Compute the partial derivative of the right expression w.r.t. the variable
    let dr = handle_expr(right, var);

    // Apply the chain rule based on the operator
    match op {
        // Differentiate addition
        BinOp::Add(_) | BinOp::AddAssign(_) => {
            quote! {
                #dl + #dr
            }
        }
        // Differentiate division using the quotient rule
        BinOp::Div(_) | BinOp::DivAssign(_) => {
            quote! {
                (#right * #dl - #left * #dr) / (#right * #right)
            }
        }
        // Differentiate multiplication
        BinOp::Mul(_) | BinOp::MulAssign(_) => {
            if let Expr::Paren(pl) = *left.clone() {
                if let Expr::Paren(pr) = *right.clone() {
                    foil(&pl, &pr, var)
                } else {
                    foil_expr(right, &pl, var)
                }
            } else if let Expr::Paren(pr) = *right.clone() {
                if let Expr::Paren(pl) = *left.clone() {
                    foil(&pl, &pr, var)
                } else {
                    foil_expr(left, &pr, var)
                }
            } else {
                quote! {
                    #dl * #right + #dr * #left
                }
            }
        }
        // Differentiate subtraction
        BinOp::Sub(_) | BinOp::SubAssign(_) => {
            quote! {
                #dl - #dr
            }
        }
        _ => panic!("Unsupported operation!"),
    }
}