rustlearn 0.4.3

A machine learning package for 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
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

import os

import subprocess

import numpy as np


def serialize_array(arr):

    template = 'Array::from(&{})'

    if len(arr.shape) == 1:
        return template.format(str([[x] for x in arr]).replace('[', 'vec!['))
    else:
        return template.format(str(arr).replace('[', 'vec!['))


class Module(object):

    TEMPLATE = """

#[cfg(test)]
#[allow(unused_imports)]
{flags}
mod generated_tests {{
    {imports}

    {tests}

}}

"""

    def __init__(self, imports=None, flags=None):

        self.imports = (imports or []) + ['prelude::*',
                                          'super::*']
        self.flags = flags or []

        self.tests = []

    def add_test(self, test):

        self.tests.append(test)

    def render_flags(self):

        return '\n'.join(self.flags)

    def render_imports(self):

        return '\n'.join(['use ' + x  + ';' for x in self.imports])

    def render(self):

        return self.TEMPLATE.format(flags=self.render_flags(),
                                    imports=self.render_imports(),
                                    tests='\n'.join([x.render() for x
                                                     in self.tests]))

    def write(self, fname):

        with open(fname, 'wb') as datafile:
            datafile.write(self.render())

        subprocess.check_call(['rustfmt',
                               fname,
                               '--write-mode=overwrite'])


class Test(object):

    TEMPLATE = """
               #[test]
               fn {name}() {{
                   // Body goes here
               }}

    """

    SERIALIZERS = {np.ndarray: serialize_array}

    def __init__(self, name, args):

        self.name = name
        self.args = args

    def _render_args(self):

        rendered = {}

        for key, value in self.args.items():
            for tpe, fnc in self.SERIALIZERS.items():
                if isinstance(value, tpe):
                    rendered[key] = fnc(value)
                else:
                    rendered[key] = str(value)

        return rendered

    def render(self):

        args = self._render_args()
        args['name'] = self.name

        return self.TEMPLATE.format(**args)