
class Vector: 
    def __init__(self, x = 0.0, y = 0.0): 
        self.x = x
        self.y = y 
    
    def __str__(self): 
        return "[{}, {}]".format(str(self.x), str(self.y))


a = Vector(2, 4)


print(a)


b = Vector(5, 2)
print(b)


def add(self, b): 
    c = Vector() 
    c.x = self.x + b.x 
    c.y = self.y + b.y 
    return c



Vector.add = add


c = a.add(b)
print(c)


def mul(self, s): 
    return Vector(s * self.x, s * self.y)

Vector.mul = mul


d = a.mul(2)
print(d)


def sub(self, b): 
    # We use the definition of vector subtraction 
    #   instead of defining something new 
    
    return self.add(  b.mul(-1)  )


Vector.sub = sub


d_min_b = d.sub(b)
print(d_min_b)


# TODO: define dot products and cross products


class Matrix: 
 
    def __init__(self, dims, fill):    
        self.rows = dims[0]  
        self.cols = dims[1]   
        
        self.A = [
            [fill] * self.cols             # for each row, this many columns 
            for i in range(self.rows)      # create this many rows 
        ]


m = Matrix((3, 4), 2.0)


print(m)

<__main__.Matrix object at 0x10332cf40>


def __str__(self):     
    rows = len(self.A) # Get the first dimension 
    ret = ''     
    
    for i in range(rows):
        cols = len(self.A[i]) 
        
        for j in range(cols): 
            ret += str(self.A[i][j]) + "\t"
        ret += "\n"

    return ret


Matrix.__str__ = __str__


print(m)

2.0	2.0	2.0	2.0	
2.0	2.0	2.0	2.0	
2.0	2.0	2.0	2.0


# This implementation of __str__ is not a good idea. Can you think of a reason why?


%time n = Matrix((100, 100), 0.0)

CPU times: user 83 µs, sys: 31 µs, total: 114 µs
Wall time: 119 µs


from sys import getsizeof
print(getsizeof(m))
print(getsizeof(n))

48
48


!pip install pympler  # to get actual size


from pympler.asizeof import asizeof


asizeof(m), asizeof(n)

(760, 86880)


dim = 5000


%time  m = Matrix((dim, dim), 0.0)

CPU times: user 133 ms, sys: 33.1 ms, total: 166 ms
Wall time: 167 ms


size = asizeof(m) / (1024 * 1024)

print("{:.2f} MBs".format(size))

191.04 MBs


# recall that we can get values from our matrix using indices 
def get(self, i, j): 
    
    # Error checking 
    if i < 0 or i > self.rows: 
        raise ValueError("Row index out of range.")
    if j < 0 or j > self.cols: 
        raise ValueError("Column index out of range.")
    
    # Value return
    return self.A[i][j]

Matrix.get = get


m.get(1, 2)


m.get(15, 0)


m.get(1, 10)


class Matrix: 
 
    def __init__(self, dims):    
        self.rows = dims[0]  
        self.cols = dims[1]   
        self.vals = {} 
        
        # Let's assume for a minute that fill is 0 
        
    # obviously need a new __str__ here ....


def set(self, i, j, val): 
    self.vals[   (i, j)    ] = val 


Matrix.set = set


# sparse implementation of get 
def get(self, i, j): 
    
    # Error checking 
    if i < 0 or i > self.rows: 
        raise ValueError("Row index out of range.")
    if j < 0 or j > self.cols: 
        raise ValueError("Column index out of range.")
    
    
    # value return 
    if (i, j) in self.vals: 
        return self.vals[  (i, j)  ]
    
    return 0.0
    
Matrix.get = get


m = Matrix((5, 5))


print(m.vals)

{}


m.get(1, 1)

0.0


m.get(10, 2)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-31-eed0eedf0876> in <module>
----> 1 m.get(10, 2)

<ipython-input-27-89faeb05289c> in get(self, i, j)
      4     # Error checking
      5     if i < 0 or i > self.rows:
----> 6         raise ValueError("Row index out of range.")
      7     if j < 0 or j > self.cols:
      8         raise ValueError("Column index out of range.")

ValueError: Row index out of range.


m.set(1, 2, 15.0)


m.get(1, 2)

15.0


m.vals

{(1, 2): 15.0}


m.set(1, 4, 29.9)


m.get(1, 4)

29.9


dim = 500 # 5_000_0000_000
m = Matrix((dim, dim))


asizeof(m)

416


# TODO: create addition, subtraction and matrix multiplication methods

Vector/Matrix Definition and Usage¶

Vector Representation¶

Matrix Representation (Dense)¶

Memory Usage¶

Matrix Representation (Sparse)¶