aegir 2.0.0

Strongly-typed, reverse-mode autodiff library in Rust
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

//! Module for concrete operator implementations.
macro_rules! impl_unary {
    ($(#[$attr:meta])* $name:ident<$F:ident: $field_type:path>, |$x:ident| $f:block, |$self:ident| $e:block) => {
        $(#[$attr])*
        #[derive(Clone, Copy, Debug, PartialEq, Contains)]
        pub struct $name<N>(#[op] pub N);

        impl<N: crate::Node> crate::Node for $name<N> {}

        impl<C, N, $F> crate::Function<C> for $name<N>
        where
            C: crate::Context,
            N: crate::Function<C>,
            $F: crate::buffers::Scalar + $field_type,

            N::Value: crate::buffers::Buffer<Field = $F>,
        {
            type Error = N::Error;
            type Value = N::Value;

            fn evaluate<CR: AsRef<C>>(&self, ctx: CR) -> Result<Self::Value, Self::Error> {
                use crate::buffers::Buffer;

                self.0.evaluate(ctx).map(|mut buf| { buf.mutate(|$x| $f); buf })
            }

            fn evaluate_spec<CR: AsRef<C>>(&self, ctx: CR) -> Result<crate::buffers::Spec<Self::Value>, Self::Error> {
                use crate::buffers::{Buffer, Spec::*};

                Ok(match self.0.evaluate_spec(ctx)? {
                    Full(sh, $x) => Full(sh, $f),
                    spec => Raw({
                        let mut buf = spec.unwrap();

                        buf.mutate(|$x| $f);

                        buf
                    }),
                })
            }

            fn evaluate_shape<CR: AsRef<C>>(&self, ctx: CR) -> Result<crate::buffers::shapes::ShapeOf<Self::Value>, Self::Error> {
                self.0.evaluate_shape(ctx)
            }
        }

        impl<N: crate::fmt::ToExpr> crate::fmt::ToExpr for $name<N> {
            fn to_expr(&$self) -> crate::fmt::Expr { $e }
        }

        impl<N: crate::fmt::ToExpr> std::fmt::Display for $name<N> {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                use crate::fmt::ToExpr;

                self.to_expr().fmt(f)
            }
        }
    };
}

mod arithmetic;
pub use self::arithmetic::*;

mod linalg;
pub use self::linalg::*;

mod logarithmic;
pub use self::logarithmic::*;

mod sigmoid;
pub use self::sigmoid::*;

pub mod trig;
pub mod special;