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
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

/*
    Appellation: unary <mod>
    Contrib: FL03 <jo3mccain@icloud.com>
*/
use crate::handle::handle_expr;
use proc_macro2::TokenStream;
use quote::quote;
use std::str::FromStr;
use syn::parse::{Parse, ParseStream, Result as ParseResult};
use syn::{Expr, Ident};

/// Additional unary methods that may be handled
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[non_exhaustive]
pub enum UnaryOp {
    Abs,
    Cos,
    Cosh,
    Cubed,
    CubeRoot,
    Exp,
    Inverse,
    Ln,
    Recip,
    Sin,
    Sinh,
    Square,
    Sqrt,
    Tan,
    Tanh,
}

impl UnaryOp {
    pub fn grad(&self, recv: &Expr, wrt: &Ident) -> TokenStream {
        let grad = handle_expr(recv, wrt);

        let ds = match *self {
            UnaryOp::Abs => quote! { #recv / #recv.abs() },
            UnaryOp::Cos => quote! { -#recv.sin() },
            UnaryOp::Cosh => quote! { #recv.sinh() },
            UnaryOp::Cubed => quote! { 3.0 * #recv.powi(2) },
            UnaryOp::CubeRoot => quote! { #recv.powi(-2) / 3.0 },
            UnaryOp::Exp => {
                quote! {
                    if #recv.is_sign_negative() {
                        -#recv.exp()
                    } else {
                        #recv.exp()
                    }
                }
            }
            UnaryOp::Inverse | UnaryOp::Recip => quote! { -#recv.powi(-2) },
            UnaryOp::Ln => quote! { #recv.recip() },
            UnaryOp::Sin => quote! { #recv.cos() },
            UnaryOp::Sinh => quote! { #recv.cosh() },
            UnaryOp::Square => quote! { 2.0 * #recv },
            UnaryOp::Sqrt => quote! { (2.0 * #recv.sqrt()).recip() },
            UnaryOp::Tan => quote! { #recv.cos().powi(2).recip() },
            UnaryOp::Tanh => quote! { #recv.cosh().powi(2).recip() },
        };
        quote! { #ds * #grad }
    }
}

impl FromStr for UnaryOp {
    type Err = Box<dyn std::error::Error>;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "abs" => Ok(UnaryOp::Abs),
            "cos" | "cosine" => Ok(UnaryOp::Cos),
            "cosh" => Ok(UnaryOp::Cosh),
            "cubed" => Ok(UnaryOp::Cubed),
            "cbr" | "cube_root" => Ok(UnaryOp::CubeRoot),
            "exp" => Ok(UnaryOp::Exp),
            "inv" | "inverse" => Ok(UnaryOp::Inverse),
            "ln" => Ok(UnaryOp::Ln),
            "recip" => Ok(UnaryOp::Recip),
            "sin" | "sine" => Ok(UnaryOp::Sin),
            "sinh" => Ok(UnaryOp::Sinh),
            "sqr" | "square" => Ok(UnaryOp::Square),
            "sqrt" | "square_root" => Ok(UnaryOp::Sqrt),
            "tan" | "tangent" => Ok(UnaryOp::Tan),
            "tanh" => Ok(UnaryOp::Tanh),
            _ => Err("Method not found".into()),
        }
    }
}

impl Parse for UnaryOp {
    fn parse(input: ParseStream) -> ParseResult<Self> {
        if input.peek(syn::Token![.]) && input.peek2(syn::Ident) {
            let method = input.parse::<syn::Ident>()?;
            if let Ok(method) = UnaryOp::from_str(method.to_string().as_str()) {
                return Ok(method);
            }
        }
        Err(input.error("Expected a method call"))
    }
}