def rmul(self, vec):
     '''
     Returns a vector that is the product of 'vec' (taken as a row vector) and this matrix using the * operator
     If the two are incompatible return None
     Return vec*self
     '''
     # Your Code
     new_list = []
     list_of_vectors = []
     prod = []
     if(len(self) <> len(vec)):
         return None
     else:
         lst = []
         for i in range(len(self)):
             for j in range(len(self[0])):
                 lst.append(self[j][i])
             new_list.append(lst)
             lst = []
         for lists in new_list:
             vect = make_vector(lists ,zero_test = lambda x : (x == 0))
             list_of_vectors.append(vect)
         new_matrix = make_matrix(list_of_vectors)
         for i in range(len(new_matrix)):
             prod.append(new_matrix[i]*vec)
         final_vector = make_vector(prod , zero_test = lambda x : (x == 0))
         return final_vector
 def get_quarters(self):
     '''
     Get all 4 quarters of the matrix - get the left-right split
     Then split each part into top and bottom
     Return the 4 parts - topleft, topright, bottomleft, bottomright - in that order
     '''
     # Your Code
     ele = [[],[],[],[]]
     for i in range(len(self)/2):
         ls = []
         for j in range(0, int(float(len(self))/2.0 + 0.5)):
             ls.append(self[i][j])
         ele[0].append( make_vector(ls) )
         ls = []
         for j in range(int(len(self)/2), len(self[i])):
             ls.append(self[i][j])
         ele[1].append( make_vector(ls) )
         ls = []
         for j in range(0, int(float(len(self))/2.0 + 0.5)):
             ls.append(self[len(self)/2 + i][j])
         ele[2].append( make_vector(ls) )
         ls = []
         for j in range(int(len(self)/2), len(self[i])):
             ls.append(self[len(self)/2 + i][j])
         ele[3].append( make_vector(ls) )
         ls = []
         
     #return make_matrix(ele[0]), make_matrix(ele[1]), make_matrix(ele[2]), make_matrix(ele[3])
     return Matrix(ele[0]), Matrix(ele[1]), Matrix(ele[2]), Matrix(ele[3])
 def get_quarters(self):
     '''
     Get all 4 quarters of the matrix - get the left-right split
     Then split each part into top and bottom
     Return the 4 parts - topleft, topright, bottomleft, bottomright - in that order
     '''
     # Your Code
     left_matrix , right_matrix = self.left_right_split()
     topleft = []
     topright = []
     bottomleft = []
     bottomright = []      
     mid = len(left_matrix) / 2
     for i in range(0 , mid):
         topleft.append(make_vector((left_matrix[i]) , lambda x : (x == 0)))
     for i in range(mid , len(left_matrix)):
         bottomleft.append(make_vector((left_matrix[i]) , lambda x : (x == 0)))
         
     mid = len(right_matrix) / 2
     for i in range(0 , mid):
         topright.append(make_vector((right_matrix[i]) , lambda x : (x == 0)))
     for i in range(mid , len(left_matrix)):
         bottomright.append(make_vector((right_matrix[i]) , lambda x : (x == 0)))
         
     return make_matrix(topleft) , make_matrix(topright) , make_matrix(bottomleft) , make_matrix(bottomright)
 def __getitem__(self, key):
     '''
     Overriding the default __getitem__ method with behavior specific to sparse matrices
     '''
     # Your Code
     
     if isinstance(key, int):
         if key >= len(self):
             return None
         
         if len(self.indices) == 0 or len(self.vectors) == 0:                
             return make_vector([0] * self.ncols, lambda x: x == 0)
         
         idx = bisect_left(self.indices, key)
         
         return (make_vector([0] * self.ncols)               
                 if (idx == len(self.indices) or self.indices[idx] != key)
                     else self.vectors[idx])
         
     else:
         if key[0] >= len(self):
             return None
         
         idx = bisect_left(self.indices, key[0])
         
         return (0 if (idx == len(self.vectors)
                       or self.indices[idx] != key[0])
                 else self.vectors[idx][key[1]]) 
 def pad(self):
     '''
     padding to incomplete matrix
     '''
     
     l_rows = len(self)
     l_cols = len(self.rows[0])
     
     i = 1
     while(i<l_rows):
         i *= 2
        
     j = 1
     while(j<l_cols):
         j *= 2
             
     order = max(i,j)
     
     if((order - l_cols ) != 0):
         col = make_vector(([0] * (order - l_cols )), zero_test) 
         cols = []
         for i in range(l_rows):
             cols.append(col)
          
         colms = make_matrix(cols)
         self.merge_cols(colms)
     
     if((order - l_rows) != 0):        
         row = make_vector(([0] * order ),zero_test)
         rws = []
         for i in range((order - l_rows)):
             rws.append(row)
             
         rws1 = make_matrix(rws)
         self.merge_rows(rws1)
 def get_quarters(self):
     '''
     Get all 4 quarters of the matrix - get the left-right split
     Then split each part into top and bottommake_vector
     Return the 4 parts - topleft, topright, bottomleft, bottomright - in that order
     '''
     # Your Code
     topleft = []
     topright = []
     bottomleft = []
     bottomright = []
     left, right = self.left_right_split()
     for rowno in range(0, len(self)/2):
         if rowno in left.indices:
             topleft.append(left[rowno])
         else:
             topleft.append(make_vector([0]*(self.ncols/2) , lambda x : (x == 0)))
         if rowno in right.indices:
             topright.append(right[rowno])
         else:
             topright.append(make_vector([0]*(self.ncols - self.ncols/2), lambda x : (x == 0)))
     for rowno in range(len(self)/2, len(self)):
         if rowno in left.indices:
             bottomleft.append(left[rowno])
         else:
             bottomleft.append(make_vector([0]* (self.ncols/2), lambda x : (x == 0)))
         if rowno in right.indices:
             bottomright.append(right[rowno])
         else:
             bottomright.append(make_vector([0]*(self.ncols - self.ncols/2), lambda x : (x == 0)))
     return make_matrix(topleft), make_matrix(topright), make_matrix(bottomleft), make_matrix(bottomright)
 def form_pad(self):
     org_row_length = len(self[0])
     org_col_length = len(self)
     
     num_row = self.is_valid(len(self[0]))
     num_col = self.is_valid(len(self))
     num = num_row if (num_row > num_col) else num_col
     
     if(num != 0):
         for i in range(len(self)):
             temp_list = []
             for j in range(len(self[i])):
                 temp_list.append(self[i][j])
             
             if not is_long_and_sparse(temp_list):
                 self[i].merge(make_vector([0] * (num - org_row_length)))
             else:
                 self[i].length = self[i].length + (num - org_row_length)
                 
     temp = num - org_col_length
     ls = []
     while(temp > 0):
         ls.append(make_vector([0]*(len(self[0]))))
         temp -= 1
             
     self = self.merge_rows(ls)
     
     return self, num - org_row_length, num - org_col_length
Ejemplo n.º 8
0
    def get_quarters(self):
        '''
        Get all 4 quarters of the matrix - get the left-right split
        Then split each part into top and bottom
        Return the 4 parts - topleft, topright, bottomleft, bottomright - in that order
        '''
        left_matrix, right_matrix = self.left_right_split()

        topleft = []
        topright = []
        bottomleft = []
        bottomright = []

        mid = len(left_matrix) / 2
        for i in range(0, mid):
            topleft.append(make_vector((left_matrix[i]), lambda x: (x == 0)))
        for i in range(mid, len(left_matrix)):
            bottomleft.append(make_vector((left_matrix[i]), lambda x:
                                          (x == 0)))

        mid = len(right_matrix) / 2
        for i in range(0, mid):
            topright.append(make_vector((right_matrix[i]), lambda x: (x == 0)))
        for i in range(mid, len(left_matrix)):
            bottomright.append(
                make_vector((right_matrix[i]), lambda x: (x == 0)))

        return make_matrix(topleft), make_matrix(topright), make_matrix(
            bottomleft), make_matrix(bottomright)
 def pad(self, add_temp):
     zero_add = [0]*(add_temp - self.ncols)
     zero_vec = make_vector(zero_add,lambda x:x==0)
     zero_mat = [0]*add_temp
     mat_vec = make_vector(zero_mat,lambda x:x==0)
     for i in range(0,len(self)):
         self[i].merge(zero_vec)
     for i in range(add_temp - self.nrows):
         self.vectors.append(mat_vec)
 def __getitem__(self, key, ):
     '''
     Overriding the default __getitem__ method with behavior specific to sparse matrices
     '''
     # Your Code
     if key in self.indices:
         return self.vectors[self.indices.index(key)]
     elif self.vectors != []:
         return make_vector([0]*len(self.vectors[0]))
     else:
         return make_vector([0]*len(self))
 def __add__(self, mat):
     '''
     Return the sum of this matrix with 'mat' - (allows use of + operator between matrices)
     Return None if the number of rows do not match
     '''
     if len(self) != len(mat):
         return None
     s_matrix = []
     for i in range(len(self)):
         s_matrix.append(make_vector(self[i], zero_test = lambda x : (x == 0))+make_vector(mat[i],zero_test = lambda x : (x == 0) ))
     sum_mat = make_matrix(s_matrix)
     return sum_mat
 def __sub__(self, mat):
     '''
     Return the difference between this matrix and 'mat' - (allows use of - operator between matrices)
     Return None if the number of rows do not match
     '''
     if len(self) != len(mat):
         return None
     sub_mat = []
     for i in range(len(self)):
         sub_mat.append(make_vector(self[i],zero_test = lambda x : (x == 0)) - make_vector(mat[i], zero_test = lambda x : (x == 0)))
     sub_matrix = make_matrix(sub_mat)
     return sub_matrix
 def __rmul__(self, vec):
     '''
     Returns a vector that is the product of 'vec' (taken as a row vector) and this matrix using the * operator
     If the two are incompatible return None
     Return vec*self
     '''
     if(len(vec) == self.nrows):
         transposed_matrix = make_matrix([make_vector(list(column), vec.zero_test) 
                              for column in itertools.izip(*self.components())])
         return make_vector([(vec * row) for row in transposed_matrix.components()], vec.zero_test)
     else:
         return None
Ejemplo n.º 14
0
    def __sub__(self, mat):
        '''
        Return the difference between this matrix and 'mat' - (allows use of - operator between matrices)
        Return None if the number of rows do not match
        '''
        matrix_diff = []
        if len(self) != len(mat):
            return None

        for i in range(0, len(self)):
            v1 = make_vector(self[i], lambda x: (x == 0))
            v2 = make_vector(mat[i], lambda x: (x == 0))
            matrix_diff.append(v1 - v2)

        return make_matrix(matrix_diff)
 def __iadd__(self, mat):
     '''
     Implements the += operator with another matrix 'mat'
     Assumes that the elements of the matrices have a + operator defined between them (if they are not numbers)
     Add corresponding elements upto the min of the number of rows in each (in case the matrices
     have different numbers of rows)
     '''
     
     lst_iadd = []
     for i in range(0 , min(len(self) , len(mat))):
         v1 = make_vector(self[i] , lambda x : (x == 0))
         v2 = make_vector(mat[i] , lambda x : (x == 0))
         v1 += v2
         lst_iadd.append(v1)
     
     return make_matrix(lst_iadd)
def make_matrix(vector_list):
    '''
    Make a matrix out of a list of vectors 'vector_list'
    Just like make_vector in the vector module, this decides whether to instantiate the FullMatrix or SparseMatrix class
    by using the is_zero method of the Vector class
    '''
    # Your Code
    
    matrix_vec_val = []
    sparse_val = []
    sparse_ind = []

    for idx , i in enumerate(vector_list):
        matrix_val = []
        for j in range(0 , len(i)):
            columns = len(i)
            matrix_val.append(i[j])
        
        if(i.is_zero() == False):
            
            sparse_val.append(i)
            sparse_ind.append(idx)
        
        matrix_vec_val.append(make_vector(matrix_val , lambda x : (x == 0)))
            
    if float(len(sparse_val))/float(len(vector_list)) < DENSITY_THRESHOLD and float(len(vector_list) * columns) > SIZE_THRESHOLD:
        obj = SparseMatrix(sparse_val , sparse_ind , len(vector_list),columns)
    else :
        obj = FullMatrix(matrix_vec_val)
         
    return obj
 def __mul__(self, mat):
     '''
     Multiplication of two matrices using Strassen's algorithm
     If either this matrix or mat is a 'small' matrix then do regular multiplication
     Else use recursive Strassen's algorithm
     '''
     matrix = []
     if (self.is_small() or mat.is_small == True):
         for i in range(len(self)):
             rows = []
             for j in range(len(mat[0])):
                 val = 0
                 for k in range(len(mat[0])):
                     val += self[i][k] * mat[k][j]
                 rows.append(val)
             matrix.append(make_vector((rows) , zero_test=lambda x : (x == 0)))
         return make_matrix(matrix)
     else:
         topleft , topright , bottomleft , bottomright = self.get_quarters()
         top_left , top_right , bottom_left , bottom_right = mat.get_quarters()
         val1 = topleft * (top_right - bottom_right)
         val2 = (topleft + topright) * bottom_right
         val3 = (bottomleft + bottomright) * top_left
         val4 = bottomright * (bottom_left - top_left)
         val5 = (topleft + bottomright) * (top_left + bottom_right)
         val6 = (topright - bottomright) * (bottom_left + bottom_right)
         val7 = (topleft - bottomleft) * ( top_left + top_right)          
         row1 = val4+val5+val6-val2
         row2 = val1+val2
         row3 = val3+val4
         row4  = val1-val3+val5-val7
         col1 = row1.merge_cols(row2)
         col2 = row3.merge_cols(row4)
         mat = col1.merge_rows(col2)
         return mat
 def pad_row(self):
     '''
     Pad the rows of this matrix to the nearest power of 2 
     '''
     
     pad = 2             
     
     while pad < self.nrows:
         pad = pad << 1
            
     pad -= self.nrows
     
     if var_globals.FLAG_ROW == 0:
         var_globals.FLAG_ROW += 1
         var_globals.ROW_LENGTH = self.nrows
    
     if pad != 0:
         if var_globals.ROW_PAD == 0:
             var_globals.ROW_PAD = pad
         
         pad_vector = [make_vector([0] * self.ncols)
                     for _ in range(pad)]                
         
         new_mat = self.merge_rows(make_matrix(pad_vector))
         t_list = [new_mat[i] for i in range(len(new_mat))]
         
         return make_matrix(t_list)
     
     else:
         return self        
Ejemplo n.º 19
0
    def __isub__(self, mat):
        '''
        Implements the -= operator with another matrix 'mat'
        Assumes that the elements of the matrices have a - operator defined between them (if they are not numbers)
        Subtract corresponding elements upto the min of the number of rows in each (in case the matrices
        have different numbers of rows)
        '''
        lst_isub = []

        for i in range(0, min(len(self), len(mat))):
            v1 = make_vector(self[i], lambda x: (x == 0))
            v2 = make_vector(mat[i], lambda x: (x == 0))
            v1 -= v2
            lst_isub.append(v1)

        return make_matrix(lst_isub)
def make_matrix(vector_list):
    '''
    Make a matrix out of a list of vectors 'vector_list'
    Just like make_vector in the vector module, this decides whether to instantiate the FullMatrix or SparseMatrix class
    by using the is_zero method of the Vector class
    '''
    # Your Code
    count = 0
    matrix = []
    vect_matrix = []
    for vect in vector_list:
        vect_matrix.append(make_vector(vect, zero_test = lambda x : (x == 0)))
    count = 0
    if len(vect_matrix) > 2:
        for vect in vect_matrix:
            
            if vect.is_zero():
                count += 1
        if count/len(vect_matrix) <= DENSITY_THRESHOLD:
            vect_list = []
            indices = []
            for ind in range(len(vect_matrix)):
                if vect_matrix[ind].is_zero() == False:
                    vect_list.append(vect_matrix[ind])
                    indices.append(ind)
            matrix = SparseMatrix(vect_list, indices, len(vect_matrix))
            return matrix
    
    matrix = FullMatrix(vect_matrix)
    return matrix
def make_matrix(vector_list):
    '''
    Make a matrix out of a list of vectors 'vector_list'
    Just like make_vector in the vector module, this decides whether to instantiate the FullMatrix or SparseMatrix class
    by using the is_zero method of the Vector class
    '''
    # Your Code
    matrix2 = []
    count = 0
    for i in range(len(vector_list)):
        ls = []
        for j in range(len(vector_list[i])):
            ls.append( vector_list[i][j] )
        if (isinstance(ls, list)):
               ls = make_vector(ls)
        if(ls.is_zero()):
            count += 1
        matrix2.append(ls) 
    
    if float(count) / float(len(vector_list)) >= DENSITY_THRESHOLD:
        indices = []
        val_vectors = []
        for i in range(len(matrix2)):
            if(matrix2[i].is_zero() == False):
                val_vectors.append(matrix2[i])
                indices.append(i)
        mat = SparseMatrix(val_vectors, indices, len(matrix2))
    else:
        mat = FullMatrix(matrix2)
    
    return mat
Ejemplo n.º 22
0
    def __add__(self, mat):
        '''
        Return the sum of this matrix with 'mat' - (allows use of + operator between matrices)
        Return None if the number of rows do not match
        '''

        matrix_sum = []
        if len(self) != len(mat):
            return None

        for i in range(0, len(self)):
            v1 = make_vector(self[i], lambda x: (x == 0))
            v2 = make_vector(mat[i], lambda x: (x == 0))
            matrix_sum.append(v1 + v2)

        return make_matrix(matrix_sum)
Ejemplo n.º 23
0
def make_matrix(vector_list):
    '''
    Make a matrix out of a list of vectors 'vector_list'
    Just like make_vector in the vector module, this decides whether to instantiate the FullMatrix or SparseMatrix class
    by using the is_zero method of the Vector class
    '''
    matrix_vec_val = []
    sparse_val = []
    sparse_ind = []

    for idx, i in enumerate(vector_list):
        matrix_val = []
        for j in range(0, len(i)):
            columns = len(i)
            matrix_val.append(i[j])

        if (i.is_zero() == False):

            sparse_val.append(i)
            sparse_ind.append(idx)

        matrix_vec_val.append(make_vector(matrix_val, lambda x: (x == 0)))

    if float(len(sparse_val)) / float(
            len(vector_list)) < DENSITY_THRESHOLD and float(
                len(vector_list) * columns) > SIZE_THRESHOLD:
        obj = SparseMatrix(sparse_val, sparse_ind, len(vector_list), columns)
    else:
        obj = FullMatrix(matrix_vec_val)

    return obj
 def pad_col(self):
     '''
     Pad the columns of this matrix to the nearest power of 2
     '''
             
     pad = 2               
     
     while pad < self.ncols:
         pad = pad << 1
          
     pad -= self.ncols
     
     if var_globals.FLAG_COL == 1:
         var_globals.COL_LENGTH = self.ncols
     
     var_globals.FLAG_COL += 1
    
     if pad != 0:
         var_globals.COL_PAD = pad
                   
         pad_vector = [make_vector([0] * pad)
                     for _ in range(self.nrows)]
         
         new_mat = self.merge_cols(make_matrix(pad_vector))
         
         t_list = [new_mat[i] for i in range(len(new_mat))]
         
         return make_matrix(t_list)
     
     else:
         return self
def pad_matrix(vector_list):
    '''
    To pad the matrix
    '''
    nrow_pad = int(pow(2, ceil(log(len(vector_list), 2))))
    ncol_pad = int(pow(2, ceil(log(len(vector_list[0]), 2))))
    zero_append.append(len(vector_list)) 
    zero_append.append(len(vector_list[0])) 
    if nrow_pad == len(vector_list) and ncol_pad == len(vector_list[0]):
        return vector_list
    new_list = [[0]*ncol_pad]*len(vector_list)
    
    for i in range(len(vector_list)):
        for j in range(len(vector_list[0])):
            new_list[i][j] = vector_list[i][j]
    
    i = 0
    while( i < nrow_pad-len(vector_list)):
        new_list.append([0]*len(new_list[0]))
        i += 1
    
    vect_list = []
    for i in new_list:
        vect_list.append(make_vector(i, zero_test = lambda x : (x == 0)))
            
    return vect_list
Ejemplo n.º 26
0
    def merge_rows(self, mat):
        '''
        Return the matrix with rows of mat appended to the rows of this matrix
        '''
        # Your Code

        final_list = []
        for i in range(0, len(self)):
            vec = make_vector(self[i], lambda x: (x == 0))
            final_list.append(vec)

        for i in range(0, len(mat)):
            vec = make_vector(mat[i], lambda x: (x == 0))
            final_list.append(vec)

        return make_matrix(final_list)
 def left_right_split(self):
     '''
     Split the matrix into two halves - left and right - and return the two matrices
     Split each row (use the split method of Vector) and put them together into the
     left and right matrices
     Use the make_matrix method for forming the new matrices
     '''
     # Your Code
     splt_left = []
     splt_right = []
     for lst_vector in len(self):
         splt_left.append(lst_vector.splt(lst_vector))
         splt_right.append(lst_vector.splt(lst_vector))
     mat_left=make_vector(splt_left)
     mat_right=make_vector(splt_right)
     
     return mat_left,mat_right
 def merge_rows(self, mat):
     '''
     Overriding the merge rows method of the parent Matrix class
     '''
     # Your Code
     mat_list = []
     for nrow in range(0, len(self)):
         if nrow in self.indices:
             mat_list.append(self[nrow])
         else:
             mat_list.append(make_vector([0]*self.ncols, lambda x : (x == 0)))
     for nrow in range(0, len(mat)):
         if nrow in mat.indices:
             mat_list.append(mat[nrow])
         else:
             mat_list.append(make_vector([0]*self.ncols, lambda x : (x == 0)))
     return make_matrix(mat_list) 
 def pad(self, add_temp):
     '''
     to add 0's to the matrices to make them 2^n x 2^n matrices
     '''
     zero_mat = []
     temp_mat = []
     for pos in range(add_temp - self.ncols):
         zero_mat.append(0)
     if(add_temp != self.ncols):
         zero_mat_obj = make_vector(zero_mat, zero_test)
         for pos in range(len(self)):
             temp_mat.append(self[pos].merge(zero_mat_obj))
         
     row = [0]*(add_temp)
     for elem in range(add_temp - self.nrows):
         temp_mat.append(make_vector(row, zero_test))
     return make_matrix(temp_mat)
 def __add__(self, mat):
     '''
     Return the sum of this matrix with 'mat' - (allows use of + operator between matrices)
     Return None if the number of rows do not match
     '''
     
 
     matrix_sum = []
     if len(self) != len(mat) :
         return None
     
     for i in range(0 , len(self)):
         v1 = make_vector(self[i] , lambda x : (x == 0))
         v2 = make_vector(mat[i] , lambda x : (x == 0))
         matrix_sum.append(v1 + v2)
     
     return make_matrix(matrix_sum)
 def __sub__(self, mat):
     '''
     Return the difference between this matrix and 'mat' - (allows use of - operator between matrices)
     Return None if the number of rows do not match
     '''
     
     
     matrix_diff = []
     if len(self) != len(mat) :
         return None
     
     for i in range(0 , len(self)):
         v1 = make_vector(self[i] , lambda x : (x == 0))
         v2 = make_vector(mat[i] , lambda x : (x == 0))
         matrix_diff.append(v1 - v2)
     
     return make_matrix(matrix_diff)
 def merge_rows(self, mat):
     '''
     Return the matrix with rows of mat appended to the rows of this matrix
     '''
     # Your Code
     
     final_list = []
     for i in range(0 , len(self)):
         vec = make_vector(self[i]  , lambda x : (x == 0))
         final_list.append(vec)
     
     
     for i in range(0 , len(mat)):
         vec = make_vector(mat[i]  , lambda x : (x == 0))
         final_list.append(vec)
     
     return make_matrix(final_list)
 def __add__(self, mat):
     '''
     Return the sum of this matrix with 'mat' - (allows use of + operator between matrices)
     Return None if the number of rows do not match
     '''
     sum_mat = []
     if len(self) == len(mat):
         for i in range(len(self)):
             if self[i]!= None and mat[i]!= None:
                 vector1 = make_vector(self[i], None)
                 vector2 = make_vector(mat[i], None)
                 vector = (vector1 + vector2) 
                 sum_mat.append(vector.data)
         mat = make_matrix(sum_mat)
         return mat
     
     return None       
    def pad(self, mat):
        '''
        Pad two matrices with zero_vectors as rows and columns to nearest multiple of 2.
        '''
        pow_2 = self.get_pow_2(mat)
        pad_info = [(pow_2 - dim) for dim in [self.nrows, self.ncols, mat.nrows, mat.ncols]]
        
        self = (self.merge_rows(make_matrix([make_vector([0] * self.ncols, self[0].zero_test) 
                for _ in xrange(pad_info[0])])) if(pad_info[0] != 0) else self)
        self = (self.merge_cols(make_matrix([make_vector([0] * pad_info[1]) for _ in xrange(self.nrows)]))
                if(pad_info[1] != 0) else self)

        mat = (mat.merge_rows(make_matrix([make_vector([0] * mat.ncols, mat[0].zero_test) 
                for _ in xrange(pad_info[2])])) if(pad_info[2] != 0) else mat)
        mat = (mat.merge_cols(make_matrix([make_vector([0] * pad_info[3]) for _ in xrange(mat.nrows)]))
               if(pad_info[3] != 0) else mat)

        return self, mat, pad_info
 def rmul(self, vec):
     '''
     Returns a vector that is the product of 'vec' (taken as a row vector) and this matrix using the * operator
     If the two are incompatible return None
     Return vec*self
     '''
     # Your Code
     if len(vec) == len(self):
         vec_list = []
         for cols in range(0, self.ncols):
             vec_element = []
             for rows in range(0, len(self)):
                 vec_element.append(self[rows][cols])
             vector = make_vector(vec_element, lambda x : (x == 0))
             vec_list.append(vec * vector)
         return make_vector(vec_list, lambda x : (x == 0))
     else :
         return None
Ejemplo n.º 36
0
    def merge_rows(self, mat):
        '''
        Overriding the merge rows method of the parent Matrix class
        '''
        if len(self) != len(mat):
            return None

        merged_list = []

        for i in range(0, len(self)):
            vec = make_vector(self[i], lambda x: (x == 0))
            merged_list.append(vec)

        for i in range(0, len(mat)):
            vec = make_vector(mat[i], lambda x: (x == 0))
            merged_list.append(vec)

        return make_matrix(merged_list)
 def __sub__(self,  mat):
     '''
     Return the difference between this matrix and 'mat' - (allows use of - operator between matrices)
     Return None if the number of rows do not match
     '''
    
     sub_mat = []
     if len(self) == len(mat):
         for i in range(len(self)):
             if self[i]!=None and mat[i]!=None:
                 vector1 = make_vector(self[i], None)
                 vector2 = make_vector(mat[i], None)
                 vector = (vector2 - vector1) 
                 sub_mat.append(vector.data)
         mat = make_matrix(sub_mat)
         return mat
     
     return None  
Ejemplo n.º 38
0
def unpadding(self):

    global org_rows, org_column
    unpadded_list = []

    for i in range(0, org_rows):
        lst = []
        for j in range(0, org_column):
            lst.append(self[i][j])
        vec = make_vector(lst, lambda x: (x == 0))
        unpadded_list.append(vec)

    return make_matrix(unpadded_list)
Ejemplo n.º 39
0
def padding(self):

    list_vectors = []
    global org_rows, org_column
    org_rows = len(self)
    org_column = len(self[0])

    pad_zeros_rows = pad_zeros(len(self[0]))
    pad_zeros_column = pad_zeros(len(self))
    dimen = max(
        int(pad_zeros_rows) + len(self[0]),
        int(pad_zeros_column) + len(self))

    for i in range(0, len(self)):
        padded_row = self[i] + [0] * (dimen - len(self[i]))
        vec = make_vector(padded_row, lambda x: (x == 0))
        list_vectors.append(vec)
    lst = [0] * (dimen)

    for i in range(0, (dimen - len(self))):
        vec = make_vector(lst, lambda x: (x == 0))
        list_vectors.append(vec)

    return make_matrix(list_vectors)
Ejemplo n.º 40
0
    def rmul(self, vec):
        '''
        Returns a vector that is the product of 'vec' (taken as a row vector) and this matrix using the * operator
        If the two are incompatible return None
        Return vec*self
        '''

        rmul_vector = []
        for i in range(0, len(self)):
            Sum = 0
            for j in range(0, len(vec)):
                Sum = Sum + vec[j] * self[j][i]
            rmul_vector.append(Sum)

        return make_vector(rmul_vector, lambda x: (x == 0))
Ejemplo n.º 41
0
    def merge_cols(self, mat):
        '''
        Return the matrix whose rows are rows of this merged with the corresponding rows of mat (columnwise merge)
        '''

        if (len(self) != len(mat)):
            return None

        merged_list = []
        for i in range(0, len(self)):
            vec = make_vector(self[i], lambda x: (x == 0))
            vec.merge(mat[i])
            merged_list.append(vec)

        return make_matrix(merged_list)
Ejemplo n.º 42
0
    def left_right_split(self):
        '''
        Split the matrix into two halves - left and right - and return the two matrices
        Split each row (use the split method of Vector) and put them together into the
        left and right matrices
        Use the make_matrix method for forming the new matrices
        '''

        left_matrix = []
        right_matrix = []

        for i in range(0, len(self)):
            vec = make_vector(self[i], lambda x: (x == 0))
            left_vector, right_vector = vec.split()
            left_matrix.append(left_vector)
            right_matrix.append(right_vector)

        return make_matrix(left_matrix), make_matrix(right_matrix)
Ejemplo n.º 43
0
        for i in range(mid, len(left_matrix)):
            bottomleft.append(make_vector((left_matrix[i]), lambda x:
                                          (x == 0)))

        mid = len(right_matrix) / 2
        for i in range(0, mid):
            topright.append(make_vector((right_matrix[i]), lambda x: (x == 0)))
        for i in range(mid, len(left_matrix)):
            bottomright.append(
                make_vector((right_matrix[i]), lambda x: (x == 0)))

        return make_matrix(topleft), make_matrix(topright), make_matrix(
            bottomleft), make_matrix(bottomright)


v1 = make_vector([1, 2, 1, 1, 3, 4, 1, 1], lambda x: (x == 0))
v2 = make_vector([1, 1, 1, 1, 1, 1], lambda x: (x == 0))
v3 = make_vector([1, 2, 3, 4, 5], lambda x: (x == 0))
v4 = make_vector([1, 0, 0, 0, 0, 0, 2, 0, 3, 4, 5, 6], lambda x: (x == 0))
v5 = make_vector([0, 0, 1, 0, 1, 0, 0, 0, 3, 6, 5, 1], lambda x: (x == 0))
v6 = make_vector([0, 0, 1, 0, 0, 0, 1, 0, 3, 4, 1, 6], lambda x: (x == 0))
v7 = make_vector([1, 0, 2, 0], lambda x: (x == 0))
v8 = make_vector([0, 0, 0, 0], lambda x: (x == 0))

m1 = make_matrix([v7, v8, v8, v8, v8, v8, v8, v8])
m2 = make_matrix([v8, v8, v8, v8])
print("m1")
for i in range(0, len(m1)):
    for j in range(0, len(m1[i])):
        print(m1[i][j], )
    print()
Ejemplo n.º 44
0
    def __mul__(self, mat):
        '''
        Multiplication of two matrices using Strassen's algorithm
        If either this matrix or mat is a 'small' matrix then do regular multiplication
        Else use recursive Strassen's algorithm
        '''

        if (len(self[0]) != len(mat)):
            print("INCOMPATIBLE MULTIPLICATION")
            return
        else:
            if (self.is_small() == True or mat.is_small() == True):
                lst_mul = []

                for i in range(0, len(self)):
                    vec = make_vector(self[i], lambda x: (x == 0))
                    vec_mul = mat.rmul(vec)
                    lst_mul.append(vec_mul)

                return make_matrix(lst_mul)

            global flag
            if (flag == 0):
                global rows, columns
                flag = 1
                self = padding(self)
                mat = padding(mat)
                if (len(self) != len(mat)):
                    minimum = min(len(self), len(mat))

                    if (minimum == len(self)):
                        matrix = self
                    else:
                        matrix = mat

                    lst_vec = []
                    pad = abs(len(self) - len(mat))

                    for i in range(0, len(matrix)):
                        pad_row = matrix[i] + [0] * pad
                        vec = make_vector(pad_row, lambda x: (x == 0))
                        lst_vec.append(vec)

                    for i in range(0, pad):
                        pad_row = [0] * len(mat)
                        vec = make_vector(pad_row, lambda x: (x == 0))
                        lst_vec.append(vec)

                    matrix = make_matrix(lst_vec)

                    if (minimum == len(self)):
                        self = matrix
                    else:
                        mat = matrix

                rows = len(self)
                columns = len(self[0])

            A, B, C, D = self.get_quarters()
            E, F, G, H = mat.get_quarters()

            P1 = (A + D) * (E + H)
            P2 = (C + D) * E
            P3 = A * (F - H)
            P4 = D * (G - E)
            P5 = (A + B) * H
            P6 = (C - A) * (E + F)
            P7 = (B - D) * (G + H)

            top_left = P1 + P4 - P5 + P7
            top_right = P3 + P5
            bottom_left = P2 + P4
            bottom_right = P1 - P2 + P3 + P6

            x = top_left.merge_cols(top_right)
            y = bottom_left.merge_cols(bottom_right)

            final_mat = x.merge_rows(y)

            if (len(final_mat) == rows and len(final_mat[0]) == columns):
                final_mat = unpadding(final_mat)

            return final_mat