matriz | Python Fiddle

#!/usr/bin/python
# -*- coding: utf-8 -*-
import argparse
import math
import ast

class Matrix():

def __init__(self,matrix,pow):
        self.matrix=matrix
        self.pow=pow
        self.cont=0
            
    def multiply(self,matriz1,matriz2):
        self.cont+=1
        res=[[0 for x in range(2)] for x in range(2)]
        for i, row in enumerate(res):
            for j in range(0,len(row)):
                for k in range(0,len(row)):
                    res[i][j]+=matriz1[i][k]*matriz2[k][j]
        return res
    
class MatrixPowLinear(Matrix):
    def __init__(self,matrix,pow):
        Matrix.__init__(self, matrix, pow)
        
    def getPow(self,pow):
        ret=[[1,0],[0,1]]
        for i in range(0,pow):
            ret=self.multiply(ret,self.matrix)
        return ret      
    
class MatrixPowLog2(Matrix):
    
    def __init__(self,matrix,pow):
        Matrix.__init__(self, matrix, pow)
        self.powerlist=self.popPowerlist()
    
    def popPowerlist(self):
        ret=[]
        value=self.matrix
        ret.append(self.matrix)
        for i in range(1,int(math.log(self.pow,2)+1)):
            value=self.multiply(value,value)
            ret.append(value)
        return ret

def getPow(self,matrix,pow):
        ret=[[1,0],[0,1]]
        resto=pow
        while resto>0:
            ind=int(math.log(resto,2))
            ret=self.multiply(ret,self.powerlist[ind])
            resto=resto-2**ind
        return ret
            
        
class MatrixPowLog(Matrix):
    
    def __init__(self,matrix,pow):
        Matrix.__init__(self, matrix, pow)
        self.powerhash={}

def getPow(self,matrix,pow):
        if pow in self.powerhash.keys():
            return self.powerhash[pow]
        if pow==1:
            return matrix
        if pow==2:
            self.powerhash[pow]=self.multiply(matrix, matrix)
            return self.powerhash[pow]
        if pow%2==0:
            self.powerhash[pow]=self.multiply(self.getPow(matrix,pow/2),self.getPow(matrix,pow/2))
        else:
            self.powerhash[pow/2+1]=self.multiply(self.getPow(matrix,pow/2),matrix)
            self.powerhash[pow]=self.multiply(self.getPow(matrix,pow/2),self.powerhash[pow/2+1])
        return self.powerhash[pow]

def printmatrix(list):
    ret="\n"
    for i, row in enumerate(list):
        ret+= "[ "
        for col in row:
            ret+=str(col) + "  "
        ret+="] \n"
    return ret

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("potencia",nargs="?",type=int,default=520)
    parser.add_argument("matriz",nargs="?",default="[[5,3],[7,1]]")
    args=parser.parse_args()    
    matriz1= ast.literal_eval(args.matriz)
    
    print "Calculando matrix %s elevado a %d" % (printmatrix(matriz1),args.potencia)
    print
    
    resLog=MatrixPowLog(matriz1,args.potencia)
    print "Resultado multiplicação matriz recursao metade: %s " % printmatrix(resLog.getPow(matriz1, args.potencia))
    print "Quantidade de chamadas de recursão: %d " % resLog.cont
    print
    
    resLog2=MatrixPowLog2(matriz1,args.potencia)
    print "Resultado multiplicação matriz iterativo somatorio potencia de dois %s " %  printmatrix(resLog2.getPow(matriz1, args.potencia))
    print "Quantidade que calculos iterativos somatorio potencia de dois: %d" % resLog2.cont    
    print
    
    resLin=MatrixPowLinear(matriz1,args.potencia)
    print "Resultado multiplicação matriz iterativo linear: %s " % printmatrix(resLin.getPow(args.potencia))
    print "Quantidade de calculos multiplicação linear: %d" % resLin.cont
    
    
            
if __name__ == '__main__':
    main()

Python Fiddle

Python Cloud IDE