-
Notifications
You must be signed in to change notification settings - Fork 2
/
SparseVector.py
73 lines (63 loc) · 2.94 KB
/
SparseVector.py
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
import numpy as np
class SparseVector(dict):
"""
A class implementing a sparse vector as a dictionary.
A sparse vector is a vector that contains only a few non-zero values.
Each non-zero value is associated with a feature (e.g., "age", "height", "weight").
The sparse vector is represented as a dictionary with features as keys and the
coordinates of the vector as values. If a label is not present in the dictionary,
it is assumed that the corresponding value of the vector is zero.
"""
def safeAccess(self,key):
""" If key is in the dictionary x, return x[key]; otherwise return 0.0
"""
if key in self:
return self[key]
else:
return 0.0
def dot(self,other):
""" Return the inner product between two sparse vectors represented as dictionaries. That is, given
sparse vectors x,y, x.dot(y) returns the scalar
<x,y>
"""
return sum( [self[key]*other[key] for key in self if key in other])
def MatMul(self, Mat):
"""Return the matrix vector product between self and a given matrix "Mat" (a dictionary) as a SparseVector."""
vecMatMul = {}
for (row, col) in Mat:
if col in self:
try:
vecMatMul[row] += self[col] * Mat[(row, col)]
except KeyError:
vecMatMul[row] = self[col] * Mat[(row, col)]
return SparseVector( vecMatMul)
def __add__(self,other):
""" Add two sparse vectors represented as dictionaries. That is, given sparse vectors x and y,
return the sparse vector representing:
x + y
"""
l = [ (key,self[key]+other[key]) for key in self if key in other ]
l += [ (key,self[key]) for key in self if key not in other ]
l += [ (key,other[key]) for key in other if key not in self ]
return SparseVector(l)
def __sub__(self,other):
""" Subtract two sparse vectors represented as dictionaries. That is, given sparse vectors x and y,
return the sparse vector representing:
x - y
"""
l = [ (key,self[key]-other[key]) for key in self if key in other ]
l += [ (key,self[key]) for key in self if key not in other ]
l += [ (key,-other[key]) for key in other if key not in self ]
return SparseVector(l)
def __mul__(self,s):
""" Multiply a sparse vector x with a scalar. That is
x * s
will return a sparse vector containing x's coordinates multiplied by s
"""
return SparseVector( [ (key,s*self[key]) for key in self] )
def __rmul__(self,s):
""" Multiply a sparse vector x with a scalar from the right. That is
s * x
will return a sparse vector containint x'y coordinates multiplied by s
"""
return self * s