LinAlg/Vector.py at main · connormurphy798/LinAlg · 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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
import math
import Utils

class Vector:
    """
    A 1d array of numbers.

        n = size of vector
        elems = list of n elements
    """

    def __init__(self, size, lst=None):
        if lst:
            if size != len(lst):
                raise ValueError("Vector length does not match number of elements.")

        self.n = size
        if lst:
            self.elems = [(round(x) if Utils.is_integer(x) else x) for x in lst]
        else:
            self.elems = [0] * size


    def __add__(self, v):
        if not isinstance(v, Vector):
            raise TypeError("Can only add vectors to vectors.")

        if self.n != v.n:
            raise ValueError("Can only add vectors of same size.")

        u = []
        for i in range(self.n):
            u.append(self.elems[i] + v.elems[i])
        return Vector(self.n, u)


    def __sub__(self, v):
        if not isinstance(v, Vector):
            raise TypeError("Can only subtract vectors from vectors.")

        if self.n != v.n:
            raise ValueError("Can only subtract vectors of same size.")

        u = []
        for i in range(self.n):
            u.append(self.elems[i] - v.elems[i])
        return Vector(self.n, u)


    def __eq__(self, v):
        if not isinstance(v, Vector):
            return False

        if self.n != v.n:
            return False
        for i in range(self.n):
            if self.elems[i] != v.elems[i]:
                return False
        return True


    def __ne__(self, v):
        return not (self==v)


    def __str__(self):
        s = str(self.elems)
        return s


    def times(self, k):
        """
        returns a vector times the scalar k
        """
        if type(k) != int and type(k) != float:
            raise TypeError("Can only multiply vectors by scalars.")

        u = []
        for i in range(self.n):
            u.append(self.elems[i] * k)
        return Vector(self.n, u)


    def dot(self, v):
        """
        returns the inner product of two vectors
        """
        if self.n != v.n:
            raise ValueError("Can only take dot product of vectors of same size.")

        d = 0
        for i in range(self.n):
            d += self.elems[i]*v.elems[i]
        return d


    def mag(self):
        """
        returns the magnitude of a vector
        """
        w = 0
        for i in range(self.n):
            w += (self.elems[i])*(self.elems[i])
        w = math.sqrt(w)
        return w


    def at(self, i):
        """
        returns the ith entry of a vector
        """
        if i >= self.n:
            raise IndexError(f"index out of range")
        return self.elems[i]


    def copy(self):
        """
        returns a deep copy of a vector
        """
        return Vector(self.n, self.elems)


def normalize(v):
    """
    returns a vector v scaled to a magnitude of 1
    """
    return v.times(1/v.mag())


if __name__ == "__main__":
    # deep versus shallow copy testing
    v11 = Vector(2, [1, 2])
    v12 = Vector(2, [1, 2])
    v13 = v11
    v14 = v11.copy()
    print(id(v11) == id(v12))
    print(id(v11) == id(v13))
    print(id(v11) == id(v14))
    print()
    print(id(v11.elems) == id(v12.elems))
    print(id(v11.elems) == id(v13.elems))
    print(id(v11.elems) == id(v14.elems))