class Matrix:
    def __init__(self, m):
        self.matrix = [[0 for i in range(len(m[0]))] for j in range(len(m))]
        for i, row in enumerate(m):
            for j, col in enumerate(row):
                self.matrix[i][j] = m[i][j]

        self.I = []
        self.R = []
        self.Q = []

    def __str__(self):
        textArr = ""
        for row in self.matrix:
            for col in row:
                if type(col) == int:
                    textArr += " " + str(col) + "  "
                else:
                    textArr += str(col) + " "
            textArr += "\n"
        return textArr

    def __len__(self):
        return len(self.matrix)

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

    def __radd__(self, other):
        return self.__add__(other)

    def __rsub__(self, other):
        return self.__sub__(other)
    
    def __rmul__(self, other):
        return self.__mul__(other)

    def __add__(self, other):
        result = [[0 for i in range(len(other.matrix[0]))] for j in range(len(other.matrix[0]))]
        if isinstance(other, self.__class__):
            for i in range(len(self.matrix)):
                for j in range(len(other.matrix[0])):
                    result[i][j] = other.matrix[i][j] + other.matrix[i][j]
        elif isinstance(other, int):
            return "TODO: Matrix Add Function w/ Int"
        return result

    def __sub__(self, other):
        if isinstance(other, self.__class__):
            if len(self.matrix) < len(other.matrix):
                short = self
            else:
                short = other
            result = [[0 for i in range(len(short.matrix[0]))] for j in range(len(short.matrix[0]))]
            for i in range(len(short.matrix)):
                for j in range(len(short.matrix[0])):
                    result[i][j] = self.matrix[i][j] - other.matrix[i][j]
        elif isinstance(other, int):
            return "TODO: Matrix Sub Function w/ Int"
        return result

    def __mul__(self, other):
        A = self
        B = other
        result = [[sum(a * b for a, b in zip(A_row, B_col))  
                        for B_col in zip(*B)] 
                                for A_row in A]
        return result
    
    def getI(self):
        return self.I
    
    def getR(self):
        return self.R

    def getQ(self):
        return self.Q

    def makeRegAndSTD(self):
        m = self.matrix
        shift = 0
        # Point Terminal states to themselves and move to top of 2d array
        for i, row in enumerate(m):
            void = True
            for col in row:
                if col != 0:
                    void = False
            if void == True:
                row[i] = 1
                m.insert(shift, row)
                m.pop(i+1)
                shift += 1

        # Shift all elements relative to the nmber of terminal states found
        for i, row in enumerate(m):
            m[i] = m[i][-shift:] + m[i][:-shift]

        # Extract sections of the matrix for use in calculating F
        top = m[:shift]
        bottom = m[shift:]
        I = [[0 for i in range(len(m))] for j in range(shift)]
        R = [[0 for i in range(len(m))] for j in range(len(m)-shift)]
        Q = [[0 for i in range(len(m))] for j in range(len(m)-shift)]

        for i, col in enumerate(top):
            I[i] = col[:shift]

        for i, col in enumerate(bottom):
            R[i] = col[:shift]
            Q[i] = col[shift:]

        self.I = Matrix(I)
        self.R = Matrix(R)
        self.Q = Matrix(Q)


def transposeMatrix(m):
    return map(list,zip(*m))

def getMatrixMinor(m,i,j):
    return [row[:j] + row[j+1:] for row in (m[:i]+m[i+1:])]

def getMatrixDeternminant(m):
    #base case for 2x2 matrix
    if len(m) == 2:
        return m[0][0]*m[1][1]-m[0][1]*m[1][0]

    determinant = 0
    for c in range(len(m)):
        determinant += ((-1)**c)*m[0][c]*getMatrixDeternminant(getMatrixMinor(m,0,c))
    return determinant

def getMatrixInverse(m):
    determinant = getMatrixDeternminant(m)
    #special case for 2x2 matrix:
    if len(m) == 2:
        return [[m[1][1]/determinant, -1*m[0][1]/determinant],
                [-1*m[1][0]/determinant, m[0][0]/determinant]]

    #find matrix of cofactors
    cofactors = []
    for r in range(len(m)):
        cofactorRow = []
        for c in range(len(m)):
            minor = getMatrixMinor(m,r,c)
            cofactorRow.append(((-1)**(r+c)) * getMatrixDeternminant(minor))
        cofactors.append(cofactorRow)
    cofactors = transposeMatrix(cofactors)
    for r in range(len(cofactors)):
        for c in range(len(cofactors)):
            cofactors[r][c] = cofactors[r][c]/determinant
    return cofactors

def print2D(array):
    for arr in array:
        print arr
    return ""

# ---------------------------------------------------------

m1 = Matrix([
    [1,0],
    [0,1]])
m2 = Matrix([
    [.8, .1],
    [.4, .4]])
m3 = Matrix([
    [12, 7, 3], 
    [4, 5, 6], 
    [7, 8, 9]])
m4 = Matrix([
    [5, 8, 1, 2], 
    [6, 7, 3, 0], 
    [4, 5, 9, 1]
   ,[2, 3, 7,3]])
m5 = Matrix([
    [0, 1, 0, 0, 0, 1], 
    [4, 0, 0, 3, 2, 0], 
    [0, 0, 0, 0, 0, 0], 
    [0, 0, 0, 0, 0, 0], 
    [0, 0, 0, 0, 0, 0], 
    [0, 0, 0, 0, 0, 0]])
m6 = Matrix([
    [.1,0,.8,.1],
    [.1,.1,.4,.4],
    [0,0,0,0],
    [0,0,0,0],])

# ----------------------------------------------------------

print "Subtract"
print2D(m3 - m4)
print ""
print2D(m4 - m3)

# print "Subtract Whole Number"
# print2D(1 - m3)