deep_quad/vectorify.py at master · cgel/deep_quad · GitHub

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
125
126
127
128
129
130
import numpy as np
import pickle
import numbers


class Vectorify:

    def __init__(self, vec):
        if isinstance(vec, Vectorify):
            self.data = [x.copy() for x in vec.data]
        elif isinstance(vec, list):
            self.data = vec
        elif isinstance(vec, str):
            self.data = pickle.load(open( vec, "rb" ))
        elif not isinstance(vec, list):
            self.data = [vec]

        self.size = 0
        for v in self.data:
            if isinstance(v, numbers.Number):
                self.size += 1
            else:
                self.size += v.size

    def compatible(self, vec):
        assert isinstance(vec, Vectorify)
        if len(self.data) != len(vec.data):
            return False
        for v1, v2 in zip(self.data, vec.data):
            if v1.size != v2.size:
                return False
        return True

    def __add__(self, a):
        if isinstance(a, list):
            a=Vectorify(a)
        # scalar product
        if isinstance(a, numbers.Number):
            res=list(map(lambda x: np.add(x, a), self.data))
        # elementwise product
        elif isinstance(a, Vectorify):
            assert self.compatible(a)
            res = list(map(np.add, self.data, a.data))
        else:
            raise Exception("Cannot add Vectorify and %s" % (type(a)))
        return Vectorify(res)

    def __radd__(self, a):
        return self + a

    def __mul__(self, a):
        if isinstance(a, list):
            a = Vectorify(a)
        # scalar product
        if isinstance(a, int) or isinstance(a, float):
            res = list(map(lambda x: np.multiply(x, a), self.data))
        # elementwise product
        elif isinstance(a, Vectorify):
            assert self.compatible(a)
            res=list(map(np.multiply, self.data, a.data))
        else:
            raise Exception("Cannot multiply Vectorify and %s" % (type(a)))
        return Vectorify(res)

    def __sub__(self, a):
        if isinstance(a, list):
            a=Vectorify(a)
        # scalar product
        if isinstance(a, int) or isinstance(a, float):
            res=list(map(lambda x: np.subtract(x, a), self.data))
        # elementwise product
        elif isinstance(a, Vectorify):
            assert self.compatible(a)
            res=list(map(np.subtract, self.data, a.data))
        else:
            raise Exception("Cannot subtract Vectorify and %s" % (type(a)))
        return Vectorify(res)

    def __truediv__(self, a):
        if isinstance(a, list):
            a=Vectorify(a)
        # scalar product
        if isinstance(a, int) or isinstance(a, float):
            res=list(map(lambda x: np.divide(x, a), self.data))
        # elementwise product
        elif isinstance(a, Vectorify):
            assert self.compatible(a)
            res=list(map(np.divide, self.data, a.data))
        else:
            raise Exception("Cannot divide Vectorify and %s" % (type(a)))
        return Vectorify(res)

    def dot(self, a):
        if isinstance(a, list):
            a=Vectorify(a)
        assert self.compatible(a)
        prod=self * a
        return sum(list(map(np.sum, prod)))

    def norm(self):
        return sum(list(map(np.sum, (self*self).data)))**0.5

    def assign(self, a):
        if isinstance(a, list):
            a=Vectorify(a)
        if isinstance(a, int) or isinstance(a, float):
            for x in self.data:
                x[:] = a
        # elementwise product
        elif isinstance(a, Vectorify):
            assert self.compatible(a)
            for x,y in zip(self.data, a.data):
                x[:] = y
        else:
            raise Exception("Cannot assign %s to Vectorify" % (type(a)))

    def copy(self):
        return Vectorify([x.copy() for x in self.data])

    def __getitem__(self, i):
        return self.data[i]

    def save(self, filename):
        pickle.dump(self.data, open(filename, "wb") )

    def __str__(self):
        if len(self.data) == 1:
            return self.data[0].__str__()
        else:
            return self.data.__str__()