tensorflux 0.8.2

The package provides an interface to TensorFlow.
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
120
121
122
123
124

macro_rules! deref {
    ($kind:ident::$field:ident<T>) => (
        impl<T> ::std::ops::Deref for $kind<T> {
            type Target = [T];

            #[inline]
            fn deref(&self) -> &[T] {
                &self.$field
            }
        }

        impl<T> ::std::ops::DerefMut for $kind<T> {
            #[inline]
            fn deref_mut(&mut self) -> &mut [T] {
                &mut self.$field
            }
        }
    );
    ($kind:ident::$field:ident<$element:ident>) => (
        impl ::std::ops::Deref for $kind {
            type Target = [$element];

            #[inline]
            fn deref(&self) -> &[$element] {
                &self.$field
            }
        }

        impl ::std::ops::DerefMut for $kind {
            #[inline]
            fn deref_mut(&mut self) -> &mut [$element] {
                &mut self.$field
            }
        }
    );
}

macro_rules! ffi(
    ($function:ident($($argument:expr),*)) => (unsafe { ::ffi::$function($($argument),*) });
);

macro_rules! into_cstring(
    ($string:expr) => (unsafe { ::std::ffi::CString::from_vec_unchecked($string.into().into()) });
);

macro_rules! memory {
    ($kind:ident<T>) => (
        deref!($kind::memory<T>);

        impl<T> ::std::convert::AsRef<[T]> for $kind<T> {
            #[inline]
            fn as_ref(&self) -> &[T] {
                &self.memory
            }
        }

        impl<T> Into<Vec<T>> for $kind<T> where T: Clone {
            #[inline]
            fn into(mut self) -> Vec<T> {
                self.memory.empty()
            }
        }
    );
    ($kind:ident<$element:ident>) => (
        deref!($kind::memory<$element>);

        impl ::std::convert::AsRef<[$element]> for $kind {
            #[inline]
            fn as_ref(&self) -> &[$element] {
                &self.memory
            }
        }

        impl Into<Vec<$element>> for $kind {
            #[inline]
            fn into(mut self) -> Vec<$element> {
                self.memory.empty()
            }
        }
    );
}

macro_rules! nonnull(
    ($pointer:expr, $status:expr) => ({
        let pointer = $pointer;
        if pointer.is_null() {
            success!($status);
            raise!("failed to call TensorFlow");
        }
        pointer
    });
    ($pointer:expr) => ({
        let pointer = $pointer;
        if pointer.is_null() {
            raise!("failed to call TensorFlow");
        }
        pointer
    });
);

macro_rules! ok(
    ($operation:expr, $status:expr) => ({
        let result = $operation;
        success!($status);
        result
    });
    ($result:expr) => (match $result {
        Ok(result) => result,
        Err(error) => raise!(error.to_string()),
    });
);

macro_rules! raise(
    ($template:expr, $($argument:tt)*) => (raise!(format!($template, $($argument)*)));
    ($message:expr) => (return Err(::error::Error::from($message)));
);

macro_rules! success(
    ($status:expr) => (
        if let Some(error) = ::error::Error::from_status($status) {
            return Err(error);
        }
    );
);